Release candidate 2.0.0-rc.1 #1
No files matched your search
@@ -0,0 +1,25 @@
|
||||
name: check
|
||||
on:
|
||||
push:
|
||||
branches: [main, feat/release-v2]
|
||||
pull_request:
|
||||
|
||||
jobs:
|
||||
check-without-hardware:
|
||||
runs-on: docker
|
||||
container: python:3.12.12-slim-bookworm
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install build dependencies
|
||||
run: |
|
||||
apt-get update
|
||||
apt-get install -y --no-install-recommends build-essential cmake git libusb-1.0-0-dev pkg-config ca-certificates
|
||||
- name: Install pinned Python tools
|
||||
run: pip install --no-cache-dir --disable-pip-version-check -r tools/requirements.txt
|
||||
- name: All tests without hardware
|
||||
run: bash ./tools/check_all
|
||||
- name: Upload validation reports
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: validation-reports
|
||||
path: artifacts/validation/
|
||||
@@ -1,6 +1,10 @@
|
||||
.pio/
|
||||
.vscode/
|
||||
.venv/
|
||||
.cache/
|
||||
artifacts/
|
||||
*.o
|
||||
*.elf
|
||||
*.bin
|
||||
__pycache__/
|
||||
*.pyc
|
||||
@@ -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”.
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
FROM python:3.12.12-slim-bookworm
|
||||
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
build-essential cmake git libusb-1.0-0-dev pkg-config ca-certificates \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
WORKDIR /work
|
||||
COPY tools/requirements.txt tools/requirements.txt
|
||||
RUN pip install --no-cache-dir --disable-pip-version-check -r tools/requirements.txt
|
||||
COPY . .
|
||||
RUN chmod +x tools/check_all tools/*.sh
|
||||
CMD ["bash", "./tools/check_all"]
|
||||
@@ -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.
|
||||
@@ -1,694 +1,159 @@
|
||||
# Symulator 4 czujników TPMS Schrader EG53MA4 (ESP32 + CC1101)
|
||||
# Symulator TPMS Schrader EG53MA4 — ESP32 + CC1101
|
||||
|
||||
Firmware dla ESP32 DevKit + moduł CC1101 (433 MHz), symulujący **4 czujniki
|
||||
ciśnienia w oponach** (po jednym na koło) dla **Opla Astry J Sedan 2016**
|
||||
(rynek EU, TPMS bezpośredni, czujniki typu Schrader / Opel OEM 13348393,
|
||||
protokół **Schrader EG53MA4**).
|
||||
**Wersja 2.0.0-rc.1 — release candidate bez walidacji sprzętowej.**
|
||||
|
||||
> ## ⚠️ ZASTRZEŻENIE
|
||||
> Projekt **wyłącznie do celów diagnostycznych i testowych**.
|
||||
> Symulator dostarcza **sztuczne dane ciśnienia i temperatury** i **nie
|
||||
> zastępuje prawdziwych czujników TPMS**. TPMS jest elementem bezpieczeństwa
|
||||
> czynnego pojazdu — **nie używaj tego urządzenia podczas jazdy po drogach
|
||||
> publicznych**. Nadawanie w paśmie 433 MHz może podlegać lokalnym
|
||||
> przepisom (np. w Polsce praca krótkiego zasięgu w 433 MHz jest dozwolona
|
||||
> z ograniczeniami mocy) — sprawdź przepisy obowiązujące w Twoim kraju.
|
||||
Urządzenie warsztatowe nadaje cztery niezależne identyfikatory TPMS profilem
|
||||
OOK/Manchester Schrader EG53MA4 na 433,92 MHz. Domyślnie każde koło raportuje
|
||||
**260 kPa (2,6 bar; bajt protokołu `0x68`)**. Docelowy scenariusz to diagnostyka
|
||||
Opla Astry J Sedan 1.4 LPG (2016, EU), ale **zgodność trzeba potwierdzić dla
|
||||
konkretnego auta**: przez VIN/wykaz serwisowy, oznaczenia fabrycznych czujników,
|
||||
odczyt diagnostyczny albo test odbioru. Numer OE 13506028, numery powiązane ani
|
||||
ogłoszenie sprzedażowe same w sobie nie potwierdzają profilu radiowego.
|
||||
|
||||
---
|
||||
> **Nie jest to homologowany czujnik ani zamiennik sprawnego TPMS. Nie używać
|
||||
> w jeździe drogowej.** Sztuczne ciśnienie może ukryć przebitą lub niedopompowaną
|
||||
> oponę i opóźnić ostrzeżenie. Przed i po teście sprawdź wszystkie opony
|
||||
> niezależnym manometrem. Zobacz [SAFETY](docs/SAFETY.md).
|
||||
|
||||
## 1. Spis treści
|
||||
## Co jest gotowe, a czego nie
|
||||
|
||||
1. [Spis treści](#1-spis-treści)
|
||||
2. [Jak to działa](#2-jak-to-działa)
|
||||
3. [Budowa projektu](#3-budowa-projektu)
|
||||
4. [Kompilacja](#4-kompilacja)
|
||||
5. [(a) Okablowanie i lista podzespołów](#5-a-okablowanie)
|
||||
6. [(b) Konfiguracja ID i ciśnień](#6-b-konfiguracja-id-i-cisnień)
|
||||
7. [(c) Test nadawania — RTL-SDR + rtl_433](#7-c-test-nadawania--rtl-sdr--rtl_433)
|
||||
8. [(d) Programowanie czujników w aucie (tryb learn)](#8-d-programowanie-czujników-w-aucie-tryb-learn)
|
||||
9. [(e) Pomiar poboru prądu](#9-e-pomiar-poboru-prądu)
|
||||
10. [(f) Weryfikacja, że błąd zniknął](#10-f-weryfikacja-że-błąd-zniknął)
|
||||
11. [Tryby pracy i sterowanie](#11-tryby-pracy-i-sterowanie)
|
||||
12. [Konsola szeregowa](#12-konsola-szeregowa)
|
||||
13. [Budżet prądu](#13-budżet-prądu)
|
||||
14. [Protokół — szczegóły techniczne](#14-protokół--szczegóły-techniczne)
|
||||
15. [Rozwiązywanie problemów](#15-rozwiązywanie-problemów)
|
||||
- Gotowe: build ESP32, testy ramek/NVS/maszyny stanów, syntetyczny CU8 dekodowany
|
||||
przez niezależny `rtl_433`, trwała konfiguracja z konsoli, Clone IDs i LEARN.
|
||||
- **Niewykonane:** pomiar rzeczywistego CC1101, RTL-SDR z anteną, test z samochodem,
|
||||
pomiar prądu i testy automotive. Dlatego wynik jest RC, nie „validated”.
|
||||
- Jedyny profil podstawowy to **OOK**. Nie przełączaj na FSK „na próbę”.
|
||||
- ESP32 nie generuje nośnej 433 MHz — wymagany jest osobny CC1101 433 MHz.
|
||||
|
||||
---
|
||||
## Schemat ideowy
|
||||
|
||||
## 2. Jak to działa
|
||||
```text
|
||||
USB 5 V (TYLKO prototyp) 3,3 V OOK 433,92 MHz
|
||||
│ │ │
|
||||
[ESP32 DevKit] ── SPI ───────> [CC1101 433 MHz] ── antena ────┘
|
||||
│ │
|
||||
├── GPIO26: przycisk └── wspólna GND
|
||||
└── GPIO27: LED + 330 Ω
|
||||
|
||||
Urządzenie zachowuje się jak 4 czujniki TPMS Schrader EG53MA4:
|
||||
|
||||
* co `TX_INTERVAL_S` (domyślnie 30 s) budzi się z **deep sleep**,
|
||||
konfiguruje CC1101 i wysyła **burst 3 ramek** dla każdego z 4 kół
|
||||
(tak jak prawdziwy czujnik, który powtarza pakiet 3–6 razy),
|
||||
* ramka zawiera: `flags` + 24-bit ID czujnika + ciśnienie (2,5 kPa/bit)
|
||||
+ temperaturę (°F) + sumę kontrolną — **zgodnie z dekoderem rtl_433
|
||||
`schrader_EG53MA4`**,
|
||||
* dane kodowane są Manchesterem **G.E.T. MC** (chip 120 µs),
|
||||
modulacja **ASK/OOK 433.92 MHz** (opcjonalnie **2-FSK, dewiacja 47.6 kHz**),
|
||||
* między transmisjami ESP32 śpi (budzik RTC + budzenie przyciskiem lub
|
||||
wejściem LF), CC1101 jest w trybie SLEEP,
|
||||
* tryb **LEARN** pozwala wprowadzić ID do pamięci auta po kolei
|
||||
(przód lewy → przód prawy → tył prawy → tył lewy),
|
||||
* tryb **SINGLE** wymusza nadawanie jednego wskazanego ID.
|
||||
|
||||
Wszystkie dane (ID, ciśnienia, temperatury, interwały) są **sztuczne**
|
||||
i konfigurowalne w `src/config.h`.
|
||||
|
||||
---
|
||||
|
||||
## 3. Budowa projektu
|
||||
|
||||
```
|
||||
tpms/
|
||||
├── platformio.ini # konfiguracja budowania (ESP32 Arduino + testy natywne)
|
||||
├── src/
|
||||
│ ├── config.h # <<< WSZYSTKIE USTAWIENIA (ID, piny, interwały) >>>
|
||||
│ ├── main.cpp # maszyna stanów: NORMAL / LEARN / SINGLE, deep sleep
|
||||
│ ├── tpms_frame.h/.cpp # generator ramki + kodowanie Manchester (bez Arduino)
|
||||
│ ├── radio.h/.cpp # konfiguracja CC1101, nadawanie, tryb SLEEP
|
||||
│ ├── power.h/.cpp # pomiar napięcia, gpio_hold, deep sleep
|
||||
│ ├── ui.h/.cpp # przycisk (gesty) + LED statusowy
|
||||
│ ├── console.h/.cpp # konsola szeregowa (debug bez samochodu)
|
||||
│ └── app.h # API aplikacji (tryby)
|
||||
├── test/test_tpms_frame/ # testy jednostkowe generatora ramek (native)
|
||||
└── tools/
|
||||
├── tpms_frame.py # referencyjna implementacja ramki + self-test
|
||||
├── gen_cu8.py # synteza nagrania IQ (OOK/FSK) do testów z rtl_433
|
||||
└── verify_rtl433.sh # automatyczna weryfikacja ramek przez rtl_433
|
||||
Konfiguracja: USB/UART 115200 → NVS → 4 × {ID, ciśnienie, temperatura}
|
||||
```
|
||||
|
||||
Referencje protokołu (źródła, na których oparto kod):
|
||||
Nie podłączaj 12 V do GPIO, 3V3 ani VIN DevKit. Połączenia i wariant automotive:
|
||||
[HARDWARE](docs/HARDWARE.md).
|
||||
|
||||
* `rtl_433/src/devices/schraeder.c` (historycznie: `tpms_schrader.c`) —
|
||||
dekoder **Schrader TPMS EG53MA4, Saab, Opel, Vauxhall, Chevrolet**
|
||||
(Opel OEM 13348393): format ramki, checksum, skale ciśnienia/temperatury:
|
||||
<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
|
||||
## Quick Start
|
||||
|
||||
---
|
||||
### 1. Złóż prototyp
|
||||
|
||||
## 4. Kompilacja
|
||||
Kup elementy z [BOM](docs/HARDWARE.md#bom-prototypu-laboratoryjnego). Podłącz
|
||||
CC1101, przycisk i LED zgodnie z tabelą pinów. Zasil DevKit przez znany kabel USB
|
||||
na biurku. Nie montuj jeszcze niczego w samochodzie.
|
||||
|
||||
### PlatformIO (zalecane)
|
||||
### 2. Zainstaluj narzędzia i sprawdź projekt
|
||||
|
||||
Wymagane: Python 3, Git, CMake, kompilator C/C++, `pkg-config` i nagłówki libusb.
|
||||
Najprościej użyć Dockera:
|
||||
|
||||
```bash
|
||||
pio run -e esp32dev # kompilacja
|
||||
pio run -e esp32dev -t upload # wgrywanie
|
||||
pio device monitor # monitor szeregowy 115200
|
||||
pio test -e native # testy generatora ramek (bez sprzętu)
|
||||
docker build -t tpms-rc .
|
||||
docker run --rm -v "$PWD/artifacts:/work/artifacts" tpms-rc
|
||||
```
|
||||
|
||||
Biblioteka CC1101 (`SmartRC-CC1101-Driver-Lib`, dawniej
|
||||
`ELECHOUSE_CC1101_SRC_DRV`) jest pobierana automatycznie z `platformio.ini`
|
||||
(przypięta do commita zweryfikowanego buildu). **Wymagana wersja ≥ 2.5.7**
|
||||
(wspólne API `setSpiPin`/`setGDO0` dla 2.5.x i 3.x; starsze 1.x używały
|
||||
`setSCK`/`setMISO`/... i nie są obsługiwane).
|
||||
|
||||
### arduino-cli (alternatywa)
|
||||
Bez Dockera skrypt utworzy `.venv` z PlatformIO, pobierze przypięty `rtl_433`
|
||||
i referencyjne nagrania:
|
||||
|
||||
```bash
|
||||
arduino-cli core install esp32:esp32
|
||||
arduino-cli lib install "SmartRC-CC1101-Driver-Lib" # albo: lib ZIP z githuba
|
||||
arduino-cli compile --fqbn esp32:esp32:esp32 --libraries . .
|
||||
bash tools/check_all
|
||||
```
|
||||
|
||||
(Utwórz folder `src/` jako szkic albo użyj `--build-property` z
|
||||
`build.extra_flags`; najwygodniej jednak otworzyć katalog w PlatformIO.)
|
||||
Ostatni komunikat musi brzmieć `PASS: wszystkie testy bez sprzetu...`.
|
||||
To nie jest test fizycznego radia.
|
||||
|
||||
### Weryfikacja bez sprzętu (opcjonalna)
|
||||
### 3. Skompiluj i wgraj
|
||||
|
||||
```bash
|
||||
python3 tools/tpms_frame.py --self-test # zgodność z dekoderem rtl_433
|
||||
RTL433=rtl_433 ./tools/verify_rtl433.sh # pełne testy z prawdziwym rtl_433
|
||||
.venv/bin/pio run -e esp32dev
|
||||
.venv/bin/pio run -e esp32dev -t upload
|
||||
.venv/bin/pio device monitor --baud 115200
|
||||
```
|
||||
|
||||
`tools/verify_rtl433.sh` generuje syntetyczne nagrania IQ takie, jakie
|
||||
odbiornik RTL-SDR zobaczy w eterze, i sprawdza, czy **prawdziwy rtl_433**
|
||||
dekoduje je jako poprawny czujnik Schrader z oczekiwanym ID/ciśnieniem/
|
||||
temperaturą. Ostatni wynik testów projektu:
|
||||
Jeżeli port nie jest wykrywany automatycznie, dodaj `--upload-port /dev/ttyUSB0`
|
||||
(przy `run`) albo `--port /dev/ttyUSB0` (przy `device monitor`). W monitorze
|
||||
PlatformIO wyjście to zwykle `Ctrl+]`.
|
||||
|
||||
```
|
||||
== OOK (domyslna modulacja, wbudowany dekoder Schrader-EG53MA4) ==
|
||||
OK c1.cu8 id=2FC871 260.0 kPa 73.0 F
|
||||
OK c2.cu8 id=3495AC 220.0 kPa 23.0 F
|
||||
OK c3.cu8 id=ABCDEE 262.5 kPa 75.0 F
|
||||
== FSK (wariant konfigurowalny, dekoder flex) ==
|
||||
OK c4.cu8 (FSK) bitstream zgodny: 00000000004c9000702fc871684965
|
||||
WSZYSTKO OK - ramki dekoduja sie poprawnie przez rtl_433
|
||||
Po uruchomieniu wpisz `stay 300` i Enter. Masz 5 minut na konfigurację; polecenie
|
||||
`info` pokazuje aktywne wartości. Każda zmiana konfiguracji jest od razu zapisywana
|
||||
w NVS i zachowuje się po restarcie — **nie edytuj ID w kodzie**.
|
||||
|
||||
### 4A. Preferowane: Clone IDs
|
||||
|
||||
Jeśli znasz oryginalne 24-bit ID (np. z wcześniejszego odczytu `rtl_433`), wpisz
|
||||
je w kolejności FL, FR, RR, RL. Przykład — zastąp wartości własnymi:
|
||||
|
||||
```text
|
||||
stay 300
|
||||
id 1 2FC871
|
||||
id 2 2EAAF9
|
||||
id 3 3495AC
|
||||
id 4 2FC780
|
||||
pressure all 260
|
||||
info
|
||||
send
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 5. (a) Okablowanie
|
||||
|
||||
### Lista podzespołów (BOM) — co kupić
|
||||
|
||||
Koszty orientacyjne (zł, z dostawą z AliExpress/Allegro, stan na 2026 r.).
|
||||
Wystarczy **jedna sztuka** każdego podzespołu.
|
||||
|
||||
**Obowiązkowe:**
|
||||
|
||||
| Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. |
|
||||
|-----|-----------|-----------------|-------|----------------|
|
||||
| 1 | ESP32 DevKit (WROOM-32) | moduł ESP32-WROOM-32, USB | Do testów na biurku OK. **Do montażu w aucie kup sam moduł ESP32-WROOM-32E** (bez mostka USB/LDO) + płytkę — patrz sekcja 13 o poborze prądu | 15–30 zł |
|
||||
| 2 | Moduł CC1101 **433 MHz** | 8-pin, SPI, złącze goldpin | Koniecznie wersja 433 MHz (nie 868/915); dokup/drut antenowy ~17 cm; sprawdzić złącze ANT | 10–25 zł |
|
||||
| 3 | Przycisk monostabilny | NO, wpuszczany lub panelowy | Tryby pracy (learn/single) | 2–5 zł |
|
||||
| 4 | LED + rezystor 330 Ω | LED 3 mm/5 mm dowolny kolor | Status trybów | 1–3 zł |
|
||||
| 5 | Rezystor 10 kΩ | 1 szt. | Podciągnięcie przycisku do 3V3 | < 1 zł |
|
||||
| 6 | Rezystory 1 MΩ + 270 kΩ | po 2 szt. | Dzielniki pomiaru napięcia i ACC (~9 µA/szt. przy 12 V) | < 1 zł |
|
||||
| 7 | Kondensatory | 100 µF/16 V elektrolityczny + 2× 100 nF ceramiczny | Odsprzężenie zasilania CC1101 i ESP32 (obowiązkowo przy długich przewodach) | 1–3 zł |
|
||||
| 8 | Bezpiecznik + uchwyt | 1 A, zwłoczny | Szeregowo z +12 V | 2–5 zł |
|
||||
| 9 | Przewody, złącza | goldpiny 2,54 mm, kostki, ekran SPI | Przewody SPI możliwie krótkie (< 10 cm) | 5–15 zł |
|
||||
| 10 | Obudowa | IP65, min. 80×60×30 mm | Montaż w komorze silnika/bagażniku | 10–25 zł |
|
||||
|
||||
**Zasilanie — wybierz wariant (konfigurowalne w `config.h`, `POWER_SUPPLY_MODE`):**
|
||||
|
||||
| Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. |
|
||||
|-----|-----------|-----------------|-------|----------------|
|
||||
| 11a | **Wariant 12 V**: LDO 3,3 V o niskim Iq i **wejściu ≥ 16 V** | np. **MCP1703-3302** (Vin 2,7–16 V, Iq ≈ 2 µA) | + zabezpieczenie wejścia: bezpiecznik, **TVS 24 V**, rezystor/dioda szeregowa (przepięcia load-dump!). Sprawdź moc strat: (14,4−3,3) V × ~30 mA ≈ 0,33 W — stosuj obudowę SOT-223/TO-92 i nie przeciążaj | 2–8 zł |
|
||||
| 11b | **Wariant 12 V** (wydajniejszy): buck o szerokim wejściu | np. **LM5164-Q1** (Vin 6–100 V, Iq ≈ 10 µA, 1 A) lub inny buck automotive | Wymaga cewki i płytki; **TPS62740 (Vin 2,2–5,5 V) i tanie bucki (LM2596, MP1584, Mini360, Iq mA) NIE nadają się do 12 V / snu < 50 µA** | 20–50 zł |
|
||||
| 12 | **Wariant bateryjny**: ogniwo 3,6 V lub LiPo | Li-SOCl2 3,6 V (AA/half-AA, np. ER14505) + uchwyt **bezposrednio**; LiPo 3,7 V **przez LDO 3,3 V** (np. MCP1700, Vin max 6 V) | **Nie zasilaj LiPo 4,2 V wprost** — max ESP32 to 3,6 V, CC1101 to 3,9 V! | 10–30 zł |
|
||||
|
||||
**Opcjonalne (ulepszenia i testy):**
|
||||
|
||||
| Lp. | Podzespół | Parametry / typ | Uwagi | Koszt orient. |
|
||||
|-----|-----------|-----------------|-------|----------------|
|
||||
| 13 | Front-end LF 125 kHz | cewka rezonansowa (ferrytowa ramka z programatora TPMS), dioda Schottkyego (BAT54/1N5711), 100 pF + 100 kΩ, komparator LM393 | Reakcja na aktywację czujnika programatorem przy kole (`PIN_LF_TRIGGER`) | 10–30 zł |
|
||||
| 14 | Dzielnik ACC | 1 MΩ + 270 kΩ + 100 nF | Sygnał zapłonu 12 V → GPIO32 (tryb ignition-aware) | < 2 zł |
|
||||
| 15 | RTL-SDR (dongle) | R820T2/RTL2832U | Testy z `rtl_433` (sekcja 7) — można wypożyczyć | 60–150 zł |
|
||||
| 16 | Kabel USB + ew. programator | do wgrywania firmware | W DevKit kabel USB-A/Micro-USB wystarczy | 5–15 zł |
|
||||
|
||||
**Narzędzia (do pomiarów, sekcja 9):** multimetr z zakresem µA (obowiązkowo do
|
||||
pomiaru snu), opcjonalnie INA219/INA226 lub oscyloskop do pomiaru prądu w burst.
|
||||
|
||||
**Na skróty — zestaw minimalny „na biurko"** (testy RF + nauka): pozycje 1–10
|
||||
z wariantem 12 V lub zasilaniem z powerbanka 5 V przez DevKit (testy RF nie
|
||||
wymagają spełnienia budżetu prądu).
|
||||
|
||||
Gdzie kupić: AliExpress (CC1101, LM5164, ESP32), Allegro/sklepy elektroniczne
|
||||
(pasywne elementy, obudowa, bezpieczniki, TVS). Przy zamawianiu CC1101 sprawdź, czy
|
||||
moduł jest oznaczony **433 MHz** — wersje 868/915 MHz nie zadziałają bez
|
||||
przestrojenia.
|
||||
|
||||
### Podłączenie
|
||||
|
||||
| ESP32 DevKit | CC1101 | Uwagi |
|
||||
|--------------|-------------|----------------------------------------|
|
||||
| 3V3 | VCC | **3.3 V!** (CC1101 nie toleruje 5 V) |
|
||||
| GND | GND | masa wspólna |
|
||||
| GPIO18 | SCK (SCLK) | `PIN_CC1101_SCK` |
|
||||
| GPIO19 | MISO (SO) | `PIN_CC1101_MISO` |
|
||||
| GPIO23 | MOSI (SI) | `PIN_CC1101_MOSI` |
|
||||
| GPIO5 | CS (CSn/SS) | `PIN_CC1101_CS` |
|
||||
| GPIO2 | GDO0 | `PIN_CC1101_GDO0` |
|
||||
| — | GDO2 | nieużywany (zostaw odłączony) |
|
||||
|
||||
Pozostałe elementy (numery pinów konfigurowalne w `config.h`):
|
||||
|
||||
| Element | Pin ESP32 | Podłączenie |
|
||||
|-------------------------|-----------|------------------------------------------------|
|
||||
| Przycisk trybów | GPIO26 | GPIO —— przycisk —— GND, rezystor 10 kΩ do 3V3 (aktywny niski, `BTN_ACTIVE_LEVEL 0`) |
|
||||
| LED statusowy | GPIO27 | GPIO —— 330 Ω —— LED —— GND |
|
||||
| Wejście LF 125 kHz (opcjonalnie) | GPIO25 | wyjście detektora LF (impuls do 3,3 V), stan spoczynkowy **niski**; bez modułu: ustaw `PIN_LF_TRIGGER -1` |
|
||||
| ACC / zapłon (opcjonalnie) | GPIO32 | dzielnik 12 V → ~3 V (1 MΩ / 270 kΩ + 100 nF), wejście **INPUT** (bez podciągania); **domyślnie wyłączone** (`PIN_ACC -1`) — ustaw 32 po podłączeniu |
|
||||
| Pomiar napięcia | GPIO34 | węzeł środkowy dzielnika `R1=1 MΩ / R2=270 kΩ` (ADC1) + 100 nF |
|
||||
|
||||
Zasilanie (wybór w `config.h`, `POWER_SUPPLY_MODE`):
|
||||
|
||||
```
|
||||
POWER_12V (na stałe z akumulatora) - UWAGA: zakres samochodowy to nie
|
||||
same "12 V": 14,4 V przy ladowaniu
|
||||
i przepięcia load-dump > 40 V:
|
||||
+12 V ──[bezpiecznik 1 A]──[TVS 24 V do masy]──[rezystor/dioda]── regulator
|
||||
── 3,3 V ── ESP32 + CC1101
|
||||
|
||||
Regulator (wybierz jeden):
|
||||
- LDO o Iq ~2 µA i wejściu >= 16 V, np. MCP1703-3302
|
||||
(straty: (14,4-3,3) V x ~30 mA = ~0,33 W - zwróć uwagę na obudowę),
|
||||
- albo buck automotive o szerokim wejściu, np. LM5164-Q1 (6-100 V,
|
||||
Iq ~10 µA) - wydajniejszy, wymaga cewki.
|
||||
TPS62740 (Vin 2,2-5,5 V!) i tanie bucki (LM2596/MP1584/Mini360, Iq mA)
|
||||
NIE nadają się do tej aplikacji.
|
||||
|
||||
POWER_BATTERY:
|
||||
Li-SOCl2 3,6 V ── bezposrednio 3V3 (ESP32 wymaga >= 3,0 V pod obciazeniem)
|
||||
LiPo 3,7 V ── PRZEZ LDO 3,3 V (np. MCP1700). Bezposrednie zasilanie
|
||||
LiPo 4,2 V przekracza max ESP32 (3,6 V) i CC1101 (3,9 V)!
|
||||
```
|
||||
|
||||
```
|
||||
+12V ──[bezpiecznik]──[TVS]──> regulator IN
|
||||
Pomiar: +12V ──[R1 1M]──+── GPIO34 ( + 100 nF do masy )
|
||||
└──[R2 270k]── GND
|
||||
(12 V -> 2,55 V, 14,4 V -> 3,05 V, prad dzielnika ~9 uA)
|
||||
```
|
||||
|
||||
Ważne:
|
||||
|
||||
* **moduły DevKit z mostkiem USB-UART (CH340/CP2102) i LDO AMS1117 pobierają
|
||||
w deep sleep 0,5–2 mA** — w aucie użyj gołego modułu ESP32-WROOM na własnej
|
||||
płytce z przetwornicą o niskim Iq (patrz sekcja 13),
|
||||
* CC1101 zasilaj **3,3 V**, antena 433 MHz (kawałek drutu ~17 cm) przy złączu
|
||||
CC1101; trzymaj przewody SPI krótkie,
|
||||
* masa dzielnika pomiarowego i CC1101 musi być wspólna z ESP32.
|
||||
|
||||
**Opcjonalny front-end LF 125 kHz** (reakcja na aktywację czujnika
|
||||
programatorem TPMS przy kole): cewka rezonansowa ~125 kHz (kilka zwojów,
|
||||
np. ferrytowa ramka z programatora) + detektor obwiedni (dioda Schottkyego
|
||||
+ kondensator + rezystor rozładowczy + bramka komparatora/logiki) →
|
||||
impuls 3,3 V na `PIN_LF_TRIGGER`. Stan spoczynkowy musi być **niski**
|
||||
(wejście ESP32 ma wewnętrzne podciągnięcie do dołu włączone przez firmware).
|
||||
Bez modułu LF jego rolę pełni przycisk — patrz sekcja 8.
|
||||
|
||||
---
|
||||
|
||||
## 6. (b) Konfiguracja ID i ciśnień
|
||||
|
||||
Wszystko w **`src/config.h`**:
|
||||
|
||||
```c
|
||||
/* ID poszczególnych kół (24 bity) */
|
||||
#define SENSOR_FL_ID 0x2FC871u // przód lewy
|
||||
#define SENSOR_FR_ID 0x2EAAF9u // przód prawy
|
||||
#define SENSOR_RR_ID 0x3495ACu // tył prawy
|
||||
#define SENSOR_RL_ID 0x2FC780u // tył lewy
|
||||
|
||||
/* Ciśnienie startowe: DOMYŚLNIE 2,6 bar = 260 kPa dla wszystkich kół */
|
||||
#define SENSOR_FL_PRESS_KPA 260.0f
|
||||
#define SENSOR_FR_PRESS_KPA 260.0f
|
||||
#define SENSOR_RR_PRESS_KPA 260.0f
|
||||
#define SENSOR_RL_PRESS_KPA 260.0f
|
||||
|
||||
/* Temperatura otoczenia (st. C) */
|
||||
#define SENSOR_TEMP_C 23
|
||||
```
|
||||
|
||||
Rozdzielczość protokołu: **2,5 kPa/bit** (zakres 0–637,5 kPa),
|
||||
temperatura w ramce w °F (przeliczenie automatyczne).
|
||||
|
||||
### Jakie ID wpisać? — to jest kluczowa decyzja
|
||||
|
||||
| Strategia | Kiedy stosować | Co zrobić |
|
||||
|---|---|---|
|
||||
| **A. Oryginalne ID (najlepsze)** | Auto ma już zapamiętane 4 ID starych czujników | **Przed** wymianą odczytaj ID oryginalnych czujników: `rtl_433 -f 433.92M` (pole `id` modelu `Schrader-EG53MA4`), wgraj je do `config.h`. ECU słyszy „znajome" czujniki i **nie trzeba nic programować**. |
|
||||
| **B. Nowe ID + procedura nauki** | Oryginalne ID nieznane / ECU nie pamięta | Wpisz dowolne unikalne ID (jak wyżej) i wykonaj **procedurę learn** w aucie (sekcja 8), aby ECU zarejestrowało nowe ID. |
|
||||
|
||||
Dodatkowo (w razie potrzeby):
|
||||
|
||||
```c
|
||||
#define TPMS_FLAGS 0x4C900070u // słowo "flags" z prawdziwych czujników
|
||||
#define TPMS_FLAGS_LOWBAT_MASK 0x00000008u // bit "rozładowana bateria"
|
||||
```
|
||||
|
||||
Wartość `TPMS_FLAGS` domyślnie pochodzi z nagrań prawdziwych czujników
|
||||
EG53MA4 (stała `4c900070`). Bitu niskiej baterii rtl_433 nie analizuje —
|
||||
jeśli Twój sterownik pokazuje ostrzeżenie „service TPMS" mimo dobrych
|
||||
ciśnień, spróbuj zmienić `TPMS_FLAGS_LOWBAT_MASK` (lub wyczyść bit przez
|
||||
`flags` w konsoli) i powtórz naukę.
|
||||
|
||||
Po zmianach: `pio run -e esp32dev -t upload`.
|
||||
|
||||
---
|
||||
|
||||
## 7. (c) Test nadawania — RTL-SDR + rtl_433
|
||||
|
||||
Zanim włożysz urządzenie do auta, sprawdź transmisję „w eterze":
|
||||
|
||||
1. Zasil urządzenie (powerbank / 3,3 V), ustaw `monitor` szeregowy.
|
||||
2. Na komputerze z RTL-SDR:
|
||||
|
||||
```bash
|
||||
rtl_433 -f 433.92M
|
||||
```
|
||||
|
||||
3. Urządzenie co 30 s wysyła po 3 ramki dla każdego koła. Powinieneś widzieć:
|
||||
|
||||
```
|
||||
time : ...
|
||||
model : Schrader-EG53MA4 type: TPMS flags: 4c900070 ID : 2FC871
|
||||
Pressure : 260.0 kPa Temperature: 73.0 F Integrity : CHECKSUM
|
||||
```
|
||||
|
||||
dla kolejno: `2FC871` (FL), `2EAAF9` (FR), `3495AC` (RR), `2FC780` (RL),
|
||||
każde 260.0 kPa i 73.0 F (23 °C).
|
||||
|
||||
4. Bez RTL-SDR możesz wywołać ramki z konsoli: `send`, `hex` (hexdump).
|
||||
|
||||
**Wariant FSK** (`TPMS_MODULATION MODE_FSK` w `config.h`) — rtl_433 nie ma
|
||||
dla tego wariantu wbudowanego dekodera EG53MA4 (deklaracja OOK), weryfikuj
|
||||
przez dekoder flex:
|
||||
|
||||
```bash
|
||||
rtl_433 -f 433.92M -X 'n=schrader,m=FSK_MC_ZEROBIT,s=120,l=120,r=300'
|
||||
```
|
||||
|
||||
> Uwaga praktyczna: nazwy plików `.cu8` do testów **nie mogą** zawierać
|
||||
> słów `ook`, `fsk`, `am`, `fm` (parser formatów rtl_433 je rozpoznaje).
|
||||
> Np. `tpms_sim.cu8` jest OK, `sim_ook.cu8` — nie.
|
||||
|
||||
---
|
||||
|
||||
## 8. (d) Programowanie czujników w aucie (tryb learn)
|
||||
|
||||
### Kolejność kół w Astrze J
|
||||
|
||||
**przód lewy (FL) → przód prawy (FR) → tył prawy (RR) → tył lewy (RL)**
|
||||
|
||||
(kolejność konfigurowalna przez `LEARN_ORDER_0..3` / kolejność wpisów w tablicy
|
||||
`SENSOR[]` w `main.cpp`).
|
||||
|
||||
### Sterowanie (przycisk `PIN_BUTTON`)
|
||||
|
||||
| Gest | Tryb NORMAL | Tryb LEARN | Tryb SINGLE |
|
||||
|--------------------------|--------------------------|--------------------------|--------------------------|
|
||||
| krótkie naciśnięcie | natychmiast burst 4 kół | **następne koło** | **następne koło** |
|
||||
| długie (≥1,5 s) | → **LEARN** | → NORMAL | → LEARN |
|
||||
| bardzo długie (≥4 s) | → **SINGLE** | → SINGLE | → NORMAL |
|
||||
|
||||
(Przycisk nie jest drzemany przy wciśniętym — urządzenie nie wejdzie w sen,
|
||||
dopóki go nie puścisz; bardzo długi gest zdąży się zawsze zarejestrować.)
|
||||
|
||||
LED: seria **N mrugnięć = N-ty numer koła** (1–4) przy zmianie koła,
|
||||
wzorzec stały: NORMAL — 1 mrugnięcie co 2 s, LEARN — 3 mrugnięcia co 0,5 s,
|
||||
SINGLE — 2 mrugnięcia co 0,5 s, niskie napięcie — 10 mrugnięć co 3 s.
|
||||
|
||||
### Procedura krok po kroku
|
||||
|
||||
1. **Odczytaj oryginalne ID** (jeśli to możliwe) — patrz strategia A w sekcji 6.
|
||||
2. Włącz zapłon, uruchom procedurę nauki TPMS w aucie
|
||||
(Astra J: menu kierowcy → ustawienia → ciśnienie w oponach → nauka /
|
||||
„Tyre learning"; w wersjach bez menu — procedura z pedałem gazu
|
||||
lub przez OP-COM/TECH2 — sprawdź instrukcję obsługi swojej wersji).
|
||||
3. **Wejdź w tryb LEARN** (długie naciśnięcie) — urządzenie nadaje
|
||||
**tylko koło FL** (ID z `SENSOR_FL_ID`), LED mruga 1×.
|
||||
4. Urządzenie nadaje burst co 2 s. Jeśli procedura w aucie wymaga
|
||||
**aktywacji czujnika przy kole** (puls LF 125 kHz / programator TPMS):
|
||||
* podejdź do koła FL i użyj programatora LF — jeśli masz moduł LF
|
||||
(`PIN_LF_TRIGGER`), urządzenie **natychmiast** wyśle właściwe ID,
|
||||
* bez modułu LF: **krótkie naciśnięcie przycisku = „aktywuj koło"**
|
||||
(w LEARN służy też do przejścia dalej — użyj komendy `send`
|
||||
w konsoli, jeśli potrzebna jest aktywacja bez zmiany koła).
|
||||
5. **Krótkie naciśnięcie = następne koło** (LED: 2×, 3×, 4×) i powtórz
|
||||
aktywację przy kolejnych kołach w kolejności **FL → FR → RR → RL**.
|
||||
6. **Okno czasowe**: na każde koło jest `LEARN_WINDOW_MS` (60 s).
|
||||
Po jego upływie urządzenie **wraca do trybu normalnego**
|
||||
(`LEARN_WINDOW_EXPIRE_TO_NORMAL 1`); ustaw `0`, jeśli wolisz
|
||||
automatyczne przejście do kolejnego koła. Cała sesja learn kończy się
|
||||
też po `LEARN_TOTAL_TIMEOUT_MS` (15 min).
|
||||
7. Zakończ procedurę w aucie (zwykle: zapłon OFF, jazda testowa).
|
||||
8. Po zakończeniu nauki urządzenie samo wraca do NORMAL i nadaje
|
||||
wszystkie 4 koła co 30 s — także przy postoju (transmisja jest ciągła,
|
||||
niezależna od ruchu; auto-learn może wymagać jazdy, ale ramki lecą zawsze).
|
||||
|
||||
### Jeśli auto „nie zapamiętuje" czujników
|
||||
|
||||
* **Użyj oryginalnych ID** (strategia A) — wtedy nie trzeba w ogóle
|
||||
programować; ECU zna już te ID i zaakceptuje je natychmiast.
|
||||
* Sprawdź, czy procedura nauki w aucie była uruchomiona **przed**
|
||||
transmisjami (ECU w trybie nauki nasłuchuje nowych ID).
|
||||
* W trybie LEARN nadawane jest **tylko jedno ID naraz** — jeśli nadawałeś
|
||||
wszystkie 4 jednocześnie, ECU mógł się „pomylić" (stąd tryb learn).
|
||||
* Upewnij się, że ciśnienie jest w zakresie akceptowanym przez ECU
|
||||
(260 kPa = 2,6 bar jest bezpieczne dla Astry J).
|
||||
* Spróbuj wariantu modulacji: `MODE_OOK` ↔ `MODE_FSK` (patrz sekcja 7) —
|
||||
wersje EU/US różnią się; referencyjne nagrania EG53MA4 to **ASK/OOK**.
|
||||
* Procedura nauki niektórych wersji Astry J wymaga **jazdy > 20 km/h**
|
||||
przez kilka minut — urządzenie nadaje przez cały czas, więc wystarczy
|
||||
wykonać jazdę próbną po starcie procedury.
|
||||
* Sprawdź DTC przed i po (OP-COM/TECH2): kody czujników (np. C0750–C0759)
|
||||
powinny zniknąć po udanej nauce.
|
||||
* Zmierz napięcie zasilania (`batt`) — przy `POWER_12V` urządzenie raportuje
|
||||
stan akumulatora i flagę niskiego napięcia w ramce (`LOWBATT`).
|
||||
|
||||
### Tryb SINGLE
|
||||
|
||||
Wymuszone nadawanie jednego ID (testy, procedury uczące jedno koło
|
||||
wielokrotnymi próbami):
|
||||
|
||||
* bardzo długie naciśnięcie (≥4 s) — SINGLE na bieżącym kole,
|
||||
* konsola: `mode single 2` (koło FR), `next` — zmiana koła,
|
||||
* wyjście: bardzo długie naciśnięcie lub `mode normal`,
|
||||
limit czasu `SINGLE_TIMEOUT_MS` (domyślnie 5 min).
|
||||
|
||||
---
|
||||
|
||||
## 9. (e) Pomiar poboru prądu
|
||||
|
||||
### Co zmierzyć
|
||||
|
||||
| Stan | Co się dzieje | Oczekiwana wartość |
|
||||
|----------------------|---------------------------------------------------|--------------------|
|
||||
| **Deep sleep** | między transmisjami (większość czasu) | **< 50 µA** (goły moduł ESP32 + CC1101 + buck o niskim Iq); ~10 µA ESP32 + < 1 µA CC1101 + Iq przetwornicy |
|
||||
| **Transmisja (burst)** | 4 koła × 3 ramki, ~0,35 s na antenie + 1,2 s aktywności | ~30 mA (CC1101 TX) + ~80 mA (ESP32) przez ok. 1,2 s co interwał |
|
||||
| **Średnia** | suma | ~4 mA przy interwale 30 s, ~1 mA przy 120 s (patrz sekcja 13) |
|
||||
|
||||
### Jak zmierzyć
|
||||
|
||||
1. **Sen** — multimetr w zakresie µA **szeregowo z zasilaniem**,
|
||||
po 30 s od ostatniej transmisji (gdy ESP32 jest w deep sleep).
|
||||
Mierz na pinach modułu, nie przez port USB!
|
||||
2. **Burst** — rezystor bocznikowy 1 Ω + oscilloskop albo INA219/INA226
|
||||
(szyna I²C), odczyt średniego prądu przez ≥ 60 s.
|
||||
3. **Średnia doby** — mierz przez 1–2 minuty w zakresie mA i przelicz
|
||||
(albo użyj miernika z integracją, np. µCurrent + logger).
|
||||
4. Porównaj z budżetem z sekcji 13; odchylenie 2× w dół/w górę jest normalne.
|
||||
|
||||
### Typowe pułapki
|
||||
|
||||
* **DevKit z USB-UART**: mostek CP2102/CH340 + LDO AMS1117 = 0,5–2 mA
|
||||
w sleep → cel < 50 µA **niedotrzymany z winy płytki**, nie firmware'u.
|
||||
Rozwiązanie: goły moduł ESP32-WROOM + regulator z sekcji 5
|
||||
(MCP1703/ LM5164-Q1 dla 12 V, MCP1700 dla LiPo).
|
||||
* **Dzielniki pomiarowe**: 2 × 1 MΩ/270 kΩ ≈ 19 µA stale — to już połowa
|
||||
budżetu < 50 µA; w wariancie bateryjnym możesz je całkowicie odpiąć
|
||||
(`PIN_VBAT_ADC -1` nie jest obsługiwany — po prostu nie montuj dzielnika
|
||||
i zignoruj odczyt) albo zwiększyć rezystancje kosztem dokładności ADC.
|
||||
* Rezystor podciągający przycisku (10 kΩ) pobiera 330 µA przy stanie
|
||||
aktywnym niskim — w sleep przycisk jest w stanie spoczynkowym (HIGH),
|
||||
więc prąd nie płynie; gdybyś użył aktywnego HIGH, zwiększ rezystor do 100 kΩ.
|
||||
* LED — w sleep zgaszony (firmware go gasi przed snem).
|
||||
|
||||
---
|
||||
|
||||
## 10. (f) Weryfikacja, że błąd zniknął
|
||||
|
||||
1. **Przed testem**: skasuj stare DTC (OP-COM/TECH2 lub odłącz akumulator
|
||||
na kilka minut — utrata ustawień radia/godziny jest możliwa).
|
||||
2. Uruchom procedurę learn w aucie (sekcja 8) albo użyj oryginalnych ID.
|
||||
3. Włącz zapłon, odczekaj 1–3 minuty (ECU zbiera ramki) lub wykonaj jazdę
|
||||
próbną 5–10 min powyżej 20 km/h.
|
||||
4. Sprawdź:
|
||||
* **kontrolka TPMS** (żółta ikona opony) — powinna zgasnąć,
|
||||
* **wyświetlacz kierowcy** (DIC): menu ciśnienia w oponach powinno
|
||||
pokazywać 4 wartości (2,6 bar),
|
||||
* **OP-COM/TECH2**: brak aktywnych kodów czujników TPMS,
|
||||
* **rtl_433**: `rtl_433 -f 433.92M` dekoduje 4 ID co ok. 30 s
|
||||
(to potwierdza, że transmisja jest ciągła).
|
||||
5. Test długotrwały: pozostaw auto na noc z włączonym zapłonem raz na
|
||||
kilka godzin — po ponownym uruchomieniu błąd nie powinien wracać.
|
||||
6. Jeśli kontrolka zapala się ponownie po dłuższym postoju — sprawdź
|
||||
interwał parkingowy (`TX_INTERVAL_PARKING_S`) i flagę baterii
|
||||
(`TPMS_FLAGS_LOWBAT_MASK`).
|
||||
|
||||
---
|
||||
|
||||
## 11. Tryby pracy i sterowanie
|
||||
|
||||
| Tryb | Zachowanie | Wejście |
|
||||
|----------|----------------------------------------------------------------------------|--------------------------------|
|
||||
| NORMAL | rotacja 4 kół: burst 3 ramek × 4 koła co `TX_INTERVAL_S` (30 s), potem deep sleep | stan domyślny, `mode normal` |
|
||||
| LEARN | **tylko jedno koło**, burst co 2 s, okno 60 s na koło, przycisk = następne koło | długie naciśnięcie, `mode learn` |
|
||||
| SINGLE | wymuszone jedno ID, burst co 2 s | bardzo długie naciśnięcie, `mode single n` |
|
||||
|
||||
### Deep sleep i budzenie
|
||||
|
||||
* budzik RTC co `TX_INTERVAL_S` / `TX_INTERVAL_IGNITION_S` /
|
||||
`TX_INTERVAL_PARKING_S`,
|
||||
* **EXT0**: przycisk (`PIN_BUTTON`) — natychmiastowe wybudzenie,
|
||||
* **EXT1**: wejście LF (`PIN_LF_TRIGGER`) — aktywacja czujnika przy kole
|
||||
= natychmiastowa transmisja odpowiedniego ID,
|
||||
* między transmisjami: CC1101 w SLEEP (`SPWD`), linie SPI trzymane przez
|
||||
`gpio_hold` (CS wysoki — utrzymuje CC1101 w sleep, SCK/MOSI niskie),
|
||||
* WiFi **nie jest w ogóle inicjalizowany**, BT wyłączany (`btStop()`),
|
||||
brak dynamicznej alokacji pamięci (same bufory statyczne),
|
||||
brak opóźnień blokujących — jedyny „blocking" to oczekiwanie na
|
||||
zakończenie nadania ramki (~29 ms) i odstępy między ramkami w burście
|
||||
(transmisja musi fizycznie trwać tyle, ile trwa).
|
||||
|
||||
### Tryb ignition-aware (ACC)
|
||||
|
||||
* `PIN_ACC` wysoki (zapłon) → interwał `TX_INTERVAL_IGNITION_S` (15 s),
|
||||
* po zaniku ACC + `ACC_GRACE_MS` (5 min) → interwał `TX_INTERVAL_PARKING_S`
|
||||
(120 s) albo całkowite uśpienie (`PARKING_SHUTDOWN 1`) — budzi wtedy
|
||||
tylko przycisk/LF,
|
||||
* bez podłączonego ACC (`PIN_ACC -1`) urządzenie pracuje stale
|
||||
z interwałem `TX_INTERVAL_S`.
|
||||
|
||||
---
|
||||
|
||||
## 12. Konsola szeregowa
|
||||
|
||||
115200 8N1, po starcie okno `BOOT_STAY_AWAKE_MS` (3 s) — wciśnij `stay 60`,
|
||||
żeby zostać dłużej. Komendy:
|
||||
|
||||
| Komenda | Działanie |
|
||||
|------------------------------|------------------------------------------------|
|
||||
| `help` | lista komend |
|
||||
| `info` / `config` | wersja, konfiguracja, ID, stan, napięcie |
|
||||
| `hex [n\|all]` | hexdump ramki koła n (1–4) lub wszystkich |
|
||||
| `send [n\|all]` | wyślij burst teraz |
|
||||
| `batt` | pomiar napięcia zasilania [mV] |
|
||||
| `mode normal\|learn\|single [n]` | zmiana trybu |
|
||||
| `next` | następne koło (learn/single) |
|
||||
| `interval <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.**
|
||||
ID musi mieć sześć cyfr hex, być niezerowe, różne od `FFFFFF` i unikalne.
|
||||
Urządzenie wróci do NORMAL i będzie nadawało znane ID. **Nauka może być
|
||||
niepotrzebna, ale nie jest to gwarantowane.** Potwierdź odbiór diagnostycznie;
|
||||
nie zaczynaj od jazdy.
|
||||
|
||||
### 4B. Alternatywa: New IDs + LEARN
|
||||
|
||||
1. Wpisz `ids new`, następnie `info` i zapisz wygenerowane ID.
|
||||
2. Uruchom właściwą dla swojej wersji auta procedurę nauki TPMS zgodnie z jej
|
||||
instrukcją serwisową. Nie zgaduj sekwencji menu/pedałów.
|
||||
3. Wpisz `mode learn`. Nadaje wyłącznie FL, co 2 s. LED wskaże 1 mrugnięcie.
|
||||
4. `send` wymusza bieżące koło bez zmiany. Po potwierdzeniu kroku w aucie wpisz
|
||||
`next`: FR → RR → RL. Krótki przycisk robi to samo; po RL wraca do NORMAL.
|
||||
5. Jeśli minie 60 s na kole, LEARN przerwie się do NORMAL. Cała sesja ma limit
|
||||
15 min. Po zakończeniu sprawdź ID i kody diagnostyczne.
|
||||
|
||||
EL-50448/OEC-T5 jest aktywatorem LF 125 kHz, **nie programatorem ESP32**. Ta
|
||||
procedura nie wymaga go. Szczegóły: [SETUP](docs/SETUP.md).
|
||||
|
||||
## Sterowanie — jedna tabela
|
||||
|
||||
LED działa tylko podczas czuwania; w deep sleep jest zgaszona. Po zmianie koła
|
||||
seria 1–4 mrugnięć wskazuje FL/FR/RR/RL.
|
||||
|
||||
| Tryb | Wzorzec LED | Krótki przycisk | Długi ≥1,5 s | Bardzo długi ≥4 s |
|
||||
|---|---|---|---|---|
|
||||
| NORMAL | 1 mrugnięcie / 2 s | burst wszystkich 4 | wejście LEARN | wejście SINGLE |
|
||||
| LEARN | 3 mrugnięcia / 0,5 s; po zmianie numer koła | następne koło + TX; po RL koniec | wyjście NORMAL | wejście SINGLE |
|
||||
| SINGLE | 2 mrugnięcia / 0,5 s; po zmianie numer koła | następne koło + TX | wejście LEARN | wyjście NORMAL |
|
||||
|
||||
W konsoli `send` w NORMAL nadaje wszystkie, a w LEARN/SINGLE tylko bieżące koło.
|
||||
`send 1`…`send 4` wybiera koło jawnie; `send all` nadaje cztery. SINGLE wyłącza
|
||||
się po 5 min.
|
||||
|
||||
## Najczęstsze problemy
|
||||
|
||||
- **`BLAD: brak CC1101`**: sprawdź 3,3 V, wspólną masę i sześć przewodów SPI;
|
||||
nie używaj 5 V na CC1101.
|
||||
- **Konsola znika przed wpisaniem komend**: po restarcie od razu `stay 300`;
|
||||
zwykłe wybudzenie RTC celowo nie otwiera okna konsoli.
|
||||
- **NVS zgłasza błąd**: urządzenie używa bezpiecznych domyślnych; wpisz `info`.
|
||||
`factory YES` kasuje własne ID i przywraca konfigurację fabryczną.
|
||||
- **Auto nie odbiera**: najpierw zweryfikuj profil auta i odbiór RTL-SDR; nie
|
||||
zmieniaj losowo modulacji, flag ani interwałów. Zobacz
|
||||
[TROUBLESHOOTING](docs/TROUBLESHOOTING.md).
|
||||
|
||||
## Walidacja, zasilanie i release
|
||||
|
||||
- Protokół i niewiadome: [PROTOCOL](docs/PROTOCOL.md)
|
||||
- Dokładne wyniki i checklista HIL: [VALIDATION](docs/VALIDATION.md)
|
||||
- Pobór (na razie szacunki): [POWER](docs/POWER.md)
|
||||
- Wymagania zasilania 12 V: [HARDWARE](docs/HARDWARE.md#wariant-automotive--wymagania-niezwalidowany-projekt)
|
||||
- Zmiany: [CHANGELOG](CHANGELOG.md)
|
||||
|
||||
Gotowe obrazy tworzy `bash tools/package_release.sh`. Pliki i adresy opisano w
|
||||
[VALIDATION](docs/VALIDATION.md#artefakty-i-wgrywanie). Release candidate nie
|
||||
zawiera wyniku testu CC1101 ani samochodu.
|
||||
@@ -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.
|
||||
@@ -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.
|
||||
@@ -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”.
|
||||
@@ -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.
|
||||
@@ -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.
|
||||
@@ -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.
|
||||
@@ -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
@@ -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.
|
||||
@@ -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.
|
||||
@@ -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.
|
||||
+5
-4
@@ -21,15 +21,16 @@ monitor_speed = 115200
|
||||
; Biblioteka CC1101 (ELECHOUSE_CC1101_SRC_DRV / SmartRC):
|
||||
; wymagana wersja >= 2.5.7 (wspolne API setSpiPin/setGDO0 dla 2.5.x i 3.x).
|
||||
lib_deps =
|
||||
https://github.com/LSatan/SmartRC-CC1101-Driver-Lib.git#de6757e
|
||||
https://github.com/LSatan/SmartRC-CC1101-Driver-Lib.git#de6757ef633b3e626dae5c7835cdb66ab53f9a1d
|
||||
build_flags =
|
||||
-Wall
|
||||
-Wextra
|
||||
-Werror
|
||||
|
||||
[env:native]
|
||||
; Testy jednostkowe generatora ramek (bez sprzetu)
|
||||
; Przenosna logika: ramka, NVS i maszyna stanow (PIN_ACC wlaczony w testach).
|
||||
platform = native
|
||||
build_flags = -std=gnu++17 -Wall
|
||||
build_src_filter = -<*> +<tpms_frame.cpp>
|
||||
build_flags = -std=gnu++17 -Wall -Wextra -Werror -DPIN_ACC=32
|
||||
build_src_filter = -<*> +<tpms_frame.cpp> +<settings.cpp> +<app_state.cpp>
|
||||
test_build_src = true
|
||||
test_framework = unity
|
||||
@@ -1,40 +1,15 @@
|
||||
/*
|
||||
* app.h - API aplikacji (tryby pracy) uzywane przez konsole i maszyne stanow
|
||||
*/
|
||||
#ifndef TPMS_APP_H
|
||||
#define TPMS_APP_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include "app_state.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
enum {
|
||||
APP_MODE_NORMAL = 0, // rotacja wszystkich 4 kol + deep sleep
|
||||
APP_MODE_LEARN = 1, // nauka czujnikow w aucie, jedno kolo naraz
|
||||
APP_MODE_SINGLE = 2, // wymuszone nadawanie wskazanego ID
|
||||
};
|
||||
|
||||
uint8_t app_mode(void);
|
||||
uint8_t app_wheel(void); // aktywne kolo (w LEARN/SINGLE)
|
||||
|
||||
void app_set_mode(uint8_t mode, uint8_t wheel);
|
||||
void app_next_wheel(void);
|
||||
void app_send_burst_wheel(uint8_t wheel);
|
||||
void app_send_burst_all(void);
|
||||
extern AppState *g_app;
|
||||
|
||||
void app_print_info(void);
|
||||
void app_print_frame(uint8_t wheel);
|
||||
bool app_save_and_apply(void);
|
||||
void app_request_sleep(void);
|
||||
void app_stay_awake(uint32_t ms);
|
||||
|
||||
uint32_t app_supply_mv(void);
|
||||
void app_set_interval(uint32_t seconds); // 0 = automatyczny (wg ACC)
|
||||
void app_set_flags(uint32_t flags);
|
||||
void app_request_sleep(void); // zaspij teraz (tryb NORMAL)
|
||||
void app_stay_awake(uint32_t ms); // przedluz okno konsoli
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* TPMS_APP_H */
|
||||
@@ -0,0 +1,147 @@
|
||||
#include "app_state.h"
|
||||
#include "config.h"
|
||||
|
||||
AppState::AppState(const settings_t *settings, RadioSink *radio)
|
||||
: settings_(settings), radio_(radio)
|
||||
{
|
||||
}
|
||||
|
||||
void AppState::begin(uint32_t now_ms, bool transmit)
|
||||
{
|
||||
set_mode(AppMode::NORMAL, WHEEL_FL, now_ms, transmit);
|
||||
}
|
||||
|
||||
uint32_t AppState::interval_s(bool ignition) const
|
||||
{
|
||||
#if PIN_ACC >= 0
|
||||
return ignition ? settings_->ignition_interval_s : settings_->parking_interval_s;
|
||||
#else
|
||||
(void)ignition;
|
||||
return settings_->normal_interval_s;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool AppState::transmit(uint8_t wheel)
|
||||
{
|
||||
bool ok = radio_ != NULL && radio_->send(wheel);
|
||||
if (!ok) {
|
||||
++error_count_;
|
||||
}
|
||||
return ok;
|
||||
}
|
||||
|
||||
bool AppState::send_current()
|
||||
{
|
||||
return transmit(active_wheel_);
|
||||
}
|
||||
|
||||
bool AppState::send_wheel(uint8_t wheel)
|
||||
{
|
||||
return wheel < WHEEL_COUNT && transmit(wheel);
|
||||
}
|
||||
|
||||
bool AppState::send_all()
|
||||
{
|
||||
bool ok = true;
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; ++i) {
|
||||
ok = transmit(i) && ok;
|
||||
}
|
||||
return ok;
|
||||
}
|
||||
|
||||
void AppState::schedule(uint32_t now_ms, bool immediate)
|
||||
{
|
||||
next_tx_ms_ = immediate ? now_ms : now_ms + LEARN_PERIOD_MS;
|
||||
}
|
||||
|
||||
bool AppState::set_mode(AppMode mode, uint8_t wheel, uint32_t now_ms,
|
||||
bool transmit_now)
|
||||
{
|
||||
if (wheel >= WHEEL_COUNT) {
|
||||
return false;
|
||||
}
|
||||
mode_ = mode;
|
||||
active_wheel_ = wheel;
|
||||
mode_start_ms_ = now_ms;
|
||||
wheel_start_ms_ = now_ms;
|
||||
schedule(now_ms, transmit_now);
|
||||
if (mode == AppMode::NORMAL) {
|
||||
next_tx_ms_ = transmit_now ? now_ms : UINT32_MAX;
|
||||
}
|
||||
if (transmit_now && mode != AppMode::NORMAL) {
|
||||
send_current();
|
||||
schedule(now_ms, false);
|
||||
} else if (transmit_now) {
|
||||
send_all();
|
||||
next_tx_ms_ = now_ms + settings_->normal_interval_s * 1000u;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool AppState::next_wheel(uint32_t now_ms)
|
||||
{
|
||||
if (mode_ == AppMode::NORMAL) {
|
||||
return false;
|
||||
}
|
||||
if (mode_ == AppMode::LEARN && active_wheel_ == WHEEL_RL) {
|
||||
return set_mode(AppMode::NORMAL, WHEEL_FL, now_ms, false);
|
||||
}
|
||||
active_wheel_ = (uint8_t)((active_wheel_ + 1u) % WHEEL_COUNT);
|
||||
wheel_start_ms_ = now_ms;
|
||||
send_current();
|
||||
schedule(now_ms, false);
|
||||
return true;
|
||||
}
|
||||
|
||||
void AppState::short_press(uint32_t now_ms)
|
||||
{
|
||||
if (mode_ == AppMode::NORMAL) {
|
||||
send_all();
|
||||
next_tx_ms_ = now_ms + settings_->normal_interval_s * 1000u;
|
||||
} else {
|
||||
next_wheel(now_ms);
|
||||
}
|
||||
}
|
||||
|
||||
void AppState::long_press(uint32_t now_ms)
|
||||
{
|
||||
if (mode_ == AppMode::LEARN) {
|
||||
set_mode(AppMode::NORMAL, WHEEL_FL, now_ms, false);
|
||||
} else {
|
||||
set_mode(AppMode::LEARN, active_wheel_, now_ms);
|
||||
}
|
||||
}
|
||||
|
||||
void AppState::very_long_press(uint32_t now_ms)
|
||||
{
|
||||
if (mode_ == AppMode::SINGLE) {
|
||||
set_mode(AppMode::NORMAL, WHEEL_FL, now_ms, false);
|
||||
} else {
|
||||
set_mode(AppMode::SINGLE, active_wheel_, now_ms);
|
||||
}
|
||||
}
|
||||
|
||||
void AppState::tick(uint32_t now_ms, bool ignition)
|
||||
{
|
||||
if (mode_ == AppMode::LEARN) {
|
||||
if ((uint32_t)(now_ms - mode_start_ms_) >= LEARN_TOTAL_MS
|
||||
|| (uint32_t)(now_ms - wheel_start_ms_) >= LEARN_WINDOW_MS) {
|
||||
set_mode(AppMode::NORMAL, WHEEL_FL, now_ms, false);
|
||||
return;
|
||||
}
|
||||
} else if (mode_ == AppMode::SINGLE
|
||||
&& (uint32_t)(now_ms - mode_start_ms_) >= SINGLE_TIMEOUT_MS) {
|
||||
set_mode(AppMode::NORMAL, WHEEL_FL, now_ms, false);
|
||||
return;
|
||||
}
|
||||
|
||||
if (next_tx_ms_ != UINT32_MAX && (int32_t)(now_ms - next_tx_ms_) >= 0) {
|
||||
if (mode_ == AppMode::NORMAL) {
|
||||
send_all();
|
||||
next_tx_ms_ = now_ms + interval_s(ignition) * 1000u;
|
||||
} else {
|
||||
send_current();
|
||||
schedule(now_ms, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
/* Przenosna maszyna stanow NORMAL/LEARN/SINGLE (fake clock/radio w testach). */
|
||||
#ifndef TPMS_APP_STATE_H
|
||||
#define TPMS_APP_STATE_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include "settings.h"
|
||||
|
||||
enum class AppMode : uint8_t {
|
||||
NORMAL = 0,
|
||||
LEARN = 1,
|
||||
SINGLE = 2,
|
||||
};
|
||||
|
||||
class RadioSink {
|
||||
public:
|
||||
virtual ~RadioSink() = default;
|
||||
virtual bool send(uint8_t wheel) = 0;
|
||||
};
|
||||
|
||||
class AppState {
|
||||
public:
|
||||
AppState(const settings_t *settings, RadioSink *radio);
|
||||
|
||||
void begin(uint32_t now_ms, bool transmit = true);
|
||||
void tick(uint32_t now_ms, bool ignition);
|
||||
void short_press(uint32_t now_ms);
|
||||
void long_press(uint32_t now_ms);
|
||||
void very_long_press(uint32_t now_ms);
|
||||
|
||||
bool set_mode(AppMode mode, uint8_t wheel, uint32_t now_ms,
|
||||
bool transmit = true);
|
||||
bool next_wheel(uint32_t now_ms);
|
||||
bool send_current();
|
||||
bool send_wheel(uint8_t wheel);
|
||||
bool send_all();
|
||||
|
||||
AppMode mode() const { return mode_; }
|
||||
uint8_t active_wheel() const { return active_wheel_; }
|
||||
uint32_t interval_s(bool ignition) const;
|
||||
uint32_t last_error_count() const { return error_count_; }
|
||||
|
||||
private:
|
||||
static const uint32_t LEARN_PERIOD_MS = 2000u;
|
||||
static const uint32_t LEARN_WINDOW_MS = 60000u;
|
||||
static const uint32_t LEARN_TOTAL_MS = 900000u;
|
||||
static const uint32_t SINGLE_TIMEOUT_MS = 300000u;
|
||||
|
||||
const settings_t *settings_;
|
||||
RadioSink *radio_;
|
||||
AppMode mode_ = AppMode::NORMAL;
|
||||
uint8_t active_wheel_ = WHEEL_FL;
|
||||
uint32_t next_tx_ms_ = 0;
|
||||
uint32_t mode_start_ms_ = 0;
|
||||
uint32_t wheel_start_ms_ = 0;
|
||||
uint32_t error_count_ = 0;
|
||||
|
||||
bool transmit(uint8_t wheel);
|
||||
void schedule(uint32_t now_ms, bool immediate);
|
||||
};
|
||||
|
||||
#endif
|
||||
+25
-169
@@ -1,190 +1,46 @@
|
||||
/*
|
||||
* config.h - konfiguracja symulatora czujnikow TPMS Schrader EG53MA4
|
||||
* dla Opla Astry J Sedan 2016 (EU, TPMS bezposredni, czujniki Schrader).
|
||||
*
|
||||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||
* ZASTRZEZENIE / DISCLAIMER:
|
||||
* Projekt wylacznie do celow diagnostycznych i testowych.
|
||||
* Symulator dostarcza SZTUCZNE dane cisnienia i temperatury i NIE
|
||||
* zastepuje prawdziwych czujnikow TPMS. Nie uzywaj tego urzadzenia do
|
||||
* jazdy po drogach publicznych - prawdziwy TPMS jest elementem
|
||||
* bezpieczenstwa czynnego pojazdu.
|
||||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||
*
|
||||
* Protokol wg rtl_433 src/devices/schraeder.c (schrader_EG53MA4):
|
||||
* "Schrader TPMS EG53MA4, Saab, Opel, Vauxhall, Chevrolet"
|
||||
* (Opel OEM 13348393), weryfikacja: tools/tpms_frame.py, tools/gen_cu8.py.
|
||||
*/
|
||||
/* Konfiguracja sprzetu. Dane czujnikow i RF sa w NVS, nie wymagaja rekompilacji. */
|
||||
#ifndef TPMS_CONFIG_H
|
||||
#define TPMS_CONFIG_H
|
||||
|
||||
#define FW_VERSION "1.0.0"
|
||||
#define CONFIG_VERSION 4 // podnos przy zmianie formatu danych w RTC
|
||||
#define FW_VERSION "2.0.0-rc.1"
|
||||
|
||||
/* ======================================================================
|
||||
* 1. ZASILANIE
|
||||
* POWER_12V - stale zasilanie z akumulatora 12 V.
|
||||
* UWAGA: potrzebny jest uklad zasilajacy na PELENY zakres
|
||||
* samochodowy (12 V nominalnie, 14,4 V przy ladowaniu, przepiecia
|
||||
* load-dump nawet > 40 V):
|
||||
* - LDO o wejsciu >= 16 V i niskim Iq, np. MCP1703 (Vin 2.7-16 V,
|
||||
* Iq ~2 uA) - zabezpiecz wejscie bezpiecznikiem + TVS (np. 24 V)
|
||||
* + rezystor szeregowy/dioda; ogranicz moc strat (patrz README),
|
||||
* - albo przetwornica buck o szerokim wejsciu, np. LM5164-Q1
|
||||
* (Vin 6-100 V, Iq ~10 uA, 1 A).
|
||||
* TPS62740 ma wejscie 2.2-5.5 V - NIE wolno podlaczac go do 12 V!
|
||||
* POWER_BATTERY - ogniwo 3.6 V (Li-SOCl2) bezposrednio, albo LiPo 3.7 V
|
||||
* PRZEZ LDO 3.3 V (np. MCP1700, Vin max 6 V). Bezposrednie
|
||||
* zasilanie LiPo 4.2 V przekracza max ESP32 (3.6 V) i CC1101 (3.9 V)!
|
||||
* ====================================================================== */
|
||||
#define POWER_SUPPLY_MODE POWER_12V
|
||||
#define POWER_12V 1
|
||||
#define POWER_BATTERY 2
|
||||
|
||||
/* ======================================================================
|
||||
* 2. PINY (ESP32 DevKit + CC1101 po SPI)
|
||||
* Piny CC1101 zgodne z wymaganiami projektu:
|
||||
* SCK=18 MISO=19 MOSI=23 CS=5 GDO0=2
|
||||
* ====================================================================== */
|
||||
/* ESP32 DevKit + CC1101 433 MHz (3,3 V). */
|
||||
#define PIN_CC1101_SCK 18
|
||||
#define PIN_CC1101_MISO 19
|
||||
#define PIN_CC1101_MOSI 23
|
||||
#define PIN_CC1101_CS 5
|
||||
#define PIN_CC1101_GDO0 2
|
||||
|
||||
/* Przycisk sterowania trybami (wejscie budzace EXT0).
|
||||
* Dolaczenie do GND + rezystor podciagajacy 10k do 3V3 (aktywny niski). */
|
||||
#define PIN_BUTTON 26
|
||||
#define BTN_ACTIVE_LEVEL 0 // 0 = aktywny niski (przycisk -> GND)
|
||||
|
||||
/* LED statusowy (rezystor szeregowy 330R, aktywny wysoki). */
|
||||
#define BTN_ACTIVE_LEVEL 0
|
||||
#define PIN_LED 27
|
||||
|
||||
/* Opcjonalne wejscie aktywacji LF 125 kHz (cewka + prostownik + tranzystor).
|
||||
* Impuls wysoki = "programator przy kole" -> natychmiastowa transmisja.
|
||||
* -1 wylacza funkcje (role pelni przycisk "aktywuj kolo"). */
|
||||
#define PIN_LF_TRIGGER 25
|
||||
|
||||
/* Opcjonalny sygnal zaplonu / ACC (dzielnik 12 V -> ok. 3 V, jak VBAT).
|
||||
* Bez podciagania wewnetrznego (INPUT) - dolna galaz dzielnika wymusza
|
||||
* stan niski. Bez sygnalu: PIN_ACC = -1 (wtedy stale TX_INTERVAL_S).
|
||||
* DOMYSLNIE -1 (wylaczone) - ustaw np. 32 po podlaczeniu dzielnika. */
|
||||
/* Opcje wylaczone do czasu zmontowania i przetestowania sprzetu. */
|
||||
#ifndef PIN_LF_TRIGGER
|
||||
#define PIN_LF_TRIGGER -1
|
||||
#endif
|
||||
#ifndef PIN_ACC
|
||||
#define PIN_ACC -1
|
||||
|
||||
/* Pomiar napiecia zasilania: dzielnik R1(gora)/R2(dol) na pin ADC1
|
||||
* + kondensator 100 nF miedzy pinem a masa (ustalanie ADC).
|
||||
* Dobor: 14,4 V (ladowanie) musi dac <= 3.0 V na wejsciu ADC,
|
||||
* a prad dzielnika ma byc mikroamperowy (nie psuc budzetu snu):
|
||||
* R1 = 1 M, R2 = 270 k -> 12 V: 2.55 V (~9 uA), 14.4 V: 3.05 V
|
||||
* Zabezpieczenie wejscia: rezystor szeregowy + dioda klamujaca do 3V3. */
|
||||
#endif
|
||||
#ifndef PIN_VBAT_ADC
|
||||
#define PIN_VBAT_ADC 34
|
||||
#define VBAT_DIVIDER_R1 1000000.0f // ohm, gora (do zasilania)
|
||||
#define VBAT_DIVIDER_R2 270000.0f // ohm, dol (do masy)
|
||||
#define VBAT_CAL 1.000f // mnoznik kalibracji (por. z multimetrem)
|
||||
#endif
|
||||
#define VBAT_DIVIDER_R1 1000000.0f
|
||||
#define VBAT_DIVIDER_R2 270000.0f
|
||||
#define VBAT_CAL 1.000f
|
||||
#define VBAT_SAMPLES 16
|
||||
#define LOWBATT_THRESHOLD_MV 11500
|
||||
|
||||
/* ======================================================================
|
||||
* 3. CZUJNIKI - 4 identyfikatory (hex, po jednym na kolo)
|
||||
* Kolejnosc nauki w Astrze: przod lewy -> przod prawy -> tyl prawy -> tyl lewy
|
||||
* ID sa przykladowe (24-bit). Najlepiej przepisz ID ze starych czujnikow
|
||||
* (odczytaj je rtl_433: rtl_433 -f 433.92M) - auto wtedy "widzi" znajome ID.
|
||||
* ====================================================================== */
|
||||
#define WHEEL_FL 0
|
||||
#define WHEEL_FR 1
|
||||
#define WHEEL_RR 2
|
||||
#define WHEEL_RL 3
|
||||
#define WHEEL_COUNT 4
|
||||
/* Jedyny profil produkcyjny: OOK, Manchester 0->01, 1->10. */
|
||||
#define TPMS_CHIP_US 120u
|
||||
|
||||
/* Kolejnosc nauki (kolejnosc pozycji w tablicy SENSOR[] ponizej = kolejnosc
|
||||
* learn; domyslnie FL -> FR -> RR -> RL). Kolejnosc mozesz zmienic po prostu
|
||||
* przestawiajac wpisy w tablicy SENSOR[] w main.cpp (lub zmieniajac ponizsze
|
||||
* makra kolejnosci w trybie learn). */
|
||||
#define LEARN_ORDER_0 WHEEL_FL
|
||||
#define LEARN_ORDER_1 WHEEL_FR
|
||||
#define LEARN_ORDER_2 WHEEL_RR
|
||||
#define LEARN_ORDER_3 WHEEL_RL
|
||||
|
||||
/* ID poszczegolnych kol (24 bity) */
|
||||
#define SENSOR_FL_ID 0x2FC871u
|
||||
#define SENSOR_FR_ID 0x2EAAF9u
|
||||
#define SENSOR_RR_ID 0x3495ACu
|
||||
#define SENSOR_RL_ID 0x2FC780u
|
||||
|
||||
/* Cisnienie startowe: DOMYSLNIE 2,6 bar = 260 kPa dla wszystkich kol.
|
||||
* Rozdzielczosc protokolu: 2,5 kPa/bit (0-637,5 kPa). */
|
||||
#define SENSOR_FL_PRESS_KPA 260.0f
|
||||
#define SENSOR_FR_PRESS_KPA 260.0f
|
||||
#define SENSOR_RR_PRESS_KPA 260.0f
|
||||
#define SENSOR_RL_PRESS_KPA 260.0f
|
||||
|
||||
/* Temperatura otoczenia (st. C) - konwertowana na st. F wg protokolu. */
|
||||
#define SENSOR_TEMP_C 23
|
||||
|
||||
/* ======================================================================
|
||||
* 4. PARAMETRY RF (Schrader EG53MA4)
|
||||
* - dane: Manchester G.E.T. MC, chip = 120 us (8.33 kBaud)
|
||||
* - nośna 433.92 MHz
|
||||
* - modulacja: ASK/OOK (domyślna - tak pracuje referencyjny EG53MA4 z
|
||||
* nagran rtl_433_tests i tak dekoderuje wbudowany Schrader-EG53MA4)
|
||||
* albo 2-FSK z dewiacja 47.6 kHz (wariant konfigurowalny - jesli Twoj
|
||||
* nadajnik/odbiornik auta pracuje FSK, przełacz MODE_FSK).
|
||||
* ====================================================================== */
|
||||
#define MODE_OOK 0
|
||||
#define MODE_FSK 1
|
||||
|
||||
#define TPMS_FREQUENCY_MHZ 433.92f
|
||||
#define TPMS_MODULATION MODE_OOK
|
||||
#define TPMS_DEVIATION_KHZ 47.6f // dla MODE_FSK
|
||||
#define TPMS_TX_POWER_DBM 10 // -30,-20,-15,-10,-6,0,5,7,10,11,12
|
||||
#define TPMS_CHIP_US 120 // czas trwania jednego chipa Manchester
|
||||
// (8.33 kBaud - zmierzone na nagraniach)
|
||||
|
||||
/* Ramka (dane z dekodera rtl_433 schrader_EG53MA4):
|
||||
* 40 bit sync + 4 bajty flags + 3 bajty ID + cisnienie + temperatura + CRC.
|
||||
* Suma kontrolna: suma 9 bajtow modulo 256 (add_bytes). */
|
||||
#define TPMS_FLAGS 0x4C900070u // flags ze zrzutow prawdziwych czujnikow
|
||||
#define TPMS_FLAGS_LOWBAT_MASK 0x00000008u // bit "rozladowana bateria"
|
||||
// (pozycja niepewna - dostosuj
|
||||
// jesli Twoj sterownik oczekuje
|
||||
// innego bitu)
|
||||
|
||||
/* ======================================================================
|
||||
* 5. HARMONOGRAM NADAWANIA / SEN
|
||||
* ====================================================================== */
|
||||
#define TX_BURST_FRAMES 3 // 3-6 ramek w burście (jak prawdziwy czujnik)
|
||||
#define TX_FRAME_GAP_MS 50 // odstep miedzy ramkami w burscie
|
||||
#define TX_INTERVAL_S 30 // interwal: kazde kolo co 30 s
|
||||
#define TX_INTERVAL_IGNITION_S 15 // krotki interwal przy zaplonie (ACC)
|
||||
#define TX_INTERVAL_PARKING_S 120 // interwal postojowy po zaniku ACC
|
||||
#define ACC_GRACE_MS (5UL*60UL*1000UL) // 5 min po zaniku ACC
|
||||
#define PARKING_SHUTDOWN 0 // 1 = po ACC_GRACE calkowite uspienie
|
||||
// (sen bez budzika, obudza przycisk/LF)
|
||||
#define BOOT_STAY_AWAKE_MS 3000 // okno na konsoli szeregowej po starcie
|
||||
|
||||
/* ======================================================================
|
||||
* 6. TRYB LEARN / SINGLE
|
||||
* ====================================================================== */
|
||||
#define LEARN_TX_PERIOD_MS 2000 // co ile ms wysylac bursta w learn
|
||||
#define LEARN_WINDOW_MS 60000 // okno czasowe na 1 czujnik (60 s)
|
||||
#define LEARN_WINDOW_EXPIRE_TO_NORMAL 1 // 1 = po uplywie okna powrot do
|
||||
// trybu normalnego (wg specyfikacji),
|
||||
// 0 = automatycznie kolejne kolo,
|
||||
// po ostatnim -> NORMAL
|
||||
#define LEARN_TOTAL_TIMEOUT_MS 900000 // bezpiecznik: 15 min i koniec learn
|
||||
#define SINGLE_TIMEOUT_MS 300000 // 0 = bez limitu
|
||||
|
||||
/* ======================================================================
|
||||
* 7. PROGI / DIAGNOSTYKA
|
||||
* ====================================================================== */
|
||||
#define LOWBATT_THRESHOLD_MV 11500 // dla POWER_12V (prog alarmu TPMS)
|
||||
// dla POWER_BATTERY ustaw np. 3200
|
||||
/* Harmonogram i moc poczatkowa: settings_defaults() w settings.cpp.
|
||||
* Sa to parametry eksperymentalne, a nie potwierdzony harmonogram OE. */
|
||||
#define BOOT_STAY_AWAKE_MS 10000u
|
||||
#define SERIAL_BAUD 115200
|
||||
|
||||
/* ======================================================================
|
||||
* 8. GESTY PRZYCISKU
|
||||
* ====================================================================== */
|
||||
#define BTN_DEBOUNCE_MS 30
|
||||
#define BTN_LONG_MS 1500 // >= 1.5 s = wejscie/wyjscie LEARN
|
||||
#define BTN_VERYLONG_MS 4000 // >= 4 s = wejscie/wyjscie SINGLE
|
||||
#define BTN_DEBOUNCE_MS 30u
|
||||
#define BTN_LONG_MS 1500u
|
||||
#define BTN_VERYLONG_MS 4000u
|
||||
|
||||
#endif /* TPMS_CONFIG_H */
|
||||
#endif
|
||||
+259
-167
@@ -1,202 +1,298 @@
|
||||
/*
|
||||
* console.cpp - debugowa konsola szeregowa (bez String i bez malloc)
|
||||
*
|
||||
* Komendy:
|
||||
* help - lista komend
|
||||
* info - wersja, konfiguracja, stan, napiecie
|
||||
* hex [n|all] - hexdump ramki TPMS dla kola n (1-4) lub wszystkich
|
||||
* send [n|all] - wyslij burst ramki teraz
|
||||
* batt - odczyt stanu baterii (napiecie zasilania)
|
||||
* mode normal|learn|single [n] - zmiana trybu
|
||||
* next - kolejne kolo (learn/single)
|
||||
* interval <s> - reczy ustalony interwal (0 = auto wg ACC)
|
||||
* flags <hex> - slowo flags wyslane w ramce
|
||||
* sleep - deep sleep teraz
|
||||
* stay [s] - zostan w stanie czuwania jeszcze s sekund
|
||||
*
|
||||
* Parser jest scisly: zly argument = komunikat bledu, bez dzialania
|
||||
* ubocznego (np. "send bla" NIE nadaje wszystkich kol).
|
||||
*/
|
||||
/* Konsola szeregowa: konfiguracja zapisywana w NVS, bez rekompilacji. */
|
||||
#include <Arduino.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <esp_system.h>
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "config.h"
|
||||
#include "app.h"
|
||||
#include "console.h"
|
||||
#include "power.h"
|
||||
#include "settings_store.h"
|
||||
|
||||
static char line[64];
|
||||
static uint8_t line_len = 0;
|
||||
static bool line_overflow = false;
|
||||
static char line[96];
|
||||
static uint8_t line_len;
|
||||
static bool line_overflow;
|
||||
|
||||
static void cmd_help(void)
|
||||
static bool parse_u32(const char *text, uint32_t lo, uint32_t hi,
|
||||
uint32_t *out, int base = 10)
|
||||
{
|
||||
Serial.println(F("Komendy:"));
|
||||
Serial.println(F(" help - ta pomoc"));
|
||||
Serial.println(F(" info - wersja/config/stan/napiecie"));
|
||||
Serial.println(F(" hex [n|all] - hexdump ramki kola n (1-4)"));
|
||||
Serial.println(F(" send [n|all] - nadaj burst teraz"));
|
||||
Serial.println(F(" batt - napiecie zasilania [mV]"));
|
||||
Serial.println(F(" mode normal|learn|single [n] - tryb pracy"));
|
||||
Serial.println(F(" next - kolejne kolo (learn/single)"));
|
||||
Serial.println(F(" interval <s> - interwal nadawania (0=auto)"));
|
||||
Serial.println(F(" flags <hex> - slowo flags w ramce"));
|
||||
Serial.println(F(" sleep - deep sleep teraz"));
|
||||
Serial.println(F(" stay [s] - czuwaj jeszcze s sekund"));
|
||||
}
|
||||
|
||||
/* Scisly parser liczby calkowitej bez znaku z zakresem. */
|
||||
static bool parse_u32(const char *s, uint32_t lo, uint32_t hi, uint32_t *out,
|
||||
int base)
|
||||
{
|
||||
if (s == NULL || *s == '\0') {
|
||||
if (text == NULL || *text == '\0' || *text == '-') {
|
||||
return false;
|
||||
}
|
||||
errno = 0;
|
||||
char *end = NULL;
|
||||
unsigned long v = strtoul(s, &end, base);
|
||||
if (errno != 0 || end == s || *end != '\0') {
|
||||
unsigned long value = strtoul(text, &end, base);
|
||||
if (errno != 0 || end == text || *end != '\0'
|
||||
|| value < lo || value > hi) {
|
||||
return false;
|
||||
}
|
||||
if (v < (unsigned long)lo || v > (unsigned long)hi) {
|
||||
return false;
|
||||
}
|
||||
*out = (uint32_t)v;
|
||||
*out = (uint32_t)value;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Numer kola 1-4 -> indeks 0-3; "all" -> 0xFF; blad -> -1. */
|
||||
static int parse_wheel(const char *arg, uint8_t *wheel)
|
||||
static bool parse_i32(const char *text, int32_t lo, int32_t hi, int32_t *out)
|
||||
{
|
||||
if (arg == NULL) {
|
||||
return -1;
|
||||
if (text == NULL || *text == '\0') {
|
||||
return false;
|
||||
}
|
||||
if (strcmp(arg, "all") == 0) {
|
||||
*wheel = 0xFF;
|
||||
return 0;
|
||||
errno = 0;
|
||||
char *end = NULL;
|
||||
long value = strtol(text, &end, 10);
|
||||
if (errno != 0 || end == text || *end != '\0' || value < lo || value > hi) {
|
||||
return false;
|
||||
}
|
||||
uint32_t n = 0;
|
||||
if (!parse_u32(arg, 1, WHEEL_COUNT, &n, 10)) {
|
||||
return -1;
|
||||
}
|
||||
*wheel = (uint8_t)(n - 1);
|
||||
return 0;
|
||||
*out = value;
|
||||
return true;
|
||||
}
|
||||
|
||||
static void handle_line(char *s)
|
||||
static bool parse_float(const char *text, float lo, float hi, float *out)
|
||||
{
|
||||
char *cmd = strtok(s, " \t");
|
||||
if (text == NULL || *text == '\0') {
|
||||
return false;
|
||||
}
|
||||
errno = 0;
|
||||
char *end = NULL;
|
||||
float value = strtof(text, &end);
|
||||
if (errno != 0 || end == text || *end != '\0' || value < lo || value > hi) {
|
||||
return false;
|
||||
}
|
||||
*out = value;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool parse_wheel(const char *text, uint8_t *wheel, bool allow_all = false)
|
||||
{
|
||||
if (allow_all && text != NULL && strcmp(text, "all") == 0) {
|
||||
*wheel = 0xFFu;
|
||||
return true;
|
||||
}
|
||||
uint32_t value;
|
||||
if (!parse_u32(text, 1u, WHEEL_COUNT, &value)) {
|
||||
return false;
|
||||
}
|
||||
*wheel = (uint8_t)(value - 1u);
|
||||
return true;
|
||||
}
|
||||
|
||||
static void cmd_help(void)
|
||||
{
|
||||
Serial.println(F("POMOC (zmiany konfiguracji zapisuja sie automatycznie):"));
|
||||
Serial.println(F(" info | hex [1-4|all] | send [1-4|all] | batt"));
|
||||
Serial.println(F(" mode normal | mode learn [1-4] | mode single 1-4 | next"));
|
||||
Serial.println(F(" id 1-4 XXXXXX - ustaw 24-bit ID (hex)"));
|
||||
Serial.println(F(" ids new - wygeneruj 4 unikalne ID"));
|
||||
Serial.println(F(" pressure 1-4|all KPA - np. pressure all 260"));
|
||||
Serial.println(F(" temp 1-4|all C - temperatura -40..85 C"));
|
||||
Serial.println(F(" interval normal|ignition|parking 5-86400"));
|
||||
Serial.println(F(" rf freq 433.05-434.79 | rf power -30..5 | rf burst 1-8"));
|
||||
Serial.println(F(" rf gap 20-500 - odstep miedzy ramkami [ms]"));
|
||||
Serial.println(F(" flags HEX - 32-bit flags (znaczenie nie w pelni znane)"));
|
||||
Serial.println(F(" factory YES - przywroc fabryczne | save | stay [s] | sleep"));
|
||||
}
|
||||
|
||||
static void cmd_send(const char *arg)
|
||||
{
|
||||
uint8_t wheel;
|
||||
bool ok;
|
||||
if (arg == NULL) {
|
||||
ok = g_app->mode() == AppMode::NORMAL ? g_app->send_all() : g_app->send_current();
|
||||
} else if (parse_wheel(arg, &wheel, true)) {
|
||||
ok = wheel == 0xFFu ? g_app->send_all() : g_app->send_wheel(wheel);
|
||||
} else {
|
||||
Serial.println(F("BLAD: send [1-4|all]"));
|
||||
return;
|
||||
}
|
||||
Serial.println(ok ? F("OK") : F("BLAD TX"));
|
||||
}
|
||||
|
||||
static void cmd_mode(const char *arg1, const char *arg2)
|
||||
{
|
||||
if (arg1 == NULL) {
|
||||
Serial.println(F("BLAD: mode normal|learn|single [1-4]"));
|
||||
return;
|
||||
}
|
||||
uint8_t wheel = WHEEL_FL;
|
||||
if (arg2 != NULL && !parse_wheel(arg2, &wheel)) {
|
||||
Serial.println(F("BLAD: kolo 1-4"));
|
||||
return;
|
||||
}
|
||||
if (strcmp(arg1, "normal") == 0) {
|
||||
g_app->set_mode(AppMode::NORMAL, WHEEL_FL, millis(), false);
|
||||
} else if (strcmp(arg1, "learn") == 0) {
|
||||
g_app->set_mode(AppMode::LEARN, wheel, millis());
|
||||
} else if (strcmp(arg1, "single") == 0 && arg2 != NULL) {
|
||||
g_app->set_mode(AppMode::SINGLE, wheel, millis());
|
||||
} else {
|
||||
Serial.println(F("BLAD: mode normal|learn [1-4]|single 1-4"));
|
||||
return;
|
||||
}
|
||||
Serial.println(F("OK"));
|
||||
}
|
||||
|
||||
static void cmd_id(const char *wheel_text, const char *id_text)
|
||||
{
|
||||
uint8_t wheel;
|
||||
uint32_t id;
|
||||
if (!parse_wheel(wheel_text, &wheel) || !parse_u32(id_text, 1u, 0xFFFFFEu, &id, 16)
|
||||
|| !settings_set_id(&g_settings, wheel, id)) {
|
||||
Serial.println(F("BLAD: id 1-4 000001..FFFFFE; ID musza byc unikalne"));
|
||||
return;
|
||||
}
|
||||
app_save_and_apply();
|
||||
}
|
||||
|
||||
static void cmd_pressure_temp(const char *which, const char *wheel_text,
|
||||
const char *value_text)
|
||||
{
|
||||
uint8_t wheel;
|
||||
if (!parse_wheel(wheel_text, &wheel, true)) {
|
||||
Serial.println(F("BLAD: kolo 1-4 lub all"));
|
||||
return;
|
||||
}
|
||||
uint8_t first = wheel == 0xFFu ? 0u : wheel;
|
||||
uint8_t last = wheel == 0xFFu ? WHEEL_COUNT : (uint8_t)(wheel + 1u);
|
||||
if (strcmp(which, "pressure") == 0) {
|
||||
float kpa;
|
||||
if (!parse_float(value_text, 0.0f, 637.5f, &kpa)) {
|
||||
Serial.println(F("BLAD: cisnienie 0..637.5 kPa"));
|
||||
return;
|
||||
}
|
||||
uint16_t value = (uint16_t)(kpa * 10.0f + 0.5f);
|
||||
for (uint8_t i = first; i < last; ++i) {
|
||||
g_settings.wheels[i].pressure_kpa10 = value;
|
||||
}
|
||||
} else {
|
||||
int32_t value;
|
||||
if (!parse_i32(value_text, -40, 85, &value)) {
|
||||
Serial.println(F("BLAD: temperatura -40..85 C"));
|
||||
return;
|
||||
}
|
||||
for (uint8_t i = first; i < last; ++i) {
|
||||
g_settings.wheels[i].temp_c = (int16_t)value;
|
||||
}
|
||||
}
|
||||
app_save_and_apply();
|
||||
}
|
||||
|
||||
static void cmd_interval(const char *which, const char *value_text)
|
||||
{
|
||||
uint32_t value;
|
||||
if (which == NULL || !parse_u32(value_text, SETTINGS_INTERVAL_MIN_S,
|
||||
SETTINGS_INTERVAL_MAX_S, &value)) {
|
||||
Serial.println(F("BLAD: interval normal|ignition|parking 5-86400"));
|
||||
return;
|
||||
}
|
||||
if (strcmp(which, "normal") == 0) {
|
||||
g_settings.normal_interval_s = value;
|
||||
} else if (strcmp(which, "ignition") == 0) {
|
||||
g_settings.ignition_interval_s = value;
|
||||
} else if (strcmp(which, "parking") == 0) {
|
||||
g_settings.parking_interval_s = value;
|
||||
} else {
|
||||
Serial.println(F("BLAD: rodzaj interwalu"));
|
||||
return;
|
||||
}
|
||||
app_save_and_apply();
|
||||
}
|
||||
|
||||
static void cmd_rf(const char *which, const char *value_text)
|
||||
{
|
||||
uint32_t value;
|
||||
int32_t signed_value;
|
||||
float frequency;
|
||||
if (which == NULL) {
|
||||
Serial.println(F("BLAD: rf freq|power|burst|gap"));
|
||||
return;
|
||||
}
|
||||
if (strcmp(which, "freq") == 0 && parse_float(value_text, 433.05f, 434.79f, &frequency)) {
|
||||
g_settings.frequency_mhz = frequency;
|
||||
} else if (strcmp(which, "power") == 0
|
||||
&& parse_i32(value_text, -30, 5, &signed_value)
|
||||
&& settings_valid_tx_power((int)signed_value)) {
|
||||
g_settings.tx_power_dbm = (int8_t)signed_value;
|
||||
} else if (strcmp(which, "burst") == 0 && parse_u32(value_text, 1u, 8u, &value)) {
|
||||
g_settings.burst_frames = (uint8_t)value;
|
||||
} else if (strcmp(which, "gap") == 0 && parse_u32(value_text, 20u, 500u, &value)) {
|
||||
g_settings.frame_gap_ms = (uint16_t)value;
|
||||
} else {
|
||||
Serial.println(F("BLAD: parametr RF poza dozwolonym zakresem"));
|
||||
return;
|
||||
}
|
||||
app_save_and_apply();
|
||||
}
|
||||
|
||||
static void handle_line(char *text)
|
||||
{
|
||||
char *cmd = strtok(text, " \t");
|
||||
if (cmd == NULL) {
|
||||
return;
|
||||
}
|
||||
char *arg1 = strtok(NULL, " \t");
|
||||
char *arg2 = strtok(NULL, " \t");
|
||||
uint32_t u = 0;
|
||||
uint32_t value;
|
||||
|
||||
if (strcmp(cmd, "help") == 0) {
|
||||
cmd_help();
|
||||
}
|
||||
else if (strcmp(cmd, "info") == 0 || strcmp(cmd, "config") == 0) {
|
||||
} else if (strcmp(cmd, "info") == 0 || strcmp(cmd, "config") == 0) {
|
||||
app_print_info();
|
||||
} else if (strcmp(cmd, "hex") == 0) {
|
||||
uint8_t wheel;
|
||||
if (arg1 == NULL) {
|
||||
app_print_frame(g_app->active_wheel());
|
||||
} else if (parse_wheel(arg1, &wheel, true)) {
|
||||
if (wheel == 0xFFu) {
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; ++i) app_print_frame(i);
|
||||
} else {
|
||||
app_print_frame(wheel);
|
||||
}
|
||||
else if (strcmp(cmd, "hex") == 0) {
|
||||
uint8_t w;
|
||||
if (arg1 == NULL || strcmp(arg1, "all") == 0) {
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; i++) {
|
||||
app_print_frame(i);
|
||||
}
|
||||
}
|
||||
else if (parse_wheel(arg1, &w) == 0) {
|
||||
app_print_frame(w);
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
Serial.println(F("BLAD: hex [1-4|all]"));
|
||||
}
|
||||
}
|
||||
else if (strcmp(cmd, "send") == 0) {
|
||||
uint8_t w;
|
||||
if (arg1 == NULL || strcmp(arg1, "all") == 0) {
|
||||
app_send_burst_all();
|
||||
Serial.println(F("OK"));
|
||||
}
|
||||
else if (parse_wheel(arg1, &w) == 0) {
|
||||
app_send_burst_wheel(w);
|
||||
Serial.println(F("OK"));
|
||||
}
|
||||
else {
|
||||
Serial.println(F("BLAD: send [1-4|all]"));
|
||||
}
|
||||
}
|
||||
else if (strcmp(cmd, "batt") == 0) {
|
||||
Serial.printf("Vcc = %u mV\n", (unsigned)app_supply_mv());
|
||||
}
|
||||
else if (strcmp(cmd, "next") == 0) {
|
||||
app_next_wheel();
|
||||
}
|
||||
else if (strcmp(cmd, "mode") == 0) {
|
||||
uint8_t w = 0;
|
||||
if (arg1 == NULL) {
|
||||
Serial.println(F("BLAD: mode normal|learn|single [n]"));
|
||||
} else if (strcmp(cmd, "send") == 0) {
|
||||
cmd_send(arg1);
|
||||
} else if (strcmp(cmd, "batt") == 0) {
|
||||
Serial.printf("Vcc=%u mV\n", (unsigned)power_read_mv());
|
||||
} else if (strcmp(cmd, "mode") == 0) {
|
||||
cmd_mode(arg1, arg2);
|
||||
} else if (strcmp(cmd, "next") == 0) {
|
||||
Serial.println(g_app->next_wheel(millis()) ? F("OK") : F("BLAD: tylko LEARN/SINGLE"));
|
||||
} else if (strcmp(cmd, "id") == 0) {
|
||||
cmd_id(arg1, arg2);
|
||||
} else if (strcmp(cmd, "ids") == 0 && arg1 != NULL && strcmp(arg1, "new") == 0) {
|
||||
settings_generate_ids(&g_settings, esp_random());
|
||||
app_save_and_apply();
|
||||
} else if (strcmp(cmd, "pressure") == 0 || strcmp(cmd, "temp") == 0) {
|
||||
cmd_pressure_temp(cmd, arg1, arg2);
|
||||
} else if (strcmp(cmd, "interval") == 0) {
|
||||
cmd_interval(arg1, arg2);
|
||||
} else if (strcmp(cmd, "rf") == 0) {
|
||||
cmd_rf(arg1, arg2);
|
||||
} else if (strcmp(cmd, "flags") == 0) {
|
||||
if (!parse_u32(arg1, 0u, 0xFFFFFFFFu, &value, 16)) {
|
||||
Serial.println(F("BLAD: flags HEX"));
|
||||
return;
|
||||
}
|
||||
if (strcmp(arg1, "normal") == 0) {
|
||||
app_set_mode(APP_MODE_NORMAL, 0);
|
||||
}
|
||||
else if (strcmp(arg1, "learn") == 0) {
|
||||
if (arg2 != NULL && parse_wheel(arg2, &w) != 0) {
|
||||
Serial.println(F("BLAD: numer kola 1-4"));
|
||||
return;
|
||||
}
|
||||
app_set_mode(APP_MODE_LEARN, w);
|
||||
}
|
||||
else if (strcmp(arg1, "single") == 0) {
|
||||
if (arg2 == NULL || parse_wheel(arg2, &w) != 0 || w == 0xFF) {
|
||||
Serial.println(F("BLAD: single wymaga numeru kola 1-4"));
|
||||
return;
|
||||
}
|
||||
app_set_mode(APP_MODE_SINGLE, w);
|
||||
}
|
||||
else {
|
||||
Serial.println(F("BLAD: mode normal|learn|single [n]"));
|
||||
return;
|
||||
}
|
||||
Serial.println(F("OK"));
|
||||
}
|
||||
else if (strcmp(cmd, "interval") == 0) {
|
||||
if (!parse_u32(arg1, 0, 86400, &u, 10)) {
|
||||
Serial.println(F("BLAD: interval <0-86400>"));
|
||||
return;
|
||||
}
|
||||
app_set_interval(u);
|
||||
Serial.println(F("OK"));
|
||||
}
|
||||
else if (strcmp(cmd, "flags") == 0) {
|
||||
if (!parse_u32(arg1, 0, 0xFFFFFFFFu, &u, 16)) {
|
||||
Serial.println(F("BLAD: flags <hex>"));
|
||||
return;
|
||||
}
|
||||
app_set_flags(u);
|
||||
Serial.println(F("OK"));
|
||||
}
|
||||
else if (strcmp(cmd, "sleep") == 0) {
|
||||
g_settings.flags = value;
|
||||
app_save_and_apply();
|
||||
} else if (strcmp(cmd, "factory") == 0 && arg1 != NULL && strcmp(arg1, "YES") == 0) {
|
||||
settings_defaults(&g_settings);
|
||||
g_app->set_mode(AppMode::NORMAL, WHEEL_FL, millis(), false);
|
||||
app_save_and_apply();
|
||||
} else if (strcmp(cmd, "save") == 0) {
|
||||
app_save_and_apply();
|
||||
} else if (strcmp(cmd, "sleep") == 0) {
|
||||
app_request_sleep();
|
||||
}
|
||||
else if (strcmp(cmd, "stay") == 0) {
|
||||
if (arg1 == NULL) {
|
||||
app_stay_awake(60000u);
|
||||
}
|
||||
else if (parse_u32(arg1, 0, 3600, &u, 10)) {
|
||||
app_stay_awake(u * 1000u);
|
||||
}
|
||||
else {
|
||||
Serial.println(F("BLAD: stay <0-3600>"));
|
||||
} else if (strcmp(cmd, "stay") == 0) {
|
||||
value = 60u;
|
||||
if (arg1 != NULL && !parse_u32(arg1, 1u, 3600u, &value)) {
|
||||
Serial.println(F("BLAD: stay 1-3600"));
|
||||
return;
|
||||
}
|
||||
app_stay_awake(value * 1000u);
|
||||
Serial.println(F("OK"));
|
||||
}
|
||||
else {
|
||||
Serial.println(F("Nieznana komenda - 'help'"));
|
||||
} else {
|
||||
Serial.println(F("Nieznana komenda; help"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -213,23 +309,19 @@ void console_poll(void)
|
||||
if (c == '\r' || c == '\n') {
|
||||
if (line_overflow) {
|
||||
Serial.println(F("BLAD: linia za dluga"));
|
||||
}
|
||||
else if (line_len > 0) {
|
||||
} else if (line_len > 0u) {
|
||||
line[line_len] = '\0';
|
||||
handle_line(line);
|
||||
}
|
||||
line_len = 0;
|
||||
line_overflow = false;
|
||||
}
|
||||
else if (line_overflow) {
|
||||
/* po przeplenieniu porzucamy cala linie lacznie z ogonem */
|
||||
}
|
||||
else if (line_len < sizeof(line) - 1u) {
|
||||
} else if (!line_overflow) {
|
||||
if (line_len < sizeof(line) - 1u) {
|
||||
line[line_len++] = c;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
line_overflow = true;
|
||||
line_len = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+160
-457
@@ -1,203 +1,61 @@
|
||||
/*
|
||||
* main.cpp - symulator 4 czujnikow TPMS Schrader EG53MA4 (ESP32 + CC1101)
|
||||
* dla Opla Astry J Sedan 2016 (EU, 433 MHz, TPMS bezposredni).
|
||||
*
|
||||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||
* ZASTRZEZENIE: projekt wylacznie diagnostyczny/testowy.
|
||||
* Symulator dostarcza SZTUCZNE dane cisnienia i temperatury i NIE
|
||||
* zastepuje prawdziwych czujnikow TPMS. Nie uzywac podczas jazdy.
|
||||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||
*
|
||||
* Tryby pracy:
|
||||
* NORMAL - rotacja 4 kol, burst 3-5 ramek co TX_INTERVAL_S, deep sleep
|
||||
* miedzy transmisjami (budzik RTC + budzenie przyciskiem/LF)
|
||||
* LEARN - nauka czujnikow w aucie: jedno kolo naraz, kolejnosc
|
||||
* FL -> FR -> RR -> RL, przycisk = kolejne kolo, okno czasowe
|
||||
* SINGLE - wymuszone nadawanie jednego ID (testy/procedury serwisowe)
|
||||
*
|
||||
* Protokol: rtl_433 src/devices/schraeder.c (schrader_EG53MA4),
|
||||
* Manchester G.E.T. MC, chip 120 us, ASK/OOK 433.92 MHz (opcjonalnie 2-FSK).
|
||||
*/
|
||||
/* Symulator diagnostyczny TPMS. Sztuczne cisnienie moze ukryc usterke opony. */
|
||||
#include <Arduino.h>
|
||||
#include <esp_sleep.h>
|
||||
#include <driver/gpio.h>
|
||||
|
||||
#include "config.h"
|
||||
#include "tpms_frame.h"
|
||||
#include "radio.h"
|
||||
#include "power.h"
|
||||
#include "ui.h"
|
||||
#include "console.h"
|
||||
#include "app.h"
|
||||
#include "config.h"
|
||||
#include "console.h"
|
||||
#include "power.h"
|
||||
#include "radio.h"
|
||||
#include "settings_store.h"
|
||||
#include "tpms_frame.h"
|
||||
#include "ui.h"
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Dane czujnikow (mapowanie ID -> kolo) */
|
||||
/* ------------------------------------------------------------------ */
|
||||
#define KPA10(x) ((uint16_t)((x) * 10.0f + 0.5f))
|
||||
AppState *g_app = nullptr;
|
||||
|
||||
static const tpms_sensor_t SENSOR[WHEEL_COUNT] = {
|
||||
{ SENSOR_FL_ID, KPA10(SENSOR_FL_PRESS_KPA), SENSOR_TEMP_C, "FL" },
|
||||
{ SENSOR_FR_ID, KPA10(SENSOR_FR_PRESS_KPA), SENSOR_TEMP_C, "FR" },
|
||||
{ SENSOR_RR_ID, KPA10(SENSOR_RR_PRESS_KPA), SENSOR_TEMP_C, "RR" },
|
||||
{ SENSOR_RL_ID, KPA10(SENSOR_RL_PRESS_KPA), SENSOR_TEMP_C, "RL" },
|
||||
};
|
||||
|
||||
/* Kolejnosc nauki (kolejnosc w tablicy SENSOR = FL, FR, RR, RL). */
|
||||
static const uint8_t LEARN_SEQ[WHEEL_COUNT] = {
|
||||
LEARN_ORDER_0, LEARN_ORDER_1, LEARN_ORDER_2, LEARN_ORDER_3,
|
||||
};
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Stan w RTC (przetrwuje deep sleep) */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Magic zwiazany z wersja konfiguracji: zmiana CONFIG_VERSION (np. po
|
||||
* zmianie formatu stanu w RTC) zeruje caly stan po wybudzeniu. */
|
||||
#define RTC_MAGIC (0x54504D53u ^ (uint32_t)CONFIG_VERSION) // 'TPMS' ^ version
|
||||
|
||||
RTC_DATA_ATTR static uint32_t rtc_magic;
|
||||
RTC_DATA_ATTR static uint8_t rtc_mode = APP_MODE_NORMAL;
|
||||
RTC_DATA_ATTR static uint8_t rtc_seq_idx = 0; // pozycja w LEARN_SEQ (LEARN)
|
||||
RTC_DATA_ATTR static uint8_t rtc_single_wheel = 0; // kolo w SINGLE (indeks SENSOR)
|
||||
RTC_DATA_ATTR static uint8_t rtc_rot_idx = 0; // rotacja w NORMAL
|
||||
RTC_DATA_ATTR static uint32_t rtc_wake_count = 0;
|
||||
RTC_DATA_ATTR static uint32_t rtc_interval_s = 0; // 0 = auto wg ACC
|
||||
RTC_DATA_ATTR static uint32_t rtc_flags = TPMS_FLAGS;
|
||||
RTC_DATA_ATTR static uint64_t rtc_last_acc_ms = 0;
|
||||
|
||||
/* Stan sesji (wazny tylko w biezaczym wybudzeniu) */
|
||||
static uint32_t stay_awake_until = 0;
|
||||
static uint32_t next_tx_ms = 0;
|
||||
static uint32_t learn_window_start = 0;
|
||||
static uint32_t learn_session_start = 0;
|
||||
static uint32_t single_start = 0;
|
||||
static bool request_sleep = false;
|
||||
static bool low_batt = false;
|
||||
static uint32_t supply_mv = 0;
|
||||
static const char *const WHEEL_NAMES[WHEEL_COUNT] = {"FL", "FR", "RR", "RL"};
|
||||
static uint32_t stay_awake_until;
|
||||
static bool request_sleep;
|
||||
static uint32_t supply_mv;
|
||||
#if PIN_LF_TRIGGER >= 0
|
||||
static bool lf_prev = false; // poprzedni stan wejscia LF (zbocze)
|
||||
static bool lf_previous;
|
||||
#endif
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Pomocnicze */
|
||||
/* ------------------------------------------------------------------ */
|
||||
static uint32_t compute_interval(void);
|
||||
|
||||
/* Aktywne kolo: SINGLE trzyma bezposredni indeks SENSOR, LEARN - pozycje
|
||||
* w sekwencji nauki LEARN_SEQ (moga sie roznic po zmianie LEARN_ORDER_*). */
|
||||
static uint8_t active_wheel(void)
|
||||
static bool ignition_on(void)
|
||||
{
|
||||
return (rtc_mode == APP_MODE_SINGLE)
|
||||
? (uint8_t)(rtc_single_wheel % WHEEL_COUNT)
|
||||
: LEARN_SEQ[rtc_seq_idx % WHEEL_COUNT];
|
||||
#if PIN_ACC >= 0
|
||||
return digitalRead(PIN_ACC) == HIGH;
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
/* Pozycja kola w sekwencji nauki (do trybu LEARN). */
|
||||
static uint8_t seq_pos_of(uint8_t wheel)
|
||||
{
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; i++) {
|
||||
if (LEARN_SEQ[i] == wheel) {
|
||||
return i;
|
||||
class HardwareRadio final : public RadioSink {
|
||||
public:
|
||||
bool send(uint8_t wheel) override
|
||||
{
|
||||
if (wheel >= WHEEL_COUNT) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void refresh_power(void)
|
||||
{
|
||||
supply_mv = power_read_mv();
|
||||
low_batt = power_low_battery(supply_mv);
|
||||
}
|
||||
|
||||
static void build_frame_for(uint8_t wheel, uint8_t out[TPMS_TX_BYTES])
|
||||
{
|
||||
const tpms_sensor_t *s = &SENSOR[wheel % WHEEL_COUNT];
|
||||
tpms_build_frame(out, s->id, s->press_kpa10, s->temp_c, rtc_flags, low_batt);
|
||||
}
|
||||
|
||||
void app_send_burst_wheel(uint8_t wheel)
|
||||
{
|
||||
const sensor_settings_t &sensor = g_settings.wheels[wheel];
|
||||
uint8_t frame[TPMS_TX_BYTES];
|
||||
build_frame_for(wheel, frame);
|
||||
bool ok = radio_send_burst(frame, TPMS_TX_BYTES, TX_BURST_FRAMES);
|
||||
Serial.printf("TX %s id=%06X %.1f kPa %d C flags=%08X%s%s\n",
|
||||
SENSOR[wheel % WHEEL_COUNT].name,
|
||||
(unsigned)SENSOR[wheel % WHEEL_COUNT].id,
|
||||
SENSOR[wheel % WHEEL_COUNT].press_kpa10 / 10.0f,
|
||||
(int)SENSOR[wheel % WHEEL_COUNT].temp_c,
|
||||
(unsigned)rtc_flags, low_batt ? " LOWBATT" : "",
|
||||
if (!tpms_build_frame(frame, sensor.id, sensor.pressure_kpa10,
|
||||
(int8_t)sensor.temp_c, g_settings.flags)) {
|
||||
return false;
|
||||
}
|
||||
bool ok = radio_send_burst(frame, TPMS_TX_BYTES, g_settings.burst_frames,
|
||||
g_settings.frame_gap_ms);
|
||||
Serial.printf("TX %s id=%06X %u.%u kPa %d C flags=%08X%s\n",
|
||||
WHEEL_NAMES[wheel], (unsigned)sensor.id,
|
||||
sensor.pressure_kpa10 / 10u, sensor.pressure_kpa10 % 10u,
|
||||
(int)sensor.temp_c, (unsigned)g_settings.flags,
|
||||
ok ? "" : " TX-ERR");
|
||||
}
|
||||
|
||||
void app_send_burst_all(void)
|
||||
{
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; i++) {
|
||||
app_send_burst_wheel((uint8_t)((rtc_rot_idx + i) % WHEEL_COUNT));
|
||||
return ok;
|
||||
}
|
||||
rtc_rot_idx = (uint8_t)((rtc_rot_idx + 1) % WHEEL_COUNT);
|
||||
}
|
||||
};
|
||||
|
||||
void app_print_frame(uint8_t wheel)
|
||||
{
|
||||
uint8_t frame[TPMS_TX_BYTES];
|
||||
uint8_t payload[TPMS_PAYLOAD_LEN];
|
||||
const tpms_sensor_t *s = &SENSOR[wheel % WHEEL_COUNT];
|
||||
build_frame_for(wheel, frame);
|
||||
tpms_build_payload(payload, s->id, s->press_kpa10, s->temp_c, rtc_flags, low_batt);
|
||||
|
||||
Serial.printf("%s frame:", s->name);
|
||||
for (uint8_t i = 0; i < TPMS_TX_BYTES; i++) {
|
||||
Serial.printf(" %02X", frame[i]);
|
||||
}
|
||||
Serial.printf("\n%s payload:", s->name);
|
||||
for (uint8_t i = 0; i < TPMS_PAYLOAD_LEN; i++) {
|
||||
Serial.printf(" %02X", payload[i]);
|
||||
}
|
||||
Serial.printf(" crc=%02X id=%06X press=%.1f kPa temp=%d F\n",
|
||||
payload[9], (unsigned)s->id,
|
||||
payload[7] * 2.5f, (int)payload[8]);
|
||||
}
|
||||
|
||||
void app_print_info(void)
|
||||
{
|
||||
Serial.printf("FW %s config v%d mode=%s wheel=%s\n",
|
||||
FW_VERSION, CONFIG_VERSION,
|
||||
rtc_mode == APP_MODE_NORMAL ? "NORMAL" :
|
||||
rtc_mode == APP_MODE_LEARN ? "LEARN" : "SINGLE",
|
||||
SENSOR[active_wheel()].name);
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; i++) {
|
||||
Serial.printf(" %s id=%06X press=%.1f kPa temp=%d C\n",
|
||||
SENSOR[i].name, (unsigned)SENSOR[i].id,
|
||||
SENSOR[i].press_kpa10 / 10.0f, (int)SENSOR[i].temp_c);
|
||||
}
|
||||
Serial.printf("flags=%08X mod=%s chip=%dus burst=%d interval=%us wake=%lu\n",
|
||||
(unsigned)rtc_flags,
|
||||
TPMS_MODULATION == MODE_FSK ? "FSK" : "OOK",
|
||||
TPMS_CHIP_US, TX_BURST_FRAMES,
|
||||
(unsigned)compute_interval(),
|
||||
(unsigned long)rtc_wake_count);
|
||||
Serial.printf("Vcc=%u mV%s\n", (unsigned)supply_mv, low_batt ? " LOWBATT" : "");
|
||||
}
|
||||
|
||||
uint32_t app_supply_mv(void)
|
||||
{
|
||||
refresh_power();
|
||||
return supply_mv;
|
||||
}
|
||||
|
||||
void app_set_interval(uint32_t seconds)
|
||||
{
|
||||
rtc_interval_s = seconds;
|
||||
}
|
||||
|
||||
void app_set_flags(uint32_t flags)
|
||||
{
|
||||
rtc_flags = flags;
|
||||
}
|
||||
|
||||
void app_request_sleep(void)
|
||||
{
|
||||
request_sleep = true;
|
||||
}
|
||||
static HardwareRadio hardware_radio;
|
||||
static AppState app_state(&g_settings, &hardware_radio);
|
||||
|
||||
void app_stay_awake(uint32_t ms)
|
||||
{
|
||||
@@ -207,94 +65,90 @@ void app_stay_awake(uint32_t ms)
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t app_mode(void)
|
||||
void app_request_sleep(void)
|
||||
{
|
||||
return rtc_mode;
|
||||
request_sleep = true;
|
||||
}
|
||||
|
||||
uint8_t app_wheel(void)
|
||||
bool app_save_and_apply(void)
|
||||
{
|
||||
return active_wheel();
|
||||
}
|
||||
|
||||
void app_next_wheel(void)
|
||||
{
|
||||
if (rtc_mode == APP_MODE_SINGLE) {
|
||||
rtc_single_wheel = (uint8_t)((rtc_single_wheel + 1) % WHEEL_COUNT);
|
||||
if (!settings_store_save()) {
|
||||
Serial.println(F("BLAD: nie zapisano NVS (walidacja lub zapis)"));
|
||||
return false;
|
||||
}
|
||||
else {
|
||||
rtc_seq_idx = (uint8_t)((rtc_seq_idx + 1) % WHEEL_COUNT);
|
||||
if (!radio_init(&g_settings)) {
|
||||
Serial.println(F("OSTRZEZENIE: zapisano, ale CC1101 nie odpowiada"));
|
||||
}
|
||||
ui_blink_count((uint8_t)(active_wheel() + 1));
|
||||
Serial.printf("Kolo: %s\n", SENSOR[active_wheel()].name);
|
||||
learn_window_start = millis();
|
||||
Serial.println(F("OK: zapisano w NVS"));
|
||||
return true;
|
||||
}
|
||||
|
||||
void app_set_mode(uint8_t mode, uint8_t wheel)
|
||||
void app_print_frame(uint8_t wheel)
|
||||
{
|
||||
rtc_mode = mode;
|
||||
switch (mode) {
|
||||
case APP_MODE_LEARN:
|
||||
rtc_seq_idx = seq_pos_of((uint8_t)(wheel % WHEEL_COUNT));
|
||||
learn_window_start = millis();
|
||||
learn_session_start = millis();
|
||||
next_tx_ms = 0;
|
||||
ui_set_pattern(UI_PAT_LEARN);
|
||||
ui_blink_count((uint8_t)(active_wheel() + 1));
|
||||
Serial.printf("LEARN start, kolo %s\n", SENSOR[active_wheel()].name);
|
||||
app_stay_awake(LEARN_TOTAL_TIMEOUT_MS);
|
||||
break;
|
||||
case APP_MODE_SINGLE:
|
||||
rtc_single_wheel = (uint8_t)(wheel % WHEEL_COUNT);
|
||||
single_start = millis();
|
||||
next_tx_ms = 0;
|
||||
ui_set_pattern(UI_PAT_SINGLE);
|
||||
ui_blink_count((uint8_t)(active_wheel() + 1));
|
||||
Serial.printf("SINGLE start, kolo %s\n", SENSOR[active_wheel()].name);
|
||||
app_stay_awake(SINGLE_TIMEOUT_MS ? SINGLE_TIMEOUT_MS : 3600000u);
|
||||
break;
|
||||
default:
|
||||
rtc_mode = APP_MODE_NORMAL;
|
||||
ui_set_pattern(UI_PAT_NORMAL);
|
||||
Serial.println(F("NORMAL"));
|
||||
next_tx_ms = 0;
|
||||
app_stay_awake(BOOT_STAY_AWAKE_MS);
|
||||
break;
|
||||
if (wheel >= WHEEL_COUNT) {
|
||||
return;
|
||||
}
|
||||
const sensor_settings_t &s = g_settings.wheels[wheel];
|
||||
uint8_t frame[TPMS_TX_BYTES];
|
||||
uint8_t payload[TPMS_PAYLOAD_LEN];
|
||||
if (!tpms_build_frame(frame, s.id, s.pressure_kpa10, (int8_t)s.temp_c,
|
||||
g_settings.flags)
|
||||
|| !tpms_build_payload(payload, s.id, s.pressure_kpa10,
|
||||
(int8_t)s.temp_c, g_settings.flags)) {
|
||||
Serial.println(F("BLAD: nieprawidlowa konfiguracja ramki"));
|
||||
return;
|
||||
}
|
||||
Serial.printf("%s payload:", WHEEL_NAMES[wheel]);
|
||||
for (uint8_t i = 0; i < TPMS_PAYLOAD_LEN; ++i) {
|
||||
Serial.printf(" %02X", payload[i]);
|
||||
}
|
||||
Serial.printf("\n%s frame:", WHEEL_NAMES[wheel]);
|
||||
for (uint8_t i = 0; i < TPMS_TX_BYTES; ++i) {
|
||||
Serial.printf(" %02X", frame[i]);
|
||||
}
|
||||
Serial.println();
|
||||
}
|
||||
|
||||
void app_print_info(void)
|
||||
{
|
||||
Serial.printf("FW %s NVS v%u mode=%u wheel=%s errors=%lu\n", FW_VERSION,
|
||||
(unsigned)SETTINGS_VERSION, (unsigned)g_app->mode(),
|
||||
WHEEL_NAMES[g_app->active_wheel()],
|
||||
(unsigned long)g_app->last_error_count());
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; ++i) {
|
||||
const sensor_settings_t &s = g_settings.wheels[i];
|
||||
Serial.printf(" %s id=%06X pressure=%u.%u kPa temp=%d C\n",
|
||||
WHEEL_NAMES[i], (unsigned)s.id, s.pressure_kpa10 / 10u,
|
||||
s.pressure_kpa10 % 10u, (int)s.temp_c);
|
||||
}
|
||||
Serial.printf("flags=%08X OOK chip=%u us burst=%u gap=%u ms\n",
|
||||
(unsigned)g_settings.flags, TPMS_CHIP_US, g_settings.burst_frames,
|
||||
g_settings.frame_gap_ms);
|
||||
Serial.printf("RF=%.2f MHz power=%d dBm intervals=%lu/%lu/%lu s\n",
|
||||
g_settings.frequency_mhz, g_settings.tx_power_dbm,
|
||||
(unsigned long)g_settings.normal_interval_s,
|
||||
(unsigned long)g_settings.ignition_interval_s,
|
||||
(unsigned long)g_settings.parking_interval_s);
|
||||
Serial.printf("Vcc=%u mV (nie zmienia flag TPMS)\n", (unsigned)supply_mv);
|
||||
}
|
||||
|
||||
static void sync_ui(void)
|
||||
{
|
||||
static AppMode previous_mode = AppMode::NORMAL;
|
||||
static uint8_t previous_wheel = UINT8_MAX;
|
||||
AppMode mode = g_app->mode();
|
||||
uint8_t wheel = g_app->active_wheel();
|
||||
if (mode != previous_mode || wheel != previous_wheel) {
|
||||
ui_set_pattern(mode == AppMode::LEARN ? UI_PAT_LEARN
|
||||
: mode == AppMode::SINGLE ? UI_PAT_SINGLE : UI_PAT_NORMAL);
|
||||
if (mode != AppMode::NORMAL) {
|
||||
ui_blink_count((uint8_t)(wheel + 1u));
|
||||
}
|
||||
previous_mode = mode;
|
||||
previous_wheel = wheel;
|
||||
}
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Cykl nadawczy w trybie NORMAL */
|
||||
/* ------------------------------------------------------------------ */
|
||||
static uint32_t compute_interval(void)
|
||||
{
|
||||
if (rtc_interval_s != 0) {
|
||||
return rtc_interval_s;
|
||||
}
|
||||
#if PIN_ACC < 0
|
||||
/* Bez wejscia ACC stale pracujemy z interwalem podstawowym - logika
|
||||
* "5 min po zaniku ACC" nie ma wtedy zastosowania. */
|
||||
return (uint32_t)TX_INTERVAL_S;
|
||||
#else
|
||||
uint64_t now_ms = power_elapsed_ms();
|
||||
if (digitalRead(PIN_ACC) == HIGH) {
|
||||
rtc_last_acc_ms = now_ms;
|
||||
return (uint32_t)TX_INTERVAL_IGNITION_S;
|
||||
}
|
||||
if (now_ms - rtc_last_acc_ms > (uint64_t)ACC_GRACE_MS) {
|
||||
return PARKING_SHUTDOWN ? 0u : (uint32_t)TX_INTERVAL_PARKING_S;
|
||||
}
|
||||
return (uint32_t)TX_INTERVAL_S;
|
||||
#endif
|
||||
}
|
||||
|
||||
static void tx_cycle(void)
|
||||
{
|
||||
refresh_power();
|
||||
app_send_burst_all();
|
||||
}
|
||||
|
||||
/* Czy ktorekolwiek zrodlo budzenia poziomowego jest aktywne? */
|
||||
static bool wake_sources_active(void)
|
||||
{
|
||||
if (ui_button_down() || digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL) {
|
||||
@@ -308,244 +162,93 @@ static bool wake_sources_active(void)
|
||||
return false;
|
||||
}
|
||||
|
||||
static void go_sleep(uint32_t seconds)
|
||||
static void go_sleep(void)
|
||||
{
|
||||
/* Nie spij, dopoki przycisk jest wcisniety lub LF aktywne - EXT0/EXT1
|
||||
* dzialaja poziomowo, wiec sen przy aktywnym zrodle = natychmiastowa
|
||||
* petla wybudzen. Dajemy krotki margines i wracamy do petli. */
|
||||
if (wake_sources_active()) {
|
||||
app_stay_awake(500);
|
||||
if (g_app->mode() != AppMode::NORMAL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (wake_sources_active()) {
|
||||
app_stay_awake(500u);
|
||||
return;
|
||||
}
|
||||
uint32_t seconds = g_app->interval_s(ignition_on());
|
||||
ui_set_pattern(UI_PAT_OFF);
|
||||
digitalWrite(PIN_LED, LOW);
|
||||
|
||||
Serial.printf("sleep %us\n", (unsigned)seconds);
|
||||
Serial.printf("sleep %lu s\n", (unsigned long)seconds);
|
||||
Serial.flush();
|
||||
power_deep_sleep(seconds); // nie wraca
|
||||
power_deep_sleep(seconds);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
void setup(void)
|
||||
{
|
||||
Serial.begin(SERIAL_BAUD);
|
||||
ui_init();
|
||||
power_init();
|
||||
settings_store_begin();
|
||||
console_init();
|
||||
|
||||
#if PIN_LF_TRIGGER >= 0
|
||||
pinMode(PIN_LF_TRIGGER, INPUT_PULLDOWN);
|
||||
lf_previous = digitalRead(PIN_LF_TRIGGER) == HIGH;
|
||||
#endif
|
||||
#if PIN_ACC >= 0
|
||||
/* INPUT (bez podciagania): dolna galazka dzielnika wymusza stan niski,
|
||||
* a wewnetrzny pulldown (~45 k) obciazylby dzielnik i zbil prog VIH. */
|
||||
pinMode(PIN_ACC, INPUT);
|
||||
#endif
|
||||
|
||||
if (rtc_magic != RTC_MAGIC) {
|
||||
rtc_magic = RTC_MAGIC;
|
||||
rtc_mode = APP_MODE_NORMAL;
|
||||
rtc_seq_idx = 0;
|
||||
rtc_single_wheel = 0;
|
||||
rtc_rot_idx = 0;
|
||||
rtc_wake_count = 0;
|
||||
rtc_interval_s = 0;
|
||||
rtc_flags = TPMS_FLAGS;
|
||||
rtc_last_acc_ms = 0;
|
||||
g_app = &app_state;
|
||||
bool radio_ready = radio_init(&g_settings);
|
||||
supply_mv = power_read_mv();
|
||||
Serial.printf("\nTPMS DIAG FW %s - DANE SZTUCZNE, NIE DO JAZDY\n", FW_VERSION);
|
||||
Serial.printf("NVS: %s; dostep=%s\n",
|
||||
settings_load_result_text(settings_store_last_load()),
|
||||
settings_store_available() ? "tak" : "nie");
|
||||
if (!radio_ready) {
|
||||
Serial.println(F("BLAD: brak CC1101; sprawdz 3V3/SPI"));
|
||||
}
|
||||
rtc_wake_count++;
|
||||
|
||||
bool radio_ok = radio_init();
|
||||
Serial.println();
|
||||
Serial.printf("TPMS simulator FW %s (config v%d) - SYMULATOR, dane sztuczne!\n",
|
||||
FW_VERSION, CONFIG_VERSION);
|
||||
if (!radio_ok) {
|
||||
Serial.println(F("BLAD: brak modulu CC1101 (sprawdz SPI)"));
|
||||
}
|
||||
|
||||
refresh_power();
|
||||
if (low_batt) {
|
||||
Serial.printf("OSTRZEZENIE: niskie napiecie zasilania %u mV!\n",
|
||||
(unsigned)supply_mv);
|
||||
if (power_low_battery(supply_mv)) {
|
||||
Serial.println(F("OSTRZEZENIE: niskie zasilanie emulatora"));
|
||||
}
|
||||
|
||||
esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
|
||||
uint32_t iv = compute_interval();
|
||||
|
||||
switch (cause) {
|
||||
case ESP_SLEEP_WAKEUP_TIMER:
|
||||
/* zwykly cykl - nadaj i spij bez czuwania */
|
||||
next_tx_ms = 0;
|
||||
stay_awake_until = 0;
|
||||
break;
|
||||
|
||||
case ESP_SLEEP_WAKEUP_EXT0:
|
||||
/* przycisk - obsluga gestu w petli, krotkie okno konsoli */
|
||||
Serial.println(F("wake: button"));
|
||||
next_tx_ms = UINT32_MAX; // nie nadawaj automatycznie
|
||||
stay_awake_until = millis() + BOOT_STAY_AWAKE_MS;
|
||||
break;
|
||||
|
||||
case ESP_SLEEP_WAKEUP_EXT1: {
|
||||
uint64_t st = esp_sleep_get_ext1_wakeup_status();
|
||||
Serial.printf("wake: ext1 mask=%08X%08X\n",
|
||||
(unsigned)(st >> 32), (unsigned)(st & 0xFFFFFFFFu));
|
||||
refresh_power();
|
||||
app_send_burst_wheel(active_wheel()); // aktywacja LF = natychmiast
|
||||
next_tx_ms = UINT32_MAX;
|
||||
stay_awake_until = millis() + BOOT_STAY_AWAKE_MS;
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
Serial.println(F("wake: power-on"));
|
||||
next_tx_ms = 0;
|
||||
stay_awake_until = millis() + BOOT_STAY_AWAKE_MS;
|
||||
break;
|
||||
}
|
||||
|
||||
if (rtc_mode == APP_MODE_LEARN) {
|
||||
ui_set_pattern(UI_PAT_LEARN);
|
||||
learn_window_start = millis();
|
||||
learn_session_start = millis();
|
||||
next_tx_ms = 0;
|
||||
stay_awake_until = millis() + LEARN_TOTAL_TIMEOUT_MS;
|
||||
}
|
||||
else if (rtc_mode == APP_MODE_SINGLE) {
|
||||
ui_set_pattern(UI_PAT_SINGLE);
|
||||
single_start = millis();
|
||||
next_tx_ms = 0;
|
||||
stay_awake_until = millis() +
|
||||
(SINGLE_TIMEOUT_MS ? SINGLE_TIMEOUT_MS : 3600000u);
|
||||
}
|
||||
else {
|
||||
ui_set_pattern(low_batt ? UI_PAT_LOWBAT : UI_PAT_NORMAL);
|
||||
}
|
||||
|
||||
/* Po wybudzeniu przyciskiem/LF obsluzylismy juz akcje - nie powtarzaj
|
||||
* cyklu natychmiast, tylko odloz go o pelny okres. */
|
||||
if (cause == ESP_SLEEP_WAKEUP_EXT0 || cause == ESP_SLEEP_WAKEUP_EXT1) {
|
||||
if (rtc_mode != APP_MODE_NORMAL) {
|
||||
next_tx_ms = millis() + LEARN_TX_PERIOD_MS;
|
||||
}
|
||||
}
|
||||
bool transmit = cause != ESP_SLEEP_WAKEUP_EXT0 && cause != ESP_SLEEP_WAKEUP_EXT1;
|
||||
g_app->begin(millis(), transmit);
|
||||
#if PIN_LF_TRIGGER >= 0
|
||||
/* LF ciagle aktywne = brak nowego zbocza = brak kolejnego bursta */
|
||||
lf_prev = (digitalRead(PIN_LF_TRIGGER) == HIGH);
|
||||
if (cause == ESP_SLEEP_WAKEUP_EXT1) {
|
||||
g_app->send_current();
|
||||
}
|
||||
#endif
|
||||
|
||||
Serial.printf("Vcc=%u mV tryb=%d interwal=%us\n", (unsigned)supply_mv,
|
||||
(int)rtc_mode, (unsigned)iv);
|
||||
stay_awake_until = cause == ESP_SLEEP_WAKEUP_TIMER
|
||||
? millis() : millis() + BOOT_STAY_AWAKE_MS;
|
||||
sync_ui();
|
||||
app_print_info();
|
||||
Serial.println(F("gotowy ('help' - komendy)"));
|
||||
Serial.println(F("gotowy; help = komendy; stay 60 = konsola 60 s"));
|
||||
}
|
||||
|
||||
void loop(void)
|
||||
{
|
||||
uint32_t now = millis();
|
||||
|
||||
ui_update();
|
||||
|
||||
/* gesty przycisku */
|
||||
ui_event_t ev = ui_poll();
|
||||
if (ev == UI_EV_SHORT) {
|
||||
if (rtc_mode == APP_MODE_NORMAL) {
|
||||
refresh_power();
|
||||
app_send_burst_all(); // "aktywuj kolo" - nadaj teraz
|
||||
switch (ui_poll()) {
|
||||
case UI_EV_SHORT: g_app->short_press(now); break;
|
||||
case UI_EV_LONG: g_app->long_press(now); break;
|
||||
case UI_EV_VERYLONG: g_app->very_long_press(now); break;
|
||||
default: break;
|
||||
}
|
||||
else {
|
||||
app_next_wheel(); // learn/single: kolejne kolo
|
||||
}
|
||||
}
|
||||
else if (ev == UI_EV_LONG) {
|
||||
if (rtc_mode == APP_MODE_LEARN) {
|
||||
app_set_mode(APP_MODE_NORMAL, 0);
|
||||
}
|
||||
else {
|
||||
app_set_mode(APP_MODE_LEARN, 0);
|
||||
}
|
||||
}
|
||||
else if (ev == UI_EV_VERYLONG) {
|
||||
if (rtc_mode == APP_MODE_SINGLE) {
|
||||
app_set_mode(APP_MODE_NORMAL, 0);
|
||||
}
|
||||
else {
|
||||
app_set_mode(APP_MODE_SINGLE, active_wheel());
|
||||
}
|
||||
}
|
||||
|
||||
console_poll();
|
||||
|
||||
#if PIN_LF_TRIGGER >= 0
|
||||
/* aktywacja LF tez dziala "na zywo" (nie tylko przez budzenie) */
|
||||
{
|
||||
bool lf = (digitalRead(PIN_LF_TRIGGER) == HIGH);
|
||||
if (lf && !lf_prev) {
|
||||
refresh_power();
|
||||
app_send_burst_wheel(active_wheel());
|
||||
/* po recznej transmisji odloz cykl - bez tego LF moglby
|
||||
* wywolac 2-3 bursty zamiast jednego */
|
||||
if (rtc_mode != APP_MODE_NORMAL) {
|
||||
next_tx_ms = millis() + LEARN_TX_PERIOD_MS;
|
||||
}
|
||||
}
|
||||
lf_prev = lf;
|
||||
bool lf = digitalRead(PIN_LF_TRIGGER) == HIGH;
|
||||
if (lf && !lf_previous) {
|
||||
g_app->send_current();
|
||||
app_stay_awake(BOOT_STAY_AWAKE_MS);
|
||||
}
|
||||
lf_previous = lf;
|
||||
#endif
|
||||
g_app->tick(millis(), ignition_on());
|
||||
sync_ui();
|
||||
|
||||
if (request_sleep) {
|
||||
request_sleep = false;
|
||||
go_sleep(compute_interval());
|
||||
}
|
||||
|
||||
switch (rtc_mode) {
|
||||
case APP_MODE_LEARN:
|
||||
if ((int32_t)(now - next_tx_ms) >= 0) {
|
||||
refresh_power();
|
||||
app_send_burst_wheel(active_wheel());
|
||||
next_tx_ms = now + LEARN_TX_PERIOD_MS;
|
||||
}
|
||||
if (now - learn_window_start >= LEARN_WINDOW_MS) {
|
||||
if (LEARN_WINDOW_EXPIRE_TO_NORMAL) {
|
||||
Serial.println(F("okno learn minelo - powrot do NORMAL"));
|
||||
app_set_mode(APP_MODE_NORMAL, 0);
|
||||
}
|
||||
else if (rtc_seq_idx + 1u >= WHEEL_COUNT) {
|
||||
Serial.println(F("learn ukonczony - powrot do NORMAL"));
|
||||
app_set_mode(APP_MODE_NORMAL, 0);
|
||||
}
|
||||
else {
|
||||
app_next_wheel();
|
||||
}
|
||||
}
|
||||
if (now - learn_session_start >= LEARN_TOTAL_TIMEOUT_MS) {
|
||||
Serial.println(F("timeout learn - powrot do NORMAL"));
|
||||
app_set_mode(APP_MODE_NORMAL, 0);
|
||||
}
|
||||
break;
|
||||
|
||||
case APP_MODE_SINGLE:
|
||||
if ((int32_t)(now - next_tx_ms) >= 0) {
|
||||
refresh_power();
|
||||
app_send_burst_wheel(active_wheel());
|
||||
next_tx_ms = now + LEARN_TX_PERIOD_MS;
|
||||
}
|
||||
if (SINGLE_TIMEOUT_MS && now - single_start >= SINGLE_TIMEOUT_MS) {
|
||||
Serial.println(F("timeout single - powrot do NORMAL"));
|
||||
app_set_mode(APP_MODE_NORMAL, 0);
|
||||
}
|
||||
break;
|
||||
|
||||
default: /* NORMAL */
|
||||
if (next_tx_ms != UINT32_MAX && (int32_t)(now - next_tx_ms) >= 0) {
|
||||
uint32_t iv = compute_interval();
|
||||
tx_cycle();
|
||||
next_tx_ms = now + (iv ? iv : 3600u) * 1000u;
|
||||
}
|
||||
if ((int32_t)(now - stay_awake_until) >= 0) {
|
||||
go_sleep(compute_interval());
|
||||
}
|
||||
break;
|
||||
go_sleep();
|
||||
} else if (g_app->mode() == AppMode::NORMAL
|
||||
&& (int32_t)(millis() - stay_awake_until) >= 0) {
|
||||
go_sleep();
|
||||
}
|
||||
}
|
||||
+18
-55
@@ -1,19 +1,8 @@
|
||||
/*
|
||||
* power.cpp - zasilanie, pomiar napiecia, deep sleep
|
||||
*
|
||||
* Zastrzezenie: urzadzenie diagnostyczne/testowe - symulator TPMS
|
||||
* dostarcza sztuczne dane cisnienia i nie zastepuje prawdziwych czujnikow.
|
||||
*
|
||||
* Budzet pradu (patrz README):
|
||||
* - ESP32 deep sleep: ~10 uA (WiFi/BT nie sa wcale inicjalizowane)
|
||||
* - CC1101 w SLEEP (SPWD): < 1 uA
|
||||
* - gpio_hold trzyma linie CC1101 w stanach niskich/wysokiej CS
|
||||
*/
|
||||
/* Zasilanie i deep sleep. Stan zasilania NIE zmienia pol protokolu TPMS. */
|
||||
#include <Arduino.h>
|
||||
#include <esp_sleep.h>
|
||||
#include <driver/gpio.h>
|
||||
#include <esp32-hal-bt.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "config.h"
|
||||
#include "power.h"
|
||||
@@ -21,28 +10,30 @@
|
||||
|
||||
void power_init(void)
|
||||
{
|
||||
/* Zwolnij hold z poprzedniego snu - po deep sleep piny sa zatrzymane. */
|
||||
gpio_deep_sleep_hold_dis();
|
||||
gpio_hold_dis((gpio_num_t)PIN_CC1101_CS);
|
||||
gpio_hold_dis((gpio_num_t)PIN_CC1101_SCK);
|
||||
gpio_hold_dis((gpio_num_t)PIN_CC1101_MOSI);
|
||||
|
||||
/* WiFi nie jest wcale uruchamiany (brak init), BT wylaczamy defensywnie. */
|
||||
btStop();
|
||||
|
||||
#if PIN_VBAT_ADC >= 0
|
||||
analogSetPinAttenuation(PIN_VBAT_ADC, ADC_11db);
|
||||
#endif
|
||||
}
|
||||
|
||||
uint32_t power_read_mv(void)
|
||||
{
|
||||
#if PIN_VBAT_ADC < 0
|
||||
return 0u;
|
||||
#else
|
||||
uint64_t sum = 0;
|
||||
for (int i = 0; i < VBAT_SAMPLES; i++) {
|
||||
for (uint8_t i = 0; i < VBAT_SAMPLES; ++i) {
|
||||
sum += analogReadMilliVolts(PIN_VBAT_ADC);
|
||||
}
|
||||
uint32_t pin_mv = (uint32_t)(sum / VBAT_SAMPLES);
|
||||
float v = (float)pin_mv * ((VBAT_DIVIDER_R1 + VBAT_DIVIDER_R2) / VBAT_DIVIDER_R2)
|
||||
float value = (float)pin_mv * ((VBAT_DIVIDER_R1 + VBAT_DIVIDER_R2) / VBAT_DIVIDER_R2)
|
||||
* VBAT_CAL;
|
||||
return (uint32_t)(v + 0.5f);
|
||||
return (uint32_t)(value + 0.5f);
|
||||
#endif
|
||||
}
|
||||
|
||||
bool power_low_battery(uint32_t mv)
|
||||
@@ -52,55 +43,27 @@ bool power_low_battery(uint32_t mv)
|
||||
|
||||
void power_deep_sleep(uint32_t seconds)
|
||||
{
|
||||
/* CC1101 w sleep + bezpieczne stany linii (CS=1 utrzymuje SPWD). */
|
||||
radio_sleep();
|
||||
|
||||
/* Zatrzymaj piny w tych stanach na czas snu. */
|
||||
gpio_hold_en((gpio_num_t)PIN_CC1101_CS);
|
||||
gpio_hold_en((gpio_num_t)PIN_CC1101_SCK);
|
||||
gpio_hold_en((gpio_num_t)PIN_CC1101_MOSI);
|
||||
gpio_deep_sleep_hold_en();
|
||||
|
||||
/* Budzik RTC. */
|
||||
esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_ALL);
|
||||
if (seconds > 0) {
|
||||
if (esp_sleep_enable_timer_wakeup((uint64_t)seconds * 1000000ULL) != ESP_OK) {
|
||||
Serial.println(F("power: blad konfiguracji budzika RTC"));
|
||||
}
|
||||
/* PARKING_SHUTDOWN nie istnieje: kazdy sen ma budzik i nie mozna
|
||||
* zatrzymac urzadzenia do czasu recznego wybudzenia. */
|
||||
if (seconds < SETTINGS_INTERVAL_MIN_S) {
|
||||
seconds = SETTINGS_INTERVAL_MIN_S;
|
||||
}
|
||||
esp_sleep_enable_timer_wakeup((uint64_t)seconds * 1000000ULL);
|
||||
|
||||
/* Przycisk jako zrodlo EXT0 (poziom konfigurowalny). */
|
||||
#if PIN_BUTTON >= 0
|
||||
if (esp_sleep_enable_ext0_wakeup((gpio_num_t)PIN_BUTTON, BTN_ACTIVE_LEVEL)
|
||||
!= ESP_OK) {
|
||||
Serial.println(F("power: blad konfiguracji EXT0 (pin nie RTC?)"));
|
||||
}
|
||||
esp_sleep_enable_ext0_wakeup((gpio_num_t)PIN_BUTTON, BTN_ACTIVE_LEVEL);
|
||||
#endif
|
||||
|
||||
/* Opcjonalne wejscie LF 125 kHz (impuls wysoki) jako EXT1.
|
||||
* Uwaga: poziom musi byc niski w spoczynku, inaczej ESP32 obudzi sie
|
||||
* natychmiast po wejsciu w sen. */
|
||||
uint64_t ext1_mask = 0;
|
||||
#if PIN_LF_TRIGGER >= 0
|
||||
ext1_mask |= (1ULL << PIN_LF_TRIGGER);
|
||||
uint64_t ext1_mask = 1ULL << PIN_LF_TRIGGER;
|
||||
esp_sleep_enable_ext1_wakeup(ext1_mask, ESP_EXT1_WAKEUP_ANY_HIGH);
|
||||
#endif
|
||||
if (ext1_mask != 0) {
|
||||
if (esp_sleep_enable_ext1_wakeup(ext1_mask, ESP_EXT1_WAKEUP_ANY_HIGH)
|
||||
!= ESP_OK) {
|
||||
Serial.println(F("power: blad konfiguracji EXT1 (pin nie RTC?)"));
|
||||
}
|
||||
}
|
||||
|
||||
esp_deep_sleep_start();
|
||||
}
|
||||
|
||||
uint64_t power_elapsed_ms(void)
|
||||
{
|
||||
/* System time jest utrzymywany przez RTC i przywracany po deep sleep,
|
||||
* wiec licznik rosnie o rzeczywisty czas (takze ten spedzony w snie),
|
||||
* a nie o planowany interwal - wczesniejsze wybudzenia (przycisk/LF)
|
||||
* nie zaklamuja wtedy logiki "5 min po zaniku ACC". */
|
||||
struct timeval tv;
|
||||
gettimeofday(&tv, NULL);
|
||||
return (uint64_t)tv.tv_sec * 1000u + (uint64_t)(tv.tv_usec / 1000);
|
||||
}
|
||||
+3
-28
@@ -1,37 +1,12 @@
|
||||
/*
|
||||
* power.h - zasilanie, pomiar napiecia, deep sleep
|
||||
*/
|
||||
#ifndef TPMS_POWER_H
|
||||
#define TPMS_POWER_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Wywolac raz po starcie (zwalnia gpio_hold z poprzedniego snu). */
|
||||
void power_init(void);
|
||||
|
||||
/* Pomiar napiecia zasilania [mV] (dzielnik ADC + kalibracja). */
|
||||
uint32_t power_read_mv(void);
|
||||
bool power_low_battery(uint32_t mv); /* tylko ostrzezenie o zasilaniu emulatora */
|
||||
void power_deep_sleep(uint32_t seconds); /* zawsze ma budzik RTC; nie wraca */
|
||||
|
||||
/* Decyzja o fladze "niska bateria" (prog LOWBATT_THRESHOLD_MV). */
|
||||
bool power_low_battery(uint32_t mV);
|
||||
|
||||
/* Przygotuj i wejdz w deep sleep na `seconds` (0 = bez budzika, tylko
|
||||
* przycisk/LF). Funkcja nie wraca. */
|
||||
void power_deep_sleep(uint32_t seconds);
|
||||
|
||||
/* Czas rzeczywisty [ms] od startu systemu - licznik RTC przetrwuje deep
|
||||
* sleep (ESP32 przywraca czas z RTC po wybudzeniu), wiec rosnie o rzeczywisty
|
||||
* czas spedzony w snie, nie o planowany interwal. Uzywane do logiki
|
||||
* "5 min po zaniku ACC". */
|
||||
uint64_t power_elapsed_ms(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* TPMS_POWER_H */
|
||||
+50
-83
@@ -1,14 +1,4 @@
|
||||
/*
|
||||
* radio.cpp - konfiguracja CC1101 i nadawanie ramek TPMS
|
||||
*
|
||||
* Modul: CC1101 po SPI (SCK=18, MISO=19, MOSI=23, CS=5, GDO0=2).
|
||||
* Biblioteka: SmartRC-CC1101-Driver-Lib (LSatan), naglowek zgodnosciowy
|
||||
* ELECHOUSE_CC1101_SRC_DRV.h - obslugiwane sa obie wersje API (2.x i 3.x).
|
||||
*
|
||||
* Nadawanie: tryb FIFO (pakiet o stalej dlugosci, bez preambuly/sync/CRC
|
||||
* CC1101 - wszystkie bity, lacznie z preambula i wlasna suma kontrolna,
|
||||
* leza w naszym buforze). Kolejnosc bitow MSB first.
|
||||
*/
|
||||
/* CC1101: surowe 30 bajtow Manchester w fixed-length FIFO, bez wstawek HW. */
|
||||
#include <Arduino.h>
|
||||
#include <SPI.h>
|
||||
#include <ELECHOUSE_CC1101_SRC_DRV.h>
|
||||
@@ -20,67 +10,54 @@
|
||||
|
||||
static bool radio_ok = false;
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Inicjalizacja pinow */
|
||||
/* Wymagana biblioteka SmartRC-CC1101-Driver-Lib >= 2.5.7 */
|
||||
/* (wspolne API setSpiPin/setGDO0 dla wersji 2.5.x i 3.x; */
|
||||
/* starsze 1.x mialy setSCK/setMISO/... - nie sa obslugiwane). */
|
||||
/* ------------------------------------------------------------------ */
|
||||
static void radio_set_pins(void)
|
||||
{
|
||||
ELECHOUSE_cc1101.setSpiPin(PIN_CC1101_SCK, PIN_CC1101_MISO,
|
||||
PIN_CC1101_MOSI, PIN_CC1101_CS);
|
||||
ELECHOUSE_cc1101.setGDO0(PIN_CC1101_GDO0);
|
||||
}
|
||||
|
||||
bool radio_init(void)
|
||||
bool radio_init(const settings_t *cfg)
|
||||
{
|
||||
radio_ok = false;
|
||||
if (cfg == NULL) {
|
||||
return false;
|
||||
}
|
||||
gpio_deep_sleep_hold_dis();
|
||||
gpio_hold_dis((gpio_num_t)PIN_CC1101_CS);
|
||||
gpio_hold_dis((gpio_num_t)PIN_CC1101_SCK);
|
||||
gpio_hold_dis((gpio_num_t)PIN_CC1101_MOSI);
|
||||
|
||||
radio_set_pins();
|
||||
ELECHOUSE_cc1101.setSpiPin(PIN_CC1101_SCK, PIN_CC1101_MISO,
|
||||
PIN_CC1101_MOSI, PIN_CC1101_CS);
|
||||
ELECHOUSE_cc1101.setGDO0(PIN_CC1101_GDO0);
|
||||
ELECHOUSE_cc1101.Init();
|
||||
|
||||
radio_ok = ELECHOUSE_cc1101.getCC1101();
|
||||
if (!radio_ok) {
|
||||
if (!ELECHOUSE_cc1101.getCC1101()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
ELECHOUSE_cc1101.setCCMode(1); // tryb wewnetrzny, dane z FIFO
|
||||
if (TPMS_MODULATION == MODE_FSK) {
|
||||
ELECHOUSE_cc1101.setModulation(0); // 2-FSK
|
||||
ELECHOUSE_cc1101.setDeviation(TPMS_DEVIATION_KHZ);
|
||||
}
|
||||
else {
|
||||
ELECHOUSE_cc1101.setModulation(2); // ASK/OOK
|
||||
}
|
||||
ELECHOUSE_cc1101.setMHZ(TPMS_FREQUENCY_MHZ);
|
||||
ELECHOUSE_cc1101.setDRate(1000.0f / (float)TPMS_CHIP_US); // kBaud (8.33)
|
||||
ELECHOUSE_cc1101.setPA(TPMS_TX_POWER_DBM);
|
||||
ELECHOUSE_cc1101.setCCMode(1);
|
||||
ELECHOUSE_cc1101.setModulation(2); /* ASK/OOK; brak profilu FSK. */
|
||||
ELECHOUSE_cc1101.setMHZ(cfg->frequency_mhz);
|
||||
ELECHOUSE_cc1101.setDRate(1000.0f / (float)TPMS_CHIP_US);
|
||||
ELECHOUSE_cc1101.setPA(cfg->tx_power_dbm);
|
||||
ELECHOUSE_cc1101.setChannel(0);
|
||||
|
||||
ELECHOUSE_cc1101.setSyncMode(0); // bez preambuly/sync CC1101
|
||||
/* SYNC_MODE=0: packet engine nie dodaje preambuly ani slowa sync. */
|
||||
ELECHOUSE_cc1101.setSyncMode(0);
|
||||
ELECHOUSE_cc1101.setPRE(0);
|
||||
ELECHOUSE_cc1101.setAdrChk(0);
|
||||
ELECHOUSE_cc1101.setAddr(0);
|
||||
ELECHOUSE_cc1101.setWhiteData(0); // bez whiteningu
|
||||
ELECHOUSE_cc1101.setManchester(0); // Manchester kodujemy sami
|
||||
ELECHOUSE_cc1101.setWhiteData(0);
|
||||
ELECHOUSE_cc1101.setManchester(0);
|
||||
ELECHOUSE_cc1101.setFEC(0);
|
||||
ELECHOUSE_cc1101.setCrc(0); // wlasna suma kontrolna protokolu
|
||||
ELECHOUSE_cc1101.setCrc(0);
|
||||
ELECHOUSE_cc1101.setCRC_AF(0);
|
||||
ELECHOUSE_cc1101.setAppendStatus(0);
|
||||
ELECHOUSE_cc1101.setDcFilterOff(0);
|
||||
ELECHOUSE_cc1101.setPktFormat(0); // normalny tryb FIFO
|
||||
ELECHOUSE_cc1101.setLengthConfig(0); // stala dlugosc pakietu
|
||||
ELECHOUSE_cc1101.setPktFormat(0);
|
||||
ELECHOUSE_cc1101.setLengthConfig(0);
|
||||
ELECHOUSE_cc1101.setPacketLength(TPMS_TX_BYTES);
|
||||
radio_ok = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool radio_send_frame(const uint8_t *buf, uint8_t len)
|
||||
{
|
||||
if (!radio_ok) {
|
||||
if (!radio_ok || buf == NULL || len != TPMS_TX_BYTES) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -89,48 +66,40 @@ bool radio_send_frame(const uint8_t *buf, uint8_t len)
|
||||
ELECHOUSE_cc1101.SpiWriteBurstReg(CC1101_TXFIFO, (uint8_t *)buf, len);
|
||||
ELECHOUSE_cc1101.SpiStrobe(CC1101_STX);
|
||||
|
||||
/* Pelny czas serializacji bufora na antenie: sprzet wysyla dokladnie
|
||||
* len*8 chipow z predkoscia DRate. UWAGA: TXBYTES == 0 NIE oznacza
|
||||
* konca transmisji - po oproznieniu FIFO ostatni bajt jest dopiero
|
||||
* w rejestrze przesuwnym (8 chipow = 8*TPMS_CHIP_US), wiec wczesniejsze
|
||||
* SIDLE obcialoby ogon ramki. Czekamy zatem na policzony czas + maly
|
||||
* margines i dopiero wtedy wychodzimy z TX. */
|
||||
uint32_t air_us = (uint32_t)len * 8u * (uint32_t)TPMS_CHIP_US + 1000u;
|
||||
uint32_t t0 = micros();
|
||||
while ((uint32_t)(micros() - t0) < air_us) {
|
||||
delayMicroseconds(500);
|
||||
/* Czekamy na MARCSTATE, nie na samo TXBYTES=0: ostatni bajt moze byc
|
||||
* jeszcze w rejestrze przesuwnym. Limit obejmuje start i pelny ogon. */
|
||||
const uint32_t timeout_us = (uint32_t)len * 8u * TPMS_CHIP_US + 10000u;
|
||||
const uint32_t start = micros();
|
||||
bool finished = false;
|
||||
bool underflow = false;
|
||||
while ((uint32_t)(micros() - start) < timeout_us) {
|
||||
uint8_t state = ELECHOUSE_cc1101.SpiReadStatus(CC1101_MARCSTATE) & 0x1Fu;
|
||||
if (state == 0x16u) { /* TXFIFO_UNDERFLOW */
|
||||
underflow = true;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Diagnostyka po zakonczeniu: dwa zgodne odczyty (errata CC1101),
|
||||
* kontrola niedopelnienia FIFO i tego, czy bufor zostal faktycznie
|
||||
* wyslany. Zwracamy blad zamiast udawac sukces. */
|
||||
bool ok = true;
|
||||
uint8_t txb = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES);
|
||||
uint8_t txb2 = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES);
|
||||
if (txb != txb2) {
|
||||
txb = txb2;
|
||||
if (state == 0x01u) { /* IDLE po automatycznym zakonczeniu pakietu */
|
||||
finished = true;
|
||||
break;
|
||||
}
|
||||
if (txb & 0x80u) { // TXFIFO_UNDERFLOW
|
||||
ok = false;
|
||||
}
|
||||
if ((txb & 0x7Fu) != 0) { // cos zostalo w FIFO - transmisja nie wyszla
|
||||
ok = false;
|
||||
delayMicroseconds(50);
|
||||
}
|
||||
|
||||
uint8_t txbytes = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES);
|
||||
underflow |= (txbytes & 0x80u) != 0u;
|
||||
ELECHOUSE_cc1101.SpiStrobe(CC1101_SIDLE);
|
||||
ELECHOUSE_cc1101.SpiStrobe(CC1101_SFTX);
|
||||
return ok;
|
||||
return finished && !underflow && (txbytes & 0x7Fu) == 0u;
|
||||
}
|
||||
|
||||
bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames)
|
||||
bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames,
|
||||
uint16_t gap_ms)
|
||||
{
|
||||
bool ok = true;
|
||||
for (uint8_t i = 0; i < frames; i++) {
|
||||
if (!radio_send_frame(buf, len)) {
|
||||
ok = false;
|
||||
}
|
||||
if (i + 1u < frames) {
|
||||
delay(TX_FRAME_GAP_MS);
|
||||
for (uint8_t i = 0; i < frames; ++i) {
|
||||
ok = radio_send_frame(buf, len) && ok;
|
||||
if ((uint8_t)(i + 1u) < frames) {
|
||||
delay(gap_ms);
|
||||
}
|
||||
}
|
||||
return ok;
|
||||
@@ -139,11 +108,9 @@ bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames)
|
||||
void radio_sleep(void)
|
||||
{
|
||||
if (radio_ok) {
|
||||
ELECHOUSE_cc1101.goSleep(); // SIDLE + SPWD (sen po zboczu CS)
|
||||
ELECHOUSE_cc1101.goSleep();
|
||||
radio_ok = false;
|
||||
}
|
||||
/* Zwolnij peryferium SPI i ustaw linie w stanach bezpiecznych:
|
||||
* CS=1 (utrzymuje CC1101 w sleep), SCK/MOSI=0, GDO0 wejscie z podciaganiem
|
||||
* w dol (CC1101 w sleep trzystanuje wyjscia). */
|
||||
SPI.end();
|
||||
pinMode(PIN_CC1101_CS, OUTPUT);
|
||||
digitalWrite(PIN_CC1101_CS, HIGH);
|
||||
|
||||
+6
-18
@@ -1,34 +1,22 @@
|
||||
/*
|
||||
* radio.h - sterowanie CC1101 (nadawanie ramek TPMS, tryb uśpienia)
|
||||
*/
|
||||
#ifndef TPMS_RADIO_H
|
||||
#define TPMS_RADIO_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include "config.h"
|
||||
#include <stdint.h>
|
||||
#include "settings.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Inicjalizacja SPI + konfiguracja CC1101. Zwraca false przy braku modulu. */
|
||||
bool radio_init(void);
|
||||
|
||||
/* Wyslij jeden bufor nadawczy (TPMS_TX_BYTES) - blokujace do zakonczenia
|
||||
* transmisji na eterze (dokladnie len*8 chipow, ~29 ms). Zwraca false
|
||||
* przy niedopelnieniu FIFO / niezakonczonej transmisji. */
|
||||
bool radio_init(const settings_t *cfg);
|
||||
bool radio_send_frame(const uint8_t *buf, uint8_t len);
|
||||
|
||||
/* Burst: n ramek tego samego bufora z odstepem TX_FRAME_GAP_MS.
|
||||
* Zwraca false, jesli ktorykolwiek z ramek sie nie udal. */
|
||||
bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames);
|
||||
|
||||
/* CC1101 do trybu SLEEP (<1 uA) + przygotowanie linii pod gpio_hold. */
|
||||
bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames,
|
||||
uint16_t gap_ms);
|
||||
void radio_sleep(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* TPMS_RADIO_H */
|
||||
#endif
|
||||
@@ -0,0 +1,172 @@
|
||||
#include "settings.h"
|
||||
|
||||
void settings_defaults(settings_t *out)
|
||||
{
|
||||
static const uint32_t ids[WHEEL_COUNT] = {
|
||||
0x2FC871u, 0x2EAAF9u, 0x3495ACu, 0x2FC780u,
|
||||
};
|
||||
*out = settings_t{};
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; ++i) {
|
||||
out->wheels[i].id = ids[i];
|
||||
out->wheels[i].pressure_kpa10 = 2600u;
|
||||
out->wheels[i].temp_c = 23;
|
||||
}
|
||||
out->flags = 0x4C900070u;
|
||||
out->normal_interval_s = 30u;
|
||||
out->ignition_interval_s = 30u;
|
||||
out->parking_interval_s = 120u;
|
||||
out->frequency_mhz = 433.92f;
|
||||
out->tx_power_dbm = -10;
|
||||
out->burst_frames = 3u;
|
||||
out->frame_gap_ms = 50u;
|
||||
}
|
||||
|
||||
bool settings_valid_id(uint32_t id)
|
||||
{
|
||||
return id > 0u && id < 0xFFFFFFu;
|
||||
}
|
||||
|
||||
bool settings_valid_tx_power(int power_dbm)
|
||||
{
|
||||
static const int8_t allowed[] = {-30, -20, -15, -10, -6, 0, 5};
|
||||
for (uint8_t i = 0; i < sizeof(allowed) / sizeof(allowed[0]); ++i) {
|
||||
if (power_dbm == allowed[i]) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool valid_interval(uint32_t value)
|
||||
{
|
||||
return value >= SETTINGS_INTERVAL_MIN_S && value <= SETTINGS_INTERVAL_MAX_S;
|
||||
}
|
||||
|
||||
bool settings_validate(const settings_t *cfg)
|
||||
{
|
||||
if (cfg == NULL) {
|
||||
return false;
|
||||
}
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; ++i) {
|
||||
if (!settings_valid_id(cfg->wheels[i].id)
|
||||
|| cfg->wheels[i].pressure_kpa10 > SETTINGS_PRESSURE_MAX_KPA10
|
||||
|| cfg->wheels[i].temp_c < -40 || cfg->wheels[i].temp_c > 85) {
|
||||
return false;
|
||||
}
|
||||
for (uint8_t j = (uint8_t)(i + 1u); j < WHEEL_COUNT; ++j) {
|
||||
if (cfg->wheels[i].id == cfg->wheels[j].id) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return valid_interval(cfg->normal_interval_s)
|
||||
&& valid_interval(cfg->ignition_interval_s)
|
||||
&& valid_interval(cfg->parking_interval_s)
|
||||
&& cfg->frequency_mhz >= 433.05f && cfg->frequency_mhz <= 434.79f
|
||||
&& settings_valid_tx_power(cfg->tx_power_dbm)
|
||||
&& cfg->burst_frames >= 1u && cfg->burst_frames <= 8u
|
||||
&& cfg->frame_gap_ms >= 20u && cfg->frame_gap_ms <= 500u;
|
||||
}
|
||||
|
||||
bool settings_set_id(settings_t *cfg, uint8_t wheel, uint32_t id)
|
||||
{
|
||||
if (cfg == NULL || wheel >= WHEEL_COUNT || !settings_valid_id(id)) {
|
||||
return false;
|
||||
}
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; ++i) {
|
||||
if (i != wheel && cfg->wheels[i].id == id) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
cfg->wheels[wheel].id = id;
|
||||
return true;
|
||||
}
|
||||
|
||||
void settings_generate_ids(settings_t *cfg, uint32_t seed)
|
||||
{
|
||||
if (seed == 0u) {
|
||||
seed = 0x6D2B79F5u;
|
||||
}
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; ++i) {
|
||||
uint32_t candidate;
|
||||
bool duplicate;
|
||||
do {
|
||||
seed ^= seed << 13;
|
||||
seed ^= seed >> 17;
|
||||
seed ^= seed << 5;
|
||||
candidate = (seed & 0xFFFFFFu);
|
||||
if (!settings_valid_id(candidate)) {
|
||||
candidate = (candidate % 0xFFFFFEu) + 1u;
|
||||
}
|
||||
duplicate = false;
|
||||
for (uint8_t j = 0; j < i; ++j) {
|
||||
duplicate |= cfg->wheels[j].id == candidate;
|
||||
}
|
||||
} while (duplicate);
|
||||
cfg->wheels[i].id = candidate;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t settings_crc32(const void *data, size_t len)
|
||||
{
|
||||
const uint8_t *p = (const uint8_t *)data;
|
||||
uint32_t crc = 0xFFFFFFFFu;
|
||||
for (size_t i = 0; i < len; ++i) {
|
||||
crc ^= p[i];
|
||||
for (uint8_t bit = 0; bit < 8u; ++bit) {
|
||||
crc = (crc >> 1) ^ ((crc & 1u) ? 0xEDB88320u : 0u);
|
||||
}
|
||||
}
|
||||
return ~crc;
|
||||
}
|
||||
|
||||
void settings_make_blob(const settings_t *cfg, settings_blob_t *blob)
|
||||
{
|
||||
*blob = settings_blob_t{};
|
||||
blob->magic = SETTINGS_MAGIC;
|
||||
blob->version = SETTINGS_VERSION;
|
||||
blob->size = sizeof(blob->values);
|
||||
blob->values = *cfg;
|
||||
blob->crc32 = settings_crc32(blob, offsetof(settings_blob_t, crc32));
|
||||
}
|
||||
|
||||
settings_load_result_t settings_decode_blob(const settings_blob_t *blob,
|
||||
settings_t *out)
|
||||
{
|
||||
if (blob == NULL || out == NULL) {
|
||||
return SETTINGS_LOAD_IO_ERROR;
|
||||
}
|
||||
if (blob->magic != SETTINGS_MAGIC) {
|
||||
return SETTINGS_LOAD_BAD_MAGIC;
|
||||
}
|
||||
if (blob->version != SETTINGS_VERSION) {
|
||||
return SETTINGS_LOAD_BAD_VERSION;
|
||||
}
|
||||
if (blob->size != sizeof(blob->values)) {
|
||||
return SETTINGS_LOAD_BAD_SIZE;
|
||||
}
|
||||
uint32_t expected = settings_crc32(blob, offsetof(settings_blob_t, crc32));
|
||||
if (expected != blob->crc32) {
|
||||
return SETTINGS_LOAD_BAD_CRC;
|
||||
}
|
||||
if (!settings_validate(&blob->values)) {
|
||||
return SETTINGS_LOAD_INVALID;
|
||||
}
|
||||
*out = blob->values;
|
||||
return SETTINGS_LOAD_OK;
|
||||
}
|
||||
|
||||
const char *settings_load_result_text(settings_load_result_t result)
|
||||
{
|
||||
switch (result) {
|
||||
case SETTINGS_LOAD_OK: return "OK";
|
||||
case SETTINGS_LOAD_EMPTY: return "pusta konfiguracja";
|
||||
case SETTINGS_LOAD_BAD_MAGIC: return "nieprawidlowy magic";
|
||||
case SETTINGS_LOAD_BAD_VERSION: return "nieobslugiwana wersja";
|
||||
case SETTINGS_LOAD_BAD_SIZE: return "nieprawidlowy rozmiar";
|
||||
case SETTINGS_LOAD_BAD_CRC: return "blad CRC";
|
||||
case SETTINGS_LOAD_INVALID: return "nieprawidlowe wartosci";
|
||||
case SETTINGS_LOAD_IO_ERROR: return "blad NVS";
|
||||
default: return "nieznany blad";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
/* Trwala konfiguracja uzytkownika; modul niezalezny od Arduino. */
|
||||
#ifndef TPMS_SETTINGS_H
|
||||
#define TPMS_SETTINGS_H
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define SETTINGS_MAGIC 0x54504D53u
|
||||
#define SETTINGS_VERSION 1u
|
||||
#define WHEEL_COUNT 4
|
||||
#define SETTINGS_PRESSURE_MAX_KPA10 6375u
|
||||
#define SETTINGS_INTERVAL_MIN_S 5u
|
||||
#define SETTINGS_INTERVAL_MAX_S 86400u
|
||||
|
||||
typedef enum {
|
||||
WHEEL_FL = 0,
|
||||
WHEEL_FR = 1,
|
||||
WHEEL_RR = 2,
|
||||
WHEEL_RL = 3,
|
||||
} wheel_t;
|
||||
|
||||
typedef struct {
|
||||
uint32_t id;
|
||||
uint16_t pressure_kpa10;
|
||||
int16_t temp_c;
|
||||
} sensor_settings_t;
|
||||
|
||||
typedef struct {
|
||||
sensor_settings_t wheels[WHEEL_COUNT];
|
||||
uint32_t flags;
|
||||
uint32_t normal_interval_s;
|
||||
uint32_t ignition_interval_s;
|
||||
uint32_t parking_interval_s;
|
||||
float frequency_mhz;
|
||||
int8_t tx_power_dbm;
|
||||
uint8_t burst_frames;
|
||||
uint16_t frame_gap_ms;
|
||||
} settings_t;
|
||||
|
||||
typedef struct {
|
||||
uint32_t magic;
|
||||
uint32_t version;
|
||||
uint32_t size;
|
||||
settings_t values;
|
||||
uint32_t crc32;
|
||||
} settings_blob_t;
|
||||
|
||||
typedef enum {
|
||||
SETTINGS_LOAD_OK = 0,
|
||||
SETTINGS_LOAD_EMPTY,
|
||||
SETTINGS_LOAD_BAD_MAGIC,
|
||||
SETTINGS_LOAD_BAD_VERSION,
|
||||
SETTINGS_LOAD_BAD_SIZE,
|
||||
SETTINGS_LOAD_BAD_CRC,
|
||||
SETTINGS_LOAD_INVALID,
|
||||
SETTINGS_LOAD_IO_ERROR,
|
||||
} settings_load_result_t;
|
||||
|
||||
void settings_defaults(settings_t *out);
|
||||
bool settings_valid_id(uint32_t id);
|
||||
bool settings_validate(const settings_t *cfg);
|
||||
bool settings_set_id(settings_t *cfg, uint8_t wheel, uint32_t id);
|
||||
void settings_generate_ids(settings_t *cfg, uint32_t seed);
|
||||
bool settings_valid_tx_power(int power_dbm);
|
||||
|
||||
uint32_t settings_crc32(const void *data, size_t len);
|
||||
void settings_make_blob(const settings_t *cfg, settings_blob_t *blob);
|
||||
settings_load_result_t settings_decode_blob(const settings_blob_t *blob,
|
||||
settings_t *out);
|
||||
const char *settings_load_result_text(settings_load_result_t result);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,73 @@
|
||||
#include <Arduino.h>
|
||||
#include <Preferences.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "settings_store.h"
|
||||
|
||||
static Preferences preferences;
|
||||
static settings_load_result_t last_load = SETTINGS_LOAD_EMPTY;
|
||||
static bool store_available = false;
|
||||
settings_t g_settings;
|
||||
|
||||
void settings_store_begin()
|
||||
{
|
||||
settings_defaults(&g_settings);
|
||||
store_available = preferences.begin("tpms", false);
|
||||
if (!store_available) {
|
||||
last_load = SETTINGS_LOAD_IO_ERROR;
|
||||
return;
|
||||
}
|
||||
|
||||
settings_blob_t blob;
|
||||
size_t length = preferences.getBytesLength("config");
|
||||
if (length == 0u) {
|
||||
last_load = SETTINGS_LOAD_EMPTY;
|
||||
settings_store_save();
|
||||
return;
|
||||
}
|
||||
if (length != sizeof(blob)
|
||||
|| preferences.getBytes("config", &blob, sizeof(blob)) != sizeof(blob)) {
|
||||
last_load = SETTINGS_LOAD_BAD_SIZE;
|
||||
} else {
|
||||
last_load = settings_decode_blob(&blob, &g_settings);
|
||||
}
|
||||
if (last_load != SETTINGS_LOAD_OK) {
|
||||
settings_defaults(&g_settings);
|
||||
/* Odzyskiwanie po uszkodzeniu: zapisz spojne domyslne. */
|
||||
settings_store_save();
|
||||
}
|
||||
}
|
||||
|
||||
bool settings_store_save()
|
||||
{
|
||||
if (!store_available || !settings_validate(&g_settings)) {
|
||||
return false;
|
||||
}
|
||||
settings_blob_t blob;
|
||||
settings_make_blob(&g_settings, &blob);
|
||||
if (preferences.putBytes("config", &blob, sizeof(blob)) != sizeof(blob)) {
|
||||
return false;
|
||||
}
|
||||
settings_blob_t verify;
|
||||
if (preferences.getBytes("config", &verify, sizeof(verify)) != sizeof(verify)
|
||||
|| memcmp(&blob, &verify, sizeof(blob)) != 0) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool settings_store_factory_reset()
|
||||
{
|
||||
settings_defaults(&g_settings);
|
||||
return settings_store_save();
|
||||
}
|
||||
|
||||
settings_load_result_t settings_store_last_load()
|
||||
{
|
||||
return last_load;
|
||||
}
|
||||
|
||||
bool settings_store_available()
|
||||
{
|
||||
return store_available;
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
#ifndef TPMS_SETTINGS_STORE_H
|
||||
#define TPMS_SETTINGS_STORE_H
|
||||
|
||||
#include "settings.h"
|
||||
|
||||
extern settings_t g_settings;
|
||||
|
||||
void settings_store_begin();
|
||||
bool settings_store_save();
|
||||
bool settings_store_factory_reset();
|
||||
settings_load_result_t settings_store_last_load();
|
||||
bool settings_store_available();
|
||||
|
||||
#endif
|
||||
+48
-63
@@ -1,97 +1,82 @@
|
||||
/*
|
||||
* tpms_frame.cpp - generator ramek TPMS Schrader EG53MA4 (bez zaleznosci
|
||||
* od Arduino - kompilowalne takze natywnie w testach).
|
||||
*
|
||||
* Zastrzezenie: symulator generuje sztuczne dane cisnienia/temperatury
|
||||
* i nie zastepuje prawdziwych czujnikow TPMS.
|
||||
*/
|
||||
/* Generator ramek EG53MA4. Sztuczne dane wylacznie do diagnostyki. */
|
||||
#include <string.h>
|
||||
#include "config.h"
|
||||
|
||||
#include "settings.h"
|
||||
#include "tpms_frame.h"
|
||||
|
||||
static void put_bit(uint8_t *buf, unsigned *nbits, unsigned v)
|
||||
static void put_bit(uint8_t *buf, unsigned *nbits, unsigned value)
|
||||
{
|
||||
if (v) {
|
||||
if (value != 0u) {
|
||||
buf[*nbits >> 3] |= (uint8_t)(0x80u >> (*nbits & 7u));
|
||||
}
|
||||
(*nbits)++;
|
||||
++(*nbits);
|
||||
}
|
||||
|
||||
/* G.E.T. Manchester: 0 -> "01", 1 -> "10" */
|
||||
/* Polaryzacja potwierdzona nagraniami i rtl_433 OOK_MC_ZEROBIT: 0=01, 1=10. */
|
||||
static void put_cell(uint8_t *buf, unsigned *nbits, unsigned bit)
|
||||
{
|
||||
if (bit) {
|
||||
put_bit(buf, nbits, 1);
|
||||
put_bit(buf, nbits, 0);
|
||||
}
|
||||
else {
|
||||
put_bit(buf, nbits, 0);
|
||||
put_bit(buf, nbits, 1);
|
||||
}
|
||||
put_bit(buf, nbits, bit != 0u ? 1u : 0u);
|
||||
put_bit(buf, nbits, bit != 0u ? 0u : 1u);
|
||||
}
|
||||
|
||||
uint8_t tpms_build_payload(uint8_t out[TPMS_PAYLOAD_LEN], uint32_t id,
|
||||
uint16_t press_kpa10, int8_t temp_c,
|
||||
uint32_t flags, bool low_batt)
|
||||
bool tpms_build_payload(uint8_t out[TPMS_PAYLOAD_LEN], uint32_t id,
|
||||
uint16_t press_kpa10, int8_t temp_c, uint32_t flags)
|
||||
{
|
||||
if (low_batt) {
|
||||
flags |= TPMS_FLAGS_LOWBAT_MASK;
|
||||
if (out == NULL || !settings_valid_id(id)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
/* cisnienie: 25 mbar/bit = 2.5 kPa/bit, zaokraglenie w gore do polowy bitu */
|
||||
int32_t press = ((int32_t)press_kpa10 + 12) / 25;
|
||||
if (press < 0) press = 0;
|
||||
if (press > 255) press = 255;
|
||||
int32_t pressure = ((int32_t)press_kpa10 + 12) / 25;
|
||||
if (pressure > 255) {
|
||||
pressure = 255;
|
||||
}
|
||||
|
||||
/* temperatura: protokol podaje stopnie Fahrenheita */
|
||||
int32_t num = 9 * (int32_t)temp_c + 160;
|
||||
int32_t tf = (num >= 0) ? (num + 2) / 5 : -((-num + 2) / 5);
|
||||
if (tf < 0) tf = 0;
|
||||
if (tf > 255) tf = 255;
|
||||
int32_t numerator = 9 * (int32_t)temp_c + 160;
|
||||
int32_t temperature_f = numerator >= 0
|
||||
? (numerator + 2) / 5 : -((-numerator + 2) / 5);
|
||||
if (temperature_f < 0) {
|
||||
temperature_f = 0;
|
||||
} else if (temperature_f > 255) {
|
||||
temperature_f = 255;
|
||||
}
|
||||
|
||||
out[0] = (uint8_t)(flags >> 24);
|
||||
out[1] = (uint8_t)(flags >> 16);
|
||||
out[2] = (uint8_t)(flags >> 8);
|
||||
out[3] = (uint8_t)(flags);
|
||||
out[3] = (uint8_t)flags;
|
||||
out[4] = (uint8_t)(id >> 16);
|
||||
out[5] = (uint8_t)(id >> 8);
|
||||
out[6] = (uint8_t)(id);
|
||||
out[7] = (uint8_t)press;
|
||||
out[8] = (uint8_t)tf;
|
||||
|
||||
uint8_t crc = 0;
|
||||
for (unsigned i = 0; i < 9; i++) {
|
||||
crc = (uint8_t)(crc + out[i]); // suma mod 256 (add_bytes w rtl_433)
|
||||
out[6] = (uint8_t)id;
|
||||
out[7] = (uint8_t)pressure;
|
||||
out[8] = (uint8_t)temperature_f;
|
||||
uint8_t checksum = 0;
|
||||
for (uint8_t i = 0; i < 9u; ++i) {
|
||||
checksum = (uint8_t)(checksum + out[i]);
|
||||
}
|
||||
out[9] = crc;
|
||||
return crc;
|
||||
out[9] = checksum;
|
||||
return true;
|
||||
}
|
||||
|
||||
void tpms_build_frame(uint8_t out[TPMS_TX_BYTES], uint32_t id,
|
||||
uint16_t press_kpa10, int8_t temp_c,
|
||||
uint32_t flags, bool low_batt)
|
||||
bool tpms_build_frame(uint8_t out[TPMS_TX_BYTES], uint32_t id,
|
||||
uint16_t press_kpa10, int8_t temp_c, uint32_t flags)
|
||||
{
|
||||
uint8_t payload[TPMS_PAYLOAD_LEN];
|
||||
tpms_build_payload(payload, id, press_kpa10, temp_c, flags, low_batt);
|
||||
if (out == NULL || !tpms_build_payload(payload, id, press_kpa10, temp_c, flags)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
memset(out, 0, TPMS_TX_BYTES);
|
||||
unsigned nbits = 0;
|
||||
|
||||
put_bit(out, &nbits, 1); // chip rozbiegowy (carrier on)
|
||||
|
||||
/* 39 bitow sync - pierwszy (zerowy) bit dopisuje odbiornik (MC_ZEROBIT) */
|
||||
for (unsigned i = 0; i < TPMS_SYNC_BITS - 1; i++) {
|
||||
put_cell(out, &nbits, 0);
|
||||
put_bit(out, &nbits, 1u); /* chip startowy */
|
||||
for (unsigned i = 0; i < TPMS_SYNC_BITS - 1u; ++i) {
|
||||
put_cell(out, &nbits, 0u);
|
||||
}
|
||||
|
||||
/* 80 bitow payloadu */
|
||||
for (unsigned b = 0; b < 8u * TPMS_PAYLOAD_LEN; b++) {
|
||||
unsigned bit = (payload[b >> 3] >> (7 - (b & 7u))) & 1u;
|
||||
put_cell(out, &nbits, bit);
|
||||
for (unsigned bit = 0; bit < 8u * TPMS_PAYLOAD_LEN; ++bit) {
|
||||
unsigned value = (payload[bit >> 3] >> (7u - (bit & 7u))) & 1u;
|
||||
put_cell(out, &nbits, value);
|
||||
}
|
||||
|
||||
/* padding do granicy bajtu - dla OOK sa to chipy "off" = cisza w eterze */
|
||||
while (nbits % 8u) {
|
||||
put_bit(out, &nbits, 0);
|
||||
while ((nbits & 7u) != 0u) {
|
||||
put_bit(out, &nbits, 0u);
|
||||
}
|
||||
return nbits == TPMS_TX_CHIPS;
|
||||
}
|
||||
+13
-50
@@ -1,70 +1,33 @@
|
||||
/*
|
||||
* tpms_frame.h - generator ramek TPMS Schrader EG53MA4
|
||||
*
|
||||
* Zastrzezenie: dane sa sztuczne (diagnostyka/testy), nie zastepuja
|
||||
* prawdziwych czujnikow TPMS.
|
||||
*
|
||||
* Ramka na zrzuconej warstwie bitowej (120 bitow, po dekodowaniu
|
||||
* Manchester przez rtl_433 OOK_MC_ZEROBIT):
|
||||
*
|
||||
* 40 bit sync (zera) | flags(4B) | id(3B) | pressure(1B) | temp(1B) | crc(1B)
|
||||
*
|
||||
* - flags: 32 bity, wg dekodera "moze zawierac preamble/status/battery"
|
||||
* - pressure: 25 mbar/bit (cisnienie w kPa = bajt * 2.5)
|
||||
* - temperature: stopnie Fahrenheita
|
||||
* - crc: suma 9 poprzednich bajtow mod 256 (add_bytes w rtl_433)
|
||||
*
|
||||
* Kodowanie na zrzuconej warstwie RF (G.E.T. Manchester):
|
||||
* bit 0 -> chipy "01", bit 1 -> chipy "10", chip = 120 us
|
||||
* Odbiornik rtl_433 (MC_ZEROBIT) dopisuje pierwszy bit ramki samodzielnie,
|
||||
* wiec nadajnik wysyla ramke BEZ pierwszego bitu, poprzedzona jednym
|
||||
* chipem rozbiegowym '1'. Bufor wyjsciowy jest dopełniany zerami do
|
||||
* granicy bajtu (dla OOK sa to chipy "wylaczone" = cisza).
|
||||
*/
|
||||
/* Schrader EG53MA4: 40 bitow sync + 80 bitow danych, OOK Manchester. */
|
||||
#ifndef TPMS_FRAME_H
|
||||
#define TPMS_FRAME_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define TPMS_ROW_BITS 120 // dlugosc dekodowanej ramki (wymagana przez rtl_433)
|
||||
#define TPMS_ROW_BITS 120
|
||||
#define TPMS_SYNC_BITS 40
|
||||
#define TPMS_PAYLOAD_LEN 10 // flags(4)+id(3)+press+temp+crc
|
||||
#define TPMS_TX_BYTES 30 // 240 chipow = 1 lead + 238 danych + 1 padding
|
||||
#define TPMS_PAYLOAD_LEN 10
|
||||
#define TPMS_TX_BYTES 30
|
||||
#define TPMS_TX_CHIPS (TPMS_TX_BYTES * 8)
|
||||
|
||||
#ifdef __cplusplus
|
||||
/* Zaleznosc bufora nadawczego od dlugosci ramki: 1 chip rozbiegowy +
|
||||
* 2 chipy na kazdy z (TPMS_ROW_BITS-1) bitow (pierwszy bit dopisuje
|
||||
* odbiornik) + padding do granicy bajtu (< 8 chipow). */
|
||||
static_assert(TPMS_TX_CHIPS >= 1 + 2 * (TPMS_ROW_BITS - 1)
|
||||
&& TPMS_TX_CHIPS < 1 + 2 * (TPMS_ROW_BITS - 1) + 8,
|
||||
"TPMS_TX_BYTES musi miescic 1 + 2*(TPMS_ROW_BITS-1) chipow");
|
||||
static_assert(TPMS_TX_CHIPS == 1 + 2 * (TPMS_ROW_BITS - 1) + 1,
|
||||
"Nieprawidlowa dlugosc bufora Manchester");
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
uint32_t id; // 24-bit identyfikator czujnika
|
||||
uint16_t press_kpa10; // cisnienie w kPa * 10 (np. 2600 = 260.0 kPa)
|
||||
int8_t temp_c; // temperatura w st. C
|
||||
const char *name; // "FL", "FR", "RR", "RL"
|
||||
} tpms_sensor_t;
|
||||
|
||||
/* Zbuduj 10-bajtowy payload (bez sync). Zwraca crc (tez wpisane do out[9]). */
|
||||
uint8_t tpms_build_payload(uint8_t out[TPMS_PAYLOAD_LEN], uint32_t id,
|
||||
uint16_t press_kpa10, int8_t temp_c,
|
||||
uint32_t flags, bool low_batt);
|
||||
|
||||
/* Zbuduj kompletny bufor nadawczy (TPMS_TX_BYTES) gotowy do CC1101 FIFO. */
|
||||
void tpms_build_frame(uint8_t out[TPMS_TX_BYTES], uint32_t id,
|
||||
uint16_t press_kpa10, int8_t temp_c,
|
||||
uint32_t flags, bool low_batt);
|
||||
/* Zwraca false dla ID 0, 0xFFFFFF i wartosci spoza 24 bitow. */
|
||||
bool tpms_build_payload(uint8_t out[TPMS_PAYLOAD_LEN], uint32_t id,
|
||||
uint16_t press_kpa10, int8_t temp_c, uint32_t flags);
|
||||
bool tpms_build_frame(uint8_t out[TPMS_TX_BYTES], uint32_t id,
|
||||
uint16_t press_kpa10, int8_t temp_c, uint32_t flags);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* TPMS_FRAME_H */
|
||||
#endif
|
||||
@@ -0,0 +1,201 @@
|
||||
#include <unity.h>
|
||||
#include "app_state.h"
|
||||
|
||||
class FakeRadio final : public RadioSink {
|
||||
public:
|
||||
uint8_t wheels[128];
|
||||
uint8_t count = 0;
|
||||
bool fail = false;
|
||||
|
||||
bool send(uint8_t wheel) override
|
||||
{
|
||||
if (count < sizeof(wheels)) wheels[count] = wheel;
|
||||
++count;
|
||||
return !fail;
|
||||
}
|
||||
};
|
||||
|
||||
void setUp(void) {}
|
||||
void tearDown(void) {}
|
||||
|
||||
static void test_normal_clone_ids_sends_four_wheels_and_repeats(void)
|
||||
{
|
||||
settings_t cfg;
|
||||
settings_defaults(&cfg);
|
||||
cfg.wheels[0].id = 0x111111u; /* Clone IDs: konfiguracja bez nauki. */
|
||||
FakeRadio radio;
|
||||
AppState app(&cfg, &radio);
|
||||
app.begin(0u);
|
||||
TEST_ASSERT_EQUAL_UINT8(4u, radio.count);
|
||||
static const uint8_t expected[] = {0, 1, 2, 3};
|
||||
TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, radio.wheels, 4);
|
||||
app.tick(29999u, false);
|
||||
TEST_ASSERT_EQUAL_UINT8(4u, radio.count);
|
||||
app.tick(30000u, false);
|
||||
TEST_ASSERT_EQUAL_UINT8(8u, radio.count);
|
||||
}
|
||||
|
||||
static void test_new_ids_learn_order_force_and_finish(void)
|
||||
{
|
||||
settings_t cfg;
|
||||
settings_defaults(&cfg);
|
||||
settings_generate_ids(&cfg, 42u);
|
||||
TEST_ASSERT_TRUE(settings_validate(&cfg));
|
||||
FakeRadio radio;
|
||||
AppState app(&cfg, &radio);
|
||||
app.begin(0u, false);
|
||||
app.set_mode(AppMode::LEARN, WHEEL_FL, 0u);
|
||||
TEST_ASSERT_EQUAL(AppMode::LEARN, app.mode());
|
||||
TEST_ASSERT_EQUAL_UINT8(1u, radio.count);
|
||||
TEST_ASSERT_EQUAL_UINT8(WHEEL_FL, radio.wheels[0]);
|
||||
TEST_ASSERT_TRUE(app.send_current()); /* wymuszenie bez zmiany kola */
|
||||
TEST_ASSERT_EQUAL_UINT8(2u, radio.count);
|
||||
app.short_press(100u);
|
||||
TEST_ASSERT_EQUAL_UINT8(WHEEL_FR, app.active_wheel());
|
||||
app.short_press(200u);
|
||||
TEST_ASSERT_EQUAL_UINT8(WHEEL_RR, app.active_wheel());
|
||||
app.short_press(300u);
|
||||
TEST_ASSERT_EQUAL_UINT8(WHEEL_RL, app.active_wheel());
|
||||
app.short_press(400u);
|
||||
TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode());
|
||||
static const uint8_t expected[] = {0, 0, 1, 2, 3};
|
||||
TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, radio.wheels, 5);
|
||||
}
|
||||
|
||||
static void test_learn_period_window_and_total_timeout(void)
|
||||
{
|
||||
settings_t cfg;
|
||||
settings_defaults(&cfg);
|
||||
FakeRadio radio;
|
||||
AppState app(&cfg, &radio);
|
||||
app.set_mode(AppMode::LEARN, WHEEL_FL, 0u);
|
||||
app.tick(1999u, false);
|
||||
TEST_ASSERT_EQUAL_UINT8(1u, radio.count);
|
||||
app.tick(2000u, false);
|
||||
TEST_ASSERT_EQUAL_UINT8(2u, radio.count);
|
||||
app.tick(59999u, false);
|
||||
TEST_ASSERT_EQUAL(AppMode::LEARN, app.mode());
|
||||
app.tick(60000u, false);
|
||||
TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode());
|
||||
TEST_ASSERT_EQUAL_UINT8(3u, radio.count); /* timeout nie nadaje nowej ramki */
|
||||
|
||||
app.set_mode(AppMode::LEARN, WHEEL_FL, 100000u);
|
||||
app.tick(1000000u, false);
|
||||
TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode());
|
||||
}
|
||||
|
||||
static void test_single_isolated_wheel_and_timeout(void)
|
||||
{
|
||||
settings_t cfg;
|
||||
settings_defaults(&cfg);
|
||||
FakeRadio radio;
|
||||
AppState app(&cfg, &radio);
|
||||
app.set_mode(AppMode::SINGLE, WHEEL_FR, 0u);
|
||||
TEST_ASSERT_EQUAL_UINT8(1u, radio.count);
|
||||
TEST_ASSERT_EQUAL_UINT8(WHEEL_FR, radio.wheels[0]);
|
||||
app.tick(2000u, false);
|
||||
TEST_ASSERT_EQUAL_UINT8(2u, radio.count);
|
||||
TEST_ASSERT_EQUAL_UINT8(WHEEL_FR, radio.wheels[1]);
|
||||
app.next_wheel(3000u);
|
||||
TEST_ASSERT_EQUAL_UINT8(WHEEL_RR, app.active_wheel());
|
||||
app.tick(300000u, false);
|
||||
TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode());
|
||||
}
|
||||
|
||||
static void test_button_gestures(void)
|
||||
{
|
||||
settings_t cfg;
|
||||
settings_defaults(&cfg);
|
||||
FakeRadio radio;
|
||||
AppState app(&cfg, &radio);
|
||||
app.begin(0u, false);
|
||||
app.long_press(0u);
|
||||
TEST_ASSERT_EQUAL(AppMode::LEARN, app.mode());
|
||||
app.long_press(10u);
|
||||
TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode());
|
||||
app.very_long_press(20u);
|
||||
TEST_ASSERT_EQUAL(AppMode::SINGLE, app.mode());
|
||||
app.very_long_press(30u);
|
||||
TEST_ASSERT_EQUAL(AppMode::NORMAL, app.mode());
|
||||
app.short_press(40u);
|
||||
TEST_ASSERT_EQUAL_UINT8(6u, radio.count); /* LEARN + SINGLE + 4 koła NORMAL */
|
||||
}
|
||||
|
||||
static void test_acc_intervals_without_permanent_shutdown(void)
|
||||
{
|
||||
settings_t cfg;
|
||||
settings_defaults(&cfg);
|
||||
cfg.ignition_interval_s = 15u;
|
||||
cfg.parking_interval_s = 120u;
|
||||
FakeRadio radio;
|
||||
AppState app(&cfg, &radio);
|
||||
app.begin(0u);
|
||||
app.tick(30000u, true);
|
||||
app.tick(45000u, true);
|
||||
TEST_ASSERT_EQUAL_UINT8(12u, radio.count);
|
||||
app.tick(60000u, false);
|
||||
TEST_ASSERT_EQUAL_UINT8(16u, radio.count);
|
||||
app.tick(179999u, false);
|
||||
TEST_ASSERT_EQUAL_UINT8(16u, radio.count);
|
||||
app.tick(180000u, false);
|
||||
TEST_ASSERT_EQUAL_UINT8(20u, radio.count);
|
||||
TEST_ASSERT_EQUAL_UINT32(15u, app.interval_s(true));
|
||||
TEST_ASSERT_EQUAL_UINT32(120u, app.interval_s(false));
|
||||
}
|
||||
|
||||
static void test_power_restart_and_nvs_reloaded_configuration(void)
|
||||
{
|
||||
settings_t persisted;
|
||||
settings_defaults(&persisted);
|
||||
persisted.wheels[3].id = 0x654321u;
|
||||
settings_blob_t blob;
|
||||
settings_make_blob(&persisted, &blob);
|
||||
settings_t reloaded;
|
||||
TEST_ASSERT_EQUAL(SETTINGS_LOAD_OK, settings_decode_blob(&blob, &reloaded));
|
||||
FakeRadio radio;
|
||||
AppState after_restart(&reloaded, &radio);
|
||||
after_restart.begin(1000u);
|
||||
TEST_ASSERT_EQUAL(AppMode::NORMAL, after_restart.mode());
|
||||
TEST_ASSERT_EQUAL_UINT8(4u, radio.count);
|
||||
TEST_ASSERT_EQUAL_HEX32(0x654321u, reloaded.wheels[3].id);
|
||||
}
|
||||
|
||||
static void test_radio_failure_is_counted_and_other_wheels_continue(void)
|
||||
{
|
||||
settings_t cfg;
|
||||
settings_defaults(&cfg);
|
||||
FakeRadio radio;
|
||||
radio.fail = true;
|
||||
AppState app(&cfg, &radio);
|
||||
app.begin(0u);
|
||||
TEST_ASSERT_EQUAL_UINT8(4u, radio.count);
|
||||
TEST_ASSERT_EQUAL_UINT32(4u, app.last_error_count());
|
||||
}
|
||||
|
||||
static void test_millis_wrap_does_not_stall_learn(void)
|
||||
{
|
||||
settings_t cfg;
|
||||
settings_defaults(&cfg);
|
||||
FakeRadio radio;
|
||||
AppState app(&cfg, &radio);
|
||||
app.set_mode(AppMode::LEARN, WHEEL_FL, UINT32_MAX - 1000u);
|
||||
app.tick(1000u, false); /* uplynely 2001 ms po zawinieciu */
|
||||
TEST_ASSERT_EQUAL_UINT8(2u, radio.count);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
(void)argc;
|
||||
(void)argv;
|
||||
UNITY_BEGIN();
|
||||
RUN_TEST(test_normal_clone_ids_sends_four_wheels_and_repeats);
|
||||
RUN_TEST(test_new_ids_learn_order_force_and_finish);
|
||||
RUN_TEST(test_learn_period_window_and_total_timeout);
|
||||
RUN_TEST(test_single_isolated_wheel_and_timeout);
|
||||
RUN_TEST(test_button_gestures);
|
||||
RUN_TEST(test_acc_intervals_without_permanent_shutdown);
|
||||
RUN_TEST(test_power_restart_and_nvs_reloaded_configuration);
|
||||
RUN_TEST(test_radio_failure_is_counted_and_other_wheels_continue);
|
||||
RUN_TEST(test_millis_wrap_does_not_stall_learn);
|
||||
return UNITY_END();
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
#include <string.h>
|
||||
#include <unity.h>
|
||||
#include "settings.h"
|
||||
|
||||
void setUp(void) {}
|
||||
void tearDown(void) {}
|
||||
|
||||
static void test_defaults_are_safe_and_valid(void)
|
||||
{
|
||||
settings_t cfg;
|
||||
settings_defaults(&cfg);
|
||||
TEST_ASSERT_TRUE(settings_validate(&cfg));
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; ++i) {
|
||||
TEST_ASSERT_EQUAL_UINT16(2600u, cfg.wheels[i].pressure_kpa10);
|
||||
TEST_ASSERT_TRUE(settings_valid_id(cfg.wheels[i].id));
|
||||
}
|
||||
TEST_ASSERT_EQUAL_INT8(-10, cfg.tx_power_dbm);
|
||||
TEST_ASSERT_FLOAT_WITHIN(0.001f, 433.92f, cfg.frequency_mhz);
|
||||
}
|
||||
|
||||
static void test_ids_must_be_24_bit_nonzero_and_unique(void)
|
||||
{
|
||||
settings_t cfg;
|
||||
settings_defaults(&cfg);
|
||||
TEST_ASSERT_FALSE(settings_set_id(&cfg, 0u, 0u));
|
||||
TEST_ASSERT_FALSE(settings_set_id(&cfg, 0u, 0xFFFFFFu));
|
||||
TEST_ASSERT_FALSE(settings_set_id(&cfg, 0u, 0x1000000u));
|
||||
TEST_ASSERT_FALSE(settings_set_id(&cfg, 4u, 0x123456u));
|
||||
TEST_ASSERT_FALSE(settings_set_id(&cfg, 0u, cfg.wheels[1].id));
|
||||
TEST_ASSERT_TRUE(settings_set_id(&cfg, 0u, 0x123456u));
|
||||
TEST_ASSERT_EQUAL_HEX32(0x123456u, cfg.wheels[0].id);
|
||||
}
|
||||
|
||||
static void test_generated_ids_are_unique_and_deterministic_for_seed(void)
|
||||
{
|
||||
settings_t a, b;
|
||||
settings_defaults(&a);
|
||||
settings_defaults(&b);
|
||||
settings_generate_ids(&a, 1234u);
|
||||
settings_generate_ids(&b, 1234u);
|
||||
TEST_ASSERT_TRUE(settings_validate(&a));
|
||||
TEST_ASSERT_EQUAL_MEMORY(&a, &b, sizeof(a));
|
||||
settings_generate_ids(&a, 0u);
|
||||
TEST_ASSERT_TRUE(settings_validate(&a));
|
||||
}
|
||||
|
||||
static void test_blob_round_trip_and_crc(void)
|
||||
{
|
||||
settings_t cfg, decoded;
|
||||
settings_defaults(&cfg);
|
||||
TEST_ASSERT_TRUE(settings_set_id(&cfg, WHEEL_FR, 0xABCDEFu));
|
||||
cfg.wheels[2].pressure_kpa10 = 2555u;
|
||||
settings_blob_t blob;
|
||||
settings_make_blob(&cfg, &blob);
|
||||
TEST_ASSERT_EQUAL_UINT32(SETTINGS_VERSION, blob.version);
|
||||
TEST_ASSERT_EQUAL(SETTINGS_LOAD_OK, settings_decode_blob(&blob, &decoded));
|
||||
TEST_ASSERT_EQUAL_MEMORY(&cfg, &decoded, sizeof(cfg));
|
||||
blob.values.wheels[0].id ^= 1u;
|
||||
TEST_ASSERT_EQUAL(SETTINGS_LOAD_BAD_CRC, settings_decode_blob(&blob, &decoded));
|
||||
}
|
||||
|
||||
static void test_incompatible_version_size_magic_are_rejected(void)
|
||||
{
|
||||
settings_t cfg, decoded;
|
||||
settings_defaults(&cfg);
|
||||
settings_blob_t blob;
|
||||
settings_make_blob(&cfg, &blob);
|
||||
++blob.version;
|
||||
TEST_ASSERT_EQUAL(SETTINGS_LOAD_BAD_VERSION, settings_decode_blob(&blob, &decoded));
|
||||
settings_make_blob(&cfg, &blob);
|
||||
--blob.size;
|
||||
TEST_ASSERT_EQUAL(SETTINGS_LOAD_BAD_SIZE, settings_decode_blob(&blob, &decoded));
|
||||
settings_make_blob(&cfg, &blob);
|
||||
blob.magic = 0u;
|
||||
TEST_ASSERT_EQUAL(SETTINGS_LOAD_BAD_MAGIC, settings_decode_blob(&blob, &decoded));
|
||||
}
|
||||
|
||||
static void test_invalid_ranges_are_rejected_even_with_valid_crc(void)
|
||||
{
|
||||
settings_t cfg, decoded;
|
||||
settings_defaults(&cfg);
|
||||
settings_blob_t blob;
|
||||
cfg.normal_interval_s = 4u;
|
||||
settings_make_blob(&cfg, &blob);
|
||||
TEST_ASSERT_EQUAL(SETTINGS_LOAD_INVALID, settings_decode_blob(&blob, &decoded));
|
||||
settings_defaults(&cfg);
|
||||
cfg.tx_power_dbm = 10;
|
||||
settings_make_blob(&cfg, &blob);
|
||||
TEST_ASSERT_EQUAL(SETTINGS_LOAD_INVALID, settings_decode_blob(&blob, &decoded));
|
||||
settings_defaults(&cfg);
|
||||
cfg.wheels[1].id = cfg.wheels[0].id;
|
||||
settings_make_blob(&cfg, &blob);
|
||||
TEST_ASSERT_EQUAL(SETTINGS_LOAD_INVALID, settings_decode_blob(&blob, &decoded));
|
||||
settings_defaults(&cfg);
|
||||
cfg.frequency_mhz = 434.80f;
|
||||
settings_make_blob(&cfg, &blob);
|
||||
TEST_ASSERT_EQUAL(SETTINGS_LOAD_INVALID, settings_decode_blob(&blob, &decoded));
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
(void)argc;
|
||||
(void)argv;
|
||||
UNITY_BEGIN();
|
||||
RUN_TEST(test_defaults_are_safe_and_valid);
|
||||
RUN_TEST(test_ids_must_be_24_bit_nonzero_and_unique);
|
||||
RUN_TEST(test_generated_ids_are_unique_and_deterministic_for_seed);
|
||||
RUN_TEST(test_blob_round_trip_and_crc);
|
||||
RUN_TEST(test_incompatible_version_size_magic_are_rejected);
|
||||
RUN_TEST(test_invalid_ranges_are_rejected_even_with_valid_crc);
|
||||
return UNITY_END();
|
||||
}
|
||||
@@ -1,144 +1,142 @@
|
||||
/*
|
||||
* test_tpms_frame.cpp - testy generatora ramek TPMS (natywne, bez sprzetu)
|
||||
*
|
||||
* Wektory odniesienia wygenerowane narzedziem tools/tpms_frame.py,
|
||||
* ktore jest zgodne bit-w-bit z dekoderem rtl_433 (schrader_EG53MA4)
|
||||
* oraz z referencyjnym nagraniem Schrader_EG53MA4_TPMS/01/gfile001.cu8.
|
||||
*/
|
||||
#include <string.h>
|
||||
#include <unity.h>
|
||||
#include "config.h"
|
||||
#include "tpms_frame.h"
|
||||
|
||||
static uint8_t hexval(char c)
|
||||
{
|
||||
if (c >= '0' && c <= '9') return (uint8_t)(c - '0');
|
||||
if (c >= 'a' && c <= 'f') return (uint8_t)(c - 'a' + 10);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void unhex(const char *hex, uint8_t *out)
|
||||
{
|
||||
for (unsigned i = 0; hex[2 * i]; i++) {
|
||||
out[i] = (uint8_t)((hexval(hex[2 * i]) << 4) | hexval(hex[2 * i + 1]));
|
||||
}
|
||||
}
|
||||
|
||||
struct vec_t {
|
||||
uint32_t id;
|
||||
uint16_t kpa10;
|
||||
int8_t temp_c;
|
||||
const char *frame_hex; // 30 bajtow bufora nadawczego
|
||||
};
|
||||
|
||||
void setUp(void) {}
|
||||
void tearDown(void) {}
|
||||
|
||||
static void test_frame_vectors(void)
|
||||
{
|
||||
static const vec_t v[] = {
|
||||
{ 0x2FC871u, 2600, 23, "aaaaaaaaaaaaaaaaaaaacb4b2caaaaaad4aab3554b2ad4acd32acb2cd2cc" },
|
||||
{ 0x2FC871u, 0, 32, "aaaaaaaaaaaaaaaaaaaacb4b2caaaaaad4aab3554b2ad4acaaaacd32ab52" },
|
||||
{ 0x3495ACu, 2200, -5, "aaaaaaaaaaaaaaaaaaaacb4b2caaaaaad4aab4cb2ccd334acd2aacd4b4aa" },
|
||||
{ 0x000001u, 6375, 85, "aaaaaaaaaaaaaaaaaaaacb4b2caaaaaad4aaaaaaaaaaaaad5555352caacc" },
|
||||
{ 0xABCDEEu, 2625, 24, "aaaaaaaaaaaaaaaaaaaacb4b2caaaaaad4ab33354b4d5352d32ccb34d2d2" },
|
||||
{ 0x2FC780u, 2580, -40, "aaaaaaaaaaaaaaaaaaaacb4b2caaaaaad4aab3554ad52aaad2d4aaaab32c" },
|
||||
};
|
||||
struct capture_vector_t {
|
||||
uint32_t id;
|
||||
int16_t temp_c;
|
||||
uint8_t temp_f;
|
||||
uint8_t checksum;
|
||||
};
|
||||
|
||||
for (unsigned i = 0; i < sizeof(v) / sizeof(v[0]); i++) {
|
||||
uint8_t got[TPMS_TX_BYTES];
|
||||
uint8_t want[TPMS_TX_BYTES];
|
||||
tpms_build_frame(got, v[i].id, v[i].kpa10, v[i].temp_c, 0x4C900070u, false);
|
||||
unhex(v[i].frame_hex, want);
|
||||
TEST_ASSERT_EQUAL_HEX8_ARRAY(want, got, TPMS_TX_BYTES);
|
||||
static void test_four_independent_capture_payloads(void)
|
||||
{
|
||||
/* rtl_433_tests commit 1aa8c29, cztery nagrania, po 16 dekodowan.
|
||||
* Wszystkie: flags=4c900070, pressure=0. Wartosci nie pochodza z generatora. */
|
||||
static const capture_vector_t vectors[] = {
|
||||
{0x2FC871u, 32, 90u, 0x0Eu},
|
||||
{0x2EAAF9u, 32, 90u, 0x77u},
|
||||
{0x3495ACu, 32, 90u, 0x1Bu},
|
||||
{0x2FC780u, 33, 91u, 0x1Du},
|
||||
};
|
||||
for (uint8_t i = 0; i < 4u; ++i) {
|
||||
uint8_t payload[TPMS_PAYLOAD_LEN];
|
||||
TEST_ASSERT_TRUE(tpms_build_payload(payload, vectors[i].id, 0u,
|
||||
(int8_t)vectors[i].temp_c, 0x4C900070u));
|
||||
TEST_ASSERT_EQUAL_HEX32(vectors[i].id,
|
||||
((uint32_t)payload[4] << 16) | ((uint32_t)payload[5] << 8) | payload[6]);
|
||||
TEST_ASSERT_EQUAL_HEX8(0x00, payload[7]);
|
||||
TEST_ASSERT_EQUAL_HEX8(vectors[i].temp_f, payload[8]);
|
||||
TEST_ASSERT_EQUAL_HEX8(vectors[i].checksum, payload[9]);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_reference_capture(void)
|
||||
static void test_known_frame_and_pressure_temperature(void)
|
||||
{
|
||||
/* gfile001.cu8: id=2FC871, flags=4c900070, 0 kPa, 90 F, crc=0x0E */
|
||||
uint8_t p[TPMS_PAYLOAD_LEN];
|
||||
tpms_build_payload(p, 0x2FC871u, 0, 32, 0x4C900070u, false);
|
||||
const uint8_t want[TPMS_PAYLOAD_LEN] = {
|
||||
0x4C, 0x90, 0x00, 0x70, 0x2F, 0xC8, 0x71, 0x00, 0x5A, 0x0E
|
||||
static const uint8_t expected[TPMS_TX_BYTES] = {
|
||||
0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,
|
||||
0xCB,0x4B,0x2C,0xAA,0xAA,0xAA,0xD4,0xAA,0xB3,0x55,
|
||||
0x4B,0x2A,0xD4,0xAC,0xD3,0x2A,0xCB,0x2C,0xD2,0xCC,
|
||||
};
|
||||
TEST_ASSERT_EQUAL_HEX8_ARRAY(want, p, TPMS_PAYLOAD_LEN);
|
||||
uint8_t frame[TPMS_TX_BYTES];
|
||||
uint8_t payload[TPMS_PAYLOAD_LEN];
|
||||
TEST_ASSERT_TRUE(tpms_build_frame(frame, 0x2FC871u, 2600u, 23, 0x4C900070u));
|
||||
TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, frame, TPMS_TX_BYTES);
|
||||
TEST_ASSERT_TRUE(tpms_build_payload(payload, 0x123456u, 2600u, 23, 0x4C900070u));
|
||||
TEST_ASSERT_EQUAL_HEX8(0x68, payload[7]); /* 260 kPa / 2.5 = 104 */
|
||||
TEST_ASSERT_EQUAL_UINT8(73u, payload[8]);
|
||||
TEST_ASSERT_EQUAL_HEX8(0x99, payload[9]);
|
||||
}
|
||||
|
||||
static void test_pressure_scale(void)
|
||||
static bool decode_strict(const uint8_t *frame, size_t length,
|
||||
uint8_t payload[TPMS_PAYLOAD_LEN])
|
||||
{
|
||||
uint8_t p[TPMS_PAYLOAD_LEN];
|
||||
/* 260 kPa = 2600 kPa*10 -> 2600/2.5 = 104 = 0x68 */
|
||||
tpms_build_payload(p, 0x123456u, 2600, 23, 0x4C900070u, false);
|
||||
TEST_ASSERT_EQUAL_HEX8(0x68, p[7]);
|
||||
/* 23 C = 73 F */
|
||||
TEST_ASSERT_EQUAL_HEX8(73, p[8]);
|
||||
/* ograniczenie zakresu */
|
||||
tpms_build_payload(p, 0x123456u, 65535, 127, 0x4C900070u, false);
|
||||
TEST_ASSERT_EQUAL_HEX8(255, p[7]);
|
||||
TEST_ASSERT_EQUAL_HEX8(255, p[8]);
|
||||
tpms_build_payload(p, 0x123456u, 0, -99, 0x4C900070u, false);
|
||||
TEST_ASSERT_EQUAL_HEX8(0, p[7]);
|
||||
TEST_ASSERT_EQUAL_HEX8(0, p[8]);
|
||||
}
|
||||
|
||||
static void test_pressure_rounding(void)
|
||||
{
|
||||
uint8_t p[TPMS_PAYLOAD_LEN];
|
||||
/* skala 2.5 kPa/bit = 25 kPa*10/bit, zaokraglenie w gore do pol bitu:
|
||||
* bajt = (kpa10 + 12) / 25 */
|
||||
tpms_build_payload(p, 1, 12, 0, 0x4C900070u, false); // 1.2 kPa -> 0
|
||||
TEST_ASSERT_EQUAL_HEX8(0, p[7]);
|
||||
tpms_build_payload(p, 1, 13, 0, 0x4C900070u, false); // 1.3 kPa -> 1
|
||||
TEST_ASSERT_EQUAL_HEX8(1, p[7]);
|
||||
tpms_build_payload(p, 1, 2588, 0, 0x4C900070u, false); // 258.8 kPa -> 104
|
||||
TEST_ASSERT_EQUAL_HEX8(104, p[7]);
|
||||
tpms_build_payload(p, 1, 2587, 0, 0x4C900070u, false); // 258.7 kPa -> 103
|
||||
TEST_ASSERT_EQUAL_HEX8(103, p[7]);
|
||||
}
|
||||
|
||||
static void test_checksum(void)
|
||||
{
|
||||
uint8_t p[TPMS_PAYLOAD_LEN];
|
||||
tpms_build_payload(p, 0x2FC871u, 2600, 23, 0x4C900070u, false);
|
||||
unsigned sum = 0;
|
||||
for (int i = 0; i < 9; i++) {
|
||||
sum += p[i];
|
||||
if (frame == NULL || length != TPMS_TX_BYTES || (frame[0] & 0x80u) == 0u) {
|
||||
return false;
|
||||
}
|
||||
TEST_ASSERT_EQUAL_HEX8(sum & 0xFF, p[9]);
|
||||
uint8_t row[15] = {0};
|
||||
unsigned chip = 1u;
|
||||
for (unsigned bit = 1u; bit < TPMS_ROW_BITS; ++bit) {
|
||||
unsigned first = (frame[chip >> 3] >> (7u - (chip & 7u))) & 1u;
|
||||
unsigned second = (frame[(chip + 1u) >> 3] >> (7u - ((chip + 1u) & 7u))) & 1u;
|
||||
if (first == second) {
|
||||
return false;
|
||||
}
|
||||
unsigned value = first != 0u ? 1u : 0u;
|
||||
row[bit >> 3] |= (uint8_t)(value << (7u - (bit & 7u)));
|
||||
chip += 2u;
|
||||
}
|
||||
if ((frame[29] & 1u) != 0u) {
|
||||
return false;
|
||||
}
|
||||
memcpy(payload, &row[5], TPMS_PAYLOAD_LEN);
|
||||
uint8_t sum = 0;
|
||||
for (uint8_t i = 0; i < 9u; ++i) sum = (uint8_t)(sum + payload[i]);
|
||||
return sum == payload[9];
|
||||
}
|
||||
|
||||
static void test_low_batt_flag(void)
|
||||
static void test_manchester_polarity_and_negative_frames(void)
|
||||
{
|
||||
uint8_t a[TPMS_PAYLOAD_LEN], b[TPMS_PAYLOAD_LEN];
|
||||
tpms_build_payload(a, 0x2FC871u, 2600, 23, 0x4C900070u, false);
|
||||
tpms_build_payload(b, 0x2FC871u, 2600, 23, 0x4C900070u, true);
|
||||
TEST_ASSERT_EQUAL_HEX32(0x4C900070u,
|
||||
((uint32_t)a[0] << 24) | (a[1] << 16) | (a[2] << 8) | a[3]);
|
||||
TEST_ASSERT_TRUE((((uint32_t)b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3])
|
||||
& TPMS_FLAGS_LOWBAT_MASK);
|
||||
uint8_t frame[TPMS_TX_BYTES];
|
||||
uint8_t payload[TPMS_PAYLOAD_LEN];
|
||||
TEST_ASSERT_TRUE(tpms_build_frame(frame, 0x2FC871u, 2600u, 23, 0x4C900070u));
|
||||
TEST_ASSERT_TRUE(decode_strict(frame, sizeof(frame), payload));
|
||||
TEST_ASSERT_EQUAL_HEX32(0x2FC871u,
|
||||
((uint32_t)payload[4] << 16) | ((uint32_t)payload[5] << 8) | payload[6]);
|
||||
|
||||
uint8_t damaged[TPMS_TX_BYTES];
|
||||
memcpy(damaged, frame, sizeof(frame));
|
||||
damaged[10] &= 0x3Fu; /* dwa jednakowe chipy: niedozwolony Manchester */
|
||||
TEST_ASSERT_FALSE(decode_strict(damaged, sizeof(damaged), payload));
|
||||
TEST_ASSERT_FALSE(decode_strict(frame, sizeof(frame) - 1u, payload));
|
||||
|
||||
memcpy(damaged, frame, sizeof(frame));
|
||||
/* Zmien ostatnia komorke checksum z zachowaniem poprawnego Manchester. */
|
||||
damaged[28] ^= 0x40u;
|
||||
damaged[28] ^= 0x10u;
|
||||
TEST_ASSERT_FALSE(decode_strict(damaged, sizeof(damaged), payload));
|
||||
}
|
||||
|
||||
static void test_frame_layout(void)
|
||||
static void test_rounding_and_saturation(void)
|
||||
{
|
||||
uint8_t f[TPMS_TX_BYTES];
|
||||
tpms_build_frame(f, 0x2FC871u, 2600, 23, 0x4C900070u, false);
|
||||
/* pierwszy bit = chip rozbiegowy '1' -> najstarszy bit pierwszego bajtu */
|
||||
TEST_ASSERT_EQUAL_HEX8(0xAA, f[0]);
|
||||
/* dlugosc stale: 240 chipow = 30 bajtow */
|
||||
TEST_ASSERT_EQUAL_UINT32(30, TPMS_TX_BYTES);
|
||||
uint8_t p[TPMS_PAYLOAD_LEN];
|
||||
TEST_ASSERT_TRUE(tpms_build_payload(p, 1u, 12u, 0, 0u));
|
||||
TEST_ASSERT_EQUAL_UINT8(0u, p[7]);
|
||||
TEST_ASSERT_TRUE(tpms_build_payload(p, 1u, 13u, 0, 0u));
|
||||
TEST_ASSERT_EQUAL_UINT8(1u, p[7]);
|
||||
TEST_ASSERT_TRUE(tpms_build_payload(p, 1u, 2588u, -40, 0u));
|
||||
TEST_ASSERT_EQUAL_UINT8(104u, p[7]);
|
||||
TEST_ASSERT_EQUAL_UINT8(0u, p[8]);
|
||||
TEST_ASSERT_TRUE(tpms_build_payload(p, 1u, 2587u, 85, 0u));
|
||||
TEST_ASSERT_EQUAL_UINT8(103u, p[7]);
|
||||
TEST_ASSERT_EQUAL_UINT8(185u, p[8]);
|
||||
TEST_ASSERT_TRUE(tpms_build_payload(p, 1u, 65535u, 127, 0u));
|
||||
TEST_ASSERT_EQUAL_UINT8(255u, p[7]);
|
||||
TEST_ASSERT_EQUAL_UINT8(255u, p[8]);
|
||||
}
|
||||
|
||||
static void test_invalid_id_and_null_are_rejected(void)
|
||||
{
|
||||
uint8_t p[TPMS_PAYLOAD_LEN];
|
||||
TEST_ASSERT_FALSE(tpms_build_payload(p, 0u, 2600u, 23, 0u));
|
||||
TEST_ASSERT_FALSE(tpms_build_payload(p, 0xFFFFFFu, 2600u, 23, 0u));
|
||||
TEST_ASSERT_FALSE(tpms_build_payload(p, 0x1000000u, 2600u, 23, 0u));
|
||||
TEST_ASSERT_FALSE(tpms_build_payload(NULL, 1u, 2600u, 23, 0u));
|
||||
TEST_ASSERT_FALSE(tpms_build_frame(NULL, 1u, 2600u, 23, 0u));
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
(void)argc; (void)argv;
|
||||
(void)argc;
|
||||
(void)argv;
|
||||
UNITY_BEGIN();
|
||||
RUN_TEST(test_frame_vectors);
|
||||
RUN_TEST(test_reference_capture);
|
||||
RUN_TEST(test_pressure_scale);
|
||||
RUN_TEST(test_pressure_rounding);
|
||||
RUN_TEST(test_checksum);
|
||||
RUN_TEST(test_low_batt_flag);
|
||||
RUN_TEST(test_frame_layout);
|
||||
RUN_TEST(test_four_independent_capture_payloads);
|
||||
RUN_TEST(test_known_frame_and_pressure_temperature);
|
||||
RUN_TEST(test_manchester_polarity_and_negative_frames);
|
||||
RUN_TEST(test_rounding_and_saturation);
|
||||
RUN_TEST(test_invalid_id_and_null_are_rejected);
|
||||
return UNITY_END();
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env bash
|
||||
# Wszystkie testy mozliwe bez ESP32/CC1101/RTL-SDR/samochodu.
|
||||
set -euo pipefail
|
||||
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
cd "$ROOT"
|
||||
mkdir -p artifacts/validation
|
||||
|
||||
if [ -n "${PIO:-}" ]; then
|
||||
PIO_BIN="$PIO"
|
||||
elif [ -x "$ROOT/.venv/bin/pio" ]; then
|
||||
PIO_BIN="$ROOT/.venv/bin/pio"
|
||||
elif command -v pio >/dev/null 2>&1; then
|
||||
PIO_BIN="$(command -v pio)"
|
||||
else
|
||||
python3 -m venv "$ROOT/.venv"
|
||||
"$ROOT/.venv/bin/pip" install --disable-pip-version-check -r tools/requirements.txt
|
||||
PIO_BIN="$ROOT/.venv/bin/pio"
|
||||
fi
|
||||
|
||||
run() {
|
||||
local name="$1"
|
||||
shift
|
||||
echo "== $name =="
|
||||
"$@" 2>&1 | tee "artifacts/validation/$name.log"
|
||||
}
|
||||
|
||||
run python-self-test python3 tools/tpms_frame.py --self-test
|
||||
run native-tests "$PIO_BIN" test -e native
|
||||
run esp32-build "$PIO_BIN" run -e esp32dev
|
||||
run cppcheck "$PIO_BIN" check -e native \
|
||||
--flags='--enable=warning,performance,portability --inline-suppr' \
|
||||
--fail-on-defect=low
|
||||
|
||||
if [ ! -x "${RTL433:-$ROOT/.cache/rtl_433/build/src/rtl_433}" ] \
|
||||
|| [ ! -f "${REFERENCE_DIR:-$ROOT/.cache/rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01}/gfile001.cu8" ]; then
|
||||
run fetch-references bash ./tools/fetch_references.sh
|
||||
fi
|
||||
run rtl433 bash ./tools/verify_rtl433.sh
|
||||
|
||||
echo "PASS: wszystkie testy bez sprzetu zakonczone sukcesem"
|
||||
@@ -0,0 +1,27 @@
|
||||
#!/usr/bin/env bash
|
||||
# Pobiera i buduje dokladnie przypiete, niezalezne referencje RF.
|
||||
set -euo pipefail
|
||||
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
DEPS="${DEPS_DIR:-$ROOT/.cache}"
|
||||
RTL_COMMIT=406f9a33550a2b6b3d0d8a8a486417ce5b3f13ab
|
||||
TESTS_COMMIT=1aa8c29d6b9383739d1aeed495dbc5069b704392
|
||||
mkdir -p "$DEPS"
|
||||
|
||||
if [ ! -d "$DEPS/rtl_433/.git" ]; then
|
||||
git clone --filter=blob:none https://github.com/merbanan/rtl_433.git "$DEPS/rtl_433"
|
||||
fi
|
||||
git -C "$DEPS/rtl_433" checkout --detach "$RTL_COMMIT"
|
||||
if [ ! -x "$DEPS/rtl_433/build/src/rtl_433" ]; then
|
||||
cmake -S "$DEPS/rtl_433" -B "$DEPS/rtl_433/build" -DCMAKE_BUILD_TYPE=Release
|
||||
cmake --build "$DEPS/rtl_433/build" -j2
|
||||
fi
|
||||
|
||||
if [ ! -d "$DEPS/rtl_433_tests/.git" ]; then
|
||||
git clone --filter=blob:none --sparse https://github.com/merbanan/rtl_433_tests.git "$DEPS/rtl_433_tests"
|
||||
git -C "$DEPS/rtl_433_tests" sparse-checkout set tests/Schrader_EG53MA4_TPMS
|
||||
fi
|
||||
git -C "$DEPS/rtl_433_tests" checkout --detach "$TESTS_COMMIT"
|
||||
|
||||
printf 'RTL433=%s\nREFERENCE_DIR=%s\n' \
|
||||
"$DEPS/rtl_433/build/src/rtl_433" \
|
||||
"$DEPS/rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01"
|
||||
@@ -0,0 +1,9 @@
|
||||
#!/usr/bin/env bash
|
||||
# Wgrywa pelny obraz release; PORT=np. /dev/ttyUSB0. Kasuje flash ESP32.
|
||||
set -euo pipefail
|
||||
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
PORT="${PORT:?Ustaw PORT=/dev/ttyUSBX}"
|
||||
ESPTOOL="${ESPTOOL:-${PLATFORMIO_CORE_DIR:-$HOME/.platformio}/packages/tool-esptool/esptool}"
|
||||
IMAGE="$ROOT/artifacts/release/firmware-full.bin"
|
||||
[ -f "$IMAGE" ] || { echo "Brak $IMAGE; uruchom tools/package_release.sh"; exit 1; }
|
||||
"$ESPTOOL" --chip esp32 --port "$PORT" --baud 460800 write-flash 0x0 "$IMAGE"
|
||||
+41
-69
@@ -1,25 +1,5 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Synthesise a .cu8 IQ capture of the TPMS simulator's RF output.
|
||||
|
||||
The generated file is what an RTL-SDR would record while the ESP32+CC1101
|
||||
simulator is transmitting. Feed it to rtl_433 to verify the frame format
|
||||
without any hardware:
|
||||
|
||||
python3 tools/gen_cu8.py --id 2FC871 --pressure 260 --temp 23 -o /tmp/sim.cu8
|
||||
rtl_433 -r /tmp/sim.cu8
|
||||
|
||||
expected:
|
||||
model : Schrader-EG53MA4 id : 2FC871 pressure_kPa: 260.0 temperature_F: 73
|
||||
|
||||
Modulations:
|
||||
ook ASK/OOK, Manchester data (default; matches the rtl_433 reference
|
||||
capture and the built-in Schrader-EG53MA4 decoder)
|
||||
fsk 2-FSK, +/-47.6 kHz deviation, same data (verify with
|
||||
rtl_433 -X 'n=schrader,m=FSK_MC_ZEROBIT,s=120,l=120,r=300')
|
||||
|
||||
DISCLAIMER: diagnostic/test tool only, generates artificial pressure data.
|
||||
"""
|
||||
|
||||
"""Synteza CU8 OOK/Manchester dla niezaleznego testu rtl_433 (bez RF)."""
|
||||
import argparse
|
||||
import math
|
||||
import os
|
||||
@@ -27,73 +7,65 @@ import random
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
from tpms_frame import build_row, build_tx_bits, CHIP_US # noqa: E402
|
||||
from tpms_frame import build_row, build_tx_bits, CHIP_US
|
||||
|
||||
SAMPLE_RATE = 250000
|
||||
|
||||
|
||||
def synth(bits: str, mode: str, deviation_hz: float, amp: float, noise: float,
|
||||
rng: random.Random):
|
||||
"""Yield (i, q) int8 pairs for one chip string."""
|
||||
sps = SAMPLE_RATE * CHIP_US / 1e6 # samples per chip (~30)
|
||||
total = int(round(len(bits) * sps))
|
||||
def synth(bits: str, amp: float, noise: float, rng: random.Random):
|
||||
samples_per_chip = SAMPLE_RATE * CHIP_US / 1e6
|
||||
phase = 0.0
|
||||
for n in range(total):
|
||||
k = int(n / sps) % len(bits)
|
||||
bit = bits[k]
|
||||
if mode == "fsk":
|
||||
freq = deviation_hz if bit == "1" else -deviation_hz
|
||||
phase += 2 * math.pi * freq / SAMPLE_RATE
|
||||
a = amp
|
||||
else:
|
||||
a = amp if bit == "1" else 0.0
|
||||
i = a * math.cos(phase) + rng.gauss(0, noise)
|
||||
q = a * math.sin(phase) + rng.gauss(0, noise)
|
||||
yield i, q
|
||||
for n in range(int(round(len(bits) * samples_per_chip))):
|
||||
chip = bits[int(n / samples_per_chip) % len(bits)]
|
||||
amplitude = amp if chip == "1" else 0.0
|
||||
phase += 0.1 # dowolna nośna w pasmie IQ; demodulator uzywa amplitudy
|
||||
yield (amplitude * math.cos(phase) + rng.gauss(0, noise),
|
||||
amplitude * math.sin(phase) + rng.gauss(0, noise))
|
||||
|
||||
|
||||
def write_cu8(path, samples):
|
||||
with open(path, "wb") as f:
|
||||
with open(path, "wb") as output:
|
||||
for i, q in samples:
|
||||
f.write(bytes((max(0, min(255, int(round(i + 127.5)))),
|
||||
output.write(bytes((max(0, min(255, int(round(i + 127.5)))),
|
||||
max(0, min(255, int(round(q + 127.5)))))))
|
||||
|
||||
|
||||
def main() -> int:
|
||||
p = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||||
p.add_argument("--id", default="2FC871")
|
||||
p.add_argument("--pressure", type=float, default=260.0)
|
||||
p.add_argument("--temp", type=float, default=23.0)
|
||||
p.add_argument("--flags", default="4C900070")
|
||||
p.add_argument("--mode", choices=("ook", "fsk"), default="ook")
|
||||
p.add_argument("--deviation", type=float, default=47.6, help="FSK deviation kHz")
|
||||
p.add_argument("--frames", type=int, default=3)
|
||||
p.add_argument("--gap-ms", type=float, default=50.0, help="gap between burst frames")
|
||||
p.add_argument("--amp", type=float, default=60.0)
|
||||
p.add_argument("--noise", type=float, default=2.0)
|
||||
p.add_argument("-o", "--out", default="/tmp/opencode/tpms_ref/sim.cu8")
|
||||
args = p.parse_args()
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--id", default="2FC871")
|
||||
parser.add_argument("--pressure", type=float, default=260.0)
|
||||
parser.add_argument("--temp", type=float, default=23.0)
|
||||
parser.add_argument("--flags", default="4C900070")
|
||||
parser.add_argument("--frames", type=int, default=3)
|
||||
parser.add_argument("--gap-ms", type=float, default=50.0)
|
||||
parser.add_argument("--amp", type=float, default=60.0)
|
||||
parser.add_argument("--noise", type=float, default=2.0)
|
||||
parser.add_argument("--corrupt", choices=("checksum", "manchester", "truncate"))
|
||||
parser.add_argument("-o", "--out", required=True)
|
||||
args = parser.parse_args()
|
||||
if not 1 <= args.frames <= 32 or not 20 <= args.gap_ms <= 500:
|
||||
parser.error("frames=1..32, gap-ms=20..500")
|
||||
|
||||
row = build_row(int(args.id, 16), args.pressure, args.temp, int(args.flags, 16))
|
||||
if args.corrupt == "checksum":
|
||||
row = row[:-1] + ("0" if row[-1] == "1" else "1")
|
||||
bits = build_tx_bits(row)
|
||||
print(f"frame: {len(bits)} chips, tx bytes:"
|
||||
f" {' '.join(f'{int(bits[i:i+8],2):02X}' for i in range(0, len(bits), 8))}")
|
||||
|
||||
out_dir = os.path.dirname(os.path.abspath(args.out))
|
||||
if out_dir:
|
||||
os.makedirs(out_dir, exist_ok=True)
|
||||
if args.corrupt == "manchester":
|
||||
bits = bits[:20] + "00" + bits[22:]
|
||||
if args.corrupt == "truncate":
|
||||
bits = bits[:-24]
|
||||
|
||||
os.makedirs(os.path.dirname(os.path.abspath(args.out)), exist_ok=True)
|
||||
rng = random.Random(1)
|
||||
gap_sps = int(SAMPLE_RATE * args.gap_ms / 1000)
|
||||
out = []
|
||||
for f in range(args.frames):
|
||||
out.extend(synth(bits, args.mode, args.deviation * 1000, args.amp,
|
||||
args.noise, rng))
|
||||
out.extend((0.0, 0.0) for _ in range(gap_sps))
|
||||
write_cu8(args.out, out)
|
||||
print(f"wrote {args.out} ({len(out) / SAMPLE_RATE:.3f} s, {args.frames} frames)")
|
||||
gap = [(0.0, 0.0)] * int(SAMPLE_RATE * args.gap_ms / 1000)
|
||||
output = []
|
||||
for _ in range(args.frames):
|
||||
output.extend(synth(bits, args.amp, args.noise, rng))
|
||||
output.extend(gap)
|
||||
write_cu8(args.out, output)
|
||||
print(f"{args.out}: {len(output) / SAMPLE_RATE:.3f} s, {args.frames} ramek")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,37 @@
|
||||
#!/usr/bin/env bash
|
||||
# Buduje obrazy ESP32 i pelny obraz 4 MB oraz manifest SHA-256.
|
||||
set -euo pipefail
|
||||
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
cd "$ROOT"
|
||||
PIO_BIN="${PIO:-$ROOT/.venv/bin/pio}"
|
||||
if [ ! -x "$PIO_BIN" ]; then PIO_BIN="${PIO:-pio}"; fi
|
||||
export SOURCE_DATE_EPOCH="${SOURCE_DATE_EPOCH:-1761600000}"
|
||||
OUT="$ROOT/artifacts/release"
|
||||
BUILD="$ROOT/.pio/build/esp32dev"
|
||||
BOOT_APP0="${PLATFORMIO_CORE_DIR:-$HOME/.platformio}/packages/framework-arduinoespressif32/tools/partitions/boot_app0.bin"
|
||||
ESPTOOL="${ESPTOOL:-${PLATFORMIO_CORE_DIR:-$HOME/.platformio}/packages/tool-esptool/esptool}"
|
||||
|
||||
"$PIO_BIN" run -e esp32dev
|
||||
mkdir -p "$OUT"
|
||||
cp "$BUILD/bootloader.bin" "$BUILD/partitions.bin" "$BUILD/firmware.bin" \
|
||||
"$BUILD/firmware.elf" "$OUT/"
|
||||
cp "$BOOT_APP0" "$OUT/boot_app0.bin"
|
||||
"$ESPTOOL" --chip esp32 merge-bin -o "$OUT/firmware-full.bin" \
|
||||
--flash-mode dio --flash-freq 40m --flash-size 4MB \
|
||||
0x1000 "$OUT/bootloader.bin" 0x8000 "$OUT/partitions.bin" \
|
||||
0xe000 "$OUT/boot_app0.bin" 0x10000 "$OUT/firmware.bin"
|
||||
(
|
||||
cd "$OUT"
|
||||
sha256sum bootloader.bin partitions.bin boot_app0.bin firmware.bin \
|
||||
firmware-full.bin firmware.elf > SHA256SUMS
|
||||
)
|
||||
cat > "$OUT/BUILD-INFO.txt" <<'EOF'
|
||||
Wersja: 2.0.0-rc.1 (release candidate, bez HIL)
|
||||
PlatformIO: 6.1.18
|
||||
Platforma: espressif32 8.0.0
|
||||
CC1101: de6757ef633b3e626dae5c7835cdb66ab53f9a1d
|
||||
Adresy: 0x1000 bootloader, 0x8000 partitions, 0xe000 boot_app0, 0x10000 firmware
|
||||
Pelny obraz firmware-full.bin: flash od 0x0.
|
||||
EOF
|
||||
cat "$OUT/BUILD-INFO.txt"
|
||||
cat "$OUT/SHA256SUMS"
|
||||
@@ -0,0 +1,22 @@
|
||||
ajsonrpc==1.2.0
|
||||
anyio==4.15.1
|
||||
bottle==0.13.4
|
||||
certifi==2026.10.23
|
||||
charset-normalizer==3.5.2
|
||||
click==8.1.7
|
||||
colorama==0.4.6
|
||||
h11==0.16.0
|
||||
idna==3.20
|
||||
marshmallow==3.26.2
|
||||
packaging==26.3
|
||||
platformio==6.1.18
|
||||
pyelftools==0.33
|
||||
pyserial==3.5
|
||||
requests==2.34.2
|
||||
semantic-version==2.10.0
|
||||
starlette==0.46.2
|
||||
tabulate==0.10.0
|
||||
typing_extensions==4.16.0
|
||||
urllib3==2.8.0
|
||||
uvicorn==0.34.3
|
||||
wsproto==1.3.2
|
||||
+71
-198
@@ -1,241 +1,114 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Reference frame builder for the Schrader EG53MA4 TPMS simulator.
|
||||
"""Niezalezny model ramki EG53MA4 i testy pomocnicze (OOK/Manchester).
|
||||
|
||||
This tool mirrors bit-for-bit what the ESP32 firmware (src/tpms_frame.c)
|
||||
puts on air, and contains a copy of rtl_433's OOK_MC_ZEROBIT slicer
|
||||
(pulse_slicer_manchester_zerobit() from src/pulse_slicer.c) so the frame
|
||||
can be self-checked without any radio hardware.
|
||||
|
||||
Protocol reference: rtl_433 src/devices/schraeder.c (schrader_EG53MA4),
|
||||
"Schrader TPMS EG53MA4, Saab, Opel, Vauxhall, Chevrolet", and the reference
|
||||
capture rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01/gfile001.cu8.
|
||||
|
||||
On-air frame (G.E.T. Manchester, chip = one half bit-cell):
|
||||
|
||||
lead chip '1' + 119 two-chip cells + zero padding to a byte boundary
|
||||
|
||||
cell "01" -> data bit 0, cell "10" -> data bit 1 (G.E.T. MC, no inversion)
|
||||
|
||||
The rtl_433 MC_ZEROBIT slicer synthesises the very first bit of the decoded
|
||||
row (a hardcoded 0), so the transmitter sends the row *without* its first bit.
|
||||
Decoded row (120 bits) = 40 bit sync (zeros) + 80 bit payload:
|
||||
|
||||
SSSS SSSS SSSS SSSS SSSS SSSS SSSS SSSS | FFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFF
|
||||
IIII IIII IIII IIII IIII IIII | PPPP PPPP | TTTT TTTT | CCCC CCCC
|
||||
|
||||
- S: sync (40 bits, not checked by the decoder, kept as in real captures)
|
||||
- F: flags (32 bit) - status / battery nibble, unanalysed upstream
|
||||
- I: sensor id (24 bit)
|
||||
- P: pressure, 25 mbar per bit (kPa = byte * 2.5)
|
||||
- T: temperature, degrees Fahrenheit
|
||||
- C: checksum = sum(bytes[0..8]) & 0xff
|
||||
|
||||
DISCLAIMER: this is a diagnostic/test tool. It generates *artificial* tyre
|
||||
pressure data and is no replacement for real TPMS sensors.
|
||||
Referencje: rtl_433 commit 406f9a33550a2b6b3d0d8a8a486417ce5b3f13ab,
|
||||
rtl_433_tests commit 1aa8c29d6b9383739d1aeed495dbc5069b704392.
|
||||
Narzedzie generuje sztuczne dane wylacznie do diagnostyki.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import math
|
||||
import sys
|
||||
|
||||
# --- protocol constants (keep in sync with src/config.h / src/tpms_frame.c) ---
|
||||
CHIP_US = 120.0 # one Manchester half bit-cell, 8.333 kBaud chip rate
|
||||
FRAME_BITS = 120 # decoded row length expected by schrader_EG53MA4
|
||||
CHIP_US = 120.0
|
||||
FRAME_BITS = 120
|
||||
SYNC_BITS = 40
|
||||
TX_BYTES = 30 # 240 chips = 1 lead + 238 data + 1 pad
|
||||
DEFAULT_FLAGS = 0x4C900070 # captured from real EG53MA4 sensors
|
||||
TX_BYTES = 30
|
||||
DEFAULT_FLAGS = 0x4C900070
|
||||
|
||||
|
||||
def valid_id(sensor_id: int) -> bool:
|
||||
return 0 < sensor_id < 0xFFFFFF
|
||||
|
||||
|
||||
def cell(bit: int) -> str:
|
||||
"""G.E.T. Manchester cell for one data bit."""
|
||||
return "01" if bit == 0 else "10"
|
||||
|
||||
|
||||
def build_row(sensor_id: int, pressure_kpa: float, temp_c: float,
|
||||
flags: int = DEFAULT_FLAGS, low_batt: bool = False,
|
||||
flags_lowbat_mask: int = 0x00000008) -> str:
|
||||
"""Return the 120 decoded row bits as a string of '0'/'1'.
|
||||
|
||||
Uses the same half-up integer rounding as src/tpms_frame.cpp.
|
||||
"""
|
||||
flags: int = DEFAULT_FLAGS) -> str:
|
||||
if not valid_id(sensor_id):
|
||||
raise ValueError("ID musi byc w zakresie 000001..FFFFFE")
|
||||
if not 0 <= flags <= 0xFFFFFFFF:
|
||||
raise ValueError("flags musza miec 32 bity")
|
||||
kpa10 = int(math.floor(pressure_kpa * 10.0 + 0.5))
|
||||
press_byte = min(max((kpa10 + 12) // 25, 0), 255) # 2.5 kPa per bit
|
||||
if not 0 <= kpa10 <= 6375:
|
||||
raise ValueError("cisnienie musi byc w zakresie 0..637.5 kPa")
|
||||
press_byte = (kpa10 + 12) // 25
|
||||
tc = int(math.floor(temp_c + 0.5))
|
||||
num = 9 * tc + 160 # temp_F = (9C+160)/5
|
||||
if not -40 <= tc <= 85:
|
||||
raise ValueError("temperatura musi byc w zakresie -40..85 C")
|
||||
num = 9 * tc + 160
|
||||
temp_f = (num + 2) // 5 if num >= 0 else -((-num + 2) // 5)
|
||||
temp_f = min(max(temp_f, 0), 255)
|
||||
if low_batt:
|
||||
flags |= flags_lowbat_mask
|
||||
payload = [
|
||||
(flags >> 24) & 0xFF,
|
||||
(flags >> 16) & 0xFF,
|
||||
(flags >> 8) & 0xFF,
|
||||
flags & 0xFF,
|
||||
(sensor_id >> 16) & 0xFF,
|
||||
(sensor_id >> 8) & 0xFF,
|
||||
sensor_id & 0xFF,
|
||||
press_byte,
|
||||
temp_f,
|
||||
]
|
||||
payload.append(sum(payload) & 0xFF)
|
||||
row = "0" * SYNC_BITS
|
||||
for b in payload:
|
||||
row += f"{b:08b}"
|
||||
assert len(row) == FRAME_BITS
|
||||
return row
|
||||
payload = [flags >> 24, (flags >> 16) & 255, (flags >> 8) & 255,
|
||||
flags & 255, sensor_id >> 16, (sensor_id >> 8) & 255,
|
||||
sensor_id & 255, press_byte, temp_f]
|
||||
payload.append(sum(payload) & 255)
|
||||
return "0" * SYNC_BITS + "".join(f"{byte:08b}" for byte in payload)
|
||||
|
||||
|
||||
def build_tx_bits(row: str) -> str:
|
||||
"""Return the chip bit string actually shifted into the CC1101 FIFO.
|
||||
|
||||
240 chips: 1 lead chip + 119 two-chip cells + 1 pad chip = 30 bytes.
|
||||
"""
|
||||
assert len(row) == FRAME_BITS
|
||||
bits = "1" # lead chip (carrier on)
|
||||
for b in row[1:]: # row[0] is synthesised by the receiver
|
||||
bits += cell(int(b))
|
||||
while len(bits) % 8: # pad with 'off' chips (silence for OOK)
|
||||
bits += "0"
|
||||
return bits
|
||||
if len(row) != FRAME_BITS:
|
||||
raise ValueError("ramka musi miec 120 bitow")
|
||||
bits = "1" + "".join(cell(int(bit)) for bit in row[1:])
|
||||
return bits.ljust(TX_BYTES * 8, "0")
|
||||
|
||||
|
||||
def tx_bytes(bits: str) -> bytes:
|
||||
assert len(bits) % 8 == 0
|
||||
if len(bits) != TX_BYTES * 8:
|
||||
raise ValueError("bufor nadawczy musi miec 30 bajtow")
|
||||
return bytes(int(bits[i:i + 8], 2) for i in range(0, len(bits), 8))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Reference slicer: verbatim model of rtl_433 pulse_slicer_manchester_zerobit()
|
||||
# (src/pulse_slicer.c), used for self-testing the encoder.
|
||||
# ---------------------------------------------------------------------------
|
||||
def mc_zerobit_slicer(chips, short_us=123.0, chip_us=CHIP_US, reset_us=300.0):
|
||||
runs = [] # (level, length_us)
|
||||
cur, cnt = chips[0], 1
|
||||
for c in chips[1:]:
|
||||
if c == cur:
|
||||
cnt += 1
|
||||
else:
|
||||
runs.append((cur, cnt * chip_us))
|
||||
cur, cnt = c, 1
|
||||
runs.append((cur, cnt * chip_us))
|
||||
|
||||
pairs = [] # (pulse_us, gap_us)
|
||||
i = 0
|
||||
while i < len(runs):
|
||||
lvl, ln = runs[i]
|
||||
if lvl:
|
||||
gap = runs[i + 1][1] if i + 1 < len(runs) and not runs[i + 1][0] else 0.0
|
||||
pairs.append((ln, gap))
|
||||
i += 2
|
||||
else:
|
||||
pairs.append((0.0, ln))
|
||||
i += 1
|
||||
|
||||
row = ["0"] # hardcoded leading zero bit
|
||||
t = 0.0
|
||||
for n, (pulse, gap) in enumerate(pairs):
|
||||
last = n == len(pairs) - 1
|
||||
if pulse + t > short_us * 1.5:
|
||||
row.append("1")
|
||||
t = 0.0
|
||||
else:
|
||||
t += pulse
|
||||
if last:
|
||||
break
|
||||
if gap > reset_us:
|
||||
break # end of message
|
||||
if gap + t > short_us * 1.5:
|
||||
row.append("0")
|
||||
t = 0.0
|
||||
else:
|
||||
t += gap
|
||||
return "".join(row)
|
||||
|
||||
|
||||
def decode_row(row: str):
|
||||
if len(row) != FRAME_BITS:
|
||||
return None
|
||||
by = [int(row[SYNC_BITS + 8 * k:SYNC_BITS + 8 * (k + 1)], 2) for k in range(10)]
|
||||
return {
|
||||
"flags": by[0] << 24 | by[1] << 16 | by[2] << 8 | by[3],
|
||||
"id": by[4] << 16 | by[5] << 8 | by[6],
|
||||
"pressure_kPa": by[7] * 2.5,
|
||||
"temperature_F": by[8],
|
||||
"checksum_ok": (sum(by[:9]) & 0xFF) == by[9],
|
||||
"bytes": by,
|
||||
}
|
||||
data = [int(row[SYNC_BITS + 8 * i:SYNC_BITS + 8 * (i + 1)], 2)
|
||||
for i in range(10)]
|
||||
return {"flags": int.from_bytes(bytes(data[:4]), "big"),
|
||||
"id": int.from_bytes(bytes(data[4:7]), "big"),
|
||||
"pressure_kPa": data[7] * 2.5, "temperature_F": data[8],
|
||||
"checksum_ok": sum(data[:9]) & 255 == data[9], "bytes": data}
|
||||
|
||||
|
||||
def self_test() -> int:
|
||||
"""Cross-check against the rtl_433 reference capture (gfile001.cu8)."""
|
||||
fails = 0
|
||||
ref = build_row(0x2FC871, 0.0, (90 - 32) * 5 / 9, flags=0x4C900070)
|
||||
# the capture carries temperature as the raw byte 90 (0x5A) = 90 F
|
||||
ref_row = ("0" * 40
|
||||
+ "01001100100100000000000001110000001011111100100001110001000000000101101000001110")
|
||||
if ref_row[40:] != ref[40:]:
|
||||
print("FAIL: reference capture row mismatch")
|
||||
print(" want:", ref_row)
|
||||
print(" got :", ref)
|
||||
fails += 1
|
||||
|
||||
# random round trip: encode -> slicer -> data must survive intact
|
||||
expected = [0x4C, 0x90, 0, 0x70, 0x2F, 0xC8, 0x71, 0, 0x5A, 0x0E]
|
||||
row = build_row(0x2FC871, 0, 32)
|
||||
got = decode_row(row)["bytes"]
|
||||
if got != expected:
|
||||
print(f"FAIL: nagranie gfile001: {got} != {expected}")
|
||||
return 1
|
||||
import random
|
||||
random.seed(42)
|
||||
rng = random.Random(42)
|
||||
for _ in range(500):
|
||||
sid = random.randrange(0, 0x1000000)
|
||||
kpa = round(random.uniform(0, 637.5), 1)
|
||||
tc = random.uniform(-40, 85)
|
||||
row = build_row(sid, kpa, tc)
|
||||
bits = build_tx_bits(row)
|
||||
chips = [int(b) for b in bits]
|
||||
out = mc_zerobit_slicer(chips)
|
||||
if len(out) != FRAME_BITS or out[SYNC_BITS:] != row[SYNC_BITS:]:
|
||||
print("FAIL: round trip", hex(sid), kpa, tc)
|
||||
print(" row:", row)
|
||||
print(" out:", out)
|
||||
fails += 1
|
||||
break
|
||||
d = decode_row(out)
|
||||
if not d["checksum_ok"] or d["id"] != sid:
|
||||
print("FAIL: decode", hex(sid), d)
|
||||
fails += 1
|
||||
break
|
||||
print("self-test:", "OK" if fails == 0 else "FAILED")
|
||||
return 1 if fails else 0
|
||||
sensor_id = rng.randrange(1, 0xFFFFFF)
|
||||
pressure = round(rng.uniform(0, 637.5), 1)
|
||||
temp = rng.randrange(-40, 86)
|
||||
decoded = decode_row(build_row(sensor_id, pressure, temp))
|
||||
if not decoded["checksum_ok"] or decoded["id"] != sensor_id:
|
||||
print("FAIL: round trip")
|
||||
return 1
|
||||
print("self-test: OK (nagranie + 500 ramek)")
|
||||
return 0
|
||||
|
||||
|
||||
def main() -> int:
|
||||
p = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||||
p.add_argument("--id", default="2FC871", help="sensor id (hex, 24 bit)")
|
||||
p.add_argument("--pressure", type=float, default=260.0, help="kPa")
|
||||
p.add_argument("--temp", type=float, default=23.0, help="deg C")
|
||||
p.add_argument("--flags", default="4C900070", help="flags word (hex)")
|
||||
p.add_argument("--low-batt", action="store_true")
|
||||
p.add_argument("--self-test", action="store_true")
|
||||
args = p.parse_args()
|
||||
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--id", default="2FC871")
|
||||
parser.add_argument("--pressure", type=float, default=260.0)
|
||||
parser.add_argument("--temp", type=float, default=23.0)
|
||||
parser.add_argument("--flags", default="4C900070")
|
||||
parser.add_argument("--self-test", action="store_true")
|
||||
args = parser.parse_args()
|
||||
if args.self_test:
|
||||
return self_test()
|
||||
|
||||
sid = int(args.id, 16)
|
||||
flags = int(args.flags, 16)
|
||||
row = build_row(sid, args.pressure, args.temp, flags, args.low_batt)
|
||||
bits = build_tx_bits(row)
|
||||
raw = tx_bytes(bits)
|
||||
d = decode_row(row)
|
||||
|
||||
print(f"row (120 bit): {row}")
|
||||
print(f"chips({len(bits):3d} bit): {bits}")
|
||||
print(f"tx bytes ({len(raw)}): {' '.join(f'{b:02X}' for b in raw)}")
|
||||
print(f"payload : {' '.join(f'{b:02X}' for b in d['bytes'])}")
|
||||
print(f"checksum: {'OK' if d['checksum_ok'] else 'BAD'}")
|
||||
print(f"id={d['id']:06X} pressure={d['pressure_kPa']:.1f} kPa "
|
||||
f"temperature={d['temperature_F']} F ({args.temp:.0f} C) flags={d['flags']:08X}")
|
||||
out = mc_zerobit_slicer([int(b) for b in bits])
|
||||
print(f"slicer check: {'OK' if out[SYNC_BITS:] == row[SYNC_BITS:] and len(out) == FRAME_BITS else 'FAILED'}")
|
||||
row = build_row(int(args.id, 16), args.pressure, args.temp, int(args.flags, 16))
|
||||
raw = tx_bytes(build_tx_bits(row))
|
||||
decoded = decode_row(row)
|
||||
print(f"row: {row}\ntx: {raw.hex()}")
|
||||
print("payload: " + " ".join(f"{byte:02X}" for byte in decoded["bytes"]))
|
||||
print(f"id={decoded['id']:06X} pressure={decoded['pressure_kPa']:.1f} kPa "
|
||||
f"temp={decoded['temperature_F']} F flags={decoded['flags']:08X}")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,100 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Walidacja prawdziwych i syntetycznych CU8 przez przypiety rtl_433."""
|
||||
import argparse
|
||||
import json
|
||||
import pathlib
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
|
||||
EXPECTED = {
|
||||
"gfile001.cu8": ("2FC871", 90.0),
|
||||
"gfile002.cu8": ("2EAAF9", 90.0),
|
||||
"gfile003.cu8": ("3495AC", 90.0),
|
||||
"gfile004.cu8": ("2FC780", 91.0),
|
||||
}
|
||||
|
||||
|
||||
def decode(rtl433: str, capture: pathlib.Path):
|
||||
result = subprocess.run([rtl433, "-q", "-F", "json", "-r", str(capture)],
|
||||
text=True, capture_output=True, check=False)
|
||||
records = []
|
||||
for line in result.stdout.splitlines():
|
||||
try:
|
||||
record = json.loads(line)
|
||||
except json.JSONDecodeError:
|
||||
continue
|
||||
if record.get("model") == "Schrader-EG53MA4":
|
||||
records.append(record)
|
||||
return result.returncode, records, result.stdout + result.stderr
|
||||
|
||||
|
||||
def require(condition, message, failures):
|
||||
if not condition:
|
||||
failures.append(message)
|
||||
return condition
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--rtl433", required=True)
|
||||
parser.add_argument("--reference-dir", required=True, type=pathlib.Path)
|
||||
args = parser.parse_args()
|
||||
root = pathlib.Path(__file__).resolve().parent.parent
|
||||
failures = []
|
||||
print("rtl_433 commit: 406f9a33550a2b6b3d0d8a8a486417ce5b3f13ab")
|
||||
print("rtl_433_tests commit: 1aa8c29d6b9383739d1aeed495dbc5069b704392")
|
||||
|
||||
for filename, (sensor_id, temp_f) in EXPECTED.items():
|
||||
capture = args.reference_dir / filename
|
||||
if not require(capture.is_file(), f"brak {capture}", failures):
|
||||
continue
|
||||
status, records, raw = decode(args.rtl433, capture)
|
||||
valid = status == 0 and len(records) == 16 and all(
|
||||
record.get("id") == sensor_id and record.get("flags") == "4c900070"
|
||||
and record.get("pressure_kPa") == 0.0
|
||||
and record.get("temperature_F") == temp_f
|
||||
and record.get("mic") == "CHECKSUM" for record in records)
|
||||
require(valid, f"{filename}: niezgodne rekordy\n{raw}", failures)
|
||||
print(f"{'OK' if valid else 'FAIL'} referencja {filename}: "
|
||||
f"{len(records)}/16, id={sensor_id}, flags=4c900070")
|
||||
|
||||
synthetic = [("2FC871", 260, 23, 73.0), ("3495AC", 220, -5, 23.0),
|
||||
("ABCDEE", 262.5, 24, 75.0)]
|
||||
with tempfile.TemporaryDirectory(prefix="tpms-rtl433-") as temp:
|
||||
for index, (sensor_id, pressure, temp_c, temp_f) in enumerate(synthetic):
|
||||
capture = pathlib.Path(temp) / f"valid{index}.cu8"
|
||||
subprocess.run([sys.executable, str(root / "tools/gen_cu8.py"),
|
||||
"--id", sensor_id, "--pressure", str(pressure),
|
||||
"--temp", str(temp_c), "-o", str(capture)],
|
||||
check=True, capture_output=True)
|
||||
status, records, raw = decode(args.rtl433, capture)
|
||||
valid = status == 0 and len(records) >= 1 and all(
|
||||
record.get("id") == sensor_id
|
||||
and record.get("pressure_kPa") == pressure
|
||||
and record.get("temperature_F") == temp_f
|
||||
and record.get("flags") == "4c900070"
|
||||
and record.get("mic") == "CHECKSUM" for record in records)
|
||||
require(valid, f"syntetyczna {sensor_id}: {raw}", failures)
|
||||
print(f"{'OK' if valid else 'FAIL'} syntetyczna id={sensor_id}: "
|
||||
f"{len(records)} dekodowan, {pressure:.1f} kPa, {temp_f:.1f} F")
|
||||
|
||||
for corruption in ("checksum", "manchester", "truncate"):
|
||||
capture = pathlib.Path(temp) / f"bad-{corruption}.cu8"
|
||||
subprocess.run([sys.executable, str(root / "tools/gen_cu8.py"),
|
||||
"--corrupt", corruption, "-o", str(capture)],
|
||||
check=True, capture_output=True)
|
||||
status, records, raw = decode(args.rtl433, capture)
|
||||
valid = status == 0 and not records
|
||||
require(valid, f"negatywny {corruption}: blednie zdekodowano\n{raw}", failures)
|
||||
print(f"{'OK' if valid else 'FAIL'} negatywny {corruption}: "
|
||||
f"{len(records)} dekodowan (oczekiwano 0)")
|
||||
|
||||
print(f"WYNIK: {'PASS' if not failures else 'FAIL'}; bledow={len(failures)}")
|
||||
for failure in failures:
|
||||
print(" - " + failure)
|
||||
return 1 if failures else 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
+9
-90
@@ -1,91 +1,10 @@
|
||||
#!/usr/bin/env bash
|
||||
# verify_rtl433.sh - automatyczna weryfikacja ramek symulatora TPMS
|
||||
# Schrader EG53MA4 za pomoca prawdziwego dekodera rtl_433 (bez sprzetu RF).
|
||||
#
|
||||
# Wymaga: python3, rtl_433 (binarka w PATH albo w zmiennej RTL433)
|
||||
#
|
||||
# Uzycie:
|
||||
# RTL433=/sciezka/do/rtl_433 ./tools/verify_rtl433.sh
|
||||
#
|
||||
# Skrypt:
|
||||
# 1) generuje syntezyczne nagrania IQ (.cu8) takie, jakie odbierze RTL-SDR
|
||||
# podczas nadawania symulatora,
|
||||
# 2) dekoduje je rtl_433 i porownuje wynik z zadanymi wartosciami:
|
||||
# - OOK: wbudowany dekoder Schrader-EG53MA4 (model/id/pressure/temp)
|
||||
# - FSK: dekoder flex, porownanie calego bitstreamu z ramka wzorcowa
|
||||
#
|
||||
# Uwaga: nazwy plikow nie moga zawierac tokenow "ook"/"fsk"/"am"/"fm" -
|
||||
# parser formatow rtl_433 traktuje je jako opis formatu pliku.
|
||||
set -u
|
||||
|
||||
RTL433="${RTL433:-rtl_433}"
|
||||
DIR="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
TMP="${TMPDIR:-/tmp}/tpms_verify_$$"
|
||||
mkdir -p "$TMP"
|
||||
|
||||
if ! command -v "$RTL433" >/dev/null 2>&1; then
|
||||
echo "BLAD: nie znaleziono rtl_433 (ustaw zmienna RTL433=...)"; exit 1
|
||||
fi
|
||||
|
||||
fail=0
|
||||
|
||||
check_ook() { # $1=plik $2=id $3=kPa $4=temp_F
|
||||
local file="$1" id="$2" kpa="$3" tf="$4"
|
||||
local out
|
||||
out="$("$RTL433" -r "$file" 2>/dev/null)"
|
||||
if echo "$out" | grep -qi "Schrader-EG53MA4" \
|
||||
&& echo "$out" | grep -q "ID : $id" \
|
||||
&& echo "$out" | grep -q "Pressure : $kpa kPa" \
|
||||
&& echo "$out" | grep -q "Temperature: $tf"; then
|
||||
echo "OK $(basename "$file") id=$id $kpa kPa $tf F"
|
||||
else
|
||||
echo "FAIL $(basename "$file") (oczekiwano id=$id $kpa kPa $tf F)"
|
||||
echo "$out" | sed 's/^/ /'
|
||||
fail=1
|
||||
fi
|
||||
}
|
||||
|
||||
check_fsk() { # $1=plik $2=id $3=kPa $4=temp_C
|
||||
local file="$1" id="$2" kpa="$3" tc="$4"
|
||||
local out codes want
|
||||
out="$("$RTL433" -r "$file" \
|
||||
-X 'n=schrader,m=FSK_MC_ZEROBIT,s=120,l=120,r=300' 2>/dev/null)"
|
||||
codes="$(echo "$out" | grep -o 'codes : {120}[0-9a-f]*' | head -1 | sed 's/.*{120}//')"
|
||||
want="0000000000$(python3 "$DIR/tools/tpms_frame.py" --id "$id" \
|
||||
--pressure "$kpa" --temp "$tc" | grep payload | sed 's/.*payload : //' \
|
||||
| tr 'A-Z' 'a-z' | tr -d ' ')"
|
||||
if [ -n "$codes" ] && [ "$codes" = "$want" ]; then
|
||||
echo "OK $(basename "$file") (FSK) bitstream zgodny: $codes"
|
||||
else
|
||||
echo "FAIL $(basename "$file") (FSK)"
|
||||
echo " otrzymano: ${codes:-<brak>}"
|
||||
echo " oczekiwano: $want"
|
||||
fail=1
|
||||
fi
|
||||
}
|
||||
|
||||
echo "== OOK (domyslna modulacja, wbudowany dekoder Schrader-EG53MA4) =="
|
||||
python3 "$DIR/tools/gen_cu8.py" --id 2FC871 --pressure 260 --temp 23 \
|
||||
-o "$TMP/c1.cu8" >/dev/null
|
||||
check_ook "$TMP/c1.cu8" 2FC871 260.0 73.0
|
||||
|
||||
python3 "$DIR/tools/gen_cu8.py" --id 3495AC --pressure 220 --temp -5 \
|
||||
-o "$TMP/c2.cu8" >/dev/null
|
||||
check_ook "$TMP/c2.cu8" 3495AC 220.0 23.0
|
||||
|
||||
python3 "$DIR/tools/gen_cu8.py" --id ABCDEE --pressure 262.5 --temp 24 \
|
||||
-o "$TMP/c3.cu8" >/dev/null
|
||||
check_ook "$TMP/c3.cu8" ABCDEE 262.5 75.0
|
||||
|
||||
echo "== FSK (wariant konfigurowalny, dekoder flex) =="
|
||||
python3 "$DIR/tools/gen_cu8.py" --id 2FC871 --pressure 260 --temp 23 \
|
||||
--mode fsk -o "$TMP/c4.cu8" >/dev/null
|
||||
check_fsk "$TMP/c4.cu8" 2FC871 260 23
|
||||
|
||||
rm -rf "$TMP"
|
||||
if [ "$fail" -eq 0 ]; then
|
||||
echo "WSZYSTKO OK - ramki dekoduja sie poprawnie przez rtl_433"
|
||||
else
|
||||
echo "WERYFIKACJA NIEUDANA"
|
||||
fi
|
||||
exit "$fail"
|
||||
# Zwraca niezerowy kod przy bledzie i zapisuje czytelny raport.
|
||||
set -euo pipefail
|
||||
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
||||
RTL433="${RTL433:-$ROOT/.cache/rtl_433/build/src/rtl_433}"
|
||||
REFERENCE_DIR="${REFERENCE_DIR:-$ROOT/.cache/rtl_433_tests/tests/Schrader_EG53MA4_TPMS/01}"
|
||||
REPORT_DIR="${REPORT_DIR:-$ROOT/artifacts/validation}"
|
||||
mkdir -p "$REPORT_DIR"
|
||||
python3 "$ROOT/tools/verify_rtl433.py" --rtl433 "$RTL433" \
|
||||
--reference-dir "$REFERENCE_DIR" | tee "$REPORT_DIR/rtl433-report.txt"
|
||||
Reference in new issue
Block a user