coolneng/homeostasis
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use a robust asynchronous MQTT client

Browse Source
This commit is contained in:
coolneng
2026-03-11 20:49:38 +01:00
parent 1dcd9c8f0a
commit 2620d05f49
8 changed files with 147 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
include/config.h
View File

@@ -1,8 +1,6 @@
#ifndef CONFIG_H_ #ifndef CONFIG_H_
#define CONFIG_H_ #define CONFIG_H_
#include "FS.h"
#include "LittleFS.h"
#include <ArduinoJson.h> #include <ArduinoJson.h>
typedef struct { typedef struct {
@@ -14,14 +12,13 @@ typedef struct {
const char *topic; const char *topic;
const char *device_id; const char *device_id;
int mqtt_port; int mqtt_port;
long sleep_time; unsigned long sleep_time;
int connection_attempts;
} Config; } Config;
void initialize_config(Config *config, StaticJsonDocument<512> json); void initialize_config(Config *config, JsonDocument json);
bool load_config_file(const char *file_path, Config *config); bool load_config_file(const char *file_path, Config *config);
long minutes_to_microseconds(int minutes); long minutes_to_milliseconds(int minutes);
#endif // CONFIG_H_ #endif // CONFIG_H_

10
include/sensor.h Normal file
View File

@@ -0,0 +1,10 @@
#ifndef SENSOR_H_
#define SENSOR_H_
#include <DHT.h>
void initialize_sensor(DHT &sensor);
void read_values(DHT &sensor, float *data);
#endif // SENSOR_H_

29
include/wlan.h
View File

@@ -2,15 +2,28 @@
#define WLAN_H #define WLAN_H
#include "config.h" #include "config.h"
#include <ESP8266WiFi.h> #include <AsyncMqttClient.h>
#include <PubSubClient.h> #include <Ticker.h>
#include <WiFi.h>
static AsyncMqttClient mqtt_client;
static Ticker mqtt_connection_timer, wlan_connection_timer;
extern Config *config;
void initialize_wlan();
void initialize_mqtt();
void connect_wlan();
void connect_mqtt();
void wlan_connection_handler(WiFiEvent_t event);
void on_mqtt_disconnection(AsyncMqttClientDisconnectReason reason);
void initial_connection(const char *ssid, const char *psk);
void connect_wlan(Config *config);
void connect_mqtt(PubSubClient &client, Config *config);
void disconnect_mqtt(PubSubClient &client, const char *topic);
size_t construct_json(float *data, char *buffer, int buffer_size); size_t construct_json(float *data, char *buffer, int buffer_size);
void mqtt_transfer(PubSubClient &client, Config *config, float *data);
void enter_deep_sleep(bool wifi_timeout, int sleep_time); void mqtt_transfer(float *data);
#endif /* WLAN_H */ #endif /* WLAN_H */

9
platformio.ini
View File

@@ -9,12 +9,13 @@
; https://docs.platformio.org/page/projectconf.html ; https://docs.platformio.org/page/projectconf.html
[env:d1_mini] [env:d1_mini]
platform = espressif8266 platform = espressif32
board = d1_mini board = wemos_d1_mini32
board_build.filesystem = littlefs board_build.filesystem = littlefs
framework = arduino framework = arduino
monitor_filters = esp32_exception_decoder
lib_deps = lib_deps =
adafruit/DHT sensor library@^1.4.4 adafruit/DHT sensor library@^1.4.4
adafruit/Adafruit Unified Sensor@^1.1.9 adafruit/Adafruit Unified Sensor@^1.1.9
knolleary/PubSubClient@^2.8 marvinroger/AsyncMqttClient@^0.9.0
bblanchon/ArduinoJson@^6.21.1 bblanchon/ArduinoJson@^7.4.1

10
src/config.cpp
View File

@@ -1,6 +1,7 @@
#include "config.h" #include "config.h"
#include "LittleFS.h"
void initialize_config(Config *config, StaticJsonDocument<512> json) { void initialize_config(Config *config, JsonDocument json) {
config->ssid = strdup(json["ssid"]); config->ssid = strdup(json["ssid"]);
config->psk = strdup(json["psk"]); config->psk = strdup(json["psk"]);
config->mqtt_host = strdup(json["mqtt_host"]); config->mqtt_host = strdup(json["mqtt_host"]);
@@ -9,8 +10,7 @@ void initialize_config(Config *config, StaticJsonDocument<512> json) {
config->topic = strdup(json["mqtt_topic"]); config->topic = strdup(json["mqtt_topic"]);
config->device_id = strdup(json["device_id"]); config->device_id = strdup(json["device_id"]);
config->mqtt_port = json["mqtt_port"]; config->mqtt_port = json["mqtt_port"];
config->sleep_time = minutes_to_microseconds(json["sleep_time"]); config->sleep_time = minutes_to_milliseconds(json["sleep_time"]);
config->connection_attempts = json["connection_attempts"];
} }
bool load_config_file(const char *file_path, Config *config) { bool load_config_file(const char *file_path, Config *config) {
@@ -19,7 +19,7 @@ bool load_config_file(const char *file_path, Config *config) {
File config_file = LittleFS.open(file_path, "r"); File config_file = LittleFS.open(file_path, "r");
if (!config_file) if (!config_file)
return false; return false;
StaticJsonDocument<512> json; JsonDocument json;
DeserializationError err = deserializeJson(json, config_file); DeserializationError err = deserializeJson(json, config_file);
if (err) if (err)
return false; return false;
@@ -27,4 +27,4 @@ bool load_config_file(const char *file_path, Config *config) {
return true; return true;
} }
long minutes_to_microseconds(int minutes) { return (minutes * 6e7); } long minutes_to_milliseconds(int minutes) { return (minutes * 6e4); }

37
src/main.cpp
View File

@@ -1,41 +1,36 @@
#include "config.h" #include "config.h"
#include "sensor.h"
#include "wlan.h" #include "wlan.h"
#include <Arduino.h> #include <Arduino.h>
#include <DHT.h> #include <DHT.h>
#define DHTTYPE DHT22 DHT dht(4, DHT22);
#define DHTPIN 4
DHT dht(DHTPIN, DHTTYPE);
const int fc28_pin = A0;
const char *config_file_path = "/config.json"; const char *config_file_path = "/config.json";
Config *config; Config *config;
WiFiClient wifi_client;
PubSubClient mqtt_client(wifi_client);
bool check_valid_value(float value) { float data[2];
return (!isnan(value) && value >= 0 && value <= 100); unsigned long previous_millis = 0;
}
void setup() { void setup() {
Serial.begin(9600); Serial.begin(9600);
dht.begin();
config = (Config *)malloc(sizeof(Config)); config = (Config *)malloc(sizeof(Config));
if (!load_config_file(config_file_path, config)) if (!load_config_file(config_file_path, config))
Serial.println("ERROR: The config file could not be loaded"); Serial.println("ERROR: The config file could not be loaded");
connect_wlan(config);
initialize_wlan();
initialize_mqtt();
connect_wlan();
initialize_sensor(dht);
} }
void loop() { void loop() {
float temperature = dht.readTemperature(); unsigned long current_millis = millis();
float humidity = dht.readHumidity();
int analog_val = analogRead(fc28_pin); if (current_millis - previous_millis >= config->sleep_time) {
int soil_percentage = map(analog_val, 0, 1023, 0, 100); previous_millis = current_millis;
float data[3] = {temperature, humidity, static_cast<float>(soil_percentage)}; read_values(dht, data);
if (check_valid_value(temperature) && check_valid_value(humidity)) { mqtt_transfer(data);
mqtt_transfer(mqtt_client, config, data);
} }
disconnect_mqtt(mqtt_client, config->topic);
free(config);
enter_deep_sleep(false, config->sleep_time);
} }

13
src/sensor.cpp Normal file
View File

@@ -0,0 +1,13 @@
#include "sensor.h"
void initialize_sensor(DHT &sensor) { sensor.begin(); }
void read_values(DHT &sensor, float *data) {
float temperature = sensor.readTemperature();
float humidity = sensor.readHumidity();
Serial.println("Data fetched from the sensor");
data[0] = temperature;
data[1] = humidity;
}

76
src/wlan.cpp
View File

@@ -1,63 +1,57 @@
#include "wlan.h" #include "wlan.h"
#include <ArduinoJson.h>
void initial_connection(const char *ssid, const char *psk) { void initialize_wlan() { WiFi.onEvent(wlan_connection_handler); }
WiFi.begin(ssid, psk);
WiFi.persistent(true); void initialize_mqtt() {
WiFi.setAutoConnect(true); mqtt_client.onDisconnect(on_mqtt_disconnection);
WiFi.setAutoReconnect(true); mqtt_client.setServer(config->mqtt_host, config->mqtt_port);
mqtt_client.setCredentials(config->mqtt_user, config->mqtt_password);
Serial.println("MQTT initialization complete");
} }
void connect_wlan(Config *config) { void connect_wlan() { WiFi.begin(config->ssid, config->psk); }
if (WiFi.SSID() != config->ssid)
initial_connection(config->ssid, config->psk); void connect_mqtt() {
int retries = 0; Serial.println("Connecting to MQTT");
while (WiFi.status() != WL_CONNECTED) { mqtt_client.connect();
if (retries == config->connection_attempts)
enter_deep_sleep(true, config->sleep_time);
retries++;
delay(1000);
Serial.print(".");
} }
void wlan_connection_handler(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d\n", event);
switch (event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected"); Serial.println("WiFi connected");
} connect_mqtt();
break;
void connect_mqtt(PubSubClient &client, Config *config) { case SYSTEM_EVENT_STA_DISCONNECTED:
if (!client.connected()) Serial.println("WiFi disconnected");
client.setServer(config->mqtt_host, config->mqtt_port); mqtt_connection_timer.detach();
if (client.connect(config->device_id, config->mqtt_user, wlan_connection_timer.once(2, connect_wlan);
config->mqtt_password)) { break;
Serial.println("MQTT connected");
client.subscribe(config->topic);
} }
} }
void disconnect_mqtt(PubSubClient &client, const char *topic) { void on_mqtt_disconnection(AsyncMqttClientDisconnectReason reason) {
Serial.println("Disconnecting MQTT"); Serial.println("MQTT disconnected");
client.unsubscribe(topic);
client.disconnect(); if (WiFi.isConnected()) {
mqtt_connection_timer.once(2, connect_mqtt);
}
} }
size_t construct_json(float *data, char *buffer, int buffer_size) { size_t construct_json(float *data, char *buffer, int buffer_size) {
StaticJsonDocument<100> json; JsonDocument json;
json["temperature"] = data[0]; json["temperature"] = data[0];
json["humidity"] = data[1]; json["humidity"] = data[1];
json["soil_humidity"] = data[2];
size_t payload_size = serializeJson(json, buffer, buffer_size); size_t payload_size = serializeJson(json, buffer, buffer_size);
return payload_size; return payload_size;
} }
void mqtt_transfer(PubSubClient &client, Config *config, float *data) { void mqtt_transfer(float *data) {
char buffer[100]; char buffer[100];
connect_mqtt(client, config);
size_t payload_size = construct_json(data, buffer, 100); size_t payload_size = construct_json(data, buffer, 100);
client.publish(config->topic, buffer, payload_size); uint16_t response =
mqtt_client.publish(config->topic, 2, true, buffer, payload_size);
if (response)
Serial.println("Data transferred successfully"); Serial.println("Data transferred successfully");
} }
void enter_deep_sleep(bool wifi_timeout, int sleep_time) {
Serial.println("Entering deep sleep");
if (wifi_timeout)
WiFi.disconnect();
ESP.deepSleep(sleep_time, WAKE_RF_DEFAULT);
}