From 3dad173002f36255b4bb49c7dbe8d4ed8d954c96 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 17:48:40 +0000 Subject: [PATCH 01/19] Konfiguracja: walidowany i wersjonowany model NVS --- src/settings.cpp | 174 +++++++++++++++++++++++++++++++++++++++++++++++ src/settings.h | 81 ++++++++++++++++++++++ 2 files changed, 255 insertions(+) create mode 100644 src/settings.cpp create mode 100644 src/settings.h diff --git a/src/settings.cpp b/src/settings.cpp new file mode 100644 index 0000000..731cf79 --- /dev/null +++ b/src/settings.cpp @@ -0,0 +1,174 @@ +#include "settings.h" + +#include + +void settings_defaults(settings_t *out) +{ + static const uint32_t ids[WHEEL_COUNT] = { + 0x2FC871u, 0x2EAAF9u, 0x3495ACu, 0x2FC780u, + }; + memset(out, 0, sizeof(*out)); + for (uint8_t i = 0; i < WHEEL_COUNT; ++i) { + out->wheels[i].id = ids[i]; + out->wheels[i].pressure_kpa10 = 2600u; + out->wheels[i].temp_c = 23; + } + out->flags = 0x4C900070u; + out->normal_interval_s = 30u; + out->ignition_interval_s = 30u; + out->parking_interval_s = 120u; + out->frequency_mhz = 433.92f; + out->tx_power_dbm = -10; + out->burst_frames = 3u; + out->frame_gap_ms = 50u; +} + +bool settings_valid_id(uint32_t id) +{ + return id > 0u && id < 0xFFFFFFu; +} + +bool settings_valid_tx_power(int power_dbm) +{ + static const int8_t allowed[] = {-30, -20, -15, -10, -6, 0, 5}; + for (uint8_t i = 0; i < sizeof(allowed) / sizeof(allowed[0]); ++i) { + if (power_dbm == allowed[i]) { + return true; + } + } + return false; +} + +static bool valid_interval(uint32_t value) +{ + return value >= SETTINGS_INTERVAL_MIN_S && value <= SETTINGS_INTERVAL_MAX_S; +} + +bool settings_validate(const settings_t *cfg) +{ + if (cfg == NULL) { + return false; + } + for (uint8_t i = 0; i < WHEEL_COUNT; ++i) { + if (!settings_valid_id(cfg->wheels[i].id) + || cfg->wheels[i].pressure_kpa10 > SETTINGS_PRESSURE_MAX_KPA10 + || cfg->wheels[i].temp_c < -40 || cfg->wheels[i].temp_c > 85) { + return false; + } + for (uint8_t j = (uint8_t)(i + 1u); j < WHEEL_COUNT; ++j) { + if (cfg->wheels[i].id == cfg->wheels[j].id) { + return false; + } + } + } + return valid_interval(cfg->normal_interval_s) + && valid_interval(cfg->ignition_interval_s) + && valid_interval(cfg->parking_interval_s) + && cfg->frequency_mhz >= 433.05f && cfg->frequency_mhz <= 434.79f + && settings_valid_tx_power(cfg->tx_power_dbm) + && cfg->burst_frames >= 1u && cfg->burst_frames <= 8u + && cfg->frame_gap_ms >= 20u && cfg->frame_gap_ms <= 500u; +} + +bool settings_set_id(settings_t *cfg, uint8_t wheel, uint32_t id) +{ + if (cfg == NULL || wheel >= WHEEL_COUNT || !settings_valid_id(id)) { + return false; + } + for (uint8_t i = 0; i < WHEEL_COUNT; ++i) { + if (i != wheel && cfg->wheels[i].id == id) { + return false; + } + } + cfg->wheels[wheel].id = id; + return true; +} + +void settings_generate_ids(settings_t *cfg, uint32_t seed) +{ + if (seed == 0u) { + seed = 0x6D2B79F5u; + } + for (uint8_t i = 0; i < WHEEL_COUNT; ++i) { + uint32_t candidate; + bool duplicate; + do { + seed ^= seed << 13; + seed ^= seed >> 17; + seed ^= seed << 5; + candidate = (seed & 0xFFFFFFu); + if (!settings_valid_id(candidate)) { + candidate = (candidate % 0xFFFFFEu) + 1u; + } + duplicate = false; + for (uint8_t j = 0; j < i; ++j) { + duplicate |= cfg->wheels[j].id == candidate; + } + } while (duplicate); + cfg->wheels[i].id = candidate; + } +} + +uint32_t settings_crc32(const void *data, size_t len) +{ + const uint8_t *p = (const uint8_t *)data; + uint32_t crc = 0xFFFFFFFFu; + for (size_t i = 0; i < len; ++i) { + crc ^= p[i]; + for (uint8_t bit = 0; bit < 8u; ++bit) { + crc = (crc >> 1) ^ ((crc & 1u) ? 0xEDB88320u : 0u); + } + } + return ~crc; +} + +void settings_make_blob(const settings_t *cfg, settings_blob_t *blob) +{ + memset(blob, 0, sizeof(*blob)); + blob->magic = SETTINGS_MAGIC; + blob->version = SETTINGS_VERSION; + blob->size = sizeof(blob->values); + blob->values = *cfg; + blob->crc32 = settings_crc32(blob, offsetof(settings_blob_t, crc32)); +} + +settings_load_result_t settings_decode_blob(const settings_blob_t *blob, + settings_t *out) +{ + if (blob == NULL || out == NULL) { + return SETTINGS_LOAD_IO_ERROR; + } + if (blob->magic != SETTINGS_MAGIC) { + return SETTINGS_LOAD_BAD_MAGIC; + } + if (blob->version != SETTINGS_VERSION) { + return SETTINGS_LOAD_BAD_VERSION; + } + if (blob->size != sizeof(blob->values)) { + return SETTINGS_LOAD_BAD_SIZE; + } + uint32_t expected = settings_crc32(blob, offsetof(settings_blob_t, crc32)); + if (expected != blob->crc32) { + return SETTINGS_LOAD_BAD_CRC; + } + if (!settings_validate(&blob->values)) { + return SETTINGS_LOAD_INVALID; + } + *out = blob->values; + return SETTINGS_LOAD_OK; +} + +const char *settings_load_result_text(settings_load_result_t result) +{ + switch (result) { + case SETTINGS_LOAD_OK: return "OK"; + case SETTINGS_LOAD_EMPTY: return "pusta konfiguracja"; + case SETTINGS_LOAD_BAD_MAGIC: return "nieprawidlowy magic"; + case SETTINGS_LOAD_BAD_VERSION: return "nieobslugiwana wersja"; + case SETTINGS_LOAD_BAD_SIZE: return "nieprawidlowy rozmiar"; + case SETTINGS_LOAD_BAD_CRC: return "blad CRC"; + case SETTINGS_LOAD_INVALID: return "nieprawidlowe wartosci"; + case SETTINGS_LOAD_IO_ERROR: return "blad NVS"; + default: return "nieznany blad"; + } +} diff --git a/src/settings.h b/src/settings.h new file mode 100644 index 0000000..9472fa9 --- /dev/null +++ b/src/settings.h @@ -0,0 +1,81 @@ +/* Trwala konfiguracja uzytkownika; modul niezalezny od Arduino. */ +#ifndef TPMS_SETTINGS_H +#define TPMS_SETTINGS_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define SETTINGS_MAGIC 0x54504D53u +#define SETTINGS_VERSION 1u +#define WHEEL_COUNT 4 +#define SETTINGS_PRESSURE_MAX_KPA10 6375u +#define SETTINGS_INTERVAL_MIN_S 5u +#define SETTINGS_INTERVAL_MAX_S 86400u + +typedef enum { + WHEEL_FL = 0, + WHEEL_FR = 1, + WHEEL_RR = 2, + WHEEL_RL = 3, +} wheel_t; + +typedef struct { + uint32_t id; + uint16_t pressure_kpa10; + int16_t temp_c; +} sensor_settings_t; + +typedef struct { + sensor_settings_t wheels[WHEEL_COUNT]; + uint32_t flags; + uint32_t normal_interval_s; + uint32_t ignition_interval_s; + uint32_t parking_interval_s; + float frequency_mhz; + int8_t tx_power_dbm; + uint8_t burst_frames; + uint16_t frame_gap_ms; +} settings_t; + +typedef struct { + uint32_t magic; + uint32_t version; + uint32_t size; + settings_t values; + uint32_t crc32; +} settings_blob_t; + +typedef enum { + SETTINGS_LOAD_OK = 0, + SETTINGS_LOAD_EMPTY, + SETTINGS_LOAD_BAD_MAGIC, + SETTINGS_LOAD_BAD_VERSION, + SETTINGS_LOAD_BAD_SIZE, + SETTINGS_LOAD_BAD_CRC, + SETTINGS_LOAD_INVALID, + SETTINGS_LOAD_IO_ERROR, +} settings_load_result_t; + +void settings_defaults(settings_t *out); +bool settings_valid_id(uint32_t id); +bool settings_validate(const settings_t *cfg); +bool settings_set_id(settings_t *cfg, uint8_t wheel, uint32_t id); +void settings_generate_ids(settings_t *cfg, uint32_t seed); +bool settings_valid_tx_power(int power_dbm); + +uint32_t settings_crc32(const void *data, size_t len); +void settings_make_blob(const settings_t *cfg, settings_blob_t *blob); +settings_load_result_t settings_decode_blob(const settings_blob_t *blob, + settings_t *out); +const char *settings_load_result_text(settings_load_result_t result); + +#ifdef __cplusplus +} +#endif + +#endif -- 2.54.1 From e2ffb8d8cf369f5c7c25948e7a5d2e850ed7f63e Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 17:49:04 +0000 Subject: [PATCH 02/19] Ramka: odrzucaj nieprawidlowe ID i usun zgadywany lowbat --- src/tpms_frame.cpp | 111 ++++++++++++++++++++------------------------- src/tpms_frame.h | 67 ++++++--------------------- 2 files changed, 63 insertions(+), 115 deletions(-) diff --git a/src/tpms_frame.cpp b/src/tpms_frame.cpp index 0e86bf7..1a90413 100644 --- a/src/tpms_frame.cpp +++ b/src/tpms_frame.cpp @@ -1,97 +1,82 @@ -/* - * tpms_frame.cpp - generator ramek TPMS Schrader EG53MA4 (bez zaleznosci - * od Arduino - kompilowalne takze natywnie w testach). - * - * Zastrzezenie: symulator generuje sztuczne dane cisnienia/temperatury - * i nie zastepuje prawdziwych czujnikow TPMS. - */ +/* Generator ramek EG53MA4. Sztuczne dane wylacznie do diagnostyki. */ #include -#include "config.h" + +#include "settings.h" #include "tpms_frame.h" -static void put_bit(uint8_t *buf, unsigned *nbits, unsigned v) +static void put_bit(uint8_t *buf, unsigned *nbits, unsigned value) { - if (v) { + if (value != 0u) { buf[*nbits >> 3] |= (uint8_t)(0x80u >> (*nbits & 7u)); } - (*nbits)++; + ++(*nbits); } -/* G.E.T. Manchester: 0 -> "01", 1 -> "10" */ +/* Polaryzacja potwierdzona nagraniami i rtl_433 OOK_MC_ZEROBIT: 0=01, 1=10. */ static void put_cell(uint8_t *buf, unsigned *nbits, unsigned bit) { - if (bit) { - put_bit(buf, nbits, 1); - put_bit(buf, nbits, 0); - } - else { - put_bit(buf, nbits, 0); - put_bit(buf, nbits, 1); - } + put_bit(buf, nbits, bit != 0u ? 1u : 0u); + put_bit(buf, nbits, bit != 0u ? 0u : 1u); } -uint8_t tpms_build_payload(uint8_t out[TPMS_PAYLOAD_LEN], uint32_t id, - uint16_t press_kpa10, int8_t temp_c, - uint32_t flags, bool low_batt) +bool tpms_build_payload(uint8_t out[TPMS_PAYLOAD_LEN], uint32_t id, + uint16_t press_kpa10, int8_t temp_c, uint32_t flags) { - if (low_batt) { - flags |= TPMS_FLAGS_LOWBAT_MASK; + if (out == NULL || !settings_valid_id(id)) { + return false; } - /* cisnienie: 25 mbar/bit = 2.5 kPa/bit, zaokraglenie w gore do polowy bitu */ - int32_t press = ((int32_t)press_kpa10 + 12) / 25; - if (press < 0) press = 0; - if (press > 255) press = 255; + int32_t pressure = ((int32_t)press_kpa10 + 12) / 25; + if (pressure > 255) { + pressure = 255; + } - /* temperatura: protokol podaje stopnie Fahrenheita */ - int32_t num = 9 * (int32_t)temp_c + 160; - int32_t tf = (num >= 0) ? (num + 2) / 5 : -((-num + 2) / 5); - if (tf < 0) tf = 0; - if (tf > 255) tf = 255; + int32_t numerator = 9 * (int32_t)temp_c + 160; + int32_t temperature_f = numerator >= 0 + ? (numerator + 2) / 5 : -((-numerator + 2) / 5); + if (temperature_f < 0) { + temperature_f = 0; + } else if (temperature_f > 255) { + temperature_f = 255; + } out[0] = (uint8_t)(flags >> 24); out[1] = (uint8_t)(flags >> 16); out[2] = (uint8_t)(flags >> 8); - out[3] = (uint8_t)(flags); + out[3] = (uint8_t)flags; out[4] = (uint8_t)(id >> 16); out[5] = (uint8_t)(id >> 8); - out[6] = (uint8_t)(id); - out[7] = (uint8_t)press; - out[8] = (uint8_t)tf; - - uint8_t crc = 0; - for (unsigned i = 0; i < 9; i++) { - crc = (uint8_t)(crc + out[i]); // suma mod 256 (add_bytes w rtl_433) + out[6] = (uint8_t)id; + out[7] = (uint8_t)pressure; + out[8] = (uint8_t)temperature_f; + uint8_t checksum = 0; + for (uint8_t i = 0; i < 9u; ++i) { + checksum = (uint8_t)(checksum + out[i]); } - out[9] = crc; - return crc; + out[9] = checksum; + return true; } -void tpms_build_frame(uint8_t out[TPMS_TX_BYTES], uint32_t id, - uint16_t press_kpa10, int8_t temp_c, - uint32_t flags, bool low_batt) +bool tpms_build_frame(uint8_t out[TPMS_TX_BYTES], uint32_t id, + uint16_t press_kpa10, int8_t temp_c, uint32_t flags) { uint8_t payload[TPMS_PAYLOAD_LEN]; - tpms_build_payload(payload, id, press_kpa10, temp_c, flags, low_batt); + if (out == NULL || !tpms_build_payload(payload, id, press_kpa10, temp_c, flags)) { + return false; + } memset(out, 0, TPMS_TX_BYTES); unsigned nbits = 0; - - put_bit(out, &nbits, 1); // chip rozbiegowy (carrier on) - - /* 39 bitow sync - pierwszy (zerowy) bit dopisuje odbiornik (MC_ZEROBIT) */ - for (unsigned i = 0; i < TPMS_SYNC_BITS - 1; i++) { - put_cell(out, &nbits, 0); + put_bit(out, &nbits, 1u); /* chip startowy */ + for (unsigned i = 0; i < TPMS_SYNC_BITS - 1u; ++i) { + put_cell(out, &nbits, 0u); } - - /* 80 bitow payloadu */ - for (unsigned b = 0; b < 8u * TPMS_PAYLOAD_LEN; b++) { - unsigned bit = (payload[b >> 3] >> (7 - (b & 7u))) & 1u; - put_cell(out, &nbits, bit); + for (unsigned bit = 0; bit < 8u * TPMS_PAYLOAD_LEN; ++bit) { + unsigned value = (payload[bit >> 3] >> (7u - (bit & 7u))) & 1u; + put_cell(out, &nbits, value); } - - /* padding do granicy bajtu - dla OOK sa to chipy "off" = cisza w eterze */ - while (nbits % 8u) { - put_bit(out, &nbits, 0); + while ((nbits & 7u) != 0u) { + put_bit(out, &nbits, 0u); } + return nbits == TPMS_TX_CHIPS; } diff --git a/src/tpms_frame.h b/src/tpms_frame.h index edea1b3..3cee0a1 100644 --- a/src/tpms_frame.h +++ b/src/tpms_frame.h @@ -1,70 +1,33 @@ -/* - * tpms_frame.h - generator ramek TPMS Schrader EG53MA4 - * - * Zastrzezenie: dane sa sztuczne (diagnostyka/testy), nie zastepuja - * prawdziwych czujnikow TPMS. - * - * Ramka na zrzuconej warstwie bitowej (120 bitow, po dekodowaniu - * Manchester przez rtl_433 OOK_MC_ZEROBIT): - * - * 40 bit sync (zera) | flags(4B) | id(3B) | pressure(1B) | temp(1B) | crc(1B) - * - * - flags: 32 bity, wg dekodera "moze zawierac preamble/status/battery" - * - pressure: 25 mbar/bit (cisnienie w kPa = bajt * 2.5) - * - temperature: stopnie Fahrenheita - * - crc: suma 9 poprzednich bajtow mod 256 (add_bytes w rtl_433) - * - * Kodowanie na zrzuconej warstwie RF (G.E.T. Manchester): - * bit 0 -> chipy "01", bit 1 -> chipy "10", chip = 120 us - * Odbiornik rtl_433 (MC_ZEROBIT) dopisuje pierwszy bit ramki samodzielnie, - * wiec nadajnik wysyla ramke BEZ pierwszego bitu, poprzedzona jednym - * chipem rozbiegowym '1'. Bufor wyjsciowy jest dopełniany zerami do - * granicy bajtu (dla OOK sa to chipy "wylaczone" = cisza). - */ +/* Schrader EG53MA4: 40 bitow sync + 80 bitow danych, OOK Manchester. */ #ifndef TPMS_FRAME_H #define TPMS_FRAME_H -#include #include +#include #ifdef __cplusplus extern "C" { #endif -#define TPMS_ROW_BITS 120 // dlugosc dekodowanej ramki (wymagana przez rtl_433) -#define TPMS_SYNC_BITS 40 -#define TPMS_PAYLOAD_LEN 10 // flags(4)+id(3)+press+temp+crc -#define TPMS_TX_BYTES 30 // 240 chipow = 1 lead + 238 danych + 1 padding -#define TPMS_TX_CHIPS (TPMS_TX_BYTES * 8) +#define TPMS_ROW_BITS 120 +#define TPMS_SYNC_BITS 40 +#define TPMS_PAYLOAD_LEN 10 +#define TPMS_TX_BYTES 30 +#define TPMS_TX_CHIPS (TPMS_TX_BYTES * 8) #ifdef __cplusplus -/* Zaleznosc bufora nadawczego od dlugosci ramki: 1 chip rozbiegowy + - * 2 chipy na kazdy z (TPMS_ROW_BITS-1) bitow (pierwszy bit dopisuje - * odbiornik) + padding do granicy bajtu (< 8 chipow). */ -static_assert(TPMS_TX_CHIPS >= 1 + 2 * (TPMS_ROW_BITS - 1) - && TPMS_TX_CHIPS < 1 + 2 * (TPMS_ROW_BITS - 1) + 8, - "TPMS_TX_BYTES musi miescic 1 + 2*(TPMS_ROW_BITS-1) chipow"); +static_assert(TPMS_TX_CHIPS == 1 + 2 * (TPMS_ROW_BITS - 1) + 1, + "Nieprawidlowa dlugosc bufora Manchester"); #endif -typedef struct { - uint32_t id; // 24-bit identyfikator czujnika - uint16_t press_kpa10; // cisnienie w kPa * 10 (np. 2600 = 260.0 kPa) - int8_t temp_c; // temperatura w st. C - const char *name; // "FL", "FR", "RR", "RL" -} tpms_sensor_t; - -/* Zbuduj 10-bajtowy payload (bez sync). Zwraca crc (tez wpisane do out[9]). */ -uint8_t tpms_build_payload(uint8_t out[TPMS_PAYLOAD_LEN], uint32_t id, - uint16_t press_kpa10, int8_t temp_c, - uint32_t flags, bool low_batt); - -/* Zbuduj kompletny bufor nadawczy (TPMS_TX_BYTES) gotowy do CC1101 FIFO. */ -void tpms_build_frame(uint8_t out[TPMS_TX_BYTES], uint32_t id, - uint16_t press_kpa10, int8_t temp_c, - uint32_t flags, bool low_batt); +/* Zwraca false dla ID 0, 0xFFFFFF i wartosci spoza 24 bitow. */ +bool tpms_build_payload(uint8_t out[TPMS_PAYLOAD_LEN], uint32_t id, + uint16_t press_kpa10, int8_t temp_c, uint32_t flags); +bool tpms_build_frame(uint8_t out[TPMS_TX_BYTES], uint32_t id, + uint16_t press_kpa10, int8_t temp_c, uint32_t flags); #ifdef __cplusplus } #endif -#endif /* TPMS_FRAME_H */ +#endif -- 2.54.1 From 824b1dbf0e60a253424a85efa0d136698e489f26 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 17:49:34 +0000 Subject: [PATCH 03/19] Maszyna stanow: przenosny NORMAL LEARN SINGLE z timeoutami --- src/app_state.cpp | 147 ++++++++++++++++++++++++++++++++++++++++++++++ src/app_state.h | 61 +++++++++++++++++++ 2 files changed, 208 insertions(+) create mode 100644 src/app_state.cpp create mode 100644 src/app_state.h diff --git a/src/app_state.cpp b/src/app_state.cpp new file mode 100644 index 0000000..6f9f74a --- /dev/null +++ b/src/app_state.cpp @@ -0,0 +1,147 @@ +#include "app_state.h" +#include "config.h" + +AppState::AppState(const settings_t *settings, RadioSink *radio) + : settings_(settings), radio_(radio) +{ +} + +void AppState::begin(uint32_t now_ms, bool transmit) +{ + set_mode(AppMode::NORMAL, WHEEL_FL, now_ms, transmit); +} + +uint32_t AppState::interval_s(bool ignition) const +{ +#if PIN_ACC >= 0 + return ignition ? settings_->ignition_interval_s : settings_->parking_interval_s; +#else + (void)ignition; + return settings_->normal_interval_s; +#endif +} + +bool AppState::transmit(uint8_t wheel) +{ + bool ok = radio_ != NULL && radio_->send(wheel); + if (!ok) { + ++error_count_; + } + return ok; +} + +bool AppState::send_current() +{ + return transmit(active_wheel_); +} + +bool AppState::send_wheel(uint8_t wheel) +{ + return wheel < WHEEL_COUNT && transmit(wheel); +} + +bool AppState::send_all() +{ + bool ok = true; + for (uint8_t i = 0; i < WHEEL_COUNT; ++i) { + ok = transmit(i) && ok; + } + return ok; +} + +void AppState::schedule(uint32_t now_ms, bool immediate) +{ + next_tx_ms_ = immediate ? now_ms : now_ms + LEARN_PERIOD_MS; +} + +bool AppState::set_mode(AppMode mode, uint8_t wheel, uint32_t now_ms, + bool transmit_now) +{ + if (wheel >= WHEEL_COUNT) { + return false; + } + mode_ = mode; + active_wheel_ = wheel; + mode_start_ms_ = now_ms; + wheel_start_ms_ = now_ms; + schedule(now_ms, transmit_now); + if (mode == AppMode::NORMAL) { + next_tx_ms_ = transmit_now ? now_ms : UINT32_MAX; + } + if (transmit_now && mode != AppMode::NORMAL) { + send_current(); + schedule(now_ms, false); + } else if (transmit_now) { + send_all(); + next_tx_ms_ = now_ms + settings_->normal_interval_s * 1000u; + } + return true; +} + +bool AppState::next_wheel(uint32_t now_ms) +{ + if (mode_ == AppMode::NORMAL) { + return false; + } + if (mode_ == AppMode::LEARN && active_wheel_ == WHEEL_RL) { + return set_mode(AppMode::NORMAL, WHEEL_FL, now_ms, false); + } + active_wheel_ = (uint8_t)((active_wheel_ + 1u) % WHEEL_COUNT); + wheel_start_ms_ = now_ms; + send_current(); + schedule(now_ms, false); + return true; +} + +void AppState::short_press(uint32_t now_ms) +{ + if (mode_ == AppMode::NORMAL) { + send_all(); + next_tx_ms_ = now_ms + settings_->normal_interval_s * 1000u; + } else { + next_wheel(now_ms); + } +} + +void AppState::long_press(uint32_t now_ms) +{ + if (mode_ == AppMode::LEARN) { + set_mode(AppMode::NORMAL, WHEEL_FL, now_ms, false); + } else { + set_mode(AppMode::LEARN, active_wheel_, now_ms); + } +} + +void AppState::very_long_press(uint32_t now_ms) +{ + if (mode_ == AppMode::SINGLE) { + set_mode(AppMode::NORMAL, WHEEL_FL, now_ms, false); + } else { + set_mode(AppMode::SINGLE, active_wheel_, now_ms); + } +} + +void AppState::tick(uint32_t now_ms, bool ignition) +{ + if (mode_ == AppMode::LEARN) { + if ((uint32_t)(now_ms - mode_start_ms_) >= LEARN_TOTAL_MS + || (uint32_t)(now_ms - wheel_start_ms_) >= LEARN_WINDOW_MS) { + set_mode(AppMode::NORMAL, WHEEL_FL, now_ms, false); + return; + } + } else if (mode_ == AppMode::SINGLE + && (uint32_t)(now_ms - mode_start_ms_) >= SINGLE_TIMEOUT_MS) { + set_mode(AppMode::NORMAL, WHEEL_FL, now_ms, false); + return; + } + + if (next_tx_ms_ != UINT32_MAX && (int32_t)(now_ms - next_tx_ms_) >= 0) { + if (mode_ == AppMode::NORMAL) { + send_all(); + next_tx_ms_ = now_ms + interval_s(ignition) * 1000u; + } else { + send_current(); + schedule(now_ms, false); + } + } +} diff --git a/src/app_state.h b/src/app_state.h new file mode 100644 index 0000000..08bf403 --- /dev/null +++ b/src/app_state.h @@ -0,0 +1,61 @@ +/* Przenosna maszyna stanow NORMAL/LEARN/SINGLE (fake clock/radio w testach). */ +#ifndef TPMS_APP_STATE_H +#define TPMS_APP_STATE_H + +#include +#include "settings.h" + +enum class AppMode : uint8_t { + NORMAL = 0, + LEARN = 1, + SINGLE = 2, +}; + +class RadioSink { +public: + virtual ~RadioSink() = default; + virtual bool send(uint8_t wheel) = 0; +}; + +class AppState { +public: + AppState(const settings_t *settings, RadioSink *radio); + + void begin(uint32_t now_ms, bool transmit = true); + void tick(uint32_t now_ms, bool ignition); + void short_press(uint32_t now_ms); + void long_press(uint32_t now_ms); + void very_long_press(uint32_t now_ms); + + bool set_mode(AppMode mode, uint8_t wheel, uint32_t now_ms, + bool transmit = true); + bool next_wheel(uint32_t now_ms); + bool send_current(); + bool send_wheel(uint8_t wheel); + bool send_all(); + + AppMode mode() const { return mode_; } + uint8_t active_wheel() const { return active_wheel_; } + uint32_t interval_s(bool ignition) const; + uint32_t last_error_count() const { return error_count_; } + +private: + static const uint32_t LEARN_PERIOD_MS = 2000u; + static const uint32_t LEARN_WINDOW_MS = 60000u; + static const uint32_t LEARN_TOTAL_MS = 900000u; + static const uint32_t SINGLE_TIMEOUT_MS = 300000u; + + const settings_t *settings_; + RadioSink *radio_; + AppMode mode_ = AppMode::NORMAL; + uint8_t active_wheel_ = WHEEL_FL; + uint32_t next_tx_ms_ = 0; + uint32_t mode_start_ms_ = 0; + uint32_t wheel_start_ms_ = 0; + uint32_t error_count_ = 0; + + bool transmit(uint8_t wheel); + void schedule(uint32_t now_ms, bool immediate); +}; + +#endif -- 2.54.1 From 9a4d7f5f73beb6067b680fb558c00cdc777ef1a2 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:13:25 +0000 Subject: [PATCH 04/19] Build: pelne SHA CC1101 i Werror dla firmware --- platformio.ini | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/platformio.ini b/platformio.ini index b3b18b1..230ce60 100644 --- a/platformio.ini +++ b/platformio.ini @@ -21,15 +21,16 @@ monitor_speed = 115200 ; Biblioteka CC1101 (ELECHOUSE_CC1101_SRC_DRV / SmartRC): ; wymagana wersja >= 2.5.7 (wspolne API setSpiPin/setGDO0 dla 2.5.x i 3.x). lib_deps = - https://github.com/LSatan/SmartRC-CC1101-Driver-Lib.git#de6757e + https://github.com/LSatan/SmartRC-CC1101-Driver-Lib.git#de6757ef633b3e626dae5c7835cdb66ab53f9a1d build_flags = -Wall -Wextra + -Werror [env:native] -; Testy jednostkowe generatora ramek (bez sprzetu) +; Przenosna logika: ramka, NVS i maszyna stanow (PIN_ACC wlaczony w testach). platform = native -build_flags = -std=gnu++17 -Wall -build_src_filter = -<*> + +build_flags = -std=gnu++17 -Wall -Wextra -Werror -DPIN_ACC=32 +build_src_filter = -<*> + + + test_build_src = true test_framework = unity -- 2.54.1 From 9160d71d883a20db28f7d5099827afadafd7a5b9 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:14:21 +0000 Subject: [PATCH 05/19] Testy: NVS i scenariusze Clone IDs LEARN SINGLE ACC --- test/test_app_state/test_app_state.cpp | 201 +++++++++++++++++++++++++ test/test_settings/test_settings.cpp | 112 ++++++++++++++ 2 files changed, 313 insertions(+) create mode 100644 test/test_app_state/test_app_state.cpp create mode 100644 test/test_settings/test_settings.cpp diff --git a/test/test_app_state/test_app_state.cpp b/test/test_app_state/test_app_state.cpp new file mode 100644 index 0000000..097aa49 --- /dev/null +++ b/test/test_app_state/test_app_state.cpp @@ -0,0 +1,201 @@ +#include +#include "app_state.h" + +class FakeRadio final : public RadioSink { +public: + uint8_t wheels[128]; + uint8_t count = 0; + bool fail = false; + + bool send(uint8_t wheel) override + { + if (count < sizeof(wheels)) wheels[count] = wheel; + ++count; + return !fail; + } +}; + +void setUp(void) {} +void tearDown(void) {} + +static void test_normal_clone_ids_sends_four_wheels_and_repeats(void) +{ + settings_t cfg; + settings_defaults(&cfg); + cfg.wheels[0].id = 0x111111u; + FakeRadio radio; + AppState app(&cfg, &radio); + app.begin(0u); + TEST_ASSERT_EQUAL_UINT8(4u, radio.count); + static const uint8_t expected[] = {0, 1, 2, 3}; + TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, radio.wheels, 4); + app.tick(29999u, false); + TEST_ASSERT_EQUAL_UINT8(4u, radio.count); + app.tick(30000u, false); + TEST_ASSERT_EQUAL_UINT8(8u, radio.count); +} + +static void test_new_ids_learn_order_force_and_finish(void) +{ + settings_t cfg; + settings_defaults(&cfg); + settings_generate_ids(&cfg, 42u); + TEST_ASSERT_TRUE(settings_validate(&cfg)); + FakeRadio radio; + AppState app(&cfg, &radio); + app.begin(0u, false); + app.set_mode(AppMode::LEARN, WHEEL_FL, 0u); + TEST_ASSERT_EQUAL(AppMode::LEARN, app.mode()); + TEST_ASSERT_EQUAL_UINT8(1u, radio.count); + TEST_ASSERT_EQUAL_UINT8(WHEEL_FL, radio.wheels[0]); + TEST_ASSERT_TRUE(app.send_current()); + TEST_ASSERT_EQUAL_UINT8(2u, radio.count); + app.short_press(100u); + TEST_ASSERT_EQUAL_UINT8(WHEEL_FR, app.active_wheel()); + app.short_press(200u); + TEST_ASSERT_EQUAL_UINT8(WHEEL_RR, app.active_wheel()); + app.short_press(300u); + TEST_ASSERT_EQUAL_UINT8(WHEEL_RL, app.active_wheel()); + app.short_press(400u); + TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode()); + static const uint8_t expected[] = {0, 0, 1, 2, 3}; + TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, radio.wheels, 5); +} + +static void test_learn_period_window_and_total_timeout(void) +{ + settings_t cfg; + settings_defaults(&cfg); + FakeRadio radio; + AppState app(&cfg, &radio); + app.set_mode(AppMode::LEARN, WHEEL_FL, 0u); + app.tick(1999u, false); + TEST_ASSERT_EQUAL_UINT8(1u, radio.count); + app.tick(2000u, false); + TEST_ASSERT_EQUAL_UINT8(2u, radio.count); + app.tick(59999u, false); + TEST_ASSERT_EQUAL(AppMode::LEARN, app.mode()); + app.tick(60000u, false); + TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode()); + TEST_ASSERT_EQUAL_UINT8(3u, radio.count); + + app.set_mode(AppMode::LEARN, WHEEL_FL, 100000u); + app.tick(1000000u, false); + TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode()); +} + +static void test_single_isolated_wheel_and_timeout(void) +{ + settings_t cfg; + settings_defaults(&cfg); + FakeRadio radio; + AppState app(&cfg, &radio); + app.set_mode(AppMode::SINGLE, WHEEL_FR, 0u); + TEST_ASSERT_EQUAL_UINT8(1u, radio.count); + TEST_ASSERT_EQUAL_UINT8(WHEEL_FR, radio.wheels[0]); + app.tick(2000u, false); + TEST_ASSERT_EQUAL_UINT8(2u, radio.count); + TEST_ASSERT_EQUAL_UINT8(WHEEL_FR, radio.wheels[1]); + app.next_wheel(3000u); + TEST_ASSERT_EQUAL_UINT8(WHEEL_RR, app.active_wheel()); + app.tick(300000u, false); + TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode()); +} + +static void test_button_gestures(void) +{ + settings_t cfg; + settings_defaults(&cfg); + FakeRadio radio; + AppState app(&cfg, &radio); + app.begin(0u, false); + app.long_press(0u); + TEST_ASSERT_EQUAL(AppMode::LEARN, app.mode()); + app.long_press(10u); + TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode()); + app.very_long_press(20u); + TEST_ASSERT_EQUAL(AppMode::SINGLE, app.mode()); + app.very_long_press(30u); + TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode()); + app.short_press(40u); + TEST_ASSERT_EQUAL_UINT8(6u, radio.count); +} + +static void test_acc_intervals_without_permanent_shutdown(void) +{ + settings_t cfg; + settings_defaults(&cfg); + cfg.ignition_interval_s = 15u; + cfg.parking_interval_s = 120u; + FakeRadio radio; + AppState app(&cfg, &radio); + app.begin(0u); + app.tick(30000u, true); + app.tick(45000u, true); + TEST_ASSERT_EQUAL_UINT8(12u, radio.count); + app.tick(60000u, false); + TEST_ASSERT_EQUAL_UINT8(16u, radio.count); + app.tick(179999u, false); + TEST_ASSERT_EQUAL_UINT8(16u, radio.count); + app.tick(180000u, false); + TEST_ASSERT_EQUAL_UINT8(20u, radio.count); + TEST_ASSERT_EQUAL_UINT32(15u, app.interval_s(true)); + TEST_ASSERT_EQUAL_UINT32(120u, app.interval_s(false)); +} + +static void test_power_restart_and_nvs_reloaded_configuration(void) +{ + settings_t persisted; + settings_defaults(&persisted); + persisted.wheels[3].id = 0x654321u; + settings_blob_t blob; + settings_make_blob(&persisted, &blob); + settings_t reloaded; + TEST_ASSERT_EQUAL(SETTINGS_LOAD_OK, settings_decode_blob(&blob, &reloaded)); + FakeRadio radio; + AppState after_restart(&reloaded, &radio); + after_restart.begin(1000u); + TEST_ASSERT_EQUAL(AppMode::NORMAL, after_restart.mode()); + TEST_ASSERT_EQUAL_UINT8(4u, radio.count); + TEST_ASSERT_EQUAL_HEX32(0x654321u, reloaded.wheels[3].id); +} + +static void test_radio_failure_is_counted_and_other_wheels_continue(void) +{ + settings_t cfg; + settings_defaults(&cfg); + FakeRadio radio; + radio.fail = true; + AppState app(&cfg, &radio); + app.begin(0u); + TEST_ASSERT_EQUAL_UINT8(4u, radio.count); + TEST_ASSERT_EQUAL_UINT32(4u, app.last_error_count()); +} + +static void test_millis_wrap_does_not_stall_learn(void) +{ + settings_t cfg; + settings_defaults(&cfg); + FakeRadio radio; + AppState app(&cfg, &radio); + app.set_mode(AppMode::LEARN, WHEEL_FL, UINT32_MAX - 1000u); + app.tick(1000u, false); + TEST_ASSERT_EQUAL_UINT8(2u, radio.count); +} + +int main(int argc, char **argv) +{ + (void)argc; + (void)argv; + UNITY_BEGIN(); + RUN_TEST(test_normal_clone_ids_sends_four_wheels_and_repeats); + RUN_TEST(test_new_ids_learn_order_force_and_finish); + RUN_TEST(test_learn_period_window_and_total_timeout); + RUN_TEST(test_single_isolated_wheel_and_timeout); + RUN_TEST(test_button_gestures); + RUN_TEST(test_acc_intervals_without_permanent_shutdown); + RUN_TEST(test_power_restart_and_nvs_reloaded_configuration); + RUN_TEST(test_radio_failure_is_counted_and_other_wheels_continue); + RUN_TEST(test_millis_wrap_does_not_stall_learn); + return UNITY_END(); +} diff --git a/test/test_settings/test_settings.cpp b/test/test_settings/test_settings.cpp new file mode 100644 index 0000000..7d03160 --- /dev/null +++ b/test/test_settings/test_settings.cpp @@ -0,0 +1,112 @@ +#include +#include +#include "settings.h" + +void setUp(void) {} +void tearDown(void) {} + +static void test_defaults_are_safe_and_valid(void) +{ + settings_t cfg; + settings_defaults(&cfg); + TEST_ASSERT_TRUE(settings_validate(&cfg)); + for (uint8_t i = 0; i < WHEEL_COUNT; ++i) { + TEST_ASSERT_EQUAL_UINT16(2600u, cfg.wheels[i].pressure_kpa10); + TEST_ASSERT_TRUE(settings_valid_id(cfg.wheels[i].id)); + } + TEST_ASSERT_EQUAL_INT8(-10, cfg.tx_power_dbm); + TEST_ASSERT_FLOAT_WITHIN(0.001f, 433.92f, cfg.frequency_mhz); +} + +static void test_ids_must_be_24_bit_nonzero_and_unique(void) +{ + settings_t cfg; + settings_defaults(&cfg); + TEST_ASSERT_FALSE(settings_set_id(&cfg, 0u, 0u)); + TEST_ASSERT_FALSE(settings_set_id(&cfg, 0u, 0xFFFFFFu)); + TEST_ASSERT_FALSE(settings_set_id(&cfg, 0u, 0x1000000u)); + TEST_ASSERT_FALSE(settings_set_id(&cfg, 4u, 0x123456u)); + TEST_ASSERT_FALSE(settings_set_id(&cfg, 0u, cfg.wheels[1].id)); + TEST_ASSERT_TRUE(settings_set_id(&cfg, 0u, 0x123456u)); + TEST_ASSERT_EQUAL_HEX32(0x123456u, cfg.wheels[0].id); +} + +static void test_generated_ids_are_unique_and_deterministic_for_seed(void) +{ + settings_t a, b; + settings_defaults(&a); + settings_defaults(&b); + settings_generate_ids(&a, 1234u); + settings_generate_ids(&b, 1234u); + TEST_ASSERT_TRUE(settings_validate(&a)); + TEST_ASSERT_EQUAL_MEMORY(&a, &b, sizeof(a)); + settings_generate_ids(&a, 0u); + TEST_ASSERT_TRUE(settings_validate(&a)); +} + +static void test_blob_round_trip_and_crc(void) +{ + settings_t cfg, decoded; + settings_defaults(&cfg); + TEST_ASSERT_TRUE(settings_set_id(&cfg, WHEEL_FR, 0xABCDEFu)); + cfg.wheels[2].pressure_kpa10 = 2555u; + settings_blob_t blob; + settings_make_blob(&cfg, &blob); + TEST_ASSERT_EQUAL_UINT32(SETTINGS_VERSION, blob.version); + TEST_ASSERT_EQUAL(SETTINGS_LOAD_OK, settings_decode_blob(&blob, &decoded)); + TEST_ASSERT_EQUAL_MEMORY(&cfg, &decoded, sizeof(cfg)); + blob.values.wheels[0].id ^= 1u; + TEST_ASSERT_EQUAL(SETTINGS_LOAD_BAD_CRC, settings_decode_blob(&blob, &decoded)); +} + +static void test_incompatible_version_size_magic_are_rejected(void) +{ + settings_t cfg, decoded; + settings_defaults(&cfg); + settings_blob_t blob; + settings_make_blob(&cfg, &blob); + ++blob.version; + TEST_ASSERT_EQUAL(SETTINGS_LOAD_BAD_VERSION, settings_decode_blob(&blob, &decoded)); + settings_make_blob(&cfg, &blob); + --blob.size; + TEST_ASSERT_EQUAL(SETTINGS_LOAD_BAD_SIZE, settings_decode_blob(&blob, &decoded)); + settings_make_blob(&cfg, &blob); + blob.magic = 0u; + TEST_ASSERT_EQUAL(SETTINGS_LOAD_BAD_MAGIC, settings_decode_blob(&blob, &decoded)); +} + +static void test_invalid_ranges_are_rejected_even_with_valid_crc(void) +{ + settings_t cfg, decoded; + settings_defaults(&cfg); + settings_blob_t blob; + cfg.normal_interval_s = 4u; + settings_make_blob(&cfg, &blob); + TEST_ASSERT_EQUAL(SETTINGS_LOAD_INVALID, settings_decode_blob(&blob, &decoded)); + settings_defaults(&cfg); + cfg.tx_power_dbm = 10; + settings_make_blob(&cfg, &blob); + TEST_ASSERT_EQUAL(SETTINGS_LOAD_INVALID, settings_decode_blob(&blob, &decoded)); + settings_defaults(&cfg); + cfg.wheels[1].id = cfg.wheels[0].id; + settings_make_blob(&cfg, &blob); + TEST_ASSERT_EQUAL(SETTINGS_LOAD_INVALID, settings_decode_blob(&blob, &decoded)); + settings_defaults(&cfg); + cfg.frequency_mhz = 434.80f; + settings_make_blob(&cfg, &blob); + TEST_ASSERT_EQUAL(SETTINGS_LOAD_INVALID, settings_decode_blob(&blob, &decoded)); +} + +int main(int argc, char **argv) +{ + (void)argc; + (void)argv; + UNITY_BEGIN(); + RUN_TEST(test_defaults_are_safe_and_valid); + RUN_TEST(test_ids_must_be_24_bit_nonzero_and_unique); + RUN_TEST(test_generated_ids_are_unique_and_deterministic_for_seed); + RUN_TEST(test_blob_round_trip_and_crc); + RUN_TEST(test_incompatible_version_size_magic_are_rejected); + RUN_TEST(test_invalid_ranges_are_rejected_even_with_valid_crc); + return UNITY_END(); +} -- 2.54.1 From 878c576fdc2d71457ed291aa0088c0ecd4287ee3 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:16:06 +0000 Subject: [PATCH 06/19] Testy ramek: cztery niezalezne nagrania i przypadki negatywne --- src/settings.cpp | 6 +- test/test_tpms_frame/test_tpms_frame.cpp | 226 +++++++++++------------ 2 files changed, 114 insertions(+), 118 deletions(-) diff --git a/src/settings.cpp b/src/settings.cpp index 731cf79..c25c6a7 100644 --- a/src/settings.cpp +++ b/src/settings.cpp @@ -1,13 +1,11 @@ #include "settings.h" -#include - void settings_defaults(settings_t *out) { static const uint32_t ids[WHEEL_COUNT] = { 0x2FC871u, 0x2EAAF9u, 0x3495ACu, 0x2FC780u, }; - memset(out, 0, sizeof(*out)); + *out = settings_t{}; for (uint8_t i = 0; i < WHEEL_COUNT; ++i) { out->wheels[i].id = ids[i]; out->wheels[i].pressure_kpa10 = 2600u; @@ -124,7 +122,7 @@ uint32_t settings_crc32(const void *data, size_t len) void settings_make_blob(const settings_t *cfg, settings_blob_t *blob) { - memset(blob, 0, sizeof(*blob)); + *blob = settings_blob_t{}; blob->magic = SETTINGS_MAGIC; blob->version = SETTINGS_VERSION; blob->size = sizeof(blob->values); diff --git a/test/test_tpms_frame/test_tpms_frame.cpp b/test/test_tpms_frame/test_tpms_frame.cpp index 64304ff..2afaf81 100644 --- a/test/test_tpms_frame/test_tpms_frame.cpp +++ b/test/test_tpms_frame/test_tpms_frame.cpp @@ -1,144 +1,142 @@ -/* - * test_tpms_frame.cpp - testy generatora ramek TPMS (natywne, bez sprzetu) - * - * Wektory odniesienia wygenerowane narzedziem tools/tpms_frame.py, - * ktore jest zgodne bit-w-bit z dekoderem rtl_433 (schrader_EG53MA4) - * oraz z referencyjnym nagraniem Schrader_EG53MA4_TPMS/01/gfile001.cu8. - */ #include #include -#include "config.h" #include "tpms_frame.h" -static uint8_t hexval(char c) -{ - if (c >= '0' && c <= '9') return (uint8_t)(c - '0'); - if (c >= 'a' && c <= 'f') return (uint8_t)(c - 'a' + 10); - return 0; -} - -static void unhex(const char *hex, uint8_t *out) -{ - for (unsigned i = 0; hex[2 * i]; i++) { - out[i] = (uint8_t)((hexval(hex[2 * i]) << 4) | hexval(hex[2 * i + 1])); - } -} - -struct vec_t { - uint32_t id; - uint16_t kpa10; - int8_t temp_c; - const char *frame_hex; // 30 bajtow bufora nadawczego -}; - void setUp(void) {} void tearDown(void) {} -static void test_frame_vectors(void) -{ - static const vec_t v[] = { - { 0x2FC871u, 2600, 23, "aaaaaaaaaaaaaaaaaaaacb4b2caaaaaad4aab3554b2ad4acd32acb2cd2cc" }, - { 0x2FC871u, 0, 32, "aaaaaaaaaaaaaaaaaaaacb4b2caaaaaad4aab3554b2ad4acaaaacd32ab52" }, - { 0x3495ACu, 2200, -5, "aaaaaaaaaaaaaaaaaaaacb4b2caaaaaad4aab4cb2ccd334acd2aacd4b4aa" }, - { 0x000001u, 6375, 85, "aaaaaaaaaaaaaaaaaaaacb4b2caaaaaad4aaaaaaaaaaaaad5555352caacc" }, - { 0xABCDEEu, 2625, 24, "aaaaaaaaaaaaaaaaaaaacb4b2caaaaaad4ab33354b4d5352d32ccb34d2d2" }, - { 0x2FC780u, 2580, -40, "aaaaaaaaaaaaaaaaaaaacb4b2caaaaaad4aab3554ad52aaad2d4aaaab32c" }, - }; +struct capture_vector_t { + uint32_t id; + int16_t temp_c; + uint8_t temp_f; + uint8_t checksum; +}; - for (unsigned i = 0; i < sizeof(v) / sizeof(v[0]); i++) { - uint8_t got[TPMS_TX_BYTES]; - uint8_t want[TPMS_TX_BYTES]; - tpms_build_frame(got, v[i].id, v[i].kpa10, v[i].temp_c, 0x4C900070u, false); - unhex(v[i].frame_hex, want); - TEST_ASSERT_EQUAL_HEX8_ARRAY(want, got, TPMS_TX_BYTES); +static void test_four_independent_capture_payloads(void) +{ + /* rtl_433_tests commit 1aa8c29, cztery nagrania, po 16 dekodowan. + * Wszystkie: flags=4c900070, pressure=0. Wartosci nie pochodza z generatora. */ + static const capture_vector_t vectors[] = { + {0x2FC871u, 32, 90u, 0x0Eu}, + {0x2EAAF9u, 32, 90u, 0x77u}, + {0x3495ACu, 32, 90u, 0x1Bu}, + {0x2FC780u, 33, 91u, 0x1Du}, + }; + for (uint8_t i = 0; i < 4u; ++i) { + uint8_t payload[TPMS_PAYLOAD_LEN]; + TEST_ASSERT_TRUE(tpms_build_payload(payload, vectors[i].id, 0u, + (int8_t)vectors[i].temp_c, 0x4C900070u)); + TEST_ASSERT_EQUAL_HEX32(vectors[i].id, + ((uint32_t)payload[4] << 16) | ((uint32_t)payload[5] << 8) | payload[6]); + TEST_ASSERT_EQUAL_HEX8(0x00, payload[7]); + TEST_ASSERT_EQUAL_HEX8(vectors[i].temp_f, payload[8]); + TEST_ASSERT_EQUAL_HEX8(vectors[i].checksum, payload[9]); } } -static void test_reference_capture(void) +static void test_known_frame_and_pressure_temperature(void) { - /* gfile001.cu8: id=2FC871, flags=4c900070, 0 kPa, 90 F, crc=0x0E */ - uint8_t p[TPMS_PAYLOAD_LEN]; - tpms_build_payload(p, 0x2FC871u, 0, 32, 0x4C900070u, false); - const uint8_t want[TPMS_PAYLOAD_LEN] = { - 0x4C, 0x90, 0x00, 0x70, 0x2F, 0xC8, 0x71, 0x00, 0x5A, 0x0E + static const uint8_t expected[TPMS_TX_BYTES] = { + 0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA, + 0xCB,0x4B,0x2C,0xAA,0xAA,0xAA,0xD4,0xAA,0xB3,0x55, + 0x4B,0x2A,0xD4,0xAC,0xD3,0x2A,0xCB,0x2C,0xD2,0xCC, }; - TEST_ASSERT_EQUAL_HEX8_ARRAY(want, p, TPMS_PAYLOAD_LEN); + uint8_t frame[TPMS_TX_BYTES]; + uint8_t payload[TPMS_PAYLOAD_LEN]; + TEST_ASSERT_TRUE(tpms_build_frame(frame, 0x2FC871u, 2600u, 23, 0x4C900070u)); + TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, frame, TPMS_TX_BYTES); + TEST_ASSERT_TRUE(tpms_build_payload(payload, 0x123456u, 2600u, 23, 0x4C900070u)); + TEST_ASSERT_EQUAL_HEX8(0x68, payload[7]); /* 260 kPa / 2.5 = 104 */ + TEST_ASSERT_EQUAL_UINT8(73u, payload[8]); + TEST_ASSERT_EQUAL_HEX8(0x99, payload[9]); } -static void test_pressure_scale(void) +static bool decode_strict(const uint8_t *frame, size_t length, + uint8_t payload[TPMS_PAYLOAD_LEN]) { - uint8_t p[TPMS_PAYLOAD_LEN]; - /* 260 kPa = 2600 kPa*10 -> 2600/2.5 = 104 = 0x68 */ - tpms_build_payload(p, 0x123456u, 2600, 23, 0x4C900070u, false); - TEST_ASSERT_EQUAL_HEX8(0x68, p[7]); - /* 23 C = 73 F */ - TEST_ASSERT_EQUAL_HEX8(73, p[8]); - /* ograniczenie zakresu */ - tpms_build_payload(p, 0x123456u, 65535, 127, 0x4C900070u, false); - TEST_ASSERT_EQUAL_HEX8(255, p[7]); - TEST_ASSERT_EQUAL_HEX8(255, p[8]); - tpms_build_payload(p, 0x123456u, 0, -99, 0x4C900070u, false); - TEST_ASSERT_EQUAL_HEX8(0, p[7]); - TEST_ASSERT_EQUAL_HEX8(0, p[8]); -} - -static void test_pressure_rounding(void) -{ - uint8_t p[TPMS_PAYLOAD_LEN]; - /* skala 2.5 kPa/bit = 25 kPa*10/bit, zaokraglenie w gore do pol bitu: - * bajt = (kpa10 + 12) / 25 */ - tpms_build_payload(p, 1, 12, 0, 0x4C900070u, false); // 1.2 kPa -> 0 - TEST_ASSERT_EQUAL_HEX8(0, p[7]); - tpms_build_payload(p, 1, 13, 0, 0x4C900070u, false); // 1.3 kPa -> 1 - TEST_ASSERT_EQUAL_HEX8(1, p[7]); - tpms_build_payload(p, 1, 2588, 0, 0x4C900070u, false); // 258.8 kPa -> 104 - TEST_ASSERT_EQUAL_HEX8(104, p[7]); - tpms_build_payload(p, 1, 2587, 0, 0x4C900070u, false); // 258.7 kPa -> 103 - TEST_ASSERT_EQUAL_HEX8(103, p[7]); -} - -static void test_checksum(void) -{ - uint8_t p[TPMS_PAYLOAD_LEN]; - tpms_build_payload(p, 0x2FC871u, 2600, 23, 0x4C900070u, false); - unsigned sum = 0; - for (int i = 0; i < 9; i++) { - sum += p[i]; + if (frame == NULL || length != TPMS_TX_BYTES || (frame[0] & 0x80u) == 0u) { + return false; } - TEST_ASSERT_EQUAL_HEX8(sum & 0xFF, p[9]); + uint8_t row[15] = {0}; + unsigned chip = 1u; + for (unsigned bit = 1u; bit < TPMS_ROW_BITS; ++bit) { + unsigned first = (frame[chip >> 3] >> (7u - (chip & 7u))) & 1u; + unsigned second = (frame[(chip + 1u) >> 3] >> (7u - ((chip + 1u) & 7u))) & 1u; + if (first == second) { + return false; + } + unsigned value = first != 0u ? 1u : 0u; + row[bit >> 3] |= (uint8_t)(value << (7u - (bit & 7u))); + chip += 2u; + } + if ((frame[29] & 1u) != 0u) { + return false; + } + memcpy(payload, &row[5], TPMS_PAYLOAD_LEN); + uint8_t sum = 0; + for (uint8_t i = 0; i < 9u; ++i) sum = (uint8_t)(sum + payload[i]); + return sum == payload[9]; } -static void test_low_batt_flag(void) +static void test_manchester_polarity_and_negative_frames(void) { - uint8_t a[TPMS_PAYLOAD_LEN], b[TPMS_PAYLOAD_LEN]; - tpms_build_payload(a, 0x2FC871u, 2600, 23, 0x4C900070u, false); - tpms_build_payload(b, 0x2FC871u, 2600, 23, 0x4C900070u, true); - TEST_ASSERT_EQUAL_HEX32(0x4C900070u, - ((uint32_t)a[0] << 24) | (a[1] << 16) | (a[2] << 8) | a[3]); - TEST_ASSERT_TRUE((((uint32_t)b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]) - & TPMS_FLAGS_LOWBAT_MASK); + uint8_t frame[TPMS_TX_BYTES]; + uint8_t payload[TPMS_PAYLOAD_LEN]; + TEST_ASSERT_TRUE(tpms_build_frame(frame, 0x2FC871u, 2600u, 23, 0x4C900070u)); + TEST_ASSERT_TRUE(decode_strict(frame, sizeof(frame), payload)); + TEST_ASSERT_EQUAL_HEX32(0x2FC871u, + ((uint32_t)payload[4] << 16) | ((uint32_t)payload[5] << 8) | payload[6]); + + uint8_t damaged[TPMS_TX_BYTES]; + memcpy(damaged, frame, sizeof(frame)); + damaged[10] &= 0x3Fu; /* dwa jednakowe chipy: niedozwolony Manchester */ + TEST_ASSERT_FALSE(decode_strict(damaged, sizeof(damaged), payload)); + TEST_ASSERT_FALSE(decode_strict(frame, sizeof(frame) - 1u, payload)); + + memcpy(damaged, frame, sizeof(frame)); + /* Zmien ostatnia komorke checksum z zachowaniem poprawnego Manchester. */ + damaged[28] ^= 0x40u; + damaged[28] ^= 0x10u; + TEST_ASSERT_FALSE(decode_strict(damaged, sizeof(damaged), payload)); } -static void test_frame_layout(void) +static void test_rounding_and_saturation(void) { - uint8_t f[TPMS_TX_BYTES]; - tpms_build_frame(f, 0x2FC871u, 2600, 23, 0x4C900070u, false); - /* pierwszy bit = chip rozbiegowy '1' -> najstarszy bit pierwszego bajtu */ - TEST_ASSERT_EQUAL_HEX8(0xAA, f[0]); - /* dlugosc stale: 240 chipow = 30 bajtow */ - TEST_ASSERT_EQUAL_UINT32(30, TPMS_TX_BYTES); + uint8_t p[TPMS_PAYLOAD_LEN]; + TEST_ASSERT_TRUE(tpms_build_payload(p, 1u, 12u, 0, 0u)); + TEST_ASSERT_EQUAL_UINT8(0u, p[7]); + TEST_ASSERT_TRUE(tpms_build_payload(p, 1u, 13u, 0, 0u)); + TEST_ASSERT_EQUAL_UINT8(1u, p[7]); + TEST_ASSERT_TRUE(tpms_build_payload(p, 1u, 2588u, -40, 0u)); + TEST_ASSERT_EQUAL_UINT8(104u, p[7]); + TEST_ASSERT_EQUAL_UINT8(0u, p[8]); + TEST_ASSERT_TRUE(tpms_build_payload(p, 1u, 2587u, 85, 0u)); + TEST_ASSERT_EQUAL_UINT8(103u, p[7]); + TEST_ASSERT_EQUAL_UINT8(185u, p[8]); + TEST_ASSERT_TRUE(tpms_build_payload(p, 1u, 65535u, 127, 0u)); + TEST_ASSERT_EQUAL_UINT8(255u, p[7]); + TEST_ASSERT_EQUAL_UINT8(255u, p[8]); +} + +static void test_invalid_id_and_null_are_rejected(void) +{ + uint8_t p[TPMS_PAYLOAD_LEN]; + TEST_ASSERT_FALSE(tpms_build_payload(p, 0u, 2600u, 23, 0u)); + TEST_ASSERT_FALSE(tpms_build_payload(p, 0xFFFFFFu, 2600u, 23, 0u)); + TEST_ASSERT_FALSE(tpms_build_payload(p, 0x1000000u, 2600u, 23, 0u)); + TEST_ASSERT_FALSE(tpms_build_payload(NULL, 1u, 2600u, 23, 0u)); + TEST_ASSERT_FALSE(tpms_build_frame(NULL, 1u, 2600u, 23, 0u)); } int main(int argc, char **argv) { - (void)argc; (void)argv; + (void)argc; + (void)argv; UNITY_BEGIN(); - RUN_TEST(test_frame_vectors); - RUN_TEST(test_reference_capture); - RUN_TEST(test_pressure_scale); - RUN_TEST(test_pressure_rounding); - RUN_TEST(test_checksum); - RUN_TEST(test_low_batt_flag); - RUN_TEST(test_frame_layout); + RUN_TEST(test_four_independent_capture_payloads); + RUN_TEST(test_known_frame_and_pressure_temperature); + RUN_TEST(test_manchester_polarity_and_negative_frames); + RUN_TEST(test_rounding_and_saturation); + RUN_TEST(test_invalid_id_and_null_are_rejected); return UNITY_END(); } -- 2.54.1 From d7fc88c22702b1e3b2289ddcd34577325708e856 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:16:12 +0000 Subject: [PATCH 07/19] Testy ramki: cztery nagrania i przypadki negatywne -- 2.54.1 From 032811a88c9609ff98387bbe7f96d29eac25af6c Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:16:19 +0000 Subject: [PATCH 08/19] Firmware: NVS UART bezpieczny sleep i kontrola CC1101 --- src/app.h | 35 +-- src/config.h | 216 +++----------- src/console.cpp | 432 +++++++++++++++++----------- src/main.cpp | 621 +++++++++++------------------------------ src/power.cpp | 75 ++--- src/power.h | 31 +- src/radio.cpp | 137 ++++----- src/radio.h | 24 +- src/settings_store.cpp | 73 +++++ src/settings_store.h | 14 + 10 files changed, 632 insertions(+), 1026 deletions(-) create mode 100644 src/settings_store.cpp create mode 100644 src/settings_store.h diff --git a/src/app.h b/src/app.h index 17377f3..8bdbc50 100644 --- a/src/app.h +++ b/src/app.h @@ -1,40 +1,15 @@ -/* - * app.h - API aplikacji (tryby pracy) uzywane przez konsole i maszyne stanow - */ #ifndef TPMS_APP_H #define TPMS_APP_H #include +#include "app_state.h" -#ifdef __cplusplus -extern "C" { -#endif - -enum { - APP_MODE_NORMAL = 0, // rotacja wszystkich 4 kol + deep sleep - APP_MODE_LEARN = 1, // nauka czujnikow w aucie, jedno kolo naraz - APP_MODE_SINGLE = 2, // wymuszone nadawanie wskazanego ID -}; - -uint8_t app_mode(void); -uint8_t app_wheel(void); // aktywne kolo (w LEARN/SINGLE) - -void app_set_mode(uint8_t mode, uint8_t wheel); -void app_next_wheel(void); -void app_send_burst_wheel(uint8_t wheel); -void app_send_burst_all(void); +extern AppState *g_app; void app_print_info(void); void app_print_frame(uint8_t wheel); +bool app_save_and_apply(void); +void app_request_sleep(void); +void app_stay_awake(uint32_t ms); -uint32_t app_supply_mv(void); -void app_set_interval(uint32_t seconds); // 0 = automatyczny (wg ACC) -void app_set_flags(uint32_t flags); -void app_request_sleep(void); // zaspij teraz (tryb NORMAL) -void app_stay_awake(uint32_t ms); // przedluz okno konsoli - -#ifdef __cplusplus -} #endif - -#endif /* TPMS_APP_H */ diff --git a/src/config.h b/src/config.h index b3dec37..7511f62 100644 --- a/src/config.h +++ b/src/config.h @@ -1,190 +1,46 @@ -/* - * config.h - konfiguracja symulatora czujnikow TPMS Schrader EG53MA4 - * dla Opla Astry J Sedan 2016 (EU, TPMS bezposredni, czujniki Schrader). - * - * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - * ZASTRZEZENIE / DISCLAIMER: - * Projekt wylacznie do celow diagnostycznych i testowych. - * Symulator dostarcza SZTUCZNE dane cisnienia i temperatury i NIE - * zastepuje prawdziwych czujnikow TPMS. Nie uzywaj tego urzadzenia do - * jazdy po drogach publicznych - prawdziwy TPMS jest elementem - * bezpieczenstwa czynnego pojazdu. - * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - * - * Protokol wg rtl_433 src/devices/schraeder.c (schrader_EG53MA4): - * "Schrader TPMS EG53MA4, Saab, Opel, Vauxhall, Chevrolet" - * (Opel OEM 13348393), weryfikacja: tools/tpms_frame.py, tools/gen_cu8.py. - */ +/* Konfiguracja sprzetu. Dane czujnikow i RF sa w NVS, nie wymagaja rekompilacji. */ #ifndef TPMS_CONFIG_H #define TPMS_CONFIG_H -#define FW_VERSION "1.0.0" -#define CONFIG_VERSION 4 // podnos przy zmianie formatu danych w RTC +#define FW_VERSION "2.0.0-rc.1" -/* ====================================================================== - * 1. ZASILANIE - * POWER_12V - stale zasilanie z akumulatora 12 V. - * UWAGA: potrzebny jest uklad zasilajacy na PELENY zakres - * samochodowy (12 V nominalnie, 14,4 V przy ladowaniu, przepiecia - * load-dump nawet > 40 V): - * - LDO o wejsciu >= 16 V i niskim Iq, np. MCP1703 (Vin 2.7-16 V, - * Iq ~2 uA) - zabezpiecz wejscie bezpiecznikiem + TVS (np. 24 V) - * + rezystor szeregowy/dioda; ogranicz moc strat (patrz README), - * - albo przetwornica buck o szerokim wejsciu, np. LM5164-Q1 - * (Vin 6-100 V, Iq ~10 uA, 1 A). - * TPS62740 ma wejscie 2.2-5.5 V - NIE wolno podlaczac go do 12 V! - * POWER_BATTERY - ogniwo 3.6 V (Li-SOCl2) bezposrednio, albo LiPo 3.7 V - * PRZEZ LDO 3.3 V (np. MCP1700, Vin max 6 V). Bezposrednie - * zasilanie LiPo 4.2 V przekracza max ESP32 (3.6 V) i CC1101 (3.9 V)! - * ====================================================================== */ -#define POWER_SUPPLY_MODE POWER_12V -#define POWER_12V 1 -#define POWER_BATTERY 2 +/* ESP32 DevKit + CC1101 433 MHz (3,3 V). */ +#define PIN_CC1101_SCK 18 +#define PIN_CC1101_MISO 19 +#define PIN_CC1101_MOSI 23 +#define PIN_CC1101_CS 5 +#define PIN_CC1101_GDO0 2 -/* ====================================================================== - * 2. PINY (ESP32 DevKit + CC1101 po SPI) - * Piny CC1101 zgodne z wymaganiami projektu: - * SCK=18 MISO=19 MOSI=23 CS=5 GDO0=2 - * ====================================================================== */ -#define PIN_CC1101_SCK 18 -#define PIN_CC1101_MISO 19 -#define PIN_CC1101_MOSI 23 -#define PIN_CC1101_CS 5 -#define PIN_CC1101_GDO0 2 +#define PIN_BUTTON 26 +#define BTN_ACTIVE_LEVEL 0 +#define PIN_LED 27 -/* Przycisk sterowania trybami (wejscie budzace EXT0). - * Dolaczenie do GND + rezystor podciagajacy 10k do 3V3 (aktywny niski). */ -#define PIN_BUTTON 26 -#define BTN_ACTIVE_LEVEL 0 // 0 = aktywny niski (przycisk -> GND) +/* Opcje wylaczone do czasu zmontowania i przetestowania sprzetu. */ +#ifndef PIN_LF_TRIGGER +#define PIN_LF_TRIGGER -1 +#endif +#ifndef PIN_ACC +#define PIN_ACC -1 +#endif +#ifndef PIN_VBAT_ADC +#define PIN_VBAT_ADC 34 +#endif +#define VBAT_DIVIDER_R1 1000000.0f +#define VBAT_DIVIDER_R2 270000.0f +#define VBAT_CAL 1.000f +#define VBAT_SAMPLES 16 +#define LOWBATT_THRESHOLD_MV 11500 -/* LED statusowy (rezystor szeregowy 330R, aktywny wysoki). */ -#define PIN_LED 27 +/* Jedyny profil produkcyjny: OOK, Manchester 0->01, 1->10. */ +#define TPMS_CHIP_US 120u -/* Opcjonalne wejscie aktywacji LF 125 kHz (cewka + prostownik + tranzystor). - * Impuls wysoki = "programator przy kole" -> natychmiastowa transmisja. - * -1 wylacza funkcje (role pelni przycisk "aktywuj kolo"). */ -#define PIN_LF_TRIGGER 25 +/* Harmonogram i moc poczatkowa: settings_defaults() w settings.cpp. + * Sa to parametry eksperymentalne, a nie potwierdzony harmonogram OE. */ +#define BOOT_STAY_AWAKE_MS 10000u +#define SERIAL_BAUD 115200 -/* Opcjonalny sygnal zaplonu / ACC (dzielnik 12 V -> ok. 3 V, jak VBAT). - * Bez podciagania wewnetrznego (INPUT) - dolna galaz dzielnika wymusza - * stan niski. Bez sygnalu: PIN_ACC = -1 (wtedy stale TX_INTERVAL_S). - * DOMYSLNIE -1 (wylaczone) - ustaw np. 32 po podlaczeniu dzielnika. */ -#define PIN_ACC -1 +#define BTN_DEBOUNCE_MS 30u +#define BTN_LONG_MS 1500u +#define BTN_VERYLONG_MS 4000u -/* Pomiar napiecia zasilania: dzielnik R1(gora)/R2(dol) na pin ADC1 - * + kondensator 100 nF miedzy pinem a masa (ustalanie ADC). - * Dobor: 14,4 V (ladowanie) musi dac <= 3.0 V na wejsciu ADC, - * a prad dzielnika ma byc mikroamperowy (nie psuc budzetu snu): - * R1 = 1 M, R2 = 270 k -> 12 V: 2.55 V (~9 uA), 14.4 V: 3.05 V - * Zabezpieczenie wejscia: rezystor szeregowy + dioda klamujaca do 3V3. */ -#define PIN_VBAT_ADC 34 -#define VBAT_DIVIDER_R1 1000000.0f // ohm, gora (do zasilania) -#define VBAT_DIVIDER_R2 270000.0f // ohm, dol (do masy) -#define VBAT_CAL 1.000f // mnoznik kalibracji (por. z multimetrem) -#define VBAT_SAMPLES 16 - -/* ====================================================================== - * 3. CZUJNIKI - 4 identyfikatory (hex, po jednym na kolo) - * Kolejnosc nauki w Astrze: przod lewy -> przod prawy -> tyl prawy -> tyl lewy - * ID sa przykladowe (24-bit). Najlepiej przepisz ID ze starych czujnikow - * (odczytaj je rtl_433: rtl_433 -f 433.92M) - auto wtedy "widzi" znajome ID. - * ====================================================================== */ -#define WHEEL_FL 0 -#define WHEEL_FR 1 -#define WHEEL_RR 2 -#define WHEEL_RL 3 -#define WHEEL_COUNT 4 - -/* Kolejnosc nauki (kolejnosc pozycji w tablicy SENSOR[] ponizej = kolejnosc - * learn; domyslnie FL -> FR -> RR -> RL). Kolejnosc mozesz zmienic po prostu - * przestawiajac wpisy w tablicy SENSOR[] w main.cpp (lub zmieniajac ponizsze - * makra kolejnosci w trybie learn). */ -#define LEARN_ORDER_0 WHEEL_FL -#define LEARN_ORDER_1 WHEEL_FR -#define LEARN_ORDER_2 WHEEL_RR -#define LEARN_ORDER_3 WHEEL_RL - -/* ID poszczegolnych kol (24 bity) */ -#define SENSOR_FL_ID 0x2FC871u -#define SENSOR_FR_ID 0x2EAAF9u -#define SENSOR_RR_ID 0x3495ACu -#define SENSOR_RL_ID 0x2FC780u - -/* Cisnienie startowe: DOMYSLNIE 2,6 bar = 260 kPa dla wszystkich kol. - * Rozdzielczosc protokolu: 2,5 kPa/bit (0-637,5 kPa). */ -#define SENSOR_FL_PRESS_KPA 260.0f -#define SENSOR_FR_PRESS_KPA 260.0f -#define SENSOR_RR_PRESS_KPA 260.0f -#define SENSOR_RL_PRESS_KPA 260.0f - -/* Temperatura otoczenia (st. C) - konwertowana na st. F wg protokolu. */ -#define SENSOR_TEMP_C 23 - -/* ====================================================================== - * 4. PARAMETRY RF (Schrader EG53MA4) - * - dane: Manchester G.E.T. MC, chip = 120 us (8.33 kBaud) - * - nośna 433.92 MHz - * - modulacja: ASK/OOK (domyślna - tak pracuje referencyjny EG53MA4 z - * nagran rtl_433_tests i tak dekoderuje wbudowany Schrader-EG53MA4) - * albo 2-FSK z dewiacja 47.6 kHz (wariant konfigurowalny - jesli Twoj - * nadajnik/odbiornik auta pracuje FSK, przełacz MODE_FSK). - * ====================================================================== */ -#define MODE_OOK 0 -#define MODE_FSK 1 - -#define TPMS_FREQUENCY_MHZ 433.92f -#define TPMS_MODULATION MODE_OOK -#define TPMS_DEVIATION_KHZ 47.6f // dla MODE_FSK -#define TPMS_TX_POWER_DBM 10 // -30,-20,-15,-10,-6,0,5,7,10,11,12 -#define TPMS_CHIP_US 120 // czas trwania jednego chipa Manchester - // (8.33 kBaud - zmierzone na nagraniach) - -/* Ramka (dane z dekodera rtl_433 schrader_EG53MA4): - * 40 bit sync + 4 bajty flags + 3 bajty ID + cisnienie + temperatura + CRC. - * Suma kontrolna: suma 9 bajtow modulo 256 (add_bytes). */ -#define TPMS_FLAGS 0x4C900070u // flags ze zrzutow prawdziwych czujnikow -#define TPMS_FLAGS_LOWBAT_MASK 0x00000008u // bit "rozladowana bateria" - // (pozycja niepewna - dostosuj - // jesli Twoj sterownik oczekuje - // innego bitu) - -/* ====================================================================== - * 5. HARMONOGRAM NADAWANIA / SEN - * ====================================================================== */ -#define TX_BURST_FRAMES 3 // 3-6 ramek w burście (jak prawdziwy czujnik) -#define TX_FRAME_GAP_MS 50 // odstep miedzy ramkami w burscie -#define TX_INTERVAL_S 30 // interwal: kazde kolo co 30 s -#define TX_INTERVAL_IGNITION_S 15 // krotki interwal przy zaplonie (ACC) -#define TX_INTERVAL_PARKING_S 120 // interwal postojowy po zaniku ACC -#define ACC_GRACE_MS (5UL*60UL*1000UL) // 5 min po zaniku ACC -#define PARKING_SHUTDOWN 0 // 1 = po ACC_GRACE calkowite uspienie - // (sen bez budzika, obudza przycisk/LF) -#define BOOT_STAY_AWAKE_MS 3000 // okno na konsoli szeregowej po starcie - -/* ====================================================================== - * 6. TRYB LEARN / SINGLE - * ====================================================================== */ -#define LEARN_TX_PERIOD_MS 2000 // co ile ms wysylac bursta w learn -#define LEARN_WINDOW_MS 60000 // okno czasowe na 1 czujnik (60 s) -#define LEARN_WINDOW_EXPIRE_TO_NORMAL 1 // 1 = po uplywie okna powrot do - // trybu normalnego (wg specyfikacji), - // 0 = automatycznie kolejne kolo, - // po ostatnim -> NORMAL -#define LEARN_TOTAL_TIMEOUT_MS 900000 // bezpiecznik: 15 min i koniec learn -#define SINGLE_TIMEOUT_MS 300000 // 0 = bez limitu - -/* ====================================================================== - * 7. PROGI / DIAGNOSTYKA - * ====================================================================== */ -#define LOWBATT_THRESHOLD_MV 11500 // dla POWER_12V (prog alarmu TPMS) - // dla POWER_BATTERY ustaw np. 3200 -#define SERIAL_BAUD 115200 - -/* ====================================================================== - * 8. GESTY PRZYCISKU - * ====================================================================== */ -#define BTN_DEBOUNCE_MS 30 -#define BTN_LONG_MS 1500 // >= 1.5 s = wejscie/wyjscie LEARN -#define BTN_VERYLONG_MS 4000 // >= 4 s = wejscie/wyjscie SINGLE - -#endif /* TPMS_CONFIG_H */ +#endif diff --git a/src/console.cpp b/src/console.cpp index 55c3fb8..a03b63b 100644 --- a/src/console.cpp +++ b/src/console.cpp @@ -1,202 +1,298 @@ -/* - * console.cpp - debugowa konsola szeregowa (bez String i bez malloc) - * - * Komendy: - * help - lista komend - * info - wersja, konfiguracja, stan, napiecie - * hex [n|all] - hexdump ramki TPMS dla kola n (1-4) lub wszystkich - * send [n|all] - wyslij burst ramki teraz - * batt - odczyt stanu baterii (napiecie zasilania) - * mode normal|learn|single [n] - zmiana trybu - * next - kolejne kolo (learn/single) - * interval - reczy ustalony interwal (0 = auto wg ACC) - * flags - slowo flags wyslane w ramce - * sleep - deep sleep teraz - * stay [s] - zostan w stanie czuwania jeszcze s sekund - * - * Parser jest scisly: zly argument = komunikat bledu, bez dzialania - * ubocznego (np. "send bla" NIE nadaje wszystkich kol). - */ +/* Konsola szeregowa: konfiguracja zapisywana w NVS, bez rekompilacji. */ #include -#include -#include +#include #include +#include +#include -#include "config.h" #include "app.h" #include "console.h" +#include "power.h" +#include "settings_store.h" -static char line[64]; -static uint8_t line_len = 0; -static bool line_overflow = false; +static char line[96]; +static uint8_t line_len; +static bool line_overflow; -static void cmd_help(void) +static bool parse_u32(const char *text, uint32_t lo, uint32_t hi, + uint32_t *out, int base = 10) { - Serial.println(F("Komendy:")); - Serial.println(F(" help - ta pomoc")); - Serial.println(F(" info - wersja/config/stan/napiecie")); - Serial.println(F(" hex [n|all] - hexdump ramki kola n (1-4)")); - Serial.println(F(" send [n|all] - nadaj burst teraz")); - Serial.println(F(" batt - napiecie zasilania [mV]")); - Serial.println(F(" mode normal|learn|single [n] - tryb pracy")); - Serial.println(F(" next - kolejne kolo (learn/single)")); - Serial.println(F(" interval - interwal nadawania (0=auto)")); - Serial.println(F(" flags - slowo flags w ramce")); - Serial.println(F(" sleep - deep sleep teraz")); - Serial.println(F(" stay [s] - czuwaj jeszcze s sekund")); -} - -/* Scisly parser liczby calkowitej bez znaku z zakresem. */ -static bool parse_u32(const char *s, uint32_t lo, uint32_t hi, uint32_t *out, - int base) -{ - if (s == NULL || *s == '\0') { + if (text == NULL || *text == '\0' || *text == '-') { return false; } errno = 0; char *end = NULL; - unsigned long v = strtoul(s, &end, base); - if (errno != 0 || end == s || *end != '\0') { + unsigned long value = strtoul(text, &end, base); + if (errno != 0 || end == text || *end != '\0' + || value < lo || value > hi) { return false; } - if (v < (unsigned long)lo || v > (unsigned long)hi) { - return false; - } - *out = (uint32_t)v; + *out = (uint32_t)value; return true; } -/* Numer kola 1-4 -> indeks 0-3; "all" -> 0xFF; blad -> -1. */ -static int parse_wheel(const char *arg, uint8_t *wheel) +static bool parse_i32(const char *text, int32_t lo, int32_t hi, int32_t *out) { - if (arg == NULL) { - return -1; + if (text == NULL || *text == '\0') { + return false; } - if (strcmp(arg, "all") == 0) { - *wheel = 0xFF; - return 0; + errno = 0; + char *end = NULL; + long value = strtol(text, &end, 10); + if (errno != 0 || end == text || *end != '\0' || value < lo || value > hi) { + return false; } - uint32_t n = 0; - if (!parse_u32(arg, 1, WHEEL_COUNT, &n, 10)) { - return -1; - } - *wheel = (uint8_t)(n - 1); - return 0; + *out = value; + return true; } -static void handle_line(char *s) +static bool parse_float(const char *text, float lo, float hi, float *out) { - char *cmd = strtok(s, " \t"); + if (text == NULL || *text == '\0') { + return false; + } + errno = 0; + char *end = NULL; + float value = strtof(text, &end); + if (errno != 0 || end == text || *end != '\0' || value < lo || value > hi) { + return false; + } + *out = value; + return true; +} + +static bool parse_wheel(const char *text, uint8_t *wheel, bool allow_all = false) +{ + if (allow_all && text != NULL && strcmp(text, "all") == 0) { + *wheel = 0xFFu; + return true; + } + uint32_t value; + if (!parse_u32(text, 1u, WHEEL_COUNT, &value)) { + return false; + } + *wheel = (uint8_t)(value - 1u); + return true; +} + +static void cmd_help(void) +{ + Serial.println(F("POMOC (zmiany konfiguracji zapisuja sie automatycznie):")); + Serial.println(F(" info | hex [1-4|all] | send [1-4|all] | batt")); + Serial.println(F(" mode normal | mode learn [1-4] | mode single 1-4 | next")); + Serial.println(F(" id 1-4 XXXXXX - ustaw 24-bit ID (hex)")); + Serial.println(F(" ids new - wygeneruj 4 unikalne ID")); + Serial.println(F(" pressure 1-4|all KPA - np. pressure all 260")); + Serial.println(F(" temp 1-4|all C - temperatura -40..85 C")); + Serial.println(F(" interval normal|ignition|parking 5-86400")); + Serial.println(F(" rf freq 433.05-434.79 | rf power -30..5 | rf burst 1-8")); + Serial.println(F(" rf gap 20-500 - odstep miedzy ramkami [ms]")); + Serial.println(F(" flags HEX - 32-bit flags (znaczenie nie w pelni znane)")); + Serial.println(F(" factory YES - przywroc fabryczne | save | stay [s] | sleep")); +} + +static void cmd_send(const char *arg) +{ + uint8_t wheel; + bool ok; + if (arg == NULL) { + ok = g_app->mode() == AppMode::NORMAL ? g_app->send_all() : g_app->send_current(); + } else if (parse_wheel(arg, &wheel, true)) { + ok = wheel == 0xFFu ? g_app->send_all() : g_app->send_wheel(wheel); + } else { + Serial.println(F("BLAD: send [1-4|all]")); + return; + } + Serial.println(ok ? F("OK") : F("BLAD TX")); +} + +static void cmd_mode(const char *arg1, const char *arg2) +{ + if (arg1 == NULL) { + Serial.println(F("BLAD: mode normal|learn|single [1-4]")); + return; + } + uint8_t wheel = WHEEL_FL; + if (arg2 != NULL && !parse_wheel(arg2, &wheel)) { + Serial.println(F("BLAD: kolo 1-4")); + return; + } + if (strcmp(arg1, "normal") == 0) { + g_app->set_mode(AppMode::NORMAL, WHEEL_FL, millis(), false); + } else if (strcmp(arg1, "learn") == 0) { + g_app->set_mode(AppMode::LEARN, wheel, millis()); + } else if (strcmp(arg1, "single") == 0 && arg2 != NULL) { + g_app->set_mode(AppMode::SINGLE, wheel, millis()); + } else { + Serial.println(F("BLAD: mode normal|learn [1-4]|single 1-4")); + return; + } + Serial.println(F("OK")); +} + +static void cmd_id(const char *wheel_text, const char *id_text) +{ + uint8_t wheel; + uint32_t id; + if (!parse_wheel(wheel_text, &wheel) || !parse_u32(id_text, 1u, 0xFFFFFEu, &id, 16) + || !settings_set_id(&g_settings, wheel, id)) { + Serial.println(F("BLAD: id 1-4 000001..FFFFFE; ID musza byc unikalne")); + return; + } + app_save_and_apply(); +} + +static void cmd_pressure_temp(const char *which, const char *wheel_text, + const char *value_text) +{ + uint8_t wheel; + if (!parse_wheel(wheel_text, &wheel, true)) { + Serial.println(F("BLAD: kolo 1-4 lub all")); + return; + } + uint8_t first = wheel == 0xFFu ? 0u : wheel; + uint8_t last = wheel == 0xFFu ? WHEEL_COUNT : (uint8_t)(wheel + 1u); + if (strcmp(which, "pressure") == 0) { + float kpa; + if (!parse_float(value_text, 0.0f, 637.5f, &kpa)) { + Serial.println(F("BLAD: cisnienie 0..637.5 kPa")); + return; + } + uint16_t value = (uint16_t)(kpa * 10.0f + 0.5f); + for (uint8_t i = first; i < last; ++i) { + g_settings.wheels[i].pressure_kpa10 = value; + } + } else { + int32_t value; + if (!parse_i32(value_text, -40, 85, &value)) { + Serial.println(F("BLAD: temperatura -40..85 C")); + return; + } + for (uint8_t i = first; i < last; ++i) { + g_settings.wheels[i].temp_c = (int16_t)value; + } + } + app_save_and_apply(); +} + +static void cmd_interval(const char *which, const char *value_text) +{ + uint32_t value; + if (which == NULL || !parse_u32(value_text, SETTINGS_INTERVAL_MIN_S, + SETTINGS_INTERVAL_MAX_S, &value)) { + Serial.println(F("BLAD: interval normal|ignition|parking 5-86400")); + return; + } + if (strcmp(which, "normal") == 0) { + g_settings.normal_interval_s = value; + } else if (strcmp(which, "ignition") == 0) { + g_settings.ignition_interval_s = value; + } else if (strcmp(which, "parking") == 0) { + g_settings.parking_interval_s = value; + } else { + Serial.println(F("BLAD: rodzaj interwalu")); + return; + } + app_save_and_apply(); +} + +static void cmd_rf(const char *which, const char *value_text) +{ + uint32_t value; + int32_t signed_value; + float frequency; + if (which == NULL) { + Serial.println(F("BLAD: rf freq|power|burst|gap")); + return; + } + if (strcmp(which, "freq") == 0 && parse_float(value_text, 433.05f, 434.79f, &frequency)) { + g_settings.frequency_mhz = frequency; + } else if (strcmp(which, "power") == 0 + && parse_i32(value_text, -30, 5, &signed_value) + && settings_valid_tx_power((int)signed_value)) { + g_settings.tx_power_dbm = (int8_t)signed_value; + } else if (strcmp(which, "burst") == 0 && parse_u32(value_text, 1u, 8u, &value)) { + g_settings.burst_frames = (uint8_t)value; + } else if (strcmp(which, "gap") == 0 && parse_u32(value_text, 20u, 500u, &value)) { + g_settings.frame_gap_ms = (uint16_t)value; + } else { + Serial.println(F("BLAD: parametr RF poza dozwolonym zakresem")); + return; + } + app_save_and_apply(); +} + +static void handle_line(char *text) +{ + char *cmd = strtok(text, " \t"); if (cmd == NULL) { return; } char *arg1 = strtok(NULL, " \t"); char *arg2 = strtok(NULL, " \t"); - uint32_t u = 0; + uint32_t value; if (strcmp(cmd, "help") == 0) { cmd_help(); - } - else if (strcmp(cmd, "info") == 0 || strcmp(cmd, "config") == 0) { + } else if (strcmp(cmd, "info") == 0 || strcmp(cmd, "config") == 0) { app_print_info(); - } - else if (strcmp(cmd, "hex") == 0) { - uint8_t w; - if (arg1 == NULL || strcmp(arg1, "all") == 0) { - for (uint8_t i = 0; i < WHEEL_COUNT; i++) { - app_print_frame(i); + } else if (strcmp(cmd, "hex") == 0) { + uint8_t wheel; + if (arg1 == NULL) { + app_print_frame(g_app->active_wheel()); + } else if (parse_wheel(arg1, &wheel, true)) { + if (wheel == 0xFFu) { + for (uint8_t i = 0; i < WHEEL_COUNT; ++i) app_print_frame(i); + } else { + app_print_frame(wheel); } - } - else if (parse_wheel(arg1, &w) == 0) { - app_print_frame(w); - } - else { + } else { Serial.println(F("BLAD: hex [1-4|all]")); } - } - else if (strcmp(cmd, "send") == 0) { - uint8_t w; - if (arg1 == NULL || strcmp(arg1, "all") == 0) { - app_send_burst_all(); - Serial.println(F("OK")); - } - else if (parse_wheel(arg1, &w) == 0) { - app_send_burst_wheel(w); - Serial.println(F("OK")); - } - else { - Serial.println(F("BLAD: send [1-4|all]")); - } - } - else if (strcmp(cmd, "batt") == 0) { - Serial.printf("Vcc = %u mV\n", (unsigned)app_supply_mv()); - } - else if (strcmp(cmd, "next") == 0) { - app_next_wheel(); - } - else if (strcmp(cmd, "mode") == 0) { - uint8_t w = 0; - if (arg1 == NULL) { - Serial.println(F("BLAD: mode normal|learn|single [n]")); + } else if (strcmp(cmd, "send") == 0) { + cmd_send(arg1); + } else if (strcmp(cmd, "batt") == 0) { + Serial.printf("Vcc=%u mV\n", (unsigned)power_read_mv()); + } else if (strcmp(cmd, "mode") == 0) { + cmd_mode(arg1, arg2); + } else if (strcmp(cmd, "next") == 0) { + Serial.println(g_app->next_wheel(millis()) ? F("OK") : F("BLAD: tylko LEARN/SINGLE")); + } else if (strcmp(cmd, "id") == 0) { + cmd_id(arg1, arg2); + } else if (strcmp(cmd, "ids") == 0 && arg1 != NULL && strcmp(arg1, "new") == 0) { + settings_generate_ids(&g_settings, esp_random()); + app_save_and_apply(); + } else if (strcmp(cmd, "pressure") == 0 || strcmp(cmd, "temp") == 0) { + cmd_pressure_temp(cmd, arg1, arg2); + } else if (strcmp(cmd, "interval") == 0) { + cmd_interval(arg1, arg2); + } else if (strcmp(cmd, "rf") == 0) { + cmd_rf(arg1, arg2); + } else if (strcmp(cmd, "flags") == 0) { + if (!parse_u32(arg1, 0u, 0xFFFFFFFFu, &value, 16)) { + Serial.println(F("BLAD: flags HEX")); return; } - if (strcmp(arg1, "normal") == 0) { - app_set_mode(APP_MODE_NORMAL, 0); - } - else if (strcmp(arg1, "learn") == 0) { - if (arg2 != NULL && parse_wheel(arg2, &w) != 0) { - Serial.println(F("BLAD: numer kola 1-4")); - return; - } - app_set_mode(APP_MODE_LEARN, w); - } - else if (strcmp(arg1, "single") == 0) { - if (arg2 == NULL || parse_wheel(arg2, &w) != 0 || w == 0xFF) { - Serial.println(F("BLAD: single wymaga numeru kola 1-4")); - return; - } - app_set_mode(APP_MODE_SINGLE, w); - } - else { - Serial.println(F("BLAD: mode normal|learn|single [n]")); - return; - } - Serial.println(F("OK")); - } - else if (strcmp(cmd, "interval") == 0) { - if (!parse_u32(arg1, 0, 86400, &u, 10)) { - Serial.println(F("BLAD: interval <0-86400>")); - return; - } - app_set_interval(u); - Serial.println(F("OK")); - } - else if (strcmp(cmd, "flags") == 0) { - if (!parse_u32(arg1, 0, 0xFFFFFFFFu, &u, 16)) { - Serial.println(F("BLAD: flags ")); - return; - } - app_set_flags(u); - Serial.println(F("OK")); - } - else if (strcmp(cmd, "sleep") == 0) { + g_settings.flags = value; + app_save_and_apply(); + } else if (strcmp(cmd, "factory") == 0 && arg1 != NULL && strcmp(arg1, "YES") == 0) { + settings_defaults(&g_settings); + g_app->set_mode(AppMode::NORMAL, WHEEL_FL, millis(), false); + app_save_and_apply(); + } else if (strcmp(cmd, "save") == 0) { + app_save_and_apply(); + } else if (strcmp(cmd, "sleep") == 0) { app_request_sleep(); - } - else if (strcmp(cmd, "stay") == 0) { - if (arg1 == NULL) { - app_stay_awake(60000u); - } - else if (parse_u32(arg1, 0, 3600, &u, 10)) { - app_stay_awake(u * 1000u); - } - else { - Serial.println(F("BLAD: stay <0-3600>")); + } else if (strcmp(cmd, "stay") == 0) { + value = 60u; + if (arg1 != NULL && !parse_u32(arg1, 1u, 3600u, &value)) { + Serial.println(F("BLAD: stay 1-3600")); return; } + app_stay_awake(value * 1000u); Serial.println(F("OK")); - } - else { - Serial.println(F("Nieznana komenda - 'help'")); + } else { + Serial.println(F("Nieznana komenda; help")); } } @@ -213,23 +309,19 @@ void console_poll(void) if (c == '\r' || c == '\n') { if (line_overflow) { Serial.println(F("BLAD: linia za dluga")); - } - else if (line_len > 0) { + } else if (line_len > 0u) { line[line_len] = '\0'; handle_line(line); } line_len = 0; line_overflow = false; - } - else if (line_overflow) { - /* po przeplenieniu porzucamy cala linie lacznie z ogonem */ - } - else if (line_len < sizeof(line) - 1u) { - line[line_len++] = c; - } - else { - line_overflow = true; - line_len = 0; + } else if (!line_overflow) { + if (line_len < sizeof(line) - 1u) { + line[line_len++] = c; + } else { + line_overflow = true; + line_len = 0; + } } } } diff --git a/src/main.cpp b/src/main.cpp index 816f761..24cc762 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -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 #include -#include -#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(); } } diff --git a/src/power.cpp b/src/power.cpp index 53686d2..c73558f 100644 --- a/src/power.cpp +++ b/src/power.cpp @@ -1,19 +1,8 @@ -/* - * power.cpp - zasilanie, pomiar napiecia, deep sleep - * - * Zastrzezenie: urzadzenie diagnostyczne/testowe - symulator TPMS - * dostarcza sztuczne dane cisnienia i nie zastepuje prawdziwych czujnikow. - * - * Budzet pradu (patrz README): - * - ESP32 deep sleep: ~10 uA (WiFi/BT nie sa wcale inicjalizowane) - * - CC1101 w SLEEP (SPWD): < 1 uA - * - gpio_hold trzyma linie CC1101 w stanach niskich/wysokiej CS - */ +/* Zasilanie i deep sleep. Stan zasilania NIE zmienia pol protokolu TPMS. */ #include #include #include #include -#include #include "config.h" #include "power.h" @@ -21,28 +10,30 @@ void power_init(void) { - /* Zwolnij hold z poprzedniego snu - po deep sleep piny sa zatrzymane. */ gpio_deep_sleep_hold_dis(); gpio_hold_dis((gpio_num_t)PIN_CC1101_CS); gpio_hold_dis((gpio_num_t)PIN_CC1101_SCK); gpio_hold_dis((gpio_num_t)PIN_CC1101_MOSI); - - /* WiFi nie jest wcale uruchamiany (brak init), BT wylaczamy defensywnie. */ btStop(); - +#if PIN_VBAT_ADC >= 0 analogSetPinAttenuation(PIN_VBAT_ADC, ADC_11db); +#endif } uint32_t power_read_mv(void) { +#if PIN_VBAT_ADC < 0 + return 0u; +#else uint64_t sum = 0; - for (int i = 0; i < VBAT_SAMPLES; i++) { + for (uint8_t i = 0; i < VBAT_SAMPLES; ++i) { sum += analogReadMilliVolts(PIN_VBAT_ADC); } uint32_t pin_mv = (uint32_t)(sum / VBAT_SAMPLES); - float v = (float)pin_mv * ((VBAT_DIVIDER_R1 + VBAT_DIVIDER_R2) / VBAT_DIVIDER_R2) - * VBAT_CAL; - return (uint32_t)(v + 0.5f); + float value = (float)pin_mv * ((VBAT_DIVIDER_R1 + VBAT_DIVIDER_R2) / VBAT_DIVIDER_R2) + * VBAT_CAL; + return (uint32_t)(value + 0.5f); +#endif } bool power_low_battery(uint32_t mv) @@ -52,55 +43,27 @@ bool power_low_battery(uint32_t mv) void power_deep_sleep(uint32_t seconds) { - /* CC1101 w sleep + bezpieczne stany linii (CS=1 utrzymuje SPWD). */ radio_sleep(); - - /* Zatrzymaj piny w tych stanach na czas snu. */ gpio_hold_en((gpio_num_t)PIN_CC1101_CS); gpio_hold_en((gpio_num_t)PIN_CC1101_SCK); gpio_hold_en((gpio_num_t)PIN_CC1101_MOSI); gpio_deep_sleep_hold_en(); - /* Budzik RTC. */ esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_ALL); - if (seconds > 0) { - if (esp_sleep_enable_timer_wakeup((uint64_t)seconds * 1000000ULL) != ESP_OK) { - Serial.println(F("power: blad konfiguracji budzika RTC")); - } + /* PARKING_SHUTDOWN nie istnieje: kazdy sen ma budzik i nie mozna + * zatrzymac urzadzenia do czasu recznego wybudzenia. */ + if (seconds < SETTINGS_INTERVAL_MIN_S) { + seconds = SETTINGS_INTERVAL_MIN_S; } + esp_sleep_enable_timer_wakeup((uint64_t)seconds * 1000000ULL); - /* Przycisk jako zrodlo EXT0 (poziom konfigurowalny). */ #if PIN_BUTTON >= 0 - if (esp_sleep_enable_ext0_wakeup((gpio_num_t)PIN_BUTTON, BTN_ACTIVE_LEVEL) - != ESP_OK) { - Serial.println(F("power: blad konfiguracji EXT0 (pin nie RTC?)")); - } + esp_sleep_enable_ext0_wakeup((gpio_num_t)PIN_BUTTON, BTN_ACTIVE_LEVEL); #endif - /* Opcjonalne wejscie LF 125 kHz (impuls wysoki) jako EXT1. - * Uwaga: poziom musi byc niski w spoczynku, inaczej ESP32 obudzi sie - * natychmiast po wejsciu w sen. */ - uint64_t ext1_mask = 0; #if PIN_LF_TRIGGER >= 0 - ext1_mask |= (1ULL << PIN_LF_TRIGGER); + uint64_t ext1_mask = 1ULL << PIN_LF_TRIGGER; + esp_sleep_enable_ext1_wakeup(ext1_mask, ESP_EXT1_WAKEUP_ANY_HIGH); #endif - if (ext1_mask != 0) { - if (esp_sleep_enable_ext1_wakeup(ext1_mask, ESP_EXT1_WAKEUP_ANY_HIGH) - != ESP_OK) { - Serial.println(F("power: blad konfiguracji EXT1 (pin nie RTC?)")); - } - } - esp_deep_sleep_start(); } - -uint64_t power_elapsed_ms(void) -{ - /* System time jest utrzymywany przez RTC i przywracany po deep sleep, - * wiec licznik rosnie o rzeczywisty czas (takze ten spedzony w snie), - * a nie o planowany interwal - wczesniejsze wybudzenia (przycisk/LF) - * nie zaklamuja wtedy logiki "5 min po zaniku ACC". */ - struct timeval tv; - gettimeofday(&tv, NULL); - return (uint64_t)tv.tv_sec * 1000u + (uint64_t)(tv.tv_usec / 1000); -} diff --git a/src/power.h b/src/power.h index f618b88..3402db6 100644 --- a/src/power.h +++ b/src/power.h @@ -1,37 +1,12 @@ -/* - * power.h - zasilanie, pomiar napiecia, deep sleep - */ #ifndef TPMS_POWER_H #define TPMS_POWER_H -#include #include +#include -#ifdef __cplusplus -extern "C" { -#endif - -/* Wywolac raz po starcie (zwalnia gpio_hold z poprzedniego snu). */ void power_init(void); - -/* Pomiar napiecia zasilania [mV] (dzielnik ADC + kalibracja). */ uint32_t power_read_mv(void); +bool power_low_battery(uint32_t mv); /* tylko ostrzezenie o zasilaniu emulatora */ +void power_deep_sleep(uint32_t seconds); /* zawsze ma budzik RTC; nie wraca */ -/* Decyzja o fladze "niska bateria" (prog LOWBATT_THRESHOLD_MV). */ -bool power_low_battery(uint32_t mV); - -/* Przygotuj i wejdz w deep sleep na `seconds` (0 = bez budzika, tylko - * przycisk/LF). Funkcja nie wraca. */ -void power_deep_sleep(uint32_t seconds); - -/* Czas rzeczywisty [ms] od startu systemu - licznik RTC przetrwuje deep - * sleep (ESP32 przywraca czas z RTC po wybudzeniu), wiec rosnie o rzeczywisty - * czas spedzony w snie, nie o planowany interwal. Uzywane do logiki - * "5 min po zaniku ACC". */ -uint64_t power_elapsed_ms(void); - -#ifdef __cplusplus -} #endif - -#endif /* TPMS_POWER_H */ diff --git a/src/radio.cpp b/src/radio.cpp index dce0cd6..bb10394 100644 --- a/src/radio.cpp +++ b/src/radio.cpp @@ -1,14 +1,4 @@ -/* - * radio.cpp - konfiguracja CC1101 i nadawanie ramek TPMS - * - * Modul: CC1101 po SPI (SCK=18, MISO=19, MOSI=23, CS=5, GDO0=2). - * Biblioteka: SmartRC-CC1101-Driver-Lib (LSatan), naglowek zgodnosciowy - * ELECHOUSE_CC1101_SRC_DRV.h - obslugiwane sa obie wersje API (2.x i 3.x). - * - * Nadawanie: tryb FIFO (pakiet o stalej dlugosci, bez preambuly/sync/CRC - * CC1101 - wszystkie bity, lacznie z preambula i wlasna suma kontrolna, - * leza w naszym buforze). Kolejnosc bitow MSB first. - */ +/* CC1101: surowe 30 bajtow Manchester w fixed-length FIFO, bez wstawek HW. */ #include #include #include @@ -20,67 +10,54 @@ static bool radio_ok = false; -/* ------------------------------------------------------------------ */ -/* Inicjalizacja pinow */ -/* Wymagana biblioteka SmartRC-CC1101-Driver-Lib >= 2.5.7 */ -/* (wspolne API setSpiPin/setGDO0 dla wersji 2.5.x i 3.x; */ -/* starsze 1.x mialy setSCK/setMISO/... - nie sa obslugiwane). */ -/* ------------------------------------------------------------------ */ -static void radio_set_pins(void) -{ - ELECHOUSE_cc1101.setSpiPin(PIN_CC1101_SCK, PIN_CC1101_MISO, - PIN_CC1101_MOSI, PIN_CC1101_CS); - ELECHOUSE_cc1101.setGDO0(PIN_CC1101_GDO0); -} - -bool radio_init(void) +bool radio_init(const settings_t *cfg) { + radio_ok = false; + if (cfg == NULL) { + return false; + } gpio_deep_sleep_hold_dis(); gpio_hold_dis((gpio_num_t)PIN_CC1101_CS); gpio_hold_dis((gpio_num_t)PIN_CC1101_SCK); gpio_hold_dis((gpio_num_t)PIN_CC1101_MOSI); - radio_set_pins(); + ELECHOUSE_cc1101.setSpiPin(PIN_CC1101_SCK, PIN_CC1101_MISO, + PIN_CC1101_MOSI, PIN_CC1101_CS); + ELECHOUSE_cc1101.setGDO0(PIN_CC1101_GDO0); ELECHOUSE_cc1101.Init(); - - radio_ok = ELECHOUSE_cc1101.getCC1101(); - if (!radio_ok) { + if (!ELECHOUSE_cc1101.getCC1101()) { return false; } - ELECHOUSE_cc1101.setCCMode(1); // tryb wewnetrzny, dane z FIFO - if (TPMS_MODULATION == MODE_FSK) { - ELECHOUSE_cc1101.setModulation(0); // 2-FSK - ELECHOUSE_cc1101.setDeviation(TPMS_DEVIATION_KHZ); - } - else { - ELECHOUSE_cc1101.setModulation(2); // ASK/OOK - } - ELECHOUSE_cc1101.setMHZ(TPMS_FREQUENCY_MHZ); - ELECHOUSE_cc1101.setDRate(1000.0f / (float)TPMS_CHIP_US); // kBaud (8.33) - ELECHOUSE_cc1101.setPA(TPMS_TX_POWER_DBM); + ELECHOUSE_cc1101.setCCMode(1); + ELECHOUSE_cc1101.setModulation(2); /* ASK/OOK; brak profilu FSK. */ + ELECHOUSE_cc1101.setMHZ(cfg->frequency_mhz); + ELECHOUSE_cc1101.setDRate(1000.0f / (float)TPMS_CHIP_US); + ELECHOUSE_cc1101.setPA(cfg->tx_power_dbm); ELECHOUSE_cc1101.setChannel(0); - ELECHOUSE_cc1101.setSyncMode(0); // bez preambuly/sync CC1101 + /* SYNC_MODE=0: packet engine nie dodaje preambuly ani slowa sync. */ + ELECHOUSE_cc1101.setSyncMode(0); ELECHOUSE_cc1101.setPRE(0); ELECHOUSE_cc1101.setAdrChk(0); ELECHOUSE_cc1101.setAddr(0); - ELECHOUSE_cc1101.setWhiteData(0); // bez whiteningu - ELECHOUSE_cc1101.setManchester(0); // Manchester kodujemy sami + ELECHOUSE_cc1101.setWhiteData(0); + ELECHOUSE_cc1101.setManchester(0); ELECHOUSE_cc1101.setFEC(0); - ELECHOUSE_cc1101.setCrc(0); // wlasna suma kontrolna protokolu + ELECHOUSE_cc1101.setCrc(0); ELECHOUSE_cc1101.setCRC_AF(0); ELECHOUSE_cc1101.setAppendStatus(0); ELECHOUSE_cc1101.setDcFilterOff(0); - ELECHOUSE_cc1101.setPktFormat(0); // normalny tryb FIFO - ELECHOUSE_cc1101.setLengthConfig(0); // stala dlugosc pakietu + ELECHOUSE_cc1101.setPktFormat(0); + ELECHOUSE_cc1101.setLengthConfig(0); ELECHOUSE_cc1101.setPacketLength(TPMS_TX_BYTES); + radio_ok = true; return true; } bool radio_send_frame(const uint8_t *buf, uint8_t len) { - if (!radio_ok) { + if (!radio_ok || buf == NULL || len != TPMS_TX_BYTES) { return false; } @@ -89,48 +66,40 @@ bool radio_send_frame(const uint8_t *buf, uint8_t len) ELECHOUSE_cc1101.SpiWriteBurstReg(CC1101_TXFIFO, (uint8_t *)buf, len); ELECHOUSE_cc1101.SpiStrobe(CC1101_STX); - /* Pelny czas serializacji bufora na antenie: sprzet wysyla dokladnie - * len*8 chipow z predkoscia DRate. UWAGA: TXBYTES == 0 NIE oznacza - * konca transmisji - po oproznieniu FIFO ostatni bajt jest dopiero - * w rejestrze przesuwnym (8 chipow = 8*TPMS_CHIP_US), wiec wczesniejsze - * SIDLE obcialoby ogon ramki. Czekamy zatem na policzony czas + maly - * margines i dopiero wtedy wychodzimy z TX. */ - uint32_t air_us = (uint32_t)len * 8u * (uint32_t)TPMS_CHIP_US + 1000u; - uint32_t t0 = micros(); - while ((uint32_t)(micros() - t0) < air_us) { - delayMicroseconds(500); - } - - /* Diagnostyka po zakonczeniu: dwa zgodne odczyty (errata CC1101), - * kontrola niedopelnienia FIFO i tego, czy bufor zostal faktycznie - * wyslany. Zwracamy blad zamiast udawac sukces. */ - bool ok = true; - uint8_t txb = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES); - uint8_t txb2 = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES); - if (txb != txb2) { - txb = txb2; - } - if (txb & 0x80u) { // TXFIFO_UNDERFLOW - ok = false; - } - if ((txb & 0x7Fu) != 0) { // cos zostalo w FIFO - transmisja nie wyszla - ok = false; + /* Czekamy na MARCSTATE, nie na samo TXBYTES=0: ostatni bajt moze byc + * jeszcze w rejestrze przesuwnym. Limit obejmuje start i pelny ogon. */ + const uint32_t timeout_us = (uint32_t)len * 8u * TPMS_CHIP_US + 10000u; + const uint32_t start = micros(); + bool finished = false; + bool underflow = false; + while ((uint32_t)(micros() - start) < timeout_us) { + uint8_t state = ELECHOUSE_cc1101.SpiReadStatus(CC1101_MARCSTATE) & 0x1Fu; + if (state == 0x16u) { /* TXFIFO_UNDERFLOW */ + underflow = true; + break; + } + if (state == 0x01u) { /* IDLE po automatycznym zakonczeniu pakietu */ + finished = true; + break; + } + delayMicroseconds(50); } + uint8_t txbytes = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES); + underflow |= (txbytes & 0x80u) != 0u; ELECHOUSE_cc1101.SpiStrobe(CC1101_SIDLE); ELECHOUSE_cc1101.SpiStrobe(CC1101_SFTX); - return ok; + return finished && !underflow && (txbytes & 0x7Fu) == 0u; } -bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames) +bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames, + uint16_t gap_ms) { bool ok = true; - for (uint8_t i = 0; i < frames; i++) { - if (!radio_send_frame(buf, len)) { - ok = false; - } - if (i + 1u < frames) { - delay(TX_FRAME_GAP_MS); + for (uint8_t i = 0; i < frames; ++i) { + ok = radio_send_frame(buf, len) && ok; + if ((uint8_t)(i + 1u) < frames) { + delay(gap_ms); } } return ok; @@ -139,11 +108,9 @@ bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames) void radio_sleep(void) { if (radio_ok) { - ELECHOUSE_cc1101.goSleep(); // SIDLE + SPWD (sen po zboczu CS) + ELECHOUSE_cc1101.goSleep(); + radio_ok = false; } - /* Zwolnij peryferium SPI i ustaw linie w stanach bezpiecznych: - * CS=1 (utrzymuje CC1101 w sleep), SCK/MOSI=0, GDO0 wejscie z podciaganiem - * w dol (CC1101 w sleep trzystanuje wyjscia). */ SPI.end(); pinMode(PIN_CC1101_CS, OUTPUT); digitalWrite(PIN_CC1101_CS, HIGH); diff --git a/src/radio.h b/src/radio.h index df7abe9..8a6a540 100644 --- a/src/radio.h +++ b/src/radio.h @@ -1,34 +1,22 @@ -/* - * radio.h - sterowanie CC1101 (nadawanie ramek TPMS, tryb uśpienia) - */ #ifndef TPMS_RADIO_H #define TPMS_RADIO_H -#include #include -#include "config.h" +#include +#include "settings.h" #ifdef __cplusplus extern "C" { #endif -/* Inicjalizacja SPI + konfiguracja CC1101. Zwraca false przy braku modulu. */ -bool radio_init(void); - -/* Wyslij jeden bufor nadawczy (TPMS_TX_BYTES) - blokujace do zakonczenia - * transmisji na eterze (dokladnie len*8 chipow, ~29 ms). Zwraca false - * przy niedopelnieniu FIFO / niezakonczonej transmisji. */ +bool radio_init(const settings_t *cfg); bool radio_send_frame(const uint8_t *buf, uint8_t len); - -/* Burst: n ramek tego samego bufora z odstepem TX_FRAME_GAP_MS. - * Zwraca false, jesli ktorykolwiek z ramek sie nie udal. */ -bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames); - -/* CC1101 do trybu SLEEP (<1 uA) + przygotowanie linii pod gpio_hold. */ +bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames, + uint16_t gap_ms); void radio_sleep(void); #ifdef __cplusplus } #endif -#endif /* TPMS_RADIO_H */ +#endif diff --git a/src/settings_store.cpp b/src/settings_store.cpp new file mode 100644 index 0000000..ef2cc5a --- /dev/null +++ b/src/settings_store.cpp @@ -0,0 +1,73 @@ +#include +#include +#include + +#include "settings_store.h" + +static Preferences preferences; +static settings_load_result_t last_load = SETTINGS_LOAD_EMPTY; +static bool store_available = false; +settings_t g_settings; + +void settings_store_begin() +{ + settings_defaults(&g_settings); + store_available = preferences.begin("tpms", false); + if (!store_available) { + last_load = SETTINGS_LOAD_IO_ERROR; + return; + } + + settings_blob_t blob; + size_t length = preferences.getBytesLength("config"); + if (length == 0u) { + last_load = SETTINGS_LOAD_EMPTY; + settings_store_save(); + return; + } + if (length != sizeof(blob) + || preferences.getBytes("config", &blob, sizeof(blob)) != sizeof(blob)) { + last_load = SETTINGS_LOAD_BAD_SIZE; + } else { + last_load = settings_decode_blob(&blob, &g_settings); + } + if (last_load != SETTINGS_LOAD_OK) { + settings_defaults(&g_settings); + /* Odzyskiwanie po uszkodzeniu: zapisz spojne domyslne. */ + settings_store_save(); + } +} + +bool settings_store_save() +{ + if (!store_available || !settings_validate(&g_settings)) { + return false; + } + settings_blob_t blob; + settings_make_blob(&g_settings, &blob); + if (preferences.putBytes("config", &blob, sizeof(blob)) != sizeof(blob)) { + return false; + } + settings_blob_t verify; + if (preferences.getBytes("config", &verify, sizeof(verify)) != sizeof(verify) + || memcmp(&blob, &verify, sizeof(blob)) != 0) { + return false; + } + return true; +} + +bool settings_store_factory_reset() +{ + settings_defaults(&g_settings); + return settings_store_save(); +} + +settings_load_result_t settings_store_last_load() +{ + return last_load; +} + +bool settings_store_available() +{ + return store_available; +} diff --git a/src/settings_store.h b/src/settings_store.h new file mode 100644 index 0000000..fe11b6e --- /dev/null +++ b/src/settings_store.h @@ -0,0 +1,14 @@ +#ifndef TPMS_SETTINGS_STORE_H +#define TPMS_SETTINGS_STORE_H + +#include "settings.h" + +extern settings_t g_settings; + +void settings_store_begin(); +bool settings_store_save(); +bool settings_store_factory_reset(); +settings_load_result_t settings_store_last_load(); +bool settings_store_available(); + +#endif -- 2.54.1 From 2919efd70a85c895aaf3b0154f51cabfb2b572a8 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:16:24 +0000 Subject: [PATCH 09/19] Firmware: konfiguracja NVS konsola CC1101 i bezpieczny sen -- 2.54.1 From 78406ecf403b8e54e9f2bfc5ed4dbb064b562d20 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:16:32 +0000 Subject: [PATCH 10/19] Firmware: NVS UART CC1101 MARCSTATE i bezpieczny RTC -- 2.54.1 From 6d2c620f9579d244e4cdaa7662f0ce726e692519 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:16:34 +0000 Subject: [PATCH 11/19] Walidacja RF: przypiete nagrania syntetyka i negatywy --- tools/fetch_references.sh | 27 ++++ tools/gen_cu8.py | 112 ++++++---------- tools/tpms_frame.py | 269 ++++++++++---------------------------- tools/verify_rtl433.py | 100 ++++++++++++++ tools/verify_rtl433.sh | 99 ++------------ 5 files changed, 249 insertions(+), 358 deletions(-) create mode 100644 tools/fetch_references.sh create mode 100644 tools/verify_rtl433.py diff --git a/tools/fetch_references.sh b/tools/fetch_references.sh new file mode 100644 index 0000000..780ed50 --- /dev/null +++ b/tools/fetch_references.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash +# Pobiera i buduje dokladnie przypiete, niezalezne referencje RF. +set -euo pipefail +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +DEPS="${DEPS_DIR:-$ROOT/.cache}" +RTL_COMMIT=406f9a33550a2b6b3d0d8a8a486417ce5b3f13ab +TESTS_COMMIT=1aa8c29d6b9383739d1aeed495dbc5069b704392 +mkdir -p "$DEPS" + +if [ ! -d "$DEPS/rtl_433/.git" ]; then + git clone --filter=blob:none https://github.com/merbanan/rtl_433.git "$DEPS/rtl_433" +fi +git -C "$DEPS/rtl_433" checkout --detach "$RTL_COMMIT" +if [ ! -x "$DEPS/rtl_433/build/src/rtl_433" ]; then + cmake -S "$DEPS/rtl_433" -B "$DEPS/rtl_433/build" -DCMAKE_BUILD_TYPE=Release + cmake --build "$DEPS/rtl_433/build" -j2 +fi + +if [ ! -d "$DEPS/rtl_433_tests/.git" ]; then + git clone --filter=blob:none --sparse https://github.com/merbanan/rtl_433_tests.git "$DEPS/rtl_433_tests" + git -C "$DEPS/rtl_433_tests" sparse-checkout set tests/Schrader_EG53MA4_TPMS +fi +git -C "$DEPS/rtl_433_tests" checkout --detach "$TESTS_COMMIT" + +printf 'RTL433=%s\nREFERENCE_DIR=%s\n' \ + "$DEPS/rtl_433/build/src/rtl_433" \ + "$DEPS/rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01" diff --git a/tools/gen_cu8.py b/tools/gen_cu8.py index dcded7f..ce5e892 100755 --- a/tools/gen_cu8.py +++ b/tools/gen_cu8.py @@ -1,25 +1,5 @@ #!/usr/bin/env python3 -"""Synthesise a .cu8 IQ capture of the TPMS simulator's RF output. - -The generated file is what an RTL-SDR would record while the ESP32+CC1101 -simulator is transmitting. Feed it to rtl_433 to verify the frame format -without any hardware: - - python3 tools/gen_cu8.py --id 2FC871 --pressure 260 --temp 23 -o /tmp/sim.cu8 - rtl_433 -r /tmp/sim.cu8 - - expected: - model : Schrader-EG53MA4 id : 2FC871 pressure_kPa: 260.0 temperature_F: 73 - -Modulations: - ook ASK/OOK, Manchester data (default; matches the rtl_433 reference - capture and the built-in Schrader-EG53MA4 decoder) - fsk 2-FSK, +/-47.6 kHz deviation, same data (verify with - rtl_433 -X 'n=schrader,m=FSK_MC_ZEROBIT,s=120,l=120,r=300') - -DISCLAIMER: diagnostic/test tool only, generates artificial pressure data. -""" - +"""Synteza CU8 OOK/Manchester dla niezaleznego testu rtl_433 (bez RF).""" import argparse import math import os @@ -27,73 +7,65 @@ import random import sys sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) -from tpms_frame import build_row, build_tx_bits, CHIP_US # noqa: E402 +from tpms_frame import build_row, build_tx_bits, CHIP_US SAMPLE_RATE = 250000 -def synth(bits: str, mode: str, deviation_hz: float, amp: float, noise: float, - rng: random.Random): - """Yield (i, q) int8 pairs for one chip string.""" - sps = SAMPLE_RATE * CHIP_US / 1e6 # samples per chip (~30) - total = int(round(len(bits) * sps)) +def synth(bits: str, amp: float, noise: float, rng: random.Random): + samples_per_chip = SAMPLE_RATE * CHIP_US / 1e6 phase = 0.0 - for n in range(total): - k = int(n / sps) % len(bits) - bit = bits[k] - if mode == "fsk": - freq = deviation_hz if bit == "1" else -deviation_hz - phase += 2 * math.pi * freq / SAMPLE_RATE - a = amp - else: - a = amp if bit == "1" else 0.0 - i = a * math.cos(phase) + rng.gauss(0, noise) - q = a * math.sin(phase) + rng.gauss(0, noise) - yield i, q + for n in range(int(round(len(bits) * samples_per_chip))): + chip = bits[int(n / samples_per_chip) % len(bits)] + amplitude = amp if chip == "1" else 0.0 + phase += 0.1 # dowolna nośna w pasmie IQ; demodulator uzywa amplitudy + yield (amplitude * math.cos(phase) + rng.gauss(0, noise), + amplitude * math.sin(phase) + rng.gauss(0, noise)) def write_cu8(path, samples): - with open(path, "wb") as f: + with open(path, "wb") as output: for i, q in samples: - f.write(bytes((max(0, min(255, int(round(i + 127.5)))), - max(0, min(255, int(round(q + 127.5))))))) + output.write(bytes((max(0, min(255, int(round(i + 127.5)))), + max(0, min(255, int(round(q + 127.5))))))) def main() -> int: - p = argparse.ArgumentParser(description=__doc__.splitlines()[0]) - p.add_argument("--id", default="2FC871") - p.add_argument("--pressure", type=float, default=260.0) - p.add_argument("--temp", type=float, default=23.0) - p.add_argument("--flags", default="4C900070") - p.add_argument("--mode", choices=("ook", "fsk"), default="ook") - p.add_argument("--deviation", type=float, default=47.6, help="FSK deviation kHz") - p.add_argument("--frames", type=int, default=3) - p.add_argument("--gap-ms", type=float, default=50.0, help="gap between burst frames") - p.add_argument("--amp", type=float, default=60.0) - p.add_argument("--noise", type=float, default=2.0) - p.add_argument("-o", "--out", default="/tmp/opencode/tpms_ref/sim.cu8") - args = p.parse_args() + parser = argparse.ArgumentParser() + parser.add_argument("--id", default="2FC871") + parser.add_argument("--pressure", type=float, default=260.0) + parser.add_argument("--temp", type=float, default=23.0) + parser.add_argument("--flags", default="4C900070") + parser.add_argument("--frames", type=int, default=3) + parser.add_argument("--gap-ms", type=float, default=50.0) + parser.add_argument("--amp", type=float, default=60.0) + parser.add_argument("--noise", type=float, default=2.0) + parser.add_argument("--corrupt", choices=("checksum", "manchester", "truncate")) + parser.add_argument("-o", "--out", required=True) + args = parser.parse_args() + if not 1 <= args.frames <= 32 or not 20 <= args.gap_ms <= 500: + parser.error("frames=1..32, gap-ms=20..500") row = build_row(int(args.id, 16), args.pressure, args.temp, int(args.flags, 16)) + if args.corrupt == "checksum": + row = row[:-1] + ("0" if row[-1] == "1" else "1") bits = build_tx_bits(row) - print(f"frame: {len(bits)} chips, tx bytes:" - f" {' '.join(f'{int(bits[i:i+8],2):02X}' for i in range(0, len(bits), 8))}") - - out_dir = os.path.dirname(os.path.abspath(args.out)) - if out_dir: - os.makedirs(out_dir, exist_ok=True) + if args.corrupt == "manchester": + bits = bits[:20] + "00" + bits[22:] + if args.corrupt == "truncate": + bits = bits[:-24] + os.makedirs(os.path.dirname(os.path.abspath(args.out)), exist_ok=True) rng = random.Random(1) - gap_sps = int(SAMPLE_RATE * args.gap_ms / 1000) - out = [] - for f in range(args.frames): - out.extend(synth(bits, args.mode, args.deviation * 1000, args.amp, - args.noise, rng)) - out.extend((0.0, 0.0) for _ in range(gap_sps)) - write_cu8(args.out, out) - print(f"wrote {args.out} ({len(out) / SAMPLE_RATE:.3f} s, {args.frames} frames)") + gap = [(0.0, 0.0)] * int(SAMPLE_RATE * args.gap_ms / 1000) + output = [] + for _ in range(args.frames): + output.extend(synth(bits, args.amp, args.noise, rng)) + output.extend(gap) + write_cu8(args.out, output) + print(f"{args.out}: {len(output) / SAMPLE_RATE:.3f} s, {args.frames} ramek") return 0 if __name__ == "__main__": - sys.exit(main()) + raise SystemExit(main()) diff --git a/tools/tpms_frame.py b/tools/tpms_frame.py index c141223..55e35f1 100755 --- a/tools/tpms_frame.py +++ b/tools/tpms_frame.py @@ -1,241 +1,114 @@ #!/usr/bin/env python3 -"""Reference frame builder for the Schrader EG53MA4 TPMS simulator. +"""Niezalezny model ramki EG53MA4 i testy pomocnicze (OOK/Manchester). -This tool mirrors bit-for-bit what the ESP32 firmware (src/tpms_frame.c) -puts on air, and contains a copy of rtl_433's OOK_MC_ZEROBIT slicer -(pulse_slicer_manchester_zerobit() from src/pulse_slicer.c) so the frame -can be self-checked without any radio hardware. - -Protocol reference: rtl_433 src/devices/schraeder.c (schrader_EG53MA4), -"Schrader TPMS EG53MA4, Saab, Opel, Vauxhall, Chevrolet", and the reference -capture rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01/gfile001.cu8. - -On-air frame (G.E.T. Manchester, chip = one half bit-cell): - - lead chip '1' + 119 two-chip cells + zero padding to a byte boundary - - cell "01" -> data bit 0, cell "10" -> data bit 1 (G.E.T. MC, no inversion) - -The rtl_433 MC_ZEROBIT slicer synthesises the very first bit of the decoded -row (a hardcoded 0), so the transmitter sends the row *without* its first bit. -Decoded row (120 bits) = 40 bit sync (zeros) + 80 bit payload: - - SSSS SSSS SSSS SSSS SSSS SSSS SSSS SSSS | FFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFF - IIII IIII IIII IIII IIII IIII | PPPP PPPP | TTTT TTTT | CCCC CCCC - -- S: sync (40 bits, not checked by the decoder, kept as in real captures) -- F: flags (32 bit) - status / battery nibble, unanalysed upstream -- I: sensor id (24 bit) -- P: pressure, 25 mbar per bit (kPa = byte * 2.5) -- T: temperature, degrees Fahrenheit -- C: checksum = sum(bytes[0..8]) & 0xff - -DISCLAIMER: this is a diagnostic/test tool. It generates *artificial* tyre -pressure data and is no replacement for real TPMS sensors. +Referencje: rtl_433 commit 406f9a33550a2b6b3d0d8a8a486417ce5b3f13ab, +rtl_433_tests commit 1aa8c29d6b9383739d1aeed495dbc5069b704392. +Narzedzie generuje sztuczne dane wylacznie do diagnostyki. """ - import argparse import math -import sys -# --- protocol constants (keep in sync with src/config.h / src/tpms_frame.c) --- -CHIP_US = 120.0 # one Manchester half bit-cell, 8.333 kBaud chip rate -FRAME_BITS = 120 # decoded row length expected by schrader_EG53MA4 +CHIP_US = 120.0 +FRAME_BITS = 120 SYNC_BITS = 40 -TX_BYTES = 30 # 240 chips = 1 lead + 238 data + 1 pad -DEFAULT_FLAGS = 0x4C900070 # captured from real EG53MA4 sensors +TX_BYTES = 30 +DEFAULT_FLAGS = 0x4C900070 + + +def valid_id(sensor_id: int) -> bool: + return 0 < sensor_id < 0xFFFFFF def cell(bit: int) -> str: - """G.E.T. Manchester cell for one data bit.""" return "01" if bit == 0 else "10" def build_row(sensor_id: int, pressure_kpa: float, temp_c: float, - flags: int = DEFAULT_FLAGS, low_batt: bool = False, - flags_lowbat_mask: int = 0x00000008) -> str: - """Return the 120 decoded row bits as a string of '0'/'1'. - - Uses the same half-up integer rounding as src/tpms_frame.cpp. - """ + flags: int = DEFAULT_FLAGS) -> str: + if not valid_id(sensor_id): + raise ValueError("ID musi byc w zakresie 000001..FFFFFE") + if not 0 <= flags <= 0xFFFFFFFF: + raise ValueError("flags musza miec 32 bity") kpa10 = int(math.floor(pressure_kpa * 10.0 + 0.5)) - press_byte = min(max((kpa10 + 12) // 25, 0), 255) # 2.5 kPa per bit + if not 0 <= kpa10 <= 6375: + raise ValueError("cisnienie musi byc w zakresie 0..637.5 kPa") + press_byte = (kpa10 + 12) // 25 tc = int(math.floor(temp_c + 0.5)) - num = 9 * tc + 160 # temp_F = (9C+160)/5 + if not -40 <= tc <= 85: + raise ValueError("temperatura musi byc w zakresie -40..85 C") + num = 9 * tc + 160 temp_f = (num + 2) // 5 if num >= 0 else -((-num + 2) // 5) - temp_f = min(max(temp_f, 0), 255) - if low_batt: - flags |= flags_lowbat_mask - payload = [ - (flags >> 24) & 0xFF, - (flags >> 16) & 0xFF, - (flags >> 8) & 0xFF, - flags & 0xFF, - (sensor_id >> 16) & 0xFF, - (sensor_id >> 8) & 0xFF, - sensor_id & 0xFF, - press_byte, - temp_f, - ] - payload.append(sum(payload) & 0xFF) - row = "0" * SYNC_BITS - for b in payload: - row += f"{b:08b}" - assert len(row) == FRAME_BITS - return row + payload = [flags >> 24, (flags >> 16) & 255, (flags >> 8) & 255, + flags & 255, sensor_id >> 16, (sensor_id >> 8) & 255, + sensor_id & 255, press_byte, temp_f] + payload.append(sum(payload) & 255) + return "0" * SYNC_BITS + "".join(f"{byte:08b}" for byte in payload) def build_tx_bits(row: str) -> str: - """Return the chip bit string actually shifted into the CC1101 FIFO. - - 240 chips: 1 lead chip + 119 two-chip cells + 1 pad chip = 30 bytes. - """ - assert len(row) == FRAME_BITS - bits = "1" # lead chip (carrier on) - for b in row[1:]: # row[0] is synthesised by the receiver - bits += cell(int(b)) - while len(bits) % 8: # pad with 'off' chips (silence for OOK) - bits += "0" - return bits + if len(row) != FRAME_BITS: + raise ValueError("ramka musi miec 120 bitow") + bits = "1" + "".join(cell(int(bit)) for bit in row[1:]) + return bits.ljust(TX_BYTES * 8, "0") def tx_bytes(bits: str) -> bytes: - assert len(bits) % 8 == 0 + if len(bits) != TX_BYTES * 8: + raise ValueError("bufor nadawczy musi miec 30 bajtow") return bytes(int(bits[i:i + 8], 2) for i in range(0, len(bits), 8)) -# --------------------------------------------------------------------------- -# Reference slicer: verbatim model of rtl_433 pulse_slicer_manchester_zerobit() -# (src/pulse_slicer.c), used for self-testing the encoder. -# --------------------------------------------------------------------------- -def mc_zerobit_slicer(chips, short_us=123.0, chip_us=CHIP_US, reset_us=300.0): - runs = [] # (level, length_us) - cur, cnt = chips[0], 1 - for c in chips[1:]: - if c == cur: - cnt += 1 - else: - runs.append((cur, cnt * chip_us)) - cur, cnt = c, 1 - runs.append((cur, cnt * chip_us)) - - pairs = [] # (pulse_us, gap_us) - i = 0 - while i < len(runs): - lvl, ln = runs[i] - if lvl: - gap = runs[i + 1][1] if i + 1 < len(runs) and not runs[i + 1][0] else 0.0 - pairs.append((ln, gap)) - i += 2 - else: - pairs.append((0.0, ln)) - i += 1 - - row = ["0"] # hardcoded leading zero bit - t = 0.0 - for n, (pulse, gap) in enumerate(pairs): - last = n == len(pairs) - 1 - if pulse + t > short_us * 1.5: - row.append("1") - t = 0.0 - else: - t += pulse - if last: - break - if gap > reset_us: - break # end of message - if gap + t > short_us * 1.5: - row.append("0") - t = 0.0 - else: - t += gap - return "".join(row) - - def decode_row(row: str): if len(row) != FRAME_BITS: return None - by = [int(row[SYNC_BITS + 8 * k:SYNC_BITS + 8 * (k + 1)], 2) for k in range(10)] - return { - "flags": by[0] << 24 | by[1] << 16 | by[2] << 8 | by[3], - "id": by[4] << 16 | by[5] << 8 | by[6], - "pressure_kPa": by[7] * 2.5, - "temperature_F": by[8], - "checksum_ok": (sum(by[:9]) & 0xFF) == by[9], - "bytes": by, - } + data = [int(row[SYNC_BITS + 8 * i:SYNC_BITS + 8 * (i + 1)], 2) + for i in range(10)] + return {"flags": int.from_bytes(bytes(data[:4]), "big"), + "id": int.from_bytes(bytes(data[4:7]), "big"), + "pressure_kPa": data[7] * 2.5, "temperature_F": data[8], + "checksum_ok": sum(data[:9]) & 255 == data[9], "bytes": data} def self_test() -> int: - """Cross-check against the rtl_433 reference capture (gfile001.cu8).""" - fails = 0 - ref = build_row(0x2FC871, 0.0, (90 - 32) * 5 / 9, flags=0x4C900070) - # the capture carries temperature as the raw byte 90 (0x5A) = 90 F - ref_row = ("0" * 40 - + "01001100100100000000000001110000001011111100100001110001000000000101101000001110") - if ref_row[40:] != ref[40:]: - print("FAIL: reference capture row mismatch") - print(" want:", ref_row) - print(" got :", ref) - fails += 1 - - # random round trip: encode -> slicer -> data must survive intact + expected = [0x4C, 0x90, 0, 0x70, 0x2F, 0xC8, 0x71, 0, 0x5A, 0x0E] + row = build_row(0x2FC871, 0, 32) + got = decode_row(row)["bytes"] + if got != expected: + print(f"FAIL: nagranie gfile001: {got} != {expected}") + return 1 import random - random.seed(42) + rng = random.Random(42) for _ in range(500): - sid = random.randrange(0, 0x1000000) - kpa = round(random.uniform(0, 637.5), 1) - tc = random.uniform(-40, 85) - row = build_row(sid, kpa, tc) - bits = build_tx_bits(row) - chips = [int(b) for b in bits] - out = mc_zerobit_slicer(chips) - if len(out) != FRAME_BITS or out[SYNC_BITS:] != row[SYNC_BITS:]: - print("FAIL: round trip", hex(sid), kpa, tc) - print(" row:", row) - print(" out:", out) - fails += 1 - break - d = decode_row(out) - if not d["checksum_ok"] or d["id"] != sid: - print("FAIL: decode", hex(sid), d) - fails += 1 - break - print("self-test:", "OK" if fails == 0 else "FAILED") - return 1 if fails else 0 + sensor_id = rng.randrange(1, 0xFFFFFF) + pressure = round(rng.uniform(0, 637.5), 1) + temp = rng.randrange(-40, 86) + decoded = decode_row(build_row(sensor_id, pressure, temp)) + if not decoded["checksum_ok"] or decoded["id"] != sensor_id: + print("FAIL: round trip") + return 1 + print("self-test: OK (nagranie + 500 ramek)") + return 0 def main() -> int: - p = argparse.ArgumentParser(description=__doc__.splitlines()[0]) - p.add_argument("--id", default="2FC871", help="sensor id (hex, 24 bit)") - p.add_argument("--pressure", type=float, default=260.0, help="kPa") - p.add_argument("--temp", type=float, default=23.0, help="deg C") - p.add_argument("--flags", default="4C900070", help="flags word (hex)") - p.add_argument("--low-batt", action="store_true") - p.add_argument("--self-test", action="store_true") - args = p.parse_args() - + parser = argparse.ArgumentParser() + parser.add_argument("--id", default="2FC871") + parser.add_argument("--pressure", type=float, default=260.0) + parser.add_argument("--temp", type=float, default=23.0) + parser.add_argument("--flags", default="4C900070") + parser.add_argument("--self-test", action="store_true") + args = parser.parse_args() if args.self_test: return self_test() - - sid = int(args.id, 16) - flags = int(args.flags, 16) - row = build_row(sid, args.pressure, args.temp, flags, args.low_batt) - bits = build_tx_bits(row) - raw = tx_bytes(bits) - d = decode_row(row) - - print(f"row (120 bit): {row}") - print(f"chips({len(bits):3d} bit): {bits}") - print(f"tx bytes ({len(raw)}): {' '.join(f'{b:02X}' for b in raw)}") - print(f"payload : {' '.join(f'{b:02X}' for b in d['bytes'])}") - print(f"checksum: {'OK' if d['checksum_ok'] else 'BAD'}") - print(f"id={d['id']:06X} pressure={d['pressure_kPa']:.1f} kPa " - f"temperature={d['temperature_F']} F ({args.temp:.0f} C) flags={d['flags']:08X}") - out = mc_zerobit_slicer([int(b) for b in bits]) - print(f"slicer check: {'OK' if out[SYNC_BITS:] == row[SYNC_BITS:] and len(out) == FRAME_BITS else 'FAILED'}") + row = build_row(int(args.id, 16), args.pressure, args.temp, int(args.flags, 16)) + raw = tx_bytes(build_tx_bits(row)) + decoded = decode_row(row) + print(f"row: {row}\ntx: {raw.hex()}") + print("payload: " + " ".join(f"{byte:02X}" for byte in decoded["bytes"])) + print(f"id={decoded['id']:06X} pressure={decoded['pressure_kPa']:.1f} kPa " + f"temp={decoded['temperature_F']} F flags={decoded['flags']:08X}") return 0 if __name__ == "__main__": - sys.exit(main()) + raise SystemExit(main()) diff --git a/tools/verify_rtl433.py b/tools/verify_rtl433.py new file mode 100644 index 0000000..d53e3b6 --- /dev/null +++ b/tools/verify_rtl433.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python3 +"""Walidacja prawdziwych i syntetycznych CU8 przez przypiety rtl_433.""" +import argparse +import json +import pathlib +import subprocess +import sys +import tempfile + +EXPECTED = { + "gfile001.cu8": ("2FC871", 90.0), + "gfile002.cu8": ("2EAAF9", 90.0), + "gfile003.cu8": ("3495AC", 90.0), + "gfile004.cu8": ("2FC780", 91.0), +} + + +def decode(rtl433: str, capture: pathlib.Path): + result = subprocess.run([rtl433, "-q", "-F", "json", "-r", str(capture)], + text=True, capture_output=True, check=False) + records = [] + for line in result.stdout.splitlines(): + try: + record = json.loads(line) + except json.JSONDecodeError: + continue + if record.get("model") == "Schrader-EG53MA4": + records.append(record) + return result.returncode, records, result.stdout + result.stderr + + +def require(condition, message, failures): + if not condition: + failures.append(message) + return condition + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--rtl433", required=True) + parser.add_argument("--reference-dir", required=True, type=pathlib.Path) + args = parser.parse_args() + root = pathlib.Path(__file__).resolve().parent.parent + failures = [] + print("rtl_433 commit: 406f9a33550a2b6b3d0d8a8a486417ce5b3f13ab") + print("rtl_433_tests commit: 1aa8c29d6b9383739d1aeed495dbc5069b704392") + + for filename, (sensor_id, temp_f) in EXPECTED.items(): + capture = args.reference_dir / filename + if not require(capture.is_file(), f"brak {capture}", failures): + continue + status, records, raw = decode(args.rtl433, capture) + valid = status == 0 and len(records) == 16 and all( + record.get("id") == sensor_id and record.get("flags") == "4c900070" + and record.get("pressure_kPa") == 0.0 + and record.get("temperature_F") == temp_f + and record.get("mic") == "CHECKSUM" for record in records) + require(valid, f"{filename}: niezgodne rekordy\n{raw}", failures) + print(f"{'OK' if valid else 'FAIL'} referencja {filename}: " + f"{len(records)}/16, id={sensor_id}, flags=4c900070") + + synthetic = [("2FC871", 260, 23, 73.0), ("3495AC", 220, -5, 23.0), + ("ABCDEE", 262.5, 24, 75.0)] + with tempfile.TemporaryDirectory(prefix="tpms-rtl433-") as temp: + for index, (sensor_id, pressure, temp_c, temp_f) in enumerate(synthetic): + capture = pathlib.Path(temp) / f"valid{index}.cu8" + subprocess.run([sys.executable, str(root / "tools/gen_cu8.py"), + "--id", sensor_id, "--pressure", str(pressure), + "--temp", str(temp_c), "-o", str(capture)], + check=True, capture_output=True) + status, records, raw = decode(args.rtl433, capture) + valid = status == 0 and len(records) >= 1 and all( + record.get("id") == sensor_id + and record.get("pressure_kPa") == pressure + and record.get("temperature_F") == temp_f + and record.get("flags") == "4c900070" + and record.get("mic") == "CHECKSUM" for record in records) + require(valid, f"syntetyczna {sensor_id}: {raw}", failures) + print(f"{'OK' if valid else 'FAIL'} syntetyczna id={sensor_id}: " + f"{len(records)} dekodowan, {pressure:.1f} kPa, {temp_f:.1f} F") + + for corruption in ("checksum", "manchester", "truncate"): + capture = pathlib.Path(temp) / f"bad-{corruption}.cu8" + subprocess.run([sys.executable, str(root / "tools/gen_cu8.py"), + "--corrupt", corruption, "-o", str(capture)], + check=True, capture_output=True) + status, records, raw = decode(args.rtl433, capture) + valid = status == 0 and not records + require(valid, f"negatywny {corruption}: blednie zdekodowano\n{raw}", failures) + print(f"{'OK' if valid else 'FAIL'} negatywny {corruption}: " + f"{len(records)} dekodowan (oczekiwano 0)") + + print(f"WYNIK: {'PASS' if not failures else 'FAIL'}; bledow={len(failures)}") + for failure in failures: + print(" - " + failure) + return 1 if failures else 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/verify_rtl433.sh b/tools/verify_rtl433.sh index d428dcc..5ce7c65 100755 --- a/tools/verify_rtl433.sh +++ b/tools/verify_rtl433.sh @@ -1,91 +1,10 @@ #!/usr/bin/env bash -# verify_rtl433.sh - automatyczna weryfikacja ramek symulatora TPMS -# Schrader EG53MA4 za pomoca prawdziwego dekodera rtl_433 (bez sprzetu RF). -# -# Wymaga: python3, rtl_433 (binarka w PATH albo w zmiennej RTL433) -# -# Uzycie: -# RTL433=/sciezka/do/rtl_433 ./tools/verify_rtl433.sh -# -# Skrypt: -# 1) generuje syntezyczne nagrania IQ (.cu8) takie, jakie odbierze RTL-SDR -# podczas nadawania symulatora, -# 2) dekoduje je rtl_433 i porownuje wynik z zadanymi wartosciami: -# - OOK: wbudowany dekoder Schrader-EG53MA4 (model/id/pressure/temp) -# - FSK: dekoder flex, porownanie calego bitstreamu z ramka wzorcowa -# -# Uwaga: nazwy plikow nie moga zawierac tokenow "ook"/"fsk"/"am"/"fm" - -# parser formatow rtl_433 traktuje je jako opis formatu pliku. -set -u - -RTL433="${RTL433:-rtl_433}" -DIR="$(cd "$(dirname "$0")/.." && pwd)" -TMP="${TMPDIR:-/tmp}/tpms_verify_$$" -mkdir -p "$TMP" - -if ! command -v "$RTL433" >/dev/null 2>&1; then - echo "BLAD: nie znaleziono rtl_433 (ustaw zmienna RTL433=...)"; exit 1 -fi - -fail=0 - -check_ook() { # $1=plik $2=id $3=kPa $4=temp_F - local file="$1" id="$2" kpa="$3" tf="$4" - local out - out="$("$RTL433" -r "$file" 2>/dev/null)" - if echo "$out" | grep -qi "Schrader-EG53MA4" \ - && echo "$out" | grep -q "ID : $id" \ - && echo "$out" | grep -q "Pressure : $kpa kPa" \ - && echo "$out" | grep -q "Temperature: $tf"; then - echo "OK $(basename "$file") id=$id $kpa kPa $tf F" - else - echo "FAIL $(basename "$file") (oczekiwano id=$id $kpa kPa $tf F)" - echo "$out" | sed 's/^/ /' - fail=1 - fi -} - -check_fsk() { # $1=plik $2=id $3=kPa $4=temp_C - local file="$1" id="$2" kpa="$3" tc="$4" - local out codes want - out="$("$RTL433" -r "$file" \ - -X 'n=schrader,m=FSK_MC_ZEROBIT,s=120,l=120,r=300' 2>/dev/null)" - codes="$(echo "$out" | grep -o 'codes : {120}[0-9a-f]*' | head -1 | sed 's/.*{120}//')" - want="0000000000$(python3 "$DIR/tools/tpms_frame.py" --id "$id" \ - --pressure "$kpa" --temp "$tc" | grep payload | sed 's/.*payload : //' \ - | tr 'A-Z' 'a-z' | tr -d ' ')" - if [ -n "$codes" ] && [ "$codes" = "$want" ]; then - echo "OK $(basename "$file") (FSK) bitstream zgodny: $codes" - else - echo "FAIL $(basename "$file") (FSK)" - echo " otrzymano: ${codes:-}" - echo " oczekiwano: $want" - fail=1 - fi -} - -echo "== OOK (domyslna modulacja, wbudowany dekoder Schrader-EG53MA4) ==" -python3 "$DIR/tools/gen_cu8.py" --id 2FC871 --pressure 260 --temp 23 \ - -o "$TMP/c1.cu8" >/dev/null -check_ook "$TMP/c1.cu8" 2FC871 260.0 73.0 - -python3 "$DIR/tools/gen_cu8.py" --id 3495AC --pressure 220 --temp -5 \ - -o "$TMP/c2.cu8" >/dev/null -check_ook "$TMP/c2.cu8" 3495AC 220.0 23.0 - -python3 "$DIR/tools/gen_cu8.py" --id ABCDEE --pressure 262.5 --temp 24 \ - -o "$TMP/c3.cu8" >/dev/null -check_ook "$TMP/c3.cu8" ABCDEE 262.5 75.0 - -echo "== FSK (wariant konfigurowalny, dekoder flex) ==" -python3 "$DIR/tools/gen_cu8.py" --id 2FC871 --pressure 260 --temp 23 \ - --mode fsk -o "$TMP/c4.cu8" >/dev/null -check_fsk "$TMP/c4.cu8" 2FC871 260 23 - -rm -rf "$TMP" -if [ "$fail" -eq 0 ]; then - echo "WSZYSTKO OK - ramki dekoduja sie poprawnie przez rtl_433" -else - echo "WERYFIKACJA NIEUDANA" -fi -exit "$fail" +# Zwraca niezerowy kod przy bledzie i zapisuje czytelny raport. +set -euo pipefail +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +RTL433="${RTL433:-$ROOT/.cache/rtl_433/build/src/rtl_433}" +REFERENCE_DIR="${REFERENCE_DIR:-$ROOT/.cache/rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01}" +REPORT_DIR="${REPORT_DIR:-$ROOT/artifacts/validation}" +mkdir -p "$REPORT_DIR" +python3 "$ROOT/tools/verify_rtl433.py" --rtl433 "$RTL433" \ + --reference-dir "$REFERENCE_DIR" | tee "$REPORT_DIR/rtl433-report.txt" -- 2.54.1 From 72af53003e2deab62e6001234c4183506e046b49 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:16:43 +0000 Subject: [PATCH 12/19] Walidacja RF: przypiete rtl_433 cztery nagrania i negatywy -- 2.54.1 From af5324cd4a96ceb24bf8542264f26f5ba7b05001 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:16:44 +0000 Subject: [PATCH 13/19] Walidacja RF: 4 nagrania 3 syntetyczne i negatywy -- 2.54.1 From d3a061262b3624d65969c59f4c030d7d177c0623 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:16:57 +0000 Subject: [PATCH 14/19] Automatyzacja: check_all Docker CI i reprodukowalne artefakty --- .gitea/workflows/check.yml | 25 ++++++++++++++++++++++++ .gitignore | 4 ++++ Dockerfile | 11 +++++++++++ tools/check_all | 40 ++++++++++++++++++++++++++++++++++++++ tools/flash_release.sh | 9 +++++++++ tools/package_release.sh | 37 +++++++++++++++++++++++++++++++++++ tools/requirements.txt | 22 +++++++++++++++++++++ 7 files changed, 148 insertions(+) create mode 100644 .gitea/workflows/check.yml create mode 100644 Dockerfile create mode 100644 tools/check_all create mode 100644 tools/flash_release.sh create mode 100644 tools/package_release.sh create mode 100644 tools/requirements.txt diff --git a/.gitea/workflows/check.yml b/.gitea/workflows/check.yml new file mode 100644 index 0000000..a75c538 --- /dev/null +++ b/.gitea/workflows/check.yml @@ -0,0 +1,25 @@ +name: check +on: + push: + branches: [main, feat/release-v2] + pull_request: + +jobs: + check-without-hardware: + runs-on: docker + container: python:3.12.12-slim-bookworm + steps: + - uses: actions/checkout@v4 + - name: Install build dependencies + run: | + apt-get update + apt-get install -y --no-install-recommends build-essential cmake git libusb-1.0-0-dev pkg-config ca-certificates + - name: Install pinned Python tools + run: pip install --no-cache-dir --disable-pip-version-check -r tools/requirements.txt + - name: All tests without hardware + run: bash ./tools/check_all + - name: Upload validation reports + uses: actions/upload-artifact@v4 + with: + name: validation-reports + path: artifacts/validation/ diff --git a/.gitignore b/.gitignore index 5d17f68..ccc5fda 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,10 @@ .pio/ .vscode/ +.venv/ +.cache/ +artifacts/ *.o *.elf *.bin __pycache__/ +*.pyc diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..67b16e7 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,11 @@ +FROM python:3.12.12-slim-bookworm + +RUN apt-get update && apt-get install -y --no-install-recommends \ + build-essential cmake git libusb-1.0-0-dev pkg-config ca-certificates \ + && rm -rf /var/lib/apt/lists/* +WORKDIR /work +COPY tools/requirements.txt tools/requirements.txt +RUN pip install --no-cache-dir --disable-pip-version-check -r tools/requirements.txt +COPY . . +RUN chmod +x tools/check_all tools/*.sh +CMD ["bash", "./tools/check_all"] diff --git a/tools/check_all b/tools/check_all new file mode 100644 index 0000000..28b5665 --- /dev/null +++ b/tools/check_all @@ -0,0 +1,40 @@ +#!/usr/bin/env bash +# Wszystkie testy mozliwe bez ESP32/CC1101/RTL-SDR/samochodu. +set -euo pipefail +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +cd "$ROOT" +mkdir -p artifacts/validation + +if [ -n "${PIO:-}" ]; then + PIO_BIN="$PIO" +elif [ -x "$ROOT/.venv/bin/pio" ]; then + PIO_BIN="$ROOT/.venv/bin/pio" +elif command -v pio >/dev/null 2>&1; then + PIO_BIN="$(command -v pio)" +else + python3 -m venv "$ROOT/.venv" + "$ROOT/.venv/bin/pip" install --disable-pip-version-check -r tools/requirements.txt + PIO_BIN="$ROOT/.venv/bin/pio" +fi + +run() { + local name="$1" + shift + echo "== $name ==" + "$@" 2>&1 | tee "artifacts/validation/$name.log" +} + +run python-self-test python3 tools/tpms_frame.py --self-test +run native-tests "$PIO_BIN" test -e native +run esp32-build "$PIO_BIN" run -e esp32dev +run cppcheck "$PIO_BIN" check -e native \ + --flags='--enable=warning,performance,portability --inline-suppr' \ + --fail-on-defect=low + +if [ ! -x "${RTL433:-$ROOT/.cache/rtl_433/build/src/rtl_433}" ] \ + || [ ! -f "${REFERENCE_DIR:-$ROOT/.cache/rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01}/gfile001.cu8" ]; then + run fetch-references bash ./tools/fetch_references.sh +fi +run rtl433 bash ./tools/verify_rtl433.sh + +echo "PASS: wszystkie testy bez sprzetu zakonczone sukcesem" diff --git a/tools/flash_release.sh b/tools/flash_release.sh new file mode 100644 index 0000000..7e67f74 --- /dev/null +++ b/tools/flash_release.sh @@ -0,0 +1,9 @@ +#!/usr/bin/env bash +# Wgrywa pelny obraz release; PORT=np. /dev/ttyUSB0. Kasuje flash ESP32. +set -euo pipefail +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +PORT="${PORT:?Ustaw PORT=/dev/ttyUSBX}" +ESPTOOL="${ESPTOOL:-${PLATFORMIO_CORE_DIR:-$HOME/.platformio}/packages/tool-esptool/esptool}" +IMAGE="$ROOT/artifacts/release/firmware-full.bin" +[ -f "$IMAGE" ] || { echo "Brak $IMAGE; uruchom tools/package_release.sh"; exit 1; } +"$ESPTOOL" --chip esp32 --port "$PORT" --baud 460800 write-flash 0x0 "$IMAGE" diff --git a/tools/package_release.sh b/tools/package_release.sh new file mode 100644 index 0000000..46729cb --- /dev/null +++ b/tools/package_release.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +# Buduje obrazy ESP32 i pelny obraz 4 MB oraz manifest SHA-256. +set -euo pipefail +ROOT="$(cd "$(dirname "$0")/.." && pwd)" +cd "$ROOT" +PIO_BIN="${PIO:-$ROOT/.venv/bin/pio}" +if [ ! -x "$PIO_BIN" ]; then PIO_BIN="${PIO:-pio}"; fi +export SOURCE_DATE_EPOCH="${SOURCE_DATE_EPOCH:-1761600000}" +OUT="$ROOT/artifacts/release" +BUILD="$ROOT/.pio/build/esp32dev" +BOOT_APP0="${PLATFORMIO_CORE_DIR:-$HOME/.platformio}/packages/framework-arduinoespressif32/tools/partitions/boot_app0.bin" +ESPTOOL="${ESPTOOL:-${PLATFORMIO_CORE_DIR:-$HOME/.platformio}/packages/tool-esptool/esptool}" + +"$PIO_BIN" run -e esp32dev +mkdir -p "$OUT" +cp "$BUILD/bootloader.bin" "$BUILD/partitions.bin" "$BUILD/firmware.bin" \ + "$BUILD/firmware.elf" "$OUT/" +cp "$BOOT_APP0" "$OUT/boot_app0.bin" +"$ESPTOOL" --chip esp32 merge-bin -o "$OUT/firmware-full.bin" \ + --flash-mode dio --flash-freq 40m --flash-size 4MB \ + 0x1000 "$OUT/bootloader.bin" 0x8000 "$OUT/partitions.bin" \ + 0xe000 "$OUT/boot_app0.bin" 0x10000 "$OUT/firmware.bin" +( + cd "$OUT" + sha256sum bootloader.bin partitions.bin boot_app0.bin firmware.bin \ + firmware-full.bin firmware.elf > SHA256SUMS +) +cat > "$OUT/BUILD-INFO.txt" <<'EOF' +Wersja: 2.0.0-rc.1 (release candidate, bez HIL) +PlatformIO: 6.1.18 +Platforma: espressif32 8.0.0 +CC1101: de6757ef633b3e626dae5c7835cdb66ab53f9a1d +Adresy: 0x1000 bootloader, 0x8000 partitions, 0xe000 boot_app0, 0x10000 firmware +Pelny obraz firmware-full.bin: flash od 0x0. +EOF +cat "$OUT/BUILD-INFO.txt" +cat "$OUT/SHA256SUMS" diff --git a/tools/requirements.txt b/tools/requirements.txt new file mode 100644 index 0000000..d8f80db --- /dev/null +++ b/tools/requirements.txt @@ -0,0 +1,22 @@ +ajsonrpc==1.2.0 +anyio==4.15.1 +bottle==0.13.4 +certifi==2026.10.23 +charset-normalizer==3.5.2 +click==8.1.7 +colorama==0.4.6 +h11==0.16.0 +idna==3.20 +marshmallow==3.26.2 +packaging==26.3 +platformio==6.1.18 +pyelftools==0.33 +pyserial==3.5 +requests==2.34.2 +semantic-version==2.10.0 +starlette==0.46.2 +tabulate==0.10.0 +typing_extensions==4.16.0 +urllib3==2.8.0 +uvicorn==0.34.3 +wsproto==1.3.2 -- 2.54.1 From 17d2cea3ea070893878578d88446b63e24c36153 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:17:08 +0000 Subject: [PATCH 15/19] Automatyzacja: check_all Docker CI i reprodukowalne artefakty -- 2.54.1 From 1fdb0c7cce2a8dd4c8c9c9fd0f2a3f8cb031c46f Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:17:25 +0000 Subject: [PATCH 16/19] Dokumentacja: Quick Start bezpieczenstwo protokol HIL i RC --- CHANGELOG.md | 62 ++++ LICENSE | 338 +++++++++++++++++ README.md | 793 +++++++--------------------------------- RELEASE_NOTES.md | 53 +++ THIRD_PARTY_NOTICES.md | 23 ++ docs/AUDIT.md | 25 ++ docs/HARDWARE.md | 110 ++++++ docs/POWER.md | 56 +++ docs/PROTOCOL.md | 93 +++++ docs/SAFETY.md | 42 +++ docs/SETUP.md | 102 ++++++ docs/TROUBLESHOOTING.md | 37 ++ docs/VALIDATION.md | 125 +++++++ 13 files changed, 1195 insertions(+), 664 deletions(-) create mode 100644 CHANGELOG.md create mode 100644 LICENSE create mode 100644 RELEASE_NOTES.md create mode 100644 THIRD_PARTY_NOTICES.md create mode 100644 docs/AUDIT.md create mode 100644 docs/HARDWARE.md create mode 100644 docs/POWER.md create mode 100644 docs/PROTOCOL.md create mode 100644 docs/SAFETY.md create mode 100644 docs/SETUP.md create mode 100644 docs/TROUBLESHOOTING.md create mode 100644 docs/VALIDATION.md diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..7fec3cc --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,62 @@ +# Changelog + +## 2.0.0-rc.1 — 2026-10-27 + +Release candidate bez testu fizycznego CC1101 i samochodu. + +### Dodane + +- Trwała konfiguracja NVS z wersją, CRC32, walidacją zakresów, unikalnymi ID, + przywracaniem fabrycznym i bezpiecznymi domyślnymi. +- Konsola: Clone IDs, generator nowych ID, ciśnienia/temperatura, interwały, + ograniczone RF, LEARN/SINGLE i diagnostyka bez rekompilacji. +- Przenośna maszyna stanów z fake clock/radio, timeoutami i kolejnością + FL→FR→RR→RL. Testy restartu, ACC, błędów radia i zawinięcia `millis()`. +- Niezależna walidacja czterech nagrań referencyjnych oraz syntetycznych CU8 + przypiętym rtl_433; testy negatywne checksum/Manchester/ucięcie. +- `tools/check_all`, Dockerfile, Gitea Actions, skrypty obrazów i SHA-256. +- Polska dokumentacja użytkownika, sprzętu, zasilania, bezpieczeństwa i HIL. + +### Zmienione + +- Domyślnie 260 kPa i −10 dBm, tylko OOK. Zachowany enkoder 30 B Manchester, + który przechodzi niezależne dekodowanie. +- CC1101 czeka na `MARCSTATE=IDLE`, kontroluje underflow i pozostałe bajty, + zamiast polegać wyłącznie na czasie i `TXBYTES=0`. +- Zwykły RTC nie otwiera okna konsoli; transmisja i powrót do snu ograniczają + szacowany pobór. Okno konsoli pozostaje po interakcji użytkownika. +- Pełny build z `-Wall -Wextra -Werror`; cppcheck bez defektów. + +### Usunięte / naprawione + +- Usunięto zgadywany `TPMS_FLAGS_LOWBAT_MASK` i sprzężenie niskiego zasilania + emulatora z symulowanym sensorem. Zasilanie jest tylko ostrzeżeniem lokalnym. +- Usunięto FSK z głównego flow: brak dowodu dla analizowanego profilu. +- Usunięto `PARKING_SHUTDOWN`; każdy deep sleep ma RTC, więc restart ACC nie + może zostawić urządzenia trwale uśpionego. +- Domyślne, niezwalidowane wejście LF jest wyłączone. Podstawowy LEARN nie + wymaga EL-50448. +- Usunięto rekomendację MCP1703 + TVS 24 V jako ochrony automotive i obietnice + wieloletniej pracy baterii. Zasilanie 12 V ma wymagania projektowe, nie HIL. + +### Iteracje audytu + +1. **Stan początkowy:** 7/7 native i build PASS, ale konfiguracja przez + rekompilację, monolit stanów, lowbat i zasilanie wymagały naprawy. Utworzono + `archive/pre-opencode`. +2. **Model danych:** dodano NVS/CRC/walidację i przenośne tryby. Pierwszy test + wykrył błędne oczekiwania testów dla zaległego tick i natychmiastowego TX; + po korekcji 20/20 native i ESP32 build PASS. +3. **Walidacja RF:** audyt czterech nagrań potwierdził 16 powtórzeń i zmienne + odstępy. Zastąpiono pojedynczy wektor pełnym skryptem; 64/64 referencji, + 3/3 syntetycznych i 3/3 negatywnych PASS. +4. **Energia:** wykryto okno konsoli po każdym RTC; ograniczono je do interakcji. + Pobór nadal wyraźnie oznaczony jako szacowany. +5. **Statycznie:** cppcheck wskazał inicjalizację struktur z float przez memset; + zamieniono na inicjalizację wartości i osiągnięto 0 defektów. + +### Niezweryfikowane fizycznie + +CC1101 na antenie/analizatorze, RTL-SDR z prototypem, pobór, brownout, ACC, +aktualizacja flash, Clone IDs i LEARN z konkretnym Oplem. Brak oznaczenia +„validated”. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..9efa6fb --- /dev/null +++ b/LICENSE @@ -0,0 +1,338 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, see . + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Moe Ghoul, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/README.md b/README.md index 17511cc..4b80050 100644 --- a/README.md +++ b/README.md @@ -1,694 +1,159 @@ -# Symulator 4 czujników TPMS Schrader EG53MA4 (ESP32 + CC1101) +# Symulator TPMS Schrader EG53MA4 — ESP32 + CC1101 -Firmware dla ESP32 DevKit + moduł CC1101 (433 MHz), symulujący **4 czujniki -ciśnienia w oponach** (po jednym na koło) dla **Opla Astry J Sedan 2016** -(rynek EU, TPMS bezpośredni, czujniki typu Schrader / Opel OEM 13348393, -protokół **Schrader EG53MA4**). +**Wersja 2.0.0-rc.1 — release candidate bez walidacji sprzętowej.** -> ## ⚠️ ZASTRZEŻENIE -> Projekt **wyłącznie do celów diagnostycznych i testowych**. -> Symulator dostarcza **sztuczne dane ciśnienia i temperatury** i **nie -> zastępuje prawdziwych czujników TPMS**. TPMS jest elementem bezpieczeństwa -> czynnego pojazdu — **nie używaj tego urządzenia podczas jazdy po drogach -> publicznych**. Nadawanie w paśmie 433 MHz może podlegać lokalnym -> przepisom (np. w Polsce praca krótkiego zasięgu w 433 MHz jest dozwolona -> z ograniczeniami mocy) — sprawdź przepisy obowiązujące w Twoim kraju. +Urządzenie warsztatowe nadaje cztery niezależne identyfikatory TPMS profilem +OOK/Manchester Schrader EG53MA4 na 433,92 MHz. Domyślnie każde koło raportuje +**260 kPa (2,6 bar; bajt protokołu `0x68`)**. Docelowy scenariusz to diagnostyka +Opla Astry J Sedan 1.4 LPG (2016, EU), ale **zgodność trzeba potwierdzić dla +konkretnego auta**: przez VIN/wykaz serwisowy, oznaczenia fabrycznych czujników, +odczyt diagnostyczny albo test odbioru. Numer OE 13506028, numery powiązane ani +ogłoszenie sprzedażowe same w sobie nie potwierdzają profilu radiowego. ---- +> **Nie jest to homologowany czujnik ani zamiennik sprawnego TPMS. Nie używać +> w jeździe drogowej.** Sztuczne ciśnienie może ukryć przebitą lub niedopompowaną +> oponę i opóźnić ostrzeżenie. Przed i po teście sprawdź wszystkie opony +> niezależnym manometrem. Zobacz [SAFETY](docs/SAFETY.md). -## 1. Spis treści +## Co jest gotowe, a czego nie -1. [Spis treści](#1-spis-treści) -2. [Jak to działa](#2-jak-to-działa) -3. [Budowa projektu](#3-budowa-projektu) -4. [Kompilacja](#4-kompilacja) -5. [(a) Okablowanie i lista podzespołów](#5-a-okablowanie) -6. [(b) Konfiguracja ID i ciśnień](#6-b-konfiguracja-id-i-cisnień) -7. [(c) Test nadawania — RTL-SDR + rtl_433](#7-c-test-nadawania--rtl-sdr--rtl_433) -8. [(d) Programowanie czujników w aucie (tryb learn)](#8-d-programowanie-czujników-w-aucie-tryb-learn) -9. [(e) Pomiar poboru prądu](#9-e-pomiar-poboru-prądu) -10. [(f) Weryfikacja, że błąd zniknął](#10-f-weryfikacja-że-błąd-zniknął) -11. [Tryby pracy i sterowanie](#11-tryby-pracy-i-sterowanie) -12. [Konsola szeregowa](#12-konsola-szeregowa) -13. [Budżet prądu](#13-budżet-prądu) -14. [Protokół — szczegóły techniczne](#14-protokół--szczegóły-techniczne) -15. [Rozwiązywanie problemów](#15-rozwiązywanie-problemów) +- Gotowe: build ESP32, testy ramek/NVS/maszyny stanów, syntetyczny CU8 dekodowany + przez niezależny `rtl_433`, trwała konfiguracja z konsoli, Clone IDs i LEARN. +- **Niewykonane:** pomiar rzeczywistego CC1101, RTL-SDR z anteną, test z samochodem, + pomiar prądu i testy automotive. Dlatego wynik jest RC, nie „validated”. +- Jedyny profil podstawowy to **OOK**. Nie przełączaj na FSK „na próbę”. +- ESP32 nie generuje nośnej 433 MHz — wymagany jest osobny CC1101 433 MHz. ---- +## Schemat ideowy -## 2. Jak to działa +```text + USB 5 V (TYLKO prototyp) 3,3 V OOK 433,92 MHz + │ │ │ + [ESP32 DevKit] ── SPI ───────> [CC1101 433 MHz] ── antena ────┘ + │ │ + ├── GPIO26: przycisk └── wspólna GND + └── GPIO27: LED + 330 Ω -Urządzenie zachowuje się jak 4 czujniki TPMS Schrader EG53MA4: - -* co `TX_INTERVAL_S` (domyślnie 30 s) budzi się z **deep sleep**, - konfiguruje CC1101 i wysyła **burst 3 ramek** dla każdego z 4 kół - (tak jak prawdziwy czujnik, który powtarza pakiet 3–6 razy), -* ramka zawiera: `flags` + 24-bit ID czujnika + ciśnienie (2,5 kPa/bit) - + temperaturę (°F) + sumę kontrolną — **zgodnie z dekoderem rtl_433 - `schrader_EG53MA4`**, -* dane kodowane są Manchesterem **G.E.T. MC** (chip 120 µs), - modulacja **ASK/OOK 433.92 MHz** (opcjonalnie **2-FSK, dewiacja 47.6 kHz**), -* między transmisjami ESP32 śpi (budzik RTC + budzenie przyciskiem lub - wejściem LF), CC1101 jest w trybie SLEEP, -* tryb **LEARN** pozwala wprowadzić ID do pamięci auta po kolei - (przód lewy → przód prawy → tył prawy → tył lewy), -* tryb **SINGLE** wymusza nadawanie jednego wskazanego ID. - -Wszystkie dane (ID, ciśnienia, temperatury, interwały) są **sztuczne** -i konfigurowalne w `src/config.h`. - ---- - -## 3. Budowa projektu - -``` -tpms/ -├── platformio.ini # konfiguracja budowania (ESP32 Arduino + testy natywne) -├── src/ -│ ├── config.h # <<< WSZYSTKIE USTAWIENIA (ID, piny, interwały) >>> -│ ├── main.cpp # maszyna stanów: NORMAL / LEARN / SINGLE, deep sleep -│ ├── tpms_frame.h/.cpp # generator ramki + kodowanie Manchester (bez Arduino) -│ ├── radio.h/.cpp # konfiguracja CC1101, nadawanie, tryb SLEEP -│ ├── power.h/.cpp # pomiar napięcia, gpio_hold, deep sleep -│ ├── ui.h/.cpp # przycisk (gesty) + LED statusowy -│ ├── console.h/.cpp # konsola szeregowa (debug bez samochodu) -│ └── app.h # API aplikacji (tryby) -├── test/test_tpms_frame/ # testy jednostkowe generatora ramek (native) -└── tools/ - ├── tpms_frame.py # referencyjna implementacja ramki + self-test - ├── gen_cu8.py # synteza nagrania IQ (OOK/FSK) do testów z rtl_433 - └── verify_rtl433.sh # automatyczna weryfikacja ramek przez rtl_433 + Konfiguracja: USB/UART 115200 → NVS → 4 × {ID, ciśnienie, temperatura} ``` -Referencje protokołu (źródła, na których oparto kod): +Nie podłączaj 12 V do GPIO, 3V3 ani VIN DevKit. Połączenia i wariant automotive: +[HARDWARE](docs/HARDWARE.md). -* `rtl_433/src/devices/schraeder.c` (historycznie: `tpms_schrader.c`) — - dekoder **Schrader TPMS EG53MA4, Saab, Opel, Vauxhall, Chevrolet** - (Opel OEM 13348393): format ramki, checksum, skale ciśnienia/temperatury: - -* `rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01/` — referencyjne nagrania - RF prawdziwych czujników (na ich podstawie odtworzono timing i modulację): - -* — wzorzec struktury - symulatora TPMS na ESP32+CC1101 (inicjalizacja CC1101, Manchester, CRC, - wysyłanie cykliczne) -* — okablowanie ESP32↔CC1101, - struktura projektu +## Quick Start ---- +### 1. Złóż prototyp -## 4. Kompilacja +Kup elementy z [BOM](docs/HARDWARE.md#bom-prototypu-laboratoryjnego). Podłącz +CC1101, przycisk i LED zgodnie z tabelą pinów. Zasil DevKit przez znany kabel USB +na biurku. Nie montuj jeszcze niczego w samochodzie. -### PlatformIO (zalecane) +### 2. Zainstaluj narzędzia i sprawdź projekt + +Wymagane: Python 3, Git, CMake, kompilator C/C++, `pkg-config` i nagłówki libusb. +Najprościej użyć Dockera: ```bash -pio run -e esp32dev # kompilacja -pio run -e esp32dev -t upload # wgrywanie -pio device monitor # monitor szeregowy 115200 -pio test -e native # testy generatora ramek (bez sprzętu) +docker build -t tpms-rc . +docker run --rm -v "$PWD/artifacts:/work/artifacts" tpms-rc ``` -Biblioteka CC1101 (`SmartRC-CC1101-Driver-Lib`, dawniej -`ELECHOUSE_CC1101_SRC_DRV`) jest pobierana automatycznie z `platformio.ini` -(przypięta do commita zweryfikowanego buildu). **Wymagana wersja ≥ 2.5.7** -(wspólne API `setSpiPin`/`setGDO0` dla 2.5.x i 3.x; starsze 1.x używały -`setSCK`/`setMISO`/... i nie są obsługiwane). - -### arduino-cli (alternatywa) +Bez Dockera skrypt utworzy `.venv` z PlatformIO, pobierze przypięty `rtl_433` +i referencyjne nagrania: ```bash -arduino-cli core install esp32:esp32 -arduino-cli lib install "SmartRC-CC1101-Driver-Lib" # albo: lib ZIP z githuba -arduino-cli compile --fqbn esp32:esp32:esp32 --libraries . . +bash tools/check_all ``` -(Utwórz folder `src/` jako szkic albo użyj `--build-property` z -`build.extra_flags`; najwygodniej jednak otworzyć katalog w PlatformIO.) +Ostatni komunikat musi brzmieć `PASS: wszystkie testy bez sprzetu...`. +To nie jest test fizycznego radia. -### Weryfikacja bez sprzętu (opcjonalna) +### 3. Skompiluj i wgraj ```bash -python3 tools/tpms_frame.py --self-test # zgodność z dekoderem rtl_433 -RTL433=rtl_433 ./tools/verify_rtl433.sh # pełne testy z prawdziwym rtl_433 +.venv/bin/pio run -e esp32dev +.venv/bin/pio run -e esp32dev -t upload +.venv/bin/pio device monitor --baud 115200 ``` -`tools/verify_rtl433.sh` generuje syntetyczne nagrania IQ takie, jakie -odbiornik RTL-SDR zobaczy w eterze, i sprawdza, czy **prawdziwy rtl_433** -dekoduje je jako poprawny czujnik Schrader z oczekiwanym ID/ciśnieniem/ -temperaturą. Ostatni wynik testów projektu: +Jeżeli port nie jest wykrywany automatycznie, dodaj `--upload-port /dev/ttyUSB0` +(przy `run`) albo `--port /dev/ttyUSB0` (przy `device monitor`). W monitorze +PlatformIO wyjście to zwykle `Ctrl+]`. -``` -== OOK (domyslna modulacja, wbudowany dekoder Schrader-EG53MA4) == -OK c1.cu8 id=2FC871 260.0 kPa 73.0 F -OK c2.cu8 id=3495AC 220.0 kPa 23.0 F -OK c3.cu8 id=ABCDEE 262.5 kPa 75.0 F -== FSK (wariant konfigurowalny, dekoder flex) == -OK c4.cu8 (FSK) bitstream zgodny: 00000000004c9000702fc871684965 -WSZYSTKO OK - ramki dekoduja sie poprawnie przez rtl_433 +Po uruchomieniu wpisz `stay 300` i Enter. Masz 5 minut na konfigurację; polecenie +`info` pokazuje aktywne wartości. Każda zmiana konfiguracji jest od razu zapisywana +w NVS i zachowuje się po restarcie — **nie edytuj ID w kodzie**. + +### 4A. Preferowane: Clone IDs + +Jeśli znasz oryginalne 24-bit ID (np. z wcześniejszego odczytu `rtl_433`), wpisz +je w kolejności FL, FR, RR, RL. Przykład — zastąp wartości własnymi: + +```text +stay 300 +id 1 2FC871 +id 2 2EAAF9 +id 3 3495AC +id 4 2FC780 +pressure all 260 +info +send ``` ---- - -## 5. (a) Okablowanie - -### Lista podzespołów (BOM) — co kupić - -Koszty orientacyjne (zł, z dostawą z AliExpress/Allegro, stan na 2026 r.). -Wystarczy **jedna sztuka** każdego podzespołu. - -**Obowiązkowe:** - -| Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. | -|-----|-----------|-----------------|-------|----------------| -| 1 | ESP32 DevKit (WROOM-32) | moduł ESP32-WROOM-32, USB | Do testów na biurku OK. **Do montażu w aucie kup sam moduł ESP32-WROOM-32E** (bez mostka USB/LDO) + płytkę — patrz sekcja 13 o poborze prądu | 15–30 zł | -| 2 | Moduł CC1101 **433 MHz** | 8-pin, SPI, złącze goldpin | Koniecznie wersja 433 MHz (nie 868/915); dokup/drut antenowy ~17 cm; sprawdzić złącze ANT | 10–25 zł | -| 3 | Przycisk monostabilny | NO, wpuszczany lub panelowy | Tryby pracy (learn/single) | 2–5 zł | -| 4 | LED + rezystor 330 Ω | LED 3 mm/5 mm dowolny kolor | Status trybów | 1–3 zł | -| 5 | Rezystor 10 kΩ | 1 szt. | Podciągnięcie przycisku do 3V3 | < 1 zł | -| 6 | Rezystory 1 MΩ + 270 kΩ | po 2 szt. | Dzielniki pomiaru napięcia i ACC (~9 µA/szt. przy 12 V) | < 1 zł | -| 7 | Kondensatory | 100 µF/16 V elektrolityczny + 2× 100 nF ceramiczny | Odsprzężenie zasilania CC1101 i ESP32 (obowiązkowo przy długich przewodach) | 1–3 zł | -| 8 | Bezpiecznik + uchwyt | 1 A, zwłoczny | Szeregowo z +12 V | 2–5 zł | -| 9 | Przewody, złącza | goldpiny 2,54 mm, kostki, ekran SPI | Przewody SPI możliwie krótkie (< 10 cm) | 5–15 zł | -| 10 | Obudowa | IP65, min. 80×60×30 mm | Montaż w komorze silnika/bagażniku | 10–25 zł | - -**Zasilanie — wybierz wariant (konfigurowalne w `config.h`, `POWER_SUPPLY_MODE`):** - -| Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. | -|-----|-----------|-----------------|-------|----------------| -| 11a | **Wariant 12 V**: LDO 3,3 V o niskim Iq i **wejściu ≥ 16 V** | np. **MCP1703-3302** (Vin 2,7–16 V, Iq ≈ 2 µA) | + zabezpieczenie wejścia: bezpiecznik, **TVS 24 V**, rezystor/dioda szeregowa (przepięcia load-dump!). Sprawdź moc strat: (14,4−3,3) V × ~30 mA ≈ 0,33 W — stosuj obudowę SOT-223/TO-92 i nie przeciążaj | 2–8 zł | -| 11b | **Wariant 12 V** (wydajniejszy): buck o szerokim wejściu | np. **LM5164-Q1** (Vin 6–100 V, Iq ≈ 10 µA, 1 A) lub inny buck automotive | Wymaga cewki i płytki; **TPS62740 (Vin 2,2–5,5 V) i tanie bucki (LM2596, MP1584, Mini360, Iq mA) NIE nadają się do 12 V / snu < 50 µA** | 20–50 zł | -| 12 | **Wariant bateryjny**: ogniwo 3,6 V lub LiPo | Li-SOCl2 3,6 V (AA/half-AA, np. ER14505) + uchwyt **bezposrednio**; LiPo 3,7 V **przez LDO 3,3 V** (np. MCP1700, Vin max 6 V) | **Nie zasilaj LiPo 4,2 V wprost** — max ESP32 to 3,6 V, CC1101 to 3,9 V! | 10–30 zł | - -**Opcjonalne (ulepszenia i testy):** - -| Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. | -|-----|-----------|-----------------|-------|----------------| -| 13 | Front-end LF 125 kHz | cewka rezonansowa (ferrytowa ramka z programatora TPMS), dioda Schottkyego (BAT54/1N5711), 100 pF + 100 kΩ, komparator LM393 | Reakcja na aktywację czujnika programatorem przy kole (`PIN_LF_TRIGGER`) | 10–30 zł | -| 14 | Dzielnik ACC | 1 MΩ + 270 kΩ + 100 nF | Sygnał zapłonu 12 V → GPIO32 (tryb ignition-aware) | < 2 zł | -| 15 | RTL-SDR (dongle) | R820T2/RTL2832U | Testy z `rtl_433` (sekcja 7) — można wypożyczyć | 60–150 zł | -| 16 | Kabel USB + ew. programator | do wgrywania firmware | W DevKit kabel USB-A/Micro-USB wystarczy | 5–15 zł | - -**Narzędzia (do pomiarów, sekcja 9):** multimetr z zakresem µA (obowiązkowo do -pomiaru snu), opcjonalnie INA219/INA226 lub oscyloskop do pomiaru prądu w burst. - -**Na skróty — zestaw minimalny „na biurko"** (testy RF + nauka): pozycje 1–10 -z wariantem 12 V lub zasilaniem z powerbanka 5 V przez DevKit (testy RF nie -wymagają spełnienia budżetu prądu). - -Gdzie kupić: AliExpress (CC1101, LM5164, ESP32), Allegro/sklepy elektroniczne -(pasywne elementy, obudowa, bezpieczniki, TVS). Przy zamawianiu CC1101 sprawdź, czy -moduł jest oznaczony **433 MHz** — wersje 868/915 MHz nie zadziałają bez -przestrojenia. - -### Podłączenie - -| ESP32 DevKit | CC1101 | Uwagi | -|--------------|-------------|----------------------------------------| -| 3V3 | VCC | **3.3 V!** (CC1101 nie toleruje 5 V) | -| GND | GND | masa wspólna | -| GPIO18 | SCK (SCLK) | `PIN_CC1101_SCK` | -| GPIO19 | MISO (SO) | `PIN_CC1101_MISO` | -| GPIO23 | MOSI (SI) | `PIN_CC1101_MOSI` | -| GPIO5 | CS (CSn/SS) | `PIN_CC1101_CS` | -| GPIO2 | GDO0 | `PIN_CC1101_GDO0` | -| — | GDO2 | nieużywany (zostaw odłączony) | - -Pozostałe elementy (numery pinów konfigurowalne w `config.h`): - -| Element | Pin ESP32 | Podłączenie | -|-------------------------|-----------|------------------------------------------------| -| Przycisk trybów | GPIO26 | GPIO —— przycisk —— GND, rezystor 10 kΩ do 3V3 (aktywny niski, `BTN_ACTIVE_LEVEL 0`) | -| LED statusowy | GPIO27 | GPIO —— 330 Ω —— LED —— GND | -| Wejście LF 125 kHz (opcjonalnie) | GPIO25 | wyjście detektora LF (impuls do 3,3 V), stan spoczynkowy **niski**; bez modułu: ustaw `PIN_LF_TRIGGER -1` | -| ACC / zapłon (opcjonalnie) | GPIO32 | dzielnik 12 V → ~3 V (1 MΩ / 270 kΩ + 100 nF), wejście **INPUT** (bez podciągania); **domyślnie wyłączone** (`PIN_ACC -1`) — ustaw 32 po podłączeniu | -| Pomiar napięcia | GPIO34 | węzeł środkowy dzielnika `R1=1 MΩ / R2=270 kΩ` (ADC1) + 100 nF | - -Zasilanie (wybór w `config.h`, `POWER_SUPPLY_MODE`): - -``` - POWER_12V (na stałe z akumulatora) - UWAGA: zakres samochodowy to nie - same "12 V": 14,4 V przy ladowaniu - i przepięcia load-dump > 40 V: - +12 V ──[bezpiecznik 1 A]──[TVS 24 V do masy]──[rezystor/dioda]── regulator - ── 3,3 V ── ESP32 + CC1101 - - Regulator (wybierz jeden): - - LDO o Iq ~2 µA i wejściu >= 16 V, np. MCP1703-3302 - (straty: (14,4-3,3) V x ~30 mA = ~0,33 W - zwróć uwagę na obudowę), - - albo buck automotive o szerokim wejściu, np. LM5164-Q1 (6-100 V, - Iq ~10 µA) - wydajniejszy, wymaga cewki. - TPS62740 (Vin 2,2-5,5 V!) i tanie bucki (LM2596/MP1584/Mini360, Iq mA) - NIE nadają się do tej aplikacji. - - POWER_BATTERY: - Li-SOCl2 3,6 V ── bezposrednio 3V3 (ESP32 wymaga >= 3,0 V pod obciazeniem) - LiPo 3,7 V ── PRZEZ LDO 3,3 V (np. MCP1700). Bezposrednie zasilanie - LiPo 4,2 V przekracza max ESP32 (3,6 V) i CC1101 (3,9 V)! -``` - -``` - +12V ──[bezpiecznik]──[TVS]──> regulator IN - Pomiar: +12V ──[R1 1M]──+── GPIO34 ( + 100 nF do masy ) - └──[R2 270k]── GND - (12 V -> 2,55 V, 14,4 V -> 3,05 V, prad dzielnika ~9 uA) -``` - -Ważne: - -* **moduły DevKit z mostkiem USB-UART (CH340/CP2102) i LDO AMS1117 pobierają - w deep sleep 0,5–2 mA** — w aucie użyj gołego modułu ESP32-WROOM na własnej - płytce z przetwornicą o niskim Iq (patrz sekcja 13), -* CC1101 zasilaj **3,3 V**, antena 433 MHz (kawałek drutu ~17 cm) przy złączu - CC1101; trzymaj przewody SPI krótkie, -* masa dzielnika pomiarowego i CC1101 musi być wspólna z ESP32. - -**Opcjonalny front-end LF 125 kHz** (reakcja na aktywację czujnika -programatorem TPMS przy kole): cewka rezonansowa ~125 kHz (kilka zwojów, -np. ferrytowa ramka z programatora) + detektor obwiedni (dioda Schottkyego -+ kondensator + rezystor rozładowczy + bramka komparatora/logiki) → -impuls 3,3 V na `PIN_LF_TRIGGER`. Stan spoczynkowy musi być **niski** -(wejście ESP32 ma wewnętrzne podciągnięcie do dołu włączone przez firmware). -Bez modułu LF jego rolę pełni przycisk — patrz sekcja 8. - ---- - -## 6. (b) Konfiguracja ID i ciśnień - -Wszystko w **`src/config.h`**: - -```c -/* ID poszczególnych kół (24 bity) */ -#define SENSOR_FL_ID 0x2FC871u // przód lewy -#define SENSOR_FR_ID 0x2EAAF9u // przód prawy -#define SENSOR_RR_ID 0x3495ACu // tył prawy -#define SENSOR_RL_ID 0x2FC780u // tył lewy - -/* Ciśnienie startowe: DOMYŚLNIE 2,6 bar = 260 kPa dla wszystkich kół */ -#define SENSOR_FL_PRESS_KPA 260.0f -#define SENSOR_FR_PRESS_KPA 260.0f -#define SENSOR_RR_PRESS_KPA 260.0f -#define SENSOR_RL_PRESS_KPA 260.0f - -/* Temperatura otoczenia (st. C) */ -#define SENSOR_TEMP_C 23 -``` - -Rozdzielczość protokołu: **2,5 kPa/bit** (zakres 0–637,5 kPa), -temperatura w ramce w °F (przeliczenie automatyczne). - -### Jakie ID wpisać? — to jest kluczowa decyzja - -| Strategia | Kiedy stosować | Co zrobić | -|---|---|---| -| **A. Oryginalne ID (najlepsze)** | Auto ma już zapamiętane 4 ID starych czujników | **Przed** wymianą odczytaj ID oryginalnych czujników: `rtl_433 -f 433.92M` (pole `id` modelu `Schrader-EG53MA4`), wgraj je do `config.h`. ECU słyszy „znajome" czujniki i **nie trzeba nic programować**. | -| **B. Nowe ID + procedura nauki** | Oryginalne ID nieznane / ECU nie pamięta | Wpisz dowolne unikalne ID (jak wyżej) i wykonaj **procedurę learn** w aucie (sekcja 8), aby ECU zarejestrowało nowe ID. | - -Dodatkowo (w razie potrzeby): - -```c -#define TPMS_FLAGS 0x4C900070u // słowo "flags" z prawdziwych czujników -#define TPMS_FLAGS_LOWBAT_MASK 0x00000008u // bit "rozładowana bateria" -``` - -Wartość `TPMS_FLAGS` domyślnie pochodzi z nagrań prawdziwych czujników -EG53MA4 (stała `4c900070`). Bitu niskiej baterii rtl_433 nie analizuje — -jeśli Twój sterownik pokazuje ostrzeżenie „service TPMS" mimo dobrych -ciśnień, spróbuj zmienić `TPMS_FLAGS_LOWBAT_MASK` (lub wyczyść bit przez -`flags` w konsoli) i powtórz naukę. - -Po zmianach: `pio run -e esp32dev -t upload`. - ---- - -## 7. (c) Test nadawania — RTL-SDR + rtl_433 - -Zanim włożysz urządzenie do auta, sprawdź transmisję „w eterze": - -1. Zasil urządzenie (powerbank / 3,3 V), ustaw `monitor` szeregowy. -2. Na komputerze z RTL-SDR: - - ```bash - rtl_433 -f 433.92M - ``` - -3. Urządzenie co 30 s wysyła po 3 ramki dla każdego koła. Powinieneś widzieć: - - ``` - time : ... - model : Schrader-EG53MA4 type: TPMS flags: 4c900070 ID : 2FC871 - Pressure : 260.0 kPa Temperature: 73.0 F Integrity : CHECKSUM - ``` - - dla kolejno: `2FC871` (FL), `2EAAF9` (FR), `3495AC` (RR), `2FC780` (RL), - każde 260.0 kPa i 73.0 F (23 °C). - -4. Bez RTL-SDR możesz wywołać ramki z konsoli: `send`, `hex` (hexdump). - -**Wariant FSK** (`TPMS_MODULATION MODE_FSK` w `config.h`) — rtl_433 nie ma -dla tego wariantu wbudowanego dekodera EG53MA4 (deklaracja OOK), weryfikuj -przez dekoder flex: - -```bash -rtl_433 -f 433.92M -X 'n=schrader,m=FSK_MC_ZEROBIT,s=120,l=120,r=300' -``` - -> Uwaga praktyczna: nazwy plików `.cu8` do testów **nie mogą** zawierać -> słów `ook`, `fsk`, `am`, `fm` (parser formatów rtl_433 je rozpoznaje). -> Np. `tpms_sim.cu8` jest OK, `sim_ook.cu8` — nie. - ---- - -## 8. (d) Programowanie czujników w aucie (tryb learn) - -### Kolejność kół w Astrze J - -**przód lewy (FL) → przód prawy (FR) → tył prawy (RR) → tył lewy (RL)** - -(kolejność konfigurowalna przez `LEARN_ORDER_0..3` / kolejność wpisów w tablicy -`SENSOR[]` w `main.cpp`). - -### Sterowanie (przycisk `PIN_BUTTON`) - -| Gest | Tryb NORMAL | Tryb LEARN | Tryb SINGLE | -|--------------------------|--------------------------|--------------------------|--------------------------| -| krótkie naciśnięcie | natychmiast burst 4 kół | **następne koło** | **następne koło** | -| długie (≥1,5 s) | → **LEARN** | → NORMAL | → LEARN | -| bardzo długie (≥4 s) | → **SINGLE** | → SINGLE | → NORMAL | - -(Przycisk nie jest drzemany przy wciśniętym — urządzenie nie wejdzie w sen, -dopóki go nie puścisz; bardzo długi gest zdąży się zawsze zarejestrować.) - -LED: seria **N mrugnięć = N-ty numer koła** (1–4) przy zmianie koła, -wzorzec stały: NORMAL — 1 mrugnięcie co 2 s, LEARN — 3 mrugnięcia co 0,5 s, -SINGLE — 2 mrugnięcia co 0,5 s, niskie napięcie — 10 mrugnięć co 3 s. - -### Procedura krok po kroku - -1. **Odczytaj oryginalne ID** (jeśli to możliwe) — patrz strategia A w sekcji 6. -2. Włącz zapłon, uruchom procedurę nauki TPMS w aucie - (Astra J: menu kierowcy → ustawienia → ciśnienie w oponach → nauka / - „Tyre learning"; w wersjach bez menu — procedura z pedałem gazu - lub przez OP-COM/TECH2 — sprawdź instrukcję obsługi swojej wersji). -3. **Wejdź w tryb LEARN** (długie naciśnięcie) — urządzenie nadaje - **tylko koło FL** (ID z `SENSOR_FL_ID`), LED mruga 1×. -4. Urządzenie nadaje burst co 2 s. Jeśli procedura w aucie wymaga - **aktywacji czujnika przy kole** (puls LF 125 kHz / programator TPMS): - * podejdź do koła FL i użyj programatora LF — jeśli masz moduł LF - (`PIN_LF_TRIGGER`), urządzenie **natychmiast** wyśle właściwe ID, - * bez modułu LF: **krótkie naciśnięcie przycisku = „aktywuj koło"** - (w LEARN służy też do przejścia dalej — użyj komendy `send` - w konsoli, jeśli potrzebna jest aktywacja bez zmiany koła). -5. **Krótkie naciśnięcie = następne koło** (LED: 2×, 3×, 4×) i powtórz - aktywację przy kolejnych kołach w kolejności **FL → FR → RR → RL**. -6. **Okno czasowe**: na każde koło jest `LEARN_WINDOW_MS` (60 s). - Po jego upływie urządzenie **wraca do trybu normalnego** - (`LEARN_WINDOW_EXPIRE_TO_NORMAL 1`); ustaw `0`, jeśli wolisz - automatyczne przejście do kolejnego koła. Cała sesja learn kończy się - też po `LEARN_TOTAL_TIMEOUT_MS` (15 min). -7. Zakończ procedurę w aucie (zwykle: zapłon OFF, jazda testowa). -8. Po zakończeniu nauki urządzenie samo wraca do NORMAL i nadaje - wszystkie 4 koła co 30 s — także przy postoju (transmisja jest ciągła, - niezależna od ruchu; auto-learn może wymagać jazdy, ale ramki lecą zawsze). - -### Jeśli auto „nie zapamiętuje" czujników - -* **Użyj oryginalnych ID** (strategia A) — wtedy nie trzeba w ogóle - programować; ECU zna już te ID i zaakceptuje je natychmiast. -* Sprawdź, czy procedura nauki w aucie była uruchomiona **przed** - transmisjami (ECU w trybie nauki nasłuchuje nowych ID). -* W trybie LEARN nadawane jest **tylko jedno ID naraz** — jeśli nadawałeś - wszystkie 4 jednocześnie, ECU mógł się „pomylić" (stąd tryb learn). -* Upewnij się, że ciśnienie jest w zakresie akceptowanym przez ECU - (260 kPa = 2,6 bar jest bezpieczne dla Astry J). -* Spróbuj wariantu modulacji: `MODE_OOK` ↔ `MODE_FSK` (patrz sekcja 7) — - wersje EU/US różnią się; referencyjne nagrania EG53MA4 to **ASK/OOK**. -* Procedura nauki niektórych wersji Astry J wymaga **jazdy > 20 km/h** - przez kilka minut — urządzenie nadaje przez cały czas, więc wystarczy - wykonać jazdę próbną po starcie procedury. -* Sprawdź DTC przed i po (OP-COM/TECH2): kody czujników (np. C0750–C0759) - powinny zniknąć po udanej nauce. -* Zmierz napięcie zasilania (`batt`) — przy `POWER_12V` urządzenie raportuje - stan akumulatora i flagę niskiego napięcia w ramce (`LOWBATT`). - -### Tryb SINGLE - -Wymuszone nadawanie jednego ID (testy, procedury uczące jedno koło -wielokrotnymi próbami): - -* bardzo długie naciśnięcie (≥4 s) — SINGLE na bieżącym kole, -* konsola: `mode single 2` (koło FR), `next` — zmiana koła, -* wyjście: bardzo długie naciśnięcie lub `mode normal`, - limit czasu `SINGLE_TIMEOUT_MS` (domyślnie 5 min). - ---- - -## 9. (e) Pomiar poboru prądu - -### Co zmierzyć - -| Stan | Co się dzieje | Oczekiwana wartość | -|----------------------|---------------------------------------------------|--------------------| -| **Deep sleep** | między transmisjami (większość czasu) | **< 50 µA** (goły moduł ESP32 + CC1101 + buck o niskim Iq); ~10 µA ESP32 + < 1 µA CC1101 + Iq przetwornicy | -| **Transmisja (burst)** | 4 koła × 3 ramki, ~0,35 s na antenie + 1,2 s aktywności | ~30 mA (CC1101 TX) + ~80 mA (ESP32) przez ok. 1,2 s co interwał | -| **Średnia** | suma | ~4 mA przy interwale 30 s, ~1 mA przy 120 s (patrz sekcja 13) | - -### Jak zmierzyć - -1. **Sen** — multimetr w zakresie µA **szeregowo z zasilaniem**, - po 30 s od ostatniej transmisji (gdy ESP32 jest w deep sleep). - Mierz na pinach modułu, nie przez port USB! -2. **Burst** — rezystor bocznikowy 1 Ω + oscilloskop albo INA219/INA226 - (szyna I²C), odczyt średniego prądu przez ≥ 60 s. -3. **Średnia doby** — mierz przez 1–2 minuty w zakresie mA i przelicz - (albo użyj miernika z integracją, np. µCurrent + logger). -4. Porównaj z budżetem z sekcji 13; odchylenie 2× w dół/w górę jest normalne. - -### Typowe pułapki - -* **DevKit z USB-UART**: mostek CP2102/CH340 + LDO AMS1117 = 0,5–2 mA - w sleep → cel < 50 µA **niedotrzymany z winy płytki**, nie firmware'u. - Rozwiązanie: goły moduł ESP32-WROOM + regulator z sekcji 5 - (MCP1703/ LM5164-Q1 dla 12 V, MCP1700 dla LiPo). -* **Dzielniki pomiarowe**: 2 × 1 MΩ/270 kΩ ≈ 19 µA stale — to już połowa - budżetu < 50 µA; w wariancie bateryjnym możesz je całkowicie odpiąć - (`PIN_VBAT_ADC -1` nie jest obsługiwany — po prostu nie montuj dzielnika - i zignoruj odczyt) albo zwiększyć rezystancje kosztem dokładności ADC. -* Rezystor podciągający przycisku (10 kΩ) pobiera 330 µA przy stanie - aktywnym niskim — w sleep przycisk jest w stanie spoczynkowym (HIGH), - więc prąd nie płynie; gdybyś użył aktywnego HIGH, zwiększ rezystor do 100 kΩ. -* LED — w sleep zgaszony (firmware go gasi przed snem). - ---- - -## 10. (f) Weryfikacja, że błąd zniknął - -1. **Przed testem**: skasuj stare DTC (OP-COM/TECH2 lub odłącz akumulator - na kilka minut — utrata ustawień radia/godziny jest możliwa). -2. Uruchom procedurę learn w aucie (sekcja 8) albo użyj oryginalnych ID. -3. Włącz zapłon, odczekaj 1–3 minuty (ECU zbiera ramki) lub wykonaj jazdę - próbną 5–10 min powyżej 20 km/h. -4. Sprawdź: - * **kontrolka TPMS** (żółta ikona opony) — powinna zgasnąć, - * **wyświetlacz kierowcy** (DIC): menu ciśnienia w oponach powinno - pokazywać 4 wartości (2,6 bar), - * **OP-COM/TECH2**: brak aktywnych kodów czujników TPMS, - * **rtl_433**: `rtl_433 -f 433.92M` dekoduje 4 ID co ok. 30 s - (to potwierdza, że transmisja jest ciągła). -5. Test długotrwały: pozostaw auto na noc z włączonym zapłonem raz na - kilka godzin — po ponownym uruchomieniu błąd nie powinien wracać. -6. Jeśli kontrolka zapala się ponownie po dłuższym postoju — sprawdź - interwał parkingowy (`TX_INTERVAL_PARKING_S`) i flagę baterii - (`TPMS_FLAGS_LOWBAT_MASK`). - ---- - -## 11. Tryby pracy i sterowanie - -| Tryb | Zachowanie | Wejście | -|----------|----------------------------------------------------------------------------|--------------------------------| -| NORMAL | rotacja 4 kół: burst 3 ramek × 4 koła co `TX_INTERVAL_S` (30 s), potem deep sleep | stan domyślny, `mode normal` | -| LEARN | **tylko jedno koło**, burst co 2 s, okno 60 s na koło, przycisk = następne koło | długie naciśnięcie, `mode learn` | -| SINGLE | wymuszone jedno ID, burst co 2 s | bardzo długie naciśnięcie, `mode single n` | - -### Deep sleep i budzenie - -* budzik RTC co `TX_INTERVAL_S` / `TX_INTERVAL_IGNITION_S` / - `TX_INTERVAL_PARKING_S`, -* **EXT0**: przycisk (`PIN_BUTTON`) — natychmiastowe wybudzenie, -* **EXT1**: wejście LF (`PIN_LF_TRIGGER`) — aktywacja czujnika przy kole - = natychmiastowa transmisja odpowiedniego ID, -* między transmisjami: CC1101 w SLEEP (`SPWD`), linie SPI trzymane przez - `gpio_hold` (CS wysoki — utrzymuje CC1101 w sleep, SCK/MOSI niskie), -* WiFi **nie jest w ogóle inicjalizowany**, BT wyłączany (`btStop()`), - brak dynamicznej alokacji pamięci (same bufory statyczne), - brak opóźnień blokujących — jedyny „blocking" to oczekiwanie na - zakończenie nadania ramki (~29 ms) i odstępy między ramkami w burście - (transmisja musi fizycznie trwać tyle, ile trwa). - -### Tryb ignition-aware (ACC) - -* `PIN_ACC` wysoki (zapłon) → interwał `TX_INTERVAL_IGNITION_S` (15 s), -* po zaniku ACC + `ACC_GRACE_MS` (5 min) → interwał `TX_INTERVAL_PARKING_S` - (120 s) albo całkowite uśpienie (`PARKING_SHUTDOWN 1`) — budzi wtedy - tylko przycisk/LF, -* bez podłączonego ACC (`PIN_ACC -1`) urządzenie pracuje stale - z interwałem `TX_INTERVAL_S`. - ---- - -## 12. Konsola szeregowa - -115200 8N1, po starcie okno `BOOT_STAY_AWAKE_MS` (3 s) — wciśnij `stay 60`, -żeby zostać dłużej. Komendy: - -| Komenda | Działanie | -|------------------------------|------------------------------------------------| -| `help` | lista komend | -| `info` / `config` | wersja, konfiguracja, ID, stan, napięcie | -| `hex [n\|all]` | hexdump ramki koła n (1–4) lub wszystkich | -| `send [n\|all]` | wyślij burst teraz | -| `batt` | pomiar napięcia zasilania [mV] | -| `mode normal\|learn\|single [n]` | zmiana trybu | -| `next` | następne koło (learn/single) | -| `interval ` | ręczny interwał (0 = automatycznie wg ACC) | -| `flags ` | słowo `flags` wysyłane w ramce | -| `sleep` | deep sleep teraz | -| `stay [s]` | czuwaj jeszcze s sekund | - -Przykładowy `hex 1` (koło FL): - -``` -FL frame: AA AA AA AA AA AA AA AA AA AA CB 4B 2C AA AA AA D4 AA B3 55 4B 2A D4 AC D3 2A CB 2C D2 CC -FL payload: 4C 90 00 70 2F C8 71 68 49 65 crc=65 id=2FC871 press=260.0 kPa temp=73 F -``` - ---- - -## 13. Budżet prądu - -Założenia: burst = 4 koła × 3 ramki, ramka na antenie 240 chipów × 120 µs -= **28,8 ms**, przerwa 50 ms między ramkami; wybudzenie + konfiguracja CC1101 -+ ADC ≈ 1,2 s aktywności na cykl; ESP32 aktywny ~80 mA, CC1101 TX ~30 mA -(+10 dBm), CC1101 idle ~15 mA, deep sleep ≈ 15 µA (ESP32 ~10 µA + CC1101 -< 1 µA + Iq regulatora) **+ ~19 µA na dzielnikach pomiarowych** -(2 × 1 MΩ/270 kΩ). Przeliczenia poniżej robione są jednym wzorem: -pobór z 12 V = pobór na szynie 3,3 V × (3,3/12) / sprawność regulatora (0,9). - -**Cykl co 30 s** (2880 cykli/dobę): - -| Składnik | Ilość na cykl | Ładunek na cykl | -|---------------------------------------|--------------------|-----------------| -| ESP32 aktywny (80 mA × 1,2 s) | 1,2 s | 96 mAs ≈ 27 µAh | -| CC1101 TX (30 mA × 0,35 s) | 0,35 s | 10 mAs ≈ 3 µAh | -| CC1101 idle/reszta (15 mA × 0,85 s) | 0,85 s | 13 mAs ≈ 4 µAh | -| deep sleep + dzielniki (~34 µA × 30 s)| 30 s | ≈ 0,3 µAh | -| **Razem** | | **≈ 34 µAh/cykl** | - -* **Dobowy pobór na szynie 3,3 V: 34 µAh × 2880 ≈ 98 mAh/dobę** - (średnio ≈ 4 mA). -* Przy zasilaniu 12 V (sprawność 90%): **≈ 30 mAh/dobę z akumulatora** - (98 × 3,3/12/0,9 = 30; średnio ≈ 1,25 mA przy 12 V). - -**Akumulator 60 Ah (Pb), bez innych odbiorników:** - -* prąd potrzebny do rozruchu wymaga napięcia > ~11,8 V, czyli ~50% pojemności - = 30 Ah użyteczne, -* 30 000 mAh / 30 mAh ≈ **1000 dni ≈ 2,7 roku** — teoretycznie; -* **w praktyce granicą jest samorozładowanie akumulatora kwasowego - (3–5%/mies.)** — akumulator bez odbiorników rozładowuje się w 6–12 mies., - więc symulator **nie jest czynnikiem limitującym**. - -**Warianty oszczędne** (pobór z 12 V z uwzględnieniem sprawności 0,9): - -| Interwał | Średni prąd (3,3 V) | Dobowy pobór (12 V) | 60 Ah (30 Ah użyteczne) | -|----------|--------------------|--------------------|--------------------------| -| 30 s | ~4 mA | ~30 mAh/dobę | ~2,7 roku* | -| 120 s (parking) | ~1 mA | ~8 mAh/dobę | ~10 lat* | -| 300 s | ~0,4 mA | ~3,5 mAh/dobę | ogranicza samorozładowanie | - -\* przed samorozładowaniem akumulatora. - -**Wariant bateryjny** (Li-SOCl2 3,6 V 2400 mAh, bez strat przetwornicy): -~98 mAh/dobę przy 30 s to ok. **24 dni**; przy 300 s ~10 mAh/dobę to ok. -**240 dni (~8 mies.)**. Do zasilania bateryjnego stosuj dłuższe interwały, -mniejszą liczbę ramek w burście (`TX_BURST_FRAMES 2`) albo -`PARKING_SHUTDOWN 1`. - -Wskazówki: zmniejsz `TX_BURST_FRAMES`, wydłuż interwał, użyj mocy TX -`TPMS_TX_POWER_DBM 0` (wystarczy w aucie), ustaw `PARKING_SHUTDOWN 1` -(przy postoju sen do przycisku). - ---- - -## 14. Protokół — szczegóły techniczne - -Dekoder referencyjny: `rtl_433/src/devices/schraeder.c` → -`schrader_EG53MA4` („Schrader TPMS EG53MA4, Saab, Opel, Vauxhall, -Chevrolet"), zasilany sygnałem **OOK Manchester** (`OOK_PULSE_MANCHESTER_ZEROBIT`, -`s=123 µs`, `r=300 µs`). Wymagana długość dekodowanego wiersza: **120 bitów**. - -Ramka (bity po dekodowaniu Manchester): - -``` - 0 40 56 80 88 96 104 - +--------+--------+---------+---------+---------+--------+ - | sync | flags (4 B) | id (3 B) |press|T |crc| - | 40 bit | 4c 90 00 70| 2F C8 71 | 68 |49| 65| - +--------+--------+---------+---------+---------+--------+ -``` - -* `flags` — 4 bajty (status/bateria, wg dekodera nie w pełni rozpoznane), -* `id` — 24-bitowy identyfikator czujnika, -* `press` — ciśnienie: **25 mbar/bit = 2,5 kPa/bit** (260 kPa → `0x68`), -* `T` — temperatura w **°F** (23 °C → `73`), -* `crc` — **suma 9 poprzednich bajtów mod 256** (`add_bytes` w rtl_433). - -Kodowanie na warstwie RF (G.E.T. Manchester, zgodnie z analizą nagrań -`rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01/`): - -* chip = **120 µs** (8,33 kBaud), -* bit `0` → chipy `01`, bit `1` → chipy `10`, -* nadajnik wysyła **1 chip rozbiegowy + 119 komórek** (ramkę bez pierwszego - bitu — pierwszy bit dopisuje dekoder MC_ZEROBIT), dopełnienie zerowe do - bajtu jest ciszą w eterze (OOK), -* modulacja: **ASK/OOK 433.92 MHz** (jak w referencyjnych nagraniach; - FCC MRXEG53MA4: „Type of Modulation: ASK + FSK", „Frames are Manchester - encoded ASK data"), opcjonalnie **2-FSK 433.92 MHz, dewiacja 47,6 kHz** - (`TPMS_MODULATION MODE_FSK`). - -Weryfikacja implementacji (bez sprzętu): - -* `tools/tpms_frame.py` — referencyjna implementacja ramki + **kopia - dekodera `pulse_slicer_manchester_zerobit()` z rtl_433** (self-test 500 - losowych ramek + wektor z prawdziwego nagrania `gfile001.cu8`), -* `tools/gen_cu8.py` + `tools/verify_rtl433.sh` — synteza nagrań IQ - i dekodowanie **prawdziwym rtl_433** (wynik w sekcji 4), -* `pio test -e native` — testy kodu C firmware'u (te same wektory). - ---- - -## 15. Rozwiązywanie problemów - -| Objaw | Przyczyna / rozwiązanie | -|---|---| -| `BLAD: brak modulu CC1101` | Sprawdź SPI (SCK=18, MISO=19, MOSI=23, CS=5), zasilanie 3,3 V, masę | -| rtl_433 nic nie dekoduje | Sprawdź antenę, odległość (< 1 m na test), `rtl_433 -f 433.92M`; spróbuj `MODE_FSK` + decoder flex; sprawdź `send` w konsoli i `hex` | -| rtl_433 dekoduje inne ID niż w config | Skompiluj i wgraj ponownie po zmianie `config.h`; sprawdź `info` | -| Auto nie zapamiętuje ID | Strategia A (oryginalne ID) lub procedura learn w trybie LEARN (jedno koło naraz), jazda testowa > 20 km/h | -| Kontrolka TPMS świeci mimo OK | Zmień `TPMS_FLAGS` / `TPMS_FLAGS_LOWBAT_MASK`, skasuj DTC, powtórz naukę | -| Pobór w sleep > 50 µA | DevKit z mostkiem USB — użyj gołego modułu; sprawdź rezystory podciągające i dzielnik pomiarowy (R1+R2 = 133 kΩ → 27 µA przy 3,6 V — rozważ 470 kΩ/150 kΩ) | -| Reset przy transmisji | Za słabe zasilanie — dodaj kondensator 100 µF przy CC1101, użyj bucka o wystarczającym prądzie | -| `pio test -e native` nie przechodzi | Upewnij się, że nie zmieniłeś `tpms_frame.cpp` bez aktualizacji wektorów w teście (generuj przez `tools/tpms_frame.py`) | - ---- - -## Wersje - -* `CONFIG_VERSION` w `src/config.h` — podnieś przy zmianie formatu danych - w pamięci RTC (magic RTC zawiera tę wersję, więc stan zostanie wyzerowany). -* Firmware testowany z: PlatformIO `espressif32@8.0.0`, Arduino core ESP32, - `SmartRC-CC1101-Driver-Lib` commit `de6757e` (3.0.2, wymagane ≥ 2.5.7), - rtl_433 (master). - -**Pamiętaj: symulator generuje sztuczne dane ciśnienia i nie zastępuje -prawdziwych czujników TPMS.** +ID musi mieć sześć cyfr hex, być niezerowe, różne od `FFFFFF` i unikalne. +Urządzenie wróci do NORMAL i będzie nadawało znane ID. **Nauka może być +niepotrzebna, ale nie jest to gwarantowane.** Potwierdź odbiór diagnostycznie; +nie zaczynaj od jazdy. + +### 4B. Alternatywa: New IDs + LEARN + +1. Wpisz `ids new`, następnie `info` i zapisz wygenerowane ID. +2. Uruchom właściwą dla swojej wersji auta procedurę nauki TPMS zgodnie z jej + instrukcją serwisową. Nie zgaduj sekwencji menu/pedałów. +3. Wpisz `mode learn`. Nadaje wyłącznie FL, co 2 s. LED wskaże 1 mrugnięcie. +4. `send` wymusza bieżące koło bez zmiany. Po potwierdzeniu kroku w aucie wpisz + `next`: FR → RR → RL. Krótki przycisk robi to samo; po RL wraca do NORMAL. +5. Jeśli minie 60 s na kole, LEARN przerwie się do NORMAL. Cała sesja ma limit + 15 min. Po zakończeniu sprawdź ID i kody diagnostyczne. + +EL-50448/OEC-T5 jest aktywatorem LF 125 kHz, **nie programatorem ESP32**. Ta +procedura nie wymaga go. Szczegóły: [SETUP](docs/SETUP.md). + +## Sterowanie — jedna tabela + +LED działa tylko podczas czuwania; w deep sleep jest zgaszona. Po zmianie koła +seria 1–4 mrugnięć wskazuje FL/FR/RR/RL. + +| Tryb | Wzorzec LED | Krótki przycisk | Długi ≥1,5 s | Bardzo długi ≥4 s | +|---|---|---|---|---| +| NORMAL | 1 mrugnięcie / 2 s | burst wszystkich 4 | wejście LEARN | wejście SINGLE | +| LEARN | 3 mrugnięcia / 0,5 s; po zmianie numer koła | następne koło + TX; po RL koniec | wyjście NORMAL | wejście SINGLE | +| SINGLE | 2 mrugnięcia / 0,5 s; po zmianie numer koła | następne koło + TX | wejście LEARN | wyjście NORMAL | + +W konsoli `send` w NORMAL nadaje wszystkie, a w LEARN/SINGLE tylko bieżące koło. +`send 1`…`send 4` wybiera koło jawnie; `send all` nadaje cztery. SINGLE wyłącza +się po 5 min. + +## Najczęstsze problemy + +- **`BLAD: brak CC1101`**: sprawdź 3,3 V, wspólną masę i sześć przewodów SPI; + nie używaj 5 V na CC1101. +- **Konsola znika przed wpisaniem komend**: po restarcie od razu `stay 300`; + zwykłe wybudzenie RTC celowo nie otwiera okna konsoli. +- **NVS zgłasza błąd**: urządzenie używa bezpiecznych domyślnych; wpisz `info`. + `factory YES` kasuje własne ID i przywraca konfigurację fabryczną. +- **Auto nie odbiera**: najpierw zweryfikuj profil auta i odbiór RTL-SDR; nie + zmieniaj losowo modulacji, flag ani interwałów. Zobacz + [TROUBLESHOOTING](docs/TROUBLESHOOTING.md). + +## Walidacja, zasilanie i release + +- Protokół i niewiadome: [PROTOCOL](docs/PROTOCOL.md) +- Dokładne wyniki i checklista HIL: [VALIDATION](docs/VALIDATION.md) +- Pobór (na razie szacunki): [POWER](docs/POWER.md) +- Wymagania zasilania 12 V: [HARDWARE](docs/HARDWARE.md#wariant-automotive--wymagania-niezwalidowany-projekt) +- Zmiany: [CHANGELOG](CHANGELOG.md) + +Gotowe obrazy tworzy `bash tools/package_release.sh`. Pliki i adresy opisano w +[VALIDATION](docs/VALIDATION.md#artefakty-i-wgrywanie). Release candidate nie +zawiera wyniku testu CC1101 ani samochodu. diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md new file mode 100644 index 0000000..84dca89 --- /dev/null +++ b/RELEASE_NOTES.md @@ -0,0 +1,53 @@ +# TPMS EG53MA4 Simulator 2.0.0-rc.1 + +**Release candidate — 2026-10-27. Nie jest to release „validated”.** + +Diagnostyczny symulator czterech czujników Schrader EG53MA4 dla ESP32-WROOM-32 / +DevKit + CC1101 433 MHz. Profil docelowy obejmuje testy z Oplem Astra J Sedan 2016, +ale zgodność konkretnego auta trzeba potwierdzić. Sztuczne dane mogą ukryć usterkę +opony; nie używać w jeździe drogowej. + +## Funkcje + +- cztery trwałe, niezależne 24-bit ID; domyślnie 260 kPa dla każdego koła; +- OOK/Manchester 433,92 MHz, niska konfigurowalna moc od −10 dBm; +- Clone IDs oraz New IDs + LEARN FL→FR→RR→RL, SINGLE/diagnostics; +- konfiguracja NVS przez UART bez rekompilacji, wersja/CRC/walidacja/factory reset; +- przycisk, LED, timeouty, deep sleep z RTC i opcjonalne sprzętowe ACC; +- automatyczne testy native/RF/build, Docker i artefakty SHA-256. + +## Wymagany sprzęt + +ESP32 DevKit z WROOM-32 do prototypu, CC1101 **433 MHz** 3,3 V, antena, przycisk, +LED + 330 Ω, odsprzężenie i zasilanie laboratoryjne. Pełny BOM/pinout: HARDWARE. +DevKit ani tania przetwornica nie są zwalidowanym rozwiązaniem automotive. + +## Instalacja i aktualizacja + +Nowa instalacja: `bash tools/check_all`, potem `pio run -e esp32dev -t upload`. +Gotowe obrazy: `bash tools/package_release.sh`; adresy i flash opisano w VALIDATION. +Przed pełnym flashem zapisz ID — partycja NVS może zostać skasowana. Konfigurację +sprawdź po restarcie przez `info`. Migracji z wersji 1.0 bez NVS nie ma; należy +wpisać ID w konsoli jeden raz. + +## Wyniki testów bez sprzętu (2026-10-27) + +- native: 20/20 PASS; +- pełny ESP32 build z `-Werror`: PASS; +- cppcheck: PASS, 0 defektów; +- rtl_433: 64/64 rekordy referencyjne, 3/3 syntetyczne, 3/3 negatywne: PASS. + +Dokładne komendy i przypięte commity: VALIDATION/PROTOCOL. + +## Znane ograniczenia + +- Nie zmierzono rzeczywistej emisji CC1101, ogona, mocy ani częstotliwości. +- Nie wykonano RTL-SDR z anteną, pomiaru poboru, brownout ani testu ACC. +- Nie wykonano Clone IDs/LEARN z samochodem; nie potwierdzono OE 13506028 dla + konkretnego VIN. +- Znaczenie wszystkich flags pozostaje nieznane; brak zgadywanego low battery. +- Harmonogram jest eksperymentalny, nie potwierdzony OE. +- Wymagania zasilania 12 V nie są zwalidowanym projektem automotive. +- Gitea Actions wymaga działającego runnera; lokalne wyniki nie oznaczają CI PASS. + +Do czasu odhaczenia HIL w VALIDATION wynik pozostaje release candidate. diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md new file mode 100644 index 0000000..17f3ab4 --- /dev/null +++ b/THIRD_PARTY_NOTICES.md @@ -0,0 +1,23 @@ +# Licencje i źródła + +Projekt jest rozpowszechniany na GPL-2.0-or-later (`LICENSE`). Wybór jest +zgodny z wykorzystaniem w historii modelu algorytmu slicera z rtl_433. Nie +przypisujemy sobie praw do kodu autorów zewnętrznych. + +- **rtl_433** — GPL-2.0-or-later; dekoder `schraeder.c`, Copyright Benjamin + Larsson, Christian W. Zuckschwerdt i kolejni autorzy. Używany jako niezależny + program do testów. Źródło i pełna historia: . + Referencja testów: commit `406f9a33550a2b6b3d0d8a8a486417ce5b3f13ab`. +- **rtl_433_tests** — nagrania i metadane należą do ich autorów; nie są kopiowane + do artefaktu firmware ani release. Skrypt pobiera przypięty commit + `1aa8c29d6b9383739d1aeed495dbc5069b704392`. +- **SmartRC-CC1101-Driver-Lib** — zewnętrzna biblioteka pobierana przez PlatformIO; + zachowane są jej oryginalne nagłówki i licencja. Użyty commit + `de6757ef633b3e626dae5c7835cdb66ab53f9a1d`. +- **Arduino ESP32 / ESP-IDF / PlatformIO / Unity** — zależności build/test na ich + własnych licencjach; nie są objęte deklaracją autorstwa tego projektu. +- Issue rtl_433 #2978 służył wyłącznie jako wzorzec integracji CC1101. Kod + protokołu Renault nie jest kodem EG53MA4 i nie został użyty jako protokół. + +Pełne teksty licencji zależności znajdują się w ich źródłach pobieranych podczas +buildu. Ten plik nie zawęża ich praw ani licencji. diff --git a/docs/AUDIT.md b/docs/AUDIT.md new file mode 100644 index 0000000..752b6b9 --- /dev/null +++ b/docs/AUDIT.md @@ -0,0 +1,25 @@ +# Rejestr audytu release-v2 + +| Priorytet | Problem początkowy | Kryterium naprawy | Stan / dowód | +|---|---|---|---| +| P0 | Zgadywany bit low battery zależny od zasilania emulatora | brak maski i sprzężenia; test flags | naprawione; grep kodu i 20/20 native | +| P0 | MCP1703 + TVS 24 V opisane jako ochrona automotive | usunąć rekomendację; wymagania i przykład z datasheet | naprawione w HARDWARE | +| P0 | Brak fizycznego dowodu zgodności z autem przedstawiany zbyt pewnie | RC, jawne HIL, weryfikacja VIN/oznaczeń | naprawiona dokumentacja; HIL nadal otwarte | +| P1 | ID/ciśnienia/RF tylko przez rekompilację | NVS z konsolą, walidacja, wersja/CRC | naprawione; test_settings i build | +| P1 | Monolit uniemożliwiał test timeoutów/ACC | przenośny state-machine, fake clock/radio | naprawione; test_app_state | +| P1 | FSK w podstawowym flow bez dowodu | tylko OOK w firmware/generatorze | naprawione | +| P1 | PARKING_SHUTDOWN bez gwarantowanego ACC wake | usunąć albo zapewnić budzenie | usunięty; każdy sen ma RTC | +| P1 | TX kończone czasem i TXBYTES, ryzyko ogona | MARCSTATE/underflow/limit | poprawione; wymaga potwierdzenia HIL | +| P1 | Wektory głównie własne | cztery prawdziwe nagrania + niezależny rtl_433 | 64/64 PASS | +| P2 | Domyślne LF bez zwalidowanego front-endu | wyłączyć domyślnie, LEARN bez LF | naprawione | +| P2 | Interwały przedstawiane jak OE | jawnie eksperymentalne | PROTOCOL/SETUP/POWER | +| P2 | Brak pełnego jednego check/build artefaktów | check_all, CI, Docker, package_release | dodane; wyniki VALIDATION | +| P2 | Okno konsoli po każdym RTC zwiększa pobór | sen od razu po cyklu RTC | poprawione; pomiar HIL otwarty | +| P2 | README niezgodne z zachowaniem | nowy Quick Start, jedna tabela UI | przepisane | + +## Otwarte, wymagające sprzętu + +Nie można ich zamknąć deklaracją: pomiar CC1101/ogon/moc/częstotliwość, test +RTL-SDR z anteną, pobór i brownout, zabezpieczone ACC, test Clone IDs/LEARN z +konkretną Astrą oraz projekt i test zasilania automotive. Są checklistą w +`VALIDATION.md` i blokują status „validated”. diff --git a/docs/HARDWARE.md b/docs/HARDWARE.md new file mode 100644 index 0000000..8094609 --- /dev/null +++ b/docs/HARDWARE.md @@ -0,0 +1,110 @@ +# Sprzęt i montaż + +## Zakres + +Podstawowy release opisuje **prototyp laboratoryjny**. DevKit, przewody +prototypowe i tania przetwornica nie są gotowym zestawem do trwałego montażu +w samochodzie. Wariant automotive poniżej jest listą wymagań projektowych, +nie zwalidowanym schematem. + +## BOM prototypu laboratoryjnego + +| Element | Wymaganie | Uwagi | +|---|---|---| +| ESP32 DevKit z ESP32-WROOM-32 | 3,3 V, USB do flash/konsoli | tylko biurko; mostek USB i LDO zwiększają pobór | +| CC1101 | moduł **433 MHz**, SPI, 3,3 V | nie kupuj wersji 868/915 MHz | +| Antena 433 MHz | dopasowana do modułu; na biurko monopol λ/4 ≈ 17 cm | uziemienie/przeciwwaga zgodnie z konstrukcją modułu | +| Przycisk NO | monostabilny | GPIO26 do GND | +| LED + rezystor | 330 Ω | GPIO27, LED do GND | +| Kondensatory | 100 nF przy każdym module + 47–100 µF przy CC1101 | możliwie blisko pinów zasilania | +| Przewody | krótkie, wspólna masa | SPI najlepiej <10 cm | +| Zasilanie laboratoryjne | USB 5 V do DevKit albo regulowane 3,3 V z limitem prądu | nie podawaj jednocześnie rywalizujących źródeł | + +Do diagnozy RF przydaje się RTL-SDR, ale nie jest częścią emulatora. Do wersji +energooszczędnej użyj gołego ESP32-WROOM-32E na własnej płytce, z poprawnym +zasilaniem, resetem, bootstrapem i złączem programowania. Sam moduł nie ma USB. + +## Pinout i połączenia + +| ESP32 | CC1101 / element | Zasada | +|---|---|---| +| 3V3 | CC1101 VCC | **tylko 3,3 V** | +| GND | CC1101 GND, przycisk, LED | wspólna masa | +| GPIO18 | SCK/SCLK | SPI | +| GPIO19 | MISO/SO | SPI | +| GPIO23 | MOSI/SI | SPI | +| GPIO5 | CS/CSn/SS | SPI | +| GPIO2 | GDO0 | diagnostyka biblioteki; GDO2 niepodłączony | +| GPIO26 | przycisk NO do GND | wewnętrzny pull-up; opcjonalny zewnętrzny 10 kΩ | +| GPIO27 | rezystor 330 Ω → LED → GND | aktywna wysoko | +| GPIO34 | opcjonalny ADC zasilania przez dzielnik | nigdy 12 V wprost | +| GPIO32 | opcjonalne ACC po zmianie `PIN_ACC` i zabezpieczeniu | nigdy 12 V wprost | +| GPIO25 | opcjonalny detektor LF po zmianie `PIN_LF_TRIGGER` | domyślnie wyłączone; brak gotowego front-endu w RC | + +Przy zasilaniu 3,3 V z zasilacza: ustaw limit np. 0,5 A, sprawdź polaryzację, +połącz GND, wyłącz USB jako drugie źródło. Prąd szczytowy zależy od modułu i PA. + +## Antena i test położenia + +Nie zgadujemy położenia odbiornika TPMS w Astrze J. Test zasięgu wykonaj na +postoju, z niską mocą, porównując odczyt RTL-SDR/diagnostykę dla kilku pozycji: +konsola środkowa, okolica za schowkiem, ewentualnie bagażnik. Wynik dla jednego +egzemplarza nie jest dowodem lokalizacji odbiornika. + +Urządzenie mocuj mechanicznie, z dala od poduszek powietrznych i ich wiązek, +strefy pedałów, ruchomych części, wilgoci, źródeł ciepła i metalowych ekranów. +Nie owijaj anteny wiązką, nie prowadź jej przy żarówce/rozdzielaczu LPG ani przy +przewodach zapłonowych. Obudowa prototypu powinna być nieprzewodząca; otwór i +konieczność ekranowania trzeba ocenić pomiarowo. + +## Wariant automotive — wymagania, niezwalidowany projekt + +Instalacja 12 V wymaga osobnego schematu, obliczeń, PCB i testów. Minimalny łańcuch: + +```text +akumulator → bezpiecznik przy źródle → ochrona reverse polarity + → ograniczenie energii + właściwie dobrany TVS + → regulator automotive → odsprzężenie → ESP32 + CC1101 +ACC → ochrona przepięciowa + dzielnik/komparator → wejście logiczne 3,3 V +``` + +Wymagania: + +- bezpiecznik dobrany do przewodów i poboru, blisko źródła; nie zastępuje TVS; +- ochrona przed odwrotną polaryzacją i ujemnymi przepięciami; +- TVS dobrany do rzeczywistego profilu przepięć, rezystancji źródła i energii; + napięcie robocze nie może powodować upływu przy 14,4–14,8 V, a napięcie + ograniczenia musi pozostawić margines względem absolutnego maksimum regulatora; +- regulator z odpowiednim zakresem wejściowym, prądem szczytowym, niskim Iq, + stabilnością z wybranymi kondensatorami i kwalifikacją automotive; +- odsprzężenie zgodne z kartą regulatora, ESP32 i CC1101, krótkie pętle prądowe; +- ACC/ADC z ograniczeniem prądu, clampami i progiem odpornym na zakłócenia; +- obliczenia termiczne dla najwyższej temperatury, test brownout/crank/load dump, + EMC, ESD oraz pomiar snu całego urządzenia. + +**MCP1703 ma Vin maks. 16 V i nie jest pełną ochroną automotive nawet z TVS 24 V.** +TVS o progu wyższym niż dopuszczalne Vin nie chroni regulatora. Nie używamy tej +rekomendacji. + +Przykład do dalszego projektu, nie gotowa rekomendacja montażowa: **LM5164-Q1**, +buck 6–100 V, 1 A, typowy Iq rzędu 10 µA (wartości zależne od warunków). Sprawdzono +z kartą TI [LM5164-Q1](https://www.ti.com/lit/ds/symlink/lm5164-q1.pdf), dostęp +2026-10-27. Projekt musi uwzględnić m.in. schemat aplikacyjny, cewkę, diodę/układ +wejściowy, kondensatory, stabilność, szczyty prądu ESP32, temperaturę i ograniczenie +przepięcia poniżej dopuszczalnego Vin z marginesem. Sama nazwa „100 V” nie dowodzi +odporności całego urządzenia. + +## Zasilanie bateryjne + +Ogniwo 18650 w kabinie **nie jest rekomendowane**: temperatura w samochodzie może +przekraczać bezpieczne warunki ogniwa, a zainstalowane ogniwo wymaga ochrony, +właściwego ładowania i obudowy. ESP32 z radiem i okresowym czuwaniem zwykle daje +krótki czas pracy; deklaracje wieloletniej pracy byłyby nieuzasadnione. Wieloletni +wariant bateryjny wymaga innej architektury low-power i nie należy do tego release. + +## Opcjonalny LF + +RC działa bez EL-50448. Nie ma w nim zwalidowanego odbiornika LF. Przyszły moduł +wymaga osobnego schematu rezonansu/detekcji 125 kHz, progu komparatora, filtracji, +testu odporności na zakłócenia i udowodnionego budzenia. Sam aktywator nie wpisuje +ID do emulatora. diff --git a/docs/POWER.md b/docs/POWER.md new file mode 100644 index 0000000..f3888f9 --- /dev/null +++ b/docs/POWER.md @@ -0,0 +1,56 @@ +# Energia i zachowanie na postoju + +## Status pomiarów + +**Nie wykonano pomiarów prądu fizycznego prototypu.** Liczby poniżej są +szacunkami budżetu, nie wynikiem walidacji. DevKit nie nadaje się do deklaracji +poboru µA, ponieważ mostek USB-UART, LED i regulator mogą pobierać ok. 0,5–2 mA +lub więcej w zależności od płytki. + +## Harmonogram firmware + +- NORMAL po wybudzeniu RTC: inicjalizacja, burst czterech kół, wyjście z TX i deep + sleep. Nie ma 10-sekundowego okna konsoli po zwykłym budziku. +- Po power-on, przycisku lub LF: okno konsoli 10 s; `stay N` wydłuża je. +- LEARN: TX jednego koła co 2 s, bez deep sleep, maks. 60 s na koło/15 min sesji. +- SINGLE: TX jednego koła co 2 s, bez deep sleep, maks. 5 min. +- CC1101 przechodzi w SPWD przed snem; CS jest wysoki, SCK/MOSI niskie, LED off. +- Każdy sen ma budzik RTC. `PARKING_SHUTDOWN` usunięto — urządzenie nie może + pozostać uśpione do czasu wyłącznie ręcznego wybudzenia. +- ACC (opcjonalny sprzętowo) wybiera interwał ignition/parking. Nie jest potrzebne + jako jedyne źródło wybudzenia, ponieważ RTC zawsze działa. + +## Szacunek ładunku dla ustawień domyślnych + +Jedna ramka to 240 × 120 µs = 28,8 ms na antenie. Dla 4 kół × 3 ramki: +345,6 ms samej transmisji plus 8 × 50 ms przerw wewnątrz burstów. Do tego dochodzi +boot, konfiguracja, SPI i logi. Do obliczeń energii trzeba zmierzyć cały cykl, +a nie tylko czas OOK. + +Przykładowy model (do zastąpienia pomiarem): jeżeli aktywność ESP32 wyniesie 1,0 s +przy 80 mA co 30 s, sam ESP32 uśrednia ok. 2,7 mA na 3,3 V. CC1101, boot i prąd snu +dodają kolejne składniki. Przy interwale 120 s udział aktywności spada ok. czterokrotnie, +ale stały Iq zasilacza i dzielników pozostaje. Nie są to zmierzone 2,7 mA ani +obietnica poboru z akumulatora 12 V. + +## Metoda pomiaru wymagana przed „validated” + +1. **Cały DevKit w sleep:** miernik µA szeregowo na wejściu, nie przez USB. + Odczekać do końca TX i zanotować minimum/stan stabilny oraz model płytki. +2. **Goły moduł + zasilacz docelowy:** powtórzyć na wejściu 12 V i na 3,3 V. + Uwzględnić Iq regulatora, TVS, dzielniki i pull-upy. +3. **Cykl NORMAL:** bocznik + oscyloskop albo logger z odpowiednim pasmem. + Zarejestrować boot, 12 ramek, przerwy, wejście w sen przez co najmniej 10 cykli. +4. **Średnia:** całkować ładunek co najmniej 15 min przy 30 s i 120 s. Podawać + warunki: napięcie, temperatura, PA, wersja płytki i firmware. +5. **LEARN/SINGLE:** osobno zmierzyć prąd ciągłego czuwania. +6. **ACC/brownout/crank:** sprawdzić restart, powrót do nadawania i integralność + NVS. Nie wykonywać na GPIO bez potwierdzonej ochrony wejścia. + +## Wnioski dopuszczalne przed pomiarem + +- Największy wpływ mają interwał, czas czuwania, PA i Iq całej płytki. +- Do wersji energooszczędnej potrzebny jest goły ESP32 i zasilacz o niskim Iq. +- Nie rekomendujemy 18650 w kabinie ani wieloletniej pracy bateryjnej z ESP32. +- Stały pobór emulatora trzeba uwzględnić przy długim postoju pojazdu; nie podajemy + czasu „bezpiecznego dla akumulatora” bez pomiaru całego samochodu. diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md new file mode 100644 index 0000000..22266b6 --- /dev/null +++ b/docs/PROTOCOL.md @@ -0,0 +1,93 @@ +# Protokół Schrader EG53MA4 — fakty i niewiadome + +## Przypięte źródła + +| Źródło | Wersja użyta do walidacji | Zakres | +|---|---|---| +| `rtl_433/src/devices/schraeder.c` | commit `406f9a33550a2b6b3d0d8a8a486417ce5b3f13ab` | dekoder i parametry slicera | +| `rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01` | commit `1aa8c29d6b9383739d1aeed495dbc5069b704392` | cztery nagrania CU8 + JSON | +| PlatformIO | 6.1.18 | build/test | +| `espressif32` | 8.0.0 | toolchain/platforma ESP32 | +| SmartRC-CC1101-Driver-Lib | `de6757ef633b3e626dae5c7835cdb66ab53f9a1d` (3.0.2) | konfiguracja CC1101 | +| Praktyczna analiza odbioru | | kontekst; nie źródło pól ramki | +| Wzorzec integracji ESP32+CC1101 | | integracja, nie protokół EG53MA4 | + +Nie używamy nieoznaczonego `master` jako referencji reprodukowalnej. Komercyjny +emulator potwierdza +jedynie istnienie takiej klasy urządzenia, nie zgodność tego projektu. + +## Potwierdzony format po dekodowaniu Manchester + +Dekoder wymaga dokładnie 120 bitów: 40 bitów synchronizacji i 80 bitów danych. + +```text +0 40 64 72 80 88 +| 40 × sync (0) | flags 4 B | ID 3 B | P 1 B | T 1 B | sum 1 B | + 4C 90 00 70 2F C8 71 68 49 65 +``` + +- `flags`: 32 bity; znaczenie pól nie jest w pełni znane. +- `ID`: 24 bity; firmware odrzuca 0, `FFFFFF` i duplikaty między kołami. +- `P`: 2,5 kPa/bit. 260 kPa daje 104 = `0x68`. Kwantyzacja jest zaokrąglana + do najbliższego kroku: `(kPa×10 + 12) / 25`. +- `T`: bajt w °F zgodnie z dekoderem, nie °C. 23 °C → 73 °F. +- `sum`: suma dziewięciu poprzednich bajtów modulo 256; to nie CRC-8. +- Wartość `4c900070` występuje we wszystkich 64 rekordach czterech nagrań. + Nie dowodzi to, że każdy czujnik/tryb auta używa zawsze tej wartości. + +## Polaryzacja, preambuła i ogon + +Nagrania i slicer `OOK_PULSE_MANCHESTER_ZEROBIT` potwierdzają G.E.T. Manchester: +`0 → 01`, `1 → 10`. Slicer dopisuje pierwszy zerowy bit. Bufor CC1101 zawiera: + +```text +1 chip startowy + 39 komórek sync + 80 komórek danych + 1 chip OFF dopełnienia += 240 chipów = 30 bajtów, MSB first. +``` + +Ostatni chip dopełnienia jest zerem OOK (cisza). Test sprawdza dokładnie tę +długość, polaryzację i odrzuca ucięty/uszkodony bufor. + +## Timing i powtórzenia + +- Dekoder ma `short_width=123 µs`, `reset_limit=300 µs`. +- Analiza `gfile001` pokazuje typowy okres pulse+gap ok. 236 µs, czyli chip + ok. **118 µs**; szerokości impulsów różnią się od szerokości przerw. Firmware + używa eksperymentalnie **120 µs**, co przechodzi dekodowanie niezależnym + `rtl_433`. Dokładny zegar fizycznego CC1101 wymaga pomiaru HIL. +- Każde z czterech nagrań zawiera **16 poprawnych powtórzeń**. W `gfile001` + odstępy początków dekodowań wahają się ok. 115–172 ms; nie są stałe. +- Domyślne **3 ramki, przerwa 50 ms, cykl 30 s** są eksperymentalnymi + ustawieniami emulatora, a nie potwierdzonym harmonogramem OE. Interwały + ACC/parking również nie mają statusu zgodności z OE. + +## Nośna i modulacja + +Podstawowy profil: **433,92 MHz, ASK/OOK**. Nagrania są zdekodowane przy tej +częstotliwości. README zestawu zawiera też dane produktu 315 MHz i wzmiankę +ASK+FSK; to nie jest dowód FSK w analizowanych plikach ani zgodności z konkretną +Astrą. FSK nie jest dostępny w podstawowym firmware/generatorze. + +## CC1101 packet engine + +Firmware ustawia fixed-length 30 B, normal FIFO, MSB first oraz wyłącza sprzętowe: +preambułę/sync (`SYNC_MODE=0`), Manchester, whitening, FEC, CRC, address check, +append status. Cała preambuła i suma protokołu są w naszych 30 B. Koniec TX jest +oczekiwany przez `MARCSTATE=IDLE` z limitem; `TXFIFO_UNDERFLOW` i pozostałe bajty +są błędem. To zapobiega obcięciu ogona przez samo `TXBYTES=0`. + +Konfiguracja została audytowana, ale syntetyczny CU8 omija CC1101. Brak dodatkowych +bajtów i dokładny ogon trzeba jeszcze potwierdzić na logic analyzer/RTL-SDR w HIL. + +## Niewiadome — nie wolno ich „dostrajać” losowo + +1. Znaczenie poszczególnych bitów `flags`, w tym jakiegokolwiek bitu niskiej + baterii czujnika. **`TPMS_FLAGS_LOWBAT_MASK` nie istnieje w firmware.** +2. Zależność flags od nauki, ruchu, LF i stanu baterii oryginalnego czujnika. +3. Wymagany przez konkretne ECU interwał i minimalna liczba powtórzeń. +4. Zgodność OE 13506028/numera powiązanego z konkretnym egzemplarzem bez VIN, + oznaczeń, odczytu albo testu. +5. Fizyczna dokładność częstotliwości, moc i ogon generowanego CC1101 przed HIL. + +Niskie zasilanie emulatora jest wyłącznie ostrzeżeniem w konsoli i nie zmienia +żadnego pola symulowanego czujnika. diff --git a/docs/SAFETY.md b/docs/SAFETY.md new file mode 100644 index 0000000..cdf7a08 --- /dev/null +++ b/docs/SAFETY.md @@ -0,0 +1,42 @@ +# Bezpieczeństwo i ograniczenia + +## Sztuczne dane mogą ukryć usterkę + +To urządzenie generuje dane, których nie mierzy w oponach. Domyślne 260 kPa jest +wartością testową, nie potwierdzeniem ciśnienia. Symulator może spowodować, że +kontrolka nie ostrzeże o realnym przebiciu, utracie ciśnienia lub uszkodzeniu opony. + +- Projekt wyłącznie diagnostyczno-warsztatowy, na postoju i pod kontrolą osoby + wykonującej test. +- Nie jest homologowanym czujnikiem ani zamiennikiem sprawnego TPMS. +- Nie używaj w jeździe drogowej i nie przedstawiaj jako bezpiecznego do tego celu. +- Przed i po teście sprawdź wszystkie opony niezależnym manometrem oraz ich stan. +- Po diagnozie przywróć sprawne, właściwie dobrane czujniki i wykonaj wymaganą + procedurę pojazdu. + +## Radio i zgodność pojazdu + +Profil EG53MA4/OOK 433,92 MHz jest hipotezą roboczą dla wskazanego pojazdu do +potwierdzenia. OE 13506028, numer powiązany lub oferta zamiennika nie wystarcza. +Użyj VIN, oznaczeń fabrycznych czujników, diagnostyki albo kontrolowanego testu. +Nie nadawaj z maksymalną mocą „dla pewności”. Zacznij od −10 dBm, ogranicz czas +transmisji i przestrzegaj lokalnych przepisów dotyczących 433 MHz oraz ingerencji +w elektronikę pojazdu. Urządzenie może być odbierane przez inne odbiorniki w pobliżu. + +## Montaż + +- Tylko prototyp laboratoryjny jest opisany jako gotowy do złożenia. Wersja 12 V + wymaga osobnego projektu i testów automotive. +- Nie podawaj 12 V na GPIO/ADC ani 5 V na CC1101. +- Nie umieszczaj urządzenia w strefie poduszek, pedałów, ruchomych elementów, + wilgoci, wysokiej temperatury ani przy instalacji LPG. +- Zabezpiecz obudowę i przewody przed poluzowaniem. Unikaj ekranowania anteny. +- Nie używaj 18650 jako rekomendowanego zasilania w kabinie. + +## Diagnostyka bez fałszywej pewności + +Poprawne dekodowanie przez rtl_433 nie dowodzi odbioru przez samochód. Zielone CI +nie zastępuje pomiaru CC1101, testu HIL ani kontroli opon. Zgaśnięcie kontrolki +również nie dowodzi, że opony są sprawne. Zapisuj pomiary i nie zmieniaj wielu +parametrów naraz. Brak potwierdzonego bitu niskiej baterii czujnika; niskie +zasilanie emulatora nie jest kodowane jako usterka symulowanego czujnika. diff --git a/docs/SETUP.md b/docs/SETUP.md new file mode 100644 index 0000000..8ce06a4 --- /dev/null +++ b/docs/SETUP.md @@ -0,0 +1,102 @@ +# Konfiguracja i uruchomienie + +## Przed rozpoczęciem + +1. Sprawdź zgodność konkretnego auta (VIN, oznaczenia czujników, diagnostyka lub + odbiór). Nie polegaj wyłącznie na numerze z ogłoszenia. +2. Zmontuj prototyp z `HARDWARE.md`, wgraj firmware i otwórz UART 115200. +3. Wpisz `stay 300`. `info` pokazuje konfigurację aktywną, nie tylko zapisaną. +4. Pracuj na postoju. Sztuczne 260 kPa nie opisuje rzeczywistych opon. + +Koła: `1=FL` przód lewy, `2=FR` przód prawy, `3=RR` tył prawy, `4=RL` tył lewy. +Komendy konfiguracyjne automatycznie zapisują NVS i weryfikują odczyt. Błąd NVS +trzeba rozwiązać przed dalszym testem, nie ignorować. + +## Ścieżka A — Clone IDs (preferowana) + +Użyj jej, jeśli wcześniej odczytano oryginalne ID i auto nadal je zna. + +1. Zapisz cztery ID w postaci sześciu cyfr hex. +2. Wpisz kolejno (przykładowe wartości zastąp własnymi): + + ```text + id 1 2FC871 + id 2 2EAAF9 + id 3 3495AC + id 4 2FC780 + pressure all 260 + info + ``` + +3. Sprawdź w `info`, że wszystkie ID i przypisania kół są właściwe. Duplikat, + `000000`, `FFFFFF` lub wartość poza 24 bitami zostanie odrzucona. +4. Opcjonalnie `send` wymusi cykl wszystkich kół. W NORMAL urządzenie robi to + również automatycznie; po restarcie konfiguracja pozostaje. +5. Potwierdź odbiór zewnętrznie. Znane ID **mogą** wyeliminować naukę, ale nie + obiecujemy tego dla każdego stanu ECU. + +Nie używaj przykładowych ID w pojeździe, jeśli mogą pokrywać się z innym +urządzeniem w pobliżu. + +## Ścieżka B — New IDs + LEARN + +### Przygotowanie + +1. `ids new` generuje cztery unikalne ID. Można zamiast tego użyć czterech `id`. +2. `info` — zapisz ID na kartce. +3. Zapoznaj się z procedurą nauki dla konkretnej wersji nadwozia/wyposażenia. + Ten dokument nie zgaduje menu, sekwencji pedałów ani położenia odbiornika. +4. Rozpocznij procedurę nauki w aucie zgodnie z instrukcją serwisową. + +### Nauka z konsoli + +1. `mode learn` — start od FL; tylko FL nadaje co 2 s. +2. `send` — natychmiastowy burst FL, bez zmiany koła. +3. Po wykonaniu kroku dla FL: `next` — FR; LED wskaże 2 mrugnięcia. +4. Powtórz `send`, potem `next` — RR, następnie `next` — RL. +5. Po ostatnim `next` urządzenie wraca do NORMAL. Kolejność to zawsze + **FL → FR → RR → RL**. +6. Zakończ procedurę auta zgodnie z jej instrukcją i sprawdź odczyt diagnostyczny. + +### Nauka jednym przyciskiem + +- wejście: przytrzymaj ≥1,5 s; +- krótkie naciśnięcie: następne koło i natychmiastowy burst; +- wymuszenie bez zmiany koła: konsola `send`; +- wyjście przed końcem: ponownie ≥1,5 s albo `mode normal`. + +Timeout 60 s na koło przerywa LEARN do NORMAL; limit całej sesji to 15 min. +Nie jest to automatyczny sukces nauki — trzeba zacząć od właściwego koła ponownie. + +## SINGLE / diagnostyka + +`mode single 2` nadaje tylko FR co 2 s. `send` wymusza FR, `next` przechodzi dalej. +`mode normal` kończy; automatyczny limit wynosi 5 min. Tryb nie zapisuje wyboru +koła w NVS i po utracie zasilania startuje bezpiecznie w NORMAL. + +## Pozostałe ustawienia + +| Komenda | Zakres / skutek | +|---|---| +| `pressure all 260` | 0–637,5 kPa, kwantyzacja 2,5 kPa | +| `temp all 23` | −40…85 °C; w ramce °F | +| `interval normal 30` | interwał bez ACC, 5–86400 s | +| `interval ignition 30` | z aktywnym sprzętowym ACC | +| `interval parking 120` | bez aktywnego ACC | +| `rf freq 433.92` | 433,05–434,79 MHz; zmiana wymaga uzasadnienia | +| `rf power -10` | −30, −20, −15, −10, −6, 0, 5 dBm | +| `rf burst 3` | 1–8 ramek na koło | +| `rf gap 50` | 20–500 ms między ramkami | +| `flags 4C900070` | eksperyment; znaczenie bitów nie jest znane | +| `factory YES` | kasuje własną konfigurację i przywraca domyślną | + +Parametry harmonogramu są eksperymentalne. Moc zaczyna się od −10 dBm; zwiększaj +tylko po pomiarze i z uwzględnieniem przepisów. Niski poziom zasilania emulatora +nie ustawia żadnej flagi czujnika. + +## Po restarcie lub brownout + +Firmware ponownie czyta NVS. Poprawna wersja/CRC i zakresy są wymagane. Uszkodzony +lub niezgodny wpis powoduje komunikat i powrót do domyślnych, a nie wysyłanie +częściowo uszkodzonej konfiguracji. Każdy deep sleep ma budzik; nie ma trybu +`PARKING_SHUTDOWN`, który mógłby zostawić auto bez transmisji do ręcznego wybudzenia. diff --git a/docs/TROUBLESHOOTING.md b/docs/TROUBLESHOOTING.md new file mode 100644 index 0000000..b36b92a --- /dev/null +++ b/docs/TROUBLESHOOTING.md @@ -0,0 +1,37 @@ +# Rozwiązywanie problemów + +Pracuj po jednej zmianie i zapisuj pomiar. Nie przełączaj losowo OOK/FSK, flags, +ID ani interwałów. Podstawowy firmware nie ma trybu FSK. + +| Objaw | Możliwa przyczyna | Pomiar / sprawdzenie | Naprawa | +|---|---|---|---| +| `BLAD: brak CC1101` | złe zasilanie, CS/SPI, moduł nie 433 MHz | 3,3 V na VCC-GND; ciągłość 18/19/23/5; oznaczenie modułu | popraw okablowanie, skróć SPI, użyj właściwego modułu | +| Reset przy TX | spadek 3,3 V, słabe przewody | napięcie przy ESP32/CC1101 podczas `send`, log brownout | popraw zasilacz i 47–100 µF przy module; nie zwiększaj PA | +| `TX-ERR` | underflow, niezakończony TX, zła konfiguracja CC1101 | log dla każdego koła; MARCSTATE/rejestry w HIL | sprawdź SPI i zasilanie; zapisz log do analizy, nie maskuj błędu | +| UART nie odpowiada | za krótkie okno konsoli, zły baud/port | 115200 8N1, reset, właściwy /dev/ttyUSB | wpisz `stay 300` od razu po starcie | +| Zmiana ID znika | błąd zapisu NVS, pełny flash | komunikat `OK: zapisano`, restart i `info` | nie kontynuuj przy błędzie NVS; sprawdź flash/zasilanie | +| ID odrzucone | duplikat, 0, FFFFFF, zła długość | sześć cyfr hex i `info` | nadaj cztery unikalne ID z 000001–FFFFFE | +| rtl_433 nic nie dekoduje | antena, częstotliwość, zły tor RF, zbyt mała moc | `send 1`; odbiornik 433,92 MHz blisko; pomiar ANT/GDO0 | popraw antenę/zasilanie; stopniowo testuj niskie moce; nie zmieniaj na FSK | +| rtl_433 widzi złe dane | stara konfiguracja, sąsiedni czujnik | `info`, `hex 1`, filtrowanie ID w odbiorniku | porównaj ID i wymuś `send 1` w izolowanym miejscu | +| Auto nie widzi znanych ID | niepotwierdzony profil, ECU wymaga nauki, zasięg | VIN/oznaczenia/DTC; odbiór RTL-SDR przy aucie | potwierdź profil; wykonaj LEARN; zmień położenie po pomiarze | +| LEARN stoi na jednym kole | użyto `send` zamiast `next` | `info` pokazuje aktywne koło | `next` po potwierdzeniu kroku; `send` tylko wymusza TX | +| LEARN wróciło do NORMAL | 60 s na kole / 15 min sesji | czas od wejścia, komunikat i LED | uruchom `mode learn 1` i powtórz świadomie od FL | +| Po RL nie ma następnego koła | sekwencja została zakończona | NORMAL w `info` | zakończ procedurę auta i sprawdź DTC | +| Kontrolka nie gaśnie mimo RTL-SDR OK | ECU nie zna ID, inny profil/flags/procedura | odczyt ID i DTC z diagnostyki, nie tylko SDR | Clone IDs albo LEARN; potwierdź profil auta; nie zgaduj flags | +| Pobór snu duży | DevKit, regulator, LED, dzielniki | pomiar całej płytki wg `POWER.md` | goły moduł i właściwy zasilacz; nie zmieniaj protokołu | +| Po postoju brak TX | brownout, zasilanie, błąd NVS/CC1101 | log po restarcie, `batt`, `info`, budzik RTC | popraw zasilanie; każdy sen ma RTC, więc nie „naprawiaj” przez PARKING_SHUTDOWN | +| ACC nie zmienia interwału | funkcja domyślnie wyłączona lub zły próg | `PIN_ACC`, napięcie na GPIO OFF/ON | zmontuj zabezpieczone wejście; nigdy 12 V na GPIO | + +## Gdy brak odbioru w samochodzie + +Kolejność diagnostyczna: + +1. **Udowodnij lokalny TX:** `send 1` + RTL-SDR/analizator. +2. **Udowodnij właściwy profil:** VIN, oznaczenia czujników, odczyt auta. +3. **Sprawdź ID i kolejność:** `info`, Clone IDs albo jeden aktywny w LEARN. +4. **Sprawdź zasięg:** niska moc najpierw, konsola/za schowkiem, ewentualnie + bagażnik; bez demontażu poduszek i zgadywania lokalizacji ECU. +5. **Dopiero analizuj flags:** porównaj z nagraniem oryginalnego czujnika tego + samego trybu. Brak potwierdzonego bitu low battery — nie ustawiaj go. +6. Jeśli nie ma pomiaru lub danych, zatrzymaj test. Losowe zmiany tworzą nowe + zmienne i nie stanowią diagnozy. diff --git a/docs/VALIDATION.md b/docs/VALIDATION.md new file mode 100644 index 0000000..8a50b57 --- /dev/null +++ b/docs/VALIDATION.md @@ -0,0 +1,125 @@ +# Walidacja + +## Jedno polecenie bez sprzętu + +```bash +bash tools/check_all +``` + +Skrypt wykonuje self-test Pythona, testy native, pełny build ESP32, cppcheck, +pobranie przypiętych źródeł (przy pierwszym uruchomieniu) oraz dekodowanie CU8 +przez prawdziwy `rtl_433`. Logi: `artifacts/validation/`. Każdy etap ma `pipefail`, +a błąd kończy skrypt kodem niezerowym. + +Alternatywa reprodukowalna: + +```bash +docker build -t tpms-rc . +docker run --rm -v "$PWD/artifacts:/work/artifacts" tpms-rc +``` + +## Wyniki z 2026-10-27 + +Środowisko: Linux, Python 3.14.4 przy teście hosta; PlatformIO 6.1.18; +espressif32 8.0.0; Arduino ESP32 3.3.12; SmartRC CC1101 commit +`de6757ef633b3e626dae5c7835cdb66ab53f9a1d`; rtl_433 commit `406f9a3…`; +rtl_433_tests commit `1aa8c29…`. Pełne SHA znajdują się w `PROTOCOL.md`. + +| Komenda | Wynik | +|---|---| +| `pio test -e native` | **20/20 PASS** — ramka, cztery niezależne wektory, negatywne, NVS, fake clock/radio, Clone IDs, LEARN, SINGLE, ACC, restart | +| `pio run -e esp32dev` | **PASS**, własne ostrzeżenia traktowane jako błędy (`-Werror`) | +| `pio check -e native ... --fail-on-defect=low` | **PASS**, 0 defektów po poprawce inicjalizacji struktur | +| `python3 tools/tpms_frame.py --self-test` | **PASS**, nagranie + 500 ramek | +| `tools/verify_rtl433.sh` | **PASS**, 64/64 rekordy referencyjne; 3/3 syntetyczne; 3/3 negatywne odrzucone | +| `git diff --check` | **PASS** | +| dwa czyste `tools/package_release.sh` | **PASS**, identyczne wszystkie 6 SHA-256 po ustawieniu `SOURCE_DATE_EPOCH=1761600000` | + +Dane referencyjne: każdy z `gfile001`…`gfile004` dał dokładnie 16 zgodnych +rekordów, z oczekiwanym ID/flags/ciśnieniem/temperaturą. Syntetyczne ramki +2FC871/260 kPa/73 F, 3495AC/220 kPa/23 F i ABCDEE/262,5 kPa/75 F zostały +zdekodowane przez niezależny `rtl_433`. Uszkodzony Manchester, zła suma i ucięcie +nie dały rekordu EG53MA4. + +## Macierz pokrycia + +| Warstwa | Automatyczne | RTL-SDR fizyczny | CC1101 fizyczny | Samochód | +|---|---|---|---|---| +| pola, checksum, kwantyzacja | wykonane | niepotrzebne do pola | niepotrzebne | potwierdzenie interpretacji ECU | +| Manchester/preambuła/długość | wykonane | **niewykonane** | **niewykonane** | niewykonane | +| prawdziwe nagrania → rtl_433 | wykonane, 64/64 | nie dotyczy | nie dotyczy | nie dotyczy | +| syntetyczne CU8 → rtl_433 | wykonane | nie dotyczy | omija hardware | nie dotyczy | +| rejestry CC1101/ogon/moc/częstotliwość | audyt kodu | wymagane | **wymagane** | wymagane | +| NVS, ID, interwały, tryby | wykonane; NVS emulowane blobem | wymagany test restartu | wymagany | wymagany | +| LEARN FL→FR→RR→RL | state-machine PASS | pomocnicze | wymagane | **niewykonane** | +| pobór/brownout/ACC | state-machine ACC; brak pomiarów | nie dotyczy | wymagane | wymagane | + +**Brak podstaw do oznaczenia „validated”.** Gitea Actions ma workflow, ale stan +runnera i wynik zdalnego CI należy sprawdzić; lokalny PASS nie jest udawanym CI. + +## Checklista HIL — wymaga użytkownika i sprzętu + +### CC1101 + analizator/RTL-SDR + +- [ ] Odczytać rejestry po inicjalizacji: OOK, 433,92 MHz, fixed 30 B, + `SYNC_MODE=0`, brak CRC/Manchester/whitening/FEC/append. +- [ ] Na GDO0/ANT potwierdzić dokładnie 30 B, chip ~120 µs, pełny ostatni chip + i brak sprzętowej preambuły/sync/CRC/dodatkowych bajtów. +- [ ] Zanotować TX-ERR/underflow; przy prawidłowym torze ma ich nie być. +- [ ] Zmierzyć częstotliwość i względną moc dla −10 dBm; nie zakładać kalibracji + taniego modułu. Nie zwiększać PA bez potrzeby. +- [ ] `send 1`…`send 4`: RTL-SDR dekoduje właściwe ID, 260 kPa i flags. +- [ ] Powtórzyć po resecie i 10 cyklach deep sleep. + +### NVS i wejścia + +- [ ] Ustawić własne ID/ciśnienia/RF, odłączyć zasilanie na >1 min, ponownie + sprawdzić `info` i transmisję. +- [ ] Sprawdzić odrzucenie duplikatu ID, złej mocy i złego interwału. +- [ ] `factory YES` przywraca 260 kPa i domyślne RF. +- [ ] Brownout/crank na zabezpieczonym zasilaczu: brak zawieszenia i uszkodzenia + konfiguracji; zapis wykonywać tylko po stabilizacji zasilania. +- [ ] Jeśli ACC jest montowane: zmierzyć napięcie na GPIO dla OFF/ON/przepięcia, + sprawdzić interwały i samoczynne wznowienie po ACC ON. Bez ACC pominąć. + +### Konkretny Opel Astra J + +- [ ] Potwierdzić profil przez VIN/oznaczenia/diagnostykę przed nadawaniem. +- [ ] Clone IDs: odbiór czterech znanych ID bez zakładania, że nauka zniknie. +- [ ] New IDs: pełna nauka FL→FR→RR→RL z jednym aktywnym kołem. +- [ ] Odczyt DTC i danych TPMS przed/po; zapisać wersję ECU i procedurę. +- [ ] Test położenia: konsola środkowa/za schowkiem, ewentualnie bagażnik; + na postoju, bez zgadywania lokalizacji odbiornika. +- [ ] Kontrola manometrem wszystkich opon przed i po. Nie wykonywać testu jako + jazdy drogowej z symulatorem zamiast sprawnego TPMS. + +## Artefakty i wgrywanie + +```bash +bash tools/package_release.sh +``` + +Katalog `artifacts/release/`: + +| Plik | Adres | +|---|---:| +| `bootloader.bin` | `0x1000` | +| `partitions.bin` | `0x8000` | +| `boot_app0.bin` | `0xE000` | +| `firmware.bin` | `0x10000` | +| `firmware-full.bin` | `0x0` — pełny obraz 4 MB | +| `firmware.elf` | debug/symbole, nie wgrywać jako flash | +| `SHA256SUMS`, `BUILD-INFO.txt` | kontrola integralności i wersji | + +Pełny obraz kasuje poprzedni flash przy zapisie całego obszaru; NVS w partycji +może zostać utracone — zapisz ID przed aktualizacją pełnym obrazem. Aktualizacja +samej aplikacji `firmware.bin` pod `0x10000` zwykle zachowuje NVS, ale przed +release użytkownik powinien wykonać test na własnym module. + +```bash +PORT=/dev/ttyUSB0 bash tools/flash_release.sh +sha256sum -c artifacts/release/SHA256SUMS +``` + +Nie wgrywaj obrazu z innego toolchaina na ślepo. RC nie zawiera fizycznego testu +update ani samochodu. -- 2.54.1 From 046c6dc26a41e0305fff72c39dd3b51e4c3c506c Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:17:27 +0000 Subject: [PATCH 17/19] Dokumentacja RC: Quick Start bezpieczenstwo hardware i HIL -- 2.54.1 From edc6fb1f5f2a60e54cea68a22a20bb8bda8c945a Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:17:38 +0000 Subject: [PATCH 18/19] Dokumentacja RC: setup bezpieczenstwo protokol walidacja i release -- 2.54.1 From 84078a914f0fb47b60940793cfa32db77b26688f Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 18:18:08 +0000 Subject: [PATCH 19/19] Testy: synchronizuj pelne scenariusze state-machine --- test/test_app_state/test_app_state.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/test/test_app_state/test_app_state.cpp b/test/test_app_state/test_app_state.cpp index 097aa49..8948f7c 100644 --- a/test/test_app_state/test_app_state.cpp +++ b/test/test_app_state/test_app_state.cpp @@ -22,7 +22,7 @@ static void test_normal_clone_ids_sends_four_wheels_and_repeats(void) { settings_t cfg; settings_defaults(&cfg); - cfg.wheels[0].id = 0x111111u; + cfg.wheels[0].id = 0x111111u; /* Clone IDs: konfiguracja bez nauki. */ FakeRadio radio; AppState app(&cfg, &radio); app.begin(0u); @@ -48,7 +48,7 @@ static void test_new_ids_learn_order_force_and_finish(void) TEST_ASSERT_EQUAL(AppMode::LEARN, app.mode()); TEST_ASSERT_EQUAL_UINT8(1u, radio.count); TEST_ASSERT_EQUAL_UINT8(WHEEL_FL, radio.wheels[0]); - TEST_ASSERT_TRUE(app.send_current()); + TEST_ASSERT_TRUE(app.send_current()); /* wymuszenie bez zmiany kola */ TEST_ASSERT_EQUAL_UINT8(2u, radio.count); app.short_press(100u); TEST_ASSERT_EQUAL_UINT8(WHEEL_FR, app.active_wheel()); @@ -77,7 +77,7 @@ static void test_learn_period_window_and_total_timeout(void) TEST_ASSERT_EQUAL(AppMode::LEARN, app.mode()); app.tick(60000u, false); TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode()); - TEST_ASSERT_EQUAL_UINT8(3u, radio.count); + TEST_ASSERT_EQUAL_UINT8(3u, radio.count); /* timeout nie nadaje nowej ramki */ app.set_mode(AppMode::LEARN, WHEEL_FL, 100000u); app.tick(1000000u, false); @@ -118,7 +118,7 @@ static void test_button_gestures(void) app.very_long_press(30u); TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode()); app.short_press(40u); - TEST_ASSERT_EQUAL_UINT8(6u, radio.count); + TEST_ASSERT_EQUAL_UINT8(6u, radio.count); /* LEARN + SINGLE + 4 koła NORMAL */ } static void test_acc_intervals_without_permanent_shutdown(void) @@ -179,7 +179,7 @@ static void test_millis_wrap_does_not_stall_learn(void) FakeRadio radio; AppState app(&cfg, &radio); app.set_mode(AppMode::LEARN, WHEEL_FL, UINT32_MAX - 1000u); - app.tick(1000u, false); + app.tick(1000u, false); /* uplynely 2001 ms po zawinieciu */ TEST_ASSERT_EQUAL_UINT8(2u, radio.count); } -- 2.54.1