Compare commits

..
10 Commits
Author SHA1 Message Date
admin 71a01cc63e sen5x: remove unused i2cdev forward declarations 2026-02-08 23:07:01 +01:00
admin 4d2e84f027 sen5x: Producer-Task sauber beenden und externes vTaskDelete vermeiden
- Producer setzt g_task_prod = NULL und löscht sich beim Beenden selbst
- sen5x_app_deinit signalisiert Stopp via g_run = false und wartet auf den Producer
- verhindert das „Abschießen“ von Tasks, die ggf. I2C/Mutexe oder andere Ressourcen halten
2026-02-08 22:58:55 +01:00
admin 81b5677b5f main: I2C Port/Pins vereinheitlicht (BSP-Defines) für i2cdev_adopt_bus + SEN5x 2026-02-08 22:15:29 +01:00
admin daa6909f5d fix(sen5x): Sensirion I2C HAL an int8_t-Fehlercodes angepasst
Ersetzt unsichere Casts von esp_err_t nach int8_t durch ein stabiles Mapping gemäß Sensirion-HAL, nutzt die i2cdev-Mutex-API direkt statt Makros mit esp_err_t-Rückgaben, korrigiert sleep_usec() auf aufrundende µs→ms-Umrechnung zur Einhaltung der Mindestwartezeit und setzt addr_bit_len explizit auf 7 Bit mit zusätzlicher Grundvalidierung der I2C-Frequenz.
2026-02-08 21:50:22 +01:00
eugen 7a163ec85f Refactor: wifi_mgr, net_influx und sen5x_app als eigene Komponenten platziert 2026-01-29 15:20:33 +01:00
eugen ac7d26eb9c Refactor: Influx-Handling aus sen5x_app ausgelagert und generisch gemacht
- sen5x_app.c auf reine Sensor-App reduziert (SEN5x Readout, Skalierung, GUI vars, device-tag)
- Influx-Init/Retry/Backoff/HTTP komplett nach net_influx.c verlagert
- SEN5x schreibt nicht mehr direkt Line-Protocol, sondern submit via net_influx_submit_point()
- net_influx als generisches Interface für unterschiedliche Sensor-Samples (variable Anzahl Felder) vorbereitet
- Consumer/Queue für Influx aus sen5x_app entfernt; nur noch Producer-Task im Sensor-Modul
2026-01-29 13:11:21 +01:00
eugen 531256529f Die Flag-Funktion fürs mDNS-Icon korregiert 2026-01-22 17:33:19 +01:00
admin 2352075c58 refactor: entkopple mDNS-Discovery, Status-Flags und WiFi-Manager
- net_mdns: Autostart + Discovery-Retry stabilisiert (Forward-Declarations, Task-Start bei GOT_IP)
- sys_status: EventGroup zentralisiert; Statusbits nicht mehr aus net_mdns gesetzt
- main: Integration von net_mdns Autostart/Discovery und UI-Status-Update vorbereitet
- wifi_mgr: mDNS-Discovery-Logik entfernt/vereinheitlicht, damit keine doppelte Discovery läuft
- net_influx: Anpassungen an neue Discovery/Storage-Semantik
2026-01-22 13:45:15 +01:00
admin ca8ec3c993 Refactor: net_mdns in separate component ausgelagert 2025-12-11 01:36:01 +01:00
admin 5f60ea3841 Refactor: sys_status in separate component ausgelagert 2025-12-11 01:16:06 +01:00
24 changed files with 1629 additions and 867 deletions
+1
View File
@@ -3,4 +3,5 @@
.vscode/c_cpp_properties.json .vscode/c_cpp_properties.json
.vscode/launch.json .vscode/launch.json
.vscode/ipch .vscode/ipch
.venv
todo.txt todo.txt
+10
View File
@@ -0,0 +1,10 @@
{
// See http://go.microsoft.com/fwlink/?LinkId=827846
// for the documentation about the extensions.json format
"recommendations": [
"platformio.platformio-ide"
],
"unwantedRecommendations": [
"ms-vscode.cpptools-extension-pack"
]
}
@@ -0,0 +1,14 @@
idf_component_register(
SRCS
"src/net_influx.c"
INCLUDE_DIRS
"include"
REQUIRES
mdns
esp_netif
esp_wifi
storage
esp_http_client
sys_status
)
@@ -0,0 +1,82 @@
// File: include/net_influx.h (oder wo dein Header liegt)
#pragma once
#include <stdint.h>
#include <stdbool.h>
#include "esp_err.h"
typedef enum {
NET_INFLUX_F_FLOAT,
NET_INFLUX_F_INT,
NET_INFLUX_F_UINT,
NET_INFLUX_F_BOOL,
NET_INFLUX_F_STRING,
} net_influx_field_type_t;
typedef struct {
const char* key; // field key
net_influx_field_type_t type;
int precision; // nur für FLOAT (z.B. 1,3). sonst ignoriert
union {
double f;
int64_t i;
uint64_t u;
bool b;
const char* s;
} v;
} net_influx_field_t;
typedef struct {
const char* measurement; // z.B. "air"
const char* tags; // z.B. "device=xyz,location=lab" (optional, kann NULL sein)
uint64_t ts_ms; // 0 => server time
const net_influx_field_t* fields;
size_t num_fields;
} net_influx_point_t;
typedef struct {
// Task/Queue
uint16_t queue_len; // z.B. 16
uint32_t task_stack; // z.B. 6144
UBaseType_t task_prio; // z.B. 5
// Init/Retry/Backoff
uint32_t init_retry_ms; // z.B. 1000
uint32_t backoff_start_ms; // z.B. 2000
uint32_t backoff_max_ms; // z.B. 300000
uint8_t fails_before_reinit; // z.B. 5
// Influx init
const char* ca_cert_pem_opt; // optional
int http_timeout_ms; // z.B. 3000
} net_influx_runtime_cfg_t;
// Bestehende Funktionen bleiben:
typedef struct {
const char* url_base;
const char* org;
const char* bucket;
const char* token;
bool use_tls;
const char* ca_cert_pem;
int http_timeout_ms;
} net_influx_cfg_t;
esp_err_t net_influx_init(const net_influx_cfg_t* cfg);
esp_err_t net_influx_init_from_nvs(const char* ca_cert_pem_opt, int timeout_ms);
// NEU:
esp_err_t net_influx_start(const net_influx_runtime_cfg_t* rt);
void net_influx_stop(void);
// Asynchron: kopiert point+felder intern und queued sie.
// Rückgabe:
// - ESP_OK: queued
// - ESP_ERR_NO_MEM / ESP_ERR_INVALID_ARG / ESP_FAIL: sonst
esp_err_t net_influx_submit_point(const net_influx_point_t* p);
// Optional (falls du synchron brauchst, bleibt deine alte API nutzbar):
esp_err_t net_influx_write_fields(const char* measurement,
const char* tags,
uint64_t ts_ms,
const char* fields_fmt,
...);
@@ -0,0 +1,719 @@
// File: src/net_influx.c
#include "esp_http_client.h"
#include "esp_err.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
#include <stdlib.h>
#include <math.h>
#include "sys_status.h"
#include "storage.h"
#include "net_influx.h"
static const char* TAG = "net_influx";
/* ---------------- State (mit internen Kopien!) ---------------- */
typedef struct {
char url_base[128];
char org[64];
char bucket[64];
char token[512]; // lang genug für Influx Token
bool use_tls;
const char* ca_cert_pem;
int http_timeout_ms;
} net_influx_state_t;
static net_influx_state_t s = {0};
/* ---------------- Worker Runtime State (asynchrones Submit) ---------------- */
typedef struct {
uint16_t queue_len;
uint32_t task_stack;
UBaseType_t task_prio;
uint32_t init_retry_ms;
uint32_t backoff_start_ms;
uint32_t backoff_max_ms;
uint8_t fails_before_reinit;
const char* ca_cert_pem_opt;
int http_timeout_ms;
} net_influx_runtime_cfg_i_t;
static QueueHandle_t s_q = NULL;
static TaskHandle_t s_task = NULL;
static bool s_run = false;
static net_influx_runtime_cfg_i_t s_rt = {
.queue_len = 16,
.task_stack = 6144,
.task_prio = 5,
.init_retry_ms = 1000,
.backoff_start_ms = 2000,
.backoff_max_ms = 300000,
.fails_before_reinit = 5,
.ca_cert_pem_opt = NULL,
.http_timeout_ms = 3000,
};
/* ---------------- Utils ---------------- */
static void trim_inplace(char* p) {
if (!p) return;
size_t len = strlen(p);
size_t a = 0, b = len;
while (a < b && (isspace((unsigned char)p[a]) || p[a] == '\"')) a++;
while (b > a && (isspace((unsigned char)p[b-1]) || p[b-1] == '\"' || p[b-1] == '/')) b--;
if (a || b != len) {
memmove(p, p + a, b - a);
p[b - a] = 0;
}
}
static void safe_copy(char* dst, size_t dst_sz, const char* src) {
if (!dst || dst_sz == 0) return;
if (!src) { dst[0] = 0; return; }
strncpy(dst, src, dst_sz - 1);
dst[dst_sz - 1] = 0;
}
typedef struct {
bool tls; // http=false, https=true
char host[64];
int port; // -1 = nicht angegeben
} base_parts_t;
// erwartet: "http://host:port" oder "host:port" oder "host"
static bool parse_base_url(const char* in, base_parts_t* out) {
if (!in || !*in || !out) return false;
char buf[128];
safe_copy(buf, sizeof(buf), in);
trim_inplace(buf);
const char* p = buf;
out->tls = false;
out->port = -1;
memset(out->host, 0, sizeof(out->host));
if (strncasecmp(p, "http://", 7) == 0) { p += 7; out->tls = false; }
else if (strncasecmp(p, "https://", 8) == 0) { p += 8; out->tls = true; }
const char* colon = strchr(p, ':');
if (colon) {
size_t host_len = (size_t)(colon - p);
if (host_len == 0 || host_len >= sizeof(out->host)) return false;
memcpy(out->host, p, host_len);
out->host[host_len] = 0;
const char* port_str = colon + 1;
if (!*port_str) return false;
int port = 0;
while (*port_str && isdigit((unsigned char)*port_str)) {
port = port * 10 + (*port_str - '0');
port_str++;
}
if (*port_str != 0) return false; // kein weiterer Kram erlaubt
out->port = port;
} else {
size_t host_len = strlen(p);
if (host_len == 0 || host_len >= sizeof(out->host)) return false;
memcpy(out->host, p, host_len);
out->host[host_len] = 0;
}
return true;
}
static void mask_token(const char* token, char* out, size_t out_len) {
if (!token || !out || out_len < 8) return;
size_t n = strlen(token);
if (n <= 8) {
snprintf(out, out_len, "****");
} else {
size_t keep = 4;
snprintf(out, out_len, "%.*s****%.*s",
(int)keep, token,
(int)keep, token + n - keep);
}
}
static char* dup0(const char* str) {
if (!str) return NULL;
size_t n = strlen(str) + 1;
char* p = (char*)malloc(n);
if (!p) return NULL;
memcpy(p, str, n);
return p;
}
/* Minimal escaping für measurement/key: spaces/commas */
static size_t esc_copy(char* dst, size_t cap, const char* src, bool escape_equals) {
size_t pos = 0;
if (!dst || cap == 0) return 0;
dst[0] = 0;
if (!src) return 0;
for (const char* p = src; *p; ++p) {
char c = *p;
bool esc = (c == ' ' || c == ',' || (escape_equals && c == '='));
if (esc) {
if (pos + 2 >= cap) break;
dst[pos++] = '\\';
dst[pos++] = c;
} else {
if (pos + 1 >= cap) break;
dst[pos++] = c;
}
}
dst[(pos < cap) ? pos : (cap - 1)] = 0;
return pos;
}
/* ---------------- HTTP Event Handler (IDF-kompatibel) ---------------- */
static esp_err_t http_evt(esp_http_client_event_t* evt) {
switch (evt->event_id) {
case HTTP_EVENT_ERROR: ESP_LOGE(TAG, "HTTP_EVENT_ERROR"); break;
case HTTP_EVENT_ON_CONNECTED: ESP_LOGI(TAG, "HTTP_EVENT_ON_CONNECTED"); break;
case HTTP_EVENT_HEADER_SENT: ESP_LOGD(TAG, "HTTP_EVENT_HEADER_SENT"); break;
case HTTP_EVENT_ON_HEADER:
ESP_LOGD(TAG, "HDR: %s: %s",
evt->header_key ? evt->header_key : "(null)",
evt->header_value ? evt->header_value : "(null)");
break;
case HTTP_EVENT_ON_DATA: ESP_LOGV(TAG, "DATA chunk len=%d", evt->data_len); break;
case HTTP_EVENT_ON_FINISH: ESP_LOGD(TAG, "HTTP_EVENT_ON_FINISH"); break;
case HTTP_EVENT_DISCONNECTED: ESP_LOGW(TAG, "HTTP_EVENT_DISCONNECTED"); break;
default: break;
}
return ESP_OK;
}
/* ---------------- Internal: HTTP send "line protocol" ---------------- */
static esp_err_t net_influx_write_line(const char* line) {
bool ok = false;
if (!line || !*line) {
sys_status_set_influx_ok(false);
return ESP_ERR_INVALID_ARG;
}
if (s.url_base[0] == 0 || s.org[0] == 0 || s.bucket[0] == 0 || s.token[0] == 0) {
sys_status_set_influx_ok(false);
return ESP_ERR_INVALID_STATE;
}
// Base parse → host/port/tls
base_parts_t bp;
if (!parse_base_url(s.url_base, &bp)) {
ESP_LOGE(TAG, "Base-URL ungueltig: \"%s\"", s.url_base);
sys_status_set_influx_ok(false);
return ESP_ERR_INVALID_ARG;
}
if (s.use_tls) bp.tls = true;
int port = (bp.port > 0) ? bp.port : (bp.tls ? 443 : 8086);
// Pfad
char path[192];
snprintf(path, sizeof(path), "/api/v2/write?org=%s&bucket=%s&precision=ms", s.org, s.bucket);
ESP_LOGI(TAG, "HTTP cfg: host=%s, port=%d, path=%s, tls=%d", bp.host, port, path, (int)bp.tls);
ESP_LOGD(TAG, "Line: %s", line);
esp_http_client_config_t cfg = {
.host = bp.host,
.port = port,
.path = path,
.timeout_ms = s.http_timeout_ms,
.cert_pem = bp.tls ? s.ca_cert_pem : NULL,
.method = HTTP_METHOD_POST,
.event_handler = http_evt,
.transport_type = bp.tls ? HTTP_TRANSPORT_OVER_SSL : HTTP_TRANSPORT_OVER_TCP,
.disable_auto_redirect = false,
};
esp_http_client_handle_t h = esp_http_client_init(&cfg);
if (!h) {
ESP_LOGE(TAG, "http_client_init: no mem");
sys_status_set_influx_ok(false);
return ESP_ERR_NO_MEM;
}
// Header
size_t auth_len = strlen(s.token) + 7; // "Token " + '\0'
char* auth = (char*)malloc(auth_len);
if (!auth) {
ESP_LOGE(TAG, "malloc auth header: no mem");
esp_http_client_cleanup(h);
sys_status_set_influx_ok(false);
return ESP_ERR_NO_MEM;
}
snprintf(auth, auth_len, "Token %s", s.token);
esp_http_client_set_header(h, "Authorization", auth);
free(auth);
esp_http_client_set_header(h, "Content-Type", "text/plain; charset=utf-8");
esp_err_t err = esp_http_client_set_post_field(h, line, (int)strlen(line));
if (err != ESP_OK) {
ESP_LOGE(TAG, "set_post_field: %s", esp_err_to_name(err));
esp_http_client_cleanup(h);
sys_status_set_influx_ok(false);
return err;
}
err = esp_http_client_perform(h);
int status = -1;
if (err == ESP_OK) {
status = esp_http_client_get_status_code(h);
int64_t cl = esp_http_client_get_content_length(h);
ESP_LOGI(TAG, "HTTP status=%d, content_length=%lld", status, (long long)cl);
if (status != 204) {
char resp[256] = {0};
int n = esp_http_client_read_response(h, resp, sizeof(resp)-1);
if (n > 0) ESP_LOGW(TAG, "Resp(%d): %.*s", status, n, resp);
else ESP_LOGW(TAG, "Resp(%d): <kein Body>", status);
}
} else {
ESP_LOGE(TAG, "perform: %s", esp_err_to_name(err));
}
esp_http_client_cleanup(h);
ok = (err == ESP_OK && status == 204);
sys_status_set_influx_ok(ok);
return ok ? ESP_OK : ESP_FAIL;
}
/* ---------------- Generic Point/Fields → Line Protocol ---------------- */
static bool field_is_valid(const net_influx_field_t* f) {
if (!f || !f->key || !*f->key) return false;
if (f->type == NET_INFLUX_F_FLOAT) return isfinite(f->v.f);
if (f->type == NET_INFLUX_F_STRING) return (f->v.s != NULL);
return true;
}
static esp_err_t build_line_protocol(const net_influx_point_t* p, char* out, size_t out_cap) {
if (!p || !p->measurement || !p->fields || p->num_fields == 0 || !out || out_cap < 64) {
return ESP_ERR_INVALID_ARG;
}
size_t off = 0;
// measurement escaped (space/comma)
char meas[96];
esc_copy(meas, sizeof(meas), p->measurement, false);
off += snprintf(out + off, out_cap - off, "%s", meas);
if (off >= out_cap) return ESP_FAIL;
// tags: passthrough (caller liefert "k=v,k2=v2")
if (p->tags && *p->tags) {
off += snprintf(out + off, out_cap - off, ",%s", p->tags);
if (off >= out_cap) return ESP_FAIL;
}
off += snprintf(out + off, out_cap - off, " ");
if (off >= out_cap) return ESP_FAIL;
bool first = true;
for (size_t i = 0; i < p->num_fields; ++i) {
const net_influx_field_t* f = &p->fields[i];
if (!field_is_valid(f)) continue;
char key[64];
esc_copy(key, sizeof(key), f->key, false);
if (!first) {
off += snprintf(out + off, out_cap - off, ",");
if (off >= out_cap) return ESP_FAIL;
}
first = false;
switch (f->type) {
case NET_INFLUX_F_FLOAT: {
int prec = (f->precision >= 0 && f->precision <= 9) ? f->precision : 3;
char fmt[24];
snprintf(fmt, sizeof(fmt), "%%s=%%.%df", prec);
off += snprintf(out + off, out_cap - off, fmt, key, f->v.f);
break;
}
case NET_INFLUX_F_INT:
off += snprintf(out + off, out_cap - off, "%s=%lldi", key, (long long)f->v.i);
break;
case NET_INFLUX_F_UINT:
off += snprintf(out + off, out_cap - off, "%s=%llui", key, (unsigned long long)f->v.u);
break;
case NET_INFLUX_F_BOOL:
off += snprintf(out + off, out_cap - off, "%s=%s", key, f->v.b ? "true" : "false");
break;
case NET_INFLUX_F_STRING: {
off += snprintf(out + off, out_cap - off, "%s=\"", key);
if (off >= out_cap) return ESP_FAIL;
const char* s0 = f->v.s ? f->v.s : "";
for (const char* sp = s0; *sp; ++sp) {
if (off + 2 >= out_cap) return ESP_FAIL;
if (*sp == '\"' || *sp == '\\') out[off++] = '\\';
out[off++] = *sp;
}
if (off + 2 >= out_cap) return ESP_FAIL;
out[off++] = '\"';
out[off] = 0;
break;
}
default:
return ESP_ERR_INVALID_ARG;
}
if (off >= out_cap) return ESP_FAIL;
}
if (first) return ESP_ERR_INVALID_STATE; // keine validen Felder
if (p->ts_ms != 0) {
off += snprintf(out + off, out_cap - off, " %llu", (unsigned long long)p->ts_ms);
if (off >= out_cap) return ESP_FAIL;
}
return ESP_OK;
}
/* ---------------- Async Queue Message (deep copy) ---------------- */
typedef struct {
char* measurement;
char* tags; // optional
uint64_t ts_ms;
size_t num_fields;
net_influx_field_t* fields; // deep-copied array; keys and string-values are duplicated
} influx_msg_t;
static void free_msg(influx_msg_t* m) {
if (!m) return;
if (m->measurement) free(m->measurement);
if (m->tags) free(m->tags);
if (m->fields) {
for (size_t i = 0; i < m->num_fields; ++i) {
if (m->fields[i].type == NET_INFLUX_F_STRING && m->fields[i].v.s) {
free((void*)m->fields[i].v.s);
}
if (m->fields[i].key) free((void*)m->fields[i].key);
}
free(m->fields);
}
memset(m, 0, sizeof(*m));
}
/* ---------------- Init/Backoff (im Worker) ---------------- */
static bool influx_init_blocking(void) {
while (s_run) {
if (net_influx_init_from_nvs(s_rt.ca_cert_pem_opt, s_rt.http_timeout_ms) == ESP_OK) {
ESP_LOGI(TAG, "Influx ready (from NVS).");
return true;
}
ESP_LOGW(TAG, "Influx nicht bereit – retry in %u ms", (unsigned)s_rt.init_retry_ms);
vTaskDelay(pdMS_TO_TICKS(s_rt.init_retry_ms));
}
return false;
}
static bool influx_reinit_with_backoff(uint32_t* backoff_ms) {
if (!backoff_ms) return false;
uint32_t wait_ms = (*backoff_ms == 0) ? s_rt.backoff_start_ms : *backoff_ms;
ESP_LOGW(TAG, "Re-Init Influx in %u ms", (unsigned)wait_ms);
vTaskDelay(pdMS_TO_TICKS(wait_ms));
bool ok = (net_influx_init_from_nvs(s_rt.ca_cert_pem_opt, s_rt.http_timeout_ms) == ESP_OK);
if (ok) {
ESP_LOGI(TAG, "Influx Re-Init OK");
*backoff_ms = s_rt.backoff_start_ms;
return true;
}
if (wait_ms < s_rt.backoff_max_ms) {
uint32_t next = wait_ms * 2;
*backoff_ms = (next > s_rt.backoff_max_ms) ? s_rt.backoff_max_ms : next;
}
return false;
}
/* ---------------- Worker Task ---------------- */
static void net_influx_worker(void* arg) {
(void)arg;
ESP_LOGI(TAG, "Influx worker started.");
if (!influx_init_blocking()) {
ESP_LOGE(TAG, "Worker beendet (Influx init fatal).");
vTaskDelete(NULL);
return;
}
int fail_count = 0;
uint32_t backoff_ms = s_rt.backoff_start_ms;
while (s_run) {
influx_msg_t msg = {0};
if (xQueueReceive(s_q, &msg, portMAX_DELAY) != pdTRUE) continue;
net_influx_point_t p = {
.measurement = msg.measurement,
.tags = msg.tags,
.ts_ms = msg.ts_ms,
.fields = msg.fields,
.num_fields = msg.num_fields,
};
char line[512];
esp_err_t b = build_line_protocol(&p, line, sizeof(line));
if (b == ESP_ERR_INVALID_STATE) {
ESP_LOGW(TAG, "Skipping write: no valid fields.");
free_msg(&msg);
continue;
}
if (b != ESP_OK) {
ESP_LOGW(TAG, "Line build failed: %s", esp_err_to_name(b));
free_msg(&msg);
continue;
}
esp_err_t e = net_influx_write_line(line);
if (e == ESP_OK) {
if (fail_count) ESP_LOGI(TAG, "Influx write recovered.");
fail_count = 0;
backoff_ms = s_rt.backoff_start_ms;
} else {
ESP_LOGW(TAG, "Influx write failed: %s", esp_err_to_name(e));
if (++fail_count >= (int)s_rt.fails_before_reinit) {
(void)influx_reinit_with_backoff(&backoff_ms);
fail_count = 0;
}
}
free_msg(&msg);
}
ESP_LOGI(TAG, "Influx worker stopping.");
vTaskDelete(NULL);
}
/* ---------------- Public API ---------------- */
esp_err_t net_influx_init(const net_influx_cfg_t* cfg) {
if (!cfg || !cfg->url_base || !cfg->org || !cfg->bucket || !cfg->token) {
return ESP_ERR_INVALID_ARG;
}
safe_copy(s.url_base, sizeof(s.url_base), cfg->url_base);
safe_copy(s.org, sizeof(s.org), cfg->org);
safe_copy(s.bucket, sizeof(s.bucket), cfg->bucket);
safe_copy(s.token, sizeof(s.token), cfg->token);
trim_inplace(s.url_base);
s.use_tls = cfg->use_tls;
s.ca_cert_pem = cfg->ca_cert_pem;
s.http_timeout_ms = (cfg->http_timeout_ms > 0) ? cfg->http_timeout_ms : 3000;
char tok[32] = {0};
mask_token(s.token, tok, sizeof(tok));
ESP_LOGI(TAG, "init: base=\"%s\", org=\"%s\", bucket=\"%s\", tls=%d, timeout=%dms, token=%s",
s.url_base, s.org, s.bucket, (int)s.use_tls, s.http_timeout_ms, tok);
sys_status_set_influx_ok(false);
return ESP_OK;
}
esp_err_t net_influx_write_fields(const char* measurement,
const char* tags,
uint64_t ts_ms,
const char* fields_fmt,
...)
{
// --- pessimistisch starten ---
bool ok = false;
if (!measurement || !fields_fmt) {
sys_status_set_influx_ok(false);
return ESP_ERR_INVALID_ARG;
}
if (s.url_base[0] == 0 || s.org[0] == 0 || s.bucket[0] == 0 || s.token[0] == 0) {
sys_status_set_influx_ok(false);
return ESP_ERR_INVALID_STATE;
}
// 1) Fields formatieren
char fields[256];
va_list ap;
va_start(ap, fields_fmt);
vsnprintf(fields, sizeof(fields), fields_fmt, ap);
va_end(ap);
// 2) Line Protocol
char line[512];
int off = 0;
// measurement escaping (space/comma)
char meas[96];
esc_copy(meas, sizeof(meas), measurement, false);
off += snprintf(line + off, sizeof(line) - off, "%s", meas);
if (off < 0 || off >= (int)sizeof(line)) { sys_status_set_influx_ok(false); return ESP_FAIL; }
if (tags && *tags) {
off += snprintf(line + off, sizeof(line) - off, ",%s", tags);
if (off < 0 || off >= (int)sizeof(line)) { sys_status_set_influx_ok(false); return ESP_FAIL; }
}
off += snprintf(line + off, sizeof(line) - off, " %s", fields);
if (off < 0 || off >= (int)sizeof(line)) { sys_status_set_influx_ok(false); return ESP_FAIL; }
if (ts_ms != 0) {
off += snprintf(line + off, sizeof(line) - off, " %llu", (unsigned long long)ts_ms);
if (off < 0 || off >= (int)sizeof(line)) { sys_status_set_influx_ok(false); return ESP_FAIL; }
}
esp_err_t err = net_influx_write_line(line);
ok = (err == ESP_OK);
sys_status_set_influx_ok(ok);
return ok ? ESP_OK : ESP_FAIL;
}
// Aus NVS: URL (service_url), org/bucket/token → net_influx_init()
esp_err_t net_influx_init_from_nvs(const char* ca_cert_pem_opt, int timeout_ms)
{
char *url = NULL, *org = NULL, *bucket = NULL, *token = NULL;
if (!storage_load_service_url(&url)) {
ESP_LOGW(TAG, "keine Service-URL in NVS gefunden (mDNS noch nicht fertig?)");
return ESP_ERR_NOT_FOUND;
}
if (!storage_get_effective_influx(&org, &bucket, &token)) {
ESP_LOGE(TAG, "Influx-Konfiguration aus NVS nicht lesbar");
free(url);
return ESP_FAIL;
}
net_influx_cfg_t cfg = {
.url_base = url, // z.B. "http://192.168.1.10:8086"
.org = org,
.bucket = bucket,
.token = token,
.use_tls = false, // URL-Parser erkennt https automatisch; true erzwingt TLS
.ca_cert_pem = ca_cert_pem_opt,
.http_timeout_ms = (timeout_ms > 0) ? timeout_ms : 3000
};
esp_err_t err = net_influx_init(&cfg);
free(url);
free(org);
free(bucket);
free(token);
return err;
}
/* ---------------- NEW: Start/Stop/Submit (generic, multi-sensor) ---------------- */
esp_err_t net_influx_start(const net_influx_runtime_cfg_t* rt) {
if (s_task) return ESP_OK;
// runtime cfg übernehmen (mit Defaults)
if (rt) {
s_rt.queue_len = rt->queue_len ? rt->queue_len : s_rt.queue_len;
s_rt.task_stack = rt->task_stack ? rt->task_stack : s_rt.task_stack;
s_rt.task_prio = rt->task_prio ? rt->task_prio : s_rt.task_prio;
s_rt.init_retry_ms = rt->init_retry_ms ? rt->init_retry_ms : s_rt.init_retry_ms;
s_rt.backoff_start_ms = rt->backoff_start_ms ? rt->backoff_start_ms : s_rt.backoff_start_ms;
s_rt.backoff_max_ms = rt->backoff_max_ms ? rt->backoff_max_ms : s_rt.backoff_max_ms;
s_rt.fails_before_reinit = rt->fails_before_reinit ? rt->fails_before_reinit : s_rt.fails_before_reinit;
s_rt.ca_cert_pem_opt = rt->ca_cert_pem_opt;
s_rt.http_timeout_ms = (rt->http_timeout_ms > 0) ? rt->http_timeout_ms : s_rt.http_timeout_ms;
}
s_q = xQueueCreate(s_rt.queue_len, sizeof(influx_msg_t));
if (!s_q) return ESP_ERR_NO_MEM;
s_run = true;
if (xTaskCreate(net_influx_worker, "influx_worker", s_rt.task_stack, NULL, s_rt.task_prio, &s_task) != pdPASS) {
vQueueDelete(s_q);
s_q = NULL;
s_run = false;
return ESP_FAIL;
}
return ESP_OK;
}
void net_influx_stop(void) {
s_run = false;
if (s_task) {
vTaskDelete(s_task);
s_task = NULL;
}
if (s_q) {
influx_msg_t msg;
while (xQueueReceive(s_q, &msg, 0) == pdTRUE) {
free_msg(&msg);
}
vQueueDelete(s_q);
s_q = NULL;
}
}
esp_err_t net_influx_submit_point(const net_influx_point_t* p) {
if (!p || !p->measurement || !*p->measurement || !p->fields || p->num_fields == 0) {
return ESP_ERR_INVALID_ARG;
}
if (!s_q) return ESP_ERR_INVALID_STATE;
influx_msg_t msg = {0};
msg.measurement = dup0(p->measurement);
msg.tags = (p->tags && *p->tags) ? dup0(p->tags) : NULL;
msg.ts_ms = p->ts_ms;
msg.num_fields = p->num_fields;
msg.fields = (net_influx_field_t*)calloc(p->num_fields, sizeof(net_influx_field_t));
if (!msg.measurement || !msg.fields) {
free_msg(&msg);
return ESP_ERR_NO_MEM;
}
for (size_t i = 0; i < p->num_fields; ++i) {
msg.fields[i] = p->fields[i];
// deep copy key
msg.fields[i].key = dup0(p->fields[i].key);
if (!msg.fields[i].key) {
free_msg(&msg);
return ESP_ERR_NO_MEM;
}
// deep copy string value if needed
if (p->fields[i].type == NET_INFLUX_F_STRING && p->fields[i].v.s) {
msg.fields[i].v.s = dup0(p->fields[i].v.s);
if (!msg.fields[i].v.s) {
free_msg(&msg);
return ESP_ERR_NO_MEM;
}
}
}
// Non-blocking enqueue; wenn voll: drop oldest
if (xQueueSend(s_q, &msg, 0) != pdPASS) {
influx_msg_t dump;
if (xQueueReceive(s_q, &dump, 0) == pdTRUE) free_msg(&dump);
if (xQueueSend(s_q, &msg, 0) != pdPASS) {
free_msg(&msg);
return ESP_FAIL;
}
}
return ESP_OK;
}
@@ -0,0 +1,12 @@
idf_component_register(
SRCS
"src/net_mdns.c"
INCLUDE_DIRS
"include"
REQUIRES
mdns
esp_netif
esp_wifi
storage
)
@@ -0,0 +1,32 @@
// net_mdns.h (Ergänzungen)
#pragma once
#include <stdbool.h>
#include <stdint.h>
#include "esp_err.h"
#include "mdns.h"
// bestehende APIs bleiben...
typedef struct {
const char *service; // z.B. "_myapp"
const char *proto; // z.B. "_tcp"
int enforce_port; // -1 oder 0 = egal
const char *fallback_service; // z.B. "_http"
const char *fallback_proto; // z.B. "_tcp"
int fallback_port; // z.B. 8086
const char *txt_key; // optional
const char *txt_value; // optional
uint32_t query_timeout_ms; // z.B. 2000
uint32_t retry_interval_ms; // z.B. 60000
int max_results; // z.B. 5
const char *instance_prefix; // z.B. "myapp-"
bool require_instance_prefix; // true/false
} net_mdns_discover_cfg_t;
esp_err_t net_mdns_autodiscover_start(const net_mdns_discover_cfg_t *cfg);
void net_mdns_autodiscover_stop(void);
esp_err_t net_mdns_autostart_init(const char* hostname, const char* instance_name);
+477
View File
@@ -0,0 +1,477 @@
// File: firmware/components/net_mdns/src/net_mdns.c
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
#include "esp_log.h"
#include "esp_err.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "esp_wifi.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "mdns.h"
#include "net_mdns.h"
#include "storage.h"
static const char *TAG = "net_mdns";
// -------------------- Global State --------------------
static char g_hostname[33] = {0};
static char g_instance[33] = {0};
static volatile bool g_mdns_running = false;
static volatile bool g_autostart_inited = false;
// Event handler instance handles (damit nicht mehrfach registriert wird)
static esp_event_handler_instance_t g_ip_handler = NULL;
static esp_event_handler_instance_t g_wifi_handler = NULL;
// Discovery task state
static TaskHandle_t g_discover_task = NULL;
// Konfiguration für Discovery-Retry (interne Kopie)
typedef struct {
char service[32];
char proto[8];
int enforce_port;
char fallback_service[32];
char fallback_proto[8];
int fallback_port;
// optional TXT filter (können leer sein)
char txt_key[32];
char txt_value[64];
uint32_t query_timeout_ms;
uint32_t retry_interval_ms;
int max_results;
// optional: Instanzpräfix-Filter
char instance_prefix[16]; // z.B. "myapp-"; leer = kein Filter
bool require_instance_prefix;
} discover_cfg_t;
static discover_cfg_t g_discover_cfg = {0};
static volatile bool g_discover_enabled = false;
// -------------------- Forward Declarations (C needs this) --------------------
static void mdns_start_if_needed(void);
static void mdns_stop_if_running(void);
static bool have_sta_ip(void);
static void mdns_discover_task(void *arg);
static void on_ip_event(void *arg, esp_event_base_t base, int32_t id, void *data);
static void on_wifi_event(void *arg, esp_event_base_t base, int32_t id, void *data);
// These are public (declared in net_mdns.h), but used before their definition in this .c
esp_err_t net_mdns_autodiscover_and_store(const char *service, const char *proto,
int enforce_port,
const char *txt_key, const char *txt_value,
uint32_t timeout_ms);
bool net_mdns_find_service_url(const char *service, const char *proto,
int enforce_port, const char *txt_key, const char *txt_value,
uint32_t timeout_ms, int max_results,
char *url_out, size_t url_out_size);
// -------------------- Internal Helpers --------------------
static void mdns_start_if_needed(void)
{
if (g_mdns_running) return;
esp_err_t err = mdns_init();
if (err != ESP_OK) {
ESP_LOGE(TAG, "mdns_init failed: %s", esp_err_to_name(err));
return;
}
if (g_hostname[0]) mdns_hostname_set(g_hostname);
if (g_instance[0]) mdns_instance_name_set(g_instance);
g_mdns_running = true;
ESP_LOGI(TAG, "mDNS started (host=%s, inst=%s)", g_hostname, g_instance);
}
static void mdns_stop_if_running(void)
{
if (!g_mdns_running) return;
mdns_free();
g_mdns_running = false;
ESP_LOGI(TAG, "mDNS stopped");
}
static bool have_sta_ip(void)
{
esp_netif_t *sta = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
if (!sta) return false;
esp_netif_ip_info_t ip;
if (esp_netif_get_ip_info(sta, &ip) != ESP_OK) return false;
return (ip.ip.addr != 0);
}
// Platzhalter: sys_status wird bewusst NICHT in diesem Component gesetzt.
static void set_mdns_ok(bool ok)
{
(void)ok;
}
// -------------------- Discovery Task --------------------
static void mdns_discover_task(void *arg)
{
(void)arg;
const uint32_t retry_ms = g_discover_cfg.retry_interval_ms ? g_discover_cfg.retry_interval_ms : 60000;
const TickType_t retry_delay = pdMS_TO_TICKS(retry_ms);
ESP_LOGI(TAG,
"mDNS discover task started: primary=%s.%s port=%d fallback=%s.%s port=%d retry=%u ms",
g_discover_cfg.service, g_discover_cfg.proto, g_discover_cfg.enforce_port,
g_discover_cfg.fallback_service, g_discover_cfg.fallback_proto, g_discover_cfg.fallback_port,
(unsigned)retry_ms);
for (;;) {
// Wenn Discovery deaktiviert wurde → sauber beenden
if (!g_discover_enabled) {
ESP_LOGI(TAG, "mDNS discover disabled; exiting task.");
g_discover_task = NULL;
vTaskDelete(NULL);
return;
}
// Wenn STA nicht online ist → warten
if (!have_sta_ip()) {
set_mdns_ok(false);
vTaskDelay(retry_delay);
continue;
}
// mDNS sicherstellen
mdns_start_if_needed();
if (!g_mdns_running) {
set_mdns_ok(false);
vTaskDelay(retry_delay);
continue;
}
// 1) Primary service
esp_err_t err = net_mdns_autodiscover_and_store(
g_discover_cfg.service,
g_discover_cfg.proto,
g_discover_cfg.enforce_port,
(g_discover_cfg.txt_key[0] ? g_discover_cfg.txt_key : NULL),
(g_discover_cfg.txt_value[0] ? g_discover_cfg.txt_value : NULL),
g_discover_cfg.query_timeout_ms ? g_discover_cfg.query_timeout_ms : 2000
);
// 2) Fallback service (wenn primary nicht gefunden)
if (err != ESP_OK && g_discover_cfg.fallback_service[0] && g_discover_cfg.fallback_proto[0]) {
err = net_mdns_autodiscover_and_store(
g_discover_cfg.fallback_service,
g_discover_cfg.fallback_proto,
g_discover_cfg.fallback_port,
NULL,
NULL,
g_discover_cfg.query_timeout_ms ? g_discover_cfg.query_timeout_ms : 2000
);
}
if (err == ESP_OK) {
set_mdns_ok(true);
ESP_LOGI(TAG, "mDNS: service found & stored; stopping discover task.");
g_discover_enabled = false; // Einmal finden reicht (wie zuvor in wifi_mgr)
g_discover_task = NULL;
vTaskDelete(NULL);
return;
} else {
set_mdns_ok(false);
ESP_LOGW(TAG, "mDNS: no service found; retry in %u ms", (unsigned)retry_ms);
vTaskDelay(retry_delay);
}
}
}
// -------------------- Event Handlers --------------------
static void on_ip_event(void *arg, esp_event_base_t base, int32_t id, void *data)
{
(void)arg;
(void)data;
if (base == IP_EVENT && id == IP_EVENT_STA_GOT_IP) {
// mDNS starten
mdns_start_if_needed();
// Optional: Discovery-Task starten, wenn enabled
if (g_discover_enabled && g_discover_task == NULL) {
BaseType_t ok = xTaskCreate(mdns_discover_task, "mdns_discover", 3072, NULL, 4, &g_discover_task);
if (ok != pdPASS) {
g_discover_task = NULL;
ESP_LOGE(TAG, "Failed to create mdns_discover task");
}
}
}
}
static void on_wifi_event(void *arg, esp_event_base_t base, int32_t id, void *data)
{
(void)arg;
(void)data;
if (base == WIFI_EVENT && id == WIFI_EVENT_STA_DISCONNECTED) {
// Beim Disconnect mDNS stoppen
mdns_stop_if_running();
// Status: nicht ok (No-op in diesem Component)
set_mdns_ok(false);
// Discovery Task NICHT hart killen (kann in mdns_query hängen).
// Bei nächstem GOT_IP kann sie erneut starten; oder sie schläft und merkt g_discover_enabled später.
}
}
// -------------------- Public API --------------------
esp_err_t net_mdns_autostart_init(const char *hostname, const char *instance_name)
{
// idempotent: mehrfacher Aufruf ist ok, registriert aber nur einmal Handler
if (hostname) {
strncpy(g_hostname, hostname, sizeof(g_hostname) - 1);
g_hostname[sizeof(g_hostname) - 1] = '\0';
}
if (instance_name) {
strncpy(g_instance, instance_name, sizeof(g_instance) - 1);
g_instance[sizeof(g_instance) - 1] = '\0';
}
if (!g_autostart_inited) {
esp_err_t e1 = esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP,
on_ip_event, NULL, &g_ip_handler);
esp_err_t e2 = esp_event_handler_instance_register(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED,
on_wifi_event, NULL, &g_wifi_handler);
if (e1 != ESP_OK || e2 != ESP_OK) {
ESP_LOGE(TAG, "Failed to register event handlers (ip=%s wifi=%s)",
esp_err_to_name(e1), esp_err_to_name(e2));
return (e1 != ESP_OK) ? e1 : e2;
}
g_autostart_inited = true;
ESP_LOGI(TAG, "mDNS autostart initialized");
} else {
ESP_LOGD(TAG, "mDNS autostart already initialized");
}
// Falls IP schon vorhanden → mDNS direkt starten (+ ggf. discovery task)
if (have_sta_ip()) {
mdns_start_if_needed();
if (g_discover_enabled && g_discover_task == NULL) {
BaseType_t ok = xTaskCreate(mdns_discover_task, "mdns_discover", 3072, NULL, 4, &g_discover_task);
if (ok != pdPASS) {
g_discover_task = NULL;
ESP_LOGE(TAG, "Failed to create mdns_discover task");
}
}
}
return ESP_OK;
}
bool net_mdns_is_running(void)
{
return g_mdns_running;
}
bool net_mdns_wait_started(uint32_t timeout_ms)
{
uint32_t waited = 0;
const uint32_t step = 50;
while (!g_mdns_running && waited < timeout_ms) {
vTaskDelay(pdMS_TO_TICKS(step));
waited += step;
}
return g_mdns_running;
}
esp_err_t net_mdns_add_service(const char *service, const char *proto,
uint16_t port, mdns_txt_item_t *txt, size_t txt_count)
{
if (!g_mdns_running) {
mdns_start_if_needed();
if (!g_mdns_running) return ESP_ERR_INVALID_STATE;
}
esp_err_t err = mdns_service_add(NULL, service, proto, port, txt, txt_count);
if (err != ESP_OK) {
ESP_LOGE(TAG, "mdns_service_add %s.%s:%u failed: %s",
service, proto, (unsigned)port, esp_err_to_name(err));
} else {
ESP_LOGI(TAG, "mDNS service announced: %s.%s:%u", service, proto, (unsigned)port);
}
return err;
}
esp_err_t net_mdns_autodiscover_and_store(const char *service, const char *proto,
int enforce_port,
const char *txt_key, const char *txt_value,
uint32_t timeout_ms)
{
char url[96] = {0};
bool ok = net_mdns_find_service_url(service, proto, enforce_port,
txt_key, txt_value,
timeout_ms, 5,
url, sizeof(url));
if (!ok) {
ESP_LOGW(TAG, "Auto-Discover: kein Treffer für %s.%s", service, proto);
return ESP_ERR_NOT_FOUND;
}
esp_err_t err = storage_save_service_url(url);
if (err == ESP_OK) {
ESP_LOGI(TAG, "Auto-Discover: URL '%s' in NVS gespeichert.", url);
}
return err;
}
bool net_mdns_find_service_url(const char *service, const char *proto,
int enforce_port, const char *txt_key, const char *txt_value,
uint32_t timeout_ms, int max_results,
char *url_out, size_t url_out_size)
{
if (!service || !proto || !url_out || url_out_size < 16) return false;
if (!g_mdns_running) {
ESP_LOGW(TAG, "mDNS not running yet; waiting...");
if (!net_mdns_wait_started(3000)) {
ESP_LOGW(TAG, "mDNS still not running; abort query");
return false;
}
}
mdns_result_t *results = NULL;
esp_err_t err = mdns_query_ptr(service, proto, timeout_ms, max_results, &results);
if (err != ESP_OK) {
ESP_LOGW(TAG, "mdns_query_ptr error: %s", esp_err_to_name(err));
return false;
}
if (!results) {
ESP_LOGI(TAG, "mDNS query OK but no results for %s.%s", service, proto);
return false;
}
bool found = false;
for (mdns_result_t *r = results; r && !found; r = r->next) {
// TXT filter
bool txt_ok = true;
if (txt_key && txt_value) {
txt_ok = false;
for (int i = 0; i < r->txt_count; ++i) {
if (r->txt[i].key && r->txt[i].value &&
strcmp(r->txt[i].key, txt_key) == 0 &&
strcmp(r->txt[i].value, txt_value) == 0) {
txt_ok = true;
break;
}
}
}
if (!txt_ok) continue;
// Optional: Instance prefix filter (nur wenn konfiguriert)
if (g_discover_cfg.require_instance_prefix && g_discover_cfg.instance_prefix[0]) {
size_t pfx_len = strlen(g_discover_cfg.instance_prefix);
if (!r->instance_name || strncmp(r->instance_name, g_discover_cfg.instance_prefix, pfx_len) != 0) {
continue;
}
}
for (mdns_ip_addr_t *a = r->addr; a && !found; a = a->next) {
if (a->addr.type != ESP_IPADDR_TYPE_V4) continue;
uint16_t port = r->port ? r->port : 80;
if (enforce_port > 0 && port != (uint16_t)enforce_port) port = (uint16_t)enforce_port;
snprintf(url_out, url_out_size, "http://" IPSTR ":%u",
IP2STR(&a->addr.u_addr.ip4), (unsigned)port);
ESP_LOGI(TAG, "mDNS URL: %s", url_out);
found = true;
}
}
mdns_query_results_free(results);
return found;
}
void net_mdns_stop(void)
{
// Discovery stoppen (soft)
g_discover_enabled = false;
// mDNS stoppen
mdns_stop_if_running();
set_mdns_ok(false);
}
// -------------------- New Public: Discovery Retry --------------------
esp_err_t net_mdns_autodiscover_start(const net_mdns_discover_cfg_t *cfg)
{
if (!cfg || !cfg->service || !cfg->proto) return ESP_ERR_INVALID_ARG;
// config übernehmen (interne Kopie)
memset(&g_discover_cfg, 0, sizeof(g_discover_cfg));
strlcpy(g_discover_cfg.service, cfg->service, sizeof(g_discover_cfg.service));
strlcpy(g_discover_cfg.proto, cfg->proto, sizeof(g_discover_cfg.proto));
g_discover_cfg.enforce_port = cfg->enforce_port;
if (cfg->fallback_service && cfg->fallback_proto) {
strlcpy(g_discover_cfg.fallback_service, cfg->fallback_service, sizeof(g_discover_cfg.fallback_service));
strlcpy(g_discover_cfg.fallback_proto, cfg->fallback_proto, sizeof(g_discover_cfg.fallback_proto));
g_discover_cfg.fallback_port = cfg->fallback_port;
}
if (cfg->txt_key && cfg->txt_value) {
strlcpy(g_discover_cfg.txt_key, cfg->txt_key, sizeof(g_discover_cfg.txt_key));
strlcpy(g_discover_cfg.txt_value, cfg->txt_value, sizeof(g_discover_cfg.txt_value));
}
g_discover_cfg.query_timeout_ms = (cfg->query_timeout_ms ? cfg->query_timeout_ms : 2000);
g_discover_cfg.retry_interval_ms = (cfg->retry_interval_ms ? cfg->retry_interval_ms : 60000);
g_discover_cfg.max_results = (cfg->max_results ? cfg->max_results : 5);
if (cfg->instance_prefix && cfg->instance_prefix[0]) {
strlcpy(g_discover_cfg.instance_prefix, cfg->instance_prefix, sizeof(g_discover_cfg.instance_prefix));
g_discover_cfg.require_instance_prefix = cfg->require_instance_prefix;
} else {
g_discover_cfg.require_instance_prefix = false;
}
// enable
g_discover_enabled = true;
set_mdns_ok(false);
// Wenn wir schon IP haben: Task sofort starten, sonst wird er bei GOT_IP gestartet
if (have_sta_ip()) {
mdns_start_if_needed();
if (g_discover_task == NULL) {
BaseType_t ok = xTaskCreate(mdns_discover_task, "mdns_discover", 3072, NULL, 4, &g_discover_task);
if (ok != pdPASS) {
g_discover_task = NULL;
ESP_LOGE(TAG, "Failed to create mdns_discover task");
return ESP_FAIL;
}
}
}
return ESP_OK;
}
void net_mdns_autodiscover_stop(void)
{
g_discover_enabled = false;
// Task beendet sich selbst (kein hartes Kill)
}
+3
View File
@@ -5,10 +5,13 @@ idf_component_register(
"sensirion_i2c.c" "sensirion_i2c.c"
"sensirion_i2c_hal.c" "sensirion_i2c_hal.c"
"i2cdev.c" "i2cdev.c"
"sen5x_app.c"
INCLUDE_DIRS INCLUDE_DIRS
"." "."
REQUIRES REQUIRES
driver driver
freertos freertos
log log
net_influx
eez_gui
) )
@@ -4,7 +4,7 @@
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/task.h" #include "freertos/task.h"
#include "freertos/queue.h" #include "freertos/queue.h" // bleibt drin (Header-Kompat / ggf. künftig wieder genutzt)
#include "esp_log.h" #include "esp_log.h"
#include "sensirion_i2c_hal.h" #include "sensirion_i2c_hal.h"
@@ -20,23 +20,22 @@
#include <math.h> // NAN, isfinite, lround #include <math.h> // NAN, isfinite, lround
#include "vars.h" #include "vars.h"
// i2cdev API (aus i2cdev.c)
esp_err_t i2cdev_init(void);
esp_err_t i2cdev_done(void);
static const char* TAG = "sen5x_app"; static const char* TAG = "sen5x_app";
/* ====================== Konfiguration ====================== */ /* ====================== Konfiguration ====================== */
#define SEN5X_QUEUE_LEN 16 // Puffergröße für Samples
#define SEN5X_PROD_STACK 4096 #define SEN5X_PROD_STACK 4096
#define SEN5X_CONS_STACK 6144
#define SEN5X_PROD_PRIO 6 // Producer leicht höher priorisiert #define SEN5X_PROD_PRIO 6 // Producer leicht höher priorisiert
#define SEN5X_CONS_PRIO 5
#define INFLUX_INIT_RETRY_MS 1000 // Retry-Intervall bis Influx init // Influx worker runtime (läuft in net_influx.c)
#define INFLUX_FAILS_REDISCOVER 5 // Nach X Fehlern: Re-Init/Rediscovery #define INFLUX_QUEUE_LEN 16
#define INFLUX_TASK_STACK 6144
#define INFLUX_TASK_PRIO 5
#define INFLUX_INIT_RETRY_MS 1000
#define INFLUX_FAILS_REDISCOVER 5
#define INFLUX_BACKOFF_START_MS 2000 #define INFLUX_BACKOFF_START_MS 2000
#define INFLUX_BACKOFF_MAX_MS 300000 #define INFLUX_BACKOFF_MAX_MS 300000
#define INFLUX_HTTP_TIMEOUT_MS 3000
/* ====================== Typen & State ====================== */ /* ====================== Typen & State ====================== */
typedef struct { typedef struct {
@@ -47,11 +46,9 @@ typedef struct {
static bool g_inited = false; static bool g_inited = false;
static bool g_run = false; static bool g_run = false;
static QueueHandle_t g_queue = NULL;
static TaskHandle_t g_task_prod = NULL; static TaskHandle_t g_task_prod = NULL;
static TaskHandle_t g_task_cons = NULL;
// Nur vom Consumer benutzt: // App-Context
static char* g_device_tag = NULL; // z.B. "device=xyz" static char* g_device_tag = NULL; // z.B. "device=xyz"
/* ====================== Helfer ====================== */ /* ====================== Helfer ====================== */
@@ -119,6 +116,26 @@ static int16_t sen5x_read_measured_pm_values_float(float* pm1, float* pm2,
return 0; return 0;
} }
/* ====================== App-Context: Device Tag ====================== */
static esp_err_t make_device_tag_once(void) {
if (g_device_tag) return ESP_OK;
char* dev = NULL;
if (storage_load_device_name(&dev) && dev && dev[0]) {
size_t need = strlen("device=") + strlen(dev) + 1;
g_device_tag = (char*)malloc(need);
if (!g_device_tag) {
if (dev) free(dev);
return ESP_ERR_NO_MEM;
}
snprintf(g_device_tag, need, "device=%s", dev);
free(dev);
return ESP_OK;
}
g_device_tag = strdup("device=unknown");
return g_device_tag ? ESP_OK : ESP_ERR_NO_MEM;
}
/* ====================== Producer-Task ====================== */ /* ====================== Producer-Task ====================== */
static void sen5x_task_producer(void* arg) { static void sen5x_task_producer(void* arg) {
(void)arg; (void)arg;
@@ -186,121 +203,7 @@ static void sen5x_task_producer(void* arg) {
if (!isfinite(pm1f)) snprintf(buf, sizeof(buf), "nan"); else snprintf(buf, sizeof(buf), "%.1f", (double)pm1f); if (!isfinite(pm1f)) snprintf(buf, sizeof(buf), "nan"); else snprintf(buf, sizeof(buf), "%.1f", (double)pm1f);
set_var_pm1p0(buf); set_var_pm1p0(buf);
// Non-blocking enqueue; bei voller Queue: ältestes raus, neues rein /* === Influx submit (generisch, variabel viele Felder) === */
if (xQueueSend(g_queue, &s, 0) != pdPASS) {
sen5x_sample_t dump;
(void)xQueueReceive(g_queue, &dump, 0); // drop oldest
(void)xQueueSend(g_queue, &s, 0);
}
}
}
vTaskDelayUntil(&last_wake, period); // präzise 1 Hz
}
ESP_LOGI(TAG, "Producer stopping.");
vTaskDelete(NULL);
}
/* ====================== Consumer-Task ====================== */
static esp_err_t make_device_tag_once(void) {
if (g_device_tag) return ESP_OK;
char* dev = NULL;
if (storage_load_device_name(&dev) && dev && dev[0]) {
size_t need = strlen("device=") + strlen(dev) + 1;
g_device_tag = (char*)malloc(need);
if (!g_device_tag) {
if (dev) free(dev);
return ESP_ERR_NO_MEM;
}
snprintf(g_device_tag, need, "device=%s", dev);
free(dev);
return ESP_OK;
}
g_device_tag = strdup("device=unknown");
return g_device_tag ? ESP_OK : ESP_ERR_NO_MEM;
}
static bool influx_init_blocking(void) {
// Warte/Retry bis Influx-Konfig aus NVS (oder Discovery via net_influx_* intern) bereit ist
while (g_run) {
if (net_influx_init_from_nvs(NULL, 3000) == ESP_OK) {
if (make_device_tag_once() == ESP_OK) {
ESP_LOGI(TAG, "Influx ready, device tag: %s", g_device_tag);
return true;
} else {
ESP_LOGE(TAG, "Device-Tag allokation fehlgeschlagen");
return false; // fatal → Task kann enden
}
} else {
ESP_LOGW(TAG, "Influx nicht bereit – retry in %d ms", INFLUX_INIT_RETRY_MS);
vTaskDelay(pdMS_TO_TICKS(INFLUX_INIT_RETRY_MS));
}
}
return false;
}
static bool influx_reinit_with_backoff(uint32_t* backoff_ms) {
if (!backoff_ms) return false;
uint32_t wait_ms = *backoff_ms;
if (wait_ms == 0) wait_ms = INFLUX_BACKOFF_START_MS;
ESP_LOGW(TAG, "Re-Init Influx in %u ms", (unsigned)wait_ms);
vTaskDelay(pdMS_TO_TICKS(wait_ms));
bool ok = (net_influx_init_from_nvs(NULL, 3000) == ESP_OK);
if (ok) {
ESP_LOGI(TAG, "Influx Re-Init OK");
*backoff_ms = INFLUX_BACKOFF_START_MS;
return true;
}
// Exponentielles Backoff bis Max
if (wait_ms < INFLUX_BACKOFF_MAX_MS) {
uint32_t next = wait_ms * 2;
*backoff_ms = (next > INFLUX_BACKOFF_MAX_MS) ? INFLUX_BACKOFF_MAX_MS : next;
}
return false;
}
/* Hilfsfunktion: Felder-String ohne NaNs bauen (Influx lehnt NaN/Inf ab) */
static size_t append_field(char* dst, size_t cap, size_t pos, const char* key, double val, int precision) {
if (!isfinite(val)) return pos; // skip NaN/Inf
int n;
if (pos > 0) {
n = snprintf(dst + pos, (cap > pos) ? (cap - pos) : 0, ",");
pos += (n > 0) ? n : 0;
}
char fmt[16];
// z.B. "%.1f" oder "%.3f"
snprintf(fmt, sizeof(fmt), "%%s=%%.%df", precision);
n = snprintf(dst + pos, (cap > pos) ? (cap - pos) : 0, fmt, key, val);
pos += (n > 0) ? n : 0;
return pos;
}
static void sen5x_task_consumer(void* arg) {
(void)arg;
ESP_LOGI(TAG, "Consumer started.");
if (!influx_init_blocking()) {
ESP_LOGE(TAG, "Consumer beendet (Influx init fatal gescheitert).");
vTaskDelete(NULL);
return;
}
int fail_count = 0;
uint32_t backoff_ms = INFLUX_BACKOFF_START_MS;
for (; g_run; ) {
sen5x_sample_t s;
if (xQueueReceive(g_queue, &s, portMAX_DELAY) != pdTRUE) {
continue;
}
// Skaliere (physikalische Einheiten)
const double pm1 = (s.pm1p0 == 0xFFFF) ? NAN : ((double)s.pm1p0 / 10.0); const double pm1 = (s.pm1p0 == 0xFFFF) ? NAN : ((double)s.pm1p0 / 10.0);
const double pm2_5 = (s.pm2p5 == 0xFFFF) ? NAN : ((double)s.pm2p5 / 10.0); const double pm2_5 = (s.pm2p5 == 0xFFFF) ? NAN : ((double)s.pm2p5 / 10.0);
const double pm4 = (s.pm4p0 == 0xFFFF) ? NAN : ((double)s.pm4p0 / 10.0); const double pm4 = (s.pm4p0 == 0xFFFF) ? NAN : ((double)s.pm4p0 / 10.0);
@@ -310,48 +213,34 @@ static void sen5x_task_consumer(void* arg) {
const double temp = (double)s.temp_c; const double temp = (double)s.temp_c;
const double rh = (double)s.rh_pct; const double rh = (double)s.rh_pct;
// Felder dynamisch ohne NaNs zusammenbauen net_influx_field_t f[] = {
char fields[256]; { .key="pm1", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=pm1 },
size_t pos = 0; { .key="pm2_5", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=pm2_5 },
pos = append_field(fields, sizeof(fields), pos, "pm1", pm1, 1); { .key="pm4", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=pm4 },
pos = append_field(fields, sizeof(fields), pos, "pm2_5", pm2_5, 1); { .key="pm10", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=pm10 },
pos = append_field(fields, sizeof(fields), pos, "pm4", pm4, 1); { .key="temp", .type=NET_INFLUX_F_FLOAT, .precision=3, .v.f=temp },
pos = append_field(fields, sizeof(fields), pos, "pm10", pm10, 1); { .key="rh", .type=NET_INFLUX_F_FLOAT, .precision=3, .v.f=rh },
pos = append_field(fields, sizeof(fields), pos, "temp", temp, 3); { .key="voc", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=voc },
pos = append_field(fields, sizeof(fields), pos, "rh", rh, 3); { .key="nox", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=nox },
pos = append_field(fields, sizeof(fields), pos, "voc", voc, 1); };
pos = append_field(fields, sizeof(fields), pos, "nox", nox, 1);
if (pos == 0) { net_influx_point_t p = {
// Nichts valides → überspringen .measurement = "air",
ESP_LOGW(TAG, "Skipping write: no finite fields."); .tags = g_device_tag ? g_device_tag : "device=unknown",
continue; .ts_ms = 0, // Serverzeit
} .fields = f,
fields[(pos < sizeof(fields)) ? pos : sizeof(fields) - 1] = '\0'; .num_fields = sizeof(f) / sizeof(f[0]),
};
// Ohne Timestamp (0) → Influx vergibt Serverzeit. precision=ms im HTTP-Client ist ok. (void)net_influx_submit_point(&p);
esp_err_t e = net_influx_write_fields(
"air",
g_device_tag ? g_device_tag : "device=unknown",
0 /* ts_ms */,
"%s",
fields
);
if (e == ESP_OK) {
if (fail_count) ESP_LOGI(TAG, "Influx write recovered.");
fail_count = 0;
backoff_ms = INFLUX_BACKOFF_START_MS;
} else {
ESP_LOGW(TAG, "Influx write failed: %s", esp_err_to_name(e));
if (++fail_count >= INFLUX_FAILS_REDISCOVER) {
(void)influx_reinit_with_backoff(&backoff_ms);
fail_count = 0;
}
} }
} }
ESP_LOGI(TAG, "Consumer stopping."); vTaskDelayUntil(&last_wake, period); // präzise 1 Hz
}
ESP_LOGI(TAG, "Producer stopping.");
g_task_prod = NULL;
vTaskDelete(NULL); vTaskDelete(NULL);
} }
@@ -366,7 +255,7 @@ esp_err_t sen5x_app_init(const sen5x_i2c_cfg_t* cfg) {
ESP_LOGI(TAG, "Initializing SEN5x app..."); ESP_LOGI(TAG, "Initializing SEN5x app...");
// 1) I2C-Subsystem // 1) I2C-Subsystem
CHECK_ESP_OR_RET(i2cdev_init());
// 2) HAL-Konfiguration // 2) HAL-Konfiguration
struct esp32_i2c_config hal_cfg = { struct esp32_i2c_config hal_cfg = {
@@ -388,15 +277,22 @@ esp_err_t sen5x_app_init(const sen5x_i2c_cfg_t* cfg) {
CHECK_SEN_OR_RET(sen5x_start_measurement()); CHECK_SEN_OR_RET(sen5x_start_measurement());
ESP_LOGI(TAG, "Measurement started."); ESP_LOGI(TAG, "Measurement started.");
// 5) Queue + Run-Flag // 5) Device Tag (App-Kontext)
g_queue = xQueueCreate(SEN5X_QUEUE_LEN, sizeof(sen5x_sample_t)); CHECK_ESP_OR_RET(make_device_tag_once());
if (!g_queue) {
ESP_LOGE(TAG, "xQueueCreate failed"); // 6) Influx Worker starten (Influx-spezifische Init/Retry/Backoff läuft intern)
sen5x_stop_measurement(); net_influx_runtime_cfg_t rt = {
sensirion_i2c_hal_free(); .queue_len = INFLUX_QUEUE_LEN,
i2cdev_done(); .task_stack = INFLUX_TASK_STACK,
return ESP_ERR_NO_MEM; .task_prio = INFLUX_TASK_PRIO,
} .init_retry_ms = INFLUX_INIT_RETRY_MS,
.backoff_start_ms = INFLUX_BACKOFF_START_MS,
.backoff_max_ms = INFLUX_BACKOFF_MAX_MS,
.fails_before_reinit = INFLUX_FAILS_REDISCOVER,
.ca_cert_pem_opt = NULL,
.http_timeout_ms = INFLUX_HTTP_TIMEOUT_MS,
};
CHECK_ESP_OR_RET(net_influx_start(&rt));
g_run = true; g_run = true;
g_inited = true; g_inited = true;
@@ -408,42 +304,38 @@ void sen5x_app_deinit(void) {
ESP_LOGI(TAG, "Deinitializing SEN5x app..."); ESP_LOGI(TAG, "Deinitializing SEN5x app...");
// Tasks stoppen
g_run = false; g_run = false;
for (int i = 0; i < 50 && g_task_prod; i++) {
vTaskDelay(pdMS_TO_TICKS(10));
}
if (g_task_prod) { if (g_task_prod) {
vTaskDelete(g_task_prod); ESP_LOGW(TAG, "Producer did not stop in time; skip sen5x_stop_measurement/HAL free");
g_task_prod = NULL; // Hier NICHT sen5x_stop_measurement() / HAL free, weil Task evtl. noch I2C nutzt
} return;
if (g_task_cons) {
vTaskDelete(g_task_cons);
g_task_cons = NULL;
} }
// Queue net_influx_stop();
if (g_queue) {
vQueueDelete(g_queue);
g_queue = NULL;
}
// Influx Tag
if (g_device_tag) { if (g_device_tag) {
free(g_device_tag); free(g_device_tag);
g_device_tag = NULL; g_device_tag = NULL;
} }
// Sensor stoppen & HAL freigeben
sen5x_stop_measurement(); sen5x_stop_measurement();
sensirion_i2c_hal_free(); sensirion_i2c_hal_free();
i2cdev_done();
// i2cdev_done(); // NICHT hier, da Bus global genutzt wird
g_inited = false; g_inited = false;
ESP_LOGI(TAG, "SEN5x app deinitialized."); ESP_LOGI(TAG, "SEN5x app deinitialized.");
} }
/** /**
* Kompatibilität zur bisherigen main.c: * Kompatibilität zur bisherigen main.c:
* Diese Task fungiert nun als "Launcher": startet Producer & Consumer und beendet sich dann. * Diese Task fungiert nun als "Launcher": startet Producer und beendet sich dann.
* In main.c bleibt der Aufruf von xTaskCreate(sen5x_app_task, ...) unverändert. * In main.c bleibt der Aufruf von xTaskCreate(sen5x_app_task, ...) unverändert.
*/ */
void sen5x_app_task(void* arg) { void sen5x_app_task(void* arg) {
@@ -455,20 +347,14 @@ void sen5x_app_task(void* arg) {
return; return;
} }
// Producer / Consumer starten // Producer starten
if (xTaskCreate(sen5x_task_producer, "sen5x_prod", SEN5X_PROD_STACK, NULL, SEN5X_PROD_PRIO, &g_task_prod) != pdPASS) { if (xTaskCreate(sen5x_task_producer, "sen5x_prod",
SEN5X_PROD_STACK, NULL, SEN5X_PROD_PRIO, &g_task_prod) != pdPASS) {
ESP_LOGE(TAG, "Failed to create producer task"); ESP_LOGE(TAG, "Failed to create producer task");
vTaskDelete(NULL); vTaskDelete(NULL);
return; return;
} }
if (xTaskCreate(sen5x_task_consumer, "sen5x_cons", SEN5X_CONS_STACK, NULL, SEN5X_CONS_PRIO, &g_task_cons) != pdPASS) {
ESP_LOGE(TAG, "Failed to create consumer task");
vTaskDelete(g_task_prod);
g_task_prod = NULL;
vTaskDelete(NULL);
return;
}
ESP_LOGI(TAG, "Launcher done (producer+consumer started)."); ESP_LOGI(TAG, "Launcher done (producer started).");
vTaskDelete(NULL); // Launcher beendet sich selbst vTaskDelete(NULL); // Launcher beendet sich selbst
} }
+109 -63
View File
@@ -1,4 +1,5 @@
// File: sensirion_i2c_hal.c // File: sensirion_i2c_hal.c
#include "sensirion_i2c_hal.h" #include "sensirion_i2c_hal.h"
#include "sensirion_common.h" #include "sensirion_common.h"
#include "sensirion_config.h" #include "sensirion_config.h"
@@ -7,35 +8,57 @@
#include <freertos/FreeRTOS.h> #include <freertos/FreeRTOS.h>
#include <freertos/task.h> #include <freertos/task.h>
#include <string.h> #include <string.h>
#include <inttypes.h> // für PRIu32 #include <inttypes.h>
#include "sensirion_i2c_esp32_config.h" #include "sensirion_i2c_esp32_config.h"
static const char* TAG = "sensirion_i2c_hal"; static const char* TAG = "sensirion_i2c_hal";
#define SLEEP_MS(x) \ #define SLEEP_MS(ms) vTaskDelay(((ms) + portTICK_PERIOD_MS - 1) / portTICK_PERIOD_MS)
vTaskDelay(((x) + portTICK_PERIOD_MS - 1) / portTICK_PERIOD_MS)
// Lokaler I2C-Gerätekontext aus i2cdev /*
* Sensirion HAL uses int8_t return codes:
* - 0 (NO_ERROR) on success
* - !=0 on failure
*
* sensirion_common.h defines only NO_ERROR and NOT_IMPLEMENTED_ERROR,
* so we provide one stable generic error that fits in int8_t.
*/
#define SENSIRION_I2C_HAL_ERROR ((int8_t)-1)
// Global (single) i2cdev device context
static i2c_dev_t dev = {0}; static i2c_dev_t dev = {0};
static struct esp32_i2c_config i2c_cfg = {0}; static struct esp32_i2c_config i2c_cfg = {0};
static esp_err_t i2c_ok = ESP_OK; static esp_err_t i2c_ok = ESP_OK;
static int8_t sensirion_map_esp_err(esp_err_t err) {
return (err == ESP_OK) ? (int8_t)NO_ERROR : SENSIRION_I2C_HAL_ERROR;
}
/**
* Select the current i2c bus by index.
* Optional for single-bus setups.
*/
int16_t sensirion_i2c_hal_select_bus(uint8_t bus_idx) { int16_t sensirion_i2c_hal_select_bus(uint8_t bus_idx) {
// Multi-Bus-Support: Port umschalten (optional, für Single-Bus reicht das so) /*
dev.port = bus_idx; * NOTE:
i2c_cfg.port = bus_idx; * - This only switches the I2C port number.
* - If "bus_idx" implies different pins/frequency, update i2c_cfg accordingly
* and call sensirion_i2c_hal_init() again.
*/
dev.port = (i2c_port_t)bus_idx;
i2c_cfg.port = (i2c_port_t)bus_idx;
ESP_LOGI(TAG, "Selected I2C bus index/port: %u", (unsigned)bus_idx); ESP_LOGI(TAG, "Selected I2C bus index/port: %u", (unsigned)bus_idx);
return NO_ERROR; // 0 return NO_ERROR;
} }
esp_err_t sensirion_i2c_config_esp32(struct esp32_i2c_config* cfg) { esp_err_t sensirion_i2c_config_esp32(struct esp32_i2c_config* cfg) {
if (cfg != NULL) { if (cfg == NULL) {
return ESP_ERR_INVALID_ARG;
}
memcpy(&i2c_cfg, cfg, sizeof(*cfg)); memcpy(&i2c_cfg, cfg, sizeof(*cfg));
return ESP_OK; return ESP_OK;
} else {
return ESP_FAIL;
}
} }
esp_err_t sensirion_i2c_esp32_ok(void) { esp_err_t sensirion_i2c_esp32_ok(void) {
@@ -47,30 +70,38 @@ esp_err_t sensirion_i2c_esp32_ok(void) {
* communication. * communication.
*/ */
void sensirion_i2c_hal_init(void) { void sensirion_i2c_hal_init(void) {
memset(&dev, 0, sizeof(i2c_dev_t)); memset(&dev, 0, sizeof(dev));
// Minimal sanity check
if (i2c_cfg.freq == 0) {
ESP_LOGE(TAG, "Invalid I2C frequency: 0 Hz");
i2c_ok = ESP_ERR_INVALID_ARG;
return;
}
// i2cdev supports 7-bit and 10-bit; Sensirion drivers use 7-bit addresses.
dev.addr_bit_len = I2C_ADDR_BIT_LEN_7;
// Port & Pins/Frequenz aus der App-Konfiguration übernehmen
dev.port = i2c_cfg.port; dev.port = i2c_cfg.port;
// Pins: i2cdev supports -1 meaning "use Kconfig default"
dev.cfg.sda_io_num = i2c_cfg.sda; dev.cfg.sda_io_num = i2c_cfg.sda;
dev.cfg.scl_io_num = i2c_cfg.scl; dev.cfg.scl_io_num = i2c_cfg.scl;
dev.cfg.sda_pullup_en = i2c_cfg.sda_pullup; dev.cfg.sda_pullup_en = i2c_cfg.sda_pullup;
dev.cfg.scl_pullup_en = i2c_cfg.scl_pullup; dev.cfg.scl_pullup_en = i2c_cfg.scl_pullup;
#if HELPER_TARGET_IS_ESP32
dev.cfg.master.clk_speed = i2c_cfg.freq; // Gerätespezifische Busgeschwindigkeit
#endif
// Mutex anlegen & Gerät registrieren (i2cdev kümmert sich um Bus-Setup on-demand) dev.cfg.master.clk_speed = (uint32_t)i2c_cfg.freq;
esp_err_t err = i2c_dev_create_mutex(&dev); esp_err_t err = i2c_dev_create_mutex(&dev);
if (err == ESP_OK) { if (err == ESP_OK) {
ESP_LOGI(TAG, ESP_LOGI(TAG,
"Sensirion I2C HAL ready. Addr: 0x%02x Port: %d SDA: %d SCL: %d Freq: %" PRIu32 "Hz", "Sensirion I2C HAL ready. Port=%d SDA=%d SCL=%d Freq=%" PRIu32 " Hz",
i2c_cfg.addr, i2c_cfg.port, i2c_cfg.sda, i2c_cfg.scl, (int)i2c_cfg.port, (int)i2c_cfg.sda, (int)i2c_cfg.scl, (uint32_t)i2c_cfg.freq);
(uint32_t)i2c_cfg.freq);
} else { } else {
ESP_LOGE(TAG, ESP_LOGE(TAG,
"Sensirion I2C HAL init error! Addr: 0x%02x Port: %d SDA: %d SCL: %d (err=%s)", "Sensirion I2C HAL init error. Port=%d SDA=%d SCL=%d (err=%s)",
i2c_cfg.addr, i2c_cfg.port, i2c_cfg.sda, i2c_cfg.scl, (int)i2c_cfg.port, (int)i2c_cfg.sda, (int)i2c_cfg.scl, esp_err_to_name(err));
esp_err_to_name(err));
} }
i2c_ok = err; i2c_ok = err;
@@ -80,7 +111,6 @@ void sensirion_i2c_hal_init(void) {
* Release all resources initialized by sensirion_i2c_hal_init(). * Release all resources initialized by sensirion_i2c_hal_init().
*/ */
void sensirion_i2c_hal_free(void) { void sensirion_i2c_hal_free(void) {
// Gibt Mutex frei, deregistriert Device & entfernt ggf. Bus-Handle wenn letztes Gerät (siehe i2cdev.c)
esp_err_t err = i2c_dev_delete_mutex(&dev); esp_err_t err = i2c_dev_delete_mutex(&dev);
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_LOGW(TAG, "i2c_dev_delete_mutex failed: %s", esp_err_to_name(err)); ESP_LOGW(TAG, "i2c_dev_delete_mutex failed: %s", esp_err_to_name(err));
@@ -88,71 +118,87 @@ void sensirion_i2c_hal_free(void) {
} }
/** /**
* Execute one read transaction on the I2C bus, reading a given number of bytes. * Execute one read transaction on the I2C bus.
* If the device does not acknowledge the read command, an error shall be
* returned.
* *
* @param address 7-bit I2C address to read from
* @param data pointer to the buffer where the data is to be stored
* @param count number of bytes to read from I2C and store in the buffer
* @returns 0 on success, error code otherwise * @returns 0 on success, error code otherwise
*/ */
int8_t sensirion_i2c_hal_read(uint8_t address, uint8_t* data, uint16_t count) { int8_t sensirion_i2c_hal_read(uint8_t address, uint8_t* data, uint16_t count) {
ESP_LOGD(TAG, "sensirion_i2c_hal_read: addr=0x%02x len=%u", address, (unsigned)count); if (count > 0 && data == NULL) {
return SENSIRION_I2C_HAL_ERROR;
}
dev.addr = address; dev.addr = address;
I2C_DEV_TAKE_MUTEX(&dev); esp_err_t err = i2c_dev_take_mutex(&dev);
esp_err_t err = i2c_dev_read(&dev, NULL, 0, data, count); if (err != ESP_OK) {
I2C_DEV_GIVE_MUTEX(&dev); ESP_LOGW(TAG, "take_mutex failed: %s", esp_err_to_name(err));
i2c_ok = err;
return sensirion_map_esp_err(err);
}
err = i2c_dev_read(&dev, NULL, 0, data, (size_t)count);
esp_err_t give_err = i2c_dev_give_mutex(&dev);
if (give_err != ESP_OK) {
ESP_LOGW(TAG, "give_mutex failed: %s", esp_err_to_name(give_err));
i2c_ok = give_err;
return sensirion_map_esp_err(give_err);
}
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_LOGW(TAG, "READ failed (addr=0x%02x, len=%u): %s", address, (unsigned)count, esp_err_to_name(err)); ESP_LOGW(TAG, "I2C READ failed addr=0x%02x len=%u: %s",
return (int8_t)err; // non-zero -> Fehler address, (unsigned)count, esp_err_to_name(err));
i2c_ok = err;
} }
// ESP_LOGV(TAG, "READ OK");
return (int8_t)NO_ERROR; // 0 return sensirion_map_esp_err(err);
} }
/** /**
* Execute one write transaction on the I2C bus, sending a given number of * Execute one write transaction on the I2C bus.
* bytes.
* *
* @param address 7-bit I2C address to write to
* @param data pointer to the buffer containing the data to write
* @param count number of bytes to send over I2C
* @returns 0 on success, error code otherwise * @returns 0 on success, error code otherwise
*/ */
int8_t sensirion_i2c_hal_write(uint8_t address, const uint8_t* data, int8_t sensirion_i2c_hal_write(uint8_t address, const uint8_t* data, uint16_t count) {
uint16_t count) { if (count > 0 && data == NULL) {
ESP_LOGD(TAG, "sensirion_i2c_hal_write: addr=0x%02x len=%u", address, (unsigned)count); return SENSIRION_I2C_HAL_ERROR;
}
dev.addr = address; dev.addr = address;
I2C_DEV_TAKE_MUTEX(&dev); esp_err_t err = i2c_dev_take_mutex(&dev);
esp_err_t err = i2c_dev_write(&dev, NULL, 0, data, count); if (err != ESP_OK) {
I2C_DEV_GIVE_MUTEX(&dev); ESP_LOGW(TAG, "take_mutex failed: %s", esp_err_to_name(err));
i2c_ok = err;
return sensirion_map_esp_err(err);
}
err = i2c_dev_write(&dev, NULL, 0, data, (size_t)count);
esp_err_t give_err = i2c_dev_give_mutex(&dev);
if (give_err != ESP_OK) {
ESP_LOGW(TAG, "give_mutex failed: %s", esp_err_to_name(give_err));
i2c_ok = give_err;
return sensirion_map_esp_err(give_err);
}
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_LOGW(TAG, "WRITE failed (addr=0x%02x, len=%u): %s", address, (unsigned)count, esp_err_to_name(err)); ESP_LOGW(TAG, "I2C WRITE failed addr=0x%02x len=%u: %s",
return (int8_t)err; // non-zero -> Fehler address, (unsigned)count, esp_err_to_name(err));
i2c_ok = err;
} }
// ESP_LOGV(TAG, "WRITE OK");
return (int8_t)NO_ERROR; // 0 return sensirion_map_esp_err(err);
} }
/** /**
* Sleep for a given number of microseconds. The function should delay the * Sleep for a given number of microseconds.
* execution for at least the given time, but may also sleep longer.
*
* Despite the unit, a <10 millisecond precision is sufficient. * Despite the unit, a <10 millisecond precision is sufficient.
*
* @param useconds the sleep time in microseconds
*/ */
void sensirion_i2c_hal_sleep_usec(uint32_t useconds) { void sensirion_i2c_hal_sleep_usec(uint32_t useconds) {
ESP_LOGV(TAG, "sensirion_i2c_hal_sleep: %" PRIu32 " usec", useconds); // at-least semantics: ceil to milliseconds
// Tick-basiert schlafen (µs->ms), Genauigkeit im Bereich <10 ms ist ausreichend uint32_t ms = (useconds + 999U) / 1000U;
uint32_t ms = useconds / 1000U;
if (ms == 0 && useconds > 0) { if (ms == 0 && useconds > 0) {
// Mindestens 1 Tick warten, wenn >0µs angefordert, um aktives Busy-Wait zu vermeiden
ms = 1; ms = 1;
} }
SLEEP_MS(ms); SLEEP_MS(ms);
@@ -0,0 +1,8 @@
idf_component_register(
SRCS
"src/sys_status.c"
INCLUDE_DIRS
"include"
REQUIRES
)
@@ -1,3 +1,4 @@
// File: firmware/components/sys_status/include/sys_status.h
#pragma once #pragma once
#include <stdbool.h> #include <stdbool.h>
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
@@ -1,8 +1,10 @@
#include "sys_status.h" // Field: firmware/components/sys_status/src/sys_status.c
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h" #include "freertos/event_groups.h"
#include "esp_check.h" #include "esp_check.h"
#include "sys_status.h"
static EventGroupHandle_t s_status_group = NULL; static EventGroupHandle_t s_status_group = NULL;
void sys_status_init(void) void sys_status_init(void)
@@ -0,0 +1,16 @@
idf_component_register(
SRCS
"src/wifi_mgr.c"
INCLUDE_DIRS
"include"
REQUIRES
esp_wifi
esp_event
esp_netif
esp_timer
lwip
storage
net_mdns
sys_status
dns_captive
)
@@ -17,7 +17,6 @@
#include "lwip/netdb.h" #include "lwip/netdb.h"
#include "http_portal.h"
#include "wifi_mgr.h" #include "wifi_mgr.h"
#include "storage.h" #include "storage.h"
#include "net_mdns.h" #include "net_mdns.h"
@@ -233,8 +232,6 @@ static void wifi_event_handler(void* arg, esp_event_base_t base, int32_t id, voi
ESP_LOGI(TAG, "STA got IP: " IPSTR, IP2STR(&e->ip_info.ip)); ESP_LOGI(TAG, "STA got IP: " IPSTR, IP2STR(&e->ip_info.ip));
xEventGroupSetBits(wifi_events, EVT_STA_GOTIP); xEventGroupSetBits(wifi_events, EVT_STA_GOTIP);
xTaskCreate(mdns_discover_task, "mdns_discover", 3072, NULL, 4, NULL);
if (ap_off_timer) { if (ap_off_timer) {
if (esp_timer_is_active(ap_off_timer)) esp_timer_stop(ap_off_timer); if (esp_timer_is_active(ap_off_timer)) esp_timer_stop(ap_off_timer);
ESP_ERROR_CHECK(esp_timer_start_once(ap_off_timer, 10 * 1000 * 1000)); // 10 s ESP_ERROR_CHECK(esp_timer_start_once(ap_off_timer, 10 * 1000 * 1000)); // 10 s
@@ -354,31 +351,3 @@ static void ap_set_dhcp_dns_to_self(void) {
&ip.ip, sizeof(ip.ip)); &ip.ip, sizeof(ip.ip));
esp_netif_dhcps_start(netif_ap); esp_netif_dhcps_start(netif_ap);
} }
// Task für mDNS-Discover ---
static void mdns_discover_task(void *arg) {
// Start/ensure mDNS läuft
(void)net_mdns_autostart_init(NULL, NULL);
const TickType_t kDelay = pdMS_TO_TICKS(60000); // 60 s
for (;;) {
// Erst offizieller Service, dann Fallback auf HTTP:8086
esp_err_t err = net_mdns_autodiscover_and_store("_myapp", "_tcp", -1,
NULL, NULL, 2000);
if (err != ESP_OK) {
err = net_mdns_autodiscover_and_store("_http", "_tcp", 8086,
NULL, NULL, 2000);
}
if (err == ESP_OK) {
sys_status_set_mdns_ok(true);
ESP_LOGI(TAG, "mDNS: Service gefunden und gespeichert. Beende Re-Try-Task.");
vTaskDelete(NULL); // fertig, keine weiteren Versuche
} else {
sys_status_set_mdns_ok(false);
ESP_LOGW(TAG, "mDNS: nichts gefunden – neuer Versuch in 60 s");
vTaskDelay(kDelay);
}
}
}
-5
View File
@@ -1,11 +1,6 @@
set(app_sources set(app_sources
"main.c" "main.c"
"lv_fs_port.c" "lv_fs_port.c"
"net_influx.c"
"net_mdns.c"
"sen5x_app.c"
"sys_status.c"
"wifi_mgr.c"
) )
idf_component_register( idf_component_register(
+47 -8
View File
@@ -45,6 +45,10 @@
#include "dns_captive.h" #include "dns_captive.h"
#include "http_portal.h" #include "http_portal.h"
#include "net_mdns.h"
#include "esp_timer.h"
// --- Callback-Implementierungen für das Portal --- // --- Callback-Implementierungen für das Portal ---
static bool app_load_sta_creds(char **ssid, char **pass) static bool app_load_sta_creds(char **ssid, char **pass)
@@ -150,6 +154,16 @@ static lv_indev_t *lvgl_touch_indev = NULL;
/* --- Button Handle global halten, falls benötigt --- */ /* --- Button Handle global halten, falls benötigt --- */
static button_handle_t g_btn = NULL; static button_handle_t g_btn = NULL;
static void app_update_mdns_status_from_nvs(void)
{
char *url = NULL;
bool ok = storage_load_service_url(&url);
sys_status_set_mdns_ok(ok && url && url[0]); // nur mDNS
if (url) free(url);
}
/* Vorwärtsdeklarationen */ /* Vorwärtsdeklarationen */
void lv_fs_fatfs_init(void); void lv_fs_fatfs_init(void);
static esp_err_t app_lvgl_init(void); static esp_err_t app_lvgl_init(void);
@@ -223,6 +237,7 @@ static esp_err_t app_lvgl_init(void)
static void ui_tick_cb(lv_timer_t *t) { static void ui_tick_cb(lv_timer_t *t) {
(void)t; (void)t;
app_update_mdns_status_from_nvs();
if (lvgl_port_lock(0)) { if (lvgl_port_lock(0)) {
ui_update_status_icons(); ui_update_status_icons();
tick_screen(0); tick_screen(0);
@@ -335,6 +350,7 @@ static void button_init(void)
/* ==================== main ==================== */ /* ==================== main ==================== */
void app_main(void) void app_main(void)
{ {
/*
esp_log_level_set("storage", ESP_LOG_NONE); esp_log_level_set("storage", ESP_LOG_NONE);
esp_log_level_set("*", ESP_LOG_NONE); esp_log_level_set("*", ESP_LOG_NONE);
@@ -343,7 +359,7 @@ void app_main(void)
sys_status_set_wifi_ok(false); sys_status_set_wifi_ok(false);
sys_status_set_influx_ok(false); sys_status_set_influx_ok(false);
sys_status_set_mdns_ok(false); sys_status_set_mdns_ok(false);
*/
// NVS zuerst // NVS zuerst
esp_err_t ret = nvs_flash_init(); esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) { if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
@@ -360,12 +376,10 @@ void app_main(void)
ESP_ERROR_CHECK(i2cdev_init()); ESP_ERROR_CHECK(i2cdev_init());
// I2C-Bus initialisieren (bsp_i2c.h)
i2c_master_bus_handle_t i2c_bus_handle = bsp_i2c_init(); i2c_master_bus_handle_t i2c_bus_handle = bsp_i2c_init();
// Diesen Bus von i2cdev "adoptieren", damit SEN5x denselben Bus nutzt ESP_ERROR_CHECK(i2cdev_adopt_bus(I2C_PORT_NUM, i2c_bus_handle,
ESP_ERROR_CHECK(i2cdev_adopt_bus(0, i2c_bus_handle, 18, 19)); // Port 0, SDA=18, SCL=19 EXAMPLE_PIN_I2C_SDA, EXAMPLE_PIN_I2C_SCL));
// Restliche Peripherie // Restliche Peripherie
bsp_spi_init(); bsp_spi_init();
bsp_battery_init(); bsp_battery_init();
@@ -393,6 +407,31 @@ void app_main(void)
// WiFi AP+STA starten // WiFi AP+STA starten
wifi_mgr_start(); wifi_mgr_start();
// --- mDNS: Autostart (startet bei STA_GOT_IP automatisch) ---
ESP_ERROR_CHECK(net_mdns_autostart_init(NULL, NULL));
// --- mDNS: Service-Discovery mit Retry (ersetzt mdns_discover_task in wifi_mgr) ---
net_mdns_discover_cfg_t mdns_cfg = {
.service = "_influxdb2",
.proto = "_tcp",
.enforce_port = 8086,
.fallback_service = "_http",
.fallback_proto = "_tcp",
.fallback_port = 8086,
.txt_key = NULL,
.txt_value = NULL,
.query_timeout_ms = 2000,
.retry_interval_ms = 60000,
.max_results = 5,
.instance_prefix = NULL,
.require_instance_prefix = false
};
ESP_ERROR_CHECK(net_mdns_autodiscover_start(&mdns_cfg));
// AP-Netif an DNS weitergeben // AP-Netif an DNS weitergeben
dns_captive_set_ap_netif(wifi_mgr_get_ap_netif()); dns_captive_set_ap_netif(wifi_mgr_get_ap_netif());
// Captive-DNS starten // Captive-DNS starten
@@ -415,9 +454,9 @@ void app_main(void)
// SEN5x // SEN5x
const sen5x_i2c_cfg_t cfg = { const sen5x_i2c_cfg_t cfg = {
.addr = 0x69, .addr = 0x69,
.port = 0, .port = I2C_PORT_NUM,
.sda = 18, .sda = EXAMPLE_PIN_I2C_SDA,
.scl = 19, .scl = EXAMPLE_PIN_I2C_SCL,
.sda_pullup = true, .sda_pullup = true,
.scl_pullup = true, .scl_pullup = true,
.freq = 400000 .freq = 400000
-318
View File
@@ -1,318 +0,0 @@
// File: src/net_influx.c
#include "storage.h"
#include "net_influx.h"
#include "esp_http_client.h"
#include "esp_err.h"
#include "esp_log.h"
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
#include <stdlib.h>
#include "sys_status.h"
static const char* TAG = "net_influx";
/* ---------------- State (mit internen Kopien!) ---------------- */
typedef struct {
char url_base[128];
char org[64];
char bucket[64];
char token[512]; // lang genug für Influx Token
bool use_tls;
const char* ca_cert_pem;
int http_timeout_ms;
} net_influx_state_t;
static net_influx_state_t s = {0};
/* ---------------- Utils ---------------- */
static void trim_inplace(char* p) {
if (!p) return;
size_t len = strlen(p);
size_t a = 0, b = len;
while (a < b && (isspace((unsigned char)p[a]) || p[a] == '\"')) a++;
while (b > a && (isspace((unsigned char)p[b-1]) || p[b-1] == '\"' || p[b-1] == '/')) b--;
if (a || b != len) {
memmove(p, p + a, b - a);
p[b - a] = 0;
}
}
static void safe_copy(char* dst, size_t dst_sz, const char* src) {
if (!dst || dst_sz == 0) return;
if (!src) { dst[0] = 0; return; }
strncpy(dst, src, dst_sz - 1);
dst[dst_sz - 1] = 0;
}
typedef struct {
bool tls; // http=false, https=true
char host[64];
int port; // -1 = nicht angegeben
} base_parts_t;
// erwartet: "http://host:port" oder "host:port" oder "host"
static bool parse_base_url(const char* in, base_parts_t* out) {
if (!in || !*in || !out) return false;
char buf[128];
safe_copy(buf, sizeof(buf), in);
trim_inplace(buf);
const char* p = buf;
out->tls = false;
out->port = -1;
memset(out->host, 0, sizeof(out->host));
if (strncasecmp(p, "http://", 7) == 0) { p += 7; out->tls = false; }
else if (strncasecmp(p, "https://", 8) == 0) { p += 8; out->tls = true; }
const char* colon = strchr(p, ':');
if (colon) {
size_t host_len = (size_t)(colon - p);
if (host_len == 0 || host_len >= sizeof(out->host)) return false;
memcpy(out->host, p, host_len);
out->host[host_len] = 0;
const char* port_str = colon + 1;
if (!*port_str) return false;
int port = 0;
while (*port_str && isdigit((unsigned char)*port_str)) {
port = port * 10 + (*port_str - '0');
port_str++;
}
if (*port_str != 0) return false; // kein weiterer Kram erlaubt
out->port = port;
} else {
size_t host_len = strlen(p);
if (host_len == 0 || host_len >= sizeof(out->host)) return false;
memcpy(out->host, p, host_len);
out->host[host_len] = 0;
}
return true;
}
static void mask_token(const char* token, char* out, size_t out_len) {
if (!token || !out || out_len < 8) return;
size_t n = strlen(token);
if (n <= 8) {
snprintf(out, out_len, "****");
} else {
size_t keep = 4;
snprintf(out, out_len, "%.*s****%.*s",
(int)keep, token,
(int)keep, token + n - keep);
}
}
/* ---------------- HTTP Event Handler (IDF-kompatibel) ---------------- */
static esp_err_t http_evt(esp_http_client_event_t* evt) {
switch (evt->event_id) {
case HTTP_EVENT_ERROR: ESP_LOGE(TAG, "HTTP_EVENT_ERROR"); break;
case HTTP_EVENT_ON_CONNECTED: ESP_LOGI(TAG, "HTTP_EVENT_ON_CONNECTED"); break;
case HTTP_EVENT_HEADER_SENT: ESP_LOGD(TAG, "HTTP_EVENT_HEADER_SENT"); break;
case HTTP_EVENT_ON_HEADER:
ESP_LOGD(TAG, "HDR: %s: %s",
evt->header_key ? evt->header_key : "(null)",
evt->header_value ? evt->header_value : "(null)");
break;
case HTTP_EVENT_ON_DATA: ESP_LOGV(TAG, "DATA chunk len=%d", evt->data_len); break;
case HTTP_EVENT_ON_FINISH: ESP_LOGD(TAG, "HTTP_EVENT_ON_FINISH"); break;
case HTTP_EVENT_DISCONNECTED: ESP_LOGW(TAG, "HTTP_EVENT_DISCONNECTED"); break;
default: break;
}
return ESP_OK;
}
/* ---------------- Public API ---------------- */
esp_err_t net_influx_init(const net_influx_cfg_t* cfg) {
if (!cfg || !cfg->url_base || !cfg->org || !cfg->bucket || !cfg->token) {
return ESP_ERR_INVALID_ARG;
}
safe_copy(s.url_base, sizeof(s.url_base), cfg->url_base);
safe_copy(s.org, sizeof(s.org), cfg->org);
safe_copy(s.bucket, sizeof(s.bucket), cfg->bucket);
safe_copy(s.token, sizeof(s.token), cfg->token);
trim_inplace(s.url_base);
s.use_tls = cfg->use_tls;
s.ca_cert_pem = cfg->ca_cert_pem;
s.http_timeout_ms = (cfg->http_timeout_ms > 0) ? cfg->http_timeout_ms : 3000;
char tok[32] = {0};
mask_token(s.token, tok, sizeof(tok));
ESP_LOGI(TAG, "init: base=\"%s\", org=\"%s\", bucket=\"%s\", tls=%d, timeout=%dms, token=%s",
s.url_base, s.org, s.bucket, (int)s.use_tls, s.http_timeout_ms, tok);
sys_status_set_influx_ok(false);
return ESP_OK;
}
esp_err_t net_influx_write_fields(const char* measurement,
const char* tags,
uint64_t ts_ms,
const char* fields_fmt,
...)
{
// --- Neu: pessimistisch starten ---
bool ok = false;
if (!measurement || !fields_fmt) {
sys_status_set_influx_ok(false); // <—
return ESP_ERR_INVALID_ARG;
}
if (s.url_base[0] == 0 || s.org[0] == 0 || s.bucket[0] == 0 || s.token[0] == 0) {
sys_status_set_influx_ok(false); // <—
return ESP_ERR_INVALID_STATE;
}
// 1) Fields formatieren
char fields[256];
va_list ap;
va_start(ap, fields_fmt);
vsnprintf(fields, sizeof(fields), fields_fmt, ap);
va_end(ap);
// 2) Line Protocol
char line[400];
int off = 0;
off += snprintf(line + off, sizeof(line) - off, "%s", measurement);
if (off < 0 || off >= (int)sizeof(line)) { sys_status_set_influx_ok(false); return ESP_FAIL; } // <—
if (tags && *tags) {
off += snprintf(line + off, sizeof(line) - off, ",%s", tags);
if (off < 0 || off >= (int)sizeof(line)) { sys_status_set_influx_ok(false); return ESP_FAIL; } // <—
}
off += snprintf(line + off, sizeof(line) - off, " %s", fields);
if (off < 0 || off >= (int)sizeof(line)) { sys_status_set_influx_ok(false); return ESP_FAIL; } // <—
if (ts_ms != 0) {
off += snprintf(line + off, sizeof(line) - off, " %llu", (unsigned long long)ts_ms);
if (off < 0 || off >= (int)sizeof(line)) { sys_status_set_influx_ok(false); return ESP_FAIL; } // <—
}
// 3) Base parse → host/port/tls
base_parts_t bp;
if (!parse_base_url(s.url_base, &bp)) {
ESP_LOGE(TAG, "Base-URL ungueltig: \"%s\"", s.url_base);
sys_status_set_influx_ok(false); // <—
return ESP_ERR_INVALID_ARG;
}
if (s.use_tls) bp.tls = true;
int port = (bp.port > 0) ? bp.port : (bp.tls ? 443 : 8086);
// 4) Pfad (Tipp: URL-encoding wenn org/bucket Sonderzeichen haben könnten)
char path[192];
snprintf(path, sizeof(path), "/api/v2/write?org=%s&bucket=%s&precision=ms", s.org, s.bucket);
ESP_LOGI(TAG, "HTTP cfg: host=%s, port=%d, path=%s, tls=%d", bp.host, port, path, (int)bp.tls);
ESP_LOGD(TAG, "Line: %s", line);
// 5) HTTP-Client
esp_http_client_config_t cfg = {
.host = bp.host,
.port = port,
.path = path,
.timeout_ms = s.http_timeout_ms,
.cert_pem = bp.tls ? s.ca_cert_pem : NULL,
.method = HTTP_METHOD_POST,
.event_handler = http_evt,
.transport_type = bp.tls ? HTTP_TRANSPORT_OVER_SSL : HTTP_TRANSPORT_OVER_TCP,
// Optional: stabiler auf schlechten Links
.disable_auto_redirect = false,
};
esp_http_client_handle_t h = esp_http_client_init(&cfg);
if (!h) {
ESP_LOGE(TAG, "http_client_init: no mem");
sys_status_set_influx_ok(false); // <—
return ESP_ERR_NO_MEM;
}
// Header
size_t auth_len = strlen(s.token) + 7; // "Token " + '\0'
char* auth = (char*)malloc(auth_len);
if (!auth) {
ESP_LOGE(TAG, "malloc auth header: no mem");
esp_http_client_cleanup(h);
sys_status_set_influx_ok(false); // <—
return ESP_ERR_NO_MEM;
}
snprintf(auth, auth_len, "Token %s", s.token);
esp_http_client_set_header(h, "Authorization", auth);
free(auth);
esp_http_client_set_header(h, "Content-Type", "text/plain; charset=utf-8");
// Optional hilfreich:
// esp_http_client_set_header(h, "Accept", "application/json");
// esp_http_client_set_header(h, "Connection", "close");
// Body
esp_err_t err = esp_http_client_set_post_field(h, line, (int)strlen(line));
if (err != ESP_OK) {
ESP_LOGE(TAG, "set_post_field: %s", esp_err_to_name(err));
esp_http_client_cleanup(h);
sys_status_set_influx_ok(false); // <—
return err;
}
// 6) Request
err = esp_http_client_perform(h);
int status = -1;
if (err == ESP_OK) {
status = esp_http_client_get_status_code(h);
int64_t cl = esp_http_client_get_content_length(h);
ESP_LOGI(TAG, "HTTP status=%d, content_length=%lld", status, (long long)cl);
if (status != 204) {
char resp[256] = {0};
int n = esp_http_client_read_response(h, resp, sizeof(resp)-1);
if (n > 0) ESP_LOGW(TAG, "Resp(%d): %.*s", status, n, resp);
else ESP_LOGW(TAG, "Resp(%d): <kein Body>", status);
}
} else {
ESP_LOGE(TAG, "perform: %s", esp_err_to_name(err));
}
esp_http_client_cleanup(h);
// --- Wichtig: Flag NACH allem zentral setzen ---
ok = (err == ESP_OK && status == 204);
sys_status_set_influx_ok(ok);
return ok ? ESP_OK : ESP_FAIL;
}
// Aus NVS: URL (service_url), org/bucket/token → net_influx_init()
esp_err_t net_influx_init_from_nvs(const char* ca_cert_pem_opt, int timeout_ms)
{
char *url = NULL, *org = NULL, *bucket = NULL, *token = NULL;
if (!storage_load_service_url(&url)) {
ESP_LOGW(TAG, "keine Service-URL in NVS gefunden (mDNS noch nicht fertig?)");
// Du kannst hier optional einen Default setzen oder ESP_ERR_NOT_FOUND zurückgeben
return ESP_ERR_NOT_FOUND;
}
if (!storage_get_effective_influx(&org, &bucket, &token)) {
ESP_LOGE(TAG, "Influx-Konfiguration aus NVS nicht lesbar");
free(url);
return ESP_FAIL;
}
net_influx_cfg_t cfg = {
.url_base = url, // z.B. "http://192.168.1.10:8086"
.org = org,
.bucket = bucket,
.token = token,
.use_tls = false, // URL-Parser erkennt https automatisch; true erzwingt TLS
.ca_cert_pem = ca_cert_pem_opt,
.http_timeout_ms = (timeout_ms > 0) ? timeout_ms : 3000
};
esp_err_t err = net_influx_init(&cfg);
free(url);
free(org);
free(bucket);
free(token);
return err;
}
-27
View File
@@ -1,27 +0,0 @@
// File: include/net_influx.h
#pragma once
#include <stdint.h>
#include <stdbool.h>
#include "esp_err.h"
typedef struct {
const char* url_base; // "http://host:8086" oder "https://host"
const char* org;
const char* bucket;
const char* token;
bool use_tls; // optional; wenn true => TLS erzwingen
const char* ca_cert_pem; // optional, bei https (kann NULL sein wenn Test)
int http_timeout_ms; // z.B. 3000
} net_influx_cfg_t;
esp_err_t net_influx_init(const net_influx_cfg_t* cfg);
// Convenience: lädt URL/org/bucket/token direkt aus NVS (storage.c)
esp_err_t net_influx_init_from_nvs(const char* ca_cert_pem_opt, int timeout_ms);
// generisches Write (Line Protocol Felderformatierung via printf)
esp_err_t net_influx_write_fields(const char* measurement,
const char* tags, // "k=v,k2=v2" oder NULL
uint64_t ts_ms, // 0 = Serverzeit
const char* fields_fmt,
...);
-180
View File
@@ -1,180 +0,0 @@
#include <string.h>
#include <stdio.h>
#include "esp_log.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "esp_wifi.h" // <— wichtig für WIFI_EVENT
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "mdns.h"
#include "net_mdns.h"
#include "storage.h"
static const char* TAG = "net_mdns";
static char g_hostname[33] = {0};
static char g_instance[33] = {0};
static volatile bool g_mdns_running = false;
esp_err_t net_mdns_autodiscover_and_store(const char *service, const char *proto,
int enforce_port,
const char *txt_key, const char *txt_value,
uint32_t timeout_ms)
{
char url[96] = {0};
bool ok = net_mdns_find_service_url(service, proto, enforce_port,
txt_key, txt_value, timeout_ms, 5,
url, sizeof(url));
if (!ok) {
ESP_LOGW(TAG, "Auto-Discover: kein Treffer für %s.%s", service, proto);
return ESP_ERR_NOT_FOUND;
}
esp_err_t err = storage_save_service_url(url);
if (err == ESP_OK) {
ESP_LOGI(TAG, "Auto-Discover: URL '%s' in NVS gespeichert.", url);
}
return err;
}
static void mdns_start_if_needed(void) {
if (g_mdns_running) return;
esp_err_t err = mdns_init();
if (err != ESP_OK) {
ESP_LOGE(TAG, "mdns_init failed: %s", esp_err_to_name(err));
return;
}
if (g_hostname[0]) mdns_hostname_set(g_hostname);
if (g_instance[0]) mdns_instance_name_set(g_instance);
g_mdns_running = true;
ESP_LOGI(TAG, "mDNS started (host=%s, inst=%s)", g_hostname, g_instance);
}
static void mdns_stop_if_running(void) {
if (!g_mdns_running) return;
mdns_free();
g_mdns_running = false;
ESP_LOGI(TAG, "mDNS stopped");
}
static void on_ip_event(void* arg, esp_event_base_t base, int32_t id, void* data) {
if (base == IP_EVENT && id == IP_EVENT_STA_GOT_IP) {
mdns_start_if_needed();
}
}
static void on_wifi_event(void* arg, esp_event_base_t base, int32_t id, void* data) {
if (base == WIFI_EVENT && id == WIFI_EVENT_STA_DISCONNECTED) {
mdns_stop_if_running();
}
}
esp_err_t net_mdns_autostart_init(const char* hostname, const char* instance_name) {
if (hostname) {
strncpy(g_hostname, hostname, sizeof(g_hostname)-1);
g_hostname[sizeof(g_hostname)-1] = '\0';
}
if (instance_name) {
strncpy(g_instance, instance_name, sizeof(g_instance)-1);
g_instance[sizeof(g_instance)-1] = '\0';
}
ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, on_ip_event, NULL, NULL));
ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, on_wifi_event, NULL, NULL));
// Falls IP schon vorhanden:
esp_netif_t* sta = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
if (sta) {
esp_netif_ip_info_t ip;
if (esp_netif_get_ip_info(sta, &ip) == ESP_OK && ip.ip.addr != 0) {
mdns_start_if_needed();
}
}
return ESP_OK;
}
bool net_mdns_is_running(void) {
return g_mdns_running;
}
bool net_mdns_wait_started(uint32_t timeout_ms) {
uint32_t waited = 0;
const uint32_t step = 50;
while (!g_mdns_running && waited < timeout_ms) {
vTaskDelay(pdMS_TO_TICKS(step));
waited += step;
}
return g_mdns_running;
}
esp_err_t net_mdns_add_service(const char* service, const char* proto,
uint16_t port, mdns_txt_item_t* txt, size_t txt_count) {
if (!g_mdns_running) {
mdns_start_if_needed();
if (!g_mdns_running) return ESP_ERR_INVALID_STATE;
}
esp_err_t err = mdns_service_add(NULL, service, proto, port, txt, txt_count);
if (err != ESP_OK) {
ESP_LOGE(TAG, "mdns_service_add %s.%s:%u failed: %s", service, proto, port, esp_err_to_name(err));
} else {
ESP_LOGI(TAG, "mDNS service announced: %s.%s:%u", service, proto, port);
}
return err;
}
bool net_mdns_find_service_url(const char* service, const char* proto,
int enforce_port, const char* txt_key, const char* txt_value,
uint32_t timeout_ms, int max_results,
char* url_out, size_t url_out_size) {
if (!service || !proto || !url_out || url_out_size < 16) return false;
if (!g_mdns_running) {
ESP_LOGW(TAG, "mDNS not running yet; waiting...");
if (!net_mdns_wait_started(3000)) {
ESP_LOGW(TAG, "mDNS still not running; abort query");
return false;
}
}
mdns_result_t* results = NULL;
esp_err_t err = mdns_query_ptr(service, proto, timeout_ms, max_results, &results);
if (err != ESP_OK) {
ESP_LOGW(TAG, "mdns_query_ptr error: %s", esp_err_to_name(err));
return false;
}
if (!results) {
ESP_LOGI(TAG, "mDNS query OK but no results for %s.%s", service, proto);
return false;
}
bool found = false;
for (mdns_result_t* r = results; r && !found; r = r->next) {
bool txt_ok = true;
if (txt_key && txt_value) {
txt_ok = false;
for (int i = 0; i < r->txt_count; ++i) {
if (r->txt[i].key && r->txt[i].value &&
strcmp(r->txt[i].key, txt_key) == 0 &&
strcmp(r->txt[i].value, txt_value) == 0) {
txt_ok = true; break;
}
}
}
if (!txt_ok) continue;
if (r->instance_name && strncmp(r->instance_name, "myapp-", 5) != 0) {
continue; // falsche Instanz, weitersuchen
}
for (mdns_ip_addr_t* a = r->addr; a && !found; a = a->next) {
if (a->addr.type != ESP_IPADDR_TYPE_V4) continue;
uint16_t port = r->port ? r->port : 80;
if (enforce_port > 0 && port != (uint16_t)enforce_port) port = (uint16_t)enforce_port;
snprintf(url_out, url_out_size, "http://" IPSTR ":%u", IP2STR(&a->addr.u_addr.ip4), (unsigned)port);
ESP_LOGI(TAG, "mDNS URL: %s", url_out);
found = true;
}
}
mdns_query_results_free(results);
return found;
}
void net_mdns_stop(void) { mdns_stop_if_running(); }
-25
View File
@@ -1,25 +0,0 @@
// File: include/net_mdns.h
#pragma once
#include <stdbool.h>
#include <stddef.h>
#include "esp_err.h"
#include "mdns.h"
esp_err_t net_mdns_autostart_init(const char* hostname, const char* instance_name);
bool net_mdns_is_running(void);
bool net_mdns_wait_started(uint32_t timeout_ms);
esp_err_t net_mdns_add_service(const char* service, const char* proto,
uint16_t port, mdns_txt_item_t* txt, size_t txt_count);
bool net_mdns_find_service_url(const char* service, const char* proto,
int enforce_port, const char* txt_key, const char* txt_value,
uint32_t timeout_ms, int max_results,
char* url_out, size_t url_out_size);
void net_mdns_stop(void);
// --- NEU: Auto-Discover + NVS persistieren ---
esp_err_t net_mdns_autodiscover_and_store(const char *service, const char *proto,
int enforce_port,
const char *txt_key, const char *txt_value,
uint32_t timeout_ms);