forked from github/esp8266-geigercounter
333 lines
7.6 KiB
C++
333 lines
7.6 KiB
C++
#include <ESP8266WiFi.h>
|
|
#include <ArduinoOTA.h>
|
|
#include <SoftwareSerial.h>
|
|
#include <DNSServer.h>
|
|
#include <ESP8266WebServer.h>
|
|
|
|
#include "dep/pubsubclient-2.7/src/PubSubClient.cpp"
|
|
#include "dep/WiFiManager-0.15.0/WiFiManager.cpp"
|
|
#include "dep/SimpleTimer-schinken/SimpleTimer.cpp"
|
|
|
|
|
|
#include "settings.h"
|
|
|
|
#ifdef USE_HA_AUTODISCOVERY
|
|
#define FIRMWARE_PREFIX "esp8266-geigercounter"
|
|
char MQTT_TOPIC_LAST_WILL[128];
|
|
char MQTT_TOPIC_CPM_MEASUREMENT[128];
|
|
char MQTT_TOPIC_USV_MEASUREMENT[128];
|
|
#endif
|
|
|
|
WiFiClient wifiClient;
|
|
PubSubClient mqttClient;
|
|
SoftwareSerial geigerCounterSerial(PIN_UART_RX, PIN_UART_TX);
|
|
SimpleTimer timer;
|
|
|
|
uint8_t mqttRetryCounter = 0;
|
|
String serialInput = "";
|
|
char serialInputHelper[RECV_LINE_SIZE];
|
|
|
|
int lastCPM = 0, currentCPM = 0;
|
|
float lastuSv = 0, currentuSv = 0;
|
|
|
|
char hostname[24];
|
|
|
|
void setup() {
|
|
delay(3000);
|
|
Serial.begin(115200);
|
|
delay(2000);
|
|
Serial.println("\n");
|
|
Serial.println("Hello from esp8266-geigercounter");
|
|
Serial.printf("Core Version: %s\n", ESP.getCoreVersion().c_str());
|
|
Serial.printf("Boot Version: %u\n", ESP.getBootVersion());
|
|
Serial.printf("Boot Mode: %u\n", ESP.getBootMode());
|
|
Serial.printf("CPU Frequency: %u MHz\n", ESP.getCpuFreqMHz());
|
|
Serial.printf("Reset reason: %s\n", ESP.getResetReason().c_str());
|
|
delay(3000);
|
|
|
|
geigerCounterSerial.begin(BAUD_GEIGERCOUNTER);
|
|
|
|
|
|
int32_t chipid = ESP.getChipId();
|
|
|
|
Serial.print("MQTT_MAX_PACKET_SIZE: ");
|
|
Serial.println(MQTT_MAX_PACKET_SIZE);
|
|
|
|
|
|
#ifdef HOSTNAME
|
|
strncpy(hostname, HOSTNAME, sizeof(hostname));
|
|
#else
|
|
snprintf(hostname, sizeof(hostname), "GEIGERCTR-%X", chipid);
|
|
#endif
|
|
|
|
#ifdef USE_HA_AUTODISCOVERY
|
|
snprintf(MQTT_TOPIC_LAST_WILL, 127, "%s/%s/presence", FIRMWARE_PREFIX, hostname);
|
|
snprintf(MQTT_TOPIC_CPM_MEASUREMENT, 127, "%s/%s/%s_%s/state", FIRMWARE_PREFIX, hostname, hostname, "cpm");
|
|
snprintf(MQTT_TOPIC_USV_MEASUREMENT, 127, "%s/%s/%s_%s/state", FIRMWARE_PREFIX, hostname, hostname, "uSv");
|
|
#endif
|
|
|
|
Serial.print("Connecting to WiFi");
|
|
|
|
WiFi.mode(WIFI_STA);
|
|
unsigned long wifiConnectStart = millis();
|
|
while (WiFi.status() != WL_CONNECTED) {
|
|
if (WiFi.status() == WL_CONNECT_FAILED) {
|
|
return;
|
|
}
|
|
if (millis() - wifiConnectStart > 10000) {
|
|
WiFiManager wifiManager;
|
|
#ifdef CONF_WIFI_PASSWORD
|
|
wifiManager.autoConnect(hostname, CONF_WIFI_PASSWORD);
|
|
#else
|
|
wifiManager.autoConnect(hostname);
|
|
#endif
|
|
}
|
|
delay(100);
|
|
Serial.print(".");
|
|
}
|
|
|
|
Serial.print("\nIP: ");
|
|
Serial.println(WiFi.localIP());
|
|
|
|
WiFi.hostname(hostname);
|
|
mqttClient.setClient(wifiClient);
|
|
mqttClient.setServer(MQTT_HOST, 1883);
|
|
|
|
ArduinoOTA.setHostname(hostname);
|
|
ArduinoOTA.setPassword(OTA_PASSWORD);
|
|
ArduinoOTA.begin();
|
|
|
|
Serial.print("Hostname: ");
|
|
Serial.println(hostname);
|
|
|
|
Serial.println("-- Current GPIO Configuration --");
|
|
Serial.print("PIN_UART_RX: ");
|
|
Serial.println(PIN_UART_RX);
|
|
|
|
mqttConnect();
|
|
timer.setInterval(UPDATE_INTERVAL_SECONDS * 1000L, updateRadiationValues);
|
|
}
|
|
|
|
void mqttConnect() {
|
|
while (!mqttClient.connected()) {
|
|
|
|
bool mqttConnected = false;
|
|
if (MQTT_USERNAME && MQTT_PASSWORD) {
|
|
mqttConnected = mqttClient.connect(hostname, MQTT_USERNAME, MQTT_PASSWORD, MQTT_TOPIC_LAST_WILL, 1, true, MQTT_LAST_WILL_PAYLOAD_DISCONNECTED);
|
|
} else {
|
|
mqttConnected = mqttClient.connect(hostname, MQTT_TOPIC_LAST_WILL, 1, true, MQTT_LAST_WILL_PAYLOAD_DISCONNECTED);
|
|
}
|
|
|
|
if (mqttConnected) {
|
|
Serial.println("Connected to MQTT Broker");
|
|
mqttClient.publish(MQTT_TOPIC_LAST_WILL, MQTT_LAST_WILL_PAYLOAD_CONNECTED, true);
|
|
mqttRetryCounter = 0;
|
|
|
|
#ifdef USE_HA_AUTODISCOVERY
|
|
setupHAAutodiscovery();
|
|
#endif
|
|
|
|
} else {
|
|
Serial.println("Failed to connect to MQTT Broker");
|
|
|
|
if (mqttRetryCounter++ > MQTT_MAX_CONNECT_RETRY) {
|
|
Serial.println("Restarting uC");
|
|
ESP.restart();
|
|
}
|
|
|
|
delay(2000);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef USE_HA_AUTODISCOVERY
|
|
#define AUTOCONFIG_PAYLOAD_TPL_USV "{\
|
|
\"stat_t\":\"%s/%s/%s_uSv/state\",\
|
|
\"avty_t\":\"%s/%s/presence\",\
|
|
\"unique_id\":\"%s_uSv\",\
|
|
\"name\":\"%s uSv\",\
|
|
\"unit_of_meas\":\"µSv/h\",\
|
|
\"dev\": {\
|
|
\"identifiers\":\"%s\",\
|
|
\"name\":\"%s\",\
|
|
\"manufacturer\":\"MightyOhm LLC\",\
|
|
\"model\":\"Geiger Counter\"\
|
|
}\
|
|
}"
|
|
#define AUTOCONFIG_PAYLOAD_TPL_CPM "{\
|
|
\"stat_t\":\"%s/%s/%s_cpm/state\",\
|
|
\"avty_t\":\"%s/%s/presence\",\
|
|
\"unique_id\":\"%s_cpm\",\
|
|
\"name\":\"%s CPM\",\
|
|
\"unit_of_meas\":\"CPM\",\
|
|
\"dev\": {\
|
|
\"identifiers\":\"%s\",\
|
|
\"name\":\"%s\",\
|
|
\"manufacturer\":\"MightyOhm LLC\",\
|
|
\"model\":\"Geiger Counter\"\
|
|
}\
|
|
}"
|
|
|
|
void setupHAAutodiscovery() {
|
|
char autoconfig_topic_cpm[128];
|
|
char autoconfig_payload_cpm[1024];
|
|
char autoconfig_topic_usv[128];
|
|
char autoconfig_payload_usv[1024];
|
|
|
|
snprintf(
|
|
autoconfig_topic_cpm,
|
|
127,
|
|
"%s/sensor/%s/%s_cpm/config",
|
|
HA_DISCOVERY_PREFIX,
|
|
hostname,
|
|
hostname
|
|
);
|
|
|
|
snprintf(
|
|
autoconfig_topic_usv,
|
|
127,
|
|
"%s/sensor/%s/%s_usv/config",
|
|
HA_DISCOVERY_PREFIX,
|
|
hostname,
|
|
hostname
|
|
);
|
|
|
|
snprintf(
|
|
autoconfig_payload_cpm,
|
|
1023,
|
|
|
|
AUTOCONFIG_PAYLOAD_TPL_CPM,
|
|
|
|
FIRMWARE_PREFIX,
|
|
hostname,
|
|
hostname,
|
|
FIRMWARE_PREFIX,
|
|
hostname,
|
|
hostname,
|
|
hostname,
|
|
hostname,
|
|
hostname
|
|
);
|
|
|
|
snprintf(
|
|
autoconfig_payload_usv,
|
|
1023,
|
|
|
|
AUTOCONFIG_PAYLOAD_TPL_USV,
|
|
|
|
FIRMWARE_PREFIX,
|
|
hostname,
|
|
hostname,
|
|
FIRMWARE_PREFIX,
|
|
hostname,
|
|
hostname,
|
|
hostname,
|
|
hostname,
|
|
hostname
|
|
);
|
|
|
|
if(
|
|
mqttClient.publish(autoconfig_topic_cpm, autoconfig_payload_cpm, true) &&
|
|
mqttClient.publish(autoconfig_topic_usv, autoconfig_payload_usv, true)
|
|
){
|
|
Serial.println("Autoconf publish successful");
|
|
} else {
|
|
Serial.println("Autoconf publish failed. Is MQTT_MAX_PACKET_SIZE large enough?");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void loop() {
|
|
timer.run();
|
|
mqttConnect();
|
|
mqttClient.loop();
|
|
ESP.wdtFeed();
|
|
|
|
if (geigerCounterSerial.available()) {
|
|
char in = (char) geigerCounterSerial.read();
|
|
|
|
serialInput += in;
|
|
|
|
if (in == '\n') {
|
|
serialInput.toCharArray(serialInputHelper, RECV_LINE_SIZE);
|
|
parseReceivedLine(serialInputHelper);
|
|
|
|
serialInput = "";
|
|
}
|
|
|
|
// Just in case the buffer gets to big, start from scratch
|
|
if (serialInput.length() > RECV_LINE_SIZE + 10) {
|
|
serialInput = "";
|
|
}
|
|
|
|
Serial.write(in);
|
|
}
|
|
|
|
ArduinoOTA.handle();
|
|
}
|
|
|
|
void updateRadiationValues() {
|
|
char tmp[8];
|
|
|
|
if (currentCPM != lastCPM) {
|
|
String(currentCPM).toCharArray(tmp, 8);
|
|
Serial.print("Sending CPM: ");
|
|
Serial.println(tmp);
|
|
mqttClient.publish(MQTT_TOPIC_CPM_MEASUREMENT, tmp, true);
|
|
}
|
|
|
|
if (currentuSv != lastuSv) {
|
|
String(currentuSv).toCharArray(tmp, 8);
|
|
Serial.print("Sending uSv: ");
|
|
Serial.println(tmp);
|
|
mqttClient.publish(MQTT_TOPIC_USV_MEASUREMENT, tmp, true);
|
|
}
|
|
|
|
lastCPM = currentCPM;
|
|
lastuSv = currentuSv;
|
|
}
|
|
|
|
void parseReceivedLine(char* input) {
|
|
|
|
char segment = 0;
|
|
char *token;
|
|
|
|
float uSv = 0;
|
|
float cpm = 0;
|
|
|
|
token = strtok(input, delimiter);
|
|
|
|
while (token != NULL) {
|
|
|
|
switch (segment) {
|
|
|
|
// This is just for validation
|
|
case IDX_CPS_KEY: if (strcmp(token, "CPS") != 0) return; break;
|
|
case IDX_CPM_KEY: if (strcmp(token, "CPM") != 0) return; break;
|
|
case IDX_uSv_KEY: if (strcmp(token, "uSv/hr") != 0) return; break;
|
|
|
|
case IDX_CPM:
|
|
Serial.printf("\nCurrent CPM: %s\n", token);
|
|
cpm = String(token).toInt();
|
|
break;
|
|
|
|
case IDX_uSv:
|
|
Serial.printf("Current uSv/hr: %s\n", token);
|
|
uSv = String(token).toFloat();
|
|
break;
|
|
}
|
|
|
|
if (segment > 7) {
|
|
// Invalid! There should be no more than 7 segments
|
|
return;
|
|
}
|
|
|
|
token = strtok(NULL, delimiter);
|
|
segment++;
|
|
}
|
|
|
|
currentuSv = uSv;
|
|
currentCPM = cpm;
|
|
}
|