Poprawki po recenzji zewnetrznej (Kimi K3.1 Pro) + regresja
KRYTYCZNE: - zasilanie: usuniete bledne zalecenia (TPS62740 do 12V, LiPo bez LDO), poprawne warianty: MCP1703 (Vin>=16V) / LM5164-Q1, Li-SOCl2 bezposrednio, LiPo przez LDO; dokumentacja przepiec samochodowych (TVS) - sleep: brak wejscia w sen przy wcisnietym przycisku/aktywnym LF (EXT0/EXT1 poziomowe = ryzyko petli wybudzen), LED gaszony przed snem - radio: koniec TX liczony z pelnego czasu serializacji (TXBYTES==0 nie znaczy konca na antenie), kontrola underflow + podwojny odczyt statusu WAZNE: - API biblioteki: setSpiPin/setGDO0 (wymagane >=2.5.7), zgodnosc z 2.5.x/3.x - PIN_ACC=-1 wylacza cala logike parkingowa (stale TX_INTERVAL_S) - czas RTC oparty o system time (przetrwaje deep sleep) - brak zawyzania po wczesnych wybudzeniach; RTC_MAGIC zwiazany z CONFIG_VERSION - dzielniki pomiarowe 1M/270k (~9uA zamiast ~90uA), ADC bez wewnetrznego pulldown, PIN_ACC domyslnie -1 - poprawiony debounce, pojedyncza obsluga LF (bez dubli burstow), SINGLE trzyma indeks koola niezaleznie od LEARN_SEQ, gesty zgodne z README DROBNE: scisly parser konsoli, TX_BYTES=30 w narzedziach, tworzenie katalogu w gen_cu8, static_assert + testy graniczne cisnienia, przypiete wersje platformy i biblioteki, przeliczony budzet pradu.
This commit is contained in:
1 parent
c85c9a1dce
commit
4897360df6
14 files changed
+403
-170
No files matched your search
+26
-9
@@ -23,9 +23,19 @@
|
||||
|
||||
/* ======================================================================
|
||||
* 1. ZASILANIE
|
||||
* POWER_12V - stale zasilanie z akumulatora 12 V przez buck/ LDO
|
||||
* o niskim pradzie spoczynkowym (np. TPS62740, Iq < 1 uA)
|
||||
* POWER_BATTERY - ogniwo 3.3-4.2 V (Li-SOCl2 / LiPo) bez przetwornicy
|
||||
* 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
|
||||
@@ -55,14 +65,21 @@
|
||||
* -1 wylacza funkcje (role pelni przycisk "aktywuj kolo"). */
|
||||
#define PIN_LF_TRIGGER 25
|
||||
|
||||
/* Opcjonalny sygnal zaplonu / ACC (dzielnik 12 V -> 3.3 V). -1 = brak. */
|
||||
#define PIN_ACC 32
|
||||
/* 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
|
||||
|
||||
/* Pomiar napiecia zasilania: dzielnik R1(gora)/R2(dol) na pin ADC1.
|
||||
* Uwaga: GPIO34/35/32/33 = ADC1, mozliwe rowniez jako wejscia EXT. */
|
||||
/* 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 100000.0f // ohm, gora (do zasilania)
|
||||
#define VBAT_DIVIDER_R2 33000.0f // ohm, dol (do masy)
|
||||
#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
|
||||
|
||||
|
||||
+77
-32
@@ -6,17 +6,21 @@
|
||||
* info - wersja, konfiguracja, stan, napiecie
|
||||
* hex [n|all] - hexdump ramki TPMS dla kola n (1-4) lub wszystkich
|
||||
* send [n|all] - wyslij burst ramki teraz
|
||||
* batt - pomiar napiecia zasilania
|
||||
* 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).
|
||||
*/
|
||||
#include <Arduino.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "config.h"
|
||||
#include "app.h"
|
||||
@@ -24,6 +28,7 @@
|
||||
|
||||
static char line[64];
|
||||
static uint8_t line_len = 0;
|
||||
static bool line_overflow = false;
|
||||
|
||||
static void cmd_help(void)
|
||||
{
|
||||
@@ -38,9 +43,30 @@ static void cmd_help(void)
|
||||
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"));
|
||||
Serial.println(F(" stay [s] - czuwaj jeszcze s sekund"));
|
||||
}
|
||||
|
||||
/* Scisly parser liczby calkowitej bez znaku z zakresem. */
|
||||
static bool parse_u32(const char *s, uint32_t lo, uint32_t hi, uint32_t *out,
|
||||
int base)
|
||||
{
|
||||
if (s == NULL || *s == '\0') {
|
||||
return false;
|
||||
}
|
||||
errno = 0;
|
||||
char *end = NULL;
|
||||
unsigned long v = strtoul(s, &end, base);
|
||||
if (errno != 0 || end == s || *end != '\0') {
|
||||
return false;
|
||||
}
|
||||
if (v < (unsigned long)lo || v > (unsigned long)hi) {
|
||||
return false;
|
||||
}
|
||||
*out = (uint32_t)v;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Numer kola 1-4 -> indeks 0-3; "all" -> 0xFF; blad -> -1. */
|
||||
static int parse_wheel(const char *arg, uint8_t *wheel)
|
||||
{
|
||||
if (arg == NULL) {
|
||||
@@ -50,8 +76,8 @@ static int parse_wheel(const char *arg, uint8_t *wheel)
|
||||
*wheel = 0xFF;
|
||||
return 0;
|
||||
}
|
||||
long n = strtol(arg, NULL, 10);
|
||||
if (n < 1 || n > WHEEL_COUNT) {
|
||||
uint32_t n = 0;
|
||||
if (!parse_u32(arg, 1, WHEEL_COUNT, &n, 10)) {
|
||||
return -1;
|
||||
}
|
||||
*wheel = (uint8_t)(n - 1);
|
||||
@@ -66,6 +92,7 @@ static void handle_line(char *s)
|
||||
}
|
||||
char *arg1 = strtok(NULL, " \t");
|
||||
char *arg2 = strtok(NULL, " \t");
|
||||
uint32_t u = 0;
|
||||
|
||||
if (strcmp(cmd, "help") == 0) {
|
||||
cmd_help();
|
||||
@@ -75,30 +102,31 @@ static void handle_line(char *s)
|
||||
}
|
||||
else if (strcmp(cmd, "hex") == 0) {
|
||||
uint8_t w;
|
||||
if (parse_wheel(arg1, &w) != 0) {
|
||||
w = 0xFF;
|
||||
}
|
||||
if (w == 0xFF) {
|
||||
if (arg1 == NULL || strcmp(arg1, "all") == 0) {
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; i++) {
|
||||
app_print_frame(i);
|
||||
}
|
||||
}
|
||||
else {
|
||||
else if (parse_wheel(arg1, &w) == 0) {
|
||||
app_print_frame(w);
|
||||
}
|
||||
else {
|
||||
Serial.println(F("BLAD: hex [1-4|all]"));
|
||||
}
|
||||
}
|
||||
else if (strcmp(cmd, "send") == 0) {
|
||||
uint8_t w;
|
||||
if (parse_wheel(arg1, &w) != 0) {
|
||||
w = 0xFF;
|
||||
}
|
||||
if (w == 0xFF) {
|
||||
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 {
|
||||
app_send_burst_wheel(w);
|
||||
Serial.println(F("BLAD: send [1-4|all]"));
|
||||
}
|
||||
Serial.println(F("OK"));
|
||||
}
|
||||
else if (strcmp(cmd, "batt") == 0) {
|
||||
Serial.printf("Vcc = %u mV\n", (unsigned)app_supply_mv());
|
||||
@@ -109,54 +137,62 @@ static void handle_line(char *s)
|
||||
else if (strcmp(cmd, "mode") == 0) {
|
||||
uint8_t w = 0;
|
||||
if (arg1 == NULL) {
|
||||
Serial.println(F("mode normal|learn|single [n]"));
|
||||
Serial.println(F("BLAD: mode normal|learn|single [n]"));
|
||||
return;
|
||||
}
|
||||
if (strcmp(arg1, "normal") == 0) {
|
||||
app_set_mode(APP_MODE_NORMAL, 0);
|
||||
}
|
||||
else if (strcmp(arg1, "learn") == 0) {
|
||||
if (arg2 != NULL) {
|
||||
if (parse_wheel(arg2, &w) != 0) {
|
||||
w = 0;
|
||||
}
|
||||
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("single wymaga numeru kola 1-4"));
|
||||
Serial.println(F("BLAD: single wymaga numeru kola 1-4"));
|
||||
return;
|
||||
}
|
||||
app_set_mode(APP_MODE_SINGLE, w);
|
||||
}
|
||||
else {
|
||||
Serial.println(F("mode normal|learn|single [n]"));
|
||||
Serial.println(F("BLAD: mode normal|learn|single [n]"));
|
||||
return;
|
||||
}
|
||||
Serial.println(F("OK"));
|
||||
}
|
||||
else if (strcmp(cmd, "interval") == 0) {
|
||||
if (arg1 == NULL) {
|
||||
Serial.println(F("interval <s>"));
|
||||
if (!parse_u32(arg1, 0, 86400, &u, 10)) {
|
||||
Serial.println(F("BLAD: interval <0-86400>"));
|
||||
return;
|
||||
}
|
||||
app_set_interval((uint32_t)strtoul(arg1, NULL, 10));
|
||||
app_set_interval(u);
|
||||
Serial.println(F("OK"));
|
||||
}
|
||||
else if (strcmp(cmd, "flags") == 0) {
|
||||
if (arg1 == NULL) {
|
||||
Serial.println(F("flags <hex>"));
|
||||
if (!parse_u32(arg1, 0, 0xFFFFFFFFu, &u, 16)) {
|
||||
Serial.println(F("BLAD: flags <hex>"));
|
||||
return;
|
||||
}
|
||||
app_set_flags((uint32_t)strtoul(arg1, NULL, 16));
|
||||
app_set_flags(u);
|
||||
Serial.println(F("OK"));
|
||||
}
|
||||
else if (strcmp(cmd, "sleep") == 0) {
|
||||
app_request_sleep();
|
||||
}
|
||||
else if (strcmp(cmd, "stay") == 0) {
|
||||
app_stay_awake(arg1 ? (uint32_t)strtoul(arg1, NULL, 10) * 1000u : 60000u);
|
||||
if (arg1 == NULL) {
|
||||
app_stay_awake(60000u);
|
||||
}
|
||||
else if (parse_u32(arg1, 0, 3600, &u, 10)) {
|
||||
app_stay_awake(u * 1000u);
|
||||
}
|
||||
else {
|
||||
Serial.println(F("BLAD: stay <0-3600>"));
|
||||
return;
|
||||
}
|
||||
Serial.println(F("OK"));
|
||||
}
|
||||
else {
|
||||
@@ -167,6 +203,7 @@ static void handle_line(char *s)
|
||||
void console_init(void)
|
||||
{
|
||||
line_len = 0;
|
||||
line_overflow = false;
|
||||
}
|
||||
|
||||
void console_poll(void)
|
||||
@@ -174,17 +211,25 @@ void console_poll(void)
|
||||
while (Serial.available() > 0) {
|
||||
char c = (char)Serial.read();
|
||||
if (c == '\r' || c == '\n') {
|
||||
if (line_len > 0) {
|
||||
if (line_overflow) {
|
||||
Serial.println(F("BLAD: linia za dluga"));
|
||||
}
|
||||
else if (line_len > 0) {
|
||||
line[line_len] = '\0';
|
||||
handle_line(line);
|
||||
line_len = 0;
|
||||
}
|
||||
line_len = 0;
|
||||
line_overflow = false;
|
||||
}
|
||||
else if (line_overflow) {
|
||||
/* po przeplenieniu porzucamy cala linie lacznie z ogonem */
|
||||
}
|
||||
else if (line_len < sizeof(line) - 1u) {
|
||||
line[line_len++] = c;
|
||||
}
|
||||
else {
|
||||
line_len = 0; // przepełnienie - porzuc linie
|
||||
line_overflow = true;
|
||||
line_len = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
+99
-24
@@ -50,14 +50,17 @@ static const uint8_t LEARN_SEQ[WHEEL_COUNT] = {
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Stan w RTC (przetrwuje deep sleep) */
|
||||
/* ------------------------------------------------------------------ */
|
||||
#define RTC_MAGIC 0x54504D53u // 'TPMS'
|
||||
/* Magic zwiazany z wersja konfiguracji: zmiana CONFIG_VERSION (np. po
|
||||
* zmianie formatu stanu w RTC) zeruje caly stan po wybudzeniu. */
|
||||
#define RTC_MAGIC (0x54504D53u ^ (uint32_t)CONFIG_VERSION) // 'TPMS' ^ version
|
||||
|
||||
RTC_DATA_ATTR static uint32_t rtc_magic;
|
||||
RTC_DATA_ATTR static uint8_t rtc_mode = APP_MODE_NORMAL;
|
||||
RTC_DATA_ATTR static uint8_t rtc_seq_idx = 0; // indeks w LEARN_SEQ
|
||||
RTC_DATA_ATTR static uint8_t rtc_rot_idx = 0; // rotacja w NORMAL
|
||||
RTC_DATA_ATTR static 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_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;
|
||||
|
||||
@@ -70,13 +73,33 @@ static uint32_t single_start = 0;
|
||||
static bool request_sleep = false;
|
||||
static bool low_batt = false;
|
||||
static uint32_t supply_mv = 0;
|
||||
#if PIN_LF_TRIGGER >= 0
|
||||
static bool lf_prev = false; // poprzedni stan wejscia LF (zbocze)
|
||||
#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)
|
||||
{
|
||||
return LEARN_SEQ[rtc_seq_idx % WHEEL_COUNT];
|
||||
return (rtc_mode == APP_MODE_SINGLE)
|
||||
? (uint8_t)(rtc_single_wheel % WHEEL_COUNT)
|
||||
: LEARN_SEQ[rtc_seq_idx % WHEEL_COUNT];
|
||||
}
|
||||
|
||||
/* Pozycja kola w sekwencji nauki (do trybu LEARN). */
|
||||
static uint8_t seq_pos_of(uint8_t wheel)
|
||||
{
|
||||
for (uint8_t i = 0; i < WHEEL_COUNT; i++) {
|
||||
if (LEARN_SEQ[i] == wheel) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void refresh_power(void)
|
||||
@@ -95,13 +118,14 @@ void app_send_burst_wheel(uint8_t wheel)
|
||||
{
|
||||
uint8_t frame[TPMS_TX_BYTES];
|
||||
build_frame_for(wheel, frame);
|
||||
radio_send_burst(frame, TPMS_TX_BYTES, TX_BURST_FRAMES);
|
||||
Serial.printf("TX %s id=%06X %.1f kPa %d C flags=%08X%s\n",
|
||||
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" : "");
|
||||
(unsigned)rtc_flags, low_batt ? " LOWBATT" : "",
|
||||
ok ? "" : " TX-ERR");
|
||||
}
|
||||
|
||||
void app_send_burst_all(void)
|
||||
@@ -149,7 +173,7 @@ void app_print_info(void)
|
||||
(unsigned)rtc_flags,
|
||||
TPMS_MODULATION == MODE_FSK ? "FSK" : "OOK",
|
||||
TPMS_CHIP_US, TX_BURST_FRAMES,
|
||||
(unsigned)(rtc_interval_s ? rtc_interval_s : TX_INTERVAL_S),
|
||||
(unsigned)compute_interval(),
|
||||
(unsigned long)rtc_wake_count);
|
||||
Serial.printf("Vcc=%u mV%s\n", (unsigned)supply_mv, low_batt ? " LOWBATT" : "");
|
||||
}
|
||||
@@ -195,10 +219,14 @@ uint8_t app_wheel(void)
|
||||
|
||||
void app_next_wheel(void)
|
||||
{
|
||||
rtc_seq_idx = (uint8_t)((rtc_seq_idx + 1) % WHEEL_COUNT);
|
||||
ui_blink_count((uint8_t)(rtc_seq_idx + 1));
|
||||
Serial.printf("Kolo: %s (learn: %d/%d)\n", SENSOR[active_wheel()].name,
|
||||
(int)rtc_seq_idx + 1, WHEEL_COUNT);
|
||||
if (rtc_mode == APP_MODE_SINGLE) {
|
||||
rtc_single_wheel = (uint8_t)((rtc_single_wheel + 1) % WHEEL_COUNT);
|
||||
}
|
||||
else {
|
||||
rtc_seq_idx = (uint8_t)((rtc_seq_idx + 1) % WHEEL_COUNT);
|
||||
}
|
||||
ui_blink_count((uint8_t)(active_wheel() + 1));
|
||||
Serial.printf("Kolo: %s\n", SENSOR[active_wheel()].name);
|
||||
learn_window_start = millis();
|
||||
}
|
||||
|
||||
@@ -207,21 +235,21 @@ void app_set_mode(uint8_t mode, uint8_t wheel)
|
||||
rtc_mode = mode;
|
||||
switch (mode) {
|
||||
case APP_MODE_LEARN:
|
||||
rtc_seq_idx = (uint8_t)(wheel % WHEEL_COUNT);
|
||||
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)(rtc_seq_idx + 1));
|
||||
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_seq_idx = (uint8_t)(wheel % WHEEL_COUNT);
|
||||
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)(rtc_seq_idx + 1));
|
||||
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;
|
||||
@@ -243,17 +271,21 @@ static uint32_t compute_interval(void)
|
||||
if (rtc_interval_s != 0) {
|
||||
return rtc_interval_s;
|
||||
}
|
||||
uint64_t now_ms = power_elapsed_ms() + millis();
|
||||
#if PIN_ACC >= 0
|
||||
#if 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;
|
||||
}
|
||||
#endif
|
||||
if (now_ms - rtc_last_acc_ms > (uint64_t)ACC_GRACE_MS) {
|
||||
return PARKING_SHUTDOWN ? 0u : (uint32_t)TX_INTERVAL_PARKING_S;
|
||||
}
|
||||
return (uint32_t)TX_INTERVAL_S;
|
||||
#endif
|
||||
}
|
||||
|
||||
static void tx_cycle(void)
|
||||
@@ -262,11 +294,35 @@ static void tx_cycle(void)
|
||||
app_send_burst_all();
|
||||
}
|
||||
|
||||
/* Czy ktorekolwiek zrodlo budzenia poziomowego jest aktywne? */
|
||||
static bool wake_sources_active(void)
|
||||
{
|
||||
if (ui_button_down() || digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL) {
|
||||
return true;
|
||||
}
|
||||
#if PIN_LF_TRIGGER >= 0
|
||||
if (digitalRead(PIN_LF_TRIGGER) == HIGH) {
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
static void go_sleep(uint32_t seconds)
|
||||
{
|
||||
/* Nie spij, dopoki przycisk jest wcisniety lub LF aktywne - EXT0/EXT1
|
||||
* dzialaja poziomowo, wiec sen przy aktywnym zrodle = natychmiastowa
|
||||
* petla wybudzen. Dajemy krotki margines i wracamy do petli. */
|
||||
if (wake_sources_active()) {
|
||||
app_stay_awake(500);
|
||||
return;
|
||||
}
|
||||
|
||||
ui_set_pattern(UI_PAT_OFF);
|
||||
digitalWrite(PIN_LED, LOW);
|
||||
|
||||
Serial.printf("sleep %us\n", (unsigned)seconds);
|
||||
Serial.flush();
|
||||
power_elapsed_add_ms(millis() + (uint64_t)seconds * 1000u);
|
||||
power_deep_sleep(seconds); // nie wraca
|
||||
}
|
||||
|
||||
@@ -282,13 +338,16 @@ void setup(void)
|
||||
pinMode(PIN_LF_TRIGGER, INPUT_PULLDOWN);
|
||||
#endif
|
||||
#if PIN_ACC >= 0
|
||||
pinMode(PIN_ACC, INPUT_PULLDOWN);
|
||||
/* INPUT (bez podciagania): dolna galazka dzielnika wymusza stan niski,
|
||||
* a wewnetrzny pulldown (~45 k) obciazylby dzielnik i zbil prog VIH. */
|
||||
pinMode(PIN_ACC, INPUT);
|
||||
#endif
|
||||
|
||||
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;
|
||||
@@ -364,6 +423,18 @@ void setup(void)
|
||||
ui_set_pattern(low_batt ? UI_PAT_LOWBAT : UI_PAT_NORMAL);
|
||||
}
|
||||
|
||||
/* Po wybudzeniu przyciskiem/LF obsluzylismy juz akcje - nie powtarzaj
|
||||
* cyklu natychmiast, tylko odloz go o pelny okres. */
|
||||
if (cause == ESP_SLEEP_WAKEUP_EXT0 || cause == ESP_SLEEP_WAKEUP_EXT1) {
|
||||
if (rtc_mode != APP_MODE_NORMAL) {
|
||||
next_tx_ms = millis() + LEARN_TX_PERIOD_MS;
|
||||
}
|
||||
}
|
||||
#if PIN_LF_TRIGGER >= 0
|
||||
/* LF ciagle aktywne = brak nowego zbocza = brak kolejnego bursta */
|
||||
lf_prev = (digitalRead(PIN_LF_TRIGGER) == HIGH);
|
||||
#endif
|
||||
|
||||
Serial.printf("Vcc=%u mV tryb=%d interwal=%us\n", (unsigned)supply_mv,
|
||||
(int)rtc_mode, (unsigned)iv);
|
||||
app_print_info();
|
||||
@@ -400,7 +471,7 @@ void loop(void)
|
||||
app_set_mode(APP_MODE_NORMAL, 0);
|
||||
}
|
||||
else {
|
||||
app_set_mode(APP_MODE_SINGLE, rtc_seq_idx);
|
||||
app_set_mode(APP_MODE_SINGLE, active_wheel());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -409,11 +480,15 @@ void loop(void)
|
||||
#if PIN_LF_TRIGGER >= 0
|
||||
/* aktywacja LF tez dziala "na zywo" (nie tylko przez budzenie) */
|
||||
{
|
||||
static bool lf_prev = false;
|
||||
bool lf = (digitalRead(PIN_LF_TRIGGER) == HIGH);
|
||||
if (lf && !lf_prev) {
|
||||
refresh_power();
|
||||
app_send_burst_wheel(active_wheel());
|
||||
/* 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;
|
||||
}
|
||||
|
||||
+19
-11
@@ -13,13 +13,12 @@
|
||||
#include <esp_sleep.h>
|
||||
#include <driver/gpio.h>
|
||||
#include <esp32-hal-bt.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "config.h"
|
||||
#include "power.h"
|
||||
#include "radio.h"
|
||||
|
||||
RTC_DATA_ATTR static uint64_t rtc_elapsed_ms = 0;
|
||||
|
||||
void power_init(void)
|
||||
{
|
||||
/* Zwolnij hold z poprzedniego snu - po deep sleep piny sa zatrzymane. */
|
||||
@@ -65,12 +64,17 @@ void power_deep_sleep(uint32_t seconds)
|
||||
/* Budzik RTC. */
|
||||
esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_ALL);
|
||||
if (seconds > 0) {
|
||||
esp_sleep_enable_timer_wakeup((uint64_t)seconds * 1000000ULL);
|
||||
if (esp_sleep_enable_timer_wakeup((uint64_t)seconds * 1000000ULL) != ESP_OK) {
|
||||
Serial.println(F("power: blad konfiguracji budzika RTC"));
|
||||
}
|
||||
}
|
||||
|
||||
/* Przycisk jako zrodlo EXT0 (poziom konfigurowalny). */
|
||||
#if PIN_BUTTON >= 0
|
||||
esp_sleep_enable_ext0_wakeup((gpio_num_t)PIN_BUTTON, BTN_ACTIVE_LEVEL);
|
||||
if (esp_sleep_enable_ext0_wakeup((gpio_num_t)PIN_BUTTON, BTN_ACTIVE_LEVEL)
|
||||
!= ESP_OK) {
|
||||
Serial.println(F("power: blad konfiguracji EXT0 (pin nie RTC?)"));
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Opcjonalne wejscie LF 125 kHz (impuls wysoki) jako EXT1.
|
||||
@@ -81,7 +85,10 @@ void power_deep_sleep(uint32_t seconds)
|
||||
ext1_mask |= (1ULL << PIN_LF_TRIGGER);
|
||||
#endif
|
||||
if (ext1_mask != 0) {
|
||||
esp_sleep_enable_ext1_wakeup(ext1_mask, ESP_EXT1_WAKEUP_ANY_HIGH);
|
||||
if (esp_sleep_enable_ext1_wakeup(ext1_mask, ESP_EXT1_WAKEUP_ANY_HIGH)
|
||||
!= ESP_OK) {
|
||||
Serial.println(F("power: blad konfiguracji EXT1 (pin nie RTC?)"));
|
||||
}
|
||||
}
|
||||
|
||||
esp_deep_sleep_start();
|
||||
@@ -89,10 +96,11 @@ void power_deep_sleep(uint32_t seconds)
|
||||
|
||||
uint64_t power_elapsed_ms(void)
|
||||
{
|
||||
return rtc_elapsed_ms;
|
||||
}
|
||||
|
||||
void power_elapsed_add_ms(uint64_t delta_ms)
|
||||
{
|
||||
rtc_elapsed_ms += delta_ms;
|
||||
/* System time jest utrzymywany przez RTC i przywracany po deep sleep,
|
||||
* wiec licznik rosnie o rzeczywisty czas (takze ten spedzony w snie),
|
||||
* a nie o planowany interwal - wczesniejsze wybudzenia (przycisk/LF)
|
||||
* 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);
|
||||
}
|
||||
+4
-3
@@ -24,10 +24,11 @@ bool power_low_battery(uint32_t mV);
|
||||
* przycisk/LF). Funkcja nie wraca. */
|
||||
void power_deep_sleep(uint32_t seconds);
|
||||
|
||||
/* Suma czasu pracy [ms] od pierwszego uruchomienia - licznik w RTC
|
||||
* przetrwuje deep sleep; uzywane do logiki "5 min po zaniku ACC". */
|
||||
/* 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);
|
||||
void power_elapsed_add_ms(uint64_t delta_ms);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
+39
-21
@@ -20,19 +20,17 @@
|
||||
|
||||
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)
|
||||
{
|
||||
#if defined(SMARTRC_CC1101_H) /* SmartRC-CC1101-Driver-Lib 3.x */
|
||||
ELECHOUSE_cc1101.setSpiPin(PIN_CC1101_SCK, PIN_CC1101_MISO,
|
||||
PIN_CC1101_MOSI, PIN_CC1101_CS);
|
||||
ELECHOUSE_cc1101.setGDO0(PIN_CC1101_GDO0);
|
||||
#else /* klasyczne ELECHOUSE_CC1101_SRC_DRV 1.x/2.x */
|
||||
ELECHOUSE_cc1101.setSCK(PIN_CC1101_SCK);
|
||||
ELECHOUSE_cc1101.setMISO(PIN_CC1101_MISO);
|
||||
ELECHOUSE_cc1101.setMOSI(PIN_CC1101_MOSI);
|
||||
ELECHOUSE_cc1101.setCS(PIN_CC1101_CS);
|
||||
ELECHOUSE_cc1101.setGDO0(PIN_CC1101_GDO0);
|
||||
#endif
|
||||
}
|
||||
|
||||
bool radio_init(void)
|
||||
@@ -80,10 +78,10 @@ bool radio_init(void)
|
||||
return true;
|
||||
}
|
||||
|
||||
void radio_send_frame(const uint8_t *buf, uint8_t len)
|
||||
bool radio_send_frame(const uint8_t *buf, uint8_t len)
|
||||
{
|
||||
if (!radio_ok) {
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
|
||||
ELECHOUSE_cc1101.SpiStrobe(CC1101_SIDLE);
|
||||
@@ -91,31 +89,51 @@ void radio_send_frame(const uint8_t *buf, uint8_t len)
|
||||
ELECHOUSE_cc1101.SpiWriteBurstReg(CC1101_TXFIFO, (uint8_t *)buf, len);
|
||||
ELECHOUSE_cc1101.SpiStrobe(CC1101_STX);
|
||||
|
||||
/* Czekamy az caly bufor wyjdzie na antene: FIFO puste + margines na
|
||||
* ostatni chip. Blokada krotka (~30 ms) i niezbedna do zakonczenia
|
||||
* transmisji - poza tym petla glowna nie uzywa delay(). */
|
||||
uint32_t air_us = (uint32_t)len * 8u * (uint32_t)TPMS_CHIP_US + 3000u;
|
||||
/* 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) {
|
||||
uint8_t txb = ELECHOUSE_cc1101.SpiReadStatus(CC1101_TXBYTES);
|
||||
if ((txb & 0x7Fu) == 0) {
|
||||
delayMicroseconds(2u * TPMS_CHIP_US); // ostatni chip na antenie
|
||||
break;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
ELECHOUSE_cc1101.SpiStrobe(CC1101_SIDLE);
|
||||
ELECHOUSE_cc1101.SpiStrobe(CC1101_SFTX);
|
||||
return ok;
|
||||
}
|
||||
|
||||
void radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames)
|
||||
bool radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames)
|
||||
{
|
||||
bool ok = true;
|
||||
for (uint8_t i = 0; i < frames; i++) {
|
||||
radio_send_frame(buf, len);
|
||||
if (!radio_send_frame(buf, len)) {
|
||||
ok = false;
|
||||
}
|
||||
if (i + 1u < frames) {
|
||||
delay(TX_FRAME_GAP_MS);
|
||||
}
|
||||
}
|
||||
return ok;
|
||||
}
|
||||
|
||||
void radio_sleep(void)
|
||||
|
||||
+6
-4
@@ -16,11 +16,13 @@ extern "C" {
|
||||
bool radio_init(void);
|
||||
|
||||
/* Wyslij jeden bufor nadawczy (TPMS_TX_BYTES) - blokujace do zakonczenia
|
||||
* transmisji na eterze (~29 ms). */
|
||||
void radio_send_frame(const uint8_t *buf, uint8_t len);
|
||||
* transmisji na eterze (dokladnie len*8 chipow, ~29 ms). Zwraca false
|
||||
* przy niedopelnieniu FIFO / niezakonczonej transmisji. */
|
||||
bool radio_send_frame(const uint8_t *buf, uint8_t len);
|
||||
|
||||
/* Burts: n ramek tego samego bufora z odstepem TX_FRAME_GAP_MS. */
|
||||
void radio_send_burst(const uint8_t *buf, uint8_t len, uint8_t frames);
|
||||
/* 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. */
|
||||
void radio_sleep(void);
|
||||
|
||||
@@ -37,6 +37,15 @@ extern "C" {
|
||||
#define TPMS_TX_BYTES 30 // 240 chipow = 1 lead + 238 danych + 1 padding
|
||||
#define TPMS_TX_CHIPS (TPMS_TX_BYTES * 8)
|
||||
|
||||
#ifdef __cplusplus
|
||||
/* Zaleznosc bufora nadawczego od dlugosci ramki: 1 chip rozbiegowy +
|
||||
* 2 chipy na kazdy z (TPMS_ROW_BITS-1) bitow (pierwszy bit dopisuje
|
||||
* odbiornik) + padding do granicy bajtu (< 8 chipow). */
|
||||
static_assert(TPMS_TX_CHIPS >= 1 + 2 * (TPMS_ROW_BITS - 1)
|
||||
&& TPMS_TX_CHIPS < 1 + 2 * (TPMS_ROW_BITS - 1) + 8,
|
||||
"TPMS_TX_BYTES musi miescic 1 + 2*(TPMS_ROW_BITS-1) chipow");
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
uint32_t id; // 24-bit identyfikator czujnika
|
||||
uint16_t press_kpa10; // cisnienie w kPa * 10 (np. 2600 = 260.0 kPa)
|
||||
|
||||
+23
-12
@@ -6,9 +6,12 @@
|
||||
#include "ui.h"
|
||||
|
||||
/* ---------------------------- przycisk ---------------------------- */
|
||||
/* Debounce: nowy stan surowy musi sie utrzymac BTN_DEBOUNCE_MS, zanim
|
||||
* zostanie uznany za stan stabilny (kandydat + czas jego zmiany). */
|
||||
|
||||
static bool btn_raw_last = false; // ostatni surowy odczyt
|
||||
static uint32_t btn_raw_change = 0; // czas ostatniej zmiany surowej
|
||||
static bool btn_stable = false; // stan po debounce
|
||||
static uint32_t btn_last_change = 0;
|
||||
static uint32_t btn_press_start = 0;
|
||||
static bool btn_long_fired = false; // bardzo dlugie zdarzenie juz wyslane
|
||||
|
||||
@@ -22,8 +25,14 @@ void ui_init(void)
|
||||
pinMode(PIN_BUTTON, BTN_ACTIVE_LEVEL ? INPUT_PULLDOWN : INPUT_PULLUP);
|
||||
pinMode(PIN_LED, OUTPUT);
|
||||
digitalWrite(PIN_LED, LOW);
|
||||
btn_stable = (digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL);
|
||||
btn_last_change = millis();
|
||||
|
||||
uint32_t now = millis();
|
||||
bool raw = (digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL);
|
||||
btn_raw_last = raw;
|
||||
btn_raw_change = now;
|
||||
btn_stable = raw;
|
||||
btn_press_start = now; // start z wcisnietym przyciskiem = poczatek gestu
|
||||
btn_long_fired = false;
|
||||
}
|
||||
|
||||
ui_event_t ui_poll(void)
|
||||
@@ -32,20 +41,22 @@ ui_event_t ui_poll(void)
|
||||
bool raw = (digitalRead(PIN_BUTTON) == BTN_ACTIVE_LEVEL);
|
||||
uint32_t now = millis();
|
||||
|
||||
if (raw != btn_stable && (now - btn_last_change) >= BTN_DEBOUNCE_MS) {
|
||||
btn_last_change = now;
|
||||
btn_stable = raw;
|
||||
if (raw != btn_raw_last) {
|
||||
/* kandydat - czekaj az stan sie utrzyma */
|
||||
btn_raw_last = raw;
|
||||
btn_raw_change = now;
|
||||
}
|
||||
else if (raw != btn_stable && (now - btn_raw_change) >= BTN_DEBOUNCE_MS) {
|
||||
btn_stable = raw; // zaakceptowany po debounce
|
||||
if (btn_stable) {
|
||||
btn_press_start = now;
|
||||
btn_long_fired = false;
|
||||
}
|
||||
else {
|
||||
else if (!btn_long_fired) {
|
||||
uint32_t held = now - btn_press_start;
|
||||
if (!btn_long_fired) {
|
||||
if (held >= BTN_VERYLONG_MS) ev = UI_EV_VERYLONG;
|
||||
else if (held >= BTN_LONG_MS) ev = UI_EV_LONG;
|
||||
else ev = UI_EV_SHORT;
|
||||
}
|
||||
if (held >= BTN_VERYLONG_MS) ev = UI_EV_VERYLONG;
|
||||
else if (held >= BTN_LONG_MS) ev = UI_EV_LONG;
|
||||
else ev = UI_EV_SHORT;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user