Firmware: NVS UART bezpieczny sleep i kontrola CC1101

This commit is contained in:
czcionka committed 2026-10-27 18:16:19 +00:00
1 parent d7fc88c227
commit 032811a88c
10 files changed
+632 -1026

No files matched your search

+162 -459
View File
@@ -1,203 +1,61 @@
/*
* main.cpp - symulator 4 czujnikow TPMS Schrader EG53MA4 (ESP32 + CC1101)
* dla Opla Astry J Sedan 2016 (EU, 433 MHz, TPMS bezposredni).
*
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
* ZASTRZEZENIE: projekt wylacznie diagnostyczny/testowy.
* Symulator dostarcza SZTUCZNE dane cisnienia i temperatury i NIE
* zastepuje prawdziwych czujnikow TPMS. Nie uzywac podczas jazdy.
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
*
* Tryby pracy:
* NORMAL - rotacja 4 kol, burst 3-5 ramek co TX_INTERVAL_S, deep sleep
* miedzy transmisjami (budzik RTC + budzenie przyciskiem/LF)
* LEARN - nauka czujnikow w aucie: jedno kolo naraz, kolejnosc
* FL -> FR -> RR -> RL, przycisk = kolejne kolo, okno czasowe
* SINGLE - wymuszone nadawanie jednego ID (testy/procedury serwisowe)
*
* Protokol: rtl_433 src/devices/schraeder.c (schrader_EG53MA4),
* Manchester G.E.T. MC, chip 120 us, ASK/OOK 433.92 MHz (opcjonalnie 2-FSK).
*/
/* Symulator diagnostyczny TPMS. Sztuczne cisnienie moze ukryc usterke opony. */
#include <Arduino.h>
#include <esp_sleep.h>
#include <driver/gpio.h>
#include "config.h"
#include "tpms_frame.h"
#include "radio.h"
#include "power.h"
#include "ui.h"
#include "console.h"
#include "app.h"
#include "config.h"
#include "console.h"
#include "power.h"
#include "radio.h"
#include "settings_store.h"
#include "tpms_frame.h"
#include "ui.h"
/* ------------------------------------------------------------------ */
/* Dane czujnikow (mapowanie ID -> kolo) */
/* ------------------------------------------------------------------ */
#define KPA10(x) ((uint16_t)((x) * 10.0f + 0.5f))
AppState *g_app = nullptr;
static const tpms_sensor_t SENSOR[WHEEL_COUNT] = {
{ SENSOR_FL_ID, KPA10(SENSOR_FL_PRESS_KPA), SENSOR_TEMP_C, "FL" },
{ SENSOR_FR_ID, KPA10(SENSOR_FR_PRESS_KPA), SENSOR_TEMP_C, "FR" },
{ SENSOR_RR_ID, KPA10(SENSOR_RR_PRESS_KPA), SENSOR_TEMP_C, "RR" },
{ SENSOR_RL_ID, KPA10(SENSOR_RL_PRESS_KPA), SENSOR_TEMP_C, "RL" },
};
/* Kolejnosc nauki (kolejnosc w tablicy SENSOR = FL, FR, RR, RL). */
static const uint8_t LEARN_SEQ[WHEEL_COUNT] = {
LEARN_ORDER_0, LEARN_ORDER_1, LEARN_ORDER_2, LEARN_ORDER_3,
};
/* ------------------------------------------------------------------ */
/* Stan w RTC (przetrwuje deep sleep) */
/* ------------------------------------------------------------------ */
/* Magic zwiazany z wersja konfiguracji: zmiana CONFIG_VERSION (np. po
* zmianie formatu stanu w RTC) zeruje caly stan po wybudzeniu. */
#define RTC_MAGIC (0x54504D53u ^ (uint32_t)CONFIG_VERSION) // 'TPMS' ^ version
RTC_DATA_ATTR static uint32_t rtc_magic;
RTC_DATA_ATTR static uint8_t rtc_mode = APP_MODE_NORMAL;
RTC_DATA_ATTR static uint8_t rtc_seq_idx = 0; // pozycja w LEARN_SEQ (LEARN)
RTC_DATA_ATTR static uint8_t rtc_single_wheel = 0; // kolo w SINGLE (indeks SENSOR)
RTC_DATA_ATTR static uint8_t rtc_rot_idx = 0; // rotacja w NORMAL
RTC_DATA_ATTR static uint32_t rtc_wake_count = 0;
RTC_DATA_ATTR static uint32_t rtc_interval_s = 0; // 0 = auto wg ACC
RTC_DATA_ATTR static uint32_t rtc_flags = TPMS_FLAGS;
RTC_DATA_ATTR static uint64_t rtc_last_acc_ms = 0;
/* Stan sesji (wazny tylko w biezaczym wybudzeniu) */
static uint32_t stay_awake_until = 0;
static uint32_t next_tx_ms = 0;
static uint32_t learn_window_start = 0;
static uint32_t learn_session_start = 0;
static uint32_t single_start = 0;
static bool request_sleep = false;
static bool low_batt = false;
static uint32_t supply_mv = 0;
static const char *const WHEEL_NAMES[WHEEL_COUNT] = {"FL", "FR", "RR", "RL"};
static uint32_t stay_awake_until;
static bool request_sleep;
static uint32_t supply_mv;
#if PIN_LF_TRIGGER >= 0
static bool lf_prev = false; // poprzedni stan wejscia LF (zbocze)
static bool lf_previous;
#endif
/* ------------------------------------------------------------------ */
/* Pomocnicze */
/* ------------------------------------------------------------------ */
static uint32_t compute_interval(void);
/* Aktywne kolo: SINGLE trzyma bezposredni indeks SENSOR, LEARN - pozycje
* w sekwencji nauki LEARN_SEQ (moga sie roznic po zmianie LEARN_ORDER_*). */
static uint8_t active_wheel(void)
static bool ignition_on(void)
{
return (rtc_mode == APP_MODE_SINGLE)
? (uint8_t)(rtc_single_wheel % WHEEL_COUNT)
: LEARN_SEQ[rtc_seq_idx % WHEEL_COUNT];
#if PIN_ACC >= 0
return digitalRead(PIN_ACC) == HIGH;
#else
return false;
#endif
}
/* Pozycja kola w sekwencji nauki (do trybu LEARN). */
static uint8_t seq_pos_of(uint8_t wheel)
{
for (uint8_t i = 0; i < WHEEL_COUNT; i++) {
if (LEARN_SEQ[i] == wheel) {
return i;
class HardwareRadio final : public RadioSink {
public:
bool send(uint8_t wheel) override
{
if (wheel >= WHEEL_COUNT) {
return false;
}
const sensor_settings_t &sensor = g_settings.wheels[wheel];
uint8_t frame[TPMS_TX_BYTES];
if (!tpms_build_frame(frame, sensor.id, sensor.pressure_kpa10,
(int8_t)sensor.temp_c, g_settings.flags)) {
return false;
}
bool ok = radio_send_burst(frame, TPMS_TX_BYTES, g_settings.burst_frames,
g_settings.frame_gap_ms);
Serial.printf("TX %s id=%06X %u.%u kPa %d C flags=%08X%s\n",
WHEEL_NAMES[wheel], (unsigned)sensor.id,
sensor.pressure_kpa10 / 10u, sensor.pressure_kpa10 % 10u,
(int)sensor.temp_c, (unsigned)g_settings.flags,
ok ? "" : " TX-ERR");
return ok;
}
return 0;
}
};
static void refresh_power(void)
{
supply_mv = power_read_mv();
low_batt = power_low_battery(supply_mv);
}
static void build_frame_for(uint8_t wheel, uint8_t out[TPMS_TX_BYTES])
{
const tpms_sensor_t *s = &SENSOR[wheel % WHEEL_COUNT];
tpms_build_frame(out, s->id, s->press_kpa10, s->temp_c, rtc_flags, low_batt);
}
void app_send_burst_wheel(uint8_t wheel)
{
uint8_t frame[TPMS_TX_BYTES];
build_frame_for(wheel, frame);
bool ok = radio_send_burst(frame, TPMS_TX_BYTES, TX_BURST_FRAMES);
Serial.printf("TX %s id=%06X %.1f kPa %d C flags=%08X%s%s\n",
SENSOR[wheel % WHEEL_COUNT].name,
(unsigned)SENSOR[wheel % WHEEL_COUNT].id,
SENSOR[wheel % WHEEL_COUNT].press_kpa10 / 10.0f,
(int)SENSOR[wheel % WHEEL_COUNT].temp_c,
(unsigned)rtc_flags, low_batt ? " LOWBATT" : "",
ok ? "" : " TX-ERR");
}
void app_send_burst_all(void)
{
for (uint8_t i = 0; i < WHEEL_COUNT; i++) {
app_send_burst_wheel((uint8_t)((rtc_rot_idx + i) % WHEEL_COUNT));
}
rtc_rot_idx = (uint8_t)((rtc_rot_idx + 1) % WHEEL_COUNT);
}
void app_print_frame(uint8_t wheel)
{
uint8_t frame[TPMS_TX_BYTES];
uint8_t payload[TPMS_PAYLOAD_LEN];
const tpms_sensor_t *s = &SENSOR[wheel % WHEEL_COUNT];
build_frame_for(wheel, frame);
tpms_build_payload(payload, s->id, s->press_kpa10, s->temp_c, rtc_flags, low_batt);
Serial.printf("%s frame:", s->name);
for (uint8_t i = 0; i < TPMS_TX_BYTES; i++) {
Serial.printf(" %02X", frame[i]);
}
Serial.printf("\n%s payload:", s->name);
for (uint8_t i = 0; i < TPMS_PAYLOAD_LEN; i++) {
Serial.printf(" %02X", payload[i]);
}
Serial.printf(" crc=%02X id=%06X press=%.1f kPa temp=%d F\n",
payload[9], (unsigned)s->id,
payload[7] * 2.5f, (int)payload[8]);
}
void app_print_info(void)
{
Serial.printf("FW %s config v%d mode=%s wheel=%s\n",
FW_VERSION, CONFIG_VERSION,
rtc_mode == APP_MODE_NORMAL ? "NORMAL" :
rtc_mode == APP_MODE_LEARN ? "LEARN" : "SINGLE",
SENSOR[active_wheel()].name);
for (uint8_t i = 0; i < WHEEL_COUNT; i++) {
Serial.printf(" %s id=%06X press=%.1f kPa temp=%d C\n",
SENSOR[i].name, (unsigned)SENSOR[i].id,
SENSOR[i].press_kpa10 / 10.0f, (int)SENSOR[i].temp_c);
}
Serial.printf("flags=%08X mod=%s chip=%dus burst=%d interval=%us wake=%lu\n",
(unsigned)rtc_flags,
TPMS_MODULATION == MODE_FSK ? "FSK" : "OOK",
TPMS_CHIP_US, TX_BURST_FRAMES,
(unsigned)compute_interval(),
(unsigned long)rtc_wake_count);
Serial.printf("Vcc=%u mV%s\n", (unsigned)supply_mv, low_batt ? " LOWBATT" : "");
}
uint32_t app_supply_mv(void)
{
refresh_power();
return supply_mv;
}
void app_set_interval(uint32_t seconds)
{
rtc_interval_s = seconds;
}
void app_set_flags(uint32_t flags)
{
rtc_flags = flags;
}
void app_request_sleep(void)
{
request_sleep = true;
}
static HardwareRadio hardware_radio;
static AppState app_state(&g_settings, &hardware_radio);
void app_stay_awake(uint32_t ms)
{
@@ -207,94 +65,90 @@ void app_stay_awake(uint32_t ms)
}
}
uint8_t app_mode(void)
void app_request_sleep(void)
{
return rtc_mode;
request_sleep = true;
}
uint8_t app_wheel(void)
bool app_save_and_apply(void)
{
return active_wheel();
}
void app_next_wheel(void)
{
if (rtc_mode == APP_MODE_SINGLE) {
rtc_single_wheel = (uint8_t)((rtc_single_wheel + 1) % WHEEL_COUNT);
if (!settings_store_save()) {
Serial.println(F("BLAD: nie zapisano NVS (walidacja lub zapis)"));
return false;
}
else {
rtc_seq_idx = (uint8_t)((rtc_seq_idx + 1) % WHEEL_COUNT);
if (!radio_init(&g_settings)) {
Serial.println(F("OSTRZEZENIE: zapisano, ale CC1101 nie odpowiada"));
}
ui_blink_count((uint8_t)(active_wheel() + 1));
Serial.printf("Kolo: %s\n", SENSOR[active_wheel()].name);
learn_window_start = millis();
Serial.println(F("OK: zapisano w NVS"));
return true;
}
void app_set_mode(uint8_t mode, uint8_t wheel)
void app_print_frame(uint8_t wheel)
{
rtc_mode = mode;
switch (mode) {
case APP_MODE_LEARN:
rtc_seq_idx = seq_pos_of((uint8_t)(wheel % WHEEL_COUNT));
learn_window_start = millis();
learn_session_start = millis();
next_tx_ms = 0;
ui_set_pattern(UI_PAT_LEARN);
ui_blink_count((uint8_t)(active_wheel() + 1));
Serial.printf("LEARN start, kolo %s\n", SENSOR[active_wheel()].name);
app_stay_awake(LEARN_TOTAL_TIMEOUT_MS);
break;
case APP_MODE_SINGLE:
rtc_single_wheel = (uint8_t)(wheel % WHEEL_COUNT);
single_start = millis();
next_tx_ms = 0;
ui_set_pattern(UI_PAT_SINGLE);
ui_blink_count((uint8_t)(active_wheel() + 1));
Serial.printf("SINGLE start, kolo %s\n", SENSOR[active_wheel()].name);
app_stay_awake(SINGLE_TIMEOUT_MS ? SINGLE_TIMEOUT_MS : 3600000u);
break;
default:
rtc_mode = APP_MODE_NORMAL;
ui_set_pattern(UI_PAT_NORMAL);
Serial.println(F("NORMAL"));
next_tx_ms = 0;
app_stay_awake(BOOT_STAY_AWAKE_MS);
break;
if (wheel >= WHEEL_COUNT) {
return;
}
const sensor_settings_t &s = g_settings.wheels[wheel];
uint8_t frame[TPMS_TX_BYTES];
uint8_t payload[TPMS_PAYLOAD_LEN];
if (!tpms_build_frame(frame, s.id, s.pressure_kpa10, (int8_t)s.temp_c,
g_settings.flags)
|| !tpms_build_payload(payload, s.id, s.pressure_kpa10,
(int8_t)s.temp_c, g_settings.flags)) {
Serial.println(F("BLAD: nieprawidlowa konfiguracja ramki"));
return;
}
Serial.printf("%s payload:", WHEEL_NAMES[wheel]);
for (uint8_t i = 0; i < TPMS_PAYLOAD_LEN; ++i) {
Serial.printf(" %02X", payload[i]);
}
Serial.printf("\n%s frame:", WHEEL_NAMES[wheel]);
for (uint8_t i = 0; i < TPMS_TX_BYTES; ++i) {
Serial.printf(" %02X", frame[i]);
}
Serial.println();
}
void app_print_info(void)
{
Serial.printf("FW %s NVS v%u mode=%u wheel=%s errors=%lu\n", FW_VERSION,
(unsigned)SETTINGS_VERSION, (unsigned)g_app->mode(),
WHEEL_NAMES[g_app->active_wheel()],
(unsigned long)g_app->last_error_count());
for (uint8_t i = 0; i < WHEEL_COUNT; ++i) {
const sensor_settings_t &s = g_settings.wheels[i];
Serial.printf(" %s id=%06X pressure=%u.%u kPa temp=%d C\n",
WHEEL_NAMES[i], (unsigned)s.id, s.pressure_kpa10 / 10u,
s.pressure_kpa10 % 10u, (int)s.temp_c);
}
Serial.printf("flags=%08X OOK chip=%u us burst=%u gap=%u ms\n",
(unsigned)g_settings.flags, TPMS_CHIP_US, g_settings.burst_frames,
g_settings.frame_gap_ms);
Serial.printf("RF=%.2f MHz power=%d dBm intervals=%lu/%lu/%lu s\n",
g_settings.frequency_mhz, g_settings.tx_power_dbm,
(unsigned long)g_settings.normal_interval_s,
(unsigned long)g_settings.ignition_interval_s,
(unsigned long)g_settings.parking_interval_s);
Serial.printf("Vcc=%u mV (nie zmienia flag TPMS)\n", (unsigned)supply_mv);
}
static void sync_ui(void)
{
static AppMode previous_mode = AppMode::NORMAL;
static uint8_t previous_wheel = UINT8_MAX;
AppMode mode = g_app->mode();
uint8_t wheel = g_app->active_wheel();
if (mode != previous_mode || wheel != previous_wheel) {
ui_set_pattern(mode == AppMode::LEARN ? UI_PAT_LEARN
: mode == AppMode::SINGLE ? UI_PAT_SINGLE : UI_PAT_NORMAL);
if (mode != AppMode::NORMAL) {
ui_blink_count((uint8_t)(wheel + 1u));
}
previous_mode = mode;
previous_wheel = wheel;
}
}
/* ------------------------------------------------------------------ */
/* Cykl nadawczy w trybie NORMAL */
/* ------------------------------------------------------------------ */
static uint32_t compute_interval(void)
{
if (rtc_interval_s != 0) {
return rtc_interval_s;
}
#if PIN_ACC < 0
/* Bez wejscia ACC stale pracujemy z interwalem podstawowym - logika
* "5 min po zaniku ACC" nie ma wtedy zastosowania. */
return (uint32_t)TX_INTERVAL_S;
#else
uint64_t now_ms = power_elapsed_ms();
if (digitalRead(PIN_ACC) == HIGH) {
rtc_last_acc_ms = now_ms;
return (uint32_t)TX_INTERVAL_IGNITION_S;
}
if (now_ms - rtc_last_acc_ms > (uint64_t)ACC_GRACE_MS) {
return PARKING_SHUTDOWN ? 0u : (uint32_t)TX_INTERVAL_PARKING_S;
}
return (uint32_t)TX_INTERVAL_S;
#endif
}
static void tx_cycle(void)
{
refresh_power();
app_send_burst_all();
}
/* Czy ktorekolwiek zrodlo budzenia poziomowego jest aktywne? */
static bool wake_sources_active(void)
{
if (ui_button_down() || digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL) {
@@ -308,244 +162,93 @@ static bool wake_sources_active(void)
return false;
}
static void go_sleep(uint32_t seconds)
static void go_sleep(void)
{
/* Nie spij, dopoki przycisk jest wcisniety lub LF aktywne - EXT0/EXT1
* dzialaja poziomowo, wiec sen przy aktywnym zrodle = natychmiastowa
* petla wybudzen. Dajemy krotki margines i wracamy do petli. */
if (wake_sources_active()) {
app_stay_awake(500);
if (g_app->mode() != AppMode::NORMAL) {
return;
}
if (wake_sources_active()) {
app_stay_awake(500u);
return;
}
uint32_t seconds = g_app->interval_s(ignition_on());
ui_set_pattern(UI_PAT_OFF);
digitalWrite(PIN_LED, LOW);
Serial.printf("sleep %us\n", (unsigned)seconds);
Serial.printf("sleep %lu s\n", (unsigned long)seconds);
Serial.flush();
power_deep_sleep(seconds); // nie wraca
power_deep_sleep(seconds);
}
/* ------------------------------------------------------------------ */
void setup(void)
{
Serial.begin(SERIAL_BAUD);
ui_init();
power_init();
settings_store_begin();
console_init();
#if PIN_LF_TRIGGER >= 0
pinMode(PIN_LF_TRIGGER, INPUT_PULLDOWN);
lf_previous = digitalRead(PIN_LF_TRIGGER) == HIGH;
#endif
#if PIN_ACC >= 0
/* INPUT (bez podciagania): dolna galazka dzielnika wymusza stan niski,
* a wewnetrzny pulldown (~45 k) obciazylby dzielnik i zbil prog VIH. */
pinMode(PIN_ACC, INPUT);
#endif
if (rtc_magic != RTC_MAGIC) {
rtc_magic = RTC_MAGIC;
rtc_mode = APP_MODE_NORMAL;
rtc_seq_idx = 0;
rtc_single_wheel = 0;
rtc_rot_idx = 0;
rtc_wake_count = 0;
rtc_interval_s = 0;
rtc_flags = TPMS_FLAGS;
rtc_last_acc_ms = 0;
g_app = &app_state;
bool radio_ready = radio_init(&g_settings);
supply_mv = power_read_mv();
Serial.printf("\nTPMS DIAG FW %s - DANE SZTUCZNE, NIE DO JAZDY\n", FW_VERSION);
Serial.printf("NVS: %s; dostep=%s\n",
settings_load_result_text(settings_store_last_load()),
settings_store_available() ? "tak" : "nie");
if (!radio_ready) {
Serial.println(F("BLAD: brak CC1101; sprawdz 3V3/SPI"));
}
rtc_wake_count++;
bool radio_ok = radio_init();
Serial.println();
Serial.printf("TPMS simulator FW %s (config v%d) - SYMULATOR, dane sztuczne!\n",
FW_VERSION, CONFIG_VERSION);
if (!radio_ok) {
Serial.println(F("BLAD: brak modulu CC1101 (sprawdz SPI)"));
}
refresh_power();
if (low_batt) {
Serial.printf("OSTRZEZENIE: niskie napiecie zasilania %u mV!\n",
(unsigned)supply_mv);
if (power_low_battery(supply_mv)) {
Serial.println(F("OSTRZEZENIE: niskie zasilanie emulatora"));
}
esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
uint32_t iv = compute_interval();
switch (cause) {
case ESP_SLEEP_WAKEUP_TIMER:
/* zwykly cykl - nadaj i spij bez czuwania */
next_tx_ms = 0;
stay_awake_until = 0;
break;
case ESP_SLEEP_WAKEUP_EXT0:
/* przycisk - obsluga gestu w petli, krotkie okno konsoli */
Serial.println(F("wake: button"));
next_tx_ms = UINT32_MAX; // nie nadawaj automatycznie
stay_awake_until = millis() + BOOT_STAY_AWAKE_MS;
break;
case ESP_SLEEP_WAKEUP_EXT1: {
uint64_t st = esp_sleep_get_ext1_wakeup_status();
Serial.printf("wake: ext1 mask=%08X%08X\n",
(unsigned)(st >> 32), (unsigned)(st & 0xFFFFFFFFu));
refresh_power();
app_send_burst_wheel(active_wheel()); // aktywacja LF = natychmiast
next_tx_ms = UINT32_MAX;
stay_awake_until = millis() + BOOT_STAY_AWAKE_MS;
break;
}
default:
Serial.println(F("wake: power-on"));
next_tx_ms = 0;
stay_awake_until = millis() + BOOT_STAY_AWAKE_MS;
break;
}
if (rtc_mode == APP_MODE_LEARN) {
ui_set_pattern(UI_PAT_LEARN);
learn_window_start = millis();
learn_session_start = millis();
next_tx_ms = 0;
stay_awake_until = millis() + LEARN_TOTAL_TIMEOUT_MS;
}
else if (rtc_mode == APP_MODE_SINGLE) {
ui_set_pattern(UI_PAT_SINGLE);
single_start = millis();
next_tx_ms = 0;
stay_awake_until = millis() +
(SINGLE_TIMEOUT_MS ? SINGLE_TIMEOUT_MS : 3600000u);
}
else {
ui_set_pattern(low_batt ? UI_PAT_LOWBAT : UI_PAT_NORMAL);
}
/* Po wybudzeniu przyciskiem/LF obsluzylismy juz akcje - nie powtarzaj
* cyklu natychmiast, tylko odloz go o pelny okres. */
if (cause == ESP_SLEEP_WAKEUP_EXT0 || cause == ESP_SLEEP_WAKEUP_EXT1) {
if (rtc_mode != APP_MODE_NORMAL) {
next_tx_ms = millis() + LEARN_TX_PERIOD_MS;
}
}
bool transmit = cause != ESP_SLEEP_WAKEUP_EXT0 && cause != ESP_SLEEP_WAKEUP_EXT1;
g_app->begin(millis(), transmit);
#if PIN_LF_TRIGGER >= 0
/* LF ciagle aktywne = brak nowego zbocza = brak kolejnego bursta */
lf_prev = (digitalRead(PIN_LF_TRIGGER) == HIGH);
if (cause == ESP_SLEEP_WAKEUP_EXT1) {
g_app->send_current();
}
#endif
Serial.printf("Vcc=%u mV tryb=%d interwal=%us\n", (unsigned)supply_mv,
(int)rtc_mode, (unsigned)iv);
stay_awake_until = cause == ESP_SLEEP_WAKEUP_TIMER
? millis() : millis() + BOOT_STAY_AWAKE_MS;
sync_ui();
app_print_info();
Serial.println(F("gotowy ('help' - komendy)"));
Serial.println(F("gotowy; help = komendy; stay 60 = konsola 60 s"));
}
void loop(void)
{
uint32_t now = millis();
ui_update();
/* gesty przycisku */
ui_event_t ev = ui_poll();
if (ev == UI_EV_SHORT) {
if (rtc_mode == APP_MODE_NORMAL) {
refresh_power();
app_send_burst_all(); // "aktywuj kolo" - nadaj teraz
}
else {
app_next_wheel(); // learn/single: kolejne kolo
}
switch (ui_poll()) {
case UI_EV_SHORT: g_app->short_press(now); break;
case UI_EV_LONG: g_app->long_press(now); break;
case UI_EV_VERYLONG: g_app->very_long_press(now); break;
default: break;
}
else if (ev == UI_EV_LONG) {
if (rtc_mode == APP_MODE_LEARN) {
app_set_mode(APP_MODE_NORMAL, 0);
}
else {
app_set_mode(APP_MODE_LEARN, 0);
}
}
else if (ev == UI_EV_VERYLONG) {
if (rtc_mode == APP_MODE_SINGLE) {
app_set_mode(APP_MODE_NORMAL, 0);
}
else {
app_set_mode(APP_MODE_SINGLE, active_wheel());
}
}
console_poll();
#if PIN_LF_TRIGGER >= 0
/* aktywacja LF tez dziala "na zywo" (nie tylko przez budzenie) */
{
bool lf = (digitalRead(PIN_LF_TRIGGER) == HIGH);
if (lf && !lf_prev) {
refresh_power();
app_send_burst_wheel(active_wheel());
/* po recznej transmisji odloz cykl - bez tego LF moglby
* wywolac 2-3 bursty zamiast jednego */
if (rtc_mode != APP_MODE_NORMAL) {
next_tx_ms = millis() + LEARN_TX_PERIOD_MS;
}
}
lf_prev = lf;
bool lf = digitalRead(PIN_LF_TRIGGER) == HIGH;
if (lf && !lf_previous) {
g_app->send_current();
app_stay_awake(BOOT_STAY_AWAKE_MS);
}
lf_previous = lf;
#endif
g_app->tick(millis(), ignition_on());
sync_ui();
if (request_sleep) {
request_sleep = false;
go_sleep(compute_interval());
}
switch (rtc_mode) {
case APP_MODE_LEARN:
if ((int32_t)(now - next_tx_ms) >= 0) {
refresh_power();
app_send_burst_wheel(active_wheel());
next_tx_ms = now + LEARN_TX_PERIOD_MS;
}
if (now - learn_window_start >= LEARN_WINDOW_MS) {
if (LEARN_WINDOW_EXPIRE_TO_NORMAL) {
Serial.println(F("okno learn minelo - powrot do NORMAL"));
app_set_mode(APP_MODE_NORMAL, 0);
}
else if (rtc_seq_idx + 1u >= WHEEL_COUNT) {
Serial.println(F("learn ukonczony - powrot do NORMAL"));
app_set_mode(APP_MODE_NORMAL, 0);
}
else {
app_next_wheel();
}
}
if (now - learn_session_start >= LEARN_TOTAL_TIMEOUT_MS) {
Serial.println(F("timeout learn - powrot do NORMAL"));
app_set_mode(APP_MODE_NORMAL, 0);
}
break;
case APP_MODE_SINGLE:
if ((int32_t)(now - next_tx_ms) >= 0) {
refresh_power();
app_send_burst_wheel(active_wheel());
next_tx_ms = now + LEARN_TX_PERIOD_MS;
}
if (SINGLE_TIMEOUT_MS && now - single_start >= SINGLE_TIMEOUT_MS) {
Serial.println(F("timeout single - powrot do NORMAL"));
app_set_mode(APP_MODE_NORMAL, 0);
}
break;
default: /* NORMAL */
if (next_tx_ms != UINT32_MAX && (int32_t)(now - next_tx_ms) >= 0) {
uint32_t iv = compute_interval();
tx_cycle();
next_tx_ms = now + (iv ? iv : 3600u) * 1000u;
}
if ((int32_t)(now - stay_awake_until) >= 0) {
go_sleep(compute_interval());
}
break;
go_sleep();
} else if (g_app->mode() == AppMode::NORMAL
&& (int32_t)(millis() - stay_awake_until) >= 0) {
go_sleep();
}
}