Poprawki po recenzji zewnetrznej (Kimi K3.1 Pro) + regresja

KRYTYCZNE:
- zasilanie: usuniete bledne zalecenia (TPS62740 do 12V, LiPo bez LDO),
  poprawne warianty: MCP1703 (Vin>=16V) / LM5164-Q1, Li-SOCl2 bezposrednio,
  LiPo przez LDO; dokumentacja przepiec samochodowych (TVS)
- sleep: brak wejscia w sen przy wcisnietym przycisku/aktywnym LF
  (EXT0/EXT1 poziomowe = ryzyko petli wybudzen), LED gaszony przed snem
- radio: koniec TX liczony z pelnego czasu serializacji (TXBYTES==0 nie
  znaczy konca na antenie), kontrola underflow + podwojny odczyt statusu

WAZNE:
- API biblioteki: setSpiPin/setGDO0 (wymagane >=2.5.7), zgodnosc z 2.5.x/3.x
- PIN_ACC=-1 wylacza cala logike parkingowa (stale TX_INTERVAL_S)
- czas RTC oparty o system time (przetrwaje deep sleep) - brak zawyzania
  po wczesnych wybudzeniach; RTC_MAGIC zwiazany z CONFIG_VERSION
- dzielniki pomiarowe 1M/270k (~9uA zamiast ~90uA), ADC bez wewnetrznego
  pulldown, PIN_ACC domyslnie -1
- poprawiony debounce, pojedyncza obsluga LF (bez dubli burstow),
  SINGLE trzyma indeks koola niezaleznie od LEARN_SEQ, gesty zgodne z README

DROBNE: scisly parser konsoli, TX_BYTES=30 w narzedziach, tworzenie katalogu
w gen_cu8, static_assert + testy graniczne cisnienia, przypiete wersje
platformy i biblioteki, przeliczony budzet pradu.
This commit is contained in:
czcionka committed 2026-10-27 07:58:14 +00:00
1 parent c85c9a1dce
commit 4897360df6
14 files changed
+395 -162

No files matched your search

