Release candidate 2.0.0-rc.1 #1
No files matched your search
@@ -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 */
|
||||
+36
-180
@@ -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
|
||||
/* 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
|
||||
|
||||
/* ======================================================================
|
||||
* 2. PINY (ESP32 DevKit + CC1101 po SPI)
|
||||
* Piny CC1101 zgodne z wymaganiami projektu:
|
||||
* SCK=18 MISO=19 MOSI=23 CS=5 GDO0=2
|
||||
* ====================================================================== */
|
||||
#define PIN_CC1101_SCK 18
|
||||
#define PIN_CC1101_MISO 19
|
||||
#define PIN_CC1101_MOSI 23
|
||||
#define PIN_CC1101_CS 5
|
||||
#define PIN_CC1101_GDO0 2
|
||||
#define PIN_BUTTON 26
|
||||
#define BTN_ACTIVE_LEVEL 0
|
||||
#define PIN_LED 27
|
||||
|
||||
/* 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)
|
||||
/* 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
|
||||
#endif
|
||||
#ifndef PIN_VBAT_ADC
|
||||
#define PIN_VBAT_ADC 34
|
||||
#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
|
||||
|
||||
/* LED statusowy (rezystor szeregowy 330R, aktywny wysoki). */
|
||||
#define PIN_LED 27
|
||||
/* Jedyny profil produkcyjny: OOK, Manchester 0->01, 1->10. */
|
||||
#define TPMS_CHIP_US 120u
|
||||
|
||||
/* 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
|
||||
/* 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
|
||||
|
||||
/* 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. */
|
||||
#define PIN_ACC -1
|
||||
#define BTN_DEBOUNCE_MS 30u
|
||||
#define BTN_LONG_MS 1500u
|
||||
#define BTN_VERYLONG_MS 4000u
|
||||
|
||||
/* 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. */
|
||||
#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)
|
||||
#define VBAT_SAMPLES 16
|
||||
|
||||
/* ======================================================================
|
||||
* 3. CZUJNIKI - 4 identyfikatory (hex, po jednym na kolo)
|
||||
* Kolejnosc nauki w Astrze: przod lewy -> przod prawy -> tyl prawy -> tyl lewy
|
||||
* ID sa przykladowe (24-bit). Najlepiej przepisz ID ze starych czujnikow
|
||||
* (odczytaj je rtl_433: rtl_433 -f 433.92M) - auto wtedy "widzi" znajome ID.
|
||||
* ====================================================================== */
|
||||
#define WHEEL_FL 0
|
||||
#define WHEEL_FR 1
|
||||
#define WHEEL_RR 2
|
||||
#define WHEEL_RL 3
|
||||
#define WHEEL_COUNT 4
|
||||
|
||||
/* Kolejnosc nauki (kolejnosc pozycji w tablicy SENSOR[] ponizej = kolejnosc
|
||||
* learn; domyslnie FL -> FR -> RR -> RL). Kolejnosc mozesz zmienic po prostu
|
||||
* przestawiajac wpisy w tablicy SENSOR[] w main.cpp (lub zmieniajac ponizsze
|
||||
* makra kolejnosci w trybie learn). */
|
||||
#define LEARN_ORDER_0 WHEEL_FL
|
||||
#define LEARN_ORDER_1 WHEEL_FR
|
||||
#define LEARN_ORDER_2 WHEEL_RR
|
||||
#define LEARN_ORDER_3 WHEEL_RL
|
||||
|
||||
/* ID poszczegolnych kol (24 bity) */
|
||||
#define SENSOR_FL_ID 0x2FC871u
|
||||
#define SENSOR_FR_ID 0x2EAAF9u
|
||||
#define SENSOR_RR_ID 0x3495ACu
|
||||
#define SENSOR_RL_ID 0x2FC780u
|
||||
|
||||
/* Cisnienie startowe: DOMYSLNIE 2,6 bar = 260 kPa dla wszystkich kol.
|
||||
* Rozdzielczosc protokolu: 2,5 kPa/bit (0-637,5 kPa). */
|
||||
#define SENSOR_FL_PRESS_KPA 260.0f
|
||||
#define SENSOR_FR_PRESS_KPA 260.0f
|
||||
#define SENSOR_RR_PRESS_KPA 260.0f
|
||||
#define SENSOR_RL_PRESS_KPA 260.0f
|
||||
|
||||
/* Temperatura otoczenia (st. C) - konwertowana na st. F wg protokolu. */
|
||||
#define SENSOR_TEMP_C 23
|
||||
|
||||
/* ======================================================================
|
||||
* 4. PARAMETRY RF (Schrader EG53MA4)
|
||||
* - dane: Manchester G.E.T. MC, chip = 120 us (8.33 kBaud)
|
||||
* - nośna 433.92 MHz
|
||||
* - modulacja: ASK/OOK (domyślna - tak pracuje referencyjny EG53MA4 z
|
||||
* nagran rtl_433_tests i tak dekoderuje wbudowany Schrader-EG53MA4)
|
||||
* albo 2-FSK z dewiacja 47.6 kHz (wariant konfigurowalny - jesli Twoj
|
||||
* nadajnik/odbiornik auta pracuje FSK, przełacz MODE_FSK).
|
||||
* ====================================================================== */
|
||||
#define MODE_OOK 0
|
||||
#define MODE_FSK 1
|
||||
|
||||
#define TPMS_FREQUENCY_MHZ 433.92f
|
||||
#define TPMS_MODULATION MODE_OOK
|
||||
#define TPMS_DEVIATION_KHZ 47.6f // dla MODE_FSK
|
||||
#define TPMS_TX_POWER_DBM 10 // -30,-20,-15,-10,-6,0,5,7,10,11,12
|
||||
#define TPMS_CHIP_US 120 // czas trwania jednego chipa Manchester
|
||||
// (8.33 kBaud - zmierzone na nagraniach)
|
||||
|
||||
/* Ramka (dane z dekodera rtl_433 schrader_EG53MA4):
|
||||
* 40 bit sync + 4 bajty flags + 3 bajty ID + cisnienie + temperatura + CRC.
|
||||
* Suma kontrolna: suma 9 bajtow modulo 256 (add_bytes). */
|
||||
#define TPMS_FLAGS 0x4C900070u // flags ze zrzutow prawdziwych czujnikow
|
||||
#define TPMS_FLAGS_LOWBAT_MASK 0x00000008u // bit "rozladowana bateria"
|
||||
// (pozycja niepewna - dostosuj
|
||||
// jesli Twoj sterownik oczekuje
|
||||
// innego bitu)
|
||||
|
||||
/* ======================================================================
|
||||
* 5. HARMONOGRAM NADAWANIA / SEN
|
||||
* ====================================================================== */
|
||||
#define TX_BURST_FRAMES 3 // 3-6 ramek w burście (jak prawdziwy czujnik)
|
||||
#define TX_FRAME_GAP_MS 50 // odstep miedzy ramkami w burscie
|
||||
#define TX_INTERVAL_S 30 // interwal: kazde kolo co 30 s
|
||||
#define TX_INTERVAL_IGNITION_S 15 // krotki interwal przy zaplonie (ACC)
|
||||
#define TX_INTERVAL_PARKING_S 120 // interwal postojowy po zaniku ACC
|
||||
#define ACC_GRACE_MS (5UL*60UL*1000UL) // 5 min po zaniku ACC
|
||||
#define PARKING_SHUTDOWN 0 // 1 = po ACC_GRACE calkowite uspienie
|
||||
// (sen bez budzika, obudza przycisk/LF)
|
||||
#define BOOT_STAY_AWAKE_MS 3000 // okno na konsoli szeregowej po starcie
|
||||
|
||||
/* ======================================================================
|
||||
* 6. TRYB LEARN / SINGLE
|
||||
* ====================================================================== */
|
||||
#define LEARN_TX_PERIOD_MS 2000 // co ile ms wysylac bursta w learn
|
||||
#define LEARN_WINDOW_MS 60000 // okno czasowe na 1 czujnik (60 s)
|
||||
#define LEARN_WINDOW_EXPIRE_TO_NORMAL 1 // 1 = po uplywie okna powrot do
|
||||
// trybu normalnego (wg specyfikacji),
|
||||
// 0 = automatycznie kolejne kolo,
|
||||
// po ostatnim -> NORMAL
|
||||
#define LEARN_TOTAL_TIMEOUT_MS 900000 // bezpiecznik: 15 min i koniec learn
|
||||
#define SINGLE_TIMEOUT_MS 300000 // 0 = bez limitu
|
||||
|
||||
/* ======================================================================
|
||||
* 7. PROGI / DIAGNOSTYKA
|
||||
* ====================================================================== */
|
||||
#define LOWBATT_THRESHOLD_MV 11500 // dla POWER_12V (prog alarmu TPMS)
|
||||
// dla POWER_BATTERY ustaw np. 3200
|
||||
#define SERIAL_BAUD 115200
|
||||
|
||||
/* ======================================================================
|
||||
* 8. GESTY PRZYCISKU
|
||||
* ====================================================================== */
|
||||
#define BTN_DEBOUNCE_MS 30
|
||||
#define BTN_LONG_MS 1500 // >= 1.5 s = wejscie/wyjscie LEARN
|
||||
#define BTN_VERYLONG_MS 4000 // >= 4 s = wejscie/wyjscie SINGLE
|
||||
|
||||
#endif /* TPMS_CONFIG_H */
|
||||
#endif
|
||||
+262
-170
@@ -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 w;
|
||||
if (arg1 == NULL || strcmp(arg1, "all") == 0) {
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; i++) {
|
||||
app_print_frame(i);
|
||||
} 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 (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) {
|
||||
line[line_len++] = c;
|
||||
}
|
||||
else {
|
||||
line_overflow = true;
|
||||
line_len = 0;
|
||||
} else if (!line_overflow) {
|
||||
if (line_len < sizeof(line) - 1u) {
|
||||
line[line_len++] = c;
|
||||
} else {
|
||||
line_overflow = true;
|
||||
line_len = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+162
-459
@@ -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;
|
||||
}
|
||||
const sensor_settings_t &sensor = g_settings.wheels[wheel];
|
||||
uint8_t frame[TPMS_TX_BYTES];
|
||||
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");
|
||||
return ok;
|
||||
}
|
||||
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)
|
||||
{
|
||||
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" : "",
|
||||
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));
|
||||
}
|
||||
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
|
||||
}
|
||||
else {
|
||||
app_next_wheel(); // learn/single: kolejne kolo
|
||||
}
|
||||
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 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();
|
||||
}
|
||||
}
|
||||
+19
-56
@@ -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)
|
||||
* VBAT_CAL;
|
||||
return (uint32_t)(v + 0.5f);
|
||||
float value = (float)pin_mv * ((VBAT_DIVIDER_R1 + VBAT_DIVIDER_R2) / VBAT_DIVIDER_R2)
|
||||
* VBAT_CAL;
|
||||
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 */
|
||||
+52
-85
@@ -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);
|
||||
}
|
||||
|
||||
/* Diagnostyka po zakonczeniu: dwa zgodne odczyty (errata CC1101),
|
||||
* kontrola niedopelnienia FIFO i tego, czy bufor zostal faktycznie
|
||||
* wyslany. Zwracamy blad zamiast udawac sukces. */
|
||||
bool ok = true;
|
||||
uint8_t txb = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES);
|
||||
uint8_t txb2 = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES);
|
||||
if (txb != txb2) {
|
||||
txb = txb2;
|
||||
}
|
||||
if (txb & 0x80u) { // TXFIFO_UNDERFLOW
|
||||
ok = false;
|
||||
}
|
||||
if ((txb & 0x7Fu) != 0) { // cos zostalo w FIFO - transmisja nie wyszla
|
||||
ok = false;
|
||||
/* 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;
|
||||
}
|
||||
if (state == 0x01u) { /* IDLE po automatycznym zakonczeniu pakietu */
|
||||
finished = true;
|
||||
break;
|
||||
}
|
||||
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,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
|
||||
Reference in new issue
Block a user