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.
This commit is contained in:
czcionka committed 2026-10-27 06:09:18 +00:00
commit 9b30351779
20 files changed
+2758

No files matched your search

+6
View File
@@ -0,0 +1,6 @@
.pio/
.vscode/
*.o
*.elf
*.bin
__pycache__/
+620
View File
@@ -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:
<https://github.com/merbanan/rtl_433>
* `rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01/` — referencyjne nagrania
RF prawdziwych czujników (na ich podstawie odtworzono timing i modulację):
<https://github.com/merbanan/rtl_433_tests>
* <https://github.com/merbanan/rtl_433/issues/2978> — wzorzec struktury
symulatora TPMS na ESP32+CC1101 (inicjalizacja CC1101, Manchester, CRC,
wysyłanie cykliczne)
* <https://github.com/avicarmeli/TPMS-SDR> — 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 <s>` | ręczny interwał (0 = automatycznie wg ACC) |
| `flags <hex>` | 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.**
+34
View File
@@ -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 = -<*> +<tpms_frame.cpp>
test_build_src = true
test_framework = unity
+40
View File
@@ -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 <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
enum {
APP_MODE_NORMAL = 0, // rotacja wszystkich 4 kol + deep sleep
APP_MODE_LEARN = 1, // nauka czujnikow w aucie, jedno kolo naraz
APP_MODE_SINGLE = 2, // wymuszone nadawanie wskazanego ID
};
uint8_t app_mode(void);
uint8_t app_wheel(void); // aktywne kolo (w LEARN/SINGLE)
void app_set_mode(uint8_t mode, uint8_t wheel);
void app_next_wheel(void);
void app_send_burst_wheel(uint8_t wheel);
void app_send_burst_all(void);
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 */
+173
View File
@@ -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 */
+190
View File
@@ -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 <s> - reczy ustalony interwal (0 = auto wg ACC)
* flags <hex> - slowo flags wyslane w ramce
* sleep - deep sleep teraz
* stay [s] - zostan w stanie czuwania jeszcze s sekund
*/
#include <Arduino.h>
#include <string.h>
#include <stdlib.h>
#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 <s> - interwal nadawania (0=auto)"));
Serial.println(F(" flags <hex> - 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 <s>"));
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 <hex>"));
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
}
}
}
+18
View File
@@ -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 */
+476
View File
@@ -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 <Arduino.h>
#include <esp_sleep.h>
#include <driver/gpio.h>
#include "config.h"
#include "tpms_frame.h"
#include "radio.h"
#include "power.h"
#include "ui.h"
#include "console.h"
#include "app.h"
/* ------------------------------------------------------------------ */
/* 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;
}
}
+98
View File
@@ -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 <Arduino.h>
#include <esp_sleep.h>
#include <driver/gpio.h>
#include <esp32-hal-bt.h>
#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;
}
+36
View File
@@ -0,0 +1,36 @@
/*
* power.h - zasilanie, pomiar napiecia, deep sleep
*/
#ifndef TPMS_POWER_H
#define TPMS_POWER_H
#include <stdint.h>
#include <stdbool.h>
#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 */
+137
View File
@@ -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 <Arduino.h>
#include <SPI.h>
#include <ELECHOUSE_CC1101_SRC_DRV.h>
#include <driver/gpio.h>
#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);
}
+32
View File
@@ -0,0 +1,32 @@
/*
* radio.h - sterowanie CC1101 (nadawanie ramek TPMS, tryb uśpienia)
*/
#ifndef TPMS_RADIO_H
#define TPMS_RADIO_H
#include <stdint.h>
#include <stdbool.h>
#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 */
+97
View File
@@ -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 <string.h>
#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);
}
}
+61
View File
@@ -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 <stdint.h>
#include <stdbool.h>
#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 */
+143
View File
@@ -0,0 +1,143 @@
/*
* ui.cpp - przycisk (gesty) i LED statusowy (nieblokujaco, bez delay())
*/
#include <Arduino.h>
#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;
}
+45
View File
@@ -0,0 +1,45 @@
/*
* ui.h - przycisk (gesty) i LED statusowy
*/
#ifndef TPMS_UI_H
#define TPMS_UI_H
#include <stdint.h>
#include <stdbool.h>
#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 */
+128
View File
@@ -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 <string.h>
#include <unity.h>
#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();
}
+95
View File
@@ -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())
+238
View File
@@ -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())
+91
View File
@@ -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:-<brak>}"
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"