Refactor: wifi_mgr, net_influx und sen5x_app als eigene Komponenten platziert
This commit is contained in:
@@ -1,9 +1,6 @@
|
||||
set(app_sources
|
||||
"main.c"
|
||||
"lv_fs_port.c"
|
||||
"net_influx.c"
|
||||
"sen5x_app.c"
|
||||
"wifi_mgr.c"
|
||||
)
|
||||
|
||||
idf_component_register(
|
||||
|
||||
@@ -1,719 +0,0 @@
|
||||
// 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;
|
||||
}
|
||||
@@ -1,82 +0,0 @@
|
||||
// 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,
|
||||
...);
|
||||
@@ -1,360 +0,0 @@
|
||||
// File: src/sen5x_app.c
|
||||
|
||||
#include "sen5x_app.h"
|
||||
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "freertos/queue.h" // bleibt drin (Header-Kompat / ggf. künftig wieder genutzt)
|
||||
|
||||
#include "esp_log.h"
|
||||
#include "sensirion_i2c_hal.h"
|
||||
#include "sensirion_i2c_esp32_config.h"
|
||||
#include "sen5x_i2c.h"
|
||||
|
||||
#include "net_influx.h"
|
||||
#include "storage.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <math.h> // NAN, isfinite, lround
|
||||
#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";
|
||||
|
||||
/* ====================== Konfiguration ====================== */
|
||||
#define SEN5X_PROD_STACK 4096
|
||||
#define SEN5X_PROD_PRIO 6 // Producer leicht höher priorisiert
|
||||
|
||||
// Influx worker runtime (läuft in net_influx.c)
|
||||
#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_MAX_MS 300000
|
||||
#define INFLUX_HTTP_TIMEOUT_MS 3000
|
||||
|
||||
/* ====================== Typen & State ====================== */
|
||||
typedef struct {
|
||||
uint16_t pm1p0, pm2p5, pm4p0, pm10p0; // Rohwerte (x10)
|
||||
float temp_c, rh_pct; // skaliert
|
||||
int16_t voc_idx, nox_idx; // Rohwerte (x10)
|
||||
} sen5x_sample_t;
|
||||
|
||||
static bool g_inited = false;
|
||||
static bool g_run = false;
|
||||
static TaskHandle_t g_task_prod = NULL;
|
||||
|
||||
// App-Context
|
||||
static char* g_device_tag = NULL; // z.B. "device=xyz"
|
||||
|
||||
/* ====================== Helfer ====================== */
|
||||
#define CHECK_ESP_OR_RET(x) do { \
|
||||
esp_err_t __e = (x); \
|
||||
if (__e != ESP_OK) { \
|
||||
ESP_LOGE(TAG, "%s failed: %s", #x, esp_err_to_name(__e)); \
|
||||
return __e; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define CHECK_SEN_OR_RET(x) do { \
|
||||
int16_t __rc = (x); \
|
||||
if (__rc != 0) { \
|
||||
ESP_LOGE(TAG, "%s failed: %d", #x, (int)__rc); \
|
||||
return ESP_FAIL; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
/* ====================== Lokale Float-Wrapper (optional) ====================== */
|
||||
static int16_t sen5x_read_measured_values_float(float* pm1p0, float* pm2p5,
|
||||
float* pm4p0, float* pm10p0,
|
||||
float* rh, float* t,
|
||||
float* voc, float* nox) {
|
||||
uint16_t pm1_i=0, pm2_i=0, pm4_i=0, pm10_i=0;
|
||||
int16_t rh_i=0, t_i=0, voc_i=0, nox_i=0;
|
||||
int16_t err = sen5x_read_measured_values(&pm1_i, &pm2_i, &pm4_i, &pm10_i,
|
||||
&rh_i, &t_i, &voc_i, &nox_i);
|
||||
if (err) return err;
|
||||
|
||||
if (pm1p0) *pm1p0 = (pm1_i == 0xFFFF) ? NAN : pm1_i / 10.0f;
|
||||
if (pm2p5) *pm2p5 = (pm2_i == 0xFFFF) ? NAN : pm2_i / 10.0f;
|
||||
if (pm4p0) *pm4p0 = (pm4_i == 0xFFFF) ? NAN : pm4_i / 10.0f;
|
||||
if (pm10p0) *pm10p0 = (pm10_i == 0xFFFF) ? NAN : pm10_i / 10.0f;
|
||||
|
||||
if (rh) *rh = (rh_i == 0x7FFF) ? NAN : rh_i / 100.0f;
|
||||
if (t) *t = (t_i == 0x7FFF) ? NAN : t_i / 200.0f;
|
||||
if (voc) *voc = (voc_i == 0x7FFF) ? NAN : voc_i / 10.0f;
|
||||
if (nox) *nox = (nox_i == 0x7FFF) ? NAN : nox_i / 10.0f;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int16_t sen5x_read_measured_pm_values_float(float* pm1, float* pm2,
|
||||
float* pm4, float* pm10,
|
||||
float* n05, float* n10,
|
||||
float* n25, float* n40,
|
||||
float* n100, float* dtyp) {
|
||||
uint16_t pm1_i=0, pm2_i=0, pm4_i=0, pm10_i=0, n05_i=0, n10_i=0, n25_i=0, n40_i=0, n100_i=0, dtyp_i=0;
|
||||
int16_t err = sen5x_read_measured_pm_values(&pm1_i, &pm2_i, &pm4_i, &pm10_i,
|
||||
&n05_i, &n10_i, &n25_i, &n40_i, &n100_i, &dtyp_i);
|
||||
if (err) return err;
|
||||
|
||||
if (pm1) *pm1 = (pm1_i == 0xFFFF) ? NAN : pm1_i / 10.0f;
|
||||
if (pm2) *pm2 = (pm2_i == 0xFFFF) ? NAN : pm2_i / 10.0f;
|
||||
if (pm4) *pm4 = (pm4_i == 0xFFFF) ? NAN : pm4_i / 10.0f;
|
||||
if (pm10) *pm10 = (pm10_i == 0xFFFF) ? NAN : pm10_i / 10.0f;
|
||||
|
||||
if (n05) *n05 = (n05_i == 0xFFFF) ? NAN : n05_i / 10.0f;
|
||||
if (n10) *n10 = (n10_i == 0xFFFF) ? NAN : n10_i / 10.0f;
|
||||
if (n25) *n25 = (n25_i == 0xFFFF) ? NAN : n25_i / 10.0f;
|
||||
if (n40) *n40 = (n40_i == 0xFFFF) ? NAN : n40_i / 10.0f;
|
||||
if (n100) *n100 = (n100_i == 0xFFFF) ? NAN : n100_i / 10.0f;
|
||||
|
||||
if (dtyp) *dtyp = (dtyp_i == 0xFFFF) ? NAN : dtyp_i / 1000.0f; // µm
|
||||
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 ====================== */
|
||||
static void sen5x_task_producer(void* arg) {
|
||||
(void)arg;
|
||||
|
||||
const TickType_t period = pdMS_TO_TICKS(1000); // exakt 1 Hz
|
||||
TickType_t last_wake = xTaskGetTickCount();
|
||||
|
||||
ESP_LOGI(TAG, "Producer started (1 Hz).");
|
||||
|
||||
for (; g_run; ) {
|
||||
bool ready = false;
|
||||
int16_t rc = sen5x_read_data_ready(&ready);
|
||||
if (rc != 0) {
|
||||
ESP_LOGW(TAG, "sen5x_read_data_ready error: %d", (int)rc);
|
||||
} else if (ready) {
|
||||
uint16_t pm1p0=0, pm2p5=0, pm4p0=0, pm10p0=0;
|
||||
int16_t rh_raw=0, t_raw=0, voc_idx=0, nox_idx=0;
|
||||
|
||||
rc = sen5x_read_measured_values(&pm1p0, &pm2p5, &pm4p0, &pm10p0,
|
||||
&rh_raw, &t_raw, &voc_idx, &nox_idx);
|
||||
if (rc != 0) {
|
||||
ESP_LOGW(TAG, "sen5x_read_measured_values error: %d", (int)rc);
|
||||
} else {
|
||||
// Roh → Struct (wie bisher)
|
||||
sen5x_sample_t s = {
|
||||
.pm1p0 = pm1p0,
|
||||
.pm2p5 = pm2p5,
|
||||
.pm4p0 = pm4p0,
|
||||
.pm10p0 = pm10p0,
|
||||
.temp_c = ((float)t_raw) / 200.0f,
|
||||
.rh_pct = ((float)rh_raw) / 100.0f,
|
||||
.voc_idx = voc_idx,
|
||||
.nox_idx = nox_idx
|
||||
};
|
||||
|
||||
/* === GUI-Variablen jede Sekunde updaten (skaliert) === */
|
||||
char buf[24];
|
||||
float pm1f = (s.pm1p0 == 0xFFFF) ? NAN : s.pm1p0 / 10.0f;
|
||||
float pm2f = (s.pm2p5 == 0xFFFF) ? NAN : s.pm2p5 / 10.0f;
|
||||
float pm4f = (s.pm4p0 == 0xFFFF) ? NAN : s.pm4p0 / 10.0f;
|
||||
float pm10f = (s.pm10p0 == 0xFFFF) ? NAN : s.pm10p0 / 10.0f;
|
||||
float vocf = (s.voc_idx == 0x7FFF) ? NAN : s.voc_idx / 10.0f;
|
||||
// float noxf = (s.nox_idx == 0x7FFF) ? NAN : s.nox_idx / 10.0f; // bei Bedarf anzeigen
|
||||
|
||||
// Temperatur
|
||||
snprintf(buf, sizeof(buf), "%.1f", (double)s.temp_c);
|
||||
set_var_temp(buf);
|
||||
|
||||
// Feuchte
|
||||
snprintf(buf, sizeof(buf), "%.1f", (double)s.rh_pct);
|
||||
set_var_humidity(buf);
|
||||
|
||||
// VOC-Index (gerundet), falls NAN → "nan"
|
||||
if (!isfinite(vocf)) snprintf(buf, sizeof(buf), "nan");
|
||||
else snprintf(buf, sizeof(buf), "%d", (int)lround(vocf));
|
||||
set_var_voc_ind(buf);
|
||||
|
||||
// PM (µg/m³) mit einer Nachkommastelle
|
||||
if (!isfinite(pm10f)) snprintf(buf, sizeof(buf), "nan"); else snprintf(buf, sizeof(buf), "%.1f", (double)pm10f);
|
||||
set_var_pm10p0(buf);
|
||||
if (!isfinite(pm4f)) snprintf(buf, sizeof(buf), "nan"); else snprintf(buf, sizeof(buf), "%.1f", (double)pm4f);
|
||||
set_var_pm4p0(buf);
|
||||
if (!isfinite(pm2f)) snprintf(buf, sizeof(buf), "nan"); else snprintf(buf, sizeof(buf), "%.1f", (double)pm2f);
|
||||
set_var_pm2p5(buf);
|
||||
if (!isfinite(pm1f)) snprintf(buf, sizeof(buf), "nan"); else snprintf(buf, sizeof(buf), "%.1f", (double)pm1f);
|
||||
set_var_pm1p0(buf);
|
||||
|
||||
/* === Influx submit (generisch, variabel viele Felder) === */
|
||||
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 pm4 = (s.pm4p0 == 0xFFFF) ? NAN : ((double)s.pm4p0 / 10.0);
|
||||
const double pm10 = (s.pm10p0 == 0xFFFF) ? NAN : ((double)s.pm10p0 / 10.0);
|
||||
const double voc = (s.voc_idx == 0x7FFF) ? NAN : ((double)s.voc_idx / 10.0);
|
||||
const double nox = (s.nox_idx == 0x7FFF) ? NAN : ((double)s.nox_idx / 10.0);
|
||||
const double temp = (double)s.temp_c;
|
||||
const double rh = (double)s.rh_pct;
|
||||
|
||||
net_influx_field_t f[] = {
|
||||
{ .key="pm1", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=pm1 },
|
||||
{ .key="pm2_5", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=pm2_5 },
|
||||
{ .key="pm4", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=pm4 },
|
||||
{ .key="pm10", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=pm10 },
|
||||
{ .key="temp", .type=NET_INFLUX_F_FLOAT, .precision=3, .v.f=temp },
|
||||
{ .key="rh", .type=NET_INFLUX_F_FLOAT, .precision=3, .v.f=rh },
|
||||
{ .key="voc", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=voc },
|
||||
{ .key="nox", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=nox },
|
||||
};
|
||||
|
||||
net_influx_point_t p = {
|
||||
.measurement = "air",
|
||||
.tags = g_device_tag ? g_device_tag : "device=unknown",
|
||||
.ts_ms = 0, // Serverzeit
|
||||
.fields = f,
|
||||
.num_fields = sizeof(f) / sizeof(f[0]),
|
||||
};
|
||||
|
||||
(void)net_influx_submit_point(&p);
|
||||
}
|
||||
}
|
||||
|
||||
vTaskDelayUntil(&last_wake, period); // präzise 1 Hz
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Producer stopping.");
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
/* ====================== Öffentliche API ====================== */
|
||||
esp_err_t sen5x_app_init(const sen5x_i2c_cfg_t* cfg) {
|
||||
if (g_inited) {
|
||||
ESP_LOGW(TAG, "already initialized");
|
||||
return ESP_OK;
|
||||
}
|
||||
if (!cfg) return ESP_ERR_INVALID_ARG;
|
||||
|
||||
ESP_LOGI(TAG, "Initializing SEN5x app...");
|
||||
|
||||
// 1) I2C-Subsystem
|
||||
CHECK_ESP_OR_RET(i2cdev_init());
|
||||
|
||||
// 2) HAL-Konfiguration
|
||||
struct esp32_i2c_config hal_cfg = {
|
||||
.addr = cfg->addr,
|
||||
.port = cfg->port,
|
||||
.sda = cfg->sda,
|
||||
.scl = cfg->scl,
|
||||
.sda_pullup = cfg->sda_pullup,
|
||||
.scl_pullup = cfg->scl_pullup,
|
||||
.freq = cfg->freq
|
||||
};
|
||||
CHECK_ESP_OR_RET(sensirion_i2c_config_esp32(&hal_cfg));
|
||||
|
||||
// 3) HAL init
|
||||
sensirion_i2c_hal_init();
|
||||
CHECK_ESP_OR_RET(sensirion_i2c_esp32_ok());
|
||||
|
||||
// 4) Messung starten
|
||||
CHECK_SEN_OR_RET(sen5x_start_measurement());
|
||||
ESP_LOGI(TAG, "Measurement started.");
|
||||
|
||||
// 5) Device Tag (App-Kontext)
|
||||
CHECK_ESP_OR_RET(make_device_tag_once());
|
||||
|
||||
// 6) Influx Worker starten (Influx-spezifische Init/Retry/Backoff läuft intern)
|
||||
net_influx_runtime_cfg_t rt = {
|
||||
.queue_len = INFLUX_QUEUE_LEN,
|
||||
.task_stack = INFLUX_TASK_STACK,
|
||||
.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_inited = true;
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
void sen5x_app_deinit(void) {
|
||||
if (!g_inited) return;
|
||||
|
||||
ESP_LOGI(TAG, "Deinitializing SEN5x app...");
|
||||
|
||||
// Producer stoppen
|
||||
g_run = false;
|
||||
|
||||
if (g_task_prod) {
|
||||
vTaskDelete(g_task_prod);
|
||||
g_task_prod = NULL;
|
||||
}
|
||||
|
||||
// Influx worker stoppen
|
||||
net_influx_stop();
|
||||
|
||||
// Device Tag
|
||||
if (g_device_tag) {
|
||||
free(g_device_tag);
|
||||
g_device_tag = NULL;
|
||||
}
|
||||
|
||||
// Sensor stoppen & HAL freigeben
|
||||
sen5x_stop_measurement();
|
||||
sensirion_i2c_hal_free();
|
||||
i2cdev_done();
|
||||
|
||||
g_inited = false;
|
||||
ESP_LOGI(TAG, "SEN5x app deinitialized.");
|
||||
}
|
||||
|
||||
/**
|
||||
* Kompatibilität zur bisherigen main.c:
|
||||
* 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.
|
||||
*/
|
||||
void sen5x_app_task(void* arg) {
|
||||
(void)arg;
|
||||
|
||||
if (!g_inited) {
|
||||
ESP_LOGE(TAG, "sen5x_app_task called before sen5x_app_init()");
|
||||
vTaskDelete(NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
// Producer starten
|
||||
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");
|
||||
vTaskDelete(NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
ESP_LOGI(TAG, "Launcher done (producer started).");
|
||||
vTaskDelete(NULL); // Launcher beendet sich selbst
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
#pragma once
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "esp_err.h"
|
||||
|
||||
// Schlanke I2C/HAL-Konfiguration (wie zuvor genutzt)
|
||||
typedef struct {
|
||||
uint8_t addr; // 7-bit I2C-Adresse (0x69)
|
||||
int port; // I2C Port (0)
|
||||
int sda; // GPIO SDA
|
||||
int scl; // GPIO SCL
|
||||
bool sda_pullup; // interne Pullups
|
||||
bool scl_pullup; // interne Pullups
|
||||
uint32_t freq; // I2C Takt (Hz, z.B. 400000)
|
||||
} sen5x_i2c_cfg_t;
|
||||
|
||||
// Initialisiert I2C/Treiber/HAL und startet die Messung
|
||||
esp_err_t sen5x_app_init(const sen5x_i2c_cfg_t* cfg);
|
||||
|
||||
// Endlosschleife (Pollt "data ready" und loggt Messwerte); als FreeRTOS-Task nutzbar
|
||||
void sen5x_app_task(void* arg);
|
||||
|
||||
// Stoppt Messung & gibt Ressourcen frei (optional aufzurufen z.B. bei Shutdown)
|
||||
void sen5x_app_deinit(void);
|
||||
@@ -1,353 +0,0 @@
|
||||
// File: src/wifi_mgr.c
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <inttypes.h>
|
||||
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "freertos/event_groups.h"
|
||||
|
||||
#include "esp_event.h"
|
||||
#include "esp_log.h"
|
||||
#include "esp_system.h"
|
||||
#include "esp_wifi.h"
|
||||
#include "esp_netif.h"
|
||||
#include "esp_timer.h"
|
||||
|
||||
#include "lwip/netdb.h"
|
||||
|
||||
#include "wifi_mgr.h"
|
||||
#include "storage.h"
|
||||
#include "net_mdns.h"
|
||||
#include "sys_status.h"
|
||||
#include "dns_captive.h"
|
||||
|
||||
// ---------- Konfig ----------
|
||||
#define SOFTAP_SSID "nanoPSX"
|
||||
#define SOFTAP_PASS "" // leer => offenes WLAN
|
||||
#define SOFTAP_CHANNEL 1
|
||||
#define SOFTAP_MAX_CONN 4
|
||||
|
||||
static const char *TAG = "wifi_mgr";
|
||||
|
||||
// ---------- Globals ----------
|
||||
static esp_netif_t *netif_ap = NULL, *netif_sta = NULL;
|
||||
|
||||
static EventGroupHandle_t wifi_events;
|
||||
#define EVT_STA_GOTIP BIT0
|
||||
#define EVT_STA_FAIL BIT1
|
||||
#define EVT_STA_DISCONNECTED BIT2
|
||||
|
||||
// AP-Auto-Off / DNS start/stop
|
||||
static bool ap_is_on = true;
|
||||
|
||||
// AP-Auto-Off Timer
|
||||
static esp_timer_handle_t ap_off_timer = NULL;
|
||||
|
||||
// ---------- Vorwärtsdeklarationen ----------
|
||||
static void ap_enable(void);
|
||||
static void ap_disable(void);
|
||||
static void ap_set_dhcp_dns_to_self(void);
|
||||
static void mdns_discover_task(void *arg);
|
||||
|
||||
// Wi-Fi
|
||||
static void wifi_event_handler(void* arg, esp_event_base_t base, int32_t id, void* data);
|
||||
static void wifi_start_ap_sta(void);
|
||||
|
||||
// Timer Callback
|
||||
static void ap_off_timer_cb(void *arg);
|
||||
|
||||
// ---------- Öffentliche Helfer (Wrapper um storage) ----------
|
||||
bool wifi_mgr_load_sta_creds(char **out_ssid, char **out_pass) {
|
||||
return storage_load_wifi_creds(out_ssid, out_pass);
|
||||
}
|
||||
|
||||
void wifi_mgr_save_sta_creds_and_reconnect(const char* ssid, const char* pass) {
|
||||
if (!ssid || !pass) return;
|
||||
|
||||
(void)storage_save_wifi_creds(ssid, pass);
|
||||
|
||||
// Status zurücksetzen
|
||||
xEventGroupClearBits(wifi_events, EVT_STA_GOTIP | EVT_STA_FAIL | EVT_STA_DISCONNECTED);
|
||||
|
||||
// 1) sauber trennen (asynchron)
|
||||
esp_err_t err = esp_wifi_disconnect();
|
||||
if (err != ESP_OK && err != ESP_ERR_WIFI_NOT_CONNECT) {
|
||||
ESP_LOGW(TAG, "esp_wifi_disconnect: %s", esp_err_to_name(err));
|
||||
}
|
||||
|
||||
// 2) auf "disconnected" warten (kurz)
|
||||
(void)xEventGroupWaitBits(
|
||||
wifi_events,
|
||||
EVT_STA_DISCONNECTED,
|
||||
pdTRUE, // beim Eintreffen löschen
|
||||
pdFALSE,
|
||||
pdMS_TO_TICKS(1500) // 1.5 s Timeout – gern anpassen
|
||||
);
|
||||
|
||||
// (Optionaler Fallback falls Timeout: Treiber kurz stoppen/neu starten)
|
||||
// Das vermeidet 0x3006 bei hartnäckigen Races.
|
||||
wifi_mode_t mode = WIFI_MODE_APSTA;
|
||||
if (esp_wifi_set_mode(mode) != ESP_OK) {
|
||||
ESP_LOGW(TAG, "set_mode(APSTA) failed pre-config");
|
||||
}
|
||||
|
||||
// 3) neue Creds setzen (MIT sicherer Kopie + Terminierung!)
|
||||
char *s = NULL, *pw = NULL;
|
||||
bool have = storage_load_wifi_creds(&s, &pw);
|
||||
if (have) {
|
||||
wifi_config_t sta = {0};
|
||||
|
||||
// WICHTIG: KEIN strncpy-Fallstrick → immer nullterminieren!
|
||||
strlcpy((char*)sta.sta.ssid, s, sizeof(sta.sta.ssid));
|
||||
strlcpy((char*)sta.sta.password, pw, sizeof(sta.sta.password));
|
||||
|
||||
#ifdef WPA3_SAE_PWE_BOTH
|
||||
sta.sta.pmf_cfg.required = true;
|
||||
sta.sta.sae_pwe_h2e = WPA3_SAE_PWE_BOTH;
|
||||
sta.sta.threshold.authmode = WIFI_AUTH_WPA2_WPA3_PSK;
|
||||
#else
|
||||
sta.sta.threshold.authmode = WIFI_AUTH_WPA2_PSK;
|
||||
#endif
|
||||
|
||||
err = esp_wifi_set_config(WIFI_IF_STA, &sta);
|
||||
if (err == ESP_ERR_WIFI_STATE) {
|
||||
// Harter Fallback: kurz stoppen, dann setzen.
|
||||
ESP_LOGW(TAG, "set_config: WIFI_STATE – stop/start fallback");
|
||||
ESP_ERROR_CHECK(esp_wifi_stop());
|
||||
ESP_ERROR_CHECK(esp_wifi_start());
|
||||
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_APSTA));
|
||||
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &sta));
|
||||
} else {
|
||||
ESP_ERROR_CHECK(err);
|
||||
}
|
||||
|
||||
ESP_ERROR_CHECK(esp_wifi_connect());
|
||||
}
|
||||
|
||||
if (s) free(s);
|
||||
if (pw) free(pw);
|
||||
}
|
||||
|
||||
|
||||
void wifi_mgr_save_device_info(const char* devicename,
|
||||
const char* token,
|
||||
const char* bucket,
|
||||
const char* org) {
|
||||
// 1) Devicename separat handhaben (NULL=kein Update, ""=löschen)
|
||||
(void)storage_save_device_name(devicename);
|
||||
|
||||
// 2) Influx-Teil mit SoftAP-Semantik (NULL=keep, ""=löschen, sonst setzen)
|
||||
(void)storage_save_influx_softap(org, bucket, token);
|
||||
|
||||
// 3) Debug: alles nochmal ausgeben
|
||||
storage_debug_dump();
|
||||
}
|
||||
|
||||
|
||||
// ---------- AP Toggle ----------
|
||||
static void ap_enable(void) {
|
||||
if (ap_is_on) return;
|
||||
|
||||
wifi_config_t ap = (wifi_config_t){0};
|
||||
strncpy((char*)ap.ap.ssid, SOFTAP_SSID, sizeof(ap.ap.ssid));
|
||||
ap.ap.ssid_len = strlen(SOFTAP_SSID);
|
||||
ap.ap.channel = SOFTAP_CHANNEL;
|
||||
ap.ap.max_connection = SOFTAP_MAX_CONN;
|
||||
if (strlen(SOFTAP_PASS) == 0) {
|
||||
ap.ap.authmode = WIFI_AUTH_OPEN;
|
||||
} else {
|
||||
strncpy((char*)ap.ap.password, SOFTAP_PASS, sizeof(ap.ap.password));
|
||||
ap.ap.authmode = WIFI_AUTH_WPA_WPA2_PSK;
|
||||
}
|
||||
ap.ap.pmf_cfg.required = false;
|
||||
|
||||
esp_wifi_set_mode(WIFI_MODE_APSTA);
|
||||
esp_wifi_set_config(WIFI_IF_AP, &ap);
|
||||
ap_is_on = true;
|
||||
|
||||
// DNS/Captive einschalten
|
||||
(void)dns_captive_start();
|
||||
|
||||
// DHCP-DNS Option auf AP-IP setzen
|
||||
ap_set_dhcp_dns_to_self();
|
||||
|
||||
if (netif_ap) {
|
||||
esp_netif_ip_info_t ip;
|
||||
if (esp_netif_get_ip_info(netif_ap, &ip) == ESP_OK) {
|
||||
ESP_LOGI(TAG, "AP reaktiviert. IP " IPSTR, IP2STR(&ip.ip));
|
||||
} else {
|
||||
ESP_LOGI(TAG, "AP reaktiviert.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void ap_disable(void) {
|
||||
if (!ap_is_on) return;
|
||||
|
||||
// DNS/Captive aus
|
||||
dns_captive_stop();
|
||||
|
||||
esp_wifi_set_mode(WIFI_MODE_STA); // nur STA aktiv
|
||||
ap_is_on = false;
|
||||
ESP_LOGI(TAG, "AP/DNS deaktiviert (nur STA aktiv).");
|
||||
|
||||
// (Optional) Portal mit abschalten, damit es nicht auf STA erreichbar bleibt:
|
||||
// portal_http_stop();
|
||||
}
|
||||
|
||||
// ---------- Timer Callback ----------
|
||||
static void ap_off_timer_cb(void *arg) {
|
||||
(void)arg;
|
||||
EventBits_t bits = xEventGroupGetBits(wifi_events);
|
||||
if (bits & EVT_STA_GOTIP) {
|
||||
ap_disable();
|
||||
} else {
|
||||
ESP_LOGW(TAG, "AP-Auto-Off abgebrochen (keine STA-IP mehr).");
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- Wi-Fi ----------
|
||||
static void wifi_event_handler(void* arg, esp_event_base_t base, int32_t id, void* data) {
|
||||
(void)arg;
|
||||
if (base == WIFI_EVENT && id == WIFI_EVENT_STA_START) {
|
||||
sys_status_set_wifi_ok(false);
|
||||
ESP_LOGI(TAG, "STA start");
|
||||
} else if (base == WIFI_EVENT && id == WIFI_EVENT_STA_DISCONNECTED) {
|
||||
sys_status_set_wifi_ok(false);
|
||||
ESP_LOGW(TAG, "STA disconnected");
|
||||
xEventGroupClearBits(wifi_events, EVT_STA_GOTIP);
|
||||
xEventGroupSetBits(wifi_events, EVT_STA_FAIL | EVT_STA_DISCONNECTED);
|
||||
|
||||
if (ap_off_timer && esp_timer_is_active(ap_off_timer)) {
|
||||
esp_timer_stop(ap_off_timer);
|
||||
}
|
||||
ap_enable();
|
||||
esp_wifi_connect();
|
||||
|
||||
} else if (base == IP_EVENT && id == IP_EVENT_STA_GOT_IP) {
|
||||
sys_status_set_wifi_ok(true);
|
||||
ip_event_got_ip_t *e = (ip_event_got_ip_t*)data;
|
||||
ESP_LOGI(TAG, "STA got IP: " IPSTR, IP2STR(&e->ip_info.ip));
|
||||
xEventGroupSetBits(wifi_events, EVT_STA_GOTIP);
|
||||
|
||||
if (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_LOGI(TAG, "AP-Auto-Off in 10s geplant…");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void wifi_start_ap_sta(void) {
|
||||
netif_ap = esp_netif_create_default_wifi_ap();
|
||||
netif_sta = esp_netif_create_default_wifi_sta();
|
||||
|
||||
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_APSTA));
|
||||
|
||||
wifi_config_t ap = (wifi_config_t){0};
|
||||
strncpy((char*)ap.ap.ssid, SOFTAP_SSID, sizeof(ap.ap.ssid));
|
||||
ap.ap.ssid_len = strlen(SOFTAP_SSID);
|
||||
ap.ap.channel = SOFTAP_CHANNEL;
|
||||
ap.ap.max_connection = SOFTAP_MAX_CONN;
|
||||
if (strlen(SOFTAP_PASS) == 0) {
|
||||
ap.ap.authmode = WIFI_AUTH_OPEN;
|
||||
} else {
|
||||
strncpy((char*)ap.ap.password, SOFTAP_PASS, sizeof(ap.ap.password));
|
||||
ap.ap.authmode = WIFI_AUTH_WPA_WPA2_PSK;
|
||||
}
|
||||
ap.ap.pmf_cfg.required = false;
|
||||
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &ap));
|
||||
|
||||
char *ssid = NULL, *pass = NULL;
|
||||
bool have = storage_load_wifi_creds(&ssid, &pass);
|
||||
if (have) {
|
||||
wifi_config_t sta = (wifi_config_t){0};
|
||||
strncpy((char*)sta.sta.ssid, ssid, sizeof(sta.sta.ssid));
|
||||
strncpy((char*)sta.sta.password, pass, sizeof(sta.sta.password));
|
||||
#ifdef WPA3_SAE_PWE_BOTH
|
||||
sta.sta.pmf_cfg.required = true;
|
||||
sta.sta.sae_pwe_h2e = WPA3_SAE_PWE_BOTH;
|
||||
sta.sta.threshold.authmode = WIFI_AUTH_WPA2_WPA3_PSK;
|
||||
#else
|
||||
sta.sta.threshold.authmode = WIFI_AUTH_WPA2_PSK;
|
||||
#endif
|
||||
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &sta));
|
||||
}
|
||||
|
||||
ESP_ERROR_CHECK(esp_wifi_start());
|
||||
|
||||
// DHCP-DNS auf AP-IP setzen (erhöht Captive-Trefferquote)
|
||||
ap_set_dhcp_dns_to_self();
|
||||
|
||||
if (netif_ap) {
|
||||
esp_netif_ip_info_t ip;
|
||||
if (esp_netif_get_ip_info(netif_ap, &ip) == ESP_OK) {
|
||||
ESP_LOGI(TAG, "AP %s gestartet. IP " IPSTR, SOFTAP_SSID, IP2STR(&ip.ip));
|
||||
}
|
||||
}
|
||||
|
||||
if (have) {
|
||||
ESP_LOGI(TAG, "Versuche STA zu verbinden zu '%s' ...", ssid);
|
||||
esp_wifi_connect();
|
||||
}
|
||||
if (ssid) free(ssid);
|
||||
if (pass) free(pass);
|
||||
}
|
||||
|
||||
// ---------- Öffentliche API ----------
|
||||
void wifi_mgr_init(void) {
|
||||
|
||||
ESP_ERROR_CHECK(esp_netif_init());
|
||||
ESP_ERROR_CHECK(esp_event_loop_create_default());
|
||||
wifi_events = xEventGroupCreate();
|
||||
|
||||
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
|
||||
ESP_ERROR_CHECK(esp_wifi_init(&cfg));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, NULL));
|
||||
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &wifi_event_handler, NULL));
|
||||
|
||||
const esp_timer_create_args_t targs = {
|
||||
.callback = ap_off_timer_cb,
|
||||
.arg = NULL,
|
||||
.dispatch_method = ESP_TIMER_TASK,
|
||||
.name = "ap_off_timer"
|
||||
};
|
||||
ESP_ERROR_CHECK(esp_timer_create(&targs, &ap_off_timer));
|
||||
}
|
||||
|
||||
void wifi_mgr_start(void) {
|
||||
wifi_start_ap_sta();
|
||||
ESP_LOGI(TAG, "WiFi AP+STA gestartet.");
|
||||
}
|
||||
|
||||
EventGroupHandle_t wifi_mgr_get_event_group(void) {
|
||||
return wifi_events;
|
||||
}
|
||||
|
||||
EventBits_t wifi_mgr_evt_sta_got_ip(void) {
|
||||
return EVT_STA_GOTIP;
|
||||
}
|
||||
|
||||
EventBits_t wifi_mgr_evt_sta_fail(void) {
|
||||
return EVT_STA_FAIL;
|
||||
}
|
||||
|
||||
esp_netif_t *wifi_mgr_get_ap_netif(void) {
|
||||
return netif_ap;
|
||||
}
|
||||
|
||||
// ---------- Hilfsfunktionen ----------
|
||||
static void ap_set_dhcp_dns_to_self(void) {
|
||||
if (!netif_ap) return;
|
||||
esp_netif_ip_info_t ip;
|
||||
if (esp_netif_get_ip_info(netif_ap, &ip) != ESP_OK) return;
|
||||
|
||||
// DHCP-Server neu konfigurieren: als DNS-Server die eigene AP-IP anbieten
|
||||
esp_netif_dhcps_stop(netif_ap);
|
||||
esp_netif_dhcps_option(netif_ap, ESP_NETIF_OP_SET,
|
||||
ESP_NETIF_DOMAIN_NAME_SERVER,
|
||||
&ip.ip, sizeof(ip.ip));
|
||||
esp_netif_dhcps_start(netif_ap);
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// Initialisiert NVS, Netif, Eventloop, Wi-Fi, registriert Event-Handler und legt den AP-Auto-Off-Timer an.
|
||||
void wifi_mgr_init(void);
|
||||
|
||||
// Startet AP+STA, HTTP-Server und DNS-Server, und stößt ggf. eine STA-Verbindung an.
|
||||
void wifi_mgr_start(void);
|
||||
|
||||
// vorhandene Funktionen, die du schon hattest
|
||||
bool wifi_mgr_load_sta_creds(char **out_ssid, char **out_pass);
|
||||
void wifi_mgr_save_sta_creds_and_reconnect(const char* ssid, const char* pass);
|
||||
void wifi_mgr_save_device_info(const char* devicename,
|
||||
const char* token,
|
||||
const char* bucket,
|
||||
const char* org);
|
||||
|
||||
// NEU: Getter für main.c
|
||||
EventGroupHandle_t wifi_mgr_get_event_group(void);
|
||||
EventBits_t wifi_mgr_evt_sta_got_ip(void);
|
||||
EventBits_t wifi_mgr_evt_sta_fail(void);
|
||||
esp_netif_t *wifi_mgr_get_ap_netif(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
Reference in New Issue
Block a user