+71 -48
View File
@@ -109,9 +109,10 @@ pio test -e native # testy generatora ramek (bez sprzętu)
``` ```
Biblioteka CC1101 (`SmartRC-CC1101-Driver-Lib`, dawniej Biblioteka CC1101 (`SmartRC-CC1101-Driver-Lib`, dawniej
`ELECHOUSE_CC1101_SRC_DRV`) jest pobierana automatycznie z `platformio.ini`. `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 (przypięta do commita zweryfikowanego buildu). **Wymagana wersja ≥ 2.5.7**
(`setSCK`/`setMISO`/...), patrz `src/radio.cpp`. (wspólne API `setSpiPin`/`setGDO0` dla 2.5.x i 3.x; starsze 1.x używały
`setSCK`/`setMISO`/... i nie są obsługiwane).
### arduino-cli (alternatywa) ### arduino-cli (alternatywa)
@@ -164,7 +165,7 @@ Wystarczy **jedna sztuka** każdego podzespołu.
| 3 | Przycisk monostabilny | NO, wpuszczany lub panelowy | Tryby pracy (learn/single) | 2–5 zł | | 3 | Przycisk monostabilny | NO, wpuszczany lub panelowy | Tryby pracy (learn/single) | 2–5 zł |
| 4 | LED + rezystor 330 Ω | LED 3 mm/5 mm dowolny kolor | Status trybów | 1–3 zł | | 4 | LED + rezystor 330 Ω | LED 3 mm/5 mm dowolny kolor | Status trybów | 1–3 zł |
| 5 | Rezystor 10 kΩ | 1 szt. | Podciągnięcie przycisku do 3V3 | < 1 zł | | 5 | Rezystor 10 kΩ | 1 szt. | Podciągnięcie przycisku do 3V3 | < 1 zł |
| 6 | Rezystory 100 kΩ + 33 kΩ | po 1 szt. | Dzielnik pomiaru napięcia (GPIO34) | < 1 zł | | 6 | Rezystory 1 MΩ + 270 kΩ | po 2 szt. | Dzielniki pomiaru napięcia i ACC (~9 µA/szt. przy 12 V) | < 1 zł |
| 7 | Kondensatory | 100 µF/16 V elektrolityczny + 2× 100 nF ceramiczny | Odsprzężenie zasilania CC1101 i ESP32 (obowiązkowo przy długich przewodach) | 1–3 zł | | 7 | Kondensatory | 100 µF/16 V elektrolityczny + 2× 100 nF ceramiczny | Odsprzężenie zasilania CC1101 i ESP32 (obowiązkowo przy długich przewodach) | 1–3 zł |
| 8 | Bezpiecznik + uchwyt | 1 A, zwłoczny | Szeregowo z +12 V | 2–5 zł | | 8 | Bezpiecznik + uchwyt | 1 A, zwłoczny | Szeregowo z +12 V | 2–5 zł |
| 9 | Przewody, złącza | goldpiny 2,54 mm, kostki, ekran SPI | Przewody SPI możliwie krótkie (< 10 cm) | 5–15 zł | | 9 | Przewody, złącza | goldpiny 2,54 mm, kostki, ekran SPI | Przewody SPI możliwie krótkie (< 10 cm) | 5–15 zł |
@@ -174,16 +175,16 @@ Wystarczy **jedna sztuka** każdego podzespołu.
| Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. | | Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. |
|-----|-----------|-----------------|-------|----------------| |-----|-----------|-----------------|-------|----------------|
| 11a | **Wariant 12 V**: przetwornica buck o **bardzo niskim Iq** | TPS62740 (Iq ≈ 0,4 µA) lub gotowy moduł na TPS62740/TPS62742 | **Zwykłe tanie bucki (LM2596, MP1584, Mini360) mają Iq rzędu mA — nie nadają się** do trybu snu < 50 µA | 15–40 zł | | 11a | **Wariant 12 V**: LDO 3,3 V o niskim Iq i **wejściu ≥ 16 V** | np. **MCP1703-3302** (Vin 2,7–16 V, Iq ≈ 2 µA) | + zabezpieczenie wejścia: bezpiecznik, **TVS 24 V**, rezystor/dioda szeregowa (przepięcia load-dump!). Sprawdź moc strat: (14,4−3,3) V × ~30 mA ≈ 0,33 W — stosuj obudowę SOT-223/TO-92 i nie przeciążaj | 2–8 zł |
| 11b | **Wariant 12 V** (alternatywa): LDO 3,3 V o niskim Iq | MCP1700-3302, HT7333 (Iq 1,6–3,5 µA) | Tylko jeśli spadek 12→3,3 V zaakceptujesz stratą mocy; prąd szczytowy ≥ 300 mA | 2–8 zł | | 11b | **Wariant 12 V** (wydajniejszy): buck o szerokim wejściu | np. **LM5164-Q1** (Vin 6–100 V, Iq ≈ 10 µA, 1 A) lub inny buck automotive | Wymaga cewki i płytki; **TPS62740 (Vin 2,2–5,5 V) i tanie bucki (LM2596, MP1584, Mini360, Iq mA) NIE nadają się do 12 V / snu < 50 µA** | 20–50 zł |
| 12 | **Wariant bateryjny**: ogniwo 3,3–4,2 V | Li-SOCl2 3,6 V (AA/half-AA, np. ER14505) + uchwyt, albo LiPo 3,7 V | Bez przetwornicy; żywotność krótka przy interwale 30 s (patrz sekcja 13) | 10–30 zł | | 12 | **Wariant bateryjny**: ogniwo 3,6 V lub LiPo | Li-SOCl2 3,6 V (AA/half-AA, np. ER14505) + uchwyt **bezposrednio**; LiPo 3,7 V **przez LDO 3,3 V** (np. MCP1700, Vin max 6 V) | **Nie zasilaj LiPo 4,2 V wprost** — max ESP32 to 3,6 V, CC1101 to 3,9 V! | 10–30 zł |
**Opcjonalne (ulepszenia i testy):** **Opcjonalne (ulepszenia i testy):**
| Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. | | Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. |
|-----|-----------|-----------------|-------|----------------| |-----|-----------|-----------------|-------|----------------|
| 13 | Front-end LF 125 kHz | cewka rezonansowa (ferrytowa ramka z programatora TPMS), dioda Schottkyego (BAT54/1N5711), 100 pF + 100 kΩ, komparator LM393 | Reakcja na aktywację czujnika programatorem przy kole (`PIN_LF_TRIGGER`) | 10–30 zł | | 13 | Front-end LF 125 kHz | cewka rezonansowa (ferrytowa ramka z programatora TPMS), dioda Schottkyego (BAT54/1N5711), 100 pF + 100 kΩ, komparator LM393 | Reakcja na aktywację czujnika programatorem przy kole (`PIN_LF_TRIGGER`) | 10–30 zł |
| 14 | Dzielnik ACC | 100 kΩ + 33 kΩ + 100 nF | Pomiar sygnału zapłonu 12 V na GPIO32 (tryb ignition-aware) | < 2 zł | | 14 | Dzielnik ACC | 1 MΩ + 270 kΩ + 100 nF | Sygnał zapłonu 12 V → GPIO32 (tryb ignition-aware) | < 2 zł |
| 15 | RTL-SDR (dongle) | R820T2/RTL2832U | Testy z `rtl_433` (sekcja 7) — można wypożyczyć | 60–150 zł | | 15 | RTL-SDR (dongle) | R820T2/RTL2832U | Testy z `rtl_433` (sekcja 7) — można wypożyczyć | 60–150 zł |
| 16 | Kabel USB + ew. programator | do wgrywania firmware | W DevKit kabel USB-A/Micro-USB wystarczy | 5–15 zł | | 16 | Kabel USB + ew. programator | do wgrywania firmware | W DevKit kabel USB-A/Micro-USB wystarczy | 5–15 zł |
@@ -194,8 +195,8 @@ pomiaru snu), opcjonalnie INA219/INA226 lub oscyloskop do pomiaru prądu w burst
z wariantem 12 V lub zasilaniem z powerbanka 5 V przez DevKit (testy RF nie z wariantem 12 V lub zasilaniem z powerbanka 5 V przez DevKit (testy RF nie
wymagają spełnienia budżetu prądu). wymagają spełnienia budżetu prądu).
Gdzie kupić: AliExpress (CC1101, TPS62740, ESP32), Allegro/sklepy elektroniczne Gdzie kupić: AliExpress (CC1101, LM5164, ESP32), Allegro/sklepy elektroniczne
(pasywne elementy, obudowa, bezpieczniki). Przy zamawianiu CC1101 sprawdź, czy (pasywne elementy, obudowa, bezpieczniki, TVS). Przy zamawianiu CC1101 sprawdź, czy
moduł jest oznaczony **433 MHz** — wersje 868/915 MHz nie zadziałają bez moduł jest oznaczony **433 MHz** — wersje 868/915 MHz nie zadziałają bez
przestrojenia. przestrojenia.
@@ -219,26 +220,37 @@ Pozostałe elementy (numery pinów konfigurowalne w `config.h`):
| Przycisk trybów | GPIO26 | GPIO —— przycisk —— GND, rezystor 10 kΩ do 3V3 (aktywny niski, `BTN_ACTIVE_LEVEL 0`) | | 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 | | 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` | | 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` | | ACC / zapłon (opcjonalnie) | GPIO32 | dzielnik 12 V → ~3 V (1 MΩ / 270 kΩ + 100 nF), wejście **INPUT** (bez podciągania); **domyślnie wyłączone** (`PIN_ACC -1`) — ustaw 32 po podłączeniu |
| Pomiar napięcia | GPIO34 | węzeł środkowy dzielnika `R1=100 kΩ / R2=33 kΩ` (ADC1) | | Pomiar napięcia | GPIO34 | węzeł środkowy dzielnika `R1=1 MΩ / R2=270 kΩ` (ADC1) + 100 nF |
Zasilanie (wybór w `config.h`, `POWER_SUPPLY_MODE`): Zasilanie (wybór w `config.h`, `POWER_SUPPLY_MODE`):
``` ```
POWER_12V (na stałe z akumulatora): POWER_12V (na stałe z akumulatora) - UWAGA: zakres samochodowy to nie
+12 V (bezpiecznik 1 A) ── buck o Iq < 20 µA (np. TPS62740, Iq ≈ 0,4 µA) same "12 V": 14,4 V przy ladowaniu
i przepięcia load-dump > 40 V:
+12 V ──[bezpiecznik 1 A]──[TVS 24 V do masy]──[rezystor/dioda]── regulator
── 3,3 V ── ESP32 + CC1101 ── 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): Regulator (wybierz jeden):
ogniwo ── 3V3 (bez przetwornicy). Uwaga: ESP32 wymaga ≥ 3,0 V pod obciążeniem. - LDO o Iq ~2 µA i wejściu >= 16 V, np. MCP1703-3302
(straty: (14,4-3,3) V x ~30 mA = ~0,33 W - zwróć uwagę na obudowę),
- albo buck automotive o szerokim wejściu, np. LM5164-Q1 (6-100 V,
Iq ~10 µA) - wydajniejszy, wymaga cewki.
TPS62740 (Vin 2,2-5,5 V!) i tanie bucki (LM2596/MP1584/Mini360, Iq mA)
NIE nadają się do tej aplikacji.
POWER_BATTERY:
Li-SOCl2 3,6 V ── bezposrednio 3V3 (ESP32 wymaga >= 3,0 V pod obciazeniem)
LiPo 3,7 V ── PRZEZ LDO 3,3 V (np. MCP1700). Bezposrednie zasilanie
LiPo 4,2 V przekracza max ESP32 (3,6 V) i CC1101 (3,9 V)!
``` ```
``` ```
+12V ──[bezpiecznik]──> buck IN +12V ──[bezpiecznik]──[TVS]──> regulator IN
Pomiar: +12V ──[R1 100k]──+── GPIO34 Pomiar: +12V ──[R1 1M]──+── GPIO34 ( + 100 nF do masy )
└──[R2 33k]── GND └──[R2 270k]── GND
(12 V -> 2,55 V, 14,4 V -> 3,05 V, prad dzielnika ~9 uA)
``` ```
Ważne: Ważne:
@@ -357,11 +369,14 @@ rtl_433 -f 433.92M -X 'n=schrader,m=FSK_MC_ZEROBIT,s=120,l=120,r=300'
### Sterowanie (przycisk `PIN_BUTTON`) ### Sterowanie (przycisk `PIN_BUTTON`)
| Gest | Tryb NORMAL | Tryb LEARN / SINGLE | | Gest | Tryb NORMAL | Tryb LEARN | Tryb SINGLE |
|--------------------------|--------------------------|--------------------------| |--------------------------|--------------------------|--------------------------|--------------------------|
| krótkie naciśnięcie | natychmiast burst 4 kół | **następne koło** | | krótkie naciśnięcie | natychmiast burst 4 kół | **następne koło** | **następne koło** |
| długie (≥1,5 s) | wejście do **LEARN** | wyjście do NORMAL | | długie (≥1,5 s) | → **LEARN** | → NORMAL | → LEARN |
| bardzo długie (≥4 s) | wejście do **SINGLE** | wyjście do NORMAL | | bardzo długie (≥4 s) | → **SINGLE** | → SINGLE | → NORMAL |
(Przycisk nie jest drzemany przy wciśniętym — urządzenie nie wejdzie w sen,
dopóki go nie puścisz; bardzo długi gest zdąży się zawsze zarejestrować.)
LED: seria **N mrugnięć = N-ty numer koła** (1–4) przy zmianie koła, 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, wzorzec stały: NORMAL — 1 mrugnięcie co 2 s, LEARN — 3 mrugnięcia co 0,5 s,
@@ -452,12 +467,16 @@ wielokrotnymi próbami):
* **DevKit z USB-UART**: mostek CP2102/CH340 + LDO AMS1117 = 0,5–2 mA * **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. 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) Rozwiązanie: goły moduł ESP32-WROOM + regulator z sekcji 5
lub LDO MCP1700/HT7333. (MCP1703/ LM5164-Q1 dla 12 V, MCP1700 dla LiPo).
* **Dzielniki pomiarowe**: 2 × 1 MΩ/270 kΩ ≈ 19 µA stale — to już połowa
budżetu < 50 µA; w wariancie bateryjnym możesz je całkowicie odpiąć
(`PIN_VBAT_ADC -1` nie jest obsługiwany — po prostu nie montuj dzielnika
i zignoruj odczyt) albo zwiększyć rezystancje kosztem dokładności ADC.
* Rezystor podciągający przycisku (10 kΩ) pobiera 330 µA przy stanie * Rezystor podciągający przycisku (10 kΩ) pobiera 330 µA przy stanie
aktywnym niskim — w sleep przycisk jest w stanie spoczynkowym (HIGH), 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Ω. 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). * LED — w sleep zgaszony (firmware go gasi przed snem).
--- ---
@@ -550,8 +569,10 @@ FL payload: 4C 90 00 70 2F C8 71 68 49 65 crc=65 id=2FC871 press=260.0 kPa temp
Założenia: burst = 4 koła × 3 ramki, ramka na antenie 240 chipów × 120 µs 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 = **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 + 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 (+10 dBm), CC1101 idle ~15 mA, deep sleep ≈ 15 µA (ESP32 ~10 µA + CC1101
< 1 µA + buck TPS62740 ~0,4 µA). < 1 µA + Iq regulatora) **+ ~19 µA na dzielnikach pomiarowych**
(2 × 1 MΩ/270 kΩ). Przeliczenia poniżej robione są jednym wzorem:
pobór z 12 V = pobór na szynie 3,3 V × (3,3/12) / sprawność regulatora (0,9).
**Cykl co 30 s** (2880 cykli/dobę): **Cykl co 30 s** (2880 cykli/dobę):
@@ -560,37 +581,38 @@ Założenia: burst = 4 koła × 3 ramki, ramka na antenie 240 chipów × 120 µs
| ESP32 aktywny (80 mA × 1,2 s) | 1,2 s | 96 mAs ≈ 27 µAh | | 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 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 | | 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 | | deep sleep + dzielniki (~34 µA × 30 s)| 30 s | ≈ 0,3 µAh |
| **Razem** | | **≈ 34 µAh/cykl** | | **Razem** | | **≈ 34 µAh/cykl** |
* **Dobowy pobór: 34 µAh × 2880 ≈ 98 mAh/dobę → średnio ≈ 4 mA** * **Dobowy pobór na szynie 3,3 V: 34 µAh × 2880 ≈ 98 mAh/dobę**
(przy 3,3 V ≈ 13 mW). (średnio ≈ 4 mA).
* Przy zasilaniu 12 V przez buck (sprawność ~90%): **≈ 27 mAh/dobę * Przy zasilaniu 12 V (sprawność 90%): **≈ 30 mAh/dobę z akumulatora**
z akumulatora** (średnio ≈ 1,1 mA przy 12 V). (98 × 3,3/12/0,9 = 30; średnio ≈ 1,25 mA przy 12 V).
**Akumulator 60 Ah (Pb), bez innych odbiorników:** **Akumulator 60 Ah (Pb), bez innych odbiorników:**
* prąd potrzebny do rozruchu wymaga napięcia > ~11,8 V, czyli ~50% pojemności * prąd potrzebny do rozruchu wymaga napięcia > ~11,8 V, czyli ~50% pojemności
= 30 Ah użyteczne, = 30 Ah użyteczne,
* 30 000 mAh / 27 mAh ≈ **1100 dni ≈ 3 lata** — teoretycznie; * 30 000 mAh / 30 mAh ≈ **1000 dni ≈ 2,7 roku** — teoretycznie;
* **w praktyce granicą jest samorozładowanie akumulatora kwasowego * **w praktyce granicą jest samorozładowanie akumulatora kwasowego
(3–5%/mies.)** — akumulator bez odbiorników rozładowuje się w 6–12 mies., (3–5%/mies.)** — akumulator bez odbiorników rozładowuje się w 6–12 mies.,
więc symulator **nie jest czynnikiem limitującym**. więc symulator **nie jest czynnikiem limitującym**.
**Warianty oszczędne:** **Warianty oszczędne** (pobór z 12 V z uwzględnieniem sprawności 0,9):
| Interwał | Średni prąd (3,3 V) | Dobowy pobór (12 V) | 60 Ah (30 Ah użyteczne) | | 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* | | 30 s | ~4 mA | ~30 mAh/dobę | ~2,7 roku* |
| 120 s (parking) | ~1,2 mA | ~8 mAh/dobę | ~10 lat* | | 120 s (parking) | ~1 mA | ~8 mAh/dobę | ~10 lat* |
| 300 s | ~0,5 mA | ~3,5 mAh/dobę | ogranicza samorozładowanie | | 300 s | ~0,4 mA | ~3,5 mAh/dobę | ogranicza samorozładowanie |
\* przed samorozładowaniem akumulatora. \* przed samorozładowaniem akumulatora.
**Wariant bateryjny** (Li-SOCl2 3,6 V 2400 mAh): ~98 mAh/dobę przy 30 s **Wariant bateryjny** (Li-SOCl2 3,6 V 2400 mAh, bez strat przetwornicy):
to ok. **25 dni** — do zasilania bateryjnego stosuj dłuższe interwały ~98 mAh/dobę przy 30 s to ok. **24 dni**; przy 300 s ~10 mAh/dobę to ok.
(300 s → ok. 150 dni) albo mniejszą liczbę ramek w burście **240 dni (~8 mies.)**. Do zasilania bateryjnego stosuj dłuższe interwały,
(`TX_BURST_FRAMES 2`), lub tryb `PARKING_SHUTDOWN 1`. mniejszą liczbę ramek w burście (`TX_BURST_FRAMES 2`) albo
`PARKING_SHUTDOWN 1`.
Wskazówki: zmniejsz `TX_BURST_FRAMES`, wydłuż interwał, użyj mocy TX 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` `TPMS_TX_POWER_DBM 0` (wystarczy w aucie), ustaw `PARKING_SHUTDOWN 1`
@@ -663,9 +685,10 @@ Weryfikacja implementacji (bez sprzętu):
## Wersje ## Wersje
* `CONFIG_VERSION` w `src/config.h` — podnieś przy zmianie formatu danych * `CONFIG_VERSION` w `src/config.h` — podnieś przy zmianie formatu danych
w pamięci RTC (stan trybów przetrwuje deep sleep). w pamięci RTC (magic RTC zawiera tę wersję, więc stan zostanie wyzerowany).
* Firmware testowany z: PlatformIO `espressif32`, Arduino core ESP32, * Firmware testowany z: PlatformIO `espressif32@8.0.0`, Arduino core ESP32,
`SmartRC-CC1101-Driver-Lib 3.x` (kompatybilny z 1.x/2.x), rtl_433 (master). `SmartRC-CC1101-Driver-Lib` commit `de6757e` (3.0.2, wymagane ≥ 2.5.7),
rtl_433 (master).
**Pamiętaj: symulator generuje sztuczne dane ciśnienia i nie zastępuje **Pamiętaj: symulator generuje sztuczne dane ciśnienia i nie zastępuje
prawdziwych czujników TPMS.** prawdziwych czujników TPMS.**
+5 -4
View File
@@ -12,15 +12,16 @@
default_envs = esp32dev default_envs = esp32dev
[env:esp32dev] [env:esp32dev]
platform = espressif32 ; Wersje przypiete do zweryfikowanego buildu (espressif32 8.0.0,
; SmartRC-CC1101-Driver-Lib 3.0.2 = commit de6757e)
platform = espressif32@8.0.0
board = esp32dev board = esp32dev
framework = arduino framework = arduino
monitor_speed = 115200 monitor_speed = 115200
; Biblioteka CC1101 (ELECHOUSE_CC1101_SRC_DRV / SmartRC): ; Biblioteka CC1101 (ELECHOUSE_CC1101_SRC_DRV / SmartRC):
; wersja 3.x udostepnia naglowek zgodnosciowy ELECHOUSE_CC1101_SRC_DRV.h, ; wymagana wersja >= 2.5.7 (wspolne API setSpiPin/setGDO0 dla 2.5.x i 3.x).
; kod obsluguje tez API 1.x/2.x (patrz src/radio.cpp).
lib_deps = lib_deps =
https://github.com/LSatan/SmartRC-CC1101-Driver-Lib.git https://github.com/LSatan/SmartRC-CC1101-Driver-Lib.git#de6757e
build_flags = build_flags =
-Wall -Wall
-Wextra -Wextra
+26 -9
View File
@@ -23,9 +23,19 @@
/* ====================================================================== /* ======================================================================
* 1. ZASILANIE * 1. ZASILANIE
* POWER_12V - stale zasilanie z akumulatora 12 V przez buck/ LDO * POWER_12V - stale zasilanie z akumulatora 12 V.
* o niskim pradzie spoczynkowym (np. TPS62740, Iq < 1 uA) * UWAGA: potrzebny jest uklad zasilajacy na PELENY zakres
* POWER_BATTERY - ogniwo 3.3-4.2 V (Li-SOCl2 / LiPo) bez przetwornicy * samochodowy (12 V nominalnie, 14,4 V przy ladowaniu, przepiecia
* load-dump nawet > 40 V):
* - LDO o wejsciu >= 16 V i niskim Iq, np. MCP1703 (Vin 2.7-16 V,
* Iq ~2 uA) - zabezpiecz wejscie bezpiecznikiem + TVS (np. 24 V)
* + rezystor szeregowy/dioda; ogranicz moc strat (patrz README),
* - albo przetwornica buck o szerokim wejsciu, np. LM5164-Q1
* (Vin 6-100 V, Iq ~10 uA, 1 A).
* TPS62740 ma wejscie 2.2-5.5 V - NIE wolno podlaczac go do 12 V!
* POWER_BATTERY - ogniwo 3.6 V (Li-SOCl2) bezposrednio, albo LiPo 3.7 V
* PRZEZ LDO 3.3 V (np. MCP1700, Vin max 6 V). Bezposrednie
* zasilanie LiPo 4.2 V przekracza max ESP32 (3.6 V) i CC1101 (3.9 V)!
* ====================================================================== */ * ====================================================================== */
#define POWER_SUPPLY_MODE POWER_12V #define POWER_SUPPLY_MODE POWER_12V
#define POWER_12V 1 #define POWER_12V 1
@@ -55,14 +65,21 @@
* -1 wylacza funkcje (role pelni przycisk "aktywuj kolo"). */ * -1 wylacza funkcje (role pelni przycisk "aktywuj kolo"). */
#define PIN_LF_TRIGGER 25 #define PIN_LF_TRIGGER 25
/* Opcjonalny sygnal zaplonu / ACC (dzielnik 12 V -> 3.3 V). -1 = brak. */ /* Opcjonalny sygnal zaplonu / ACC (dzielnik 12 V -> ok. 3 V, jak VBAT).
#define PIN_ACC 32 * Bez podciagania wewnetrznego (INPUT) - dolna galaz dzielnika wymusza
* stan niski. Bez sygnalu: PIN_ACC = -1 (wtedy stale TX_INTERVAL_S).
* DOMYSLNIE -1 (wylaczone) - ustaw np. 32 po podlaczeniu dzielnika. */
#define PIN_ACC -1
/* Pomiar napiecia zasilania: dzielnik R1(gora)/R2(dol) na pin ADC1. /* Pomiar napiecia zasilania: dzielnik R1(gora)/R2(dol) na pin ADC1
* Uwaga: GPIO34/35/32/33 = ADC1, mozliwe rowniez jako wejscia EXT. */ * + kondensator 100 nF miedzy pinem a masa (ustalanie ADC).
* Dobor: 14,4 V (ladowanie) musi dac <= 3.0 V na wejsciu ADC,
* a prad dzielnika ma byc mikroamperowy (nie psuc budzetu snu):
* R1 = 1 M, R2 = 270 k -> 12 V: 2.55 V (~9 uA), 14.4 V: 3.05 V
* Zabezpieczenie wejscia: rezystor szeregowy + dioda klamujaca do 3V3. */
#define PIN_VBAT_ADC 34 #define PIN_VBAT_ADC 34
#define VBAT_DIVIDER_R1 100000.0f // ohm, gora (do zasilania) #define VBAT_DIVIDER_R1 1000000.0f // ohm, gora (do zasilania)
#define VBAT_DIVIDER_R2 33000.0f // ohm, dol (do masy) #define VBAT_DIVIDER_R2 270000.0f // ohm, dol (do masy)
#define VBAT_CAL 1.000f // mnoznik kalibracji (por. z multimetrem) #define VBAT_CAL 1.000f // mnoznik kalibracji (por. z multimetrem)
#define VBAT_SAMPLES 16 #define VBAT_SAMPLES 16
+76 -31
View File
@@ -6,17 +6,21 @@
* info - wersja, konfiguracja, stan, napiecie * info - wersja, konfiguracja, stan, napiecie
* hex [n|all] - hexdump ramki TPMS dla kola n (1-4) lub wszystkich * hex [n|all] - hexdump ramki TPMS dla kola n (1-4) lub wszystkich
* send [n|all] - wyslij burst ramki teraz * send [n|all] - wyslij burst ramki teraz
* batt - pomiar napiecia zasilania * batt - odczyt stanu baterii (napiecie zasilania)
* mode normal|learn|single [n] - zmiana trybu * mode normal|learn|single [n] - zmiana trybu
* next - kolejne kolo (learn/single) * next - kolejne kolo (learn/single)
* interval <s> - reczy ustalony interwal (0 = auto wg ACC) * interval <s> - reczy ustalony interwal (0 = auto wg ACC)
* flags <hex> - slowo flags wyslane w ramce * flags <hex> - slowo flags wyslane w ramce
* sleep - deep sleep teraz * sleep - deep sleep teraz
* stay [s] - zostan w stanie czuwania jeszcze s sekund * stay [s] - zostan w stanie czuwania jeszcze s sekund
*
* Parser jest scisly: zly argument = komunikat bledu, bez dzialania
* ubocznego (np. "send bla" NIE nadaje wszystkich kol).
*/ */
#include <Arduino.h> #include <Arduino.h>
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <errno.h>
#include "config.h" #include "config.h"
#include "app.h" #include "app.h"
@@ -24,6 +28,7 @@
static char line[64]; static char line[64];
static uint8_t line_len = 0; static uint8_t line_len = 0;
static bool line_overflow = false;
static void cmd_help(void) static void cmd_help(void)
{ {
@@ -41,6 +46,27 @@ static void cmd_help(void)
Serial.println(F(" stay [s] - czuwaj jeszcze s sekund")); Serial.println(F(" stay [s] - czuwaj jeszcze s sekund"));
} }
/* Scisly parser liczby calkowitej bez znaku z zakresem. */
static bool parse_u32(const char *s, uint32_t lo, uint32_t hi, uint32_t *out,
int base)
{
if (s == NULL || *s == '\0') {
return false;
}
errno = 0;
char *end = NULL;
unsigned long v = strtoul(s, &end, base);
if (errno != 0 || end == s || *end != '\0') {
return false;
}
if (v < (unsigned long)lo || v > (unsigned long)hi) {
return false;
}
*out = (uint32_t)v;
return true;
}
/* Numer kola 1-4 -> indeks 0-3; "all" -> 0xFF; blad -> -1. */
static int parse_wheel(const char *arg, uint8_t *wheel) static int parse_wheel(const char *arg, uint8_t *wheel)
{ {
if (arg == NULL) { if (arg == NULL) {
@@ -50,8 +76,8 @@ static int parse_wheel(const char *arg, uint8_t *wheel)
*wheel = 0xFF; *wheel = 0xFF;
return 0; return 0;
} }
long n = strtol(arg, NULL, 10); uint32_t n = 0;
if (n < 1 || n > WHEEL_COUNT) { if (!parse_u32(arg, 1, WHEEL_COUNT, &n, 10)) {
return -1; return -1;
} }
*wheel = (uint8_t)(n - 1); *wheel = (uint8_t)(n - 1);
@@ -66,6 +92,7 @@ static void handle_line(char *s)
} }
char *arg1 = strtok(NULL, " \t"); char *arg1 = strtok(NULL, " \t");
char *arg2 = strtok(NULL, " \t"); char *arg2 = strtok(NULL, " \t");
uint32_t u = 0;
if (strcmp(cmd, "help") == 0) { if (strcmp(cmd, "help") == 0) {
cmd_help(); cmd_help();
@@ -75,30 +102,31 @@ static void handle_line(char *s)
} }
else if (strcmp(cmd, "hex") == 0) { else if (strcmp(cmd, "hex") == 0) {
uint8_t w; uint8_t w;
if (parse_wheel(arg1, &w) != 0) { if (arg1 == NULL || strcmp(arg1, "all") == 0) {
w = 0xFF;
}
if (w == 0xFF) {
for (uint8_t i = 0; i < WHEEL_COUNT; i++) { for (uint8_t i = 0; i < WHEEL_COUNT; i++) {
app_print_frame(i); app_print_frame(i);
} }
} }
else { else if (parse_wheel(arg1, &w) == 0) {
app_print_frame(w); app_print_frame(w);
} }
else {
Serial.println(F("BLAD: hex [1-4|all]"));
}
} }
else if (strcmp(cmd, "send") == 0) { else if (strcmp(cmd, "send") == 0) {
uint8_t w; uint8_t w;
if (parse_wheel(arg1, &w) != 0) { if (arg1 == NULL || strcmp(arg1, "all") == 0) {
w = 0xFF;
}
if (w == 0xFF) {
app_send_burst_all(); app_send_burst_all();
Serial.println(F("OK"));
}
else if (parse_wheel(arg1, &w) == 0) {
app_send_burst_wheel(w);
Serial.println(F("OK"));
} }
else { else {
app_send_burst_wheel(w); Serial.println(F("BLAD: send [1-4|all]"));
} }
Serial.println(F("OK"));
} }
else if (strcmp(cmd, "batt") == 0) { else if (strcmp(cmd, "batt") == 0) {
Serial.printf("Vcc = %u mV\n", (unsigned)app_supply_mv()); Serial.printf("Vcc = %u mV\n", (unsigned)app_supply_mv());
@@ -109,54 +137,62 @@ static void handle_line(char *s)
else if (strcmp(cmd, "mode") == 0) { else if (strcmp(cmd, "mode") == 0) {
uint8_t w = 0; uint8_t w = 0;
if (arg1 == NULL) { if (arg1 == NULL) {
Serial.println(F("mode normal|learn|single [n]")); Serial.println(F("BLAD: mode normal|learn|single [n]"));
return; return;
} }
if (strcmp(arg1, "normal") == 0) { if (strcmp(arg1, "normal") == 0) {
app_set_mode(APP_MODE_NORMAL, 0); app_set_mode(APP_MODE_NORMAL, 0);
} }
else if (strcmp(arg1, "learn") == 0) { else if (strcmp(arg1, "learn") == 0) {
if (arg2 != NULL) { if (arg2 != NULL && parse_wheel(arg2, &w) != 0) {
if (parse_wheel(arg2, &w) != 0) { Serial.println(F("BLAD: numer kola 1-4"));
w = 0; return;
}
} }
app_set_mode(APP_MODE_LEARN, w); app_set_mode(APP_MODE_LEARN, w);
} }
else if (strcmp(arg1, "single") == 0) { else if (strcmp(arg1, "single") == 0) {
if (arg2 == NULL || parse_wheel(arg2, &w) != 0 || w == 0xFF) { if (arg2 == NULL || parse_wheel(arg2, &w) != 0 || w == 0xFF) {
Serial.println(F("single wymaga numeru kola 1-4")); Serial.println(F("BLAD: single wymaga numeru kola 1-4"));
return; return;
} }
app_set_mode(APP_MODE_SINGLE, w); app_set_mode(APP_MODE_SINGLE, w);
} }
else { else {
Serial.println(F("mode normal|learn|single [n]")); Serial.println(F("BLAD: mode normal|learn|single [n]"));
return; return;
} }
Serial.println(F("OK")); Serial.println(F("OK"));
} }
else if (strcmp(cmd, "interval") == 0) { else if (strcmp(cmd, "interval") == 0) {
if (arg1 == NULL) { if (!parse_u32(arg1, 0, 86400, &u, 10)) {
Serial.println(F("interval <s>")); Serial.println(F("BLAD: interval <0-86400>"));
return; return;
} }
app_set_interval((uint32_t)strtoul(arg1, NULL, 10)); app_set_interval(u);
Serial.println(F("OK")); Serial.println(F("OK"));
} }
else if (strcmp(cmd, "flags") == 0) { else if (strcmp(cmd, "flags") == 0) {
if (arg1 == NULL) { if (!parse_u32(arg1, 0, 0xFFFFFFFFu, &u, 16)) {
Serial.println(F("flags <hex>")); Serial.println(F("BLAD: flags <hex>"));
return; return;
} }
app_set_flags((uint32_t)strtoul(arg1, NULL, 16)); app_set_flags(u);
Serial.println(F("OK")); Serial.println(F("OK"));
} }
else if (strcmp(cmd, "sleep") == 0) { else if (strcmp(cmd, "sleep") == 0) {
app_request_sleep(); app_request_sleep();
} }
else if (strcmp(cmd, "stay") == 0) { else if (strcmp(cmd, "stay") == 0) {
app_stay_awake(arg1 ? (uint32_t)strtoul(arg1, NULL, 10) * 1000u : 60000u); if (arg1 == NULL) {
app_stay_awake(60000u);
}
else if (parse_u32(arg1, 0, 3600, &u, 10)) {
app_stay_awake(u * 1000u);
}
else {
Serial.println(F("BLAD: stay <0-3600>"));
return;
}
Serial.println(F("OK")); Serial.println(F("OK"));
} }
else { else {
@@ -167,6 +203,7 @@ static void handle_line(char *s)
void console_init(void) void console_init(void)
{ {
line_len = 0; line_len = 0;
line_overflow = false;
} }
void console_poll(void) void console_poll(void)
@@ -174,17 +211,25 @@ void console_poll(void)
while (Serial.available() > 0) { while (Serial.available() > 0) {
char c = (char)Serial.read(); char c = (char)Serial.read();
if (c == '\r' || c == '\n') { if (c == '\r' || c == '\n') {
if (line_len > 0) { if (line_overflow) {
Serial.println(F("BLAD: linia za dluga"));
}
else if (line_len > 0) {
line[line_len] = '\0'; line[line_len] = '\0';
handle_line(line); handle_line(line);
line_len = 0;
} }
line_len = 0;
line_overflow = false;
}
else if (line_overflow) {
/* po przeplenieniu porzucamy cala linie lacznie z ogonem */
} }
else if (line_len < sizeof(line) - 1u) { else if (line_len < sizeof(line) - 1u) {
line[line_len++] = c; line[line_len++] = c;
} }
else { else {
line_len = 0; // przepełnienie - porzuc linie line_overflow = true;
line_len = 0;
} }
} }
} }
+96 -21
View File
@@ -50,11 +50,14 @@ static const uint8_t LEARN_SEQ[WHEEL_COUNT] = {
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* Stan w RTC (przetrwuje deep sleep) */ /* Stan w RTC (przetrwuje deep sleep) */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
#define RTC_MAGIC 0x54504D53u // 'TPMS' /* Magic zwiazany z wersja konfiguracji: zmiana CONFIG_VERSION (np. po
* zmianie formatu stanu w RTC) zeruje caly stan po wybudzeniu. */
#define RTC_MAGIC (0x54504D53u ^ (uint32_t)CONFIG_VERSION) // 'TPMS' ^ version
RTC_DATA_ATTR static uint32_t rtc_magic; RTC_DATA_ATTR static uint32_t rtc_magic;
RTC_DATA_ATTR static uint8_t rtc_mode = APP_MODE_NORMAL; 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_seq_idx = 0; // pozycja w LEARN_SEQ (LEARN)
RTC_DATA_ATTR static uint8_t rtc_single_wheel = 0; // kolo w SINGLE (indeks SENSOR)
RTC_DATA_ATTR static uint8_t rtc_rot_idx = 0; // rotacja w NORMAL RTC_DATA_ATTR static 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_wake_count = 0;
RTC_DATA_ATTR static uint32_t rtc_interval_s = 0; // 0 = auto wg ACC RTC_DATA_ATTR static uint32_t rtc_interval_s = 0; // 0 = auto wg ACC
@@ -70,13 +73,33 @@ static uint32_t single_start = 0;
static bool request_sleep = false; static bool request_sleep = false;
static bool low_batt = false; static bool low_batt = false;
static uint32_t supply_mv = 0; static uint32_t supply_mv = 0;
#if PIN_LF_TRIGGER >= 0
static bool lf_prev = false; // poprzedni stan wejscia LF (zbocze)
#endif
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* Pomocnicze */ /* Pomocnicze */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
static uint32_t compute_interval(void);
/* Aktywne kolo: SINGLE trzyma bezposredni indeks SENSOR, LEARN - pozycje
* w sekwencji nauki LEARN_SEQ (moga sie roznic po zmianie LEARN_ORDER_*). */
static uint8_t active_wheel(void) static uint8_t active_wheel(void)
{ {
return LEARN_SEQ[rtc_seq_idx % WHEEL_COUNT]; return (rtc_mode == APP_MODE_SINGLE)
? (uint8_t)(rtc_single_wheel % WHEEL_COUNT)
: LEARN_SEQ[rtc_seq_idx % WHEEL_COUNT];
}
/* Pozycja kola w sekwencji nauki (do trybu LEARN). */
static uint8_t seq_pos_of(uint8_t wheel)
{
for (uint8_t i = 0; i < WHEEL_COUNT; i++) {
if (LEARN_SEQ[i] == wheel) {
return i;
}
}
return 0;
} }
static void refresh_power(void) static void refresh_power(void)
@@ -95,13 +118,14 @@ void app_send_burst_wheel(uint8_t wheel)
{ {
uint8_t frame[TPMS_TX_BYTES]; uint8_t frame[TPMS_TX_BYTES];
build_frame_for(wheel, frame); build_frame_for(wheel, frame);
radio_send_burst(frame, TPMS_TX_BYTES, TX_BURST_FRAMES); bool ok = radio_send_burst(frame, TPMS_TX_BYTES, TX_BURST_FRAMES);
Serial.printf("TX %s id=%06X %.1f kPa %d C flags=%08X%s\n", Serial.printf("TX %s id=%06X %.1f kPa %d C flags=%08X%s%s\n",
SENSOR[wheel % WHEEL_COUNT].name, SENSOR[wheel % WHEEL_COUNT].name,
(unsigned)SENSOR[wheel % WHEEL_COUNT].id, (unsigned)SENSOR[wheel % WHEEL_COUNT].id,
SENSOR[wheel % WHEEL_COUNT].press_kpa10 / 10.0f, SENSOR[wheel % WHEEL_COUNT].press_kpa10 / 10.0f,
(int)SENSOR[wheel % WHEEL_COUNT].temp_c, (int)SENSOR[wheel % WHEEL_COUNT].temp_c,
(unsigned)rtc_flags, low_batt ? " LOWBATT" : ""); (unsigned)rtc_flags, low_batt ? " LOWBATT" : "",
ok ? "" : " TX-ERR");
} }
void app_send_burst_all(void) void app_send_burst_all(void)
@@ -149,7 +173,7 @@ void app_print_info(void)
(unsigned)rtc_flags, (unsigned)rtc_flags,
TPMS_MODULATION == MODE_FSK ? "FSK" : "OOK", TPMS_MODULATION == MODE_FSK ? "FSK" : "OOK",
TPMS_CHIP_US, TX_BURST_FRAMES, TPMS_CHIP_US, TX_BURST_FRAMES,
(unsigned)(rtc_interval_s ? rtc_interval_s : TX_INTERVAL_S), (unsigned)compute_interval(),
(unsigned long)rtc_wake_count); (unsigned long)rtc_wake_count);
Serial.printf("Vcc=%u mV%s\n", (unsigned)supply_mv, low_batt ? " LOWBATT" : ""); Serial.printf("Vcc=%u mV%s\n", (unsigned)supply_mv, low_batt ? " LOWBATT" : "");
} }
@@ -195,10 +219,14 @@ uint8_t app_wheel(void)
void app_next_wheel(void) void app_next_wheel(void)
{ {
if (rtc_mode == APP_MODE_SINGLE) {
rtc_single_wheel = (uint8_t)((rtc_single_wheel + 1) % WHEEL_COUNT);
}
else {
rtc_seq_idx = (uint8_t)((rtc_seq_idx + 1) % WHEEL_COUNT); 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, ui_blink_count((uint8_t)(active_wheel() + 1));
(int)rtc_seq_idx + 1, WHEEL_COUNT); Serial.printf("Kolo: %s\n", SENSOR[active_wheel()].name);
learn_window_start = millis(); learn_window_start = millis();
} }
@@ -207,21 +235,21 @@ void app_set_mode(uint8_t mode, uint8_t wheel)
rtc_mode = mode; rtc_mode = mode;
switch (mode) { switch (mode) {
case APP_MODE_LEARN: case APP_MODE_LEARN:
rtc_seq_idx = (uint8_t)(wheel % WHEEL_COUNT); rtc_seq_idx = seq_pos_of((uint8_t)(wheel % WHEEL_COUNT));
learn_window_start = millis(); learn_window_start = millis();
learn_session_start = millis(); learn_session_start = millis();
next_tx_ms = 0; next_tx_ms = 0;
ui_set_pattern(UI_PAT_LEARN); ui_set_pattern(UI_PAT_LEARN);
ui_blink_count((uint8_t)(rtc_seq_idx + 1)); ui_blink_count((uint8_t)(active_wheel() + 1));
Serial.printf("LEARN start, kolo %s\n", SENSOR[active_wheel()].name); Serial.printf("LEARN start, kolo %s\n", SENSOR[active_wheel()].name);
app_stay_awake(LEARN_TOTAL_TIMEOUT_MS); app_stay_awake(LEARN_TOTAL_TIMEOUT_MS);
break; break;
case APP_MODE_SINGLE: case APP_MODE_SINGLE:
rtc_seq_idx = (uint8_t)(wheel % WHEEL_COUNT); rtc_single_wheel = (uint8_t)(wheel % WHEEL_COUNT);
single_start = millis(); single_start = millis();
next_tx_ms = 0; next_tx_ms = 0;
ui_set_pattern(UI_PAT_SINGLE); ui_set_pattern(UI_PAT_SINGLE);
ui_blink_count((uint8_t)(rtc_seq_idx + 1)); ui_blink_count((uint8_t)(active_wheel() + 1));
Serial.printf("SINGLE start, kolo %s\n", SENSOR[active_wheel()].name); Serial.printf("SINGLE start, kolo %s\n", SENSOR[active_wheel()].name);
app_stay_awake(SINGLE_TIMEOUT_MS ? SINGLE_TIMEOUT_MS : 3600000u); app_stay_awake(SINGLE_TIMEOUT_MS ? SINGLE_TIMEOUT_MS : 3600000u);
break; break;
@@ -243,17 +271,21 @@ static uint32_t compute_interval(void)
if (rtc_interval_s != 0) { if (rtc_interval_s != 0) {
return rtc_interval_s; return rtc_interval_s;
} }
uint64_t now_ms = power_elapsed_ms() + millis(); #if PIN_ACC < 0
#if PIN_ACC >= 0 /* Bez wejscia ACC stale pracujemy z interwalem podstawowym - logika
* "5 min po zaniku ACC" nie ma wtedy zastosowania. */
return (uint32_t)TX_INTERVAL_S;
#else
uint64_t now_ms = power_elapsed_ms();
if (digitalRead(PIN_ACC) == HIGH) { if (digitalRead(PIN_ACC) == HIGH) {
rtc_last_acc_ms = now_ms; rtc_last_acc_ms = now_ms;
return (uint32_t)TX_INTERVAL_IGNITION_S; return (uint32_t)TX_INTERVAL_IGNITION_S;
} }
#endif
if (now_ms - rtc_last_acc_ms > (uint64_t)ACC_GRACE_MS) { if (now_ms - rtc_last_acc_ms > (uint64_t)ACC_GRACE_MS) {
return PARKING_SHUTDOWN ? 0u : (uint32_t)TX_INTERVAL_PARKING_S; return PARKING_SHUTDOWN ? 0u : (uint32_t)TX_INTERVAL_PARKING_S;
} }
return (uint32_t)TX_INTERVAL_S; return (uint32_t)TX_INTERVAL_S;
#endif
} }
static void tx_cycle(void) static void tx_cycle(void)
@@ -262,11 +294,35 @@ static void tx_cycle(void)
app_send_burst_all(); app_send_burst_all();
} }
/* Czy ktorekolwiek zrodlo budzenia poziomowego jest aktywne? */
static bool wake_sources_active(void)
{
if (ui_button_down() || digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL) {
return true;
}
#if PIN_LF_TRIGGER >= 0
if (digitalRead(PIN_LF_TRIGGER) == HIGH) {
return true;
}
#endif
return false;
}
static void go_sleep(uint32_t seconds) static void go_sleep(uint32_t seconds)
{ {
/* Nie spij, dopoki przycisk jest wcisniety lub LF aktywne - EXT0/EXT1
* dzialaja poziomowo, wiec sen przy aktywnym zrodle = natychmiastowa
* petla wybudzen. Dajemy krotki margines i wracamy do petli. */
if (wake_sources_active()) {
app_stay_awake(500);
return;
}
ui_set_pattern(UI_PAT_OFF);
digitalWrite(PIN_LED, LOW);
Serial.printf("sleep %us\n", (unsigned)seconds); Serial.printf("sleep %us\n", (unsigned)seconds);
Serial.flush(); Serial.flush();
power_elapsed_add_ms(millis() + (uint64_t)seconds * 1000u);
power_deep_sleep(seconds); // nie wraca power_deep_sleep(seconds); // nie wraca
} }
@@ -282,13 +338,16 @@ void setup(void)
pinMode(PIN_LF_TRIGGER, INPUT_PULLDOWN); pinMode(PIN_LF_TRIGGER, INPUT_PULLDOWN);
#endif #endif
#if PIN_ACC >= 0 #if PIN_ACC >= 0
pinMode(PIN_ACC, INPUT_PULLDOWN); /* INPUT (bez podciagania): dolna galazka dzielnika wymusza stan niski,
* a wewnetrzny pulldown (~45 k) obciazylby dzielnik i zbil prog VIH. */
pinMode(PIN_ACC, INPUT);
#endif #endif
if (rtc_magic != RTC_MAGIC) { if (rtc_magic != RTC_MAGIC) {
rtc_magic = RTC_MAGIC; rtc_magic = RTC_MAGIC;
rtc_mode = APP_MODE_NORMAL; rtc_mode = APP_MODE_NORMAL;
rtc_seq_idx = 0; rtc_seq_idx = 0;
rtc_single_wheel = 0;
rtc_rot_idx = 0; rtc_rot_idx = 0;
rtc_wake_count = 0; rtc_wake_count = 0;
rtc_interval_s = 0; rtc_interval_s = 0;
@@ -364,6 +423,18 @@ void setup(void)
ui_set_pattern(low_batt ? UI_PAT_LOWBAT : UI_PAT_NORMAL); ui_set_pattern(low_batt ? UI_PAT_LOWBAT : UI_PAT_NORMAL);
} }
/* Po wybudzeniu przyciskiem/LF obsluzylismy juz akcje - nie powtarzaj
* cyklu natychmiast, tylko odloz go o pelny okres. */
if (cause == ESP_SLEEP_WAKEUP_EXT0 || cause == ESP_SLEEP_WAKEUP_EXT1) {
if (rtc_mode != APP_MODE_NORMAL) {
next_tx_ms = millis() + LEARN_TX_PERIOD_MS;
}
}
#if PIN_LF_TRIGGER >= 0
/* LF ciagle aktywne = brak nowego zbocza = brak kolejnego bursta */
lf_prev = (digitalRead(PIN_LF_TRIGGER) == HIGH);
#endif
Serial.printf("Vcc=%u mV tryb=%d interwal=%us\n", (unsigned)supply_mv, Serial.printf("Vcc=%u mV tryb=%d interwal=%us\n", (unsigned)supply_mv,
(int)rtc_mode, (unsigned)iv); (int)rtc_mode, (unsigned)iv);
app_print_info(); app_print_info();
@@ -400,7 +471,7 @@ void loop(void)
app_set_mode(APP_MODE_NORMAL, 0); app_set_mode(APP_MODE_NORMAL, 0);
} }
else { else {
app_set_mode(APP_MODE_SINGLE, rtc_seq_idx); app_set_mode(APP_MODE_SINGLE, active_wheel());
} }
} }
@@ -409,11 +480,15 @@ void loop(void)
#if PIN_LF_TRIGGER >= 0 #if PIN_LF_TRIGGER >= 0
/* aktywacja LF tez dziala "na zywo" (nie tylko przez budzenie) */ /* aktywacja LF tez dziala "na zywo" (nie tylko przez budzenie) */
{ {
static bool lf_prev = false;
bool lf = (digitalRead(PIN_LF_TRIGGER) == HIGH); bool lf = (digitalRead(PIN_LF_TRIGGER) == HIGH);
if (lf && !lf_prev) { if (lf && !lf_prev) {
refresh_power(); refresh_power();
app_send_burst_wheel(active_wheel()); app_send_burst_wheel(active_wheel());
/* po recznej transmisji odloz cykl - bez tego LF moglby
* wywolac 2-3 bursty zamiast jednego */
if (rtc_mode != APP_MODE_NORMAL) {
next_tx_ms = millis() + LEARN_TX_PERIOD_MS;
}
} }
lf_prev = lf; lf_prev = lf;
} }
+19 -11
View File
@@ -13,13 +13,12 @@
#include <esp_sleep.h> #include <esp_sleep.h>
#include <driver/gpio.h> #include <driver/gpio.h>
#include <esp32-hal-bt.h> #include <esp32-hal-bt.h>
#include <sys/time.h>
#include "config.h" #include "config.h"
#include "power.h" #include "power.h"
#include "radio.h" #include "radio.h"
RTC_DATA_ATTR static uint64_t rtc_elapsed_ms = 0;
void power_init(void) void power_init(void)
{ {
/* Zwolnij hold z poprzedniego snu - po deep sleep piny sa zatrzymane. */ /* Zwolnij hold z poprzedniego snu - po deep sleep piny sa zatrzymane. */
@@ -65,12 +64,17 @@ void power_deep_sleep(uint32_t seconds)
/* Budzik RTC. */ /* Budzik RTC. */
esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_ALL); esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_ALL);
if (seconds > 0) { if (seconds > 0) {
esp_sleep_enable_timer_wakeup((uint64_t)seconds * 1000000ULL); if (esp_sleep_enable_timer_wakeup((uint64_t)seconds * 1000000ULL) != ESP_OK) {
Serial.println(F("power: blad konfiguracji budzika RTC"));
}
} }
/* Przycisk jako zrodlo EXT0 (poziom konfigurowalny). */ /* Przycisk jako zrodlo EXT0 (poziom konfigurowalny). */
#if PIN_BUTTON >= 0 #if PIN_BUTTON >= 0
esp_sleep_enable_ext0_wakeup((gpio_num_t)PIN_BUTTON, BTN_ACTIVE_LEVEL); if (esp_sleep_enable_ext0_wakeup((gpio_num_t)PIN_BUTTON, BTN_ACTIVE_LEVEL)
!= ESP_OK) {
Serial.println(F("power: blad konfiguracji EXT0 (pin nie RTC?)"));
}
#endif #endif
/* Opcjonalne wejscie LF 125 kHz (impuls wysoki) jako EXT1. /* Opcjonalne wejscie LF 125 kHz (impuls wysoki) jako EXT1.
@@ -81,7 +85,10 @@ void power_deep_sleep(uint32_t seconds)
ext1_mask |= (1ULL << PIN_LF_TRIGGER); ext1_mask |= (1ULL << PIN_LF_TRIGGER);
#endif #endif
if (ext1_mask != 0) { if (ext1_mask != 0) {
esp_sleep_enable_ext1_wakeup(ext1_mask, ESP_EXT1_WAKEUP_ANY_HIGH); if (esp_sleep_enable_ext1_wakeup(ext1_mask, ESP_EXT1_WAKEUP_ANY_HIGH)
!= ESP_OK) {
Serial.println(F("power: blad konfiguracji EXT1 (pin nie RTC?)"));
}
} }
esp_deep_sleep_start(); esp_deep_sleep_start();
@@ -89,10 +96,11 @@ void power_deep_sleep(uint32_t seconds)
uint64_t power_elapsed_ms(void) uint64_t power_elapsed_ms(void)
{ {
return rtc_elapsed_ms; /* System time jest utrzymywany przez RTC i przywracany po deep sleep,
} * wiec licznik rosnie o rzeczywisty czas (takze ten spedzony w snie),
* a nie o planowany interwal - wczesniejsze wybudzenia (przycisk/LF)
void power_elapsed_add_ms(uint64_t delta_ms) * nie zaklamuja wtedy logiki "5 min po zaniku ACC". */
{ struct timeval tv;
rtc_elapsed_ms += delta_ms; gettimeofday(&tv, NULL);
return (uint64_t)tv.tv_sec * 1000u + (uint64_t)(tv.tv_usec / 1000);
} }
+4 -3
View File
@@ -24,10 +24,11 @@ bool power_low_battery(uint32_t mV);
* przycisk/LF). Funkcja nie wraca. */ * przycisk/LF). Funkcja nie wraca. */
void power_deep_sleep(uint32_t seconds); void power_deep_sleep(uint32_t seconds);
/* Suma czasu pracy [ms] od pierwszego uruchomienia - licznik w RTC /* Czas rzeczywisty [ms] od startu systemu - licznik RTC przetrwuje deep
* przetrwuje deep sleep; uzywane do logiki "5 min po zaniku ACC". */ * sleep (ESP32 przywraca czas z RTC po wybudzeniu), wiec rosnie o rzeczywisty
* czas spedzony w snie, nie o planowany interwal. Uzywane do logiki
* "5 min po zaniku ACC". */
uint64_t power_elapsed_ms(void); uint64_t power_elapsed_ms(void);
void power_elapsed_add_ms(uint64_t delta_ms);
#ifdef __cplusplus #ifdef __cplusplus
} }
+38 -20
View File
@@ -20,19 +20,17 @@
static bool radio_ok = false; static bool radio_ok = false;
/* ------------------------------------------------------------------ */
/* Inicjalizacja pinow */
/* Wymagana biblioteka SmartRC-CC1101-Driver-Lib >= 2.5.7 */
/* (wspolne API setSpiPin/setGDO0 dla wersji 2.5.x i 3.x; */
/* starsze 1.x mialy setSCK/setMISO/... - nie sa obslugiwane). */
/* ------------------------------------------------------------------ */
static void radio_set_pins(void) 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, ELECHOUSE_cc1101.setSpiPin(PIN_CC1101_SCK, PIN_CC1101_MISO,
PIN_CC1101_MOSI, PIN_CC1101_CS); PIN_CC1101_MOSI, PIN_CC1101_CS);
ELECHOUSE_cc1101.setGDO0(PIN_CC1101_GDO0); 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) bool radio_init(void)
@@ -80,10 +78,10 @@ bool radio_init(void)
return true; return true;
} }
void radio_send_frame(const uint8_t *buf, uint8_t len) bool radio_send_frame(const uint8_t *buf, uint8_t len)
{ {
if (!radio_ok) { if (!radio_ok) {
return; return false;
} }
ELECHOUSE_cc1101.SpiStrobe(CC1101_SIDLE); ELECHOUSE_cc1101.SpiStrobe(CC1101_SIDLE);
@@ -91,31 +89,51 @@ void radio_send_frame(const uint8_t *buf, uint8_t len)
ELECHOUSE_cc1101.SpiWriteBurstReg(CC1101_TXFIFO, (uint8_t *)buf, len); ELECHOUSE_cc1101.SpiWriteBurstReg(CC1101_TXFIFO, (uint8_t *)buf, len);
ELECHOUSE_cc1101.SpiStrobe(CC1101_STX); ELECHOUSE_cc1101.SpiStrobe(CC1101_STX);
/* Czekamy az caly bufor wyjdzie na antene: FIFO puste + margines na /* Pelny czas serializacji bufora na antenie: sprzet wysyla dokladnie
* ostatni chip. Blokada krotka (~30 ms) i niezbedna do zakonczenia * len*8 chipow z predkoscia DRate. UWAGA: TXBYTES == 0 NIE oznacza
* transmisji - poza tym petla glowna nie uzywa delay(). */ * konca transmisji - po oproznieniu FIFO ostatni bajt jest dopiero
uint32_t air_us = (uint32_t)len * 8u * (uint32_t)TPMS_CHIP_US + 3000u; * w rejestrze przesuwnym (8 chipow = 8*TPMS_CHIP_US), wiec wczesniejsze
* SIDLE obcialoby ogon ramki. Czekamy zatem na policzony czas + maly
* margines i dopiero wtedy wychodzimy z TX. */
uint32_t air_us = (uint32_t)len * 8u * (uint32_t)TPMS_CHIP_US + 1000u;
uint32_t t0 = micros(); uint32_t t0 = micros();
while ((uint32_t)(micros() - t0) < air_us) { while ((uint32_t)(micros() - t0) < air_us) {
uint8_t txb = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES); delayMicroseconds(500);
if ((txb & 0x7Fu) == 0) {
delayMicroseconds(2u * TPMS_CHIP_US); // ostatni chip na antenie
break;
} }
/* Diagnostyka po zakonczeniu: dwa zgodne odczyty (errata CC1101),
* kontrola niedopelnienia FIFO i tego, czy bufor zostal faktycznie
* wyslany. Zwracamy blad zamiast udawac sukces. */
bool ok = true;
uint8_t txb = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES);
uint8_t txb2 = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES);
if (txb != txb2) {
txb = txb2;
}
if (txb & 0x80u) { // TXFIFO_UNDERFLOW
ok = false;
}
if ((txb & 0x7Fu) != 0) { // cos zostalo w FIFO - transmisja nie wyszla
ok = false;
} }
ELECHOUSE_cc1101.SpiStrobe(CC1101_SIDLE); ELECHOUSE_cc1101.SpiStrobe(CC1101_SIDLE);
ELECHOUSE_cc1101.SpiStrobe(CC1101_SFTX); ELECHOUSE_cc1101.SpiStrobe(CC1101_SFTX);
return ok;
} }
void radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames) bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames)
{ {
bool ok = true;
for (uint8_t i = 0; i < frames; i++) { for (uint8_t i = 0; i < frames; i++) {
radio_send_frame(buf, len); if (!radio_send_frame(buf, len)) {
ok = false;
}
if (i + 1u < frames) { if (i + 1u < frames) {
delay(TX_FRAME_GAP_MS); delay(TX_FRAME_GAP_MS);
} }
} }
return ok;
} }
void radio_sleep(void) void radio_sleep(void)
+6 -4
View File
@@ -16,11 +16,13 @@ extern "C" {
bool radio_init(void); bool radio_init(void);
/* Wyslij jeden bufor nadawczy (TPMS_TX_BYTES) - blokujace do zakonczenia /* Wyslij jeden bufor nadawczy (TPMS_TX_BYTES) - blokujace do zakonczenia
* transmisji na eterze (~29 ms). */ * transmisji na eterze (dokladnie len*8 chipow, ~29 ms). Zwraca false
void radio_send_frame(const uint8_t *buf, uint8_t len); * przy niedopelnieniu FIFO / niezakonczonej transmisji. */
bool radio_send_frame(const uint8_t *buf, uint8_t len);
/* Burts: n ramek tego samego bufora z odstepem TX_FRAME_GAP_MS. */ /* Burst: 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); * Zwraca false, jesli ktorykolwiek z ramek sie nie udal. */
bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames);
/* CC1101 do trybu SLEEP (<1 uA) + przygotowanie linii pod gpio_hold. */ /* CC1101 do trybu SLEEP (<1 uA) + przygotowanie linii pod gpio_hold. */
void radio_sleep(void); void radio_sleep(void);
+9
View File
@@ -37,6 +37,15 @@ extern "C" {
#define TPMS_TX_BYTES 30 // 240 chipow = 1 lead + 238 danych + 1 padding #define TPMS_TX_BYTES 30 // 240 chipow = 1 lead + 238 danych + 1 padding
#define TPMS_TX_CHIPS (TPMS_TX_BYTES * 8) #define TPMS_TX_CHIPS (TPMS_TX_BYTES * 8)
#ifdef __cplusplus
/* Zaleznosc bufora nadawczego od dlugosci ramki: 1 chip rozbiegowy +
* 2 chipy na kazdy z (TPMS_ROW_BITS-1) bitow (pierwszy bit dopisuje
* odbiornik) + padding do granicy bajtu (< 8 chipow). */
static_assert(TPMS_TX_CHIPS >= 1 + 2 * (TPMS_ROW_BITS - 1)
&& TPMS_TX_CHIPS < 1 + 2 * (TPMS_ROW_BITS - 1) + 8,
"TPMS_TX_BYTES musi miescic 1 + 2*(TPMS_ROW_BITS-1) chipow");
#endif
typedef struct { typedef struct {
uint32_t id; // 24-bit identyfikator czujnika uint32_t id; // 24-bit identyfikator czujnika
uint16_t press_kpa10; // cisnienie w kPa * 10 (np. 2600 = 260.0 kPa) uint16_t press_kpa10; // cisnienie w kPa * 10 (np. 2600 = 260.0 kPa)
+20 -9
View File
@@ -6,9 +6,12 @@
#include "ui.h" #include "ui.h"
/* ---------------------------- przycisk ---------------------------- */ /* ---------------------------- przycisk ---------------------------- */
/* Debounce: nowy stan surowy musi sie utrzymac BTN_DEBOUNCE_MS, zanim
* zostanie uznany za stan stabilny (kandydat + czas jego zmiany). */
static bool btn_raw_last = false; // ostatni surowy odczyt
static uint32_t btn_raw_change = 0; // czas ostatniej zmiany surowej
static bool btn_stable = false; // stan po debounce static bool btn_stable = false; // stan po debounce
static uint32_t btn_last_change = 0;
static uint32_t btn_press_start = 0; static uint32_t btn_press_start = 0;
static bool btn_long_fired = false; // bardzo dlugie zdarzenie juz wyslane static bool btn_long_fired = false; // bardzo dlugie zdarzenie juz wyslane
@@ -22,8 +25,14 @@ void ui_init(void)
pinMode(PIN_BUTTON, BTN_ACTIVE_LEVEL ? INPUT_PULLDOWN : INPUT_PULLUP); pinMode(PIN_BUTTON, BTN_ACTIVE_LEVEL ? INPUT_PULLDOWN : INPUT_PULLUP);
pinMode(PIN_LED, OUTPUT); pinMode(PIN_LED, OUTPUT);
digitalWrite(PIN_LED, LOW); digitalWrite(PIN_LED, LOW);
btn_stable = (digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL);
btn_last_change = millis(); uint32_t now = millis();
bool raw = (digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL);
btn_raw_last = raw;
btn_raw_change = now;
btn_stable = raw;
btn_press_start = now; // start z wcisnietym przyciskiem = poczatek gestu
btn_long_fired = false;
} }
ui_event_t ui_poll(void) ui_event_t ui_poll(void)
@@ -32,22 +41,24 @@ ui_event_t ui_poll(void)
bool raw = (digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL); bool raw = (digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL);
uint32_t now = millis(); uint32_t now = millis();
if (raw != btn_stable && (now - btn_last_change) >= BTN_DEBOUNCE_MS) { if (raw != btn_raw_last) {
btn_last_change = now; /* kandydat - czekaj az stan sie utrzyma */
btn_stable = raw; btn_raw_last = raw;
btn_raw_change = now;
}
else if (raw != btn_stable && (now - btn_raw_change) >= BTN_DEBOUNCE_MS) {
btn_stable = raw; // zaakceptowany po debounce
if (btn_stable) { if (btn_stable) {
btn_press_start = now; btn_press_start = now;
btn_long_fired = false; btn_long_fired = false;
} }
else { else if (!btn_long_fired) {
uint32_t held = now - btn_press_start; uint32_t held = now - btn_press_start;
if (!btn_long_fired) {
if (held >= BTN_VERYLONG_MS) ev = UI_EV_VERYLONG; if (held >= BTN_VERYLONG_MS) ev = UI_EV_VERYLONG;
else if (held >= BTN_LONG_MS) ev = UI_EV_LONG; else if (held >= BTN_LONG_MS) ev = UI_EV_LONG;
else ev = UI_EV_SHORT; else ev = UI_EV_SHORT;
} }
} }
}
/* bardzo dlugi przycisk sygnalizujemy od razu (nie czekajac na puszczenie) */ /* bardzo dlugi przycisk sygnalizujemy od razu (nie czekajac na puszczenie) */
if (btn_stable && !btn_long_fired && (now - btn_press_start) >= BTN_VERYLONG_MS) { if (btn_stable && !btn_long_fired && (now - btn_press_start) >= BTN_VERYLONG_MS) {
+16
View File
@@ -82,6 +82,21 @@ static void test_pressure_scale(void)
TEST_ASSERT_EQUAL_HEX8(0, p[8]); TEST_ASSERT_EQUAL_HEX8(0, p[8]);
} }
static void test_pressure_rounding(void)
{
uint8_t p[TPMS_PAYLOAD_LEN];
/* skala 2.5 kPa/bit = 25 kPa*10/bit, zaokraglenie w gore do pol bitu:
* bajt = (kpa10 + 12) / 25 */
tpms_build_payload(p, 1, 12, 0, 0x4C900070u, false); // 1.2 kPa -> 0
TEST_ASSERT_EQUAL_HEX8(0, p[7]);
tpms_build_payload(p, 1, 13, 0, 0x4C900070u, false); // 1.3 kPa -> 1
TEST_ASSERT_EQUAL_HEX8(1, p[7]);
tpms_build_payload(p, 1, 2588, 0, 0x4C900070u, false); // 258.8 kPa -> 104
TEST_ASSERT_EQUAL_HEX8(104, p[7]);
tpms_build_payload(p, 1, 2587, 0, 0x4C900070u, false); // 258.7 kPa -> 103
TEST_ASSERT_EQUAL_HEX8(103, p[7]);
}
static void test_checksum(void) static void test_checksum(void)
{ {
uint8_t p[TPMS_PAYLOAD_LEN]; uint8_t p[TPMS_PAYLOAD_LEN];
@@ -121,6 +136,7 @@ int main(int argc, char **argv)
RUN_TEST(test_frame_vectors); RUN_TEST(test_frame_vectors);
RUN_TEST(test_reference_capture); RUN_TEST(test_reference_capture);
RUN_TEST(test_pressure_scale); RUN_TEST(test_pressure_scale);
RUN_TEST(test_pressure_rounding);
RUN_TEST(test_checksum); RUN_TEST(test_checksum);
RUN_TEST(test_low_batt_flag); RUN_TEST(test_low_batt_flag);
RUN_TEST(test_frame_layout); RUN_TEST(test_frame_layout);
+4
View File
@@ -79,6 +79,10 @@ def main() -> int:
print(f"frame: {len(bits)} chips, tx bytes:" 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))}") f" {' '.join(f'{int(bits[i:i+8],2):02X}' for i in range(0, len(bits), 8))}")
out_dir = os.path.dirname(os.path.abspath(args.out))
if out_dir:
os.makedirs(out_dir, exist_ok=True)
rng = random.Random(1) rng = random.Random(1)
gap_sps = int(SAMPLE_RATE * args.gap_ms / 1000) gap_sps = int(SAMPLE_RATE * args.gap_ms / 1000)
out = [] out = []
+5 -2
View File
@@ -42,7 +42,7 @@ import sys
CHIP_US = 120.0 # one Manchester half bit-cell, 8.333 kBaud chip rate CHIP_US = 120.0 # one Manchester half bit-cell, 8.333 kBaud chip rate
FRAME_BITS = 120 # decoded row length expected by schrader_EG53MA4 FRAME_BITS = 120 # decoded row length expected by schrader_EG53MA4
SYNC_BITS = 40 SYNC_BITS = 40
TX_BYTES = 31 # 1 lead chip + 238 data chips + 9 pad chips = 248 chips TX_BYTES = 30 # 240 chips = 1 lead + 238 data + 1 pad
DEFAULT_FLAGS = 0x4C900070 # captured from real EG53MA4 sensors DEFAULT_FLAGS = 0x4C900070 # captured from real EG53MA4 sensors
@@ -86,7 +86,10 @@ def build_row(sensor_id: int, pressure_kpa: float, temp_c: float,
def build_tx_bits(row: str) -> str: def build_tx_bits(row: str) -> str:
"""Return the 248 chip long bit string actually shifted into the CC1101 FIFO.""" """Return the chip bit string actually shifted into the CC1101 FIFO.
240 chips: 1 lead chip + 119 two-chip cells + 1 pad chip = 30 bytes.
"""
assert len(row) == FRAME_BITS assert len(row) == FRAME_BITS
bits = "1" # lead chip (carrier on) bits = "1" # lead chip (carrier on)
for b in row[1:]: # row[0] is synthesised by the receiver for b in row[1:]: # row[0] is synthesised by the receiver