skruecken/powerpods
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add runtime BMA456 tap config with NVS persistence and goTool UI.

Browse Source 
Expose multitap parameters over UART/ESP-NOW (like deadzone), store per node in NVS, and allow get/set from CLI, REST, and the dashboard without poll-overwrite while editing.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
simon
2026-09-26 13:07:13 +02:00
co-authored by Cursor
parent f006f8b912
commit d7441cb85f
32 changed files with 1859 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files
main/CMakeLists.txt
+1
View File
@@ -20,6 +20,7 @@ idf_component_register(
"cmd/cmd_accel_deadzone.c"
"cmd/cmd_accel_stream.c"
"cmd/cmd_tap_notify.c"
"cmd/cmd_tap_config.c"
"cmd/cmd_cache_status.c"
"cmd/cmd_espnow_unicast_test.c"
"cmd/cmd_espnow_echo_ping.c"
main/README.md
+29 -1
View File
@@ -88,12 +88,16 @@ Powerpod uses the Bosch **BMA456H** (hearable) variant, not the generic `bma456w
**Persistence:** The local deadzone is stored in the **`nvs`** partition (namespace `powerpod`, key `accel_dz`) via `pod_settings.c`. Each node (master or slave) keeps its own value across reboot. Loaded at boot after `init_bma456()`; saved when set locally (UART `client_id = 0`, `all_clients` on master, or ESP-NOW deadzone on a slave).
Tap detection parameters (`bma456_tap_config_t`) use the same pattern with NVS key `tap_cfg` (blob), UART `TAP_CONFIG`, and ESP-NOW `ESPNOW_SET_TAP_CONFIG`.
**Configuration paths:**
| Path | Effect |
|------|--------|
| UART `ACCEL_DEADZONE` with `client_id = 0` | Set + save local deadzone |
| ESP-NOW `SET_ACCEL_DEADZONE` | Set + save on the receiving slave |
| UART `TAP_CONFIG` with `client_id = 0` | Set + save local tap config |
| ESP-NOW `SET_TAP_CONFIG` | Set + save tap config on the receiving slave |
| `make gotool-deadzone-set DEADZONE=… CLIENT=0` | Host shortcut for local deadzone |
**Logs:** `[BMA456] ACC X=… Y=… Z=…` when deadzone exceeded; `[BMA456] tap: single|double|triple` on interrupt.
@@ -116,6 +120,7 @@ Schema: `proto/esp_now_messages.proto`. Encode/decode: `esp_now_proto.c`. The ES
| `ESPNOW_SLAVE_INFO` | Slave → master | `EspNowSlavePresence` |
| `ESPNOW_HEARTBEAT` | Slave → master | `EspNowSlavePresence` (same fields) |
| `ESPNOW_SET_ACCEL_DEADZONE` | Master → slave | `EspNowAccelDeadzone` (`deadzone` LSB) |
| `ESPNOW_SET_TAP_CONFIG` | Master → slave | `EspNowTapConfig` (multitap sens/timing/axis + enable S/D/T) |
| `ESPNOW_UNICAST_TEST` | Master → slave | `EspNowUnicastTest` (`seq`) |
| `ESPNOW_FIND_ME` | Master → slave | `EspNowFindMe` (`client_id` filter) — LED locate sequence |
| `ESPNOW_RESTART` | Master → slave | `EspNowRestart` (`client_id` filter) — reboot slave |
@@ -232,6 +237,7 @@ Host and master speak nanopb-encoded `UartMessage` inside UART frames (byte 0 =
| 29 | `CACHE_STATUS` | Implemented (`cmd/cmd_cache_status.c`) — subscribed accel + tap cache (one UART round-trip) |
| 30 | `ESPNOW_ECHO_PING` | Implemented (`cmd/cmd_espnow_echo_ping.c`) — ESP-NOW timestamp echo (latency test) |
| 31 | `SET_LOG_LEVEL` | Implemented (`cmd/cmd_set_log_level.c`) — get/set global `esp_log_level_set("*", …)` on master |
| 32 | `TAP_CONFIG` | Implemented (`cmd/cmd_tap_config.c`) — get/set BMA456H multitap params (+ NVS) |
Regenerate C code:
@@ -325,6 +331,27 @@ Sets the **software** deadzone used by `bosch456.c` when logging accel (see [BMA
**Response:** `accel_deadzone_response` with applied `deadzone`, `success`, and `slaves_updated` (ESP-NOW count).
### TAP_CONFIG command
Get/set **hardware** BMA456H multitap parameters (`tap_sens_thres`, timing fields, `axis_sel`, enable single/double/triple). Applied via `bma456_set_tap_config()` and persisted in NVS (`tap_cfg`) on each target node.
**Request:** framed `20` (`0x20`) + `tap_config_request`:
| Field | Meaning |
|-------|---------|
| `write` | `false` = read, `true` = write |
| `tap_sens_thres` … `enable_triple` | Same fields as `bma456_tap_config_t` |
| `client_id` | `0` = local sensor; `>0` = slave id (master) |
| `all_clients` | Master: ESP-NOW unicast to every registered slave |
**Response:** `tap_config_response` with fields echo, `success`, `slaves_updated`.
```bash
go run . -port /dev/ttyUSB0 tap-config
go run . -port /dev/ttyUSB0 tap-config -set -sens 5 -axis 2
go run . -port /dev/ttyUSB0 tap-config -client 16 -set -sens 7
```
### TAP_NOTIFY command
Configure which BMA456 tap kinds a **slave** forwards to the master over ESP-NOW. The slave only sends `ESPNOW_TAP_EVENT` when the matching notify flag is enabled (set locally on the slave via ESP-NOW).
@@ -578,10 +605,11 @@ Target: ESP32-S3. Close serial monitor on the UART adapter port before running `
| `client_registry.c/h` | Registered slave table |
| `bosch456.c/h` | BMA456H I2C driver, accel poll, on-demand read, tap INT, deadzone filter |
| `cmd/cmd_tap_notify.c` | UART `TAP_NOTIFY` — ESP-NOW tap notify config |
| `cmd/cmd_tap_config.c` | UART `TAP_CONFIG` — BMA456 multitap params + NVS |
| `cmd/cmd_cache_status.c` | UART `CACHE_STATUS` — subscribed accel + tap cache poll |
| `board_input.c/h` | Taster GPIO12, LiPo ADC on GPIO1 / GPIO11 |
| `battery_uv.c/h` | Software LiPo UV latch, energy-save boot (`POWERPOD_BATTERY_UV_ENABLE`) |
| `pod_settings.c/h` | NVS persistence (accel deadzone, UV latch, …) |
| `pod_settings.c/h` | NVS persistence (accel deadzone, tap config, UV latch) |
| `led_ring.c/h` | LED ring (digit display, progress bar) |
| `cmd/cmd_led_ring.c` | UART `LED_RING` progress command |
| `cmd/cmd_set_log_level.c` | UART `SET_LOG_LEVEL` — runtime ESP-IDF log level |
main/bosch456.c
+92 -45
View File
@@ -38,7 +38,7 @@ static volatile bool s_int_pending;
static SemaphoreHandle_t s_accel_mutex;
static bma456_tap_handler_t s_tap_handler;
static void *s_tap_handler_ctx;
static const bma456_tap_config_t s_tap_config = BMA456_TAP_CONFIG_DEFAULT;
static bma456_tap_config_t s_tap_config = BMA456_TAP_CONFIG_DEFAULT;
static esp_err_t check_bma4(const char *api_name, int8_t rslt);
@@ -126,6 +126,96 @@ void bma456_set_accel_deadzone(uint32_t deadzone_lsb) {
uint32_t bma456_get_accel_deadzone(void) { return s_accel_deadzone; }
bool bma456_tap_config_valid(const bma456_tap_config_t *cfg) {
if (cfg == NULL) {
return false;
}
if (cfg->tap_sens_thres > 15u) {
return false;
}
if (cfg->axis_sel > 2u) {
return false;
}
if (cfg->wait_for_timeout > 1u) {
return false;
}
if (!cfg->enable_single && !cfg->enable_double && !cfg->enable_triple) {
return false;
}
return true;
}
void bma456_get_tap_config(bma456_tap_config_t *cfg_out) {
if (cfg_out == NULL) {
return;
}
*cfg_out = s_tap_config;
}
static esp_err_t apply_tap_parameters(const bma456_tap_config_t *cfg) {
struct bma456h_multitap_settings tap_settings = {0};
int8_t ret = bma456h_tap_get_parameter(&tap_settings, &s_bma456);
if (check_bma4("bma456h_tap_get_parameter", ret) != ESP_OK) {
return ESP_FAIL;
}
tap_settings.tap_sens_thres = cfg->tap_sens_thres;
tap_settings.max_gest_dur = cfg->max_gest_dur;
tap_settings.tap_shock_dur = cfg->tap_shock_dur;
tap_settings.quite_time_after_gest = cfg->quite_time_after_gest;
tap_settings.wait_for_timeout = cfg->wait_for_timeout;
tap_settings.axis_sel = cfg->axis_sel;
ret = bma456h_tap_set_parameter(&tap_settings, &s_bma456);
if (check_bma4("bma456h_tap_set_parameter", ret) != ESP_OK) {
return ESP_FAIL;
}
/* Disable all tap kinds first, then enable the requested set. */
uint16_t all_taps =
BMA456H_SINGLE_TAP_EN | BMA456H_DOUBLE_TAP_EN | BMA456H_TRIPLE_TAP_EN;
ret = bma456h_feature_enable(all_taps, BMA4_DISABLE, &s_bma456);
if (check_bma4("bma456h_feature_enable(disable taps)", ret) != ESP_OK) {
return ESP_FAIL;
}
uint16_t tap_features = 0;
if (cfg->enable_single) {
tap_features |= BMA456H_SINGLE_TAP_EN;
}
if (cfg->enable_double) {
tap_features |= BMA456H_DOUBLE_TAP_EN;
}
if (cfg->enable_triple) {
tap_features |= BMA456H_TRIPLE_TAP_EN;
}
ret = bma456h_feature_enable(tap_features, BMA4_ENABLE, &s_bma456);
if (check_bma4("bma456h_feature_enable(taps)", ret) != ESP_OK) {
return ESP_FAIL;
}
ESP_LOGI(TAG,
"tap config sens=%u max_gest=%u shock=%u quiet=%u wait=%u axis=%u "
"(single=%d double=%d triple=%d)",
(unsigned)cfg->tap_sens_thres, (unsigned)cfg->max_gest_dur,
(unsigned)cfg->tap_shock_dur, (unsigned)cfg->quite_time_after_gest,
(unsigned)cfg->wait_for_timeout, (unsigned)cfg->axis_sel,
cfg->enable_single, cfg->enable_double, cfg->enable_triple);
return ESP_OK;
}
esp_err_t bma456_set_tap_config(const bma456_tap_config_t *cfg) {
if (!bma456_tap_config_valid(cfg)) {
return ESP_ERR_INVALID_ARG;
}
if (s_bma456_ready) {
esp_err_t err = apply_tap_parameters(cfg);
if (err != ESP_OK) {
return err;
}
}
s_tap_config = *cfg;
return ESP_OK;
}
void bma456_set_tap_handler(bma456_tap_handler_t handler, void *ctx) {
s_tap_handler = handler;
s_tap_handler_ctx = ctx;
@@ -259,52 +349,9 @@ static esp_err_t configure_tap_interrupt(void) {
int8_t ret;
const uint8_t int_line = BMA4_INTR2_MAP;
struct bma456h_multitap_settings tap_settings = {0};
ret = bma456h_tap_get_parameter(&tap_settings, &s_bma456);
if (check_bma4("bma456h_tap_get_parameter", ret) != ESP_OK) {
if (apply_tap_parameters(&s_tap_config) != ESP_OK) {
return ESP_FAIL;
}
tap_settings.tap_sens_thres = s_tap_config.tap_sens_thres;
tap_settings.max_gest_dur = s_tap_config.max_gest_dur;
tap_settings.tap_shock_dur = s_tap_config.tap_shock_dur;
tap_settings.quite_time_after_gest = s_tap_config.quite_time_after_gest;
tap_settings.wait_for_timeout = s_tap_config.wait_for_timeout;
tap_settings.axis_sel = s_tap_config.axis_sel;
ret = bma456h_tap_set_parameter(&tap_settings, &s_bma456);
if (check_bma4("bma456h_tap_set_parameter", ret) != ESP_OK) {
return ESP_FAIL;
}
uint16_t tap_features = 0;
if (s_tap_config.enable_single) {
tap_features |= BMA456H_SINGLE_TAP_EN;
}
if (s_tap_config.enable_double) {
tap_features |= BMA456H_DOUBLE_TAP_EN;
}
if (s_tap_config.enable_triple) {
tap_features |= BMA456H_TRIPLE_TAP_EN;
}
if (tap_features == 0) {
ESP_LOGW(TAG, "tap config: no tap kinds enabled");
return ESP_ERR_INVALID_ARG;
}
ret = bma456h_feature_enable(tap_features, BMA4_ENABLE, &s_bma456);
if (check_bma4("bma456h_feature_enable", ret) != ESP_OK) {
return ESP_FAIL;
}
ESP_LOGI(TAG,
"tap config sens=%u max_gest=%u shock=%u quiet=%u wait=%u axis=%u "
"(single=%d double=%d triple=%d)",
(unsigned)s_tap_config.tap_sens_thres,
(unsigned)s_tap_config.max_gest_dur,
(unsigned)s_tap_config.tap_shock_dur,
(unsigned)s_tap_config.quite_time_after_gest,
(unsigned)s_tap_config.wait_for_timeout,
(unsigned)s_tap_config.axis_sel, s_tap_config.enable_single,
s_tap_config.enable_double, s_tap_config.enable_triple);
ret = bma456h_map_interrupt(int_line, BMA456H_TAP_OUT_INT, BMA4_ENABLE,
&s_bma456);
main/bosch456.h
+14 -1
View File
@@ -42,7 +42,7 @@ typedef struct {
bool enable_triple;
} bma456_tap_config_t;
/** Edit these values to tune tap detection, then rebuild. */
/** Edit these values for the compile-time default (overridden by NVS if set). */
#define BMA456_TAP_CONFIG_DEFAULT \
{ \
.tap_sens_thres = 5, /* sensitive; 0=max, Bosch default=9 */ \
@@ -56,6 +56,19 @@ typedef struct {
.enable_triple = true, \
}
/** True if cfg fields are within sensor limits and at least one tap kind is on. */
bool bma456_tap_config_valid(const bma456_tap_config_t *cfg);
/** Copy current runtime tap config (compile default until set/NVS-applied). */
void bma456_get_tap_config(bma456_tap_config_t *cfg_out);
/**
* Apply tap config to the sensor (and keep RAM copy).
* Returns ESP_ERR_INVALID_ARG if invalid. When the sensor is not ready, only
* the RAM copy is updated (ESP_OK).
*/
esp_err_t bma456_set_tap_config(const bma456_tap_config_t *cfg);
/**
* Probe and configure the sensor on bus_handle (100 kHz device).
* On failure the device is removed and ESP_ERR_NOT_FOUND / ESP_FAIL is returned;
main/client_registry.c
+54
View File
@@ -82,6 +82,10 @@ static client_slot_t *alloc_slot(const uint8_t mac[CLIENT_MAC_LEN],
slot->active = true;
memcpy(slot->info.mac, mac, CLIENT_MAC_LEN);
slot->info.accel_deadzone = CLIENT_REGISTRY_DEFAULT_ACCEL_DEADZONE;
{
static const bma456_tap_config_t k_tap_default = BMA456_TAP_CONFIG_DEFAULT;
slot->info.tap_config = k_tap_default;
}
if (out_is_new != NULL) {
*out_is_new = true;
}
@@ -246,6 +250,56 @@ size_t client_registry_set_accel_deadzone_all(uint32_t deadzone) {
return n;
}
esp_err_t client_registry_set_tap_config(uint32_t client_id,
const bma456_tap_config_t *cfg) {
if (cfg == NULL || !bma456_tap_config_valid(cfg)) {
return ESP_ERR_INVALID_ARG;
}
const client_info_t *info = client_registry_find_by_id(client_id);
if (info == NULL) {
return ESP_ERR_NOT_FOUND;
}
for (size_t i = 0; i < CLIENT_REGISTRY_MAX; i++) {
if (s_clients[i].active && s_clients[i].info.id == client_id) {
s_clients[i].info.tap_config = *cfg;
return ESP_OK;
}
}
return ESP_ERR_NOT_FOUND;
}
esp_err_t client_registry_get_tap_config(uint32_t client_id,
bma456_tap_config_t *cfg_out) {
if (cfg_out == NULL) {
return ESP_ERR_INVALID_ARG;
}
const client_info_t *info = client_registry_find_by_id(client_id);
if (info == NULL) {
return ESP_ERR_NOT_FOUND;
}
*cfg_out = info->tap_config;
return ESP_OK;
}
size_t client_registry_set_tap_config_all(const bma456_tap_config_t *cfg) {
if (cfg == NULL || !bma456_tap_config_valid(cfg)) {
return 0;
}
size_t n = 0;
for (size_t i = 0; i < CLIENT_REGISTRY_MAX; i++) {
if (!s_clients[i].active) {
continue;
}
s_clients[i].info.tap_config = *cfg;
n++;
}
return n;
}
static void clear_client_accel(client_slot_t *slot) {
if (slot == NULL) {
return;
main/client_registry.h
+9
View File
@@ -2,6 +2,7 @@
#define CLIENT_REGISTRY_H
#include "board_input.h"
#include "bosch456.h"
#include "esp_err.h"
#include <stdbool.h>
#include <stddef.h>
@@ -22,6 +23,8 @@ typedef struct {
uint32_t version;
/** Accel deadzone in raw LSB per axis (master copy for ESP-NOW config). */
uint32_t accel_deadzone;
/** Tap detection config (master copy for ESP-NOW / UART read). */
bma456_tap_config_t tap_config;
/** Latest accel from slave ESP-NOW stream (master only). */
bool accel_valid;
int16_t accel_x;
@@ -88,6 +91,12 @@ esp_err_t client_registry_get_accel_deadzone(uint32_t client_id,
/** Push deadzone to all active registry entries; returns count updated. */
size_t client_registry_set_accel_deadzone_all(uint32_t deadzone);
esp_err_t client_registry_set_tap_config(uint32_t client_id,
const bma456_tap_config_t *cfg);
esp_err_t client_registry_get_tap_config(uint32_t client_id,
bma456_tap_config_t *cfg_out);
size_t client_registry_set_tap_config_all(const bma456_tap_config_t *cfg);
/** Store latest accel sample from a slave (matched by sender MAC). */
esp_err_t client_registry_update_accel(const uint8_t mac[CLIENT_MAC_LEN],
uint32_t slave_id, int16_t x, int16_t y,
main/cmd/cmd_handler.c
+2
View File
@@ -61,6 +61,8 @@ static const char *message_type_name(uint16_t id) {
return "ESPNOW_ECHO_PING";
case alox_MessageType_SET_LOG_LEVEL:
return "SET_LOG_LEVEL";
case alox_MessageType_TAP_CONFIG:
return "TAP_CONFIG";
default:
return "UNKNOWN";
}
main/cmd/cmd_tap_config.c
+162
View File
@@ -0,0 +1,162 @@
#include "bosch456.h"
#include "client_registry.h"
#include "cmd_tap_config.h"
#include "esp_log.h"
#include "esp_now_comm.h"
#include "pod_settings.h"
#include "uart_cmd.h"
static const char *TAG = "[TAP_CFG]";
static void fill_response_fields(alox_TapConfigResponse *out,
const bma456_tap_config_t *cfg) {
out->tap_sens_thres = cfg->tap_sens_thres;
out->max_gest_dur = cfg->max_gest_dur;
out->tap_shock_dur = cfg->tap_shock_dur;
out->quite_time_after_gest = cfg->quite_time_after_gest;
out->wait_for_timeout = cfg->wait_for_timeout;
out->axis_sel = cfg->axis_sel;
out->enable_single = cfg->enable_single;
out->enable_double = cfg->enable_double;
out->enable_triple = cfg->enable_triple;
}
static void reply(uint32_t client_id, bool success, uint32_t slaves_updated,
const bma456_tap_config_t *cfg) {
alox_UartMessage response;
uart_cmd_init_response(&response, alox_MessageType_TAP_CONFIG,
alox_UartMessage_tap_config_response_tag);
response.payload.tap_config_response.client_id = client_id;
response.payload.tap_config_response.success = success;
response.payload.tap_config_response.slaves_updated = slaves_updated;
if (cfg != NULL) {
fill_response_fields(&response.payload.tap_config_response, cfg);
}
uart_cmd_send(&response, TAG);
}
static void req_to_cfg(const alox_TapConfigRequest *req,
bma456_tap_config_t *cfg) {
cfg->tap_sens_thres = (uint16_t)req->tap_sens_thres;
cfg->max_gest_dur = (uint16_t)req->max_gest_dur;
cfg->tap_shock_dur = (uint16_t)req->tap_shock_dur;
cfg->quite_time_after_gest = (uint16_t)req->quite_time_after_gest;
cfg->wait_for_timeout = (uint16_t)req->wait_for_timeout;
cfg->axis_sel = (uint16_t)req->axis_sel;
cfg->enable_single = req->enable_single;
cfg->enable_double = req->enable_double;
cfg->enable_triple = req->enable_triple;
}
static void apply_local_tap_config(const bma456_tap_config_t *cfg) {
if (bma456_set_tap_config(cfg) != ESP_OK) {
ESP_LOGW(TAG, "local tap config apply failed");
return;
}
if (pod_settings_save_tap_config(cfg) != ESP_OK) {
ESP_LOGW(TAG, "tap config applied but not saved to NVS");
}
}
static esp_err_t push_tap_config_to_slave(const client_info_t *client,
const bma456_tap_config_t *cfg) {
if (client == NULL || cfg == NULL) {
return ESP_ERR_INVALID_ARG;
}
esp_err_t err = client_registry_set_tap_config(client->id, cfg);
if (err != ESP_OK) {
return err;
}
return esp_now_comm_send_tap_config(client->mac, client->id, cfg);
}
static void handle_tap_config(const uint8_t *data, size_t len) {
alox_UartMessage uart_msg;
alox_TapConfigRequest req = alox_TapConfigRequest_init_zero;
static const bma456_tap_config_t k_default = BMA456_TAP_CONFIG_DEFAULT;
if (uart_cmd_decode(data, len, &uart_msg) != ESP_OK) {
ESP_LOGW(TAG, "decode failed");
reply(0, false, 0, &k_default);
return;
}
const alox_TapConfigRequest *req_ptr =
UART_CMD_REQ(&uart_msg, alox_UartMessage_tap_config_request_tag,
tap_config_request);
if (req_ptr != NULL) {
req = *req_ptr;
}
bma456_tap_config_t cfg;
req_to_cfg(&req, &cfg);
if (req.write) {
if (!bma456_tap_config_valid(&cfg)) {
ESP_LOGW(TAG, "invalid tap config");
reply(req.client_id, false, 0, &cfg);
return;
}
if (req.all_clients) {
size_t n = client_registry_set_tap_config_all(&cfg);
uint32_t sent = 0;
for (size_t i = 0; i < client_registry_count(); i++) {
const client_info_t *client = client_registry_at(i);
if (client == NULL) {
continue;
}
if (esp_now_comm_send_tap_config(client->mac, client->id, &cfg) ==
ESP_OK) {
sent++;
}
}
if (bma456_is_ready()) {
apply_local_tap_config(&cfg);
}
ESP_LOGI(TAG, "set tap config via unicast to %u/%u slaves",
(unsigned)sent, (unsigned)n);
reply(0, sent > 0 || bma456_is_ready(), sent, &cfg);
return;
}
if (req.client_id == 0) {
apply_local_tap_config(&cfg);
ESP_LOGI(TAG, "set local tap config (no ESP-NOW; use -client or -all "
"for slaves)");
reply(0, true, 0, &cfg);
return;
}
const client_info_t *client = client_registry_find_by_id(req.client_id);
if (client == NULL) {
ESP_LOGW(TAG, "client id %lu not found", (unsigned long)req.client_id);
reply(req.client_id, false, 0, &cfg);
return;
}
esp_err_t err = push_tap_config_to_slave(client, &cfg);
reply(req.client_id, err == ESP_OK, err == ESP_OK ? 1 : 0, &cfg);
return;
}
if (req.all_clients || req.client_id == 0) {
bma456_tap_config_t local;
bma456_get_tap_config(&local);
reply(0, true, 0, &local);
return;
}
bma456_tap_config_t cached;
esp_err_t err = client_registry_get_tap_config(req.client_id, &cached);
reply(req.client_id, err == ESP_OK, 0, err == ESP_OK ? &cached : &k_default);
}
void cmd_tap_config_register(void) {
uart_cmd_register(alox_MessageType_TAP_CONFIG, handle_tap_config);
}
main/cmd/cmd_tap_config.h
+6
View File
@@ -0,0 +1,6 @@
#ifndef CMD_TAP_CONFIG_H
#define CMD_TAP_CONFIG_H
void cmd_tap_config_register(void);
#endif
main/esp_now_comm.h
+5
View File
@@ -22,6 +22,11 @@ esp_err_t esp_now_comm_send_tap_notify(const uint8_t mac[CLIENT_MAC_LEN],
esp_err_t esp_now_comm_send_accel_deadzone(const uint8_t mac[CLIENT_MAC_LEN],
uint32_t client_id, uint32_t deadzone);
/** Master: unicast BMA456 tap config to one slave. */
esp_err_t esp_now_comm_send_tap_config(const uint8_t mac[CLIENT_MAC_LEN],
uint32_t client_id,
const bma456_tap_config_t *cfg);
/** Master: send minimal unicast test payload to verify master→slave path. */
esp_err_t esp_now_comm_send_unicast_test(const uint8_t mac[CLIENT_MAC_LEN],
uint32_t seq);
main/esp_now_master.c
+40
View File
@@ -45,6 +45,24 @@ static esp_err_t send_accel_deadzone(const uint8_t *dest_mac, uint32_t client_id
return esp_now_core_send(dest_mac, &msg);
}
static esp_err_t send_tap_config(const uint8_t *dest_mac, uint32_t client_id,
const bma456_tap_config_t *cfg) {
alox_EspNowMessage msg = alox_EspNowMessage_init_zero;
msg.type = alox_EspNowMessageType_ESPNOW_SET_TAP_CONFIG;
msg.which_payload = alox_EspNowMessage_tap_config_tag;
msg.payload.tap_config.client_id = client_id;
msg.payload.tap_config.tap_sens_thres = cfg->tap_sens_thres;
msg.payload.tap_config.max_gest_dur = cfg->max_gest_dur;
msg.payload.tap_config.tap_shock_dur = cfg->tap_shock_dur;
msg.payload.tap_config.quite_time_after_gest = cfg->quite_time_after_gest;
msg.payload.tap_config.wait_for_timeout = cfg->wait_for_timeout;
msg.payload.tap_config.axis_sel = cfg->axis_sel;
msg.payload.tap_config.enable_single = cfg->enable_single;
msg.payload.tap_config.enable_double = cfg->enable_double;
msg.payload.tap_config.enable_triple = cfg->enable_triple;
return esp_now_core_send(dest_mac, &msg);
}
static esp_err_t send_unicast_test(const uint8_t *dest_mac, uint32_t seq) {
alox_EspNowMessage msg = alox_EspNowMessage_init_zero;
msg.type = alox_EspNowMessageType_ESPNOW_UNICAST_TEST;
@@ -387,6 +405,28 @@ esp_err_t esp_now_comm_send_accel_deadzone(const uint8_t mac[CLIENT_MAC_LEN],
return err;
}
esp_err_t esp_now_comm_send_tap_config(const uint8_t mac[CLIENT_MAC_LEN],
uint32_t client_id,
const bma456_tap_config_t *cfg) {
if (mac == NULL || cfg == NULL || !esp_now_core_is_master()) {
return ESP_ERR_INVALID_STATE;
}
char mac_str[18];
esp_now_core_mac_to_str(mac, mac_str, sizeof(mac_str));
esp_err_t err = send_tap_config(mac, client_id, cfg);
if (err == ESP_OK) {
ESP_LOGI(TAG,
"unicast SET_TAP_CONFIG to %s: sens=%u client_id=%lu "
"(S=%d D=%d T=%d)",
mac_str, (unsigned)cfg->tap_sens_thres, (unsigned long)client_id,
cfg->enable_single, cfg->enable_double, cfg->enable_triple);
} else {
ESP_LOGW(TAG, "unicast SET_TAP_CONFIG to %s failed: %s", mac_str,
esp_err_to_name(err));
}
return err;
}
static void handle_accel_sample(const uint8_t mac[CLIENT_MAC_LEN],
const alox_EspNowAccelSample *sample) {
if (sample == NULL) {
main/esp_now_slave.c
+47
View File
@@ -389,6 +389,48 @@ static void handle_accel_deadzone(const uint8_t *master_mac,
}
}
static void handle_tap_config(const uint8_t *master_mac,
const alox_EspNowTapConfig *msg) {
uint32_t my_id = esp_now_core_own_mac()[5];
if (msg->client_id != 0 && msg->client_id != my_id) {
return;
}
if (s_joined && !esp_now_core_mac_equal(master_mac, s_master_mac)) {
return;
}
bma456_tap_config_t cfg = {
.tap_sens_thres = (uint16_t)msg->tap_sens_thres,
.max_gest_dur = (uint16_t)msg->max_gest_dur,
.tap_shock_dur = (uint16_t)msg->tap_shock_dur,
.quite_time_after_gest = (uint16_t)msg->quite_time_after_gest,
.wait_for_timeout = (uint16_t)msg->wait_for_timeout,
.axis_sel = (uint16_t)msg->axis_sel,
.enable_single = msg->enable_single,
.enable_double = msg->enable_double,
.enable_triple = msg->enable_triple,
};
char mac_str[18];
esp_now_core_mac_to_str(master_mac, mac_str, sizeof(mac_str));
ESP_LOGI(TAG,
"tap config from master %s: sens=%u id=%lu (sensor %s)", mac_str,
(unsigned)cfg.tap_sens_thres, (unsigned long)my_id,
bma456_is_ready() ? "ok" : "not installed");
if (!bma456_tap_config_valid(&cfg)) {
ESP_LOGW(TAG, "invalid tap config from master; ignored");
return;
}
if (bma456_set_tap_config(&cfg) != ESP_OK) {
ESP_LOGW(TAG, "tap config apply failed");
return;
}
if (pod_settings_save_tap_config(&cfg) != ESP_OK) {
ESP_LOGW(TAG, "tap config applied but not saved to NVS");
}
}
static void handle_discover(const uint8_t *sender_mac,
const alox_EspNowDiscover *discover) {
if (discover->network != esp_now_core_network()) {
@@ -577,6 +619,11 @@ void esp_now_slave_on_recv(const esp_now_recv_info_t *info, const uint8_t *data,
handle_accel_deadzone(info->src_addr, &msg.payload.accel_deadzone);
}
break;
case alox_EspNowMessage_tap_config_tag:
if (from_joined_master(info->src_addr)) {
handle_tap_config(info->src_addr, &msg.payload.tap_config);
}
break;
case alox_EspNowMessage_accel_stream_tag:
if (from_joined_master(info->src_addr)) {
handle_accel_stream(info->src_addr, &msg.payload.accel_stream);
main/pod_settings.c
+143
View File
@@ -3,13 +3,28 @@
#include "esp_log.h"
#include "nvs.h"
#include "nvs_flash.h"
#include <string.h>
static const char *TAG = "[SETTINGS]";
static const char *NS = "powerpod";
static const char *KEY_ACCEL_DZ = "accel_dz";
static const char *KEY_UV_LATCH = "uv_latch";
static const char *KEY_TAP_CFG = "tap_cfg";
#define ACCEL_DEADZONE_MAX 4095u
#define TAP_CFG_NVS_VERSION 1u
/** Packed layout for NVS blob (stable across rebuilds). */
typedef struct __attribute__((packed)) {
uint8_t version;
uint16_t tap_sens_thres;
uint16_t max_gest_dur;
uint16_t tap_shock_dur;
uint16_t quite_time_after_gest;
uint16_t wait_for_timeout;
uint16_t axis_sel;
uint8_t enable_flags; /* bit0=single, bit1=double, bit2=triple */
} tap_config_nvs_t;
static bool s_nvs_ready;
@@ -110,6 +125,134 @@ void pod_settings_apply_accel_deadzone(void) {
}
}
static void tap_config_to_nvs(const bma456_tap_config_t *cfg,
tap_config_nvs_t *out) {
memset(out, 0, sizeof(*out));
out->version = TAP_CFG_NVS_VERSION;
out->tap_sens_thres = cfg->tap_sens_thres;
out->max_gest_dur = cfg->max_gest_dur;
out->tap_shock_dur = cfg->tap_shock_dur;
out->quite_time_after_gest = cfg->quite_time_after_gest;
out->wait_for_timeout = cfg->wait_for_timeout;
out->axis_sel = cfg->axis_sel;
if (cfg->enable_single) {
out->enable_flags |= 0x01u;
}
if (cfg->enable_double) {
out->enable_flags |= 0x02u;
}
if (cfg->enable_triple) {
out->enable_flags |= 0x04u;
}
}
static bool tap_config_from_nvs(const tap_config_nvs_t *in,
bma456_tap_config_t *cfg) {
if (in->version != TAP_CFG_NVS_VERSION) {
return false;
}
cfg->tap_sens_thres = in->tap_sens_thres;
cfg->max_gest_dur = in->max_gest_dur;
cfg->tap_shock_dur = in->tap_shock_dur;
cfg->quite_time_after_gest = in->quite_time_after_gest;
cfg->wait_for_timeout = in->wait_for_timeout;
cfg->axis_sel = in->axis_sel;
cfg->enable_single = (in->enable_flags & 0x01u) != 0;
cfg->enable_double = (in->enable_flags & 0x02u) != 0;
cfg->enable_triple = (in->enable_flags & 0x04u) != 0;
return bma456_tap_config_valid(cfg);
}
bool pod_settings_load_tap_config(bma456_tap_config_t *cfg_out) {
static const bma456_tap_config_t k_default = BMA456_TAP_CONFIG_DEFAULT;
if (cfg_out == NULL) {
return false;
}
*cfg_out = k_default;
if (!s_nvs_ready) {
return false;
}
nvs_handle_t handle;
esp_err_t err = nvs_open(NS, NVS_READONLY, &handle);
if (err != ESP_OK) {
return false;
}
tap_config_nvs_t blob = {0};
size_t len = sizeof(blob);
err = nvs_get_blob(handle, KEY_TAP_CFG, &blob, &len);
nvs_close(handle);
if (err == ESP_ERR_NVS_NOT_FOUND) {
return false;
}
if (err != ESP_OK || len != sizeof(blob)) {
ESP_LOGW(TAG, "read tap_cfg failed: %s (len=%u)", esp_err_to_name(err),
(unsigned)len);
return false;
}
if (!tap_config_from_nvs(&blob, cfg_out)) {
ESP_LOGW(TAG, "tap_cfg blob invalid; using defaults");
*cfg_out = k_default;
return false;
}
return true;
}
esp_err_t pod_settings_save_tap_config(const bma456_tap_config_t *cfg) {
if (!bma456_tap_config_valid(cfg)) {
return ESP_ERR_INVALID_ARG;
}
esp_err_t err = ensure_nvs();
if (err != ESP_OK) {
return err;
}
nvs_handle_t handle;
err = nvs_open(NS, NVS_READWRITE, &handle);
if (err != ESP_OK) {
ESP_LOGE(TAG, "nvs_open failed: %s", esp_err_to_name(err));
return err;
}
tap_config_nvs_t blob;
tap_config_to_nvs(cfg, &blob);
err = nvs_set_blob(handle, KEY_TAP_CFG, &blob, sizeof(blob));
if (err == ESP_OK) {
err = nvs_commit(handle);
}
nvs_close(handle);
if (err != ESP_OK) {
ESP_LOGE(TAG, "save tap_cfg failed: %s", esp_err_to_name(err));
return err;
}
ESP_LOGI(TAG,
"saved tap config sens=%u max_gest=%u shock=%u quiet=%u wait=%u "
"axis=%u (S=%d D=%d T=%d)",
(unsigned)cfg->tap_sens_thres, (unsigned)cfg->max_gest_dur,
(unsigned)cfg->tap_shock_dur, (unsigned)cfg->quite_time_after_gest,
(unsigned)cfg->wait_for_timeout, (unsigned)cfg->axis_sel,
cfg->enable_single, cfg->enable_double, cfg->enable_triple);
return ESP_OK;
}
void pod_settings_apply_tap_config(void) {
bma456_tap_config_t cfg;
if (!pod_settings_load_tap_config(&cfg)) {
return;
}
if (!bma456_is_ready()) {
return;
}
if (bma456_set_tap_config(&cfg) != ESP_OK) {
ESP_LOGW(TAG, "failed to apply NVS tap config");
}
}
bool pod_settings_is_uv_latched(void) {
if (!s_nvs_ready) {
return false;
main/pod_settings.h
+13
View File
@@ -1,6 +1,7 @@
#ifndef POD_SETTINGS_H
#define POD_SETTINGS_H
#include "bosch456.h"
#include "esp_err.h"
#include <stdbool.h>
#include <stdint.h>
@@ -17,6 +18,18 @@ uint32_t pod_settings_load_accel_deadzone(void);
/** Apply NVS deadzone to BMA456 when the sensor is present. */
void pod_settings_apply_accel_deadzone(void);
/** Persist local BMA456 tap detection config. */
esp_err_t pod_settings_save_tap_config(const bma456_tap_config_t *cfg);
/**
* Load tap config from NVS into *cfg_out.
* Returns true when a valid blob was loaded; false → compile-time defaults.
*/
bool pod_settings_load_tap_config(bma456_tap_config_t *cfg_out);
/** Apply NVS tap config to BMA456 when the sensor is present. */
void pod_settings_apply_tap_config(void);
/** LiPo under-voltage latch persisted across reboot (software UV protection). */
bool pod_settings_is_uv_latched(void);
esp_err_t pod_settings_set_uv_latched(bool latched);
main/powerpod.c
+3
View File
@@ -3,6 +3,7 @@
#include "cmd_accel_deadzone.h"
#include "cmd_accel_stream.h"
#include "cmd_tap_notify.h"
#include "cmd_tap_config.h"
#include "cmd_cache_status.h"
#include "cmd_espnow_unicast_test.h"
#include "cmd_espnow_echo_ping.h"
@@ -150,6 +151,7 @@ void app_main(void) {
ESP_LOGI(TAG, "BMA456 init skipped: %s", esp_err_to_name(bma_err));
} else {
pod_settings_apply_accel_deadzone();
pod_settings_apply_tap_config();
}
}
@@ -197,6 +199,7 @@ void app_main(void) {
cmd_accel_deadzone_register();
cmd_accel_stream_register();
cmd_tap_notify_register();
cmd_tap_config_register();
cmd_cache_status_register();
cmd_espnow_unicast_test_register();
cmd_espnow_echo_ping_register();
main/proto/esp_now_messages.pb.c
+3
View File
@@ -42,6 +42,9 @@ PB_BIND(alox_EspNowBatteryQuery, alox_EspNowBatteryQuery, AUTO)
PB_BIND(alox_EspNowTapNotify, alox_EspNowTapNotify, AUTO)
PB_BIND(alox_EspNowTapConfig, alox_EspNowTapConfig, AUTO)
PB_BIND(alox_EspNowTapEvent, alox_EspNowTapEvent, AUTO)
main/proto/esp_now_messages.pb.h
+53 -4
View File
@@ -31,7 +31,8 @@ typedef enum _alox_EspNowMessageType {
alox_EspNowMessageType_ESPNOW_SET_TAP_NOTIFY = 17,
alox_EspNowMessageType_ESPNOW_TAP_EVENT = 18,
alox_EspNowMessageType_ESPNOW_ECHO_PING = 19,
alox_EspNowMessageType_ESPNOW_ECHO_PONG = 20
alox_EspNowMessageType_ESPNOW_ECHO_PONG = 20,
alox_EspNowMessageType_ESPNOW_SET_TAP_CONFIG = 21
} alox_EspNowMessageType;
/* Struct definitions */
@@ -110,6 +111,20 @@ typedef struct _alox_EspNowTapNotify {
bool triple;
} alox_EspNowTapNotify;
/* * Master → slave: BMA456H multitap detection parameters. */
typedef struct _alox_EspNowTapConfig {
uint32_t client_id; /* 0 = all slaves; otherwise only matching slave_id applies */
uint32_t tap_sens_thres;
uint32_t max_gest_dur;
uint32_t tap_shock_dur;
uint32_t quite_time_after_gest;
uint32_t wait_for_timeout;
uint32_t axis_sel;
bool enable_single;
bool enable_double;
bool enable_triple;
} alox_EspNowTapConfig;
/* * Slave → master: tap detected on BMA456 (event, not periodic). */
typedef struct _alox_EspNowTapEvent {
uint32_t slave_id;
@@ -188,6 +203,7 @@ typedef struct _alox_EspNowMessage {
alox_EspNowTapEvent tap_event;
alox_EspNowEchoPing echo_ping;
alox_EspNowEchoPong echo_pong;
alox_EspNowTapConfig tap_config;
} payload;
} alox_EspNowMessage;
@@ -198,8 +214,9 @@ extern "C" {
/* Helper constants for enums */
#define _alox_EspNowMessageType_MIN alox_EspNowMessageType_ESPNOW_UNKNOWN
#define _alox_EspNowMessageType_MAX alox_EspNowMessageType_ESPNOW_ECHO_PONG
#define _alox_EspNowMessageType_ARRAYSIZE ((alox_EspNowMessageType)(alox_EspNowMessageType_ESPNOW_ECHO_PONG+1))
#define _alox_EspNowMessageType_MAX alox_EspNowMessageType_ESPNOW_SET_TAP_CONFIG
#define _alox_EspNowMessageType_ARRAYSIZE ((alox_EspNowMessageType)(alox_EspNowMessageType_ESPNOW_SET_TAP_CONFIG+1))
@@ -236,6 +253,7 @@ extern "C" {
#define alox_EspNowAccelSample_init_default {0, 0, 0, 0}
#define alox_EspNowBatteryQuery_init_default {0}
#define alox_EspNowTapNotify_init_default {0, 0, 0, 0}
#define alox_EspNowTapConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
#define alox_EspNowTapEvent_init_default {0, 0}
#define alox_EspNowBatteryReport_init_default {0, 0, 0, 0, 0}
#define alox_EspNowLedRing_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
@@ -256,6 +274,7 @@ extern "C" {
#define alox_EspNowAccelSample_init_zero {0, 0, 0, 0}
#define alox_EspNowBatteryQuery_init_zero {0}
#define alox_EspNowTapNotify_init_zero {0, 0, 0, 0}
#define alox_EspNowTapConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
#define alox_EspNowTapEvent_init_zero {0, 0}
#define alox_EspNowBatteryReport_init_zero {0, 0, 0, 0, 0}
#define alox_EspNowLedRing_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
@@ -294,6 +313,16 @@ extern "C" {
#define alox_EspNowTapNotify_single_tag 2
#define alox_EspNowTapNotify_double_tap_tag 3
#define alox_EspNowTapNotify_triple_tag 4
#define alox_EspNowTapConfig_client_id_tag 1
#define alox_EspNowTapConfig_tap_sens_thres_tag 2
#define alox_EspNowTapConfig_max_gest_dur_tag 3
#define alox_EspNowTapConfig_tap_shock_dur_tag 4
#define alox_EspNowTapConfig_quite_time_after_gest_tag 5
#define alox_EspNowTapConfig_wait_for_timeout_tag 6
#define alox_EspNowTapConfig_axis_sel_tag 7
#define alox_EspNowTapConfig_enable_single_tag 8
#define alox_EspNowTapConfig_enable_double_tag 9
#define alox_EspNowTapConfig_enable_triple_tag 10
#define alox_EspNowTapEvent_slave_id_tag 1
#define alox_EspNowTapEvent_kind_tag 2
#define alox_EspNowBatteryReport_client_id_tag 1
@@ -338,6 +367,7 @@ extern "C" {
#define alox_EspNowMessage_tap_event_tag 19
#define alox_EspNowMessage_echo_ping_tag 20
#define alox_EspNowMessage_echo_pong_tag 21
#define alox_EspNowMessage_tap_config_tag 22
/* Struct field encoding specification for nanopb */
#define alox_EspNowUnicastTest_FIELDLIST(X, a) \
@@ -416,6 +446,20 @@ X(a, STATIC, SINGULAR, BOOL, triple, 4)
#define alox_EspNowTapNotify_CALLBACK NULL
#define alox_EspNowTapNotify_DEFAULT NULL
#define alox_EspNowTapConfig_FIELDLIST(X, a) \
X(a, STATIC, SINGULAR, UINT32, client_id, 1) \
X(a, STATIC, SINGULAR, UINT32, tap_sens_thres, 2) \
X(a, STATIC, SINGULAR, UINT32, max_gest_dur, 3) \
X(a, STATIC, SINGULAR, UINT32, tap_shock_dur, 4) \
X(a, STATIC, SINGULAR, UINT32, quite_time_after_gest, 5) \
X(a, STATIC, SINGULAR, UINT32, wait_for_timeout, 6) \
X(a, STATIC, SINGULAR, UINT32, axis_sel, 7) \
X(a, STATIC, SINGULAR, BOOL, enable_single, 8) \
X(a, STATIC, SINGULAR, BOOL, enable_double, 9) \
X(a, STATIC, SINGULAR, BOOL, enable_triple, 10)
#define alox_EspNowTapConfig_CALLBACK NULL
#define alox_EspNowTapConfig_DEFAULT NULL
#define alox_EspNowTapEvent_FIELDLIST(X, a) \
X(a, STATIC, SINGULAR, UINT32, slave_id, 1) \
X(a, STATIC, SINGULAR, UINT32, kind, 2)
@@ -489,7 +533,8 @@ X(a, STATIC, ONEOF, MESSAGE, (payload,battery_report,payload.battery_repor
X(a, STATIC, ONEOF, MESSAGE, (payload,tap_notify,payload.tap_notify), 18) \
X(a, STATIC, ONEOF, MESSAGE, (payload,tap_event,payload.tap_event), 19) \
X(a, STATIC, ONEOF, MESSAGE, (payload,echo_ping,payload.echo_ping), 20) \
X(a, STATIC, ONEOF, MESSAGE, (payload,echo_pong,payload.echo_pong), 21)
X(a, STATIC, ONEOF, MESSAGE, (payload,echo_pong,payload.echo_pong), 21) \
X(a, STATIC, ONEOF, MESSAGE, (payload,tap_config,payload.tap_config), 22)
#define alox_EspNowMessage_CALLBACK NULL
#define alox_EspNowMessage_DEFAULT NULL
#define alox_EspNowMessage_payload_discover_MSGTYPE alox_EspNowDiscover
@@ -512,6 +557,7 @@ X(a, STATIC, ONEOF, MESSAGE, (payload,echo_pong,payload.echo_pong), 21)
#define alox_EspNowMessage_payload_tap_event_MSGTYPE alox_EspNowTapEvent
#define alox_EspNowMessage_payload_echo_ping_MSGTYPE alox_EspNowEchoPing
#define alox_EspNowMessage_payload_echo_pong_MSGTYPE alox_EspNowEchoPong
#define alox_EspNowMessage_payload_tap_config_MSGTYPE alox_EspNowTapConfig
extern const pb_msgdesc_t alox_EspNowUnicastTest_msg;
extern const pb_msgdesc_t alox_EspNowEchoPing_msg;
@@ -525,6 +571,7 @@ extern const pb_msgdesc_t alox_EspNowAccelStream_msg;
extern const pb_msgdesc_t alox_EspNowAccelSample_msg;
extern const pb_msgdesc_t alox_EspNowBatteryQuery_msg;
extern const pb_msgdesc_t alox_EspNowTapNotify_msg;
extern const pb_msgdesc_t alox_EspNowTapConfig_msg;
extern const pb_msgdesc_t alox_EspNowTapEvent_msg;
extern const pb_msgdesc_t alox_EspNowBatteryReport_msg;
extern const pb_msgdesc_t alox_EspNowLedRing_msg;
@@ -547,6 +594,7 @@ extern const pb_msgdesc_t alox_EspNowMessage_msg;
#define alox_EspNowAccelSample_fields &alox_EspNowAccelSample_msg
#define alox_EspNowBatteryQuery_fields &alox_EspNowBatteryQuery_msg
#define alox_EspNowTapNotify_fields &alox_EspNowTapNotify_msg
#define alox_EspNowTapConfig_fields &alox_EspNowTapConfig_msg
#define alox_EspNowTapEvent_fields &alox_EspNowTapEvent_msg
#define alox_EspNowBatteryReport_fields &alox_EspNowBatteryReport_msg
#define alox_EspNowLedRing_fields &alox_EspNowLedRing_msg
@@ -575,6 +623,7 @@ extern const pb_msgdesc_t alox_EspNowMessage_msg;
#define alox_EspNowOtaStart_size 6
#define alox_EspNowOtaStatus_size 18
#define alox_EspNowRestart_size 6
#define alox_EspNowTapConfig_size 48
#define alox_EspNowTapEvent_size 12
#define alox_EspNowTapNotify_size 12
#define alox_EspNowUnicastTest_size 6
main/proto/esp_now_messages.proto
+16
View File
@@ -26,6 +26,7 @@ enum EspNowMessageType {
ESPNOW_TAP_EVENT = 18;
ESPNOW_ECHO_PING = 19;
ESPNOW_ECHO_PONG = 20;
ESPNOW_SET_TAP_CONFIG = 21;
}
message EspNowUnicastTest {
@@ -103,6 +104,20 @@ message EspNowTapNotify {
bool triple = 4;
}
/** Master → slave: BMA456H multitap detection parameters. */
message EspNowTapConfig {
uint32 client_id = 1; // 0 = all slaves; otherwise only matching slave_id applies
uint32 tap_sens_thres = 2;
uint32 max_gest_dur = 3;
uint32 tap_shock_dur = 4;
uint32 quite_time_after_gest = 5;
uint32 wait_for_timeout = 6;
uint32 axis_sel = 7;
bool enable_single = 8;
bool enable_double = 9;
bool enable_triple = 10;
}
/** Slave → master: tap detected on BMA456 (event, not periodic). */
message EspNowTapEvent {
uint32 slave_id = 1;
@@ -177,5 +192,6 @@ message EspNowMessage {
EspNowTapEvent tap_event = 19;
EspNowEchoPing echo_ping = 20;
EspNowEchoPong echo_pong = 21;
EspNowTapConfig tap_config = 22;
}
}
main/proto/uart_messages.pb.c
+6
View File
@@ -117,6 +117,12 @@ PB_BIND(alox_SetLogLevelRequest, alox_SetLogLevelRequest, AUTO)
PB_BIND(alox_SetLogLevelResponse, alox_SetLogLevelResponse, AUTO)
PB_BIND(alox_TapConfigRequest, alox_TapConfigRequest, AUTO)
PB_BIND(alox_TapConfigResponse, alox_TapConfigResponse, AUTO)
PB_BIND(alox_OtaStartPayload, alox_OtaStartPayload, AUTO)
main/proto/uart_messages.pb.h
+114 -4
View File
@@ -36,7 +36,9 @@ typedef enum _alox_MessageType {
/* * Host → master → slave → master: timestamp echo round-trip (latency test). */
alox_MessageType_ESPNOW_ECHO_PING = 30,
/* * Host → master: get/set ESP-IDF log level for tag "*" (global). */
alox_MessageType_SET_LOG_LEVEL = 31
alox_MessageType_SET_LOG_LEVEL = 31,
/* * Host → master: get/set BMA456H multitap detection parameters. */
alox_MessageType_TAP_CONFIG = 32
} alox_MessageType;
typedef enum _alox_TapKind {
@@ -321,6 +323,38 @@ typedef struct _alox_SetLogLevelResponse {
uint32_t level;
} alox_SetLogLevelResponse;
/* write=false: read tap config; write=true: apply + persist on target node.
client_id 0 = local BMA456; >0 = slave id on master; all_clients = push to all slaves. */
typedef struct _alox_TapConfigRequest {
bool write;
uint32_t client_id;
bool all_clients;
uint32_t tap_sens_thres;
uint32_t max_gest_dur;
uint32_t tap_shock_dur;
uint32_t quite_time_after_gest;
uint32_t wait_for_timeout;
uint32_t axis_sel;
bool enable_single;
bool enable_double;
bool enable_triple;
} alox_TapConfigRequest;
typedef struct _alox_TapConfigResponse {
uint32_t client_id;
bool success;
uint32_t slaves_updated;
uint32_t tap_sens_thres;
uint32_t max_gest_dur;
uint32_t tap_shock_dur;
uint32_t quite_time_after_gest;
uint32_t wait_for_timeout;
uint32_t axis_sel;
bool enable_single;
bool enable_double;
bool enable_triple;
} alox_TapConfigResponse;
/* Host → device: begin UART OTA (erase inactive OTA slot; device replies OTA_STATUS). */
typedef struct _alox_OtaStartPayload {
uint32_t total_size;
@@ -407,6 +441,8 @@ typedef struct _alox_UartMessage {
alox_EspNowEchoPingResponse espnow_echo_ping_response;
alox_SetLogLevelRequest set_log_level_request;
alox_SetLogLevelResponse set_log_level_response;
alox_TapConfigRequest tap_config_request;
alox_TapConfigResponse tap_config_response;
} payload;
} alox_UartMessage;
@@ -417,8 +453,8 @@ extern "C" {
/* Helper constants for enums */
#define _alox_MessageType_MIN alox_MessageType_UNKNOWN
#define _alox_MessageType_MAX alox_MessageType_SET_LOG_LEVEL
#define _alox_MessageType_ARRAYSIZE ((alox_MessageType)(alox_MessageType_SET_LOG_LEVEL+1))
#define _alox_MessageType_MAX alox_MessageType_TAP_CONFIG
#define _alox_MessageType_ARRAYSIZE ((alox_MessageType)(alox_MessageType_TAP_CONFIG+1))
#define _alox_TapKind_MIN alox_TapKind_TAP_NONE
#define _alox_TapKind_MAX alox_TapKind_TAP_TRIPLE
@@ -469,6 +505,8 @@ extern "C" {
@@ -510,6 +548,8 @@ extern "C" {
#define alox_RestartResponse_init_default {0, 0}
#define alox_SetLogLevelRequest_init_default {0, 0}
#define alox_SetLogLevelResponse_init_default {0, 0}
#define alox_TapConfigRequest_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
#define alox_TapConfigResponse_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
#define alox_OtaStartPayload_init_default {0}
#define alox_OtaPayload_init_default {0, {0, {0}}}
#define alox_OtaEndPayload_init_default {0}
@@ -554,6 +594,8 @@ extern "C" {
#define alox_RestartResponse_init_zero {0, 0}
#define alox_SetLogLevelRequest_init_zero {0, 0}
#define alox_SetLogLevelResponse_init_zero {0, 0}
#define alox_TapConfigRequest_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
#define alox_TapConfigResponse_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
#define alox_OtaStartPayload_init_zero {0}
#define alox_OtaPayload_init_zero {0, {0, {0}}}
#define alox_OtaEndPayload_init_zero {0}
@@ -681,6 +723,30 @@ extern "C" {
#define alox_SetLogLevelRequest_level_tag 2
#define alox_SetLogLevelResponse_success_tag 1
#define alox_SetLogLevelResponse_level_tag 2
#define alox_TapConfigRequest_write_tag 1
#define alox_TapConfigRequest_client_id_tag 2
#define alox_TapConfigRequest_all_clients_tag 3
#define alox_TapConfigRequest_tap_sens_thres_tag 4
#define alox_TapConfigRequest_max_gest_dur_tag 5
#define alox_TapConfigRequest_tap_shock_dur_tag 6
#define alox_TapConfigRequest_quite_time_after_gest_tag 7
#define alox_TapConfigRequest_wait_for_timeout_tag 8
#define alox_TapConfigRequest_axis_sel_tag 9
#define alox_TapConfigRequest_enable_single_tag 10
#define alox_TapConfigRequest_enable_double_tag 11
#define alox_TapConfigRequest_enable_triple_tag 12
#define alox_TapConfigResponse_client_id_tag 1
#define alox_TapConfigResponse_success_tag 2
#define alox_TapConfigResponse_slaves_updated_tag 3
#define alox_TapConfigResponse_tap_sens_thres_tag 4
#define alox_TapConfigResponse_max_gest_dur_tag 5
#define alox_TapConfigResponse_tap_shock_dur_tag 6
#define alox_TapConfigResponse_quite_time_after_gest_tag 7
#define alox_TapConfigResponse_wait_for_timeout_tag 8
#define alox_TapConfigResponse_axis_sel_tag 9
#define alox_TapConfigResponse_enable_single_tag 10
#define alox_TapConfigResponse_enable_double_tag 11
#define alox_TapConfigResponse_enable_triple_tag 12
#define alox_OtaStartPayload_total_size_tag 1
#define alox_OtaPayload_seq_tag 1
#define alox_OtaPayload_data_tag 2
@@ -733,6 +799,8 @@ extern "C" {
#define alox_UartMessage_espnow_echo_ping_response_tag 36
#define alox_UartMessage_set_log_level_request_tag 37
#define alox_UartMessage_set_log_level_response_tag 38
#define alox_UartMessage_tap_config_request_tag 39
#define alox_UartMessage_tap_config_response_tag 40
/* Struct field encoding specification for nanopb */
#define alox_UartMessage_FIELDLIST(X, a) \
@@ -769,7 +837,9 @@ X(a, STATIC, ONEOF, MESSAGE, (payload,cache_status_response,payload.cache_
X(a, STATIC, ONEOF, MESSAGE, (payload,espnow_echo_ping_request,payload.espnow_echo_ping_request), 35) \
X(a, STATIC, ONEOF, MESSAGE, (payload,espnow_echo_ping_response,payload.espnow_echo_ping_response), 36) \
X(a, STATIC, ONEOF, MESSAGE, (payload,set_log_level_request,payload.set_log_level_request), 37) \
X(a, STATIC, ONEOF, MESSAGE, (payload,set_log_level_response,payload.set_log_level_response), 38)
X(a, STATIC, ONEOF, MESSAGE, (payload,set_log_level_response,payload.set_log_level_response), 38) \
X(a, STATIC, ONEOF, MESSAGE, (payload,tap_config_request,payload.tap_config_request), 39) \
X(a, STATIC, ONEOF, MESSAGE, (payload,tap_config_response,payload.tap_config_response), 40)
#define alox_UartMessage_CALLBACK NULL
#define alox_UartMessage_DEFAULT NULL
#define alox_UartMessage_payload_ack_payload_MSGTYPE alox_Ack
@@ -805,6 +875,8 @@ X(a, STATIC, ONEOF, MESSAGE, (payload,set_log_level_response,payload.set_l
#define alox_UartMessage_payload_espnow_echo_ping_response_MSGTYPE alox_EspNowEchoPingResponse
#define alox_UartMessage_payload_set_log_level_request_MSGTYPE alox_SetLogLevelRequest
#define alox_UartMessage_payload_set_log_level_response_MSGTYPE alox_SetLogLevelResponse
#define alox_UartMessage_payload_tap_config_request_MSGTYPE alox_TapConfigRequest
#define alox_UartMessage_payload_tap_config_response_MSGTYPE alox_TapConfigResponse
#define alox_Ack_FIELDLIST(X, a) \
@@ -1078,6 +1150,38 @@ X(a, STATIC, SINGULAR, UINT32, level, 2)
#define alox_SetLogLevelResponse_CALLBACK NULL
#define alox_SetLogLevelResponse_DEFAULT NULL
#define alox_TapConfigRequest_FIELDLIST(X, a) \
X(a, STATIC, SINGULAR, BOOL, write, 1) \
X(a, STATIC, SINGULAR, UINT32, client_id, 2) \
X(a, STATIC, SINGULAR, BOOL, all_clients, 3) \
X(a, STATIC, SINGULAR, UINT32, tap_sens_thres, 4) \
X(a, STATIC, SINGULAR, UINT32, max_gest_dur, 5) \
X(a, STATIC, SINGULAR, UINT32, tap_shock_dur, 6) \
X(a, STATIC, SINGULAR, UINT32, quite_time_after_gest, 7) \
X(a, STATIC, SINGULAR, UINT32, wait_for_timeout, 8) \
X(a, STATIC, SINGULAR, UINT32, axis_sel, 9) \
X(a, STATIC, SINGULAR, BOOL, enable_single, 10) \
X(a, STATIC, SINGULAR, BOOL, enable_double, 11) \
X(a, STATIC, SINGULAR, BOOL, enable_triple, 12)
#define alox_TapConfigRequest_CALLBACK NULL
#define alox_TapConfigRequest_DEFAULT NULL
#define alox_TapConfigResponse_FIELDLIST(X, a) \
X(a, STATIC, SINGULAR, UINT32, client_id, 1) \
X(a, STATIC, SINGULAR, BOOL, success, 2) \
X(a, STATIC, SINGULAR, UINT32, slaves_updated, 3) \
X(a, STATIC, SINGULAR, UINT32, tap_sens_thres, 4) \
X(a, STATIC, SINGULAR, UINT32, max_gest_dur, 5) \
X(a, STATIC, SINGULAR, UINT32, tap_shock_dur, 6) \
X(a, STATIC, SINGULAR, UINT32, quite_time_after_gest, 7) \
X(a, STATIC, SINGULAR, UINT32, wait_for_timeout, 8) \
X(a, STATIC, SINGULAR, UINT32, axis_sel, 9) \
X(a, STATIC, SINGULAR, BOOL, enable_single, 10) \
X(a, STATIC, SINGULAR, BOOL, enable_double, 11) \
X(a, STATIC, SINGULAR, BOOL, enable_triple, 12)
#define alox_TapConfigResponse_CALLBACK NULL
#define alox_TapConfigResponse_DEFAULT NULL
#define alox_OtaStartPayload_FIELDLIST(X, a) \
X(a, STATIC, SINGULAR, UINT32, total_size, 1)
#define alox_OtaStartPayload_CALLBACK NULL
@@ -1163,6 +1267,8 @@ extern const pb_msgdesc_t alox_RestartRequest_msg;
extern const pb_msgdesc_t alox_RestartResponse_msg;
extern const pb_msgdesc_t alox_SetLogLevelRequest_msg;
extern const pb_msgdesc_t alox_SetLogLevelResponse_msg;
extern const pb_msgdesc_t alox_TapConfigRequest_msg;
extern const pb_msgdesc_t alox_TapConfigResponse_msg;
extern const pb_msgdesc_t alox_OtaStartPayload_msg;
extern const pb_msgdesc_t alox_OtaPayload_msg;
extern const pb_msgdesc_t alox_OtaEndPayload_msg;
@@ -1209,6 +1315,8 @@ extern const pb_msgdesc_t alox_OtaSlaveProgressResponse_msg;
#define alox_RestartResponse_fields &alox_RestartResponse_msg
#define alox_SetLogLevelRequest_fields &alox_SetLogLevelRequest_msg
#define alox_SetLogLevelResponse_fields &alox_SetLogLevelResponse_msg
#define alox_TapConfigRequest_fields &alox_TapConfigRequest_msg
#define alox_TapConfigResponse_fields &alox_TapConfigResponse_msg
#define alox_OtaStartPayload_fields &alox_OtaStartPayload_msg
#define alox_OtaPayload_fields &alox_OtaPayload_msg
#define alox_OtaEndPayload_fields &alox_OtaEndPayload_msg
@@ -1260,6 +1368,8 @@ extern const pb_msgdesc_t alox_OtaSlaveProgressResponse_msg;
#define alox_RestartResponse_size 8
#define alox_SetLogLevelRequest_size 8
#define alox_SetLogLevelResponse_size 8
#define alox_TapConfigRequest_size 52
#define alox_TapConfigResponse_size 56
#define alox_TapEvent_size 16
#define alox_TapNotifyRequest_size 16
#define alox_TapNotifyResponse_size 20
main/proto/uart_messages.proto
+36
View File
@@ -33,6 +33,8 @@ enum MessageType {
ESPNOW_ECHO_PING = 30;
/** Host → master: get/set ESP-IDF log level for tag "*" (global). */
SET_LOG_LEVEL = 31;
/** Host → master: get/set BMA456H multitap detection parameters. */
TAP_CONFIG = 32;
}
message UartMessage {
@@ -71,6 +73,8 @@ message UartMessage {
EspNowEchoPingResponse espnow_echo_ping_response = 36;
SetLogLevelRequest set_log_level_request = 37;
SetLogLevelResponse set_log_level_response = 38;
TapConfigRequest tap_config_request = 39;
TapConfigResponse tap_config_response = 40;
}
}
@@ -345,6 +349,38 @@ message SetLogLevelResponse {
uint32 level = 2;
}
// write=false: read tap config; write=true: apply + persist on target node.
// client_id 0 = local BMA456; >0 = slave id on master; all_clients = push to all slaves.
message TapConfigRequest {
bool write = 1;
uint32 client_id = 2;
bool all_clients = 3;
uint32 tap_sens_thres = 4;
uint32 max_gest_dur = 5;
uint32 tap_shock_dur = 6;
uint32 quite_time_after_gest = 7;
uint32 wait_for_timeout = 8;
uint32 axis_sel = 9;
bool enable_single = 10;
bool enable_double = 11;
bool enable_triple = 12;
}
message TapConfigResponse {
uint32 client_id = 1;
bool success = 2;
uint32 slaves_updated = 3;
uint32 tap_sens_thres = 4;
uint32 max_gest_dur = 5;
uint32 tap_shock_dur = 6;
uint32 quite_time_after_gest = 7;
uint32 wait_for_timeout = 8;
uint32 axis_sel = 9;
bool enable_single = 10;
bool enable_double = 11;
bool enable_triple = 12;
}
// Host → device: begin UART OTA (erase inactive OTA slot; device replies OTA_STATUS).
message OtaStartPayload {
uint32 total_size = 1;