esp_garden git · master
Distributed ESP sensor and actuator system (garden)
C++ 70.7% Markdown 18% C 10.7%git clone https://git.christianimmanuel.de/embedded/esp_garden.gitwget https://git.christianimmanuel.de/embedded/esp_garden/archive/esp_garden.tar.gzCleanup logging
client_pump/main/ClientPump.cpp | 33 ++--- client_pump/main/main.cpp | 11 +- client_sensor/main/ClientSensor.cpp | 237 +++++++++++++++++++----------------- client_sensor/main/main.cpp | 23 ++-- post_server/main/WiFiManager.cpp | 135 ++++++++++---------- post_server/main/main.cpp | 2 +- 6 files changed, 232 insertions(+), 209 deletions(-) diff --git a/client_pump/main/ClientPump.cpp b/client_pump/main/ClientPump.cpp index 0ebe809..2f2746a 100644 --- a/client_pump/main/ClientPump.cpp +++ b/client_pump/main/ClientPump.cpp @@ -95,6 +95,8 @@ void init_WiFi() { // ---------------------------------------------------------------------------- void on_DataRecv(const esp_now_recv_info *info, const uint8_t *data, int len) { + static const char *TAG = "on_DataRecv"; + if (!info || !data || len <= 0) return; if (memcmp(info->src_addr, PEER_SENSOR, 6) != 0) return; @@ -106,7 +108,7 @@ void on_DataRecv(const esp_now_recv_info *info, const uint8_t *data, int len) { memcpy(msg, data, len); msg[len] = '\0'; - DBG_PRINTF("Received from server: %s\n", msg); + ESP_LOGI("Received from server: %s", msg); if (strncmp(msg, "p:", 2) == 0) { @@ -136,7 +138,7 @@ void on_DataRecv(const esp_now_recv_info *info, const uint8_t *data, int len) { if (!esp_now_is_peer_exist(info->src_addr)) { esp_err_t add_status = esp_now_add_peer(&peer); if (add_status != ESP_OK) { - DBG_PRINTF("Failed to add peer before sending ACK, err=%d\n", add_status); + ESP_LOGI(TAG, "Failed to add peer before sending ACK, err=%d", add_status); return; } } @@ -144,9 +146,9 @@ void on_DataRecv(const esp_now_recv_info *info, const uint8_t *data, int len) { const char ack_msg[] = "thanks"; esp_err_t result = esp_now_send(info->src_addr, (const uint8_t *)ack_msg, sizeof(ack_msg)); if (result == ESP_OK) - DBG_PRINTLN("Sent acknowledgment: thanks"); + ESP_LOGI(TAG, "Sent acknowledgment: thanks"); else - DBG_PRINTF("Failed to send acknowledgment, err=%d\n", result); + ESP_LOGI(TAG, "Failed to send acknowledgment, err=%d", result); // --- Copy data from message --- // make sure we keep old data before memcpy @@ -157,11 +159,11 @@ void on_DataRecv(const esp_now_recv_info *info, const uint8_t *data, int len) { memcpy(&pump_configs[i], &pump_config, sizeof(PumpConfig_s)); next_message_unix = pump_config.next_message_unix; - DBG_PRINTF("unix_now: %lld\n", unix_now); - DBG_PRINTF("pump_name: %s\n", pump_configs[i].pump_name); - DBG_PRINTF("pumping_delay_sec: %d\n", pump_configs[i].pumping_delay_sec); - DBG_PRINTF("pumping_duration: %d\n", pump_configs[i].pumping_duration); - DBG_PRINTF("next_message_unix: %lld\n", pump_configs[i].next_message_unix); + ESP_LOGI(TAG, "unix_now: %lld", unix_now); + ESP_LOGI(TAG, "pump_name: %s", pump_configs[i].pump_name); + ESP_LOGI(TAG, "pumping_delay_sec: %d", pump_configs[i].pumping_delay_sec); + ESP_LOGI(TAG, "pumping_duration: %d", pump_configs[i].pumping_duration); + ESP_LOGI(TAG, "next_message_unix: %lld", pump_configs[i].next_message_unix); if (pump_configs[i].pumping_duration > 0) pump_configs[i].pumping_status = START; @@ -174,7 +176,7 @@ void on_DataRecv(const esp_now_recv_info *info, const uint8_t *data, int len) { return; } } else { - DBG_PRINTLN("Failed to parse message"); + ESP_LOGI(TAG, "Failed to parse message"); } } received_starting_message = false; @@ -183,7 +185,7 @@ void on_DataRecv(const esp_now_recv_info *info, const uint8_t *data, int len) { void init_EspNow() { if (esp_now_init() != ESP_OK) { - DBG_PRINTLN("ESP NOW init failed"); + ESP_LOGI("init_EspNow", "ESP NOW init failed"); while (true); } esp_now_register_recv_cb(on_DataRecv); @@ -195,8 +197,9 @@ void init_EspNow() { // ---------------------------------------------------------------------------- void sleep_UntilNextSend(int64_t next_read) { + static const char *TAG = "sleep_UntilNextSend"; - DBG_PRINTF("Next read: %lld\n", next_read); + ESP_LOGI(TAG, "Next read: %lld", next_read); int64_t now_sec = get_CurrentUnix(); @@ -210,8 +213,7 @@ void sleep_UntilNextSend(int64_t next_read) { // Prevent sleeping if next send is within g_min_sleep_time if (min_delay_ms < g_min_sleep_time) { - DBG_PRINTF("Delaying for %u ms (no deep sleep)\n", min_delay_ms); - DBG_PRINTF("######################\n\n"); + ESP_LOGI(TAG, "Delaying for %u ms (no deep sleep)", min_delay_ms); if (!received_starting_message) vTaskDelay(pdMS_TO_TICKS(min_delay_ms)); return; @@ -225,9 +227,8 @@ void sleep_UntilNextSend(int64_t next_read) { esp_sleep_enable_timer_wakeup((uint64_t)sleep_time_ms * 1000ULL); if (!received_starting_message) { - DBG_PRINTF("Sleeping for %u ms (setup margin: %u ms)\n", + ESP_LOGI(TAG, "Sleeping for %u ms (setup margin: %u ms)", sleep_time_ms, prep_time_ms); - DBG_PRINTF("######################\n\n"); esp_deep_sleep_start(); } } diff --git a/client_pump/main/main.cpp b/client_pump/main/main.cpp index 4fbf1e0..3882972 100644 --- a/client_pump/main/main.cpp +++ b/client_pump/main/main.cpp @@ -15,13 +15,13 @@ PumpConfig_s pump_configs[PUMP_COUNT] = { }; void start_Pump(PumpConfig_s& pump_data) { - DBG_PRINTF("Starting Pump %s", pump_data.pump_name); + ESP_LOGI("start_Pump", "Starting Pump %s", pump_data.pump_name); pump_data.pumping_started_at_unix = get_CurrentUnix(); pump_data.pumping_status = RUNNING; } void stop_Pump(PumpConfig_s& pump_data) { - DBG_PRINTF("Stopped Pump %s", pump_data.pump_name); + ESP_LOGI("stop_Pump", "Stopped Pump %s", pump_data.pump_name); pump_data.pumping_status = INACTIVE; } @@ -57,10 +57,11 @@ void pump_loop(void*) { } extern "C" void app_main(void) { + static const char *TAG = "app_main"; + uint32_t setup_start = esp_timer_get_time() / 1000ULL; - DBG_BEGIN(); - DBG_PRINTF("Initializing ClientPump..."); + ESP_LOGI(TAG, "Initializing ClientPump..."); esp_base_mac_addr_set(PEER_PUMP); @@ -72,7 +73,7 @@ extern "C" void app_main(void) { received_starting_message = false; uint32_t setup_duration = (esp_timer_get_time() / 1000ULL) - setup_start; - DBG_PRINTF("Setup duration: %u ms", setup_duration); + ESP_LOGI(TAG, "Setup duration: %u ms", setup_duration); xTaskCreate(pump_loop, "pump_loop", 4096, nullptr, 5, nullptr); } diff --git a/client_sensor/main/ClientSensor.cpp b/client_sensor/main/ClientSensor.cpp index 6e44fec..bc0ab96 100644 --- a/client_sensor/main/ClientSensor.cpp +++ b/client_sensor/main/ClientSensor.cpp @@ -91,28 +91,26 @@ void init_WiFi() { // ---------------------------------------------------------------------------- void print_SensorConfig(const SensorConfig_s& cfg) { - DBG_PRINTF("SensorConfig for '%s'\n", cfg.sensor_name); - DBG_PRINTF(" is_active: %s\n", cfg.is_active ? "true" : "false"); - DBG_PRINTF(" pin: %d\n", cfg.pin); - DBG_PRINTF(" min_moisture: %d\n", cfg.min_moisture); - DBG_PRINTF(" notification_name: %s\n", cfg.notification_name); - DBG_PRINTF(" pumping_delay_sec: %d\n", cfg.pumping_delay_sec); - DBG_PRINTF(" pumping_duration: %d\n", cfg.pumping_duration); - DBG_PRINTF(" pump_mac: "); printMac(cfg.pump_mac); - DBG_PRINTF(" delay_ms: %d\n", cfg.delay_ms); - DBG_PRINTF(" use_time: %s\n", cfg.use_time ? "true" : "false"); - DBG_PRINTF(" time_count: %u\n", cfg.time_count); - DBG_PRINTF(" last_sensor_read: %lld\n", cfg.last_sensor_read); - DBG_PRINTF(" next_sensor_read: %lld\n", cfg.next_sensor_read); + static const char *TAG = "print_SensorConfig"; + + ESP_LOGI(TAG, "SensorConfig for '%s'", cfg.sensor_name); + ESP_LOGI(TAG, " is_active: %s", cfg.is_active ? "true" : "false"); + ESP_LOGI(TAG, " pin: %d", cfg.pin); + ESP_LOGI(TAG, " min_moisture: %d", cfg.min_moisture); + ESP_LOGI(TAG, " notification_name: %s", cfg.notification_name); + ESP_LOGI(TAG, " pumping_delay_sec: %d", cfg.pumping_delay_sec); + ESP_LOGI(TAG, " pumping_duration: %d", cfg.pumping_duration); + ESP_LOGI(TAG, " pump_mac: "); printMac(cfg.pump_mac); + ESP_LOGI(TAG, " delay_ms: %d", cfg.delay_ms); + ESP_LOGI(TAG, " use_time: %s", cfg.use_time ? "true" : "false"); + ESP_LOGI(TAG, " time_count: %u", cfg.time_count); + ESP_LOGI(TAG, " last_sensor_read: %lld", cfg.last_sensor_read); + ESP_LOGI(TAG, " next_sensor_read: %lld", cfg.next_sensor_read); if (cfg.time_count > 0) { - DBG_PRINT(" times: "); - for (uint8_t i = 0; i < cfg.time_count; i++) { - DBG_PRINTF("%u", cfg.times[i]); - if (i < cfg.time_count - 1) - DBG_PRINT("|"); - } - DBG_PRINTLN(""); + ESP_LOGI(TAG, " times: "); + for (uint8_t i = 0; i < cfg.time_count; i++) + ESP_LOGI(TAG, "%u", cfg.times[i]); } } @@ -121,12 +119,14 @@ void print_SensorConfig(const SensorConfig_s& cfg) { // ---------------------------------------------------------------------------- bool load_SensorConfigs() { - DBG_PRINTLN("Loading sensor configs from NVS..."); + static const char *TAG = "load_SensorConfigs"; + + ESP_LOGI(TAG, "Loading sensor configs from NVS..."); nvs_handle_t handle; esp_err_t err = nvs_open("sensors", NVS_READONLY, &handle); if (err != ESP_OK) { - DBG_PRINTF("Failed to open NVS namespace: %d\n", err); + ESP_LOGI(TAG, "Failed to open NVS namespace: %d", err); return false; } @@ -134,45 +134,49 @@ bool load_SensorConfigs() { size_t stored_size = sc_size; err = nvs_get_blob(handle, "configs", sensor_configs, &stored_size); if (err == ESP_OK && stored_size == sc_size) { - DBG_PRINTLN("Config read successfully."); + ESP_LOGI(TAG, "Config read successfully."); nvs_close(handle); return true; } else { - DBG_PRINTLN("No valid stored config found."); + ESP_LOGI(TAG, "No valid stored config found."); nvs_close(handle); return false; } } void save_SensorConfigs() { - DBG_PRINTLN("Saving sensor configs to NVS..."); + static const char *TAG = "save_SensorConfigs"; + + ESP_LOGI(TAG, "Saving sensor configs to NVS..."); nvs_handle_t handle; esp_err_t err = nvs_open("sensors", NVS_READWRITE, &handle); if (err != ESP_OK) { - DBG_PRINTF("Failed to open NVS namespace: %d\n", err); + ESP_LOGI(TAG, "Failed to open NVS namespace: %d", err); return; } size_t sc_size = SENSOR_CONFIG_COUNT * sizeof(SensorConfig_s); err = nvs_set_blob(handle, "configs", sensor_configs, sc_size); if (err != ESP_OK) { - DBG_PRINTF("Failed to write blob to NVS: %d\n", err); + ESP_LOGI(TAG, "Failed to write blob to NVS: %d", err); } else { nvs_commit(handle); - DBG_PRINTLN("Save complete."); + ESP_LOGI(TAG, "Save complete."); } nvs_close(handle); } void restore_SensorConfigs() { - DBG_PRINTLN("Trying to load old config!"); + static const char *TAG = "restore_SensorConfigs"; + + ESP_LOGI(TAG, "Trying to load old config!"); if (load_SensorConfigs()) { - DBG_PRINTLN("Sensor configs restored from flash."); + ESP_LOGI(TAG, "Sensor configs restored from flash."); } else { - DBG_PRINTLN("No stored configs found, using defaults."); + ESP_LOGI(TAG, "No stored configs found, using defaults."); for (size_t i = 0; i < SENSOR_CONFIG_COUNT; i++) { memcpy(sensor_configs[i].pump_mac, PEER_PUMP, 6); } @@ -185,26 +189,29 @@ void restore_SensorConfigs() { // ---------------------------------------------------------------------------- void on_DataSent(const wifi_tx_info_t* info, esp_now_send_status_t status) { - DBG_PRINT("Packet to "); + static const char *TAG = "on_DataSent"; + + ESP_LOGI(TAG, "Packet to "); for (int i = 0; i < 6; i++) { - DBG_PRINTF("%02X", info->des_addr[i]); - if (i < 5) DBG_PRINT(":"); + ESP_LOGI(TAG, " :%02X", info->des_addr[i]); } if (status == ESP_NOW_SEND_SUCCESS) - DBG_PRINTLN(" queued successfully"); + ESP_LOGI(TAG, " queued successfully"); else - DBG_PRINTLN(" failed to queue!"); + ESP_LOGI(TAG, " failed to queue!"); } void on_DataRecv(const esp_now_recv_info *info, const uint8_t *data, int len) { + static const char *TAG = "on_DataRecv"; + if (!info || !data || len <= 0) return; // --- Filter by source MAC --- const uint8_t *src = info->src_addr; if (memcmp(src, PEER_SERVER, 6) == 0) { - DBG_PRINTLN("Ignoring message: unknown sender"); + ESP_LOGI("Ignoring message: unknown sender"); return; } @@ -213,22 +220,24 @@ void on_DataRecv(const esp_now_recv_info *info, const uint8_t *data, int len) { memcpy(msg, data, len); msg[len] = '\0'; - DBG_PRINTF("Received from server: %s\n", msg); + ESP_LOGI(TAG, "Received from server: %s", msg); if (strncmp(msg, "time:", 5) == 0) { int64_t server_unix = strtoll(msg + 5, nullptr, 10); struct timeval tv = { .tv_sec = server_unix, .tv_usec = 0 }; settimeofday(&tv, nullptr); rtc_synced_with_server = true; - DBG_PRINTLN("System time updated from server."); + ESP_LOGI(TAG, "System time updated from server."); } - DBG_PRINTLN("Setting send_process_complete to TRUE"); + ESP_LOGI(TAG, "Setting send_process_complete to TRUE"); send_process_complete = true; } void on_DataRecvResponse(const esp_now_recv_info *info, const uint8_t *data, int len) { + static const char *TAG = "on_DataRecvResponse"; + if (!info || !data || len <= 0) return; // --- Filter by source MAC --- @@ -244,7 +253,7 @@ void on_DataRecvResponse(const esp_now_recv_info *info, const uint8_t *data, int } if (!from_server && !from_pump) { - DBG_PRINTLN("Ignoring message: unknown sender"); + ESP_LOGI(TAG, "Ignoring message: unknown sender"); return; } @@ -253,13 +262,13 @@ void on_DataRecvResponse(const esp_now_recv_info *info, const uint8_t *data, int memcpy(msg, data, copylen); msg[copylen] = '\0'; - DBG_PRINTF("Response received: %s\n", msg); + ESP_LOGI(TAG, "Response received: %s", msg); if (from_pump) { - DBG_PRINTF("Received from Pump: %s\n", msg); + ESP_LOGI(TAG, "Received from Pump: %s", msg); if (strncmp(msg, "thanks", 6) == 0) { response_received = true; - DBG_PRINTLN("Setting send_response_process_complete to TRUE"); + ESP_LOGI(TAG, "Setting send_response_process_complete to TRUE"); send_response_process_complete = true; } return; @@ -272,7 +281,7 @@ void on_DataRecvResponse(const esp_now_recv_info *info, const uint8_t *data, int settimeofday(&tv, nullptr); rtc_synced_with_server = true; response_received = true; - DBG_PRINTLN("System time updated from server (Response)."); + ESP_LOGI(TAG, "System time updated from server (Response)."); } const char *cfg_ptr = msg; @@ -298,56 +307,60 @@ void on_DataRecvResponse(const esp_now_recv_info *info, const uint8_t *data, int strncpy(g_pending_sensor_configs[g_pending_sensor_configs_count], new_cfg, sizeof(g_pending_sensor_configs[0]) - 1); g_pending_sensor_configs[g_pending_sensor_configs_count][sizeof(g_pending_sensor_configs[0]) - 1] = '\0'; g_pending_sensor_configs_count++; - DBG_PRINTF("Added new config: %s\n", new_cfg); + ESP_LOGI(TAG, "Added new config: %s", new_cfg); } if (!end) break; cfg_ptr = end; } - DBG_PRINTLN("Setting send_response_process_complete to TRUE"); + ESP_LOGI(TAG, "Setting send_response_process_complete to TRUE"); send_response_process_complete = true; } void print_AllPeers() { + static const char *TAG = "print_AllPeers"; + esp_now_peer_num_t peerCount; esp_err_t res = esp_now_get_peer_num(&peerCount); if (res != ESP_OK) { - DBG_PRINTLN("Failed to get peer count"); + ESP_LOGI(TAG, "Failed to get peer count"); return; } - DBG_PRINTF("Total peers: %d\n", peerCount.total_num); + ESP_LOGI(TAG, "Total peers: %d", peerCount.total_num); for (int i = 0; i < peerCount.total_num; i++) { esp_now_peer_info_t peerInfo; res = esp_now_fetch_peer(i, &peerInfo); if (res == ESP_OK) { - DBG_PRINTF("Peer %d: ", i); + ESP_LOGI(TAG, "Peer %d: ", i); printMac(peerInfo.peer_addr); } else { - DBG_PRINTF("Failed to fetch peer %d\n", i); + ESP_LOGI(TAG, "Failed to fetch peer %d", i); } } } void add_Peer(const uint8_t* addr, int32_t channel) { - DBG_PRINT("add_Peer: "); + static const char *TAG = "print_AllPeers"; + + ESP_LOGI(TAG, "add_Peer: "); if (!addr) { - DBG_PRINTLN("ERROR: null MAC address!"); + ESP_LOGI(TAG, "ERROR: null MAC address!"); return; } for (int i = 0; i < 6; i++) { if (addr[i] != 0) continue; else { - DBG_PRINTLN("ERROR: MAC address is zero!"); + ESP_LOGI(TAG, "ERROR: MAC address is zero!"); return; } } printMac(addr); if (esp_now_is_peer_exist(addr)) { - DBG_PRINTLN("Peer already exists, skipping:"); + ESP_LOGI(TAG, "Peer already exists, skipping:"); printMac(addr); return; } @@ -360,12 +373,12 @@ void add_Peer(const uint8_t* addr, int32_t channel) { esp_err_t res = esp_now_add_peer(&peer); if (res == ESP_OK) { - DBG_PRINT("Added peer: "); + ESP_LOGI(TAG, "Added peer: "); printMac(addr); } else { - DBG_PRINT("Failed to add peer: "); + ESP_LOGI(TAG, "Failed to add peer: "); printMac(addr); - DBG_PRINTF(" (ESP_ERR: %d)\n", res); + ESP_LOGI(TAG, " (ESP_ERR: %d)", res); } } @@ -381,8 +394,10 @@ void ensure_Peers() { } void init_EspNow() { + static const char *TAG = "init_EspNow"; + if (esp_now_init() != ESP_OK) { - DBG_PRINTLN("ESP NOW init failed"); + ESP_LOGI(TAG, "ESP NOW init failed"); while (true); } esp_now_register_send_cb(on_DataSent); @@ -390,12 +405,14 @@ void init_EspNow() { } bool send_Message(const uint8_t* peer, const char* message) { - DBG_PRINTLN("send_Message: "); + static const char *TAG = "send_Message"; + + ESP_LOGI(TAG, "send_Message: "); printMac(peer); - DBG_PRINTLN("Message:"); - DBG_PRINTF(" %s\n", message); + ESP_LOGI(TAG, "Message:"); + ESP_LOGI(TAG, " %s", message); if (!esp_now_is_peer_exist(peer)) { - DBG_PRINTLN("ERROR: peer doese not exist!"); + ESP_LOGI(TAG, "ERROR: peer doese not exist!"); return false; } esp_err_t result = esp_now_send(peer, (uint8_t*)message, strlen(message)); @@ -403,13 +420,15 @@ bool send_Message(const uint8_t* peer, const char* message) { } bool send_AndWaitResponse(const uint8_t* peer, const char* message, uint32_t timeout_ms = 5000) { + static const char *TAG = "send_AndWaitResponse"; + send_response_process_complete = false; response_received = false; esp_now_register_recv_cb(on_DataRecvResponse); if (!send_Message(peer, message)) { - DBG_PRINTLN("Failed to queue message for sending!"); + ESP_LOGI(TAG, "Failed to queue message for sending!"); return false; } @@ -419,7 +438,7 @@ bool send_AndWaitResponse(const uint8_t* peer, const char* message, uint32_t tim } if (!response_received) { - DBG_PRINT("No Response received from "); + ESP_LOGI(TAG, "No Response received from "); printMac(peer); return false; } @@ -476,12 +495,14 @@ uint16_t get_CurrentMinutes() { bool is_TimeToReadSensor(size_t config_id) { + static const char *TAG = "is_TimeToReadSensor"; + SensorConfig_s& p = sensor_configs[config_id]; - DBG_PRINTF("check is_TimeToReadSensor: %s\n", p.sensor_name); + ESP_LOGI(TAG, "check is_TimeToReadSensor: %s", p.sensor_name); if (!p.is_active) { - DBG_PRINTLN("Sensor is inactive!"); + ESP_LOGI(TAG, "Sensor is inactive!"); return false; } @@ -544,6 +565,8 @@ int64_t get_NextSensorReadsUnixTime(const uint8_t* mac) { } void sleep_UntilNextSend(int64_t next_read) { + static const char *TAG = "sleep_UntilNextSend"; + int64_t now_sec = get_CurrentUnix(); int64_t delta_sec = next_read - now_sec; @@ -556,8 +579,8 @@ void sleep_UntilNextSend(int64_t next_read) { // Prevent sleeping if next send is within g_min_sleep_time if (min_delay_ms < g_min_sleep_time) { - DBG_PRINTF("Delaying for %u ms (no deep sleep)\n", min_delay_ms); - DBG_PRINTF("######################\n\n"); + ESP_LOGI(TAG, "Delaying for %u ms (no deep sleep)", min_delay_ms); + ESP_LOGI(TAG, "######################"); vTaskDelay(pdMS_TO_TICKS(min_delay_ms)); return; } @@ -570,9 +593,9 @@ void sleep_UntilNextSend(int64_t next_read) { save_SensorConfigs(); - DBG_PRINTF("Sleeping for %u ms (setup margin: %u ms)\n", + ESP_LOGI(TAG, "Sleeping for %u ms (setup margin: %u ms)", sleep_time_ms, prep_time_ms); - DBG_PRINTF("######################\n\n"); + ESP_LOGI(TAG, "######################"); esp_sleep_enable_timer_wakeup((uint64_t)sleep_time_ms * 1000ULL); esp_deep_sleep_start(); @@ -587,6 +610,8 @@ bool sensor_config_received = false; char sensor_config_message[256] = { 0 }; void on_DataRecvSensorConfig(const esp_now_recv_info* info, const uint8_t* data, int len) { + static const char *TAG = "on_DataRecvSensorConfig"; + if (!info || !data || len <= 0) return; printMac(info->src_addr); if (memcmp(info->src_addr, PEER_SERVER, 6) != 0) return; @@ -595,14 +620,16 @@ void on_DataRecvSensorConfig(const esp_now_recv_info* info, const uint8_t* data, memcpy(sensor_config_message, data, copylen); sensor_config_message[copylen] = '\0'; - DBG_PRINTF("%s\n", sensor_config_message); + ESP_LOGI(TAG, "%s", sensor_config_message); if (strncmp(sensor_config_message, "cfg:", 4) != 0) return; sensor_config_received = true; } bool request_SensorConfig(const char* sensor_name) { - DBG_PRINTF("Getting sensor config for: %s\n", sensor_name); + static const char *TAG = "request_SensorConfig"; + + ESP_LOGI(TAG, "Getting sensor config for: %s", sensor_name); const uint8_t* server_mac = PEER_SERVER; sensor_config_received = false; @@ -614,7 +641,7 @@ bool request_SensorConfig(const char* sensor_name) { snprintf(msg, sizeof(msg), "get_config:%s", sensor_name); if (!send_Message(server_mac, msg)) { - DBG_PRINTLN("Failed to send get_config request"); + ESP_LOGI(TAG, "Failed to send get_config request"); return false; } @@ -626,12 +653,12 @@ bool request_SensorConfig(const char* sensor_name) { } if (!sensor_config_received) { - DBG_PRINTLN("No config reply received (timeout)"); + ESP_LOGI(TAG, "No config reply received (timeout)"); return false; } if (strncmp(sensor_config_message, "cfg:", 4) != 0) { - DBG_PRINTF("Invalid config response: %s\n", sensor_config_message); + ESP_LOGI(TAG, "Invalid config response: %s", sensor_config_message); return false; } @@ -646,14 +673,14 @@ bool request_SensorConfig(const char* sensor_name) { if (count_token == 0) return false; - DBG_PRINTF("Config received for %s:\n", tokens[0]); + ESP_LOGI(TAG, "Config received for %s:", tokens[0]); for (uint8_t i = 1; i < count_token; i++) { - DBG_PRINTF(" %u: %s\n", i, tokens[i]); + ESP_LOGI(TAG, " %u: %s", i, tokens[i]); } if (count_token < 9) { - DBG_PRINTLN("Incomplete config data"); + ESP_LOGI(TAG, "Incomplete config data"); return false; } @@ -666,7 +693,7 @@ bool request_SensorConfig(const char* sensor_name) { } if (!cfg) { - DBG_PRINTF("Unknown sensor name in config: %s\n", tokens[0]); + ESP_LOGI(TAG, "Unknown sensor name in config: %s", tokens[0]); return false; } @@ -699,26 +726,8 @@ bool request_SensorConfig(const char* sensor_name) { } } - /* - for (int i = 0; i < 6; i++) { - if (new_mac[i] != cfg->pump_mac[i]) { - DBG_PRINTLN("New mac address!"); - printMac(new_mac); - printMac(cfg->pump_mac); - if (esp_now_is_peer_exist(cfg->pump_mac)) { - if (esp_now_del_peer(cfg->pump_mac) != ESP_OK) - DBG_PRINTLN("Failed to delete old peer!"); - } - memcpy(cfg->pump_mac, new_mac, 6); - ensure_Peers(); - - break; - } - } - */ - if (cfg->last_sensor_read == 0) { - DBG_PRINTLN("RESETTING last_sensor_read"); + ESP_LOGI(TAG, "RESETTING last_sensor_read"); cfg->last_sensor_read = get_CurrentUnix(); } @@ -728,20 +737,22 @@ bool request_SensorConfig(const char* sensor_name) { } void process_PendingSensorConfigs() { + static const char *TAG = "process_PendingSensorConfigs"; + config_request_attempts = 0; - DBG_PRINTF("NEW CONFIGS: %d\n", g_pending_sensor_configs_count); + ESP_LOGI(TAG, "NEW CONFIGS: %d", g_pending_sensor_configs_count); size_t config_id = 0; bool save_new_configs = false; while (config_id < g_pending_sensor_configs_count) { - DBG_PRINTF("SENSOR: %s\n", g_pending_sensor_configs[config_id]); + ESP_LOGI(TAG, "SENSOR: %s", g_pending_sensor_configs[config_id]); bool success = false; for (config_request_attempts = 0; config_request_attempts < config_request_attempts_max; config_request_attempts++) { - DBG_PRINTF("Requesting config attempt %u...\n", config_request_attempts + 1); + ESP_LOGI(TAG, "Requesting config attempt %u...", config_request_attempts + 1); if (request_SensorConfig(g_pending_sensor_configs[config_id])) { success = true; break; @@ -750,7 +761,7 @@ void process_PendingSensorConfigs() { } if (success) { - DBG_PRINTF("Config %s processed successfully, removing.\n", + ESP_LOGI(TAG, "Config %s processed successfully, removing.", g_pending_sensor_configs[config_id]); if (config_id >= g_pending_sensor_configs_count) return; for (size_t i = config_id; i < g_pending_sensor_configs_count - 1; i++) @@ -758,7 +769,7 @@ void process_PendingSensorConfigs() { g_pending_sensor_configs_count--; save_new_configs = true; } else { - DBG_PRINTLN("Config request failed repeatedly, aborting loop."); + ESP_LOGI(TAG, "Config request failed repeatedly, aborting loop."); break; } } @@ -796,14 +807,16 @@ void get_AllSensorConfigs() { void send_DataToPumpAndServer(size_t config_id, uint32_t value, bool shall_pump) { + static const char *TAG = "send_DataToPumpAndServer"; + SensorConfig_s& p = sensor_configs[config_id]; - DBG_PRINTF("send_DataToPumpAndServer: %s\n", p.sensor_name); + ESP_LOGI(TAG, "send_DataToPumpAndServer: %s", p.sensor_name); int pumping_duration = shall_pump ? p.pumping_duration : 0; char message[64]; - DBG_PRINT("Sending to Pump: "); printMac(p.pump_mac); + ESP_LOGI(TAG, "Sending to Pump: "); printMac(p.pump_mac); snprintf(message, sizeof(message), "p:%lld:%s:%d:%d:%lld", get_CurrentUnix(), p.notification_name, @@ -813,14 +826,14 @@ void send_DataToPumpAndServer(size_t config_id, uint32_t value, bool shall_pump) bool reached_pump = false; if (!send_AndWaitResponse(p.pump_mac, message)) { - DBG_PRINTLN("Delivery failed or peer offline!"); + ESP_LOGI(TAG, "Delivery failed or peer offline!"); send_response_process_complete = true; } else reached_pump = true; while (!send_response_process_complete) vTaskDelay(pdMS_TO_TICKS(100)); - DBG_PRINT("Sending to Server: "); printMac(PEER_SERVER); + ESP_LOGI(TAG, "Sending to Server: "); printMac(PEER_SERVER); snprintf(message, sizeof(message), "%s:%lu:%lld:%d", p.sensor_name, value, @@ -828,7 +841,7 @@ void send_DataToPumpAndServer(size_t config_id, uint32_t value, bool shall_pump) reached_pump); send_response_process_complete = false; if (!send_AndWaitResponse(PEER_SERVER, message)) { - DBG_PRINTLN("Failed to get response from server!"); + ESP_LOGI(TAG, "Failed to get response from server!"); send_response_process_complete = true; } while (!send_response_process_complete) @@ -837,13 +850,15 @@ void send_DataToPumpAndServer(size_t config_id, uint32_t value, bool shall_pump) void send_NextSensorReadToPeer(const uint8_t* mac, int64_t unix_time) { + static const char *TAG = "send_NextSensorReadToPeer"; + char message[64]; snprintf(message, sizeof(message), "next_read:%lld", unix_time); - DBG_PRINT("Sending to peer: "); + ESP_LOGI(TAG, "Sending to peer: "); printMac(mac); if (!send_Message(mac, message)) { - DBG_PRINTLN("Delivery failed or peer offline!"); + ESP_LOGI(TAG, "Delivery failed or peer offline!"); } } diff --git a/client_sensor/main/main.cpp b/client_sensor/main/main.cpp index 3f172a9..d4acbcf 100644 --- a/client_sensor/main/main.cpp +++ b/client_sensor/main/main.cpp @@ -18,15 +18,17 @@ RTC_DATA_ATTR uint32_t fake_value_to_send = 0; // Sensor task loop // ---------------------------------------------------------------------------- void sensor_loop(void*) { + static const char *TAG = "sensor_loop"; + while (true) { - DBG_PRINTF("## Unix time: %lld\n", get_CurrentUnix()); + ESP_LOGI(TAG, "## Unix time: %lld", get_CurrentUnix()); for (size_t config_id = 0; config_id < SENSOR_CONFIG_COUNT; config_id++) { SensorConfig_s& peer = sensor_configs[config_id]; - DBG_PRINTF("LOOP checking config: %s\n", peer.sensor_name); + ESP_LOGI(TAG, "LOOP checking config: %s", peer.sensor_name); print_SensorConfig(peer); if (is_TimeToReadSensor(config_id)) { - DBG_PRINTLN("ITS TIME FOR THIS SENSOR!"); + ESP_LOGI(TAG, "ITS TIME FOR THIS SENSOR!"); uint32_t value_to_send = fake_value_to_send; // set last and next read times @@ -59,33 +61,32 @@ void sensor_loop(void*) { // ESP-IDF entry point // ---------------------------------------------------------------------------- extern "C" void app_main(void) { + static const char *TAG = "app_main"; uint32_t setup_start = esp_timer_get_time() / 1000ULL; - DBG_BEGIN(); - esp_base_mac_addr_set(PEER_SENSOR); setup_Timezone(); init_WiFi(); init_EspNow(); - DBG_PRINTLN("Requesting time sync..."); - if (request_TimeSync()) DBG_PRINTLN("done"); - else DBG_PRINTLN("failed (timeout)"); + ESP_LOGI(TAG, "Requesting time sync..."); + if (request_TimeSync()) ESP_LOGI(TAG, "done"); + else ESP_LOGI(TAG, "failed (timeout)"); restore_SensorConfigs(); - DBG_PRINTF("----------------------\n"); + ESP_LOGI(TAG, "----------------------"); if (!all_init_configs_received) get_AllSensorConfigs(); - DBG_PRINTF("----------------------\n"); + ESP_LOGI(TAG, "----------------------"); ensure_Peers(); g_setup_duration = (esp_timer_get_time() / 1000ULL) - setup_start; - DBG_PRINTF("Setup duration: %u ms\n", g_setup_duration); + ESP_LOGI(TAG, "Setup duration: %u ms", g_setup_duration); // start sensor loop task xTaskCreate(sensor_loop, "sensor_loop", 8192, nullptr, 5, nullptr); diff --git a/post_server/main/WiFiManager.cpp b/post_server/main/WiFiManager.cpp index 0aead7e..f77f0fd 100644 --- a/post_server/main/WiFiManager.cpp +++ b/post_server/main/WiFiManager.cpp @@ -18,31 +18,32 @@ static const char *TAG = "WiFiManager.cpp"; esp_err_t WiFi_connect() { - wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); - cfg.nvs_enable = 0; - esp_wifi_init(&cfg); - - esp_netif_inherent_config_t esp_netif_config = - ESP_NETIF_INHERENT_DEFAULT_WIFI_STA(); - esp_netif_create_wifi(WIFI_IF_STA, &esp_netif_config); - esp_wifi_set_default_wifi_sta_handlers(); - - esp_wifi_set_storage(WIFI_STORAGE_RAM); - esp_wifi_set_mode(WIFI_MODE_STA); - esp_wifi_start(); - - wifi_config_t wifi_config = { - .sta = - { - .ssid = WIFI_SSID, - .password = WIFI_PASSWORD, - }, - }; - ESP_LOGI(TAG, "Connecting to %s...", wifi_config.sta.ssid); - esp_wifi_set_config(WIFI_IF_STA, &wifi_config); - esp_wifi_connect(); - - return ESP_OK; + static const char *TAG = "WiFi_connect"; + wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); + cfg.nvs_enable = 0; + esp_wifi_init(&cfg); + + esp_netif_inherent_config_t esp_netif_config = + ESP_NETIF_INHERENT_DEFAULT_WIFI_STA(); + esp_netif_create_wifi(WIFI_IF_STA, &esp_netif_config); + esp_wifi_set_default_wifi_sta_handlers(); + + esp_wifi_set_storage(WIFI_STORAGE_RAM); + esp_wifi_set_mode(WIFI_MODE_STA); + esp_wifi_start(); + + wifi_config_t wifi_config = { + .sta = + { + .ssid = WIFI_SSID, + .password = WIFI_PASSWORD, + }, + }; + ESP_LOGI(TAG, "Connecting to %s...", wifi_config.sta.ssid); + esp_wifi_set_config(WIFI_IF_STA, &wifi_config); + esp_wifi_connect(); + + return ESP_OK; } esp_err_t WiFi_disconnect() { @@ -100,50 +101,52 @@ void WIFI_SyncTime() { static std::string http_response; esp_err_t http_event_handler(esp_http_client_event_t *evt) { + static const char *TAG = "http_event_handler"; switch (evt->event_id) { - case HTTP_EVENT_ERROR: - ESP_LOGI(TAG, "HTTP_EVENT_ERROR"); - http_response.clear(); - break; - case HTTP_EVENT_ON_CONNECTED: - ESP_LOGI(TAG, "HTTP_EVENT_ON_CONNECTED"); - break; - case HTTP_EVENT_HEADER_SENT: - ESP_LOGI(TAG, "HTTP_EVENT_HEADER_SENT"); - break; - case HTTP_EVENT_ON_HEADER: - ESP_LOGI(TAG, "HTTP_EVENT_ON_HEADER, key=%s, value=%s", evt->header_key ?: "", evt->header_value ?: ""); - break; - case HTTP_EVENT_ON_DATA: - ESP_LOGI(TAG, "HTTP_EVENT_ON_DATA, len=%d", evt->data_len); - if (evt->data && evt->data_len > 0) { - // append chunk to accumulating std::string - http_response.append(reinterpret_cast<const char*>(evt->data), evt->data_len); - } - break; - case HTTP_EVENT_ON_FINISH: - ESP_LOGI(TAG, "HTTP_EVENT_ON_FINISH"); - // leave http_response for caller to inspect - break; - case HTTP_EVENT_DISCONNECTED: - ESP_LOGI(TAG, "HTTP_EVENT_DISCONNECTED"); - // clear response if disconnected prematurely - // (caller will check content-length / status) - break; - case HTTP_EVENT_REDIRECT: - ESP_LOGI(TAG, "HTTP_EVENT_REDIRECT"); - break; + case HTTP_EVENT_ERROR: + ESP_LOGI(TAG, "HTTP_EVENT_ERROR"); + http_response.clear(); + break; + case HTTP_EVENT_ON_CONNECTED: + ESP_LOGI(TAG, "HTTP_EVENT_ON_CONNECTED"); + break; + case HTTP_EVENT_HEADER_SENT: + ESP_LOGI(TAG, "HTTP_EVENT_HEADER_SENT"); + break; + case HTTP_EVENT_ON_HEADER: + ESP_LOGI(TAG, "HTTP_EVENT_ON_HEADER, key=%s, value=%s", evt->header_key ?: "", evt->header_value ?: ""); + break; + case HTTP_EVENT_ON_DATA: + ESP_LOGI(TAG, "HTTP_EVENT_ON_DATA, len=%d", evt->data_len); + if (evt->data && evt->data_len > 0) { + // append chunk to accumulating std::string + http_response.append(reinterpret_cast<const char*>(evt->data), evt->data_len); + } + break; + case HTTP_EVENT_ON_FINISH: + ESP_LOGI(TAG, "HTTP_EVENT_ON_FINISH"); + // leave http_response for caller to inspect + break; + case HTTP_EVENT_DISCONNECTED: + ESP_LOGI(TAG, "HTTP_EVENT_DISCONNECTED"); + // clear response if disconnected prematurely + // (caller will check content-length / status) + break; + case HTTP_EVENT_REDIRECT: + ESP_LOGI(TAG, "HTTP_EVENT_REDIRECT"); + break; } return ESP_OK; } void post_ToServer( const char* path, char* json, size_t len) { + static const char *TAG = "post_ToServer"; // prepare HTTP client char url[256]; snprintf(url, sizeof(url), "https://%s%s", server_host, path); - // clear any previous response and set up config + // clear previous response and set up config http_response.clear(); esp_http_client_config_t config = { .url = url, @@ -180,6 +183,8 @@ void post_ToServer( const char* path, char* json, size_t len) { } void WiFi_PostDataToServer(size_t buffer_len, SensorEntry_s buffer[BUFFER_SIZE]) { + static const char *TAG = "WiFi_PostDataToServer"; + // allocate JSON buffer const size_t json_cap = JSON_BUFFER_SIZE; char *json = (char*)malloc(json_cap); @@ -216,11 +221,11 @@ void WiFi_PostDataToServer(size_t buffer_len, SensorEntry_s buffer[BUFFER_SIZE]) // format object ret = snprintf(json + len, (len < json_cap) ? (json_cap - len) : 0, - "{\"table\":\"%s\",\"value\":\"%s\",\"time\":%" PRId64 ",\"pump_reached\":%d}", - table, - value, - buffer[i].time, - buffer[i].pump_reached); + "{\"table\":\"%s\",\"value\":\"%s\",\"time\":%" PRId64 ",\"pump_reached\":%d}", + table, + value, + buffer[i].time, + buffer[i].pump_reached); if (ret < 0) { free(json); g_received_ok_from_server = true; @@ -438,9 +443,9 @@ bool WIFI_GetSensorConfigServer(const char* sensor_name, SensorConfigServer_s &c } ESP_LOGI(TAG, "Parsed config: success=%d pin=%d min=%d delay=%d use_time=%d time_count=%u", - cfg.success, cfg.pin, cfg.min_moisture, cfg.delay_ms, cfg.use_time, cfg.time_count); + cfg.success, cfg.pin, cfg.min_moisture, cfg.delay_ms, cfg.use_time, cfg.time_count); ESP_LOGI(TAG, "sensor_name='%s' notification='%s' pumping_delay_sec=%d pumping_duration=%d", - cfg.sensor_name, cfg.notification_name, cfg.pumping_delay_sec, cfg.pumping_duration); + cfg.sensor_name, cfg.notification_name, cfg.pumping_delay_sec, cfg.pumping_duration); return cfg.success; } diff --git a/post_server/main/main.cpp b/post_server/main/main.cpp index a17c410..e105f6c 100644 --- a/post_server/main/main.cpp +++ b/post_server/main/main.cpp @@ -11,10 +11,10 @@ #include "esp_wifi.h" #include <sys/param.h> -static const char *TAG = "main.cpp"; extern "C" void app_main() { + static const char *TAG = "app_main"; xTaskCreate([](void*) { esp_netif_init(); nvs_flash_init();