Dokumentacja: Quick Start bezpieczenstwo protokol HIL i RC
check / check-without-hardware (push) Canceled after 0s

This commit is contained in:
czcionka committed 2026-10-27 18:17:25 +00:00
1 parent 17d2cea3ea
commit 1fdb0c7cce
13 files changed
+1195 -664

No files matched your search

+62
View File
@@ -0,0 +1,62 @@
# Changelog
## 2.0.0-rc.1 — 2026-10-27
Release candidate bez testu fizycznego CC1101 i samochodu.
### Dodane
- Trwała konfiguracja NVS z wersją, CRC32, walidacją zakresów, unikalnymi ID,
przywracaniem fabrycznym i bezpiecznymi domyślnymi.
- Konsola: Clone IDs, generator nowych ID, ciśnienia/temperatura, interwały,
ograniczone RF, LEARN/SINGLE i diagnostyka bez rekompilacji.
- Przenośna maszyna stanów z fake clock/radio, timeoutami i kolejnością
FL→FR→RR→RL. Testy restartu, ACC, błędów radia i zawinięcia `millis()`.
- Niezależna walidacja czterech nagrań referencyjnych oraz syntetycznych CU8
przypiętym rtl_433; testy negatywne checksum/Manchester/ucięcie.
- `tools/check_all`, Dockerfile, Gitea Actions, skrypty obrazów i SHA-256.
- Polska dokumentacja użytkownika, sprzętu, zasilania, bezpieczeństwa i HIL.
### Zmienione
- Domyślnie 260 kPa i −10 dBm, tylko OOK. Zachowany enkoder 30 B Manchester,
który przechodzi niezależne dekodowanie.
- CC1101 czeka na `MARCSTATE=IDLE`, kontroluje underflow i pozostałe bajty,
zamiast polegać wyłącznie na czasie i `TXBYTES=0`.
- Zwykły RTC nie otwiera okna konsoli; transmisja i powrót do snu ograniczają
szacowany pobór. Okno konsoli pozostaje po interakcji użytkownika.
- Pełny build z `-Wall -Wextra -Werror`; cppcheck bez defektów.
### Usunięte / naprawione
- Usunięto zgadywany `TPMS_FLAGS_LOWBAT_MASK` i sprzężenie niskiego zasilania
emulatora z symulowanym sensorem. Zasilanie jest tylko ostrzeżeniem lokalnym.
- Usunięto FSK z głównego flow: brak dowodu dla analizowanego profilu.
- Usunięto `PARKING_SHUTDOWN`; każdy deep sleep ma RTC, więc restart ACC nie
może zostawić urządzenia trwale uśpionego.
- Domyślne, niezwalidowane wejście LF jest wyłączone. Podstawowy LEARN nie
wymaga EL-50448.
- Usunięto rekomendację MCP1703 + TVS 24 V jako ochrony automotive i obietnice
wieloletniej pracy baterii. Zasilanie 12 V ma wymagania projektowe, nie HIL.
### Iteracje audytu
1. **Stan początkowy:** 7/7 native i build PASS, ale konfiguracja przez
rekompilację, monolit stanów, lowbat i zasilanie wymagały naprawy. Utworzono
`archive/pre-opencode`.
2. **Model danych:** dodano NVS/CRC/walidację i przenośne tryby. Pierwszy test
wykrył błędne oczekiwania testów dla zaległego tick i natychmiastowego TX;
po korekcji 20/20 native i ESP32 build PASS.
3. **Walidacja RF:** audyt czterech nagrań potwierdził 16 powtórzeń i zmienne
odstępy. Zastąpiono pojedynczy wektor pełnym skryptem; 64/64 referencji,
3/3 syntetycznych i 3/3 negatywnych PASS.
4. **Energia:** wykryto okno konsoli po każdym RTC; ograniczono je do interakcji.
Pobór nadal wyraźnie oznaczony jako szacowany.
5. **Statycznie:** cppcheck wskazał inicjalizację struktur z float przez memset;
zamieniono na inicjalizację wartości i osiągnięto 0 defektów.
### Niezweryfikowane fizycznie
CC1101 na antenie/analizatorze, RTL-SDR z prototypem, pobór, brownout, ACC,
aktualizacja flash, Clone IDs i LEARN z konkretnym Oplem. Brak oznaczenia
„validated”.
+338
View File
@@ -0,0 +1,338 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
<https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, see <https://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Moe Ghoul>, 1 April 1989
Moe Ghoul, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License.
+129 -664
View File
@@ -1,694 +1,159 @@
# Symulator 4 czujników TPMS Schrader EG53MA4 (ESP32 + CC1101) # Symulator TPMS Schrader EG53MA4 — ESP32 + CC1101
Firmware dla ESP32 DevKit + moduł CC1101 (433 MHz), symulujący **4 czujniki **Wersja 2.0.0-rc.1 — release candidate bez walidacji sprzętowej.**
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 Urządzenie warsztatowe nadaje cztery niezależne identyfikatory TPMS profilem
> Projekt **wyłącznie do celów diagnostycznych i testowych**. OOK/Manchester Schrader EG53MA4 na 433,92 MHz. Domyślnie każde koło raportuje
> Symulator dostarcza **sztuczne dane ciśnienia i temperatury** i **nie **260 kPa (2,6 bar; bajt protokołu `0x68`)**. Docelowy scenariusz to diagnostyka
> zastępuje prawdziwych czujników TPMS**. TPMS jest elementem bezpieczeństwa Opla Astry J Sedan 1.4 LPG (2016, EU), ale **zgodność trzeba potwierdzić dla
> czynnego pojazdu — **nie używaj tego urządzenia podczas jazdy po drogach konkretnego auta**: przez VIN/wykaz serwisowy, oznaczenia fabrycznych czujników,
> publicznych**. Nadawanie w paśmie 433 MHz może podlegać lokalnym odczyt diagnostyczny albo test odbioru. Numer OE 13506028, numery powiązane ani
> przepisom (np. w Polsce praca krótkiego zasięgu w 433 MHz jest dozwolona ogłoszenie sprzedażowe same w sobie nie potwierdzają profilu radiowego.
> z ograniczeniami mocy) — sprawdź przepisy obowiązujące w Twoim kraju.
--- > **Nie jest to homologowany czujnik ani zamiennik sprawnego TPMS. Nie używać
> w jeździe drogowej.** Sztuczne ciśnienie może ukryć przebitą lub niedopompowaną
> oponę i opóźnić ostrzeżenie. Przed i po teście sprawdź wszystkie opony
> niezależnym manometrem. Zobacz [SAFETY](docs/SAFETY.md).
## 1. Spis treści ## Co jest gotowe, a czego nie
1. [Spis treści](#1-spis-treści) - Gotowe: build ESP32, testy ramek/NVS/maszyny stanów, syntetyczny CU8 dekodowany
2. [Jak to działa](#2-jak-to-działa) przez niezależny `rtl_433`, trwała konfiguracja z konsoli, Clone IDs i LEARN.
3. [Budowa projektu](#3-budowa-projektu) - **Niewykonane:** pomiar rzeczywistego CC1101, RTL-SDR z anteną, test z samochodem,
4. [Kompilacja](#4-kompilacja) pomiar prądu i testy automotive. Dlatego wynik jest RC, nie „validated”.
5. [(a) Okablowanie i lista podzespołów](#5-a-okablowanie) - Jedyny profil podstawowy to **OOK**. Nie przełączaj na FSK „na próbę”.
6. [(b) Konfiguracja ID i ciśnień](#6-b-konfiguracja-id-i-cisnień) - ESP32 nie generuje nośnej 433 MHz — wymagany jest osobny CC1101 433 MHz.
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)
--- ## Schemat ideowy
## 2. Jak to działa ```text
USB 5 V (TYLKO prototyp) 3,3 V OOK 433,92 MHz
│ │ │
[ESP32 DevKit] ── SPI ───────> [CC1101 433 MHz] ── antena ────┘
│ │
├── GPIO26: przycisk └── wspólna GND
└── GPIO27: LED + 330 Ω
Urządzenie zachowuje się jak 4 czujniki TPMS Schrader EG53MA4: Konfiguracja: USB/UART 115200 → NVS → 4 × {ID, ciśnienie, temperatura}
* 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): Nie podłączaj 12 V do GPIO, 3V3 ani VIN DevKit. Połączenia i wariant automotive:
[HARDWARE](docs/HARDWARE.md).
* `rtl_433/src/devices/schraeder.c` (historycznie: `tpms_schrader.c`) — ## Quick Start
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
--- ### 1. Złóż prototyp
## 4. Kompilacja Kup elementy z [BOM](docs/HARDWARE.md#bom-prototypu-laboratoryjnego). Podłącz
CC1101, przycisk i LED zgodnie z tabelą pinów. Zasil DevKit przez znany kabel USB
na biurku. Nie montuj jeszcze niczego w samochodzie.
### PlatformIO (zalecane) ### 2. Zainstaluj narzędzia i sprawdź projekt
Wymagane: Python 3, Git, CMake, kompilator C/C++, `pkg-config` i nagłówki libusb.
Najprościej użyć Dockera:
```bash ```bash
pio run -e esp32dev # kompilacja docker build -t tpms-rc .
pio run -e esp32dev -t upload # wgrywanie docker run --rm -v "$PWD/artifacts:/work/artifacts" tpms-rc
pio device monitor # monitor szeregowy 115200
pio test -e native # testy generatora ramek (bez sprzętu)
``` ```
Biblioteka CC1101 (`SmartRC-CC1101-Driver-Lib`, dawniej Bez Dockera skrypt utworzy `.venv` z PlatformIO, pobierze przypięty `rtl_433`
`ELECHOUSE_CC1101_SRC_DRV`) jest pobierana automatycznie z `platformio.ini` i referencyjne nagrania:
(przypięta do commita zweryfikowanego buildu). **Wymagana wersja ≥ 2.5.7**
(wspólne API `setSpiPin`/`setGDO0` dla 2.5.x i 3.x; starsze 1.x używały
`setSCK`/`setMISO`/... i nie są obsługiwane).
### arduino-cli (alternatywa)
```bash ```bash
arduino-cli core install esp32:esp32 bash tools/check_all
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 Ostatni komunikat musi brzmieć `PASS: wszystkie testy bez sprzetu...`.
`build.extra_flags`; najwygodniej jednak otworzyć katalog w PlatformIO.) To nie jest test fizycznego radia.
### Weryfikacja bez sprzętu (opcjonalna) ### 3. Skompiluj i wgraj
```bash ```bash
python3 tools/tpms_frame.py --self-test # zgodność z dekoderem rtl_433 .venv/bin/pio run -e esp32dev
RTL433=rtl_433 ./tools/verify_rtl433.sh # pełne testy z prawdziwym rtl_433 .venv/bin/pio run -e esp32dev -t upload
.venv/bin/pio device monitor --baud 115200
``` ```
`tools/verify_rtl433.sh` generuje syntetyczne nagrania IQ takie, jakie Jeżeli port nie jest wykrywany automatycznie, dodaj `--upload-port /dev/ttyUSB0`
odbiornik RTL-SDR zobaczy w eterze, i sprawdza, czy **prawdziwy rtl_433** (przy `run`) albo `--port /dev/ttyUSB0` (przy `device monitor`). W monitorze
dekoduje je jako poprawny czujnik Schrader z oczekiwanym ID/ciśnieniem/ PlatformIO wyjście to zwykle `Ctrl+]`.
temperaturą. Ostatni wynik testów projektu:
``` Po uruchomieniu wpisz `stay 300` i Enter. Masz 5 minut na konfigurację; polecenie
== OOK (domyslna modulacja, wbudowany dekoder Schrader-EG53MA4) == `info` pokazuje aktywne wartości. Każda zmiana konfiguracji jest od razu zapisywana
OK c1.cu8 id=2FC871 260.0 kPa 73.0 F w NVS i zachowuje się po restarcie — **nie edytuj ID w kodzie**.
OK c2.cu8 id=3495AC 220.0 kPa 23.0 F
OK c3.cu8 id=ABCDEE 262.5 kPa 75.0 F ### 4A. Preferowane: Clone IDs
== FSK (wariant konfigurowalny, dekoder flex) ==
OK c4.cu8 (FSK) bitstream zgodny: 00000000004c9000702fc871684965 Jeśli znasz oryginalne 24-bit ID (np. z wcześniejszego odczytu `rtl_433`), wpisz
WSZYSTKO OK - ramki dekoduja sie poprawnie przez rtl_433 je w kolejności FL, FR, RR, RL. Przykład — zastąp wartości własnymi:
```text
stay 300
id 1 2FC871
id 2 2EAAF9
id 3 3495AC
id 4 2FC780
pressure all 260
info
send
``` ```
--- ID musi mieć sześć cyfr hex, być niezerowe, różne od `FFFFFF` i unikalne.
Urządzenie wróci do NORMAL i będzie nadawało znane ID. **Nauka może być
## 5. (a) Okablowanie niepotrzebna, ale nie jest to gwarantowane.** Potwierdź odbiór diagnostycznie;
nie zaczynaj od jazdy.
### Lista podzespołów (BOM) — co kupić
### 4B. Alternatywa: New IDs + LEARN
Koszty orientacyjne (zł, z dostawą z AliExpress/Allegro, stan na 2026 r.).
Wystarczy **jedna sztuka** każdego podzespołu. 1. Wpisz `ids new`, następnie `info` i zapisz wygenerowane ID.
2. Uruchom właściwą dla swojej wersji auta procedurę nauki TPMS zgodnie z jej
**Obowiązkowe:** instrukcją serwisową. Nie zgaduj sekwencji menu/pedałów.
3. Wpisz `mode learn`. Nadaje wyłącznie FL, co 2 s. LED wskaże 1 mrugnięcie.
| Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. | 4. `send` wymusza bieżące koło bez zmiany. Po potwierdzeniu kroku w aucie wpisz
|-----|-----------|-----------------|-------|----------------| `next`: FR → RR → RL. Krótki przycisk robi to samo; po RL wraca do NORMAL.
| 1 | ESP32 DevKit (WROOM-32) | moduł ESP32-WROOM-32, USB | Do testów na biurku OK. **Do montażu w aucie kup sam moduł ESP32-WROOM-32E** (bez mostka USB/LDO) + płytkę — patrz sekcja 13 o poborze prądu | 15–30 zł | 5. Jeśli minie 60 s na kole, LEARN przerwie się do NORMAL. Cała sesja ma limit
| 2 | Moduł CC1101 **433 MHz** | 8-pin, SPI, złącze goldpin | Koniecznie wersja 433 MHz (nie 868/915); dokup/drut antenowy ~17 cm; sprawdzić złącze ANT | 10–25 zł | 15 min. Po zakończeniu sprawdź ID i kody diagnostyczne.
| 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ł | EL-50448/OEC-T5 jest aktywatorem LF 125 kHz, **nie programatorem ESP32**. Ta
| 5 | Rezystor 10 kΩ | 1 szt. | Podciągnięcie przycisku do 3V3 | < 1 zł | procedura nie wymaga go. Szczegóły: [SETUP](docs/SETUP.md).
| 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ł | ## Sterowanie — jedna tabela
| 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ł | LED działa tylko podczas czuwania; w deep sleep jest zgaszona. Po zmianie koła
| 10 | Obudowa | IP65, min. 80×60×30 mm | Montaż w komorze silnika/bagażniku | 10–25 zł | seria 1–4 mrugnięć wskazuje FL/FR/RR/RL.
**Zasilanie — wybierz wariant (konfigurowalne w `config.h`, `POWER_SUPPLY_MODE`):** | Tryb | Wzorzec LED | Krótki przycisk | Długi ≥1,5 s | Bardzo długi ≥4 s |
|---|---|---|---|---|
| Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. | | NORMAL | 1 mrugnięcie / 2 s | burst wszystkich 4 | wejście LEARN | wejście SINGLE |
|-----|-----------|-----------------|-------|----------------| | LEARN | 3 mrugnięcia / 0,5 s; po zmianie numer koła | następne koło + TX; po RL koniec | wyjście NORMAL | wejście SINGLE |
| 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ł | | SINGLE | 2 mrugnięcia / 0,5 s; po zmianie numer koła | następne koło + TX | wejście LEARN | wyjście NORMAL |
| 11b | **Wariant 12 V** (wydajniejszy): buck o szerokim wejściu | np. **LM5164-Q1** (Vin 6–100 V, Iq ≈ 10 µA, 1 A) lub inny buck automotive | Wymaga cewki i płytki; **TPS62740 (Vin 2,2–5,5 V) i tanie bucki (LM2596, MP1584, Mini360, Iq mA) NIE nadają się do 12 V / snu < 50 µA** | 20–50 zł |
| 12 | **Wariant bateryjny**: ogniwo 3,6 V lub LiPo | Li-SOCl2 3,6 V (AA/half-AA, np. ER14505) + uchwyt **bezposrednio**; LiPo 3,7 V **przez LDO 3,3 V** (np. MCP1700, Vin max 6 V) | **Nie zasilaj LiPo 4,2 V wprost** — max ESP32 to 3,6 V, CC1101 to 3,9 V! | 10–30 zł | W konsoli `send` w NORMAL nadaje wszystkie, a w LEARN/SINGLE tylko bieżące koło.
`send 1`…`send 4` wybiera koło jawnie; `send all` nadaje cztery. SINGLE wyłącza
**Opcjonalne (ulepszenia i testy):** się po 5 min.
| Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. | ## Najczęstsze problemy
|-----|-----------|-----------------|-------|----------------|
| 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ł | - **`BLAD: brak CC1101`**: sprawdź 3,3 V, wspólną masę i sześć przewodów SPI;
| 14 | Dzielnik ACC | 1 MΩ + 270 kΩ + 100 nF | Sygnał zapłonu 12 V → GPIO32 (tryb ignition-aware) | < 2 zł | nie używaj 5 V na CC1101.
| 15 | RTL-SDR (dongle) | R820T2/RTL2832U | Testy z `rtl_433` (sekcja 7) — można wypożyczyć | 60–150 zł | - **Konsola znika przed wpisaniem komend**: po restarcie od razu `stay 300`;
| 16 | Kabel USB + ew. programator | do wgrywania firmware | W DevKit kabel USB-A/Micro-USB wystarczy | 5–15 zł | zwykłe wybudzenie RTC celowo nie otwiera okna konsoli.
- **NVS zgłasza błąd**: urządzenie używa bezpiecznych domyślnych; wpisz `info`.
**Narzędzia (do pomiarów, sekcja 9):** multimetr z zakresem µA (obowiązkowo do `factory YES` kasuje własne ID i przywraca konfigurację fabryczną.
pomiaru snu), opcjonalnie INA219/INA226 lub oscyloskop do pomiaru prądu w burst. - **Auto nie odbiera**: najpierw zweryfikuj profil auta i odbiór RTL-SDR; nie
zmieniaj losowo modulacji, flag ani interwałów. Zobacz
**Na skróty — zestaw minimalny „na biurko"** (testy RF + nauka): pozycje 1–10 [TROUBLESHOOTING](docs/TROUBLESHOOTING.md).
z wariantem 12 V lub zasilaniem z powerbanka 5 V przez DevKit (testy RF nie
wymagają spełnienia budżetu prądu). ## Walidacja, zasilanie i release
Gdzie kupić: AliExpress (CC1101, LM5164, ESP32), Allegro/sklepy elektroniczne - Protokół i niewiadome: [PROTOCOL](docs/PROTOCOL.md)
(pasywne elementy, obudowa, bezpieczniki, TVS). Przy zamawianiu CC1101 sprawdź, czy - Dokładne wyniki i checklista HIL: [VALIDATION](docs/VALIDATION.md)
moduł jest oznaczony **433 MHz** — wersje 868/915 MHz nie zadziałają bez - Pobór (na razie szacunki): [POWER](docs/POWER.md)
przestrojenia. - Wymagania zasilania 12 V: [HARDWARE](docs/HARDWARE.md#wariant-automotive--wymagania-niezwalidowany-projekt)
- Zmiany: [CHANGELOG](CHANGELOG.md)
### Podłączenie
Gotowe obrazy tworzy `bash tools/package_release.sh`. Pliki i adresy opisano w
| ESP32 DevKit | CC1101 | Uwagi | [VALIDATION](docs/VALIDATION.md#artefakty-i-wgrywanie). Release candidate nie
|--------------|-------------|----------------------------------------| zawiera wyniku testu CC1101 ani samochodu.
| 3V3 | VCC | **3.3 V!** (CC1101 nie toleruje 5 V) |
| GND | GND | masa wspólna |
| GPIO18 | SCK (SCLK) | `PIN_CC1101_SCK` |
| GPIO19 | MISO (SO) | `PIN_CC1101_MISO` |
| GPIO23 | MOSI (SI) | `PIN_CC1101_MOSI` |
| GPIO5 | CS (CSn/SS) | `PIN_CC1101_CS` |
| GPIO2 | GDO0 | `PIN_CC1101_GDO0` |
| — | GDO2 | nieużywany (zostaw odłączony) |
Pozostałe elementy (numery pinów konfigurowalne w `config.h`):
| Element | Pin ESP32 | Podłączenie |
|-------------------------|-----------|------------------------------------------------|
| Przycisk trybów | GPIO26 | GPIO —— przycisk —— GND, rezystor 10 kΩ do 3V3 (aktywny niski, `BTN_ACTIVE_LEVEL 0`) |
| LED statusowy | GPIO27 | GPIO —— 330 Ω —— LED —— GND |
| Wejście LF 125 kHz (opcjonalnie) | GPIO25 | wyjście detektora LF (impuls do 3,3 V), stan spoczynkowy **niski**; bez modułu: ustaw `PIN_LF_TRIGGER -1` |
| ACC / zapłon (opcjonalnie) | GPIO32 | dzielnik 12 V → ~3 V (1 MΩ / 270 kΩ + 100 nF), wejście **INPUT** (bez podciągania); **domyślnie wyłączone** (`PIN_ACC -1`) — ustaw 32 po podłączeniu |
| Pomiar napięcia | GPIO34 | węzeł środkowy dzielnika `R1=1 MΩ / R2=270 kΩ` (ADC1) + 100 nF |
Zasilanie (wybór w `config.h`, `POWER_SUPPLY_MODE`):
```
POWER_12V (na stałe z akumulatora) - UWAGA: zakres samochodowy to nie
same "12 V": 14,4 V przy ladowaniu
i przepięcia load-dump > 40 V:
+12 V ──[bezpiecznik 1 A]──[TVS 24 V do masy]──[rezystor/dioda]── regulator
── 3,3 V ── ESP32 + CC1101
Regulator (wybierz jeden):
- LDO o Iq ~2 µA i wejściu >= 16 V, np. MCP1703-3302
(straty: (14,4-3,3) V x ~30 mA = ~0,33 W - zwróć uwagę na obudowę),
- albo buck automotive o szerokim wejściu, np. LM5164-Q1 (6-100 V,
Iq ~10 µA) - wydajniejszy, wymaga cewki.
TPS62740 (Vin 2,2-5,5 V!) i tanie bucki (LM2596/MP1584/Mini360, Iq mA)
NIE nadają się do tej aplikacji.
POWER_BATTERY:
Li-SOCl2 3,6 V ── bezposrednio 3V3 (ESP32 wymaga >= 3,0 V pod obciazeniem)
LiPo 3,7 V ── PRZEZ LDO 3,3 V (np. MCP1700). Bezposrednie zasilanie
LiPo 4,2 V przekracza max ESP32 (3,6 V) i CC1101 (3,9 V)!
```
```
+12V ──[bezpiecznik]──[TVS]──> regulator IN
Pomiar: +12V ──[R1 1M]──+── GPIO34 ( + 100 nF do masy )
└──[R2 270k]── GND
(12 V -> 2,55 V, 14,4 V -> 3,05 V, prad dzielnika ~9 uA)
```
Ważne:
* **moduły DevKit z mostkiem USB-UART (CH340/CP2102) i LDO AMS1117 pobierają
w deep sleep 0,5–2 mA** — w aucie użyj gołego modułu ESP32-WROOM na własnej
płytce z przetwornicą o niskim Iq (patrz sekcja 13),
* CC1101 zasilaj **3,3 V**, antena 433 MHz (kawałek drutu ~17 cm) przy złączu
CC1101; trzymaj przewody SPI krótkie,
* masa dzielnika pomiarowego i CC1101 musi być wspólna z ESP32.
**Opcjonalny front-end LF 125 kHz** (reakcja na aktywację czujnika
programatorem TPMS przy kole): cewka rezonansowa ~125 kHz (kilka zwojów,
np. ferrytowa ramka z programatora) + detektor obwiedni (dioda Schottkyego
+ kondensator + rezystor rozładowczy + bramka komparatora/logiki) →
impuls 3,3 V na `PIN_LF_TRIGGER`. Stan spoczynkowy musi być **niski**
(wejście ESP32 ma wewnętrzne podciągnięcie do dołu włączone przez firmware).
Bez modułu LF jego rolę pełni przycisk — patrz sekcja 8.
---
## 6. (b) Konfiguracja ID i ciśnień
Wszystko w **`src/config.h`**:
```c
/* ID poszczególnych kół (24 bity) */
#define SENSOR_FL_ID 0x2FC871u // przód lewy
#define SENSOR_FR_ID 0x2EAAF9u // przód prawy
#define SENSOR_RR_ID 0x3495ACu // tył prawy
#define SENSOR_RL_ID 0x2FC780u // tył lewy
/* Ciśnienie startowe: DOMYŚLNIE 2,6 bar = 260 kPa dla wszystkich kół */
#define SENSOR_FL_PRESS_KPA 260.0f
#define SENSOR_FR_PRESS_KPA 260.0f
#define SENSOR_RR_PRESS_KPA 260.0f
#define SENSOR_RL_PRESS_KPA 260.0f
/* Temperatura otoczenia (st. C) */
#define SENSOR_TEMP_C 23
```
Rozdzielczość protokołu: **2,5 kPa/bit** (zakres 0–637,5 kPa),
temperatura w ramce w °F (przeliczenie automatyczne).
### Jakie ID wpisać? — to jest kluczowa decyzja
| Strategia | Kiedy stosować | Co zrobić |
|---|---|---|
| **A. Oryginalne ID (najlepsze)** | Auto ma już zapamiętane 4 ID starych czujników | **Przed** wymianą odczytaj ID oryginalnych czujników: `rtl_433 -f 433.92M` (pole `id` modelu `Schrader-EG53MA4`), wgraj je do `config.h`. ECU słyszy „znajome" czujniki i **nie trzeba nic programować**. |
| **B. Nowe ID + procedura nauki** | Oryginalne ID nieznane / ECU nie pamięta | Wpisz dowolne unikalne ID (jak wyżej) i wykonaj **procedurę learn** w aucie (sekcja 8), aby ECU zarejestrowało nowe ID. |
Dodatkowo (w razie potrzeby):
```c
#define TPMS_FLAGS 0x4C900070u // słowo "flags" z prawdziwych czujników
#define TPMS_FLAGS_LOWBAT_MASK 0x00000008u // bit "rozładowana bateria"
```
Wartość `TPMS_FLAGS` domyślnie pochodzi z nagrań prawdziwych czujników
EG53MA4 (stała `4c900070`). Bitu niskiej baterii rtl_433 nie analizuje —
jeśli Twój sterownik pokazuje ostrzeżenie „service TPMS" mimo dobrych
ciśnień, spróbuj zmienić `TPMS_FLAGS_LOWBAT_MASK` (lub wyczyść bit przez
`flags` w konsoli) i powtórz naukę.
Po zmianach: `pio run -e esp32dev -t upload`.
---
## 7. (c) Test nadawania — RTL-SDR + rtl_433
Zanim włożysz urządzenie do auta, sprawdź transmisję „w eterze":
1. Zasil urządzenie (powerbank / 3,3 V), ustaw `monitor` szeregowy.
2. Na komputerze z RTL-SDR:
```bash
rtl_433 -f 433.92M
```
3. Urządzenie co 30 s wysyła po 3 ramki dla każdego koła. Powinieneś widzieć:
```
time : ...
model : Schrader-EG53MA4 type: TPMS flags: 4c900070 ID : 2FC871
Pressure : 260.0 kPa Temperature: 73.0 F Integrity : CHECKSUM
```
dla kolejno: `2FC871` (FL), `2EAAF9` (FR), `3495AC` (RR), `2FC780` (RL),
każde 260.0 kPa i 73.0 F (23 °C).
4. Bez RTL-SDR możesz wywołać ramki z konsoli: `send`, `hex` (hexdump).
**Wariant FSK** (`TPMS_MODULATION MODE_FSK` w `config.h`) — rtl_433 nie ma
dla tego wariantu wbudowanego dekodera EG53MA4 (deklaracja OOK), weryfikuj
przez dekoder flex:
```bash
rtl_433 -f 433.92M -X 'n=schrader,m=FSK_MC_ZEROBIT,s=120,l=120,r=300'
```
> Uwaga praktyczna: nazwy plików `.cu8` do testów **nie mogą** zawierać
> słów `ook`, `fsk`, `am`, `fm` (parser formatów rtl_433 je rozpoznaje).
> Np. `tpms_sim.cu8` jest OK, `sim_ook.cu8` — nie.
---
## 8. (d) Programowanie czujników w aucie (tryb learn)
### Kolejność kół w Astrze J
**przód lewy (FL) → przód prawy (FR) → tył prawy (RR) → tył lewy (RL)**
(kolejność konfigurowalna przez `LEARN_ORDER_0..3` / kolejność wpisów w tablicy
`SENSOR[]` w `main.cpp`).
### Sterowanie (przycisk `PIN_BUTTON`)
| Gest | Tryb NORMAL | Tryb LEARN | Tryb SINGLE |
|--------------------------|--------------------------|--------------------------|--------------------------|
| krótkie naciśnięcie | natychmiast burst 4 kół | **następne koło** | **następne koło** |
| długie (≥1,5 s) | → **LEARN** | → NORMAL | → LEARN |
| bardzo długie (≥4 s) | → **SINGLE** | → SINGLE | → NORMAL |
(Przycisk nie jest drzemany przy wciśniętym — urządzenie nie wejdzie w sen,
dopóki go nie puścisz; bardzo długi gest zdąży się zawsze zarejestrować.)
LED: seria **N mrugnięć = N-ty numer koła** (1–4) przy zmianie koła,
wzorzec stały: NORMAL — 1 mrugnięcie co 2 s, LEARN — 3 mrugnięcia co 0,5 s,
SINGLE — 2 mrugnięcia co 0,5 s, niskie napięcie — 10 mrugnięć co 3 s.
### Procedura krok po kroku
1. **Odczytaj oryginalne ID** (jeśli to możliwe) — patrz strategia A w sekcji 6.
2. Włącz zapłon, uruchom procedurę nauki TPMS w aucie
(Astra J: menu kierowcy → ustawienia → ciśnienie w oponach → nauka /
„Tyre learning"; w wersjach bez menu — procedura z pedałem gazu
lub przez OP-COM/TECH2 — sprawdź instrukcję obsługi swojej wersji).
3. **Wejdź w tryb LEARN** (długie naciśnięcie) — urządzenie nadaje
**tylko koło FL** (ID z `SENSOR_FL_ID`), LED mruga 1×.
4. Urządzenie nadaje burst co 2 s. Jeśli procedura w aucie wymaga
**aktywacji czujnika przy kole** (puls LF 125 kHz / programator TPMS):
* podejdź do koła FL i użyj programatora LF — jeśli masz moduł LF
(`PIN_LF_TRIGGER`), urządzenie **natychmiast** wyśle właściwe ID,
* bez modułu LF: **krótkie naciśnięcie przycisku = „aktywuj koło"**
(w LEARN służy też do przejścia dalej — użyj komendy `send`
w konsoli, jeśli potrzebna jest aktywacja bez zmiany koła).
5. **Krótkie naciśnięcie = następne koło** (LED: 2×, 3×, 4×) i powtórz
aktywację przy kolejnych kołach w kolejności **FL → FR → RR → RL**.
6. **Okno czasowe**: na każde koło jest `LEARN_WINDOW_MS` (60 s).
Po jego upływie urządzenie **wraca do trybu normalnego**
(`LEARN_WINDOW_EXPIRE_TO_NORMAL 1`); ustaw `0`, jeśli wolisz
automatyczne przejście do kolejnego koła. Cała sesja learn kończy się
też po `LEARN_TOTAL_TIMEOUT_MS` (15 min).
7. Zakończ procedurę w aucie (zwykle: zapłon OFF, jazda testowa).
8. Po zakończeniu nauki urządzenie samo wraca do NORMAL i nadaje
wszystkie 4 koła co 30 s — także przy postoju (transmisja jest ciągła,
niezależna od ruchu; auto-learn może wymagać jazdy, ale ramki lecą zawsze).
### Jeśli auto „nie zapamiętuje" czujników
* **Użyj oryginalnych ID** (strategia A) — wtedy nie trzeba w ogóle
programować; ECU zna już te ID i zaakceptuje je natychmiast.
* Sprawdź, czy procedura nauki w aucie była uruchomiona **przed**
transmisjami (ECU w trybie nauki nasłuchuje nowych ID).
* W trybie LEARN nadawane jest **tylko jedno ID naraz** — jeśli nadawałeś
wszystkie 4 jednocześnie, ECU mógł się „pomylić" (stąd tryb learn).
* Upewnij się, że ciśnienie jest w zakresie akceptowanym przez ECU
(260 kPa = 2,6 bar jest bezpieczne dla Astry J).
* Spróbuj wariantu modulacji: `MODE_OOK` ↔ `MODE_FSK` (patrz sekcja 7) —
wersje EU/US różnią się; referencyjne nagrania EG53MA4 to **ASK/OOK**.
* Procedura nauki niektórych wersji Astry J wymaga **jazdy > 20 km/h**
przez kilka minut — urządzenie nadaje przez cały czas, więc wystarczy
wykonać jazdę próbną po starcie procedury.
* Sprawdź DTC przed i po (OP-COM/TECH2): kody czujników (np. C0750–C0759)
powinny zniknąć po udanej nauce.
* Zmierz napięcie zasilania (`batt`) — przy `POWER_12V` urządzenie raportuje
stan akumulatora i flagę niskiego napięcia w ramce (`LOWBATT`).
### Tryb SINGLE
Wymuszone nadawanie jednego ID (testy, procedury uczące jedno koło
wielokrotnymi próbami):
* bardzo długie naciśnięcie (≥4 s) — SINGLE na bieżącym kole,
* konsola: `mode single 2` (koło FR), `next` — zmiana koła,
* wyjście: bardzo długie naciśnięcie lub `mode normal`,
limit czasu `SINGLE_TIMEOUT_MS` (domyślnie 5 min).
---
## 9. (e) Pomiar poboru prądu
### Co zmierzyć
| Stan | Co się dzieje | Oczekiwana wartość |
|----------------------|---------------------------------------------------|--------------------|
| **Deep sleep** | między transmisjami (większość czasu) | **< 50 µA** (goły moduł ESP32 + CC1101 + buck o niskim Iq); ~10 µA ESP32 + < 1 µA CC1101 + Iq przetwornicy |
| **Transmisja (burst)** | 4 koła × 3 ramki, ~0,35 s na antenie + 1,2 s aktywności | ~30 mA (CC1101 TX) + ~80 mA (ESP32) przez ok. 1,2 s co interwał |
| **Średnia** | suma | ~4 mA przy interwale 30 s, ~1 mA przy 120 s (patrz sekcja 13) |
### Jak zmierzyć
1. **Sen** — multimetr w zakresie µA **szeregowo z zasilaniem**,
po 30 s od ostatniej transmisji (gdy ESP32 jest w deep sleep).
Mierz na pinach modułu, nie przez port USB!
2. **Burst** — rezystor bocznikowy 1 Ω + oscilloskop albo INA219/INA226
(szyna I²C), odczyt średniego prądu przez ≥ 60 s.
3. **Średnia doby** — mierz przez 1–2 minuty w zakresie mA i przelicz
(albo użyj miernika z integracją, np. µCurrent + logger).
4. Porównaj z budżetem z sekcji 13; odchylenie 2× w dół/w górę jest normalne.
### Typowe pułapki
* **DevKit z USB-UART**: mostek CP2102/CH340 + LDO AMS1117 = 0,5–2 mA
w sleep → cel < 50 µA **niedotrzymany z winy płytki**, nie firmware'u.
Rozwiązanie: goły moduł ESP32-WROOM + regulator z sekcji 5
(MCP1703/ LM5164-Q1 dla 12 V, MCP1700 dla LiPo).
* **Dzielniki pomiarowe**: 2 × 1 MΩ/270 kΩ ≈ 19 µA stale — to już połowa
budżetu < 50 µA; w wariancie bateryjnym możesz je całkowicie odpiąć
(`PIN_VBAT_ADC -1` nie jest obsługiwany — po prostu nie montuj dzielnika
i zignoruj odczyt) albo zwiększyć rezystancje kosztem dokładności ADC.
* Rezystor podciągający przycisku (10 kΩ) pobiera 330 µA przy stanie
aktywnym niskim — w sleep przycisk jest w stanie spoczynkowym (HIGH),
więc prąd nie płynie; gdybyś użył aktywnego HIGH, zwiększ rezystor do 100 kΩ.
* LED — w sleep zgaszony (firmware go gasi przed snem).
---
## 10. (f) Weryfikacja, że błąd zniknął
1. **Przed testem**: skasuj stare DTC (OP-COM/TECH2 lub odłącz akumulator
na kilka minut — utrata ustawień radia/godziny jest możliwa).
2. Uruchom procedurę learn w aucie (sekcja 8) albo użyj oryginalnych ID.
3. Włącz zapłon, odczekaj 1–3 minuty (ECU zbiera ramki) lub wykonaj jazdę
próbną 5–10 min powyżej 20 km/h.
4. Sprawdź:
* **kontrolka TPMS** (żółta ikona opony) — powinna zgasnąć,
* **wyświetlacz kierowcy** (DIC): menu ciśnienia w oponach powinno
pokazywać 4 wartości (2,6 bar),
* **OP-COM/TECH2**: brak aktywnych kodów czujników TPMS,
* **rtl_433**: `rtl_433 -f 433.92M` dekoduje 4 ID co ok. 30 s
(to potwierdza, że transmisja jest ciągła).
5. Test długotrwały: pozostaw auto na noc z włączonym zapłonem raz na
kilka godzin — po ponownym uruchomieniu błąd nie powinien wracać.
6. Jeśli kontrolka zapala się ponownie po dłuższym postoju — sprawdź
interwał parkingowy (`TX_INTERVAL_PARKING_S`) i flagę baterii
(`TPMS_FLAGS_LOWBAT_MASK`).
---
## 11. Tryby pracy i sterowanie
| Tryb | Zachowanie | Wejście |
|----------|----------------------------------------------------------------------------|--------------------------------|
| NORMAL | rotacja 4 kół: burst 3 ramek × 4 koła co `TX_INTERVAL_S` (30 s), potem deep sleep | stan domyślny, `mode normal` |
| LEARN | **tylko jedno koło**, burst co 2 s, okno 60 s na koło, przycisk = następne koło | długie naciśnięcie, `mode learn` |
| SINGLE | wymuszone jedno ID, burst co 2 s | bardzo długie naciśnięcie, `mode single n` |
### Deep sleep i budzenie
* budzik RTC co `TX_INTERVAL_S` / `TX_INTERVAL_IGNITION_S` /
`TX_INTERVAL_PARKING_S`,
* **EXT0**: przycisk (`PIN_BUTTON`) — natychmiastowe wybudzenie,
* **EXT1**: wejście LF (`PIN_LF_TRIGGER`) — aktywacja czujnika przy kole
= natychmiastowa transmisja odpowiedniego ID,
* między transmisjami: CC1101 w SLEEP (`SPWD`), linie SPI trzymane przez
`gpio_hold` (CS wysoki — utrzymuje CC1101 w sleep, SCK/MOSI niskie),
* WiFi **nie jest w ogóle inicjalizowany**, BT wyłączany (`btStop()`),
brak dynamicznej alokacji pamięci (same bufory statyczne),
brak opóźnień blokujących — jedyny „blocking" to oczekiwanie na
zakończenie nadania ramki (~29 ms) i odstępy między ramkami w burście
(transmisja musi fizycznie trwać tyle, ile trwa).
### Tryb ignition-aware (ACC)
* `PIN_ACC` wysoki (zapłon) → interwał `TX_INTERVAL_IGNITION_S` (15 s),
* po zaniku ACC + `ACC_GRACE_MS` (5 min) → interwał `TX_INTERVAL_PARKING_S`
(120 s) albo całkowite uśpienie (`PARKING_SHUTDOWN 1`) — budzi wtedy
tylko przycisk/LF,
* bez podłączonego ACC (`PIN_ACC -1`) urządzenie pracuje stale
z interwałem `TX_INTERVAL_S`.
---
## 12. Konsola szeregowa
115200 8N1, po starcie okno `BOOT_STAY_AWAKE_MS` (3 s) — wciśnij `stay 60`,
żeby zostać dłużej. Komendy:
| Komenda | Działanie |
|------------------------------|------------------------------------------------|
| `help` | lista komend |
| `info` / `config` | wersja, konfiguracja, ID, stan, napięcie |
| `hex [n\|all]` | hexdump ramki koła n (1–4) lub wszystkich |
| `send [n\|all]` | wyślij burst teraz |
| `batt` | pomiar napięcia zasilania [mV] |
| `mode normal\|learn\|single [n]` | zmiana trybu |
| `next` | następne koło (learn/single) |
| `interval <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 ≈ 15 µA (ESP32 ~10 µA + CC1101
< 1 µA + Iq regulatora) **+ ~19 µA na dzielnikach pomiarowych**
(2 × 1 MΩ/270 kΩ). Przeliczenia poniżej robione są jednym wzorem:
pobór z 12 V = pobór na szynie 3,3 V × (3,3/12) / sprawność regulatora (0,9).
**Cykl co 30 s** (2880 cykli/dobę):
| Składnik | Ilość na cykl | Ładunek na cykl |
|---------------------------------------|--------------------|-----------------|
| ESP32 aktywny (80 mA × 1,2 s) | 1,2 s | 96 mAs ≈ 27 µAh |
| CC1101 TX (30 mA × 0,35 s) | 0,35 s | 10 mAs ≈ 3 µAh |
| CC1101 idle/reszta (15 mA × 0,85 s) | 0,85 s | 13 mAs ≈ 4 µAh |
| deep sleep + dzielniki (~34 µA × 30 s)| 30 s | ≈ 0,3 µAh |
| **Razem** | | **≈ 34 µAh/cykl** |
* **Dobowy pobór na szynie 3,3 V: 34 µAh × 2880 ≈ 98 mAh/dobę**
(średnio ≈ 4 mA).
* Przy zasilaniu 12 V (sprawność 90%): **≈ 30 mAh/dobę z akumulatora**
(98 × 3,3/12/0,9 = 30; średnio ≈ 1,25 mA przy 12 V).
**Akumulator 60 Ah (Pb), bez innych odbiorników:**
* prąd potrzebny do rozruchu wymaga napięcia > ~11,8 V, czyli ~50% pojemności
= 30 Ah użyteczne,
* 30 000 mAh / 30 mAh ≈ **1000 dni ≈ 2,7 roku** — teoretycznie;
* **w praktyce granicą jest samorozładowanie akumulatora kwasowego
(3–5%/mies.)** — akumulator bez odbiorników rozładowuje się w 6–12 mies.,
więc symulator **nie jest czynnikiem limitującym**.
**Warianty oszczędne** (pobór z 12 V z uwzględnieniem sprawności 0,9):
| Interwał | Średni prąd (3,3 V) | Dobowy pobór (12 V) | 60 Ah (30 Ah użyteczne) |
|----------|--------------------|--------------------|--------------------------|
| 30 s | ~4 mA | ~30 mAh/dobę | ~2,7 roku* |
| 120 s (parking) | ~1 mA | ~8 mAh/dobę | ~10 lat* |
| 300 s | ~0,4 mA | ~3,5 mAh/dobę | ogranicza samorozładowanie |
\* przed samorozładowaniem akumulatora.
**Wariant bateryjny** (Li-SOCl2 3,6 V 2400 mAh, bez strat przetwornicy):
~98 mAh/dobę przy 30 s to ok. **24 dni**; przy 300 s ~10 mAh/dobę to ok.
**240 dni (~8 mies.)**. Do zasilania bateryjnego stosuj dłuższe interwały,
mniejszą liczbę ramek w burście (`TX_BURST_FRAMES 2`) albo
`PARKING_SHUTDOWN 1`.
Wskazówki: zmniejsz `TX_BURST_FRAMES`, wydłuż interwał, użyj mocy TX
`TPMS_TX_POWER_DBM 0` (wystarczy w aucie), ustaw `PARKING_SHUTDOWN 1`
(przy postoju sen do przycisku).
---
## 14. Protokół — szczegóły techniczne
Dekoder referencyjny: `rtl_433/src/devices/schraeder.c` →
`schrader_EG53MA4` („Schrader TPMS EG53MA4, Saab, Opel, Vauxhall,
Chevrolet"), zasilany sygnałem **OOK Manchester** (`OOK_PULSE_MANCHESTER_ZEROBIT`,
`s=123 µs`, `r=300 µs`). Wymagana długość dekodowanego wiersza: **120 bitów**.
Ramka (bity po dekodowaniu Manchester):
```
0 40 56 80 88 96 104
+--------+--------+---------+---------+---------+--------+
| sync | flags (4 B) | id (3 B) |press|T |crc|
| 40 bit | 4c 90 00 70| 2F C8 71 | 68 |49| 65|
+--------+--------+---------+---------+---------+--------+
```
* `flags` — 4 bajty (status/bateria, wg dekodera nie w pełni rozpoznane),
* `id` — 24-bitowy identyfikator czujnika,
* `press` — ciśnienie: **25 mbar/bit = 2,5 kPa/bit** (260 kPa → `0x68`),
* `T` — temperatura w **°F** (23 °C → `73`),
* `crc` — **suma 9 poprzednich bajtów mod 256** (`add_bytes` w rtl_433).
Kodowanie na warstwie RF (G.E.T. Manchester, zgodnie z analizą nagrań
`rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01/`):
* chip = **120 µs** (8,33 kBaud),
* bit `0` → chipy `01`, bit `1` → chipy `10`,
* nadajnik wysyła **1 chip rozbiegowy + 119 komórek** (ramkę bez pierwszego
bitu — pierwszy bit dopisuje dekoder MC_ZEROBIT), dopełnienie zerowe do
bajtu jest ciszą w eterze (OOK),
* modulacja: **ASK/OOK 433.92 MHz** (jak w referencyjnych nagraniach;
FCC MRXEG53MA4: „Type of Modulation: ASK + FSK", „Frames are Manchester
encoded ASK data"), opcjonalnie **2-FSK 433.92 MHz, dewiacja 47,6 kHz**
(`TPMS_MODULATION MODE_FSK`).
Weryfikacja implementacji (bez sprzętu):
* `tools/tpms_frame.py` — referencyjna implementacja ramki + **kopia
dekodera `pulse_slicer_manchester_zerobit()` z rtl_433** (self-test 500
losowych ramek + wektor z prawdziwego nagrania `gfile001.cu8`),
* `tools/gen_cu8.py` + `tools/verify_rtl433.sh` — synteza nagrań IQ
i dekodowanie **prawdziwym rtl_433** (wynik w sekcji 4),
* `pio test -e native` — testy kodu C firmware'u (te same wektory).
---
## 15. Rozwiązywanie problemów
| Objaw | Przyczyna / rozwiązanie |
|---|---|
| `BLAD: brak modulu CC1101` | Sprawdź SPI (SCK=18, MISO=19, MOSI=23, CS=5), zasilanie 3,3 V, masę |
| rtl_433 nic nie dekoduje | Sprawdź antenę, odległość (< 1 m na test), `rtl_433 -f 433.92M`; spróbuj `MODE_FSK` + decoder flex; sprawdź `send` w konsoli i `hex` |
| rtl_433 dekoduje inne ID niż w config | Skompiluj i wgraj ponownie po zmianie `config.h`; sprawdź `info` |
| Auto nie zapamiętuje ID | Strategia A (oryginalne ID) lub procedura learn w trybie LEARN (jedno koło naraz), jazda testowa > 20 km/h |
| Kontrolka TPMS świeci mimo OK | Zmień `TPMS_FLAGS` / `TPMS_FLAGS_LOWBAT_MASK`, skasuj DTC, powtórz naukę |
| Pobór w sleep > 50 µA | DevKit z mostkiem USB — użyj gołego modułu; sprawdź rezystory podciągające i dzielnik pomiarowy (R1+R2 = 133 kΩ → 27 µA przy 3,6 V — rozważ 470 kΩ/150 kΩ) |
| Reset przy transmisji | Za słabe zasilanie — dodaj kondensator 100 µF przy CC1101, użyj bucka o wystarczającym prądzie |
| `pio test -e native` nie przechodzi | Upewnij się, że nie zmieniłeś `tpms_frame.cpp` bez aktualizacji wektorów w teście (generuj przez `tools/tpms_frame.py`) |
---
## Wersje
* `CONFIG_VERSION` w `src/config.h` — podnieś przy zmianie formatu danych
w pamięci RTC (magic RTC zawiera tę wersję, więc stan zostanie wyzerowany).
* Firmware testowany z: PlatformIO `espressif32@8.0.0`, Arduino core ESP32,
`SmartRC-CC1101-Driver-Lib` commit `de6757e` (3.0.2, wymagane ≥ 2.5.7),
rtl_433 (master).
**Pamiętaj: symulator generuje sztuczne dane ciśnienia i nie zastępuje
prawdziwych czujników TPMS.**
+53
View File
@@ -0,0 +1,53 @@
# TPMS EG53MA4 Simulator 2.0.0-rc.1
**Release candidate — 2026-10-27. Nie jest to release „validated”.**
Diagnostyczny symulator czterech czujników Schrader EG53MA4 dla ESP32-WROOM-32 /
DevKit + CC1101 433 MHz. Profil docelowy obejmuje testy z Oplem Astra J Sedan 2016,
ale zgodność konkretnego auta trzeba potwierdzić. Sztuczne dane mogą ukryć usterkę
opony; nie używać w jeździe drogowej.
## Funkcje
- cztery trwałe, niezależne 24-bit ID; domyślnie 260 kPa dla każdego koła;
- OOK/Manchester 433,92 MHz, niska konfigurowalna moc od −10 dBm;
- Clone IDs oraz New IDs + LEARN FL→FR→RR→RL, SINGLE/diagnostics;
- konfiguracja NVS przez UART bez rekompilacji, wersja/CRC/walidacja/factory reset;
- przycisk, LED, timeouty, deep sleep z RTC i opcjonalne sprzętowe ACC;
- automatyczne testy native/RF/build, Docker i artefakty SHA-256.
## Wymagany sprzęt
ESP32 DevKit z WROOM-32 do prototypu, CC1101 **433 MHz** 3,3 V, antena, przycisk,
LED + 330 Ω, odsprzężenie i zasilanie laboratoryjne. Pełny BOM/pinout: HARDWARE.
DevKit ani tania przetwornica nie są zwalidowanym rozwiązaniem automotive.
## Instalacja i aktualizacja
Nowa instalacja: `bash tools/check_all`, potem `pio run -e esp32dev -t upload`.
Gotowe obrazy: `bash tools/package_release.sh`; adresy i flash opisano w VALIDATION.
Przed pełnym flashem zapisz ID — partycja NVS może zostać skasowana. Konfigurację
sprawdź po restarcie przez `info`. Migracji z wersji 1.0 bez NVS nie ma; należy
wpisać ID w konsoli jeden raz.
## Wyniki testów bez sprzętu (2026-10-27)
- native: 20/20 PASS;
- pełny ESP32 build z `-Werror`: PASS;
- cppcheck: PASS, 0 defektów;
- rtl_433: 64/64 rekordy referencyjne, 3/3 syntetyczne, 3/3 negatywne: PASS.
Dokładne komendy i przypięte commity: VALIDATION/PROTOCOL.
## Znane ograniczenia
- Nie zmierzono rzeczywistej emisji CC1101, ogona, mocy ani częstotliwości.
- Nie wykonano RTL-SDR z anteną, pomiaru poboru, brownout ani testu ACC.
- Nie wykonano Clone IDs/LEARN z samochodem; nie potwierdzono OE 13506028 dla
konkretnego VIN.
- Znaczenie wszystkich flags pozostaje nieznane; brak zgadywanego low battery.
- Harmonogram jest eksperymentalny, nie potwierdzony OE.
- Wymagania zasilania 12 V nie są zwalidowanym projektem automotive.
- Gitea Actions wymaga działającego runnera; lokalne wyniki nie oznaczają CI PASS.
Do czasu odhaczenia HIL w VALIDATION wynik pozostaje release candidate.
+23
View File
@@ -0,0 +1,23 @@
# Licencje i źródła
Projekt jest rozpowszechniany na GPL-2.0-or-later (`LICENSE`). Wybór jest
zgodny z wykorzystaniem w historii modelu algorytmu slicera z rtl_433. Nie
przypisujemy sobie praw do kodu autorów zewnętrznych.
- **rtl_433** — GPL-2.0-or-later; dekoder `schraeder.c`, Copyright Benjamin
Larsson, Christian W. Zuckschwerdt i kolejni autorzy. Używany jako niezależny
program do testów. Źródło i pełna historia: <https://github.com/merbanan/rtl_433>.
Referencja testów: commit `406f9a33550a2b6b3d0d8a8a486417ce5b3f13ab`.
- **rtl_433_tests** — nagrania i metadane należą do ich autorów; nie są kopiowane
do artefaktu firmware ani release. Skrypt pobiera przypięty commit
`1aa8c29d6b9383739d1aeed495dbc5069b704392`.
- **SmartRC-CC1101-Driver-Lib** — zewnętrzna biblioteka pobierana przez PlatformIO;
zachowane są jej oryginalne nagłówki i licencja. Użyty commit
`de6757ef633b3e626dae5c7835cdb66ab53f9a1d`.
- **Arduino ESP32 / ESP-IDF / PlatformIO / Unity** — zależności build/test na ich
własnych licencjach; nie są objęte deklaracją autorstwa tego projektu.
- Issue rtl_433 #2978 służył wyłącznie jako wzorzec integracji CC1101. Kod
protokołu Renault nie jest kodem EG53MA4 i nie został użyty jako protokół.
Pełne teksty licencji zależności znajdują się w ich źródłach pobieranych podczas
buildu. Ten plik nie zawęża ich praw ani licencji.
+25
View File
@@ -0,0 +1,25 @@
# Rejestr audytu release-v2
| Priorytet | Problem początkowy | Kryterium naprawy | Stan / dowód |
|---|---|---|---|
| P0 | Zgadywany bit low battery zależny od zasilania emulatora | brak maski i sprzężenia; test flags | naprawione; grep kodu i 20/20 native |
| P0 | MCP1703 + TVS 24 V opisane jako ochrona automotive | usunąć rekomendację; wymagania i przykład z datasheet | naprawione w HARDWARE |
| P0 | Brak fizycznego dowodu zgodności z autem przedstawiany zbyt pewnie | RC, jawne HIL, weryfikacja VIN/oznaczeń | naprawiona dokumentacja; HIL nadal otwarte |
| P1 | ID/ciśnienia/RF tylko przez rekompilację | NVS z konsolą, walidacja, wersja/CRC | naprawione; test_settings i build |
| P1 | Monolit uniemożliwiał test timeoutów/ACC | przenośny state-machine, fake clock/radio | naprawione; test_app_state |
| P1 | FSK w podstawowym flow bez dowodu | tylko OOK w firmware/generatorze | naprawione |
| P1 | PARKING_SHUTDOWN bez gwarantowanego ACC wake | usunąć albo zapewnić budzenie | usunięty; każdy sen ma RTC |
| P1 | TX kończone czasem i TXBYTES, ryzyko ogona | MARCSTATE/underflow/limit | poprawione; wymaga potwierdzenia HIL |
| P1 | Wektory głównie własne | cztery prawdziwe nagrania + niezależny rtl_433 | 64/64 PASS |
| P2 | Domyślne LF bez zwalidowanego front-endu | wyłączyć domyślnie, LEARN bez LF | naprawione |
| P2 | Interwały przedstawiane jak OE | jawnie eksperymentalne | PROTOCOL/SETUP/POWER |
| P2 | Brak pełnego jednego check/build artefaktów | check_all, CI, Docker, package_release | dodane; wyniki VALIDATION |
| P2 | Okno konsoli po każdym RTC zwiększa pobór | sen od razu po cyklu RTC | poprawione; pomiar HIL otwarty |
| P2 | README niezgodne z zachowaniem | nowy Quick Start, jedna tabela UI | przepisane |
## Otwarte, wymagające sprzętu
Nie można ich zamknąć deklaracją: pomiar CC1101/ogon/moc/częstotliwość, test
RTL-SDR z anteną, pobór i brownout, zabezpieczone ACC, test Clone IDs/LEARN z
konkretną Astrą oraz projekt i test zasilania automotive. Są checklistą w
`VALIDATION.md` i blokują status „validated”.
+110
View File
@@ -0,0 +1,110 @@
# Sprzęt i montaż
## Zakres
Podstawowy release opisuje **prototyp laboratoryjny**. DevKit, przewody
prototypowe i tania przetwornica nie są gotowym zestawem do trwałego montażu
w samochodzie. Wariant automotive poniżej jest listą wymagań projektowych,
nie zwalidowanym schematem.
## BOM prototypu laboratoryjnego
| Element | Wymaganie | Uwagi |
|---|---|---|
| ESP32 DevKit z ESP32-WROOM-32 | 3,3 V, USB do flash/konsoli | tylko biurko; mostek USB i LDO zwiększają pobór |
| CC1101 | moduł **433 MHz**, SPI, 3,3 V | nie kupuj wersji 868/915 MHz |
| Antena 433 MHz | dopasowana do modułu; na biurko monopol λ/4 ≈ 17 cm | uziemienie/przeciwwaga zgodnie z konstrukcją modułu |
| Przycisk NO | monostabilny | GPIO26 do GND |
| LED + rezystor | 330 Ω | GPIO27, LED do GND |
| Kondensatory | 100 nF przy każdym module + 47–100 µF przy CC1101 | możliwie blisko pinów zasilania |
| Przewody | krótkie, wspólna masa | SPI najlepiej <10 cm |
| Zasilanie laboratoryjne | USB 5 V do DevKit albo regulowane 3,3 V z limitem prądu | nie podawaj jednocześnie rywalizujących źródeł |
Do diagnozy RF przydaje się RTL-SDR, ale nie jest częścią emulatora. Do wersji
energooszczędnej użyj gołego ESP32-WROOM-32E na własnej płytce, z poprawnym
zasilaniem, resetem, bootstrapem i złączem programowania. Sam moduł nie ma USB.
## Pinout i połączenia
| ESP32 | CC1101 / element | Zasada |
|---|---|---|
| 3V3 | CC1101 VCC | **tylko 3,3 V** |
| GND | CC1101 GND, przycisk, LED | wspólna masa |
| GPIO18 | SCK/SCLK | SPI |
| GPIO19 | MISO/SO | SPI |
| GPIO23 | MOSI/SI | SPI |
| GPIO5 | CS/CSn/SS | SPI |
| GPIO2 | GDO0 | diagnostyka biblioteki; GDO2 niepodłączony |
| GPIO26 | przycisk NO do GND | wewnętrzny pull-up; opcjonalny zewnętrzny 10 kΩ |
| GPIO27 | rezystor 330 Ω → LED → GND | aktywna wysoko |
| GPIO34 | opcjonalny ADC zasilania przez dzielnik | nigdy 12 V wprost |
| GPIO32 | opcjonalne ACC po zmianie `PIN_ACC` i zabezpieczeniu | nigdy 12 V wprost |
| GPIO25 | opcjonalny detektor LF po zmianie `PIN_LF_TRIGGER` | domyślnie wyłączone; brak gotowego front-endu w RC |
Przy zasilaniu 3,3 V z zasilacza: ustaw limit np. 0,5 A, sprawdź polaryzację,
połącz GND, wyłącz USB jako drugie źródło. Prąd szczytowy zależy od modułu i PA.
## Antena i test położenia
Nie zgadujemy położenia odbiornika TPMS w Astrze J. Test zasięgu wykonaj na
postoju, z niską mocą, porównując odczyt RTL-SDR/diagnostykę dla kilku pozycji:
konsola środkowa, okolica za schowkiem, ewentualnie bagażnik. Wynik dla jednego
egzemplarza nie jest dowodem lokalizacji odbiornika.
Urządzenie mocuj mechanicznie, z dala od poduszek powietrznych i ich wiązek,
strefy pedałów, ruchomych części, wilgoci, źródeł ciepła i metalowych ekranów.
Nie owijaj anteny wiązką, nie prowadź jej przy żarówce/rozdzielaczu LPG ani przy
przewodach zapłonowych. Obudowa prototypu powinna być nieprzewodząca; otwór i
konieczność ekranowania trzeba ocenić pomiarowo.
## Wariant automotive — wymagania, niezwalidowany projekt
Instalacja 12 V wymaga osobnego schematu, obliczeń, PCB i testów. Minimalny łańcuch:
```text
akumulator → bezpiecznik przy źródle → ochrona reverse polarity
→ ograniczenie energii + właściwie dobrany TVS
→ regulator automotive → odsprzężenie → ESP32 + CC1101
ACC → ochrona przepięciowa + dzielnik/komparator → wejście logiczne 3,3 V
```
Wymagania:
- bezpiecznik dobrany do przewodów i poboru, blisko źródła; nie zastępuje TVS;
- ochrona przed odwrotną polaryzacją i ujemnymi przepięciami;
- TVS dobrany do rzeczywistego profilu przepięć, rezystancji źródła i energii;
napięcie robocze nie może powodować upływu przy 14,4–14,8 V, a napięcie
ograniczenia musi pozostawić margines względem absolutnego maksimum regulatora;
- regulator z odpowiednim zakresem wejściowym, prądem szczytowym, niskim Iq,
stabilnością z wybranymi kondensatorami i kwalifikacją automotive;
- odsprzężenie zgodne z kartą regulatora, ESP32 i CC1101, krótkie pętle prądowe;
- ACC/ADC z ograniczeniem prądu, clampami i progiem odpornym na zakłócenia;
- obliczenia termiczne dla najwyższej temperatury, test brownout/crank/load dump,
EMC, ESD oraz pomiar snu całego urządzenia.
**MCP1703 ma Vin maks. 16 V i nie jest pełną ochroną automotive nawet z TVS 24 V.**
TVS o progu wyższym niż dopuszczalne Vin nie chroni regulatora. Nie używamy tej
rekomendacji.
Przykład do dalszego projektu, nie gotowa rekomendacja montażowa: **LM5164-Q1**,
buck 6–100 V, 1 A, typowy Iq rzędu 10 µA (wartości zależne od warunków). Sprawdzono
z kartą TI [LM5164-Q1](https://www.ti.com/lit/ds/symlink/lm5164-q1.pdf), dostęp
2026-10-27. Projekt musi uwzględnić m.in. schemat aplikacyjny, cewkę, diodę/układ
wejściowy, kondensatory, stabilność, szczyty prądu ESP32, temperaturę i ograniczenie
przepięcia poniżej dopuszczalnego Vin z marginesem. Sama nazwa „100 V” nie dowodzi
odporności całego urządzenia.
## Zasilanie bateryjne
Ogniwo 18650 w kabinie **nie jest rekomendowane**: temperatura w samochodzie może
przekraczać bezpieczne warunki ogniwa, a zainstalowane ogniwo wymaga ochrony,
właściwego ładowania i obudowy. ESP32 z radiem i okresowym czuwaniem zwykle daje
krótki czas pracy; deklaracje wieloletniej pracy byłyby nieuzasadnione. Wieloletni
wariant bateryjny wymaga innej architektury low-power i nie należy do tego release.
## Opcjonalny LF
RC działa bez EL-50448. Nie ma w nim zwalidowanego odbiornika LF. Przyszły moduł
wymaga osobnego schematu rezonansu/detekcji 125 kHz, progu komparatora, filtracji,
testu odporności na zakłócenia i udowodnionego budzenia. Sam aktywator nie wpisuje
ID do emulatora.
+56
View File
@@ -0,0 +1,56 @@
# Energia i zachowanie na postoju
## Status pomiarów
**Nie wykonano pomiarów prądu fizycznego prototypu.** Liczby poniżej są
szacunkami budżetu, nie wynikiem walidacji. DevKit nie nadaje się do deklaracji
poboru µA, ponieważ mostek USB-UART, LED i regulator mogą pobierać ok. 0,5–2 mA
lub więcej w zależności od płytki.
## Harmonogram firmware
- NORMAL po wybudzeniu RTC: inicjalizacja, burst czterech kół, wyjście z TX i deep
sleep. Nie ma 10-sekundowego okna konsoli po zwykłym budziku.
- Po power-on, przycisku lub LF: okno konsoli 10 s; `stay N` wydłuża je.
- LEARN: TX jednego koła co 2 s, bez deep sleep, maks. 60 s na koło/15 min sesji.
- SINGLE: TX jednego koła co 2 s, bez deep sleep, maks. 5 min.
- CC1101 przechodzi w SPWD przed snem; CS jest wysoki, SCK/MOSI niskie, LED off.
- Każdy sen ma budzik RTC. `PARKING_SHUTDOWN` usunięto — urządzenie nie może
pozostać uśpione do czasu wyłącznie ręcznego wybudzenia.
- ACC (opcjonalny sprzętowo) wybiera interwał ignition/parking. Nie jest potrzebne
jako jedyne źródło wybudzenia, ponieważ RTC zawsze działa.
## Szacunek ładunku dla ustawień domyślnych
Jedna ramka to 240 × 120 µs = 28,8 ms na antenie. Dla 4 kół × 3 ramki:
345,6 ms samej transmisji plus 8 × 50 ms przerw wewnątrz burstów. Do tego dochodzi
boot, konfiguracja, SPI i logi. Do obliczeń energii trzeba zmierzyć cały cykl,
a nie tylko czas OOK.
Przykładowy model (do zastąpienia pomiarem): jeżeli aktywność ESP32 wyniesie 1,0 s
przy 80 mA co 30 s, sam ESP32 uśrednia ok. 2,7 mA na 3,3 V. CC1101, boot i prąd snu
dodają kolejne składniki. Przy interwale 120 s udział aktywności spada ok. czterokrotnie,
ale stały Iq zasilacza i dzielników pozostaje. Nie są to zmierzone 2,7 mA ani
obietnica poboru z akumulatora 12 V.
## Metoda pomiaru wymagana przed „validated”
1. **Cały DevKit w sleep:** miernik µA szeregowo na wejściu, nie przez USB.
Odczekać do końca TX i zanotować minimum/stan stabilny oraz model płytki.
2. **Goły moduł + zasilacz docelowy:** powtórzyć na wejściu 12 V i na 3,3 V.
Uwzględnić Iq regulatora, TVS, dzielniki i pull-upy.
3. **Cykl NORMAL:** bocznik + oscyloskop albo logger z odpowiednim pasmem.
Zarejestrować boot, 12 ramek, przerwy, wejście w sen przez co najmniej 10 cykli.
4. **Średnia:** całkować ładunek co najmniej 15 min przy 30 s i 120 s. Podawać
warunki: napięcie, temperatura, PA, wersja płytki i firmware.
5. **LEARN/SINGLE:** osobno zmierzyć prąd ciągłego czuwania.
6. **ACC/brownout/crank:** sprawdzić restart, powrót do nadawania i integralność
NVS. Nie wykonywać na GPIO bez potwierdzonej ochrony wejścia.
## Wnioski dopuszczalne przed pomiarem
- Największy wpływ mają interwał, czas czuwania, PA i Iq całej płytki.
- Do wersji energooszczędnej potrzebny jest goły ESP32 i zasilacz o niskim Iq.
- Nie rekomendujemy 18650 w kabinie ani wieloletniej pracy bateryjnej z ESP32.
- Stały pobór emulatora trzeba uwzględnić przy długim postoju pojazdu; nie podajemy
czasu „bezpiecznego dla akumulatora” bez pomiaru całego samochodu.
+93
View File
@@ -0,0 +1,93 @@
# Protokół Schrader EG53MA4 — fakty i niewiadome
## Przypięte źródła
| Źródło | Wersja użyta do walidacji | Zakres |
|---|---|---|
| `rtl_433/src/devices/schraeder.c` | commit `406f9a33550a2b6b3d0d8a8a486417ce5b3f13ab` | dekoder i parametry slicera |
| `rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01` | commit `1aa8c29d6b9383739d1aeed495dbc5069b704392` | cztery nagrania CU8 + JSON |
| PlatformIO | 6.1.18 | build/test |
| `espressif32` | 8.0.0 | toolchain/platforma ESP32 |
| SmartRC-CC1101-Driver-Lib | `de6757ef633b3e626dae5c7835cdb66ab53f9a1d` (3.0.2) | konfiguracja CC1101 |
| Praktyczna analiza odbioru | <https://milek7.pl/tpmsreceiver/> | kontekst; nie źródło pól ramki |
| Wzorzec integracji ESP32+CC1101 | <https://github.com/merbanan/rtl_433/issues/2978> | integracja, nie protokół EG53MA4 |
Nie używamy nieoznaczonego `master` jako referencji reprodukowalnej. Komercyjny
emulator <https://spooftpms.com/us-eu-gm-1-2-family-tpms-simulator/> potwierdza
jedynie istnienie takiej klasy urządzenia, nie zgodność tego projektu.
## Potwierdzony format po dekodowaniu Manchester
Dekoder wymaga dokładnie 120 bitów: 40 bitów synchronizacji i 80 bitów danych.
```text
0 40 64 72 80 88
| 40 × sync (0) | flags 4 B | ID 3 B | P 1 B | T 1 B | sum 1 B |
4C 90 00 70 2F C8 71 68 49 65
```
- `flags`: 32 bity; znaczenie pól nie jest w pełni znane.
- `ID`: 24 bity; firmware odrzuca 0, `FFFFFF` i duplikaty między kołami.
- `P`: 2,5 kPa/bit. 260 kPa daje 104 = `0x68`. Kwantyzacja jest zaokrąglana
do najbliższego kroku: `(kPa×10 + 12) / 25`.
- `T`: bajt w °F zgodnie z dekoderem, nie °C. 23 °C → 73 °F.
- `sum`: suma dziewięciu poprzednich bajtów modulo 256; to nie CRC-8.
- Wartość `4c900070` występuje we wszystkich 64 rekordach czterech nagrań.
Nie dowodzi to, że każdy czujnik/tryb auta używa zawsze tej wartości.
## Polaryzacja, preambuła i ogon
Nagrania i slicer `OOK_PULSE_MANCHESTER_ZEROBIT` potwierdzają G.E.T. Manchester:
`0 → 01`, `1 → 10`. Slicer dopisuje pierwszy zerowy bit. Bufor CC1101 zawiera:
```text
1 chip startowy + 39 komórek sync + 80 komórek danych + 1 chip OFF dopełnienia
= 240 chipów = 30 bajtów, MSB first.
```
Ostatni chip dopełnienia jest zerem OOK (cisza). Test sprawdza dokładnie tę
długość, polaryzację i odrzuca ucięty/uszkodony bufor.
## Timing i powtórzenia
- Dekoder ma `short_width=123 µs`, `reset_limit=300 µs`.
- Analiza `gfile001` pokazuje typowy okres pulse+gap ok. 236 µs, czyli chip
ok. **118 µs**; szerokości impulsów różnią się od szerokości przerw. Firmware
używa eksperymentalnie **120 µs**, co przechodzi dekodowanie niezależnym
`rtl_433`. Dokładny zegar fizycznego CC1101 wymaga pomiaru HIL.
- Każde z czterech nagrań zawiera **16 poprawnych powtórzeń**. W `gfile001`
odstępy początków dekodowań wahają się ok. 115–172 ms; nie są stałe.
- Domyślne **3 ramki, przerwa 50 ms, cykl 30 s** są eksperymentalnymi
ustawieniami emulatora, a nie potwierdzonym harmonogramem OE. Interwały
ACC/parking również nie mają statusu zgodności z OE.
## Nośna i modulacja
Podstawowy profil: **433,92 MHz, ASK/OOK**. Nagrania są zdekodowane przy tej
częstotliwości. README zestawu zawiera też dane produktu 315 MHz i wzmiankę
ASK+FSK; to nie jest dowód FSK w analizowanych plikach ani zgodności z konkretną
Astrą. FSK nie jest dostępny w podstawowym firmware/generatorze.
## CC1101 packet engine
Firmware ustawia fixed-length 30 B, normal FIFO, MSB first oraz wyłącza sprzętowe:
preambułę/sync (`SYNC_MODE=0`), Manchester, whitening, FEC, CRC, address check,
append status. Cała preambuła i suma protokołu są w naszych 30 B. Koniec TX jest
oczekiwany przez `MARCSTATE=IDLE` z limitem; `TXFIFO_UNDERFLOW` i pozostałe bajty
są błędem. To zapobiega obcięciu ogona przez samo `TXBYTES=0`.
Konfiguracja została audytowana, ale syntetyczny CU8 omija CC1101. Brak dodatkowych
bajtów i dokładny ogon trzeba jeszcze potwierdzić na logic analyzer/RTL-SDR w HIL.
## Niewiadome — nie wolno ich „dostrajać” losowo
1. Znaczenie poszczególnych bitów `flags`, w tym jakiegokolwiek bitu niskiej
baterii czujnika. **`TPMS_FLAGS_LOWBAT_MASK` nie istnieje w firmware.**
2. Zależność flags od nauki, ruchu, LF i stanu baterii oryginalnego czujnika.
3. Wymagany przez konkretne ECU interwał i minimalna liczba powtórzeń.
4. Zgodność OE 13506028/numera powiązanego z konkretnym egzemplarzem bez VIN,
oznaczeń, odczytu albo testu.
5. Fizyczna dokładność częstotliwości, moc i ogon generowanego CC1101 przed HIL.
Niskie zasilanie emulatora jest wyłącznie ostrzeżeniem w konsoli i nie zmienia
żadnego pola symulowanego czujnika.
+42
View File
@@ -0,0 +1,42 @@
# Bezpieczeństwo i ograniczenia
## Sztuczne dane mogą ukryć usterkę
To urządzenie generuje dane, których nie mierzy w oponach. Domyślne 260 kPa jest
wartością testową, nie potwierdzeniem ciśnienia. Symulator może spowodować, że
kontrolka nie ostrzeże o realnym przebiciu, utracie ciśnienia lub uszkodzeniu opony.
- Projekt wyłącznie diagnostyczno-warsztatowy, na postoju i pod kontrolą osoby
wykonującej test.
- Nie jest homologowanym czujnikiem ani zamiennikiem sprawnego TPMS.
- Nie używaj w jeździe drogowej i nie przedstawiaj jako bezpiecznego do tego celu.
- Przed i po teście sprawdź wszystkie opony niezależnym manometrem oraz ich stan.
- Po diagnozie przywróć sprawne, właściwie dobrane czujniki i wykonaj wymaganą
procedurę pojazdu.
## Radio i zgodność pojazdu
Profil EG53MA4/OOK 433,92 MHz jest hipotezą roboczą dla wskazanego pojazdu do
potwierdzenia. OE 13506028, numer powiązany lub oferta zamiennika nie wystarcza.
Użyj VIN, oznaczeń fabrycznych czujników, diagnostyki albo kontrolowanego testu.
Nie nadawaj z maksymalną mocą „dla pewności”. Zacznij od −10 dBm, ogranicz czas
transmisji i przestrzegaj lokalnych przepisów dotyczących 433 MHz oraz ingerencji
w elektronikę pojazdu. Urządzenie może być odbierane przez inne odbiorniki w pobliżu.
## Montaż
- Tylko prototyp laboratoryjny jest opisany jako gotowy do złożenia. Wersja 12 V
wymaga osobnego projektu i testów automotive.
- Nie podawaj 12 V na GPIO/ADC ani 5 V na CC1101.
- Nie umieszczaj urządzenia w strefie poduszek, pedałów, ruchomych elementów,
wilgoci, wysokiej temperatury ani przy instalacji LPG.
- Zabezpiecz obudowę i przewody przed poluzowaniem. Unikaj ekranowania anteny.
- Nie używaj 18650 jako rekomendowanego zasilania w kabinie.
## Diagnostyka bez fałszywej pewności
Poprawne dekodowanie przez rtl_433 nie dowodzi odbioru przez samochód. Zielone CI
nie zastępuje pomiaru CC1101, testu HIL ani kontroli opon. Zgaśnięcie kontrolki
również nie dowodzi, że opony są sprawne. Zapisuj pomiary i nie zmieniaj wielu
parametrów naraz. Brak potwierdzonego bitu niskiej baterii czujnika; niskie
zasilanie emulatora nie jest kodowane jako usterka symulowanego czujnika.
+102
View File
@@ -0,0 +1,102 @@
# Konfiguracja i uruchomienie
## Przed rozpoczęciem
1. Sprawdź zgodność konkretnego auta (VIN, oznaczenia czujników, diagnostyka lub
odbiór). Nie polegaj wyłącznie na numerze z ogłoszenia.
2. Zmontuj prototyp z `HARDWARE.md`, wgraj firmware i otwórz UART 115200.
3. Wpisz `stay 300`. `info` pokazuje konfigurację aktywną, nie tylko zapisaną.
4. Pracuj na postoju. Sztuczne 260 kPa nie opisuje rzeczywistych opon.
Koła: `1=FL` przód lewy, `2=FR` przód prawy, `3=RR` tył prawy, `4=RL` tył lewy.
Komendy konfiguracyjne automatycznie zapisują NVS i weryfikują odczyt. Błąd NVS
trzeba rozwiązać przed dalszym testem, nie ignorować.
## Ścieżka A — Clone IDs (preferowana)
Użyj jej, jeśli wcześniej odczytano oryginalne ID i auto nadal je zna.
1. Zapisz cztery ID w postaci sześciu cyfr hex.
2. Wpisz kolejno (przykładowe wartości zastąp własnymi):
```text
id 1 2FC871
id 2 2EAAF9
id 3 3495AC
id 4 2FC780
pressure all 260
info
```
3. Sprawdź w `info`, że wszystkie ID i przypisania kół są właściwe. Duplikat,
`000000`, `FFFFFF` lub wartość poza 24 bitami zostanie odrzucona.
4. Opcjonalnie `send` wymusi cykl wszystkich kół. W NORMAL urządzenie robi to
również automatycznie; po restarcie konfiguracja pozostaje.
5. Potwierdź odbiór zewnętrznie. Znane ID **mogą** wyeliminować naukę, ale nie
obiecujemy tego dla każdego stanu ECU.
Nie używaj przykładowych ID w pojeździe, jeśli mogą pokrywać się z innym
urządzeniem w pobliżu.
## Ścieżka B — New IDs + LEARN
### Przygotowanie
1. `ids new` generuje cztery unikalne ID. Można zamiast tego użyć czterech `id`.
2. `info` — zapisz ID na kartce.
3. Zapoznaj się z procedurą nauki dla konkretnej wersji nadwozia/wyposażenia.
Ten dokument nie zgaduje menu, sekwencji pedałów ani położenia odbiornika.
4. Rozpocznij procedurę nauki w aucie zgodnie z instrukcją serwisową.
### Nauka z konsoli
1. `mode learn` — start od FL; tylko FL nadaje co 2 s.
2. `send` — natychmiastowy burst FL, bez zmiany koła.
3. Po wykonaniu kroku dla FL: `next` — FR; LED wskaże 2 mrugnięcia.
4. Powtórz `send`, potem `next` — RR, następnie `next` — RL.
5. Po ostatnim `next` urządzenie wraca do NORMAL. Kolejność to zawsze
**FL → FR → RR → RL**.
6. Zakończ procedurę auta zgodnie z jej instrukcją i sprawdź odczyt diagnostyczny.
### Nauka jednym przyciskiem
- wejście: przytrzymaj ≥1,5 s;
- krótkie naciśnięcie: następne koło i natychmiastowy burst;
- wymuszenie bez zmiany koła: konsola `send`;
- wyjście przed końcem: ponownie ≥1,5 s albo `mode normal`.
Timeout 60 s na koło przerywa LEARN do NORMAL; limit całej sesji to 15 min.
Nie jest to automatyczny sukces nauki — trzeba zacząć od właściwego koła ponownie.
## SINGLE / diagnostyka
`mode single 2` nadaje tylko FR co 2 s. `send` wymusza FR, `next` przechodzi dalej.
`mode normal` kończy; automatyczny limit wynosi 5 min. Tryb nie zapisuje wyboru
koła w NVS i po utracie zasilania startuje bezpiecznie w NORMAL.
## Pozostałe ustawienia
| Komenda | Zakres / skutek |
|---|---|
| `pressure all 260` | 0–637,5 kPa, kwantyzacja 2,5 kPa |
| `temp all 23` | −40…85 °C; w ramce °F |
| `interval normal 30` | interwał bez ACC, 5–86400 s |
| `interval ignition 30` | z aktywnym sprzętowym ACC |
| `interval parking 120` | bez aktywnego ACC |
| `rf freq 433.92` | 433,05–434,79 MHz; zmiana wymaga uzasadnienia |
| `rf power -10` | −30, −20, −15, −10, −6, 0, 5 dBm |
| `rf burst 3` | 1–8 ramek na koło |
| `rf gap 50` | 20–500 ms między ramkami |
| `flags 4C900070` | eksperyment; znaczenie bitów nie jest znane |
| `factory YES` | kasuje własną konfigurację i przywraca domyślną |
Parametry harmonogramu są eksperymentalne. Moc zaczyna się od −10 dBm; zwiększaj
tylko po pomiarze i z uwzględnieniem przepisów. Niski poziom zasilania emulatora
nie ustawia żadnej flagi czujnika.
## Po restarcie lub brownout
Firmware ponownie czyta NVS. Poprawna wersja/CRC i zakresy są wymagane. Uszkodzony
lub niezgodny wpis powoduje komunikat i powrót do domyślnych, a nie wysyłanie
częściowo uszkodzonej konfiguracji. Każdy deep sleep ma budzik; nie ma trybu
`PARKING_SHUTDOWN`, który mógłby zostawić auto bez transmisji do ręcznego wybudzenia.
+37
View File
@@ -0,0 +1,37 @@
# Rozwiązywanie problemów
Pracuj po jednej zmianie i zapisuj pomiar. Nie przełączaj losowo OOK/FSK, flags,
ID ani interwałów. Podstawowy firmware nie ma trybu FSK.
| Objaw | Możliwa przyczyna | Pomiar / sprawdzenie | Naprawa |
|---|---|---|---|
| `BLAD: brak CC1101` | złe zasilanie, CS/SPI, moduł nie 433 MHz | 3,3 V na VCC-GND; ciągłość 18/19/23/5; oznaczenie modułu | popraw okablowanie, skróć SPI, użyj właściwego modułu |
| Reset przy TX | spadek 3,3 V, słabe przewody | napięcie przy ESP32/CC1101 podczas `send`, log brownout | popraw zasilacz i 47–100 µF przy module; nie zwiększaj PA |
| `TX-ERR` | underflow, niezakończony TX, zła konfiguracja CC1101 | log dla każdego koła; MARCSTATE/rejestry w HIL | sprawdź SPI i zasilanie; zapisz log do analizy, nie maskuj błędu |
| UART nie odpowiada | za krótkie okno konsoli, zły baud/port | 115200 8N1, reset, właściwy /dev/ttyUSB | wpisz `stay 300` od razu po starcie |
| Zmiana ID znika | błąd zapisu NVS, pełny flash | komunikat `OK: zapisano`, restart i `info` | nie kontynuuj przy błędzie NVS; sprawdź flash/zasilanie |
| ID odrzucone | duplikat, 0, FFFFFF, zła długość | sześć cyfr hex i `info` | nadaj cztery unikalne ID z 000001–FFFFFE |
| rtl_433 nic nie dekoduje | antena, częstotliwość, zły tor RF, zbyt mała moc | `send 1`; odbiornik 433,92 MHz blisko; pomiar ANT/GDO0 | popraw antenę/zasilanie; stopniowo testuj niskie moce; nie zmieniaj na FSK |
| rtl_433 widzi złe dane | stara konfiguracja, sąsiedni czujnik | `info`, `hex 1`, filtrowanie ID w odbiorniku | porównaj ID i wymuś `send 1` w izolowanym miejscu |
| Auto nie widzi znanych ID | niepotwierdzony profil, ECU wymaga nauki, zasięg | VIN/oznaczenia/DTC; odbiór RTL-SDR przy aucie | potwierdź profil; wykonaj LEARN; zmień położenie po pomiarze |
| LEARN stoi na jednym kole | użyto `send` zamiast `next` | `info` pokazuje aktywne koło | `next` po potwierdzeniu kroku; `send` tylko wymusza TX |
| LEARN wróciło do NORMAL | 60 s na kole / 15 min sesji | czas od wejścia, komunikat i LED | uruchom `mode learn 1` i powtórz świadomie od FL |
| Po RL nie ma następnego koła | sekwencja została zakończona | NORMAL w `info` | zakończ procedurę auta i sprawdź DTC |
| Kontrolka nie gaśnie mimo RTL-SDR OK | ECU nie zna ID, inny profil/flags/procedura | odczyt ID i DTC z diagnostyki, nie tylko SDR | Clone IDs albo LEARN; potwierdź profil auta; nie zgaduj flags |
| Pobór snu duży | DevKit, regulator, LED, dzielniki | pomiar całej płytki wg `POWER.md` | goły moduł i właściwy zasilacz; nie zmieniaj protokołu |
| Po postoju brak TX | brownout, zasilanie, błąd NVS/CC1101 | log po restarcie, `batt`, `info`, budzik RTC | popraw zasilanie; każdy sen ma RTC, więc nie „naprawiaj” przez PARKING_SHUTDOWN |
| ACC nie zmienia interwału | funkcja domyślnie wyłączona lub zły próg | `PIN_ACC`, napięcie na GPIO OFF/ON | zmontuj zabezpieczone wejście; nigdy 12 V na GPIO |
## Gdy brak odbioru w samochodzie
Kolejność diagnostyczna:
1. **Udowodnij lokalny TX:** `send 1` + RTL-SDR/analizator.
2. **Udowodnij właściwy profil:** VIN, oznaczenia czujników, odczyt auta.
3. **Sprawdź ID i kolejność:** `info`, Clone IDs albo jeden aktywny w LEARN.
4. **Sprawdź zasięg:** niska moc najpierw, konsola/za schowkiem, ewentualnie
bagażnik; bez demontażu poduszek i zgadywania lokalizacji ECU.
5. **Dopiero analizuj flags:** porównaj z nagraniem oryginalnego czujnika tego
samego trybu. Brak potwierdzonego bitu low battery — nie ustawiaj go.
6. Jeśli nie ma pomiaru lub danych, zatrzymaj test. Losowe zmiany tworzą nowe
zmienne i nie stanowią diagnozy.
+125
View File
@@ -0,0 +1,125 @@
# Walidacja
## Jedno polecenie bez sprzętu
```bash
bash tools/check_all
```
Skrypt wykonuje self-test Pythona, testy native, pełny build ESP32, cppcheck,
pobranie przypiętych źródeł (przy pierwszym uruchomieniu) oraz dekodowanie CU8
przez prawdziwy `rtl_433`. Logi: `artifacts/validation/`. Każdy etap ma `pipefail`,
a błąd kończy skrypt kodem niezerowym.
Alternatywa reprodukowalna:
```bash
docker build -t tpms-rc .
docker run --rm -v "$PWD/artifacts:/work/artifacts" tpms-rc
```
## Wyniki z 2026-10-27
Środowisko: Linux, Python 3.14.4 przy teście hosta; PlatformIO 6.1.18;
espressif32 8.0.0; Arduino ESP32 3.3.12; SmartRC CC1101 commit
`de6757ef633b3e626dae5c7835cdb66ab53f9a1d`; rtl_433 commit `406f9a3…`;
rtl_433_tests commit `1aa8c29…`. Pełne SHA znajdują się w `PROTOCOL.md`.
| Komenda | Wynik |
|---|---|
| `pio test -e native` | **20/20 PASS** — ramka, cztery niezależne wektory, negatywne, NVS, fake clock/radio, Clone IDs, LEARN, SINGLE, ACC, restart |
| `pio run -e esp32dev` | **PASS**, własne ostrzeżenia traktowane jako błędy (`-Werror`) |
| `pio check -e native ... --fail-on-defect=low` | **PASS**, 0 defektów po poprawce inicjalizacji struktur |
| `python3 tools/tpms_frame.py --self-test` | **PASS**, nagranie + 500 ramek |
| `tools/verify_rtl433.sh` | **PASS**, 64/64 rekordy referencyjne; 3/3 syntetyczne; 3/3 negatywne odrzucone |
| `git diff --check` | **PASS** |
| dwa czyste `tools/package_release.sh` | **PASS**, identyczne wszystkie 6 SHA-256 po ustawieniu `SOURCE_DATE_EPOCH=1761600000` |
Dane referencyjne: każdy z `gfile001`…`gfile004` dał dokładnie 16 zgodnych
rekordów, z oczekiwanym ID/flags/ciśnieniem/temperaturą. Syntetyczne ramki
2FC871/260 kPa/73 F, 3495AC/220 kPa/23 F i ABCDEE/262,5 kPa/75 F zostały
zdekodowane przez niezależny `rtl_433`. Uszkodzony Manchester, zła suma i ucięcie
nie dały rekordu EG53MA4.
## Macierz pokrycia
| Warstwa | Automatyczne | RTL-SDR fizyczny | CC1101 fizyczny | Samochód |
|---|---|---|---|---|
| pola, checksum, kwantyzacja | wykonane | niepotrzebne do pola | niepotrzebne | potwierdzenie interpretacji ECU |
| Manchester/preambuła/długość | wykonane | **niewykonane** | **niewykonane** | niewykonane |
| prawdziwe nagrania → rtl_433 | wykonane, 64/64 | nie dotyczy | nie dotyczy | nie dotyczy |
| syntetyczne CU8 → rtl_433 | wykonane | nie dotyczy | omija hardware | nie dotyczy |
| rejestry CC1101/ogon/moc/częstotliwość | audyt kodu | wymagane | **wymagane** | wymagane |
| NVS, ID, interwały, tryby | wykonane; NVS emulowane blobem | wymagany test restartu | wymagany | wymagany |
| LEARN FL→FR→RR→RL | state-machine PASS | pomocnicze | wymagane | **niewykonane** |
| pobór/brownout/ACC | state-machine ACC; brak pomiarów | nie dotyczy | wymagane | wymagane |
**Brak podstaw do oznaczenia „validated”.** Gitea Actions ma workflow, ale stan
runnera i wynik zdalnego CI należy sprawdzić; lokalny PASS nie jest udawanym CI.
## Checklista HIL — wymaga użytkownika i sprzętu
### CC1101 + analizator/RTL-SDR
- [ ] Odczytać rejestry po inicjalizacji: OOK, 433,92 MHz, fixed 30 B,
`SYNC_MODE=0`, brak CRC/Manchester/whitening/FEC/append.
- [ ] Na GDO0/ANT potwierdzić dokładnie 30 B, chip ~120 µs, pełny ostatni chip
i brak sprzętowej preambuły/sync/CRC/dodatkowych bajtów.
- [ ] Zanotować TX-ERR/underflow; przy prawidłowym torze ma ich nie być.
- [ ] Zmierzyć częstotliwość i względną moc dla −10 dBm; nie zakładać kalibracji
taniego modułu. Nie zwiększać PA bez potrzeby.
- [ ] `send 1`…`send 4`: RTL-SDR dekoduje właściwe ID, 260 kPa i flags.
- [ ] Powtórzyć po resecie i 10 cyklach deep sleep.
### NVS i wejścia
- [ ] Ustawić własne ID/ciśnienia/RF, odłączyć zasilanie na >1 min, ponownie
sprawdzić `info` i transmisję.
- [ ] Sprawdzić odrzucenie duplikatu ID, złej mocy i złego interwału.
- [ ] `factory YES` przywraca 260 kPa i domyślne RF.
- [ ] Brownout/crank na zabezpieczonym zasilaczu: brak zawieszenia i uszkodzenia
konfiguracji; zapis wykonywać tylko po stabilizacji zasilania.
- [ ] Jeśli ACC jest montowane: zmierzyć napięcie na GPIO dla OFF/ON/przepięcia,
sprawdzić interwały i samoczynne wznowienie po ACC ON. Bez ACC pominąć.
### Konkretny Opel Astra J
- [ ] Potwierdzić profil przez VIN/oznaczenia/diagnostykę przed nadawaniem.
- [ ] Clone IDs: odbiór czterech znanych ID bez zakładania, że nauka zniknie.
- [ ] New IDs: pełna nauka FL→FR→RR→RL z jednym aktywnym kołem.
- [ ] Odczyt DTC i danych TPMS przed/po; zapisać wersję ECU i procedurę.
- [ ] Test położenia: konsola środkowa/za schowkiem, ewentualnie bagażnik;
na postoju, bez zgadywania lokalizacji odbiornika.
- [ ] Kontrola manometrem wszystkich opon przed i po. Nie wykonywać testu jako
jazdy drogowej z symulatorem zamiast sprawnego TPMS.
## Artefakty i wgrywanie
```bash
bash tools/package_release.sh
```
Katalog `artifacts/release/`:
| Plik | Adres |
|---|---:|
| `bootloader.bin` | `0x1000` |
| `partitions.bin` | `0x8000` |
| `boot_app0.bin` | `0xE000` |
| `firmware.bin` | `0x10000` |
| `firmware-full.bin` | `0x0` — pełny obraz 4 MB |
| `firmware.elf` | debug/symbole, nie wgrywać jako flash |
| `SHA256SUMS`, `BUILD-INFO.txt` | kontrola integralności i wersji |
Pełny obraz kasuje poprzedni flash przy zapisie całego obszaru; NVS w partycji
może zostać utracone — zapisz ID przed aktualizacją pełnym obrazem. Aktualizacja
samej aplikacji `firmware.bin` pod `0x10000` zwykle zachowuje NVS, ale przed
release użytkownik powinien wykonać test na własnym module.
```bash
PORT=/dev/ttyUSB0 bash tools/flash_release.sh
sha256sum -c artifacts/release/SHA256SUMS
```
Nie wgrywaj obrazu z innego toolchaina na ślepo. RC nie zawiera fizycznego testu
update ani samochodu.