From 9b30351779da1f739cf09208ddae16086e3926f5 Mon Sep 17 00:00:00 2001 From: czcionka Date: Tue, 27 Oct 2026 06:09:18 +0000 Subject: [PATCH] Symulator 4 czujnikow TPMS Schrader EG53MA4 (ESP32 + CC1101) Firmware symulujacy 4 czujniki TPMS dla Opla Astry J Sedan 2016 (EU, protokol Schrader EG53MA4, 433.92 MHz, Manchester G.E.T. MC). Tryby NORMAL/LEARN/SINGLE, deep sleep, konsola szeregowa. Weryfikacja: rtl_433 + testy natywne + kompilacja ESP32. PROJEKT DIAGNOSTYCZNY/TESTOWY - symulator generuje sztuczne dane cisnienia i nie zastepuje prawdziwych czujnikow TPMS. --- .gitignore | 6 + README.md | 620 +++++++++++++++++++++++ platformio.ini | 34 ++ src/app.h | 40 ++ src/config.h | 173 +++++++ src/console.cpp | 190 +++++++ src/console.h | 18 + src/main.cpp | 476 +++++++++++++++++ src/power.cpp | 98 ++++ src/power.h | 36 ++ src/radio.cpp | 137 +++++ src/radio.h | 32 ++ src/tpms_frame.cpp | 97 ++++ src/tpms_frame.h | 61 +++ src/ui.cpp | 143 ++++++ src/ui.h | 45 ++ test/test_tpms_frame/test_tpms_frame.cpp | 128 +++++ tools/gen_cu8.py | 95 ++++ tools/tpms_frame.py | 238 +++++++++ tools/verify_rtl433.sh | 91 ++++ 20 files changed, 2758 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 platformio.ini create mode 100644 src/app.h create mode 100644 src/config.h create mode 100644 src/console.cpp create mode 100644 src/console.h create mode 100644 src/main.cpp create mode 100644 src/power.cpp create mode 100644 src/power.h create mode 100644 src/radio.cpp create mode 100644 src/radio.h create mode 100644 src/tpms_frame.cpp create mode 100644 src/tpms_frame.h create mode 100644 src/ui.cpp create mode 100644 src/ui.h create mode 100644 test/test_tpms_frame/test_tpms_frame.cpp create mode 100755 tools/gen_cu8.py create mode 100755 tools/tpms_frame.py create mode 100755 tools/verify_rtl433.sh diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5d17f68 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +.pio/ +.vscode/ +*.o +*.elf +*.bin +__pycache__/ diff --git a/README.md b/README.md new file mode 100644 index 0000000..c339da4 --- /dev/null +++ b/README.md @@ -0,0 +1,620 @@ +# Symulator 4 czujników 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**). + +> ## ⚠️ 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. + +--- + +## 1. Spis treści + +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](#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) + +--- + +## 2. Jak to działa + +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 +``` + +Referencje protokołu (źródła, na których oparto kod): + +* `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 + +--- + +## 4. Kompilacja + +### PlatformIO (zalecane) + +```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) +``` + +Biblioteka CC1101 (`SmartRC-CC1101-Driver-Lib`, dawniej +`ELECHOUSE_CC1101_SRC_DRV`) jest pobierana automatycznie z `platformio.ini`. +Kod obsługuje zarówno API 3.x (`setSpiPin`), jak i klasyczne 1.x/2.x +(`setSCK`/`setMISO`/...), patrz `src/radio.cpp`. + +### arduino-cli (alternatywa) + +```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 . . +``` + +(Utwórz folder `src/` jako szkic albo użyj `--build-property` z +`build.extra_flags`; najwygodniej jednak otworzyć katalog w PlatformIO.) + +### Weryfikacja bez sprzętu (opcjonalna) + +```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 +``` + +`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: + +``` +== 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 +``` + +--- + +## 5. (a) Okablowanie + +| 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,3 V (100 kΩ / 33 kΩ), stan spoczynkowy niski; bez: `PIN_ACC -1` | +| Pomiar napięcia | GPIO34 | węzeł środkowy dzielnika `R1=100 kΩ / R2=33 kΩ` (ADC1) | + +Zasilanie (wybór w `config.h`, `POWER_SUPPLY_MODE`): + +``` + POWER_12V (na stałe z akumulatora): + +12 V (bezpiecznik 1 A) ── buck o Iq < 20 µA (np. TPS62740, Iq ≈ 0,4 µA) + ── 3,3 V ── ESP32 + CC1101 + opcjonalnie LDO o niskim Iq (np. MCP1700, HT7333) jeśli pobór prądu + w transmisji mieści się w zakresie LDO (do ~250 mA). + + POWER_BATTERY (ogniwo 3,3–4,2 V, np. Li-SOCl2): + ogniwo ── 3V3 (bez przetwornicy). Uwaga: ESP32 wymaga ≥ 3,0 V pod obciążeniem. +``` + +``` + +12V ──[bezpiecznik]──> buck IN + Pomiar: +12V ──[R1 100k]──+── GPIO34 + └──[R2 33k]── GND +``` + +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 / SINGLE | +|--------------------------|--------------------------|--------------------------| +| krótkie naciśnięcie | natychmiast burst 4 kół | **następne koło** | +| długie (≥1,5 s) | wejście do **LEARN** | wyjście do NORMAL | +| bardzo długie (≥4 s) | wejście do **SINGLE** | wyjście do NORMAL | + +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 + buck TPS62740 (Iq ≈ 0,4 µA) + lub LDO MCP1700/HT7333. +* 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). + +--- + +## 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 ~12 µA (ESP32 ~10 µA + CC1101 +< 1 µA + buck TPS62740 ~0,4 µA). + +**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 (12 µA × 25 s) | 25 s | 0,08 µAh | +| **Razem** | | **≈ 34 µAh/cykl** | + +* **Dobowy pobór: 34 µAh × 2880 ≈ 98 mAh/dobę → średnio ≈ 4 mA** + (przy 3,3 V ≈ 13 mW). +* Przy zasilaniu 12 V przez buck (sprawność ~90%): **≈ 27 mAh/dobę + z akumulatora** (średnio ≈ 1,1 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 / 27 mAh ≈ **1100 dni ≈ 3 lata** — 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:** + +| Interwał | Średni prąd (3,3 V) | Dobowy pobór (12 V) | 60 Ah (30 Ah użyteczne) | +|----------|--------------------|--------------------|--------------------------| +| 30 s | ~4 mA | ~27 mAh/dobę | ~3 lata* | +| 120 s (parking) | ~1,2 mA | ~8 mAh/dobę | ~10 lat* | +| 300 s | ~0,5 mA | ~3,5 mAh/dobę | ogranicza samorozładowanie | + +\* przed samorozładowaniem akumulatora. + +**Wariant bateryjny** (Li-SOCl2 3,6 V 2400 mAh): ~98 mAh/dobę przy 30 s +to ok. **25 dni** — do zasilania bateryjnego stosuj dłuższe interwały +(300 s → ok. 150 dni) albo mniejszą liczbę ramek w burście +(`TX_BURST_FRAMES 2`), lub tryb `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 (stan trybów przetrwuje deep sleep). +* Firmware testowany z: PlatformIO `espressif32`, Arduino core ESP32, + `SmartRC-CC1101-Driver-Lib 3.x` (kompatybilny z 1.x/2.x), rtl_433 (master). + +**Pamiętaj: symulator generuje sztuczne dane ciśnienia i nie zastępuje +prawdziwych czujników TPMS.** diff --git a/platformio.ini b/platformio.ini new file mode 100644 index 0000000..aab7c7f --- /dev/null +++ b/platformio.ini @@ -0,0 +1,34 @@ +; PlatformIO - symulator czujnikow TPMS Schrader EG53MA4 (ESP32 + CC1101) +; +; Kompilacja: pio run -e esp32dev +; Testy: pio test -e native +; Upload: pio run -e esp32dev -t upload +; Monitor: pio device monitor +; +; Zastrzezenie: projekt diagnostyczny/testowy - symulator generuje +; sztuczne dane cisnienia, nie zastepuje prawdziwych czujnikow TPMS. + +[platformio] +default_envs = esp32dev + +[env:esp32dev] +platform = espressif32 +board = esp32dev +framework = arduino +monitor_speed = 115200 +; Biblioteka CC1101 (ELECHOUSE_CC1101_SRC_DRV / SmartRC): +; wersja 3.x udostepnia naglowek zgodnosciowy ELECHOUSE_CC1101_SRC_DRV.h, +; kod obsluguje tez API 1.x/2.x (patrz src/radio.cpp). +lib_deps = + https://github.com/LSatan/SmartRC-CC1101-Driver-Lib.git +build_flags = + -Wall + -Wextra + +[env:native] +; Testy jednostkowe generatora ramek (bez sprzetu) +platform = native +build_flags = -std=gnu++17 -Wall +build_src_filter = -<*> + +test_build_src = true +test_framework = unity diff --git a/src/app.h b/src/app.h new file mode 100644 index 0000000..17377f3 --- /dev/null +++ b/src/app.h @@ -0,0 +1,40 @@ +/* + * app.h - API aplikacji (tryby pracy) uzywane przez konsole i maszyne stanow + */ +#ifndef TPMS_APP_H +#define TPMS_APP_H + +#include + +#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); + +void app_print_info(void); +void app_print_frame(uint8_t wheel); + +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 new file mode 100644 index 0000000..1465c18 --- /dev/null +++ b/src/config.h @@ -0,0 +1,173 @@ +/* + * 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. + */ +#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 + +/* ====================================================================== + * 1. ZASILANIE + * POWER_12V - stale zasilanie z akumulatora 12 V przez buck/ LDO + * o niskim pradzie spoczynkowym (np. TPS62740, Iq < 1 uA) + * POWER_BATTERY - ogniwo 3.3-4.2 V (Li-SOCl2 / LiPo) bez przetwornicy + * ====================================================================== */ +#define POWER_SUPPLY_MODE POWER_12V +#define POWER_12V 1 +#define POWER_BATTERY 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 + +/* 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) + +/* LED statusowy (rezystor szeregowy 330R, aktywny wysoki). */ +#define PIN_LED 27 + +/* 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 + +/* Opcjonalny sygnal zaplonu / ACC (dzielnik 12 V -> 3.3 V). -1 = brak. */ +#define PIN_ACC 32 + +/* Pomiar napiecia zasilania: dzielnik R1(gora)/R2(dol) na pin ADC1. + * Uwaga: GPIO34/35/32/33 = ADC1, mozliwe rowniez jako wejscia EXT. */ +#define PIN_VBAT_ADC 34 +#define VBAT_DIVIDER_R1 100000.0f // ohm, gora (do zasilania) +#define VBAT_DIVIDER_R2 33000.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 */ diff --git a/src/console.cpp b/src/console.cpp new file mode 100644 index 0000000..0f29d08 --- /dev/null +++ b/src/console.cpp @@ -0,0 +1,190 @@ +/* + * 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 - pomiar napiecia 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 + */ +#include +#include +#include + +#include "config.h" +#include "app.h" +#include "console.h" + +static char line[64]; +static uint8_t line_len = 0; + +static void cmd_help(void) +{ + 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")); +} + +static int parse_wheel(const char *arg, uint8_t *wheel) +{ + if (arg == NULL) { + return -1; + } + if (strcmp(arg, "all") == 0) { + *wheel = 0xFF; + return 0; + } + long n = strtol(arg, NULL, 10); + if (n < 1 || n > WHEEL_COUNT) { + return -1; + } + *wheel = (uint8_t)(n - 1); + return 0; +} + +static void handle_line(char *s) +{ + char *cmd = strtok(s, " \t"); + if (cmd == NULL) { + return; + } + char *arg1 = strtok(NULL, " \t"); + char *arg2 = strtok(NULL, " \t"); + + if (strcmp(cmd, "help") == 0) { + cmd_help(); + } + else if (strcmp(cmd, "info") == 0 || strcmp(cmd, "config") == 0) { + app_print_info(); + } + else if (strcmp(cmd, "hex") == 0) { + uint8_t w; + if (parse_wheel(arg1, &w) != 0) { + w = 0xFF; + } + if (w == 0xFF) { + for (uint8_t i = 0; i < WHEEL_COUNT; i++) { + app_print_frame(i); + } + } + else { + app_print_frame(w); + } + } + else if (strcmp(cmd, "send") == 0) { + uint8_t w; + if (parse_wheel(arg1, &w) != 0) { + w = 0xFF; + } + if (w == 0xFF) { + app_send_burst_all(); + } + else { + app_send_burst_wheel(w); + } + Serial.println(F("OK")); + } + 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("mode normal|learn|single [n]")); + return; + } + if (strcmp(arg1, "normal") == 0) { + app_set_mode(APP_MODE_NORMAL, 0); + } + else if (strcmp(arg1, "learn") == 0) { + if (arg2 != NULL) { + if (parse_wheel(arg2, &w) != 0) { + w = 0; + } + } + 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("single wymaga numeru kola 1-4")); + return; + } + app_set_mode(APP_MODE_SINGLE, w); + } + else { + Serial.println(F("mode normal|learn|single [n]")); + return; + } + Serial.println(F("OK")); + } + else if (strcmp(cmd, "interval") == 0) { + if (arg1 == NULL) { + Serial.println(F("interval ")); + return; + } + app_set_interval((uint32_t)strtoul(arg1, NULL, 10)); + Serial.println(F("OK")); + } + else if (strcmp(cmd, "flags") == 0) { + if (arg1 == NULL) { + Serial.println(F("flags ")); + return; + } + app_set_flags((uint32_t)strtoul(arg1, NULL, 16)); + Serial.println(F("OK")); + } + else if (strcmp(cmd, "sleep") == 0) { + app_request_sleep(); + } + else if (strcmp(cmd, "stay") == 0) { + app_stay_awake(arg1 ? (uint32_t)strtoul(arg1, NULL, 10) * 1000u : 60000u); + Serial.println(F("OK")); + } + else { + Serial.println(F("Nieznana komenda - 'help'")); + } +} + +void console_init(void) +{ + line_len = 0; +} + +void console_poll(void) +{ + while (Serial.available() > 0) { + char c = (char)Serial.read(); + if (c == '\r' || c == '\n') { + if (line_len > 0) { + line[line_len] = '\0'; + handle_line(line); + line_len = 0; + } + } + else if (line_len < sizeof(line) - 1u) { + line[line_len++] = c; + } + else { + line_len = 0; // przepełnienie - porzuc linie + } + } +} diff --git a/src/console.h b/src/console.h new file mode 100644 index 0000000..2c18808 --- /dev/null +++ b/src/console.h @@ -0,0 +1,18 @@ +/* + * console.h - debugowa konsola szeregowa (bez String, stalobuforowa) + */ +#ifndef TPMS_CONSOLE_H +#define TPMS_CONSOLE_H + +#ifdef __cplusplus +extern "C" { +#endif + +void console_init(void); +void console_poll(void); // nieblokujaca obsluga linii - wywolywac w petli + +#ifdef __cplusplus +} +#endif + +#endif /* TPMS_CONSOLE_H */ diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..323181d --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,476 @@ +/* + * 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). + */ +#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" + +/* ------------------------------------------------------------------ */ +/* Dane czujnikow (mapowanie ID -> kolo) */ +/* ------------------------------------------------------------------ */ +#define KPA10(x) ((uint16_t)((x) * 10.0f + 0.5f)) + +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) */ +/* ------------------------------------------------------------------ */ +#define RTC_MAGIC 0x54504D53u // 'TPMS' + +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; // indeks w LEARN_SEQ +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; + +/* ------------------------------------------------------------------ */ +/* Pomocnicze */ +/* ------------------------------------------------------------------ */ +static uint8_t active_wheel(void) +{ + return LEARN_SEQ[rtc_seq_idx % WHEEL_COUNT]; +} + +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); + radio_send_burst(frame, TPMS_TX_BYTES, TX_BURST_FRAMES); + Serial.printf("TX %s id=%06X %.1f kPa %d C flags=%08X%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" : ""); +} + +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)(rtc_interval_s ? rtc_interval_s : TX_INTERVAL_S), + (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; +} + +void app_stay_awake(uint32_t ms) +{ + uint32_t until = millis() + ms; + if ((int32_t)(until - stay_awake_until) > 0) { + stay_awake_until = until; + } +} + +uint8_t app_mode(void) +{ + return rtc_mode; +} + +uint8_t app_wheel(void) +{ + return active_wheel(); +} + +void app_next_wheel(void) +{ + rtc_seq_idx = (uint8_t)((rtc_seq_idx + 1) % WHEEL_COUNT); + ui_blink_count((uint8_t)(rtc_seq_idx + 1)); + Serial.printf("Kolo: %s (learn: %d/%d)\n", SENSOR[active_wheel()].name, + (int)rtc_seq_idx + 1, WHEEL_COUNT); + learn_window_start = millis(); +} + +void app_set_mode(uint8_t mode, uint8_t wheel) +{ + rtc_mode = mode; + switch (mode) { + case APP_MODE_LEARN: + rtc_seq_idx = (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)(rtc_seq_idx + 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_seq_idx = (uint8_t)(wheel % WHEEL_COUNT); + single_start = millis(); + next_tx_ms = 0; + ui_set_pattern(UI_PAT_SINGLE); + ui_blink_count((uint8_t)(rtc_seq_idx + 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; + } +} + +/* ------------------------------------------------------------------ */ +/* Cykl nadawczy w trybie NORMAL */ +/* ------------------------------------------------------------------ */ +static uint32_t compute_interval(void) +{ + if (rtc_interval_s != 0) { + return rtc_interval_s; + } + uint64_t now_ms = power_elapsed_ms() + millis(); +#if PIN_ACC >= 0 + if (digitalRead(PIN_ACC) == HIGH) { + rtc_last_acc_ms = now_ms; + return (uint32_t)TX_INTERVAL_IGNITION_S; + } +#endif + 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; +} + +static void tx_cycle(void) +{ + refresh_power(); + app_send_burst_all(); +} + +static void go_sleep(uint32_t seconds) +{ + Serial.printf("sleep %us\n", (unsigned)seconds); + Serial.flush(); + power_elapsed_add_ms(millis() + (uint64_t)seconds * 1000u); + power_deep_sleep(seconds); // nie wraca +} + +/* ------------------------------------------------------------------ */ +void setup(void) +{ + Serial.begin(SERIAL_BAUD); + ui_init(); + power_init(); + console_init(); + +#if PIN_LF_TRIGGER >= 0 + pinMode(PIN_LF_TRIGGER, INPUT_PULLDOWN); +#endif +#if PIN_ACC >= 0 + pinMode(PIN_ACC, INPUT_PULLDOWN); +#endif + + if (rtc_magic != RTC_MAGIC) { + rtc_magic = RTC_MAGIC; + rtc_mode = APP_MODE_NORMAL; + rtc_seq_idx = 0; + rtc_rot_idx = 0; + rtc_wake_count = 0; + rtc_interval_s = 0; + rtc_flags = TPMS_FLAGS; + rtc_last_acc_ms = 0; + } + 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); + } + + 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); + } + + Serial.printf("Vcc=%u mV tryb=%d interwal=%us\n", (unsigned)supply_mv, + (int)rtc_mode, (unsigned)iv); + app_print_info(); + Serial.println(F("gotowy ('help' - komendy)")); +} + +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 + } + } + 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, rtc_seq_idx); + } + } + + console_poll(); + +#if PIN_LF_TRIGGER >= 0 + /* aktywacja LF tez dziala "na zywo" (nie tylko przez budzenie) */ + { + static bool lf_prev = false; + bool lf = (digitalRead(PIN_LF_TRIGGER) == HIGH); + if (lf && !lf_prev) { + refresh_power(); + app_send_burst_wheel(active_wheel()); + } + lf_prev = lf; + } +#endif + + 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; + } +} diff --git a/src/power.cpp b/src/power.cpp new file mode 100644 index 0000000..0d9ebe1 --- /dev/null +++ b/src/power.cpp @@ -0,0 +1,98 @@ +/* + * 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 + */ +#include +#include +#include +#include + +#include "config.h" +#include "power.h" +#include "radio.h" + +RTC_DATA_ATTR static uint64_t rtc_elapsed_ms = 0; + +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(); + + analogSetPinAttenuation(PIN_VBAT_ADC, ADC_11db); +} + +uint32_t power_read_mv(void) +{ + uint64_t sum = 0; + for (int 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); +} + +bool power_low_battery(uint32_t mv) +{ + return mv > 500u && mv < (uint32_t)LOWBATT_THRESHOLD_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) { + esp_sleep_enable_timer_wakeup((uint64_t)seconds * 1000000ULL); + } + + /* Przycisk jako zrodlo EXT0 (poziom konfigurowalny). */ +#if PIN_BUTTON >= 0 + 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); +#endif + if (ext1_mask != 0) { + esp_sleep_enable_ext1_wakeup(ext1_mask, ESP_EXT1_WAKEUP_ANY_HIGH); + } + + esp_deep_sleep_start(); +} + +uint64_t power_elapsed_ms(void) +{ + return rtc_elapsed_ms; +} + +void power_elapsed_add_ms(uint64_t delta_ms) +{ + rtc_elapsed_ms += delta_ms; +} diff --git a/src/power.h b/src/power.h new file mode 100644 index 0000000..597f82e --- /dev/null +++ b/src/power.h @@ -0,0 +1,36 @@ +/* + * power.h - zasilanie, pomiar napiecia, deep sleep + */ +#ifndef TPMS_POWER_H +#define TPMS_POWER_H + +#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); + +/* 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); + +/* Suma czasu pracy [ms] od pierwszego uruchomienia - licznik w RTC + * przetrwuje deep sleep; uzywane do logiki "5 min po zaniku ACC". */ +uint64_t power_elapsed_ms(void); +void power_elapsed_add_ms(uint64_t delta_ms); + +#ifdef __cplusplus +} +#endif + +#endif /* TPMS_POWER_H */ diff --git a/src/radio.cpp b/src/radio.cpp new file mode 100644 index 0000000..2807056 --- /dev/null +++ b/src/radio.cpp @@ -0,0 +1,137 @@ +/* + * 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. + */ +#include +#include +#include +#include + +#include "config.h" +#include "radio.h" +#include "tpms_frame.h" + +static bool radio_ok = false; + +static void radio_set_pins(void) +{ +#if defined(SMARTRC_CC1101_H) /* SmartRC-CC1101-Driver-Lib 3.x */ + ELECHOUSE_cc1101.setSpiPin(PIN_CC1101_SCK, PIN_CC1101_MISO, + PIN_CC1101_MOSI, PIN_CC1101_CS); + ELECHOUSE_cc1101.setGDO0(PIN_CC1101_GDO0); +#else /* klasyczne ELECHOUSE_CC1101_SRC_DRV 1.x/2.x */ + ELECHOUSE_cc1101.setSCK(PIN_CC1101_SCK); + ELECHOUSE_cc1101.setMISO(PIN_CC1101_MISO); + ELECHOUSE_cc1101.setMOSI(PIN_CC1101_MOSI); + ELECHOUSE_cc1101.setCS(PIN_CC1101_CS); + ELECHOUSE_cc1101.setGDO0(PIN_CC1101_GDO0); +#endif +} + +bool radio_init(void) +{ + 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.Init(); + + radio_ok = ELECHOUSE_cc1101.getCC1101(); + if (!radio_ok) { + 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.setChannel(0); + + ELECHOUSE_cc1101.setSyncMode(0); // bez preambuly/sync CC1101 + 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.setFEC(0); + ELECHOUSE_cc1101.setCrc(0); // wlasna suma kontrolna protokolu + 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.setPacketLength(TPMS_TX_BYTES); + return true; +} + +void radio_send_frame(const uint8_t *buf, uint8_t len) +{ + if (!radio_ok) { + return; + } + + ELECHOUSE_cc1101.SpiStrobe(CC1101_SIDLE); + ELECHOUSE_cc1101.SpiStrobe(CC1101_SFTX); + ELECHOUSE_cc1101.SpiWriteBurstReg(CC1101_TXFIFO, (uint8_t *)buf, len); + ELECHOUSE_cc1101.SpiStrobe(CC1101_STX); + + /* Czekamy az caly bufor wyjdzie na antene: FIFO puste + margines na + * ostatni chip. Blokada krotka (~30 ms) i niezbedna do zakonczenia + * transmisji - poza tym petla glowna nie uzywa delay(). */ + uint32_t air_us = (uint32_t)len * 8u * (uint32_t)TPMS_CHIP_US + 3000u; + uint32_t t0 = micros(); + while ((uint32_t)(micros() - t0) < air_us) { + uint8_t txb = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES); + if ((txb & 0x7Fu) == 0) { + delayMicroseconds(2u * TPMS_CHIP_US); // ostatni chip na antenie + break; + } + } + + ELECHOUSE_cc1101.SpiStrobe(CC1101_SIDLE); + ELECHOUSE_cc1101.SpiStrobe(CC1101_SFTX); +} + +void radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames) +{ + for (uint8_t i = 0; i < frames; i++) { + radio_send_frame(buf, len); + if (i + 1u < frames) { + delay(TX_FRAME_GAP_MS); + } + } +} + +void radio_sleep(void) +{ + if (radio_ok) { + ELECHOUSE_cc1101.goSleep(); // SIDLE + SPWD (sen po zboczu CS) + } + /* 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); + pinMode(PIN_CC1101_SCK, OUTPUT); + digitalWrite(PIN_CC1101_SCK, LOW); + pinMode(PIN_CC1101_MOSI, OUTPUT); + digitalWrite(PIN_CC1101_MOSI, LOW); + pinMode(PIN_CC1101_GDO0, INPUT_PULLDOWN); +} diff --git a/src/radio.h b/src/radio.h new file mode 100644 index 0000000..77dd38e --- /dev/null +++ b/src/radio.h @@ -0,0 +1,32 @@ +/* + * radio.h - sterowanie CC1101 (nadawanie ramek TPMS, tryb uśpienia) + */ +#ifndef TPMS_RADIO_H +#define TPMS_RADIO_H + +#include +#include +#include "config.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 (~29 ms). */ +void radio_send_frame(const uint8_t *buf, uint8_t len); + +/* Burts: n ramek tego samego bufora z odstepem TX_FRAME_GAP_MS. */ +void radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames); + +/* CC1101 do trybu SLEEP (<1 uA) + przygotowanie linii pod gpio_hold. */ +void radio_sleep(void); + +#ifdef __cplusplus +} +#endif + +#endif /* TPMS_RADIO_H */ diff --git a/src/tpms_frame.cpp b/src/tpms_frame.cpp new file mode 100644 index 0000000..0e86bf7 --- /dev/null +++ b/src/tpms_frame.cpp @@ -0,0 +1,97 @@ +/* + * 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. + */ +#include +#include "config.h" +#include "tpms_frame.h" + +static void put_bit(uint8_t *buf, unsigned *nbits, unsigned v) +{ + if (v) { + buf[*nbits >> 3] |= (uint8_t)(0x80u >> (*nbits & 7u)); + } + (*nbits)++; +} + +/* G.E.T. Manchester: 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); + } +} + +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) +{ + if (low_batt) { + flags |= TPMS_FLAGS_LOWBAT_MASK; + } + + /* 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; + + /* 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; + + out[0] = (uint8_t)(flags >> 24); + out[1] = (uint8_t)(flags >> 16); + out[2] = (uint8_t)(flags >> 8); + 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[9] = crc; + return crc; +} + +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) +{ + uint8_t payload[TPMS_PAYLOAD_LEN]; + tpms_build_payload(payload, id, press_kpa10, temp_c, flags, low_batt); + + 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); + } + + /* 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); + } + + /* padding do granicy bajtu - dla OOK sa to chipy "off" = cisza w eterze */ + while (nbits % 8u) { + put_bit(out, &nbits, 0); + } +} diff --git a/src/tpms_frame.h b/src/tpms_frame.h new file mode 100644 index 0000000..744535a --- /dev/null +++ b/src/tpms_frame.h @@ -0,0 +1,61 @@ +/* + * 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). + */ +#ifndef TPMS_FRAME_H +#define TPMS_FRAME_H + +#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) + +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); + +#ifdef __cplusplus +} +#endif + +#endif /* TPMS_FRAME_H */ diff --git a/src/ui.cpp b/src/ui.cpp new file mode 100644 index 0000000..2e31bb2 --- /dev/null +++ b/src/ui.cpp @@ -0,0 +1,143 @@ +/* + * ui.cpp - przycisk (gesty) i LED statusowy (nieblokujaco, bez delay()) + */ +#include +#include "config.h" +#include "ui.h" + +/* ---------------------------- przycisk ---------------------------- */ + +static bool btn_stable = false; // stan po debounce +static uint32_t btn_last_change = 0; +static uint32_t btn_press_start = 0; +static bool btn_long_fired = false; // bardzo dlugie zdarzenie juz wyslane + +bool ui_button_down(void) +{ + return btn_stable; +} + +void ui_init(void) +{ + pinMode(PIN_BUTTON, BTN_ACTIVE_LEVEL ? INPUT_PULLDOWN : INPUT_PULLUP); + pinMode(PIN_LED, OUTPUT); + digitalWrite(PIN_LED, LOW); + btn_stable = (digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL); + btn_last_change = millis(); +} + +ui_event_t ui_poll(void) +{ + ui_event_t ev = UI_EV_NONE; + bool raw = (digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL); + uint32_t now = millis(); + + if (raw != btn_stable && (now - btn_last_change) >= BTN_DEBOUNCE_MS) { + btn_last_change = now; + btn_stable = raw; + if (btn_stable) { + btn_press_start = now; + btn_long_fired = false; + } + else { + uint32_t held = now - btn_press_start; + if (!btn_long_fired) { + if (held >= BTN_VERYLONG_MS) ev = UI_EV_VERYLONG; + else if (held >= BTN_LONG_MS) ev = UI_EV_LONG; + else ev = UI_EV_SHORT; + } + } + } + + /* bardzo dlugi przycisk sygnalizujemy od razu (nie czekajac na puszczenie) */ + if (btn_stable && !btn_long_fired && (now - btn_press_start) >= BTN_VERYLONG_MS) { + btn_long_fired = true; + ev = UI_EV_VERYLONG; + } + return ev; +} + +/* ------------------------------- LED ------------------------------ */ + +static ui_pat_t led_pat = UI_PAT_OFF; +static uint8_t led_blinks_left = 0; +static bool led_on = false; +static bool led_series = false; // seria migniec w trakcie +static uint32_t led_next = 0; + +void ui_set_pattern(ui_pat_t pat) +{ + led_pat = pat; + led_blinks_left = 0; + led_on = false; + led_series = false; + digitalWrite(PIN_LED, LOW); + led_next = millis(); +} + +void ui_blink_count(uint8_t n) +{ + led_blinks_left = n; + led_on = false; + led_series = true; + led_next = millis(); +} + +void ui_update(void) +{ + uint32_t now = millis(); + if ((int32_t)(now - led_next) < 0) { + return; + } + + if (led_series) { + if (led_on) { + /* koniec migniecia */ + digitalWrite(PIN_LED, LOW); + led_on = false; + if (led_blinks_left > 0) { + led_blinks_left--; + } + led_next = now + 90; + } + else if (led_blinks_left > 0) { + /* kolejne migniecie */ + digitalWrite(PIN_LED, HIGH); + led_on = true; + led_next = now + 90; + } + else { + /* koniec serii - przerwa zalezna od wzorca */ + led_series = false; + uint32_t idle = 2000; + switch (led_pat) { + case UI_PAT_OFF: idle = 50; break; + case UI_PAT_NORMAL: idle = 2000; break; + case UI_PAT_LEARN: idle = 500; break; + case UI_PAT_SINGLE: idle = 500; break; + case UI_PAT_LOWBAT: idle = 3000; break; + } + led_next = now + idle; + } + return; + } + + /* rozpoczynamy serie wg wzorca */ + if (led_pat == UI_PAT_OFF) { + digitalWrite(PIN_LED, LOW); + led_next = now + 50; + return; + } + uint8_t n = 1; + switch (led_pat) { + case UI_PAT_NORMAL: n = 1; break; + case UI_PAT_LEARN: n = 3; break; + case UI_PAT_SINGLE: n = 2; break; + case UI_PAT_LOWBAT: n = 10; break; + default: break; + } + led_blinks_left = n; + led_on = false; + led_series = true; + led_next = now; +} diff --git a/src/ui.h b/src/ui.h new file mode 100644 index 0000000..cc0da9c --- /dev/null +++ b/src/ui.h @@ -0,0 +1,45 @@ +/* + * ui.h - przycisk (gesty) i LED statusowy + */ +#ifndef TPMS_UI_H +#define TPMS_UI_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + UI_EV_NONE = 0, + UI_EV_SHORT, // < BTN_LONG_MS + UI_EV_LONG, // >= BTN_LONG_MS (wejscie/wyjscie LEARN) + UI_EV_VERYLONG, // >= BTN_VERYLONG_MS (wejscie/wyjscie SINGLE) +} ui_event_t; + +typedef enum { + UI_PAT_OFF = 0, + UI_PAT_NORMAL, // 1 migniecie co 2 s + UI_PAT_LEARN, // 3 szybkie migniecia co 0.5 s + UI_PAT_SINGLE, // 2 szybkie migniecia co 0.5 s + UI_PAT_LOWBAT, // 10 szybkich migniec co 3 s +} ui_pat_t; + +void ui_init(void); + +/* Nieblokujaca obsluga przycisku i LED - wywolywac w kazdej petli. */ +ui_event_t ui_poll(void); +void ui_update(void); + +bool ui_button_down(void); +void ui_set_pattern(ui_pat_t pat); + +/* Seria n szybkich migniec (np. numer kola: 1-4). */ +void ui_blink_count(uint8_t n); + +#ifdef __cplusplus +} +#endif + +#endif /* TPMS_UI_H */ diff --git a/test/test_tpms_frame/test_tpms_frame.cpp b/test/test_tpms_frame/test_tpms_frame.cpp new file mode 100644 index 0000000..d3c2936 --- /dev/null +++ b/test/test_tpms_frame/test_tpms_frame.cpp @@ -0,0 +1,128 @@ +/* + * 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" }, + }; + + 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_reference_capture(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 + }; + TEST_ASSERT_EQUAL_HEX8_ARRAY(want, p, TPMS_PAYLOAD_LEN); +} + +static void test_pressure_scale(void) +{ + 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_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]; + } + TEST_ASSERT_EQUAL_HEX8(sum & 0xFF, p[9]); +} + +static void test_low_batt_flag(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); +} + +static void test_frame_layout(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); +} + +int main(int argc, char **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_checksum); + RUN_TEST(test_low_batt_flag); + RUN_TEST(test_frame_layout); + return UNITY_END(); +} diff --git a/tools/gen_cu8.py b/tools/gen_cu8.py new file mode 100755 index 0000000..99d0cc6 --- /dev/null +++ b/tools/gen_cu8.py @@ -0,0 +1,95 @@ +#!/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. +""" + +import argparse +import math +import os +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 + +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)) + 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 + + +def write_cu8(path, samples): + with open(path, "wb") as f: + 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))))))) + + +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() + + row = build_row(int(args.id, 16), args.pressure, args.temp, int(args.flags, 16)) + 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))}") + + 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)") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/tpms_frame.py b/tools/tpms_frame.py new file mode 100755 index 0000000..d5b56e9 --- /dev/null +++ b/tools/tpms_frame.py @@ -0,0 +1,238 @@ +#!/usr/bin/env python3 +"""Reference frame builder for the Schrader EG53MA4 TPMS simulator. + +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. +""" + +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 +SYNC_BITS = 40 +TX_BYTES = 31 # 1 lead chip + 238 data chips + 9 pad chips = 248 chips +DEFAULT_FLAGS = 0x4C900070 # captured from real EG53MA4 sensors + + +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. + """ + kpa10 = int(math.floor(pressure_kpa * 10.0 + 0.5)) + press_byte = min(max((kpa10 + 12) // 25, 0), 255) # 2.5 kPa per bit + tc = int(math.floor(temp_c + 0.5)) + num = 9 * tc + 160 # temp_F = (9C+160)/5 + 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 + + +def build_tx_bits(row: str) -> str: + """Return the 248 chip long bit string actually shifted into the CC1101 FIFO.""" + 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 + + +def tx_bytes(bits: str) -> bytes: + assert len(bits) % 8 == 0 + 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, + } + + +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 + import random + random.seed(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 + + +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() + + 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'}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/verify_rtl433.sh b/tools/verify_rtl433.sh new file mode 100755 index 0000000..d428dcc --- /dev/null +++ b/tools/verify_rtl433.sh @@ -0,0 +1,91 @@ +#!/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"