mirror of
https://github.com/Show-maket/IR-protocol.git
synced 2026-04-28 03:08:08 +00:00
Compare commits
14 Commits
STM32-opti
...
e7d7c0e1c1
| Author | SHA1 | Date | |
|---|---|---|---|
| e7d7c0e1c1 | |||
| af3e012aac | |||
| fc1a3bacef | |||
| 8a0d7f8dba | |||
| d1c84ba18a | |||
| e9c568aed2 | |||
| 7bf71d1d52 | |||
| 38f3ecac3a | |||
| dec8467280 | |||
| bc9563fbb5 | |||
| 021e1e290d | |||
| 89d14919c9 | |||
| 403b8e6850 | |||
| d0c3138c52 |
2
.gitignore
vendored
2
.gitignore
vendored
@ -3,3 +3,5 @@ bin/*
|
||||
!.vscode/launch.json
|
||||
log/*
|
||||
/.vscode
|
||||
*.zip
|
||||
**/__pycache__
|
||||
|
||||
141
IR_DMA_ISR_signal_analysis.md
Normal file
141
IR_DMA_ISR_signal_analysis.md
Normal file
@ -0,0 +1,141 @@
|
||||
# IR DMA vs ISR: анализ согласованности сигнала и ответа версии
|
||||
|
||||
Связка с остальным пультом (модули, настройки): **[`ARCHITECTURE.md`](ARCHITECTURE.md)**.
|
||||
|
||||
Документ фиксирует наблюдения по переходу машинки (проект Car) на **DMA-передачу** ИК через `IR_Encoder::setExternalTxBackend` и `IrDmaBackend`, сравнение со **старым путём** (таймер + **`_isr()`**), ручную проверку CRC по логу пульта и роль **`buildGateRuns`** в библиотеке **IR-protocol**.
|
||||
|
||||
---
|
||||
|
||||
## 1. Контекст
|
||||
|
||||
- До введения DMA передача шла через **`IR_Encoder::begin(..., IR_Encoder::isr)`**: на каждый тик таймера (`carrierFrec * 2`) вызывается **`_isr()`**, формируются преамбула, данные, синхробиты.
|
||||
- После коммита с **IR_DMA** (`Car`, `IR.cpp`): **`beginClockOnly`**, **`setExternalTxBackend`**, фактическая модуляция — **`IrDmaBackend::start`** → **`IR_Encoder::buildGateRuns`** + DMA в **BSRR**.
|
||||
- Ответ версии — один из самых **длинных** кадров (до **31 байта** полного кадра по заголовку). Короткие пакеты (эхо `Version_Query`, 8 байт) в логе остаются **FrameOK**; длинный ответ версии даёт **CRC fail** / `Frame reject`.
|
||||
|
||||
---
|
||||
|
||||
## 2. Два пути: ISR и DMA
|
||||
|
||||
| Этап | Старый ISR | DMA |
|
||||
|------|------------|-----|
|
||||
| Байты пакета + CRC | `sendDataFULL` → `sendBuffer` | То же; в `buildGateRuns` — `memcpy` в локальный буфер размером `dataByteSizeMax` |
|
||||
| Развёртка в импульсы | **`_isr()`**: счётчик `toggleCounter`, ветки preamb / data / sync | **`buildGateRuns`**: RLE-сегменты `(gate, lenTicks)` → **`nextWord()`** по тикам таймера |
|
||||
| Останов передачи | `signal == noSignal`, `isSending = false` | `ticksOutput >= totalTicks`, `sum(runs[i].lenTicks)` |
|
||||
|
||||
Идея `buildGateRuns`: **эмулировать** шаги FSM, которые в ISR выполняются при **`toggleCounter == 0`** (см. комментарий в `IR_Encoder.cpp` рядом с внутренним `while`).
|
||||
|
||||
### 2.1. Приоритеты NVIC: приём ИК выше, чем DMA передачи (STM32)
|
||||
|
||||
Пока активна **внешняя** передача по DMA (`IrDmaBackend` и т.п.), таймер крутит поток запросов к DMA — срабатывают **`DMA1_Channelx_IRQn`** (половина/конец буфера и т.д.). Если их приоритет **выше**, чем у **EXTI** линии пина приёмника, обработка фронтов на входе ИК **откладывается** → растёт джиттер `micros()` и страдает заполнение `subBuffer` / журнал `@IRF1v1`, хотя алгоритм `tick`/`writeToBuffer` не менялся.
|
||||
|
||||
**Требование:** числовой приоритет **приёма (EXTI)** должен быть **выше приоритета DMA передачи** (в терминах Cortex-M / STM32 HAL: **меньше** значение preempt priority у EXTI, чем у канала DMA ИК).
|
||||
|
||||
**В репозитории:**
|
||||
|
||||
- **`IR_Decoder`**: библиотека **не** задаёт приоритет EXTI по умолчанию. На Arduino STM32 пользователь вызывает **`setReceiveExtiPreemptPriority(preempt)`** (до или после `enable()`); после `attachInterrupt` применяется поверх приоритета ядра. Семейства с укороченной картой EXTI (C0/F0/G0/L0) — без изменения NVIC из этой функции.
|
||||
- **DMA ИК-TX** (например **`Car/src/IR/IrDmaBackend.cpp`**): preempt задаётся в прошивке носителя (**`CarIrq::kIrTxDmaPreempt`** и т.д.) и должен быть **больше** (ниже срочность), чем у приёма.
|
||||
|
||||
Свой проект: пользователь обязан согласовать приоритеты; **ни один** канал DMA ИК-TX не должен вытеснять EXTI приёма (меньший preempt у DMA = ошибка).
|
||||
|
||||
---
|
||||
|
||||
## 3. Ключевое наблюдение: `runLenTicks = toggleCounter + 1`
|
||||
|
||||
В **`IR_Encoder::buildGateRuns`** на каждой итерации внешнего цикла:
|
||||
|
||||
```cpp
|
||||
const uint16_t runLenTicks = (uint16_t)toggleCounterLocal + 1U;
|
||||
```
|
||||
|
||||
В **`_isr()`** при стартовом **`toggleCounter == N`** выполняется **ровно N** раз ветка `if (toggleCounter) { toggleCounter--; }` подряд, пока счётчик не станет **0**; **следующий** тик попадает в `else` и делает один шаг `switch (signal)`.
|
||||
|
||||
Между двумя такими визитами в `else` проходит **N тиков таймера**, не **N+1**.
|
||||
|
||||
В `buildGateRuns` для того же начального `toggleCounterLocal` в run записывается **`N + 1` тик**. Это даёт **систематическое удлинение каждого сегмента на 1 тик** относительно модели «счётчик убывает N раз до нуля».
|
||||
|
||||
**Следствие:**
|
||||
|
||||
- `totalTicks = Σ lenTicks` в **`IrDmaBackend::startStream`** **больше**, чем число тиков, которое дал бы чистый ISR при том же пакете.
|
||||
- Число внешних итераций `buildGateRuns` (шагов FSM) совпадает с числом таких сегментов; приближённо:
|
||||
`totalTicks ≈ totalTicks_ISR + (число_внешних_шагов)`.
|
||||
|
||||
Короткий кадр: ошибка может «теряться» в допусках приёмника. Длинный (версия) — **накопление** ошибки по времени → сдвиг границ битов → **неверные байты**, в том числе **CRC**.
|
||||
|
||||
---
|
||||
|
||||
## 4. Ручная проверка CRC по логу (пульт)
|
||||
|
||||
Алгоритм: **`IR_FOX::crc8`** (`IR_config.cpp`), два байта как в **`sendDataFULL`**:
|
||||
|
||||
- первый байт CRC = `crc8(data, 0, packSize - 2, poly1)`;
|
||||
- второй = `crc8(data, 0, packSize - 1, poly2)` (в расчёт второго входит уже первый байт CRC).
|
||||
|
||||
Пример **31-байтного** кадра из лога `Frame reject`:
|
||||
|
||||
- Тело **0…28** (29 байт).
|
||||
- Байты **29…30** — CRC на проводе.
|
||||
|
||||
Для фиксированного дампа байтов **0…28** корректная пара CRC по формуле библиотеки — **`6E 54`**, в логе на проводе — **`96 62`** → **не совпадает**; приёмник обоснованно отклоняет кадр.
|
||||
|
||||
Это **не** объясняется разницей AVR vs STM32: счёт идёт по массиву `uint8_t` побайтно.
|
||||
|
||||
Эхо **8 байт** `C8 FA 2A FD E8 5D AA B4`: пересчёт даёт **`AA B4`** — совпадает с последними байтами кадра → для этого пакета цепочка **байт → CRC** согласована.
|
||||
|
||||
---
|
||||
|
||||
## 5. Скрипт симуляции
|
||||
|
||||
В репозитории: **`docs/scripts/ir_protocol_gate_runs_sim.py`**.
|
||||
|
||||
Запуск:
|
||||
|
||||
```bash
|
||||
python docs/scripts/ir_protocol_gate_runs_sim.py
|
||||
```
|
||||
|
||||
Скрипт:
|
||||
|
||||
1. Считает **CRC** для примеров пакетов (8 байт эха и 31 байт из reject).
|
||||
2. Воспроизводит логику **`buildGateRuns`** (с дополнением буфера до `dataByteSizeMax`, как в C++).
|
||||
3. Печатает **`totalTicks`**, число **внешних шагов** FSM и связь **`totalTicks - outer_steps`** как оценку «тиков в модели ISR без +1 на каждый шаг».
|
||||
|
||||
Пример вывода (значения могут слегка отличаться при смене констант в `IR_config.h`):
|
||||
|
||||
- `preambToggle = 97`
|
||||
- для 8-байт пакета: сотни шагов FSM, `totalTicks` порядка тысяч тиков
|
||||
- для 31-байт: больше шагов и `totalTicks` (~25k+ тиков для текущих констант)
|
||||
|
||||
---
|
||||
|
||||
## 6. Связь с проектами
|
||||
|
||||
- **Car** (`Executer.cpp`): ответ версии через **`IR_Module::getENC().sendData(...)`** — тот же **`sendDataFULL`**, затем **`rawSend`** → DMA.
|
||||
- **ControlPointUnion** (`CustomCmd.h`, слоты): запрос версии через **`sendResp`** с **`version_query`** — задержка **`IR_ResponseDelay`**, затем **`sendData`** на адрес машинки.
|
||||
- **ControlPointUnion** (`Plan_B.ino`): разбор **`version_response`** из **`gotData` / `gotBackData`** только после **успешного CRC** в декодере.
|
||||
|
||||
---
|
||||
|
||||
## 7. Выводы
|
||||
|
||||
1. **Байты в RAM** на передаче формируются корректно библиотекой; проблема «после DMA» укладывается в **расхождение тайминговой развёртки** (`buildGateRuns` + DMA) со **старой** развёрткой ISR, а не в «другой CRC на машинке» при неизменённой библиотеке.
|
||||
2. **Подозрение №1:** `runLenTicks = toggleCounter + 1` в **`buildGateRuns`** не совпадает с числом тиков ISR между шагами FSM (**`N`** vs **`N+1`**). Требуется сверка с эталонной трассой ISR или логическим анализатором.
|
||||
3. **Проверка на будущее:** сравнить побитово выходы ISR и DMA на **одном** буфере (8 и 31 байт); при необходимости поправить формулу длины run в **`IR-protocol`** и пересобрать Car и пульт.
|
||||
4. При **DMA-режиме передачи** на STM32 соблюдать **приоритеты NVIC** (раздел **2.1**): приём EXTI **выше**, чем DMA ИК-TX.
|
||||
|
||||
---
|
||||
|
||||
## 8. Ссылки на файлы
|
||||
|
||||
| Файл | Назначение |
|
||||
|------|------------|
|
||||
| `Documents/Arduino/libraries/IR-protocol/IR_Encoder.cpp` | `buildGateRuns`, `_isr`, `rawSend` |
|
||||
| `Documents/Arduino/libraries/IR-protocol/IR_Decoder.cpp` | `setReceiveExtiPreemptPriority` / `enable`: опциональный `NVIC_SetPriority` для EXTI (Arduino STM32) |
|
||||
| `Documents/Arduino/libraries/IR-protocol/IR_config.cpp` | `crc8` |
|
||||
| `Car/src/IR/IR.cpp` | `setExternalTxBackend`, `txStart` |
|
||||
| `Car/src/IR/IrDmaBackend.cpp` | `startStream`, `totalTicks`, `nextWord`, NVIC DMA из `CarIrq` |
|
||||
| `Car/src/IR/IR.cpp` | `setReceiveExtiPreemptPriority` + `enable` декодера |
|
||||
| `ControlPointUnion/Plan_B/TestPoints/CustomCmd.h` | `sendResp` / `version_query` для тестовых слотов |
|
||||
|
||||
---
|
||||
|
||||
*Документ составлен по обсуждению в чате; при смене версии IR-protocol числа констант и `totalTicks` пересчитывайте скриптом.*
|
||||
@ -1,5 +1,67 @@
|
||||
#include "IR_Decoder.h"
|
||||
|
||||
#if defined(ARDUINO_ARCH_STM32) && !defined(HAL_EXTI_MODULE_DISABLED)
|
||||
#include "Arduino.h"
|
||||
/* NVIC_SetPriority — CMSIS, как в IR_Encoder::begin и Car.ino (без HAL-заголовка yyxx). */
|
||||
|
||||
/** NVIC для линии EXTI пина (как в Arduino STM32 SrcWrapper interrupt.cpp). */
|
||||
static IRQn_Type ir_decoder_exti_irqn_for_pin(uint8_t arduino_pin)
|
||||
{
|
||||
#if defined(STM32C0xx) || defined(STM32F0xx) || defined(STM32G0xx) || defined(STM32L0xx)
|
||||
(void)arduino_pin;
|
||||
return (IRQn_Type)(-1);
|
||||
#else
|
||||
const PinName p = digitalPinToPinName(arduino_pin);
|
||||
if (p == NC) {
|
||||
return (IRQn_Type)(-1);
|
||||
}
|
||||
const uint16_t pinmask = STM_GPIO_PIN(p);
|
||||
uint8_t id = 0U;
|
||||
uint16_t pm = pinmask;
|
||||
while (pm != 0x0001U) {
|
||||
pm = (uint16_t)(pm >> 1U);
|
||||
id++;
|
||||
}
|
||||
#if defined(STM32H5xx) || defined(STM32MP1xx) || defined(STM32L5xx) || defined(STM32U5xx) || defined(STM32WBAxx)
|
||||
static const IRQn_Type exti_irqnb[16] = {
|
||||
EXTI0_IRQn, EXTI1_IRQn, EXTI2_IRQn, EXTI3_IRQn, EXTI4_IRQn, EXTI5_IRQn, EXTI6_IRQn,
|
||||
EXTI7_IRQn, EXTI8_IRQn, EXTI9_IRQn, EXTI10_IRQn, EXTI11_IRQn,
|
||||
EXTI12_IRQn, EXTI13_IRQn, EXTI14_IRQn, EXTI15_IRQn};
|
||||
#else
|
||||
static const IRQn_Type exti_irqnb[16] = {
|
||||
EXTI0_IRQn, EXTI1_IRQn, EXTI2_IRQn, EXTI3_IRQn, EXTI4_IRQn,
|
||||
EXTI9_5_IRQn, EXTI9_5_IRQn, EXTI9_5_IRQn, EXTI9_5_IRQn, EXTI9_5_IRQn,
|
||||
EXTI15_10_IRQn, EXTI15_10_IRQn, EXTI15_10_IRQn, EXTI15_10_IRQn,
|
||||
EXTI15_10_IRQn, EXTI15_10_IRQn};
|
||||
#endif
|
||||
if (id < 16U) {
|
||||
return exti_irqnb[id];
|
||||
}
|
||||
return (IRQn_Type)(-1);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void ir_decoder_apply_rx_exti_nvic(uint8_t arduino_pin, uint32_t preempt)
|
||||
{
|
||||
const IRQn_Type irqn = ir_decoder_exti_irqn_for_pin(arduino_pin);
|
||||
if ((int)irqn < 0) {
|
||||
return;
|
||||
}
|
||||
#if !defined(STM32C0xx) && !defined(STM32F0xx) && !defined(STM32G0xx) && !defined(STM32L0xx)
|
||||
NVIC_SetPriority(irqn, preempt);
|
||||
#endif
|
||||
}
|
||||
|
||||
void IR_Decoder::setReceiveExtiPreemptPriority(uint32_t preempt)
|
||||
{
|
||||
rxExtiPreemptConfigured_ = true;
|
||||
rxExtiPreemptValue_ = preempt;
|
||||
if (extiEnabled_) {
|
||||
ir_decoder_apply_rx_exti_nvic(pin, preempt);
|
||||
}
|
||||
}
|
||||
#endif /* ARDUINO_ARCH_STM32 && !HAL_EXTI_MODULE_DISABLED */
|
||||
|
||||
std::list<IR_Decoder *> &IR_Decoder::get_dec_list() // определение функции
|
||||
{
|
||||
static std::list<IR_Decoder *> dec_list; // статическая локальная переменная
|
||||
@ -7,11 +69,11 @@ std::list<IR_Decoder *> &IR_Decoder::get_dec_list() // определение ф
|
||||
}
|
||||
|
||||
// IR_Decoder::IR_Decoder() {};
|
||||
IR_Decoder::IR_Decoder(const uint8_t pin, uint16_t addr, IR_Encoder *encPair, bool autoHandle)
|
||||
IR_Decoder::IR_Decoder(const uint8_t pin, uint16_t addr, IR_Encoder *encPair, bool enableOnConstruct)
|
||||
: IR_DecoderRaw(pin, addr, encPair)
|
||||
{
|
||||
get_dec_list().push_back(this);
|
||||
if(autoHandle){
|
||||
if (enableOnConstruct) {
|
||||
enable();
|
||||
}
|
||||
};
|
||||
@ -25,10 +87,17 @@ void IR_Decoder::enable()
|
||||
}
|
||||
pinMode(pin, INPUT_PULLUP);
|
||||
attachInterrupt(pin, (*this)(), CHANGE);
|
||||
extiEnabled_ = true;
|
||||
#if defined(ARDUINO_ARCH_STM32) && !defined(HAL_EXTI_MODULE_DISABLED)
|
||||
if (rxExtiPreemptConfigured_) {
|
||||
ir_decoder_apply_rx_exti_nvic(pin, rxExtiPreemptValue_);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void IR_Decoder::disable()
|
||||
{
|
||||
extiEnabled_ = false;
|
||||
detachInterrupt(pin);
|
||||
pinMode(pin, INPUT);
|
||||
auto &dec_list = get_dec_list();
|
||||
@ -61,11 +130,9 @@ void IR_Decoder::tick()
|
||||
void IR_Decoder::_tick()
|
||||
{
|
||||
IR_DecoderRaw::tick();
|
||||
|
||||
if (availableRaw())
|
||||
{
|
||||
#ifdef IRDEBUG_INFO
|
||||
Serial.println("PARSING RAW DATA");
|
||||
#endif
|
||||
isWaitingAcceptSend = false;
|
||||
switch (packInfo.buffer[0] >> 5 & IR_MASK_MSG_TYPE)
|
||||
{
|
||||
@ -103,3 +170,7 @@ void IR_Decoder::_tick()
|
||||
isWaitingAcceptSend = false;
|
||||
}
|
||||
}
|
||||
|
||||
bool IR_Decoder::isReceive(uint8_t type) {
|
||||
return (msgTypeReceive & 0b11111000) && ((msgTypeReceive & IR_MASK_MSG_TYPE) == type);
|
||||
}
|
||||
|
||||
27
IR_Decoder.h
27
IR_Decoder.h
@ -17,6 +17,10 @@ private:
|
||||
uint16_t acceptDelay = IR_ResponseDelay;
|
||||
uint8_t acceptCustomByte;
|
||||
|
||||
bool extiEnabled_ = false;
|
||||
bool rxExtiPreemptConfigured_ = false;
|
||||
uint32_t rxExtiPreemptValue_ = 0;
|
||||
|
||||
public:
|
||||
PacketTypes::Data gotData;
|
||||
PacketTypes::DataBack gotBackData;
|
||||
@ -25,17 +29,38 @@ public:
|
||||
PacketTypes::BasePack gotRaw;
|
||||
|
||||
// IR_Decoder();
|
||||
IR_Decoder(const uint8_t pin, uint16_t addr = 0, IR_Encoder *encPair = nullptr, bool autoHandle = true);
|
||||
/** @param enableOnConstruct true — вызвать enable() из конструктора; false — отложенный enable() (NVIC и т.д.), tick — tickThis() / tick(). */
|
||||
IR_Decoder(const uint8_t pin, uint16_t addr = 0, IR_Encoder *encPair = nullptr, bool enableOnConstruct = true);
|
||||
|
||||
std::function<void()> operator()();
|
||||
|
||||
/**
|
||||
* Arduino STM32: после attachInterrupt ядро выставляет свой приоритет EXTI.
|
||||
* Если вызывали setReceiveExtiPreemptPriority(), здесь он применяется поверх (обычно нужен выше срочности, чем DMA ИК-TX).
|
||||
* На других платформах поведение без изменений.
|
||||
*/
|
||||
void enable();
|
||||
void disable();
|
||||
|
||||
#if defined(ARDUINO_ARCH_STM32) && !defined(HAL_EXTI_MODULE_DISABLED)
|
||||
/**
|
||||
* Задать preempt-приоритет NVIC для EXTI линии этого пина (тот же смысл, что второй аргумент CMSIS NVIC_SetPriority).
|
||||
* Вызывайте до или после enable(); при активном приёме применяется сразу.
|
||||
* При использовании DMA на передачу ИК preempt приёма должен быть меньше, чем у DMA TX (выше срочность прерывания).
|
||||
*/
|
||||
void setReceiveExtiPreemptPriority(uint32_t preempt);
|
||||
#endif
|
||||
|
||||
bool isReceive(uint8_t type);
|
||||
|
||||
~IR_Decoder();
|
||||
|
||||
/** Обойти все экземпляры из внутреннего списка и вызвать tick у каждого. */
|
||||
static void tick();
|
||||
|
||||
/** Tick только этого декодера (без обхода списка). Не комбинируйте с static tick() для того же экземпляра. */
|
||||
void tickThis() { _tick(); }
|
||||
|
||||
inline void setAcceptDelay(uint16_t acceptDelay)
|
||||
{
|
||||
this->acceptDelay = acceptDelay;
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
#include "IR_DecoderRaw.h"
|
||||
#include "IR_Encoder.h"
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
|
||||
IR_DecoderRaw::IR_DecoderRaw(const uint8_t pin, uint16_t addr, IR_Encoder *encPair) : encoder(encPair)
|
||||
{
|
||||
@ -47,29 +49,11 @@ volatile uint32_t time_;
|
||||
|
||||
void IR_DecoderRaw::isr()
|
||||
{
|
||||
// Serial.print("ISR\n");
|
||||
if(isPairSending){
|
||||
return;
|
||||
}
|
||||
|
||||
noInterrupts();
|
||||
// time_ = HAL_GetTick() * 1000 + ((SysTick->LOAD + 1 - SysTick->VAL) * 1000) / SysTick->LOAD + 1;
|
||||
time_ = micros();
|
||||
interrupts();
|
||||
if (time_ < oldTime)
|
||||
{
|
||||
|
||||
#ifdef IRDEBUG
|
||||
Serial.print("\n");
|
||||
Serial.print("count: ");
|
||||
Serial.println(wrongCounter++);
|
||||
Serial.print("time: ");
|
||||
Serial.println(time_);
|
||||
Serial.print("oldTime: ");
|
||||
Serial.println(oldTime);
|
||||
Serial.print("sub: ");
|
||||
Serial.println(max((uint32_t)time_, oldTime) - min((uint32_t)time_, oldTime));
|
||||
#endif
|
||||
time_ += 1000;
|
||||
}
|
||||
oldTime = time_;
|
||||
@ -78,6 +62,16 @@ void IR_DecoderRaw::isr()
|
||||
edge.dir = port->IDR & mask;
|
||||
edge.time = time_;
|
||||
|
||||
#if defined(IR_EDGE_TRACE)
|
||||
edgeTracePush(edge.time, edge.dir ? 1u : 0u,
|
||||
isPairSending ? (uint8_t)IR_EDGE_TRACE_F_SKIP_DECODE : 0u);
|
||||
#endif
|
||||
|
||||
if (isPairSending)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
subBuffer.push(edge);
|
||||
}
|
||||
|
||||
@ -85,9 +79,8 @@ void IR_DecoderRaw::isr()
|
||||
|
||||
void IR_DecoderRaw::firstRX()
|
||||
{
|
||||
|
||||
#ifdef IRDEBUG_INFO
|
||||
Serial.print("\nRX>");
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
packTraceResetFrame();
|
||||
#endif
|
||||
|
||||
errors.reset();
|
||||
@ -112,16 +105,42 @@ void IR_DecoderRaw::firstRX()
|
||||
|
||||
void IR_DecoderRaw::listenStart()
|
||||
{
|
||||
if (isRecive && ((micros() - prevRise) > IR_timeout * 2))
|
||||
if (isReciveRaw && ((micros() - prevRise) > IR_timeout * 2))
|
||||
{
|
||||
// Serial.print("\nlis>");
|
||||
isRecive = false;
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
packTraceOnTimeoutOrAbort(true);
|
||||
#endif
|
||||
isReciveRaw = false;
|
||||
firstRX();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ---- быстрая проверка конца пакета ---------------------------------
|
||||
inline void IR_DecoderRaw::checkTimeout()
|
||||
{
|
||||
if (!isRecive) return; // уже не принимаем – нечего проверять
|
||||
|
||||
if (micros() - lastEdgeTime > IR_timeout * 2U)
|
||||
{
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
packTraceOnTimeoutOrAbort(false);
|
||||
#endif
|
||||
isRecive = false; // приём завершён
|
||||
msgTypeReceive = 0;
|
||||
// firstRX(); // подготовка к новому пакету
|
||||
lastEdgeTime = micros(); // защита от повторного срабатывания
|
||||
}
|
||||
}
|
||||
// ====================================================================
|
||||
|
||||
void IR_DecoderRaw::tick()
|
||||
{
|
||||
// FrontStorage *currentFrontPtr;
|
||||
// noInterrupts();
|
||||
// currentFrontPtr = subBuffer.pop();
|
||||
// interrupts();
|
||||
|
||||
FrontStorage currentFront;
|
||||
noInterrupts();
|
||||
listenStart();
|
||||
@ -130,12 +149,27 @@ void IR_DecoderRaw::tick()
|
||||
if (currentFrontPtr == nullptr)
|
||||
{
|
||||
isSubBufferOverflow = false;
|
||||
checkTimeout(); // <--- новое место проверки
|
||||
interrupts();
|
||||
#if defined(IR_EDGE_TRACE)
|
||||
while (edgeTraceFlushChunk(Serial, 48) > 0) {}
|
||||
#endif
|
||||
return;
|
||||
} // Если данных нет - ничего не делаем
|
||||
currentFront = *currentFrontPtr;
|
||||
interrupts();
|
||||
|
||||
// ---------- буфер пуст: фронтов нет, проверяем тайм-аут ----------
|
||||
// if (currentFrontPtr == nullptr)
|
||||
// {
|
||||
// isSubBufferOverflow = false;
|
||||
// return;
|
||||
// }
|
||||
|
||||
// // ---------- есть фронт: продолжаем обработку ----------
|
||||
// FrontStorage currentFront = *currentFrontPtr;
|
||||
lastEdgeTime = currentFront.time; // запоминаем любой фронт
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
if (currentFront.dir)
|
||||
@ -197,7 +231,7 @@ void IR_DecoderRaw::tick()
|
||||
digitalWrite(errOut, currentFront.dir);
|
||||
#endif
|
||||
|
||||
if (currentFront.time > prevRise && currentFront.time - prevRise > IR_timeout * 2 && !isRecive)
|
||||
if (currentFront.time > prevRise && currentFront.time - prevRise > IR_timeout * 2 && !isReciveRaw)
|
||||
{ // первый
|
||||
#ifdef IRDEBUG
|
||||
errPulse(up, 50);
|
||||
@ -209,7 +243,12 @@ void IR_DecoderRaw::tick()
|
||||
isPreamb = true;
|
||||
|
||||
isRecive = true;
|
||||
isReciveRaw = true;
|
||||
isWrongPack = false;
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
packTraceResetFrame();
|
||||
packTraceOpen = true;
|
||||
#endif
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------
|
||||
@ -217,8 +256,8 @@ void IR_DecoderRaw::tick()
|
||||
if (preambFrontCounter)
|
||||
{ // в преамбуле
|
||||
#ifdef IRDEBUG
|
||||
Serial.print("risePeriod: ");
|
||||
Serial.println(risePeriod);
|
||||
// Serial.print("risePeriod: ");
|
||||
// Serial.println(risePeriod);
|
||||
#endif
|
||||
if (currentFront.dir && risePeriod < IR_timeout)
|
||||
{ // __/``` ↑ и мы в внутри пакета
|
||||
@ -278,21 +317,21 @@ void IR_DecoderRaw::tick()
|
||||
lowCount = 0;
|
||||
allCount = 0;
|
||||
bool invertErr = false;
|
||||
#ifdef IRDEBUG
|
||||
Serial.print("\n");
|
||||
// #ifdef IRDEBUG
|
||||
// Serial.print("\n");
|
||||
|
||||
Serial.print("wrCounter: ");
|
||||
Serial.println(wrCounter++);
|
||||
// Serial.print("wrCounter: ");
|
||||
// Serial.println(wrCounter++);
|
||||
|
||||
Serial.print("risePeriod: ");
|
||||
Serial.println(risePeriod);
|
||||
// Serial.print("risePeriod: ");
|
||||
// Serial.println(risePeriod);
|
||||
|
||||
Serial.print("highTime: ");
|
||||
Serial.println(highTime);
|
||||
// Serial.print("highTime: ");
|
||||
// Serial.println(highTime);
|
||||
|
||||
Serial.print("lowTime: ");
|
||||
Serial.println(lowTime);
|
||||
#endif
|
||||
// Serial.print("lowTime: ");
|
||||
// Serial.println(lowTime);
|
||||
// #endif
|
||||
|
||||
if (aroundRise(risePeriod))
|
||||
{ // тактирование есть, сигнал хороший - без ошибок(?)
|
||||
@ -386,7 +425,7 @@ void IR_DecoderRaw::tick()
|
||||
if (i == lowCount - 1 && invertErr)
|
||||
{
|
||||
invertErr = false;
|
||||
writeToBuffer(HIGH);
|
||||
writeToBuffer(HIGH, true);
|
||||
#ifdef IRDEBUG
|
||||
errPulse(wrHigh, 1);
|
||||
#endif
|
||||
@ -405,7 +444,7 @@ void IR_DecoderRaw::tick()
|
||||
if (i == highCount - 1 && invertErr)
|
||||
{
|
||||
invertErr = false;
|
||||
writeToBuffer(LOW);
|
||||
writeToBuffer(LOW, true);
|
||||
#ifdef IRDEBUG
|
||||
errPulse(wrLow, 1);
|
||||
#endif
|
||||
@ -426,21 +465,29 @@ void IR_DecoderRaw::tick()
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
END:;
|
||||
#if defined(IR_EDGE_TRACE)
|
||||
while (edgeTraceFlushChunk(Serial, 48) > 0) {}
|
||||
#endif
|
||||
}
|
||||
|
||||
void IR_DecoderRaw::writeToBuffer(bool bit)
|
||||
void IR_DecoderRaw::writeToBuffer(bool bit, bool packTraceInvertFix)
|
||||
{
|
||||
#if !defined(IRDEBUG_SERIAL_PACK)
|
||||
(void)packTraceInvertFix;
|
||||
#endif
|
||||
if (i_dataBuffer > dataByteSizeMax * 8)
|
||||
{ // проверка переполнения
|
||||
// TODO: Буффер переполнен!
|
||||
#ifdef IRDEBUG_INFO
|
||||
Serial.println("OverBuf");
|
||||
#endif
|
||||
isBufferOverflow = true;
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
if (packTraceOpen)
|
||||
packTraceEmitErrorFlash(F("ERROR: buffer overflow"));
|
||||
#endif
|
||||
}
|
||||
if (isBufferOverflow || isPreamb || isWrongPack)
|
||||
{
|
||||
isRecive = false;
|
||||
isReciveRaw = false;
|
||||
msgTypeReceive = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
@ -451,112 +498,98 @@ void IR_DecoderRaw::writeToBuffer(bool bit)
|
||||
isData = !isData;
|
||||
i_syncBit = 0; // сброс счетчика битов синхронизации
|
||||
err_syncBit = 0; // сброс счетчика ошибок синхронизации
|
||||
#ifdef IRDEBUG_INFO
|
||||
Serial.print(" ");
|
||||
#endif
|
||||
}
|
||||
|
||||
if (isData)
|
||||
{ // Запись битов в dataBuffer
|
||||
#ifdef IRDEBUG_INFO
|
||||
Serial.print(bit);
|
||||
#endif
|
||||
|
||||
// if (i_dataBuffer % 8 == 7) {
|
||||
// // Serial.print("+");
|
||||
// }
|
||||
|
||||
dataBuffer[(i_dataBuffer / 8)] |= bit << (7 - i_dataBuffer % 8); // Запись в буффер
|
||||
i_dataBuffer++;
|
||||
bufBitPos++;
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
if (packTraceInvertFix)
|
||||
{
|
||||
packTracePushChar('`');
|
||||
packTracePushChar(bit ? '1' : '0');
|
||||
packTracePushChar('`');
|
||||
}
|
||||
else
|
||||
packTracePushBit(bit);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
//********************************* Проверка контрольных sync битов*******************************//
|
||||
//********************************* Проверка контрольных sync битов *******************************//
|
||||
////////////////////// Исправление лишнего нуля ///////////////////////
|
||||
if (i_syncBit == 0)
|
||||
{ // Первый бит синхронизации
|
||||
// Serial.print("~");
|
||||
if (bit != (dataBuffer[((i_dataBuffer - 1) / 8)] >> (7 - (i_dataBuffer - 1) % 8) & 1))
|
||||
{
|
||||
bufBitPos++;
|
||||
i_syncBit++;
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
packTracePushBit(bit);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
i_syncBit = 0;
|
||||
errors.other++;
|
||||
// Serial.print("E");
|
||||
err_syncBit++;
|
||||
// Serial.print("bit: "); Serial.println(bit);
|
||||
// Serial.print("dataBuffer: "); Serial.println(dataBuffer[((i_dataBuffer - 1) / 8)] & 1 << (7 - ((i_dataBuffer - 1) & ~(~0 << 3))));
|
||||
const bool fatalSync = (err_syncBit >= syncBits);
|
||||
if (fatalSync)
|
||||
{
|
||||
#if defined(IRDEBUG_SERIAL_PACK) && defined(IRDEBUG_SERIAL_SOFT_REJECT)
|
||||
if (packTraceSoftReject())
|
||||
{
|
||||
packTraceHadWrongSync = true;
|
||||
packTraceForceEndSyncPhase();
|
||||
err_syncBit = 0;
|
||||
i_syncBit = 0;
|
||||
isWrongPack = false;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
isWrongPack = true;
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
packTraceEmitErrorFlash(F("ERROR: Wrong sync bit"));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{ // Последующие биты синхронизации
|
||||
// Serial.print("`");
|
||||
bufBitPos++;
|
||||
i_syncBit++;
|
||||
}
|
||||
////////////////////// Проверка наличия битов синхранизации //////////////////////
|
||||
if (isWrongPack = (err_syncBit >= syncBits))
|
||||
{
|
||||
#ifdef IRDEBUG_INFO
|
||||
Serial.print("****************");
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
packTracePushBit(bit);
|
||||
#endif
|
||||
};
|
||||
|
||||
}
|
||||
isWrongPack = (err_syncBit >= syncBits);
|
||||
} //**************************************************************************************************//
|
||||
|
||||
// Serial.print(bit);
|
||||
#ifdef IRDEBUG
|
||||
bit ? infoPulse(writeOp, 2) : infoPulse(writeOp, 1);
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef IRDEBUG_INFO
|
||||
if (isData)
|
||||
{
|
||||
if (i_dataBuffer == ((msgBytes)*bitPerByte))
|
||||
{
|
||||
Serial.print(" -> ");
|
||||
Serial.print(dataBuffer[0] & IR_MASK_MSG_INFO);
|
||||
Serial.print(" ->");
|
||||
}
|
||||
if (i_dataBuffer == ((msgBytes + addrBytes) * bitPerByte))
|
||||
{
|
||||
Serial.print(" |");
|
||||
}
|
||||
if (i_dataBuffer == ((msgBytes + addrBytes + addrBytes) * bitPerByte))
|
||||
{
|
||||
Serial.print(" ->");
|
||||
}
|
||||
if (i_dataBuffer == (((dataBuffer[0] & IR_MASK_MSG_INFO) - 2) * bitPerByte))
|
||||
{
|
||||
Serial.print(" <-");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!isAvailable && isData && !isWrongPack)
|
||||
{
|
||||
if (i_dataBuffer == 8 * msgBytes)
|
||||
{ // Ппервый байт
|
||||
packSize = dataBuffer[0] & IR_MASK_MSG_INFO;
|
||||
#ifdef IRDEBUG_INFO
|
||||
Serial.print(" [");
|
||||
Serial.print(packSize);
|
||||
Serial.print("] ");
|
||||
#endif
|
||||
}
|
||||
|
||||
// Тип приёма (для isReceive): выставляем сразу после первого байта, ДО проверки «Конец».
|
||||
// Иначе при packSize==1 один и тот же шаг i_dataBuffer==8 одновременно «закрывает» кадр (msgTypeReceive=0)
|
||||
// и снова выставляет msgTypeReceive ниже — флаг залипает, пока не придёт ошибка/другой кадр.
|
||||
if (packSize && (i_dataBuffer == 8))
|
||||
{
|
||||
msgTypeReceive = (dataBuffer[0] >> 5) | 0b11111000;
|
||||
}
|
||||
|
||||
if (packSize && (i_dataBuffer == packSize * bitPerByte))
|
||||
{ // Конец
|
||||
#ifdef IRDEBUG_INFO
|
||||
Serial.print(" END DATA " + crcCheck(packSize - crcBytes, crcValue) ? "OK " : "ERR ");
|
||||
#endif
|
||||
|
||||
packInfo.buffer = dataBuffer;
|
||||
packInfo.crc = crcValue;
|
||||
packInfo.err = errors;
|
||||
@ -564,9 +597,15 @@ void IR_DecoderRaw::writeToBuffer(bool bit)
|
||||
packInfo.rTime = riseSyncTime;
|
||||
|
||||
isRecive = false;
|
||||
isReciveRaw = false;
|
||||
msgTypeReceive = 0;
|
||||
isAvailable = crcCheck(packSize - crcBytes, crcValue);
|
||||
|
||||
#ifdef BRUTEFORCE_CHECK
|
||||
{
|
||||
uint16_t packTraceBfByte = 0;
|
||||
uint8_t packTraceBfBit = 0;
|
||||
bool packTraceBfMark = false;
|
||||
if (!isAvailable) // Исправление первого бита // Очень большая затычка...
|
||||
for (size_t i = 0; i < min(uint16_t(packSize - crcBytes * 2U), uint16_t(dataByteSizeMax)); ++i)
|
||||
{
|
||||
@ -575,14 +614,15 @@ void IR_DecoderRaw::writeToBuffer(bool bit)
|
||||
// инвертируем бит
|
||||
dataBuffer[i] ^= 1 << j;
|
||||
|
||||
isAvailable = crcCheck(min(uint16_t(packSize - crcBytes), uint16_t(dataByteSizeMax - 1U)), crcValue);
|
||||
isAvailable =
|
||||
crcCheck(min(uint16_t(packSize - crcBytes), uint16_t(dataByteSizeMax - 1U)), crcValue);
|
||||
// обратно инвертируем бит в исходное состояние
|
||||
|
||||
if (isAvailable)
|
||||
{
|
||||
#ifdef IRDEBUG_INFO
|
||||
Serial.println("!!!INV!!!");
|
||||
#endif
|
||||
packTraceBfByte = static_cast<uint16_t>(i);
|
||||
packTraceBfBit = static_cast<uint8_t>(j);
|
||||
packTraceBfMark = true;
|
||||
goto OUT_BRUTEFORCE;
|
||||
}
|
||||
else
|
||||
@ -591,9 +631,25 @@ void IR_DecoderRaw::writeToBuffer(bool bit)
|
||||
}
|
||||
}
|
||||
}
|
||||
OUT_BRUTEFORCE:;
|
||||
OUT_BRUTEFORCE:
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
if (packTraceBfMark)
|
||||
packTraceWrapDataBitInBackticks(packTraceBfByte, packTraceBfBit);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
if (isAvailable)
|
||||
packTraceEmitEndOk(static_cast<uint8_t>(packSize));
|
||||
else
|
||||
packTraceEmitEndBadCrc(static_cast<uint8_t>(packSize));
|
||||
#endif
|
||||
if (!isAvailable && packSize > 0 && packSize <= dataByteSizeMax) {
|
||||
memcpy(rejectBuffer, dataBuffer, packSize);
|
||||
rejectPackSize = static_cast<uint8_t>(packSize);
|
||||
isRejectAvailable = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
@ -607,9 +663,7 @@ bool IR_DecoderRaw::crcCheck(uint8_t len, crc_t &crc)
|
||||
crc = (crc8(dataBuffer, 0, len, poly1) << 8) & ~((crc_t)0xFF);
|
||||
crc |= crc8(dataBuffer, 0, len + 1, poly2) & (crc_t)0xFF;
|
||||
|
||||
if (
|
||||
crc &&
|
||||
dataBuffer[len] == (crc >> 8) & 0xFF &&
|
||||
if (dataBuffer[len] == (crc >> 8) & 0xFF &&
|
||||
dataBuffer[len + 1] == (crc & 0xFF))
|
||||
{
|
||||
crcOK = true;
|
||||
@ -622,6 +676,14 @@ bool IR_DecoderRaw::crcCheck(uint8_t len, crc_t &crc)
|
||||
return crcOK;
|
||||
}
|
||||
|
||||
bool IR_DecoderRaw::availableReject()
|
||||
{
|
||||
if (!isRejectAvailable)
|
||||
return false;
|
||||
isRejectAvailable = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
uint16_t IR_DecoderRaw::ceil_div(uint16_t val, uint16_t divider)
|
||||
{
|
||||
int ret = val / divider;
|
||||
@ -630,6 +692,461 @@ uint16_t IR_DecoderRaw::ceil_div(uint16_t val, uint16_t divider)
|
||||
return ret;
|
||||
}
|
||||
|
||||
#if defined(IR_EDGE_TRACE)
|
||||
|
||||
void IR_DecoderRaw::edgeTracePush(uint32_t t_us, uint8_t level, uint8_t flags)
|
||||
{
|
||||
const uint16_t cap = static_cast<uint16_t>(IR_EDGE_TRACE_CAPACITY);
|
||||
noInterrupts();
|
||||
const uint16_t w = edgeTrace_w;
|
||||
const uint16_t r = edgeTrace_r;
|
||||
const uint16_t next = static_cast<uint16_t>((w + 1u) % cap);
|
||||
if (next == r)
|
||||
{
|
||||
edgeTrace_overflow = true;
|
||||
interrupts();
|
||||
return;
|
||||
}
|
||||
edgeTrace_buf[w].t_us = t_us;
|
||||
edgeTrace_buf[w].level = level ? 1u : 0u;
|
||||
edgeTrace_buf[w].flags = flags;
|
||||
edgeTrace_w = next;
|
||||
interrupts();
|
||||
}
|
||||
|
||||
void IR_DecoderRaw::edgeTraceClear()
|
||||
{
|
||||
noInterrupts();
|
||||
edgeTrace_w = 0;
|
||||
edgeTrace_r = 0;
|
||||
edgeTrace_overflow = false;
|
||||
interrupts();
|
||||
}
|
||||
|
||||
uint16_t IR_DecoderRaw::edgeTracePendingCount() const
|
||||
{
|
||||
noInterrupts();
|
||||
const uint16_t w = edgeTrace_w;
|
||||
const uint16_t r = edgeTrace_r;
|
||||
interrupts();
|
||||
const uint16_t cap = static_cast<uint16_t>(IR_EDGE_TRACE_CAPACITY);
|
||||
if (w >= r)
|
||||
return static_cast<uint16_t>(w - r);
|
||||
return static_cast<uint16_t>(cap - r + w);
|
||||
}
|
||||
|
||||
uint16_t IR_DecoderRaw::edgeTraceFlushChunk(Print &out, uint16_t maxRec)
|
||||
{
|
||||
if (maxRec == 0)
|
||||
maxRec = 48;
|
||||
constexpr uint16_t kStackCap = 64;
|
||||
if (maxRec > kStackCap)
|
||||
maxRec = kStackCap;
|
||||
|
||||
const uint16_t cap = static_cast<uint16_t>(IR_EDGE_TRACE_CAPACITY);
|
||||
noInterrupts();
|
||||
const uint16_t w = edgeTrace_w;
|
||||
const uint16_t r = edgeTrace_r;
|
||||
uint16_t avail = (w >= r) ? static_cast<uint16_t>(w - r) : static_cast<uint16_t>(cap - r + w);
|
||||
uint16_t toCopy = (avail > maxRec) ? maxRec : avail;
|
||||
const bool truncated = (avail > toCopy);
|
||||
if (toCopy == 0)
|
||||
{
|
||||
interrupts();
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t tmp[kStackCap * 6];
|
||||
for (uint16_t i = 0; i < toCopy; ++i)
|
||||
{
|
||||
const uint16_t idx = static_cast<uint16_t>((r + i) % cap);
|
||||
memcpy(tmp + i * 6u, &edgeTrace_buf[idx], 6u);
|
||||
}
|
||||
edgeTrace_r = static_cast<uint16_t>((r + toCopy) % cap);
|
||||
const bool ovf = edgeTrace_overflow;
|
||||
interrupts();
|
||||
|
||||
uint8_t meta = 0;
|
||||
if (ovf)
|
||||
meta |= 0x01u;
|
||||
if (truncated)
|
||||
meta |= 0x02u;
|
||||
|
||||
uint8_t line[3 + kStackCap * 6];
|
||||
line[0] = meta;
|
||||
line[1] = static_cast<uint8_t>(toCopy & 0xFFu);
|
||||
line[2] = static_cast<uint8_t>((toCopy >> 8) & 0xFFu);
|
||||
memcpy(line + 3, tmp, toCopy * 6u);
|
||||
|
||||
out.print(F("\n@IRF1v1:"));
|
||||
static const char hd[] = "0123456789abcdef";
|
||||
const uint16_t lineLen = static_cast<uint16_t>(3u + toCopy * 6u);
|
||||
for (uint16_t i = 0; i < lineLen; ++i)
|
||||
{
|
||||
const uint8_t b = line[i];
|
||||
out.write(hd[b >> 4]);
|
||||
out.write(hd[b & 0x0Fu]);
|
||||
}
|
||||
out.write('\n');
|
||||
return toCopy;
|
||||
}
|
||||
|
||||
#endif // IR_EDGE_TRACE
|
||||
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
|
||||
struct IrPackTraceSeg
|
||||
{
|
||||
uint8_t isSync;
|
||||
uint8_t nbits; // число логических бит (данные) или символов синхры
|
||||
uint8_t nchars; // сырых символов в b (данные: 8…24 из‑за `0`/`1`)
|
||||
char b[24];
|
||||
};
|
||||
|
||||
namespace {
|
||||
|
||||
void ptPrintHexU8(uint8_t v)
|
||||
{
|
||||
static const char hd[] = "0123456789ABCDEF";
|
||||
Serial.print(hd[v >> 4]);
|
||||
Serial.print(hd[v & 0x0Fu]);
|
||||
}
|
||||
|
||||
/** Тройной пробел перед началом блока: msg→from, from→to, to→data, data→CRC. */
|
||||
static bool ptRawLeadTriple(uint8_t byteIndex, uint8_t framePs)
|
||||
{
|
||||
if (byteIndex == 1 || byteIndex == 3)
|
||||
return true;
|
||||
if (framePs > 7 && byteIndex == 5)
|
||||
return true;
|
||||
if (framePs >= 7 && byteIndex == static_cast<uint8_t>(framePs - 2))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
/** В IR raw: только 0/1 из flex-сегмента (без `), takeBits логических бит после skipLogical. */
|
||||
static void ptEmitRawFlexSliceSerial(const char *s, uint8_t nbytes, uint8_t skipLogical, uint8_t takeBits)
|
||||
{
|
||||
size_t i = 0;
|
||||
uint8_t logical = 0;
|
||||
uint8_t emitted = 0;
|
||||
while (i < nbytes && emitted < takeBits)
|
||||
{
|
||||
if (s[i] == '`' && i + 2u < nbytes && (s[i + 1] == '0' || s[i + 1] == '1') && s[i + 2] == '`')
|
||||
{
|
||||
if (logical >= skipLogical)
|
||||
{
|
||||
Serial.print(s[i + 1]);
|
||||
++emitted;
|
||||
}
|
||||
i += 3;
|
||||
++logical;
|
||||
}
|
||||
else if (s[i] == '0' || s[i] == '1')
|
||||
{
|
||||
if (logical >= skipLogical)
|
||||
{
|
||||
Serial.print(s[i]);
|
||||
++emitted;
|
||||
}
|
||||
++i;
|
||||
++logical;
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static bool ptTryConsumeFlexDataBit(const char *buf, uint16_t len, uint16_t &pos, IrPackTraceSeg &d)
|
||||
{
|
||||
if (pos + 2 < len && buf[pos] == '`' && (buf[pos + 1] == '0' || buf[pos + 1] == '1') && buf[pos + 2] == '`')
|
||||
{
|
||||
if (d.nchars + 3u > sizeof(d.b))
|
||||
return false;
|
||||
d.b[d.nchars++] = '`';
|
||||
d.b[d.nchars++] = buf[pos + 1];
|
||||
d.b[d.nchars++] = '`';
|
||||
pos = static_cast<uint16_t>(pos + 3u);
|
||||
return true;
|
||||
}
|
||||
if (pos < len && (buf[pos] == '0' || buf[pos] == '1'))
|
||||
{
|
||||
if (d.nchars + 1u > sizeof(d.b))
|
||||
return false;
|
||||
d.b[d.nchars++] = buf[pos++];
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void IR_DecoderRaw::packTraceResetFrame()
|
||||
{
|
||||
packTraceOpen = false;
|
||||
packTraceHadWrongSync = false;
|
||||
packTraceLen = 0;
|
||||
packTraceBitBuf[0] = '\0';
|
||||
}
|
||||
|
||||
void IR_DecoderRaw::packTracePushChar(char c)
|
||||
{
|
||||
if (packTraceLen + 1u < kPackTraceBufCap)
|
||||
{
|
||||
packTraceBitBuf[packTraceLen++] = c;
|
||||
packTraceBitBuf[packTraceLen] = '\0';
|
||||
}
|
||||
}
|
||||
|
||||
void IR_DecoderRaw::packTracePushBit(bool bit) { packTracePushChar(bit ? '1' : '0'); }
|
||||
|
||||
void IR_DecoderRaw::packTraceWrapDataBitInBackticks(uint16_t byteIndex, uint8_t bitInByte)
|
||||
{
|
||||
const uint32_t target = uint32_t(byteIndex) * 8u + bitInByte;
|
||||
uint32_t dbit = 0;
|
||||
uint16_t pos = 0;
|
||||
bool inData = true;
|
||||
uint16_t len = packTraceLen;
|
||||
if (len >= kPackTraceBufCap)
|
||||
len = kPackTraceBufCap - 1u;
|
||||
|
||||
while (pos < len)
|
||||
{
|
||||
if (inData)
|
||||
{
|
||||
uint8_t bitLen = 0;
|
||||
if (pos + 2 < len && packTraceBitBuf[pos] == '`' && packTraceBitBuf[pos + 2] == '`' &&
|
||||
(packTraceBitBuf[pos + 1] == '0' || packTraceBitBuf[pos + 1] == '1'))
|
||||
bitLen = 3;
|
||||
else if (packTraceBitBuf[pos] == '0' || packTraceBitBuf[pos] == '1')
|
||||
bitLen = 1;
|
||||
else
|
||||
return;
|
||||
|
||||
if (dbit == target)
|
||||
{
|
||||
if (bitLen == 3)
|
||||
return;
|
||||
if (packTraceLen + 2u >= kPackTraceBufCap)
|
||||
return;
|
||||
const uint8_t finalBit =
|
||||
static_cast<uint8_t>((dataBuffer[byteIndex] >> (7u - bitInByte)) & 1u);
|
||||
const char ch = finalBit ? '1' : '0';
|
||||
memmove(packTraceBitBuf + pos + 2, packTraceBitBuf + pos, packTraceLen - pos);
|
||||
packTraceBitBuf[pos] = '`';
|
||||
packTraceBitBuf[pos + 1] = ch;
|
||||
packTraceBitBuf[pos + 2] = '`';
|
||||
packTraceLen += 2;
|
||||
if (packTraceLen < kPackTraceBufCap)
|
||||
packTraceBitBuf[packTraceLen] = '\0';
|
||||
return;
|
||||
}
|
||||
++dbit;
|
||||
pos = static_cast<uint16_t>(pos + bitLen);
|
||||
if ((dbit % 8u) == 0u)
|
||||
inData = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
uint8_t sc = 0;
|
||||
while (pos < len && sc < syncBits)
|
||||
{
|
||||
const char c = packTraceBitBuf[pos];
|
||||
if (c == '0' || c == '1' || c == '?')
|
||||
{
|
||||
++pos;
|
||||
++sc;
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
inData = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool IR_DecoderRaw::packTraceSoftReject() const
|
||||
{
|
||||
#if defined(IRDEBUG_SERIAL_SOFT_REJECT)
|
||||
return true;
|
||||
#else
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
void IR_DecoderRaw::packTraceForceEndSyncPhase()
|
||||
{
|
||||
for (uint8_t i = 0; i < syncBits; i++)
|
||||
packTracePushChar('?');
|
||||
|
||||
const uint8_t cycLen = bitPerByte + syncBits;
|
||||
const uint16_t cyc = uint16_t(bufBitPos / cycLen);
|
||||
bufBitPos = uint16_t((cyc + 1u) * cycLen);
|
||||
if (bufBitPos == nextControlBit)
|
||||
{
|
||||
nextControlBit += (isData ? syncBits : bitPerByte);
|
||||
isData = !isData;
|
||||
i_syncBit = 0;
|
||||
err_syncBit = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void IR_DecoderRaw::packTraceEmitHex(uint8_t byteCount) const
|
||||
{
|
||||
Serial.print(F("IR hex:"));
|
||||
for (uint8_t i = 0; i < byteCount && i < dataByteSizeMax; i++)
|
||||
{
|
||||
Serial.print(' ');
|
||||
ptPrintHexU8(dataBuffer[i]);
|
||||
}
|
||||
Serial.println();
|
||||
}
|
||||
|
||||
void IR_DecoderRaw::packTraceEmitRawBitsLine(bool endWithNewline) const
|
||||
{
|
||||
Serial.print(F("IR raw: "));
|
||||
uint16_t len = packTraceLen;
|
||||
if (len >= kPackTraceBufCap)
|
||||
len = kPackTraceBufCap - 1u;
|
||||
const char *buf = packTraceBitBuf;
|
||||
uint16_t pos = 0;
|
||||
uint8_t byteIndex = 0;
|
||||
bool firstSeg = true;
|
||||
const uint8_t framePs =
|
||||
(i_dataBuffer >= 8) ? static_cast<uint8_t>(dataBuffer[0] & IR_MASK_MSG_INFO) : 0;
|
||||
|
||||
while (pos < len)
|
||||
{
|
||||
IrPackTraceSeg d{};
|
||||
d.isSync = 0;
|
||||
while (pos < len && d.nbits < 8)
|
||||
{
|
||||
const uint16_t posBefore = pos;
|
||||
if (!ptTryConsumeFlexDataBit(buf, len, pos, d))
|
||||
break;
|
||||
if (pos == posBefore)
|
||||
break;
|
||||
++d.nbits;
|
||||
}
|
||||
if (!d.nbits)
|
||||
break;
|
||||
|
||||
if (!firstSeg)
|
||||
{
|
||||
if (ptRawLeadTriple(byteIndex, framePs))
|
||||
Serial.print(F(" "));
|
||||
else
|
||||
Serial.print(' ');
|
||||
}
|
||||
firstSeg = false;
|
||||
|
||||
if (d.nbits < 8)
|
||||
{
|
||||
ptEmitRawFlexSliceSerial(d.b, d.nchars, 0, d.nbits);
|
||||
break;
|
||||
}
|
||||
|
||||
if (byteIndex == 0u)
|
||||
{
|
||||
ptEmitRawFlexSliceSerial(d.b, d.nchars, 0, 3);
|
||||
Serial.print(' ');
|
||||
ptEmitRawFlexSliceSerial(d.b, d.nchars, 3, 5);
|
||||
}
|
||||
else
|
||||
ptEmitRawFlexSliceSerial(d.b, d.nchars, 0, 8);
|
||||
|
||||
++byteIndex;
|
||||
|
||||
if (pos >= len)
|
||||
break;
|
||||
|
||||
IrPackTraceSeg s{};
|
||||
s.isSync = 1;
|
||||
while (pos < len && s.nbits < syncBits)
|
||||
{
|
||||
const char c = buf[pos];
|
||||
if (c != '0' && c != '1' && c != '?')
|
||||
break;
|
||||
if (s.nchars >= sizeof(s.b))
|
||||
break;
|
||||
s.b[s.nchars++] = c;
|
||||
++s.nbits;
|
||||
++pos;
|
||||
}
|
||||
if (s.nbits)
|
||||
{
|
||||
Serial.print(' ');
|
||||
for (uint8_t i = 0; i < s.nbits; ++i)
|
||||
Serial.print(s.b[i]);
|
||||
}
|
||||
}
|
||||
if (endWithNewline)
|
||||
Serial.println();
|
||||
}
|
||||
|
||||
void IR_DecoderRaw::packTraceEmitErrorFlash(const __FlashStringHelper *msg)
|
||||
{
|
||||
Serial.println();
|
||||
packTraceEmitRawBitsLine(false);
|
||||
Serial.print(F(" => "));
|
||||
Serial.println(msg);
|
||||
{
|
||||
uint16_t nb = i_dataBuffer / 8u;
|
||||
if (nb > dataByteSizeMax)
|
||||
nb = dataByteSizeMax;
|
||||
packTraceEmitHex(static_cast<uint8_t>(nb));
|
||||
}
|
||||
packTraceResetFrame();
|
||||
}
|
||||
|
||||
void IR_DecoderRaw::packTraceEmitEndOk(uint8_t packSize)
|
||||
{
|
||||
Serial.println();
|
||||
packTraceEmitRawBitsLine(false);
|
||||
Serial.print(F(" => OK: "));
|
||||
irPackTracePrintOkCommand(dataBuffer, packSize);
|
||||
Serial.println();
|
||||
packTraceEmitHex(packSize);
|
||||
packTraceResetFrame();
|
||||
}
|
||||
|
||||
void IR_DecoderRaw::packTraceEmitEndBadCrc(uint8_t packSize)
|
||||
{
|
||||
Serial.println();
|
||||
packTraceEmitRawBitsLine(false);
|
||||
Serial.println(F(" => ERROR: Wrong CRC"));
|
||||
packTraceEmitHex(packSize);
|
||||
packTraceResetFrame();
|
||||
}
|
||||
|
||||
void IR_DecoderRaw::packTraceOnTimeoutOrAbort(bool fromListenStart)
|
||||
{
|
||||
(void)fromListenStart;
|
||||
if (!packTraceOpen)
|
||||
return;
|
||||
const uint16_t expected = (i_dataBuffer >= 8) ? uint16_t(dataBuffer[0] & IR_MASK_MSG_INFO) : 0;
|
||||
uint16_t gotBytes = i_dataBuffer / 8;
|
||||
if (gotBytes > dataByteSizeMax)
|
||||
gotBytes = dataByteSizeMax;
|
||||
Serial.println();
|
||||
packTraceEmitRawBitsLine(false);
|
||||
Serial.print(F(" => ERROR: TIMEOUT, rx_data_size = "));
|
||||
Serial.print(expected);
|
||||
Serial.print(F(", but only "));
|
||||
Serial.print(gotBytes);
|
||||
Serial.println(F(" bytes received"));
|
||||
packTraceEmitHex(static_cast<uint8_t>(gotBytes));
|
||||
packTraceResetFrame();
|
||||
}
|
||||
|
||||
__attribute__((weak)) void irPackTracePrintOkCommand(const uint8_t *buf, uint8_t packSize)
|
||||
{
|
||||
(void)buf;
|
||||
(void)packSize;
|
||||
}
|
||||
|
||||
#endif // IRDEBUG_SERIAL_PACK
|
||||
|
||||
// IRDEBUG FUNC
|
||||
#ifdef IRDEBUG
|
||||
inline void IR_DecoderRaw::errPulse(uint8_t pin, uint8_t count)
|
||||
|
||||
@ -2,17 +2,19 @@
|
||||
#include "IR_config.h"
|
||||
#include "RingBuffer.h"
|
||||
|
||||
// #define IRDEBUG
|
||||
class Print;
|
||||
|
||||
#define IRDEBUG
|
||||
|
||||
#ifdef IRDEBUG
|
||||
#define wrHigh PA1 // Запись HIGH инициирована // green
|
||||
#define wrLow PA0 // Запись LOW инициирована // blue
|
||||
#define writeOp PA5 // Операция записи, 1 пульс для 0 и 2 для 1 // orange
|
||||
#define wrHigh 255 // Запись HIGH инициирована // green
|
||||
#define wrLow 255 // Запись LOW инициирована // blue
|
||||
#define writeOp 255 // Операция записи, 1 пульс для 0 и 2 для 1 // orange
|
||||
// Исправленные ошибки // purle
|
||||
// 1 пульс: fix
|
||||
#define errOut PA4
|
||||
#define up PA3
|
||||
#define down PA2
|
||||
#define errOut 255
|
||||
#define up 255
|
||||
#define down 255
|
||||
#endif
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
@ -31,9 +33,10 @@ class IR_DecoderRaw : virtual public IR_FOX
|
||||
friend IR_Encoder;
|
||||
|
||||
protected:
|
||||
PackInfo packInfo;
|
||||
IR_Encoder *encoder; // Указатель на парный передатчик
|
||||
bool availableRaw();
|
||||
PackInfo packInfo;
|
||||
uint8_t msgTypeReceive = 0;
|
||||
IR_Encoder *encoder; // Указатель на парный передатчик
|
||||
bool availableRaw();
|
||||
|
||||
public:
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
@ -48,10 +51,27 @@ public:
|
||||
|
||||
inline bool isOverflow() { return isBufferOverflow; }; // Буффер переполнился
|
||||
bool isSubOverflow();
|
||||
inline bool isReciving() { return isBufferOverflow; }; // Возвращает true, если происходит приём пакета
|
||||
volatile inline bool isReciving() { return isRecive; }; // Возвращает true, если происходит приём пакета
|
||||
|
||||
#if defined(IR_EDGE_TRACE)
|
||||
void edgeTraceClear();
|
||||
bool edgeTraceOverflow() const { return edgeTrace_overflow; }
|
||||
uint16_t edgeTracePendingCount() const;
|
||||
/** При непустом кольце: перевод строки + @IRF1v1: + hex; в tick() сброс на Serial автоматически. См. ref/IR_EDGE_TRACE_FORMAT.md */
|
||||
uint16_t edgeTraceFlushChunk(Print &out, uint16_t maxRec = 48);
|
||||
#endif
|
||||
|
||||
/// Кадр собран по длине из заголовка, но CRC не сошёлся — один раз можно прочитать копию сырых байтов.
|
||||
bool availableReject();
|
||||
uint8_t getRejectSize() const { return rejectPackSize; }
|
||||
const uint8_t* getRejectBuffer() const { return rejectBuffer; }
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
private:
|
||||
bool isRejectAvailable = false;
|
||||
uint8_t rejectPackSize = 0;
|
||||
uint8_t rejectBuffer[dataByteSizeMax]{};
|
||||
|
||||
ErrorsStruct errors;
|
||||
bool isAvailable = false;
|
||||
uint16_t packSize;
|
||||
@ -65,6 +85,8 @@ private:
|
||||
|
||||
uint16_t riseSyncTime = bitTime; // Подстраиваемое время бита в мкс
|
||||
|
||||
volatile uint32_t lastEdgeTime = 0; // время последнего фронта
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
volatile uint32_t currentSubBufferIndex; // Счетчик текущей позиции во вспомогательном буфере фронтов/спадов
|
||||
|
||||
@ -80,6 +102,20 @@ private:
|
||||
|
||||
RingBuffer<FrontStorage, subBufferSize> subBuffer;
|
||||
|
||||
#if defined(IR_EDGE_TRACE)
|
||||
struct IrEdgeTraceRec
|
||||
{
|
||||
uint32_t t_us;
|
||||
uint8_t level;
|
||||
uint8_t flags;
|
||||
};
|
||||
void edgeTracePush(uint32_t t_us, uint8_t level, uint8_t flags);
|
||||
IrEdgeTraceRec edgeTrace_buf[IR_EDGE_TRACE_CAPACITY]{};
|
||||
volatile uint16_t edgeTrace_w = 0;
|
||||
volatile uint16_t edgeTrace_r = 0;
|
||||
volatile bool edgeTrace_overflow = false;
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
uint8_t dataBuffer[dataByteSizeMax]{0}; // Буффер данных
|
||||
volatile uint32_t prevRise, prevPrevRise, prevFall, prevPrevFall; // Время предыдущих фронтов/спадов
|
||||
@ -100,7 +136,9 @@ private:
|
||||
int16_t bufBitPos = 0; // Позиция для записи бита в буффер
|
||||
|
||||
private:
|
||||
void listenStart(); // @brief Слушатель для работы isReciving()
|
||||
bool isReciveRaw;
|
||||
void listenStart();
|
||||
void checkTimeout(); //
|
||||
|
||||
/// @brief Проверка CRC. Проверяет len байт со значением crc, пришедшим в пакете
|
||||
/// @param len Длина в байтах проверяемых данных
|
||||
@ -116,8 +154,8 @@ private:
|
||||
uint8_t err_syncBit; // Счётчик ошибок синхронизации
|
||||
|
||||
/// @brief Запиь бита в буффер, а так же проверка битов синхранизации и их фильтрация
|
||||
/// @param Бит данных
|
||||
void writeToBuffer(bool);
|
||||
/// @param packTraceInvertFix если true — в IRDEBUG_SERIAL_PACK бит в трассе пишется как `0`/`1` (исправление по фронтам)
|
||||
void writeToBuffer(bool bit, bool packTraceInvertFix = false);
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void firstRX(); /// @brief Установка и сброс начальных значений и флагов в готовность к приёму данных
|
||||
@ -133,4 +171,30 @@ private:
|
||||
inline void errPulse(uint8_t pin, uint8_t count);
|
||||
inline void infoPulse(uint8_t pin, uint8_t count);
|
||||
#endif
|
||||
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
static constexpr uint16_t kPackTraceBufCap =
|
||||
uint16_t(dataByteSizeMax) * (uint16_t(bitPerByte) + uint16_t(syncBits)) + 48u;
|
||||
|
||||
void packTraceResetFrame();
|
||||
void packTracePushBit(bool bit);
|
||||
void packTracePushChar(char c);
|
||||
/** Помечает в packTraceBitBuf бит (после BRUTEFORCE_CHECK) обёрткой `0`/`1` по финальному значению в dataBuffer. */
|
||||
void packTraceWrapDataBitInBackticks(uint16_t byteIndex, uint8_t bitInByte);
|
||||
/** IR hex: все байты dataBuffer[0 .. byteCount-1] в hex. */
|
||||
void packTraceEmitHex(uint8_t byteCount) const;
|
||||
/** IR raw: биты и синхра; тройной пробел между блоками msg/from/to/data/CRC; первый байт 3+пробел+5. endWithNewline — перевод строки после сырой строки. */
|
||||
void packTraceEmitRawBitsLine(bool endWithNewline = true) const;
|
||||
void packTraceEmitErrorFlash(const __FlashStringHelper *msg);
|
||||
void packTraceEmitEndOk(uint8_t packSize);
|
||||
void packTraceEmitEndBadCrc(uint8_t packSize);
|
||||
void packTraceOnTimeoutOrAbort(bool fromListenStart);
|
||||
void packTraceForceEndSyncPhase();
|
||||
bool packTraceSoftReject() const;
|
||||
|
||||
bool packTraceOpen = false;
|
||||
bool packTraceHadWrongSync = false;
|
||||
char packTraceBitBuf[kPackTraceBufCap]{};
|
||||
uint16_t packTraceLen = 0;
|
||||
#endif
|
||||
};
|
||||
|
||||
368
IR_Encoder.cpp
368
IR_Encoder.cpp
@ -1,5 +1,6 @@
|
||||
#include "IR_Encoder.h"
|
||||
#include "IR_DecoderRaw.h"
|
||||
#include <string.h>
|
||||
|
||||
#define LoopOut 12
|
||||
#define ISR_Out 10
|
||||
@ -7,6 +8,7 @@
|
||||
|
||||
IR_Encoder *IR_Encoder::head = nullptr;
|
||||
IR_Encoder *IR_Encoder::last = nullptr;
|
||||
volatile bool IR_Encoder::carrierStopPending = false;
|
||||
|
||||
IR_Encoder::IR_Encoder(uint8_t pin, uint16_t addr, IR_DecoderRaw *decPair, bool autoHandle)
|
||||
{
|
||||
@ -38,20 +40,204 @@ IR_Encoder::IR_Encoder(uint8_t pin, uint16_t addr, IR_DecoderRaw *decPair, bool
|
||||
last->next = this;
|
||||
}
|
||||
last = this;
|
||||
|
||||
pinMode(pin, OUTPUT);
|
||||
}
|
||||
};
|
||||
|
||||
HardwareTimer* IR_Encoder::IR_Timer = nullptr;
|
||||
IR_Encoder::ExternalTxStartFn IR_Encoder::externalTxStartFn = nullptr;
|
||||
IR_Encoder::ExternalTxBusyFn IR_Encoder::externalTxBusyFn = nullptr;
|
||||
void *IR_Encoder::externalTxCtx = nullptr;
|
||||
|
||||
inline HardwareTimer* IR_Encoder::get_IR_Timer(){return IR_Encoder::IR_Timer;}
|
||||
|
||||
void IR_Encoder::carrierResume() {
|
||||
if (IR_Timer != nullptr)
|
||||
IR_Timer->resume();
|
||||
}
|
||||
|
||||
void IR_Encoder::carrierPauseIfIdle() {
|
||||
for (IR_Encoder *p = head; p != nullptr; p = p->next)
|
||||
if (p->isSending)
|
||||
return;
|
||||
if (IR_Timer != nullptr)
|
||||
IR_Timer->pause();
|
||||
}
|
||||
|
||||
void IR_Encoder::tick() {
|
||||
if (!carrierStopPending)
|
||||
return;
|
||||
carrierStopPending = false;
|
||||
carrierPauseIfIdle();
|
||||
}
|
||||
|
||||
void IR_Encoder::begin(HardwareTimer* timer, uint8_t channel, IRQn_Type IRQn, uint8_t priority, void(*isrCallback)()){
|
||||
IR_Timer = timer;
|
||||
if(IR_Timer == nullptr) return;
|
||||
IR_Timer->pause();
|
||||
IR_Timer->setOverflow(carrierFrec * 2, HERTZ_FORMAT);
|
||||
IR_Timer->attachInterrupt(channel, (isrCallback == nullptr ? IR_Encoder::isr : isrCallback));
|
||||
NVIC_SetPriority(IRQn, priority);
|
||||
IR_Timer->resume();
|
||||
IR_Timer->pause();
|
||||
}
|
||||
|
||||
void IR_Encoder::beginClockOnly(HardwareTimer *timer)
|
||||
{
|
||||
IR_Timer = timer;
|
||||
if (IR_Timer == nullptr)
|
||||
return;
|
||||
IR_Timer->pause();
|
||||
IR_Timer->setOverflow(carrierFrec * 2, HERTZ_FORMAT);
|
||||
IR_Timer->pause();
|
||||
}
|
||||
|
||||
void IR_Encoder::setExternalTxBackend(ExternalTxStartFn startFn, ExternalTxBusyFn busyFn, void *ctx)
|
||||
{
|
||||
externalTxStartFn = startFn;
|
||||
externalTxBusyFn = busyFn;
|
||||
externalTxCtx = ctx;
|
||||
}
|
||||
|
||||
void IR_Encoder::externalFinishSend()
|
||||
{
|
||||
if (!isSending)
|
||||
return;
|
||||
|
||||
// Force output low.
|
||||
if (port != nullptr) {
|
||||
port->BSRR = ((uint32_t)mask) << 16;
|
||||
}
|
||||
|
||||
isSending = false;
|
||||
setDecoder_isSending();
|
||||
}
|
||||
|
||||
size_t IR_Encoder::buildGateRuns(const uint8_t *packet, uint8_t len, IR_TxGateRun *outRuns, size_t maxRuns)
|
||||
{
|
||||
if (packet == nullptr || outRuns == nullptr || maxRuns == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
if (len == 0 || len > dataByteSizeMax)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Copy into fixed-size buffer to match original encoder behavior (safe reads past sendLen).
|
||||
uint8_t sendBufferLocal[dataByteSizeMax] = {0};
|
||||
memcpy(sendBufferLocal, packet, len);
|
||||
|
||||
uint8_t sendLenLocal = len;
|
||||
uint8_t toggleCounterLocal = preambToggle;
|
||||
uint8_t dataBitCounterLocal = bitPerByte - 1;
|
||||
uint8_t dataByteCounterLocal = 0;
|
||||
uint8_t preambFrontCounterLocal = preambPulse * 2 - 1;
|
||||
uint8_t dataSequenceCounterLocal = bitPerByte * 2;
|
||||
uint8_t syncSequenceCounterLocal = syncBits * 2;
|
||||
bool syncLastBitLocal = false;
|
||||
SignalPart signalLocal = preamb;
|
||||
bool stateLocal = HIGH;
|
||||
uint8_t *currentBitSequenceLocal = bitHigh;
|
||||
|
||||
size_t runCount = 0;
|
||||
|
||||
while (true)
|
||||
{
|
||||
const bool gate = stateLocal;
|
||||
const uint16_t runLenTicks = (uint16_t)toggleCounterLocal + 1U;
|
||||
|
||||
if (runCount > 0 && outRuns[runCount - 1].gate == gate)
|
||||
{
|
||||
outRuns[runCount - 1].lenTicks = (uint16_t)(outRuns[runCount - 1].lenTicks + runLenTicks);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (runCount >= maxRuns)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
outRuns[runCount].gate = gate;
|
||||
outRuns[runCount].lenTicks = runLenTicks;
|
||||
runCount++;
|
||||
}
|
||||
|
||||
// Advance state to the next run boundary (equivalent to ISR iteration when toggleCounter == 0).
|
||||
while (true)
|
||||
{
|
||||
switch (signalLocal)
|
||||
{
|
||||
case noSignal:
|
||||
return runCount;
|
||||
|
||||
case preamb:
|
||||
if (preambFrontCounterLocal)
|
||||
{
|
||||
preambFrontCounterLocal--;
|
||||
toggleCounterLocal = preambToggle;
|
||||
break;
|
||||
}
|
||||
// End of preamble.
|
||||
signalLocal = data;
|
||||
stateLocal = !LOW;
|
||||
continue;
|
||||
|
||||
case data:
|
||||
if (dataSequenceCounterLocal)
|
||||
{
|
||||
if (!(dataSequenceCounterLocal & 1U))
|
||||
{
|
||||
currentBitSequenceLocal = ((sendBufferLocal[dataByteCounterLocal] >> dataBitCounterLocal) & 1U) ? bitHigh : bitLow;
|
||||
dataBitCounterLocal--;
|
||||
}
|
||||
toggleCounterLocal = currentBitSequenceLocal[!stateLocal];
|
||||
dataSequenceCounterLocal--;
|
||||
break;
|
||||
}
|
||||
// End of data byte.
|
||||
syncLastBitLocal = ((sendBufferLocal[dataByteCounterLocal]) & 1U);
|
||||
dataByteCounterLocal++;
|
||||
dataBitCounterLocal = bitPerByte - 1;
|
||||
dataSequenceCounterLocal = bitPerByte * 2;
|
||||
signalLocal = sync;
|
||||
continue;
|
||||
|
||||
case sync:
|
||||
if (syncSequenceCounterLocal)
|
||||
{
|
||||
if (!(syncSequenceCounterLocal & 1U))
|
||||
{
|
||||
if (syncSequenceCounterLocal == 2)
|
||||
{
|
||||
currentBitSequenceLocal = ((sendBufferLocal[dataByteCounterLocal]) & 0b10000000) ? bitLow : bitHigh;
|
||||
}
|
||||
else
|
||||
{
|
||||
currentBitSequenceLocal = syncLastBitLocal ? bitLow : bitHigh;
|
||||
syncLastBitLocal = !syncLastBitLocal;
|
||||
}
|
||||
}
|
||||
toggleCounterLocal = currentBitSequenceLocal[!stateLocal];
|
||||
syncSequenceCounterLocal--;
|
||||
break;
|
||||
}
|
||||
// End of sync.
|
||||
signalLocal = data;
|
||||
syncSequenceCounterLocal = syncBits * 2;
|
||||
if (dataByteCounterLocal >= sendLenLocal)
|
||||
{
|
||||
signalLocal = noSignal;
|
||||
}
|
||||
continue;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
|
||||
stateLocal = !stateLocal;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -126,20 +312,21 @@ void IR_Encoder::setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count)
|
||||
|
||||
IR_Encoder::~IR_Encoder(){};
|
||||
|
||||
void IR_Encoder::sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept)
|
||||
IR_SendResult IR_Encoder::sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept)
|
||||
{
|
||||
sendData(addrTo, &dataByte, 1, needAccept);
|
||||
return sendData(addrTo, &dataByte, 1, needAccept);
|
||||
}
|
||||
|
||||
void IR_Encoder::sendData(uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept){
|
||||
sendDataFULL(id, addrTo, data, len, needAccept);
|
||||
IR_SendResult IR_Encoder::sendData(uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept){
|
||||
return sendDataFULL(id, addrTo, data, len, needAccept);
|
||||
}
|
||||
|
||||
void IR_Encoder::sendDataFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept)
|
||||
IR_SendResult IR_Encoder::sendDataFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept)
|
||||
{
|
||||
if (len > bytePerPack)
|
||||
{
|
||||
return;
|
||||
Serial.println("IR Pack to big");
|
||||
return IR_SendResult(false, 0);
|
||||
}
|
||||
constexpr uint8_t dataStart = msgBytes + addrBytes + addrBytes;
|
||||
memset(sendBuffer, 0x00, dataByteSizeMax);
|
||||
@ -168,6 +355,19 @@ void IR_Encoder::sendDataFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data,
|
||||
sendBuffer[packSize - crcBytes] = crc8(sendBuffer, 0, packSize - crcBytes, poly1) & 0xFF;
|
||||
sendBuffer[packSize - crcBytes + 1] = crc8(sendBuffer, 0, packSize - crcBytes + 1, poly2) & 0xFF;
|
||||
|
||||
//* вывод итогового буфера
|
||||
// Serial.print("IR SEND [len=");
|
||||
// Serial.print(packSize);
|
||||
// Serial.print("] : ");
|
||||
// for (uint8_t i = 0; i < packSize; i++)
|
||||
// {
|
||||
// if (sendBuffer[i] < 0x10)
|
||||
// Serial.print('0');
|
||||
// Serial.print(sendBuffer[i], HEX);
|
||||
// Serial.print(' ');
|
||||
// }
|
||||
// Serial.println();
|
||||
|
||||
// if (decPair != nullptr) {
|
||||
// decPair->isWaitingAccept = ((msgType >> 5) & IR_MASK_MSG_TYPE == IR_MSG_DATA_ACCEPT);
|
||||
// if (decPair->isWaitingAccept) {
|
||||
@ -177,9 +377,14 @@ void IR_Encoder::sendDataFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data,
|
||||
|
||||
// отправка
|
||||
rawSend(sendBuffer, packSize);
|
||||
|
||||
// Возвращаем результат отправки
|
||||
uint32_t sendTime = calculateSendTime(packSize);
|
||||
return IR_SendResult(true, sendTime);
|
||||
}
|
||||
|
||||
void IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte)
|
||||
|
||||
IR_SendResult IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte)
|
||||
{
|
||||
constexpr uint8_t packsize = msgBytes + addrBytes + 1U + crcBytes;
|
||||
memset(sendBuffer, 0x00, dataByteSizeMax);
|
||||
@ -200,9 +405,13 @@ void IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte)
|
||||
sendBuffer[5] = crc8(sendBuffer, 0, 5, poly2) & 0xFF;
|
||||
|
||||
rawSend(sendBuffer, packsize);
|
||||
|
||||
// Возвращаем результат отправки
|
||||
uint32_t sendTime = calculateSendTime(packsize);
|
||||
return IR_SendResult(true, sendTime);
|
||||
}
|
||||
|
||||
void IR_Encoder::sendRequest(uint16_t addrTo)
|
||||
IR_SendResult IR_Encoder::sendRequest(uint16_t addrTo)
|
||||
{
|
||||
constexpr uint8_t packsize = msgBytes + addrBytes + addrBytes + crcBytes;
|
||||
memset(sendBuffer, 0x00, dataByteSizeMax);
|
||||
@ -222,35 +431,39 @@ void IR_Encoder::sendRequest(uint16_t addrTo)
|
||||
sendBuffer[6] = crc8(sendBuffer, 0, 6, poly2) & 0xFF;
|
||||
|
||||
rawSend(sendBuffer, packsize);
|
||||
|
||||
// Возвращаем результат отправки
|
||||
uint32_t sendTime = calculateSendTime(packsize);
|
||||
return IR_SendResult(true, sendTime);
|
||||
}
|
||||
|
||||
void IR_Encoder::sendBack(uint8_t data)
|
||||
IR_SendResult IR_Encoder::sendBack(uint8_t data)
|
||||
{
|
||||
_sendBack(false, 0, &data, 1);
|
||||
return _sendBack(false, 0, &data, 1);
|
||||
}
|
||||
|
||||
void IR_Encoder::sendBack(uint8_t *data, uint8_t len)
|
||||
IR_SendResult IR_Encoder::sendBack(uint8_t *data, uint8_t len)
|
||||
{
|
||||
_sendBack(false, 0, data, len);
|
||||
return _sendBack(false, 0, data, len);
|
||||
}
|
||||
|
||||
void IR_Encoder::sendBackTo(uint16_t addrTo, uint8_t *data, uint8_t len)
|
||||
IR_SendResult IR_Encoder::sendBackTo(uint16_t addrTo, uint8_t *data, uint8_t len)
|
||||
{
|
||||
_sendBack(true, addrTo, data, len);
|
||||
return _sendBack(true, addrTo, data, len);
|
||||
}
|
||||
|
||||
void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len)
|
||||
IR_SendResult IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len)
|
||||
{
|
||||
if (len > bytePerPack)
|
||||
{
|
||||
return;
|
||||
return IR_SendResult(false, 0);
|
||||
}
|
||||
memset(sendBuffer, 0x00, dataByteSizeMax);
|
||||
uint8_t dataStart = msgBytes + addrBytes + (isAdressed ? addrBytes : 0);
|
||||
|
||||
uint8_t packSize = msgBytes + addrBytes + (isAdressed ? addrBytes : 0) + min(uint8_t(1), len) + crcBytes;
|
||||
uint8_t msgType =
|
||||
((isAdressed ? IR_MSG_BACK_TO : IR_MSG_BACK) << 5) | ((packSize) & (IR_MASK_MSG_INFO >> 1));
|
||||
((isAdressed ? IR_MSG_BACK_TO : IR_MSG_BACK) << 5) | ((packSize) & IR_MASK_MSG_INFO);
|
||||
|
||||
// формирование массива
|
||||
// msg_type
|
||||
@ -275,6 +488,10 @@ void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint
|
||||
|
||||
// отправка
|
||||
rawSend(sendBuffer, packSize);
|
||||
|
||||
// Возвращаем результат отправки
|
||||
uint32_t sendTime = calculateSendTime(packSize);
|
||||
return IR_SendResult(true, sendTime);
|
||||
}
|
||||
|
||||
void IR_Encoder::setDecoder_isSending()
|
||||
@ -299,6 +516,34 @@ void IR_Encoder::rawSend(uint8_t *ptr, uint8_t len)
|
||||
// TODO: Обработка повторной отправки
|
||||
return;
|
||||
}
|
||||
|
||||
// Проверка на переполнение буфера
|
||||
if (len > dataByteSizeMax)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (externalTxStartFn != nullptr)
|
||||
{
|
||||
if (externalTxBusyFn != nullptr && externalTxBusyFn(externalTxCtx))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Mark as sending and delegate actual signal output to external backend.
|
||||
setDecoder_isSending();
|
||||
sendLen = len;
|
||||
isSending = true;
|
||||
|
||||
const bool ok = externalTxStartFn(externalTxCtx, this, ptr, len);
|
||||
if (!ok)
|
||||
{
|
||||
isSending = false;
|
||||
setDecoder_isSending();
|
||||
}
|
||||
return;
|
||||
}
|
||||
IR_Encoder::carrierResume();
|
||||
// Serial.println("START");
|
||||
setDecoder_isSending();
|
||||
|
||||
@ -318,7 +563,6 @@ void IR_Encoder::rawSend(uint8_t *ptr, uint8_t len)
|
||||
state = HIGH;
|
||||
|
||||
currentBitSequence = bitHigh;
|
||||
isSending = true;
|
||||
// interrupts();
|
||||
}
|
||||
|
||||
@ -358,6 +602,7 @@ void IR_Encoder::_isr()
|
||||
isSending = false;
|
||||
// Serial.println("STOP");
|
||||
setDecoder_isSending();
|
||||
carrierStopPending = true;
|
||||
// Serial.println();
|
||||
return;
|
||||
break;
|
||||
@ -483,6 +728,91 @@ uint8_t IR_Encoder::bitLow[2] = {
|
||||
(bitPauseTakts / 2 + bitActiveTakts) * 2 - 1,
|
||||
(bitPauseTakts)-1};
|
||||
|
||||
uint32_t IR_Encoder::calculateSendTime(uint8_t packSize) const
|
||||
{
|
||||
// Расчет времени отправки пакета в миллисекундах
|
||||
|
||||
// Время преамбулы: preambPulse * 2 фронта * bitTakts тактов
|
||||
uint32_t preambTime = preambPulse * 2 * bitTakts;
|
||||
|
||||
// Время данных: количество бит * bitTakts тактов
|
||||
uint32_t dataTime = packSize * 8 * bitTakts;
|
||||
|
||||
// Время синхронизации: syncBits * 2 фронта * bitTakts тактов
|
||||
uint32_t syncTime = syncBits * 2 * bitTakts;
|
||||
|
||||
// Общее время в тактах
|
||||
uint32_t totalTakts = preambTime + dataTime + syncTime;
|
||||
|
||||
// Конвертируем в миллисекунды
|
||||
// carrierPeriod - период несущей в микросекундах
|
||||
// totalTakts * carrierPeriod / 1000 = время в миллисекундах
|
||||
uint32_t sendTimeMs = (totalTakts * carrierPeriod) / 1000;
|
||||
|
||||
return sendTimeMs;
|
||||
}
|
||||
|
||||
// Функции для тестирования времени отправки без фактической отправки
|
||||
|
||||
uint32_t IR_Encoder::testSendTime(uint16_t addrTo, uint8_t dataByte, bool needAccept) const
|
||||
{
|
||||
return testSendTime(addrTo, &dataByte, 1, needAccept);
|
||||
}
|
||||
|
||||
uint32_t IR_Encoder::testSendTime(uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept) const
|
||||
{
|
||||
return testSendTimeFULL(id, addrTo, data, len, needAccept);
|
||||
}
|
||||
|
||||
uint32_t IR_Encoder::testSendTimeFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept) const
|
||||
{
|
||||
if (len > bytePerPack)
|
||||
{
|
||||
return 0; // Возвращаем 0 для недопустимого размера
|
||||
}
|
||||
|
||||
uint8_t packSize = msgBytes + addrBytes + addrBytes + len + crcBytes;
|
||||
return calculateSendTime(packSize);
|
||||
}
|
||||
|
||||
uint32_t IR_Encoder::testSendAccept(uint16_t addrTo, uint8_t customByte) const
|
||||
{
|
||||
constexpr uint8_t packsize = msgBytes + addrBytes + 1U + crcBytes;
|
||||
return calculateSendTime(packsize);
|
||||
}
|
||||
|
||||
uint32_t IR_Encoder::testSendRequest(uint16_t addrTo) const
|
||||
{
|
||||
constexpr uint8_t packsize = msgBytes + addrBytes + addrBytes + crcBytes;
|
||||
return calculateSendTime(packsize);
|
||||
}
|
||||
|
||||
uint32_t IR_Encoder::testSendBack(uint8_t data) const
|
||||
{
|
||||
return testSendBack(false, 0, &data, 1);
|
||||
}
|
||||
|
||||
uint32_t IR_Encoder::testSendBack(uint8_t *data, uint8_t len) const
|
||||
{
|
||||
return testSendBack(false, 0, data, len);
|
||||
}
|
||||
|
||||
uint32_t IR_Encoder::testSendBackTo(uint16_t addrTo, uint8_t *data, uint8_t len) const
|
||||
{
|
||||
return testSendBack(true, addrTo, data, len);
|
||||
}
|
||||
|
||||
uint32_t IR_Encoder::testSendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len) const
|
||||
{
|
||||
if (len > bytePerPack)
|
||||
{
|
||||
return 0; // Возвращаем 0 для недопустимого размера
|
||||
}
|
||||
|
||||
uint8_t packSize = msgBytes + addrBytes + (isAdressed ? addrBytes : 0) + min(uint8_t(1), len) + crcBytes;
|
||||
return calculateSendTime(packSize);
|
||||
}
|
||||
|
||||
// uint8_t* IR_Encoder::bitHigh = new uint8_t[2]{
|
||||
// (bitPauseTakts) * 2 - 0,
|
||||
// (bitActiveTakts) * 2 - 0};
|
||||
|
||||
70
IR_Encoder.h
70
IR_Encoder.h
@ -3,6 +3,15 @@
|
||||
|
||||
// TODO: Отложенная передача после завершения приема
|
||||
|
||||
// Структура для возврата результата отправки
|
||||
struct IR_SendResult {
|
||||
bool success; // Флаг успешности отправки
|
||||
uint32_t sendTimeMs; // Время отправки пакета в миллисекундах
|
||||
|
||||
IR_SendResult(bool success = false, uint32_t sendTimeMs = 0)
|
||||
: success(success), sendTimeMs(sendTimeMs) {}
|
||||
};
|
||||
|
||||
class IR_DecoderRaw;
|
||||
class IR_Encoder : public IR_FOX
|
||||
{
|
||||
@ -12,6 +21,14 @@ class IR_Encoder : public IR_FOX
|
||||
IR_Encoder *next;
|
||||
public:
|
||||
static HardwareTimer* IR_Timer;
|
||||
|
||||
struct IR_TxGateRun {
|
||||
uint16_t lenTicks; // number of timer ticks at carrierFrec*2
|
||||
bool gate; // true: carrier enabled (output toggles), false: silent (output forced low)
|
||||
};
|
||||
|
||||
using ExternalTxBusyFn = bool (*)(void *ctx);
|
||||
using ExternalTxStartFn = bool (*)(void *ctx, IR_Encoder *enc, const uint8_t *packet, uint8_t len);
|
||||
private:
|
||||
// uint16_t id; /// @brief Адрес передатчика
|
||||
public:
|
||||
@ -22,7 +39,20 @@ public:
|
||||
IR_Encoder(uint8_t pin, uint16_t addr = 0, IR_DecoderRaw *decPair = nullptr, bool autoHandle = true);
|
||||
static void isr();
|
||||
static void begin(HardwareTimer* timer, uint8_t channel, IRQn_Type IRQn, uint8_t priority, void(*isrCallback)() = nullptr);
|
||||
/** Configure timer frequency for TX clock (carrierFrec*2) without attaching ISR. */
|
||||
static void beginClockOnly(HardwareTimer *timer);
|
||||
static HardwareTimer* get_IR_Timer();
|
||||
/** Call from main loop/tick: if ISR requested carrier stop, pause timer here (not in ISR). */
|
||||
static void tick();
|
||||
|
||||
/** Optional: register external TX backend (e.g. DMA driver). */
|
||||
static void setExternalTxBackend(ExternalTxStartFn startFn, ExternalTxBusyFn busyFn, void *ctx);
|
||||
|
||||
/** Called by external TX backend on actual end of transmission. */
|
||||
void externalFinishSend();
|
||||
|
||||
/** Build RLE runs of carrier gate for a packet (no HW access). */
|
||||
static size_t buildGateRuns(const uint8_t *packet, uint8_t len, IR_TxGateRun *outRuns, size_t maxRuns);
|
||||
|
||||
void enable();
|
||||
void disable();
|
||||
@ -30,17 +60,29 @@ public:
|
||||
void setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count);
|
||||
void rawSend(uint8_t *ptr, uint8_t len);
|
||||
|
||||
void sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept = false);
|
||||
void sendData(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false);
|
||||
void sendDataFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false);
|
||||
IR_SendResult sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept = false);
|
||||
IR_SendResult sendData(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false);
|
||||
IR_SendResult sendDataFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false);
|
||||
|
||||
|
||||
void sendAccept(uint16_t addrTo, uint8_t customByte = 0);
|
||||
void sendRequest(uint16_t addrTo);
|
||||
IR_SendResult sendAccept(uint16_t addrTo, uint8_t customByte = 0);
|
||||
IR_SendResult sendRequest(uint16_t addrTo);
|
||||
|
||||
void sendBack(uint8_t data);
|
||||
void sendBack(uint8_t *data = nullptr, uint8_t len = 0);
|
||||
void sendBackTo(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0);
|
||||
IR_SendResult sendBack(uint8_t data);
|
||||
IR_SendResult sendBack(uint8_t *data = nullptr, uint8_t len = 0);
|
||||
IR_SendResult sendBackTo(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0);
|
||||
|
||||
// Функция для тестирования времени отправки без фактической отправки
|
||||
uint32_t testSendTime(uint16_t addrTo, uint8_t dataByte, bool needAccept = false) const;
|
||||
uint32_t testSendTime(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false) const;
|
||||
uint32_t testSendTimeFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false) const;
|
||||
uint32_t testSendAccept(uint16_t addrTo, uint8_t customByte = 0) const;
|
||||
uint32_t testSendRequest(uint16_t addrTo) const;
|
||||
uint32_t testSendBack(uint8_t data) const;
|
||||
uint32_t testSendBack(uint8_t *data = nullptr, uint8_t len = 0) const;
|
||||
uint32_t testSendBackTo(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0) const;
|
||||
|
||||
inline bool isBusy() const { return isSending;}
|
||||
|
||||
|
||||
~IR_Encoder();
|
||||
@ -48,11 +90,20 @@ public:
|
||||
|
||||
void _isr();
|
||||
private:
|
||||
void _sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len);
|
||||
static volatile bool carrierStopPending;
|
||||
static void carrierResume();
|
||||
static void carrierPauseIfIdle();
|
||||
|
||||
static ExternalTxStartFn externalTxStartFn;
|
||||
static ExternalTxBusyFn externalTxBusyFn;
|
||||
static void *externalTxCtx;
|
||||
IR_SendResult _sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len);
|
||||
|
||||
void setDecoder_isSending();
|
||||
void sendByte(uint8_t byte, bool *prev, bool LOW_FIRST);
|
||||
void addSync(bool *prev, bool *next);
|
||||
uint32_t calculateSendTime(uint8_t packSize) const;
|
||||
uint32_t testSendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len) const;
|
||||
void send_HIGH(bool = 1);
|
||||
void send_LOW();
|
||||
void send_EMPTY(uint8_t count);
|
||||
@ -95,4 +146,3 @@ private:
|
||||
uint8_t *currentBitSequence = bitLow;
|
||||
volatile SignalPart signal;
|
||||
};
|
||||
|
||||
|
||||
55
IR_config.h
55
IR_config.h
@ -2,6 +2,32 @@
|
||||
#include <Arduino.h>
|
||||
#include <list>
|
||||
// #define IRDEBUG_INFO
|
||||
|
||||
/** Число потоков DMA-TX задаётся шаблоном: IrDmaTxStm32<2>, см. IrDmaTxStm32.h и irproto::kDefaultDmaTxMaxStreams. */
|
||||
namespace irproto {
|
||||
constexpr size_t kDefaultDmaTxMaxStreams = 4U;
|
||||
}
|
||||
|
||||
// Пошаговый разбор кадра на Serial (по умолчанию выключено). Пульсы IRDEBUG на пинах не меняют.
|
||||
// #define IRDEBUG_SERIAL_PACK
|
||||
// Не обрывать приём сразу при накопленной sync-ошибке — «дописывать» до таймаута (только вместе с IRDEBUG_SERIAL_PACK).
|
||||
// #define IRDEBUG_SERIAL_SOFT_REJECT
|
||||
|
||||
// Журнал фронтов ИК в ISR; сброс строк @IRF1v1: в IR_DecoderRaw::tick(). См. ref/IR_EDGE_TRACE_FORMAT.md
|
||||
// Расход RAM ≈ IR_EDGE_TRACE_CAPACITY * 6 байт на декодер. Выключить — закомментировать:
|
||||
// #define IR_EDGE_TRACE
|
||||
#if defined(IR_EDGE_TRACE)
|
||||
#ifndef IR_EDGE_TRACE_CAPACITY
|
||||
#define IR_EDGE_TRACE_CAPACITY 512u
|
||||
#endif
|
||||
/** Запись в edgeTrace: фронт не передан в decode (isPairSending). */
|
||||
#define IR_EDGE_TRACE_F_SKIP_DECODE 0x01u
|
||||
#endif
|
||||
// Пример в скетче: void irPackTracePrintOkCommand(const uint8_t* b, uint8_t n) { Serial.print(F("CarCmd::...")); }
|
||||
#if defined(IRDEBUG_SERIAL_PACK)
|
||||
/** Слабая реализация в IR_DecoderRaw.cpp; в скетче определите свою для вывода вроде CarCmd::... */
|
||||
void irPackTracePrintOkCommand(const uint8_t *buf, uint8_t packSize);
|
||||
#endif
|
||||
/*//////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
Для работы в паре положить декодер в энкодер
|
||||
@ -48,12 +74,13 @@
|
||||
\____________________________________________________________________________________________________/
|
||||
|
||||
msg type:
|
||||
// __________
|
||||
// | 01234567 |
|
||||
// ----------
|
||||
// | xxx..... | = тип сообщения
|
||||
// | ...xxxxx | = длина (максимум 31 бита)
|
||||
// ---------- */
|
||||
// __________
|
||||
// | 01234567 |
|
||||
// ----------
|
||||
// | xxx..... | = тип сообщения (биты 7..5)
|
||||
// | ...xxxxx | = полная длина кадра в байтах (5 бит, 0..31, IR_MASK_MSG_INFO), не «31 бит» и не отдельный лимит «24 байта»
|
||||
// Полезная нагрузка в data pack: до bytePerPack байт (см. #define bytePerPack).
|
||||
// ---------- */
|
||||
#define IR_MSG_BACK 0U // | 000...... | = Задний сигнал машинки
|
||||
#define IR_MSG_ACCEPT 1U // | 001..... | = подтверждение
|
||||
#define IR_MSG_REQUEST 2U // | 010..... | = запрос
|
||||
@ -81,12 +108,13 @@ msg type:
|
||||
|
||||
|
||||
/`````````````````````` Задний сигнал машинки без адресации ``````````````````````\
|
||||
// Первый байт: (IR_MSG_BACK<<5) | (packSize & IR_MASK_MSG_INFO) — как у data pack (тип + длина 0..31).
|
||||
|
||||
{``````````} [````````````````````````] [````````````````````````] [``````````````]
|
||||
{ msg type } [ addr_from uint16_t ] [====== data bytes ======] [ CRC Bytes ]
|
||||
{..........} [........................] [........................] [..............]
|
||||
|
||||
{ 0000xxxx } [addr_from_H][addr_from_L] [data_H][data_n..][data_L] [ crc1 ][ crc2 ]
|
||||
{ xxx..|..xxxxx } [addr_from_H][addr_from_L] [data_H][data_n..][data_L] [ crc1 ][ crc2 ]
|
||||
| 0 1 2 3 | |
|
||||
\_____________________________________________________________________/ |
|
||||
| |
|
||||
@ -95,12 +123,13 @@ msg type:
|
||||
|
||||
|
||||
/```````````````````````````````````` Задний сигнал машинки с адресацией ````````````````````````````````````\
|
||||
|
||||
// Первый байт: (IR_MSG_BACK_TO<<5) | (packSize & IR_MASK_MSG_INFO) — IR_MSG_BACK_TO в битах 7..5, длина 0..31.
|
||||
|
||||
{``````````} [````````````````````````] [````````````````````````] [````````````````````````] [``````````````]
|
||||
{ msg type } [ addr_from uint16_t ] [ addr_to uint16_t ] [====== data bytes ======] [ CRC Bytes ]
|
||||
{..........} [........................] [........................] [........................] [..............]
|
||||
|
||||
{ 0001xxxx } [addr_from_H][addr_from_L] [addr_from_H][addr_from_L] [data_H][data_n..][data_L] [ crc1 ][ crc2 ]
|
||||
|
||||
{ xxx..|..xxxxx } [addr_from_H][addr_from_L] [addr_to_H][addr_to_L] [data_H][data_n..][data_L] [ crc1 ][ crc2 ]
|
||||
| 0 1 2 3 4 5 | |
|
||||
\________________________________________________________________________________________________/ |
|
||||
| |
|
||||
@ -116,13 +145,13 @@ msg type:
|
||||
typedef uint16_t crc_t;
|
||||
|
||||
// #define BRUTEFORCE_CHECK // Перепроверяет пакет на 1 битные ошибки //TODO: зависает
|
||||
#define bytePerPack 16 // колличество байтов в пакете
|
||||
#define bytePerPack (31) // колличество байтов в пакете
|
||||
#ifndef freeFrec
|
||||
#define freeFrec false
|
||||
#endif
|
||||
|
||||
#ifndef subBufferSize
|
||||
#define subBufferSize 50 // Буфер для складирования фронтов, пока их не обработают (передатчик)
|
||||
#define subBufferSize 250 // Буфер для складирования фронтов, пока их не обработают (передатчик)
|
||||
#endif
|
||||
|
||||
#define preambPulse 3
|
||||
@ -201,6 +230,8 @@ public:
|
||||
static void checkAddressRuleApply(uint16_t address, uint16_t id, bool &flag);
|
||||
void setPin(uint8_t pin);
|
||||
inline uint8_t getPin() { return pin; };
|
||||
inline GPIO_TypeDef *getPort() const { return port; }
|
||||
inline uint16_t getPinMask() const { return mask; }
|
||||
|
||||
protected:
|
||||
uint16_t id;
|
||||
|
||||
386
IrDmaTxStm32.h
Normal file
386
IrDmaTxStm32.h
Normal file
@ -0,0 +1,386 @@
|
||||
#pragma once
|
||||
|
||||
#include "IR_Encoder.h"
|
||||
|
||||
#if defined(ARDUINO_ARCH_STM32) && defined(STM32G4xx)
|
||||
|
||||
#include <Arduino.h>
|
||||
#include <HardwareTimer.h>
|
||||
|
||||
#if defined(__GNUC__)
|
||||
#define IR_DMA_TX_HOT __attribute__((always_inline)) inline
|
||||
#else
|
||||
#define IR_DMA_TX_HOT inline
|
||||
#endif
|
||||
|
||||
#include "stm32g4xx_hal.h"
|
||||
|
||||
/**
|
||||
* STM32G4: ИК TX через DMA в GPIO BSRR, такт от TIM UPDATE (carrierFrec×2).
|
||||
*
|
||||
* Число слотов потоков — параметр шаблона (без макросов), например IrDmaTxStm32<2>.
|
||||
* По умолчанию: IrDmaTxStm32<> ≡ irproto::kDefaultDmaTxMaxStreams (см. IR_config.h).
|
||||
*
|
||||
* Контракт: ref/IR_DMA_TX_backend.md
|
||||
*/
|
||||
template<size_t MaxStreams = irproto::kDefaultDmaTxMaxStreams>
|
||||
class IrDmaTxStm32 {
|
||||
static_assert(MaxStreams >= 1U, "IrDmaTxStm32: MaxStreams >= 1");
|
||||
|
||||
public:
|
||||
struct StreamCfg {
|
||||
DMA_Channel_TypeDef* instance = nullptr;
|
||||
IRQn_Type irq = IRQn_Type(0);
|
||||
uint32_t dmamuxRequest = 0;
|
||||
IR_Encoder* enc = nullptr;
|
||||
|
||||
uint32_t* dmaWords = nullptr;
|
||||
uint16_t dmaWordCount = 0;
|
||||
|
||||
IR_Encoder::IR_TxGateRun* gateRuns = nullptr;
|
||||
size_t maxGateRuns = 0;
|
||||
};
|
||||
|
||||
struct Config {
|
||||
HardwareTimer* timer = nullptr;
|
||||
uint8_t streamCount = 0;
|
||||
StreamCfg streams[MaxStreams];
|
||||
};
|
||||
|
||||
bool begin(const Config& cfg) {
|
||||
cfg_ = cfg;
|
||||
streamCount_ = cfg.streamCount;
|
||||
|
||||
if (cfg_.timer == nullptr || streamCount_ == 0) return false;
|
||||
if (streamCount_ > MaxStreams) return false;
|
||||
|
||||
htim_ = cfg_.timer->getHandle();
|
||||
if (htim_ == nullptr) return false;
|
||||
|
||||
for (uint8_t i = 0; i < streamCount_; i++) {
|
||||
const StreamCfg& sc = cfg_.streams[i];
|
||||
if (sc.enc == nullptr || sc.instance == nullptr) return false;
|
||||
if (sc.dmaWords == nullptr || sc.dmaWordCount < 2U) return false;
|
||||
if ((sc.dmaWordCount & 1U) != 0U) return false;
|
||||
if (sc.gateRuns == nullptr || sc.maxGateRuns == 0U) return false;
|
||||
}
|
||||
|
||||
__HAL_RCC_DMA1_CLK_ENABLE();
|
||||
__HAL_RCC_DMAMUX1_CLK_ENABLE();
|
||||
|
||||
for (uint8_t i = 0; i < streamCount_; i++) {
|
||||
const StreamCfg& sc = cfg_.streams[i];
|
||||
if (!initStream(streams_[i], sc)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
s_instance = this;
|
||||
activeCount_ = 0;
|
||||
|
||||
for (uint8_t i = 0; i < streamCount_; i++) {
|
||||
HAL_NVIC_EnableIRQ(streams_[i].dmaIrq);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static IrDmaTxStm32<MaxStreams>* instance() {
|
||||
return s_instance;
|
||||
}
|
||||
|
||||
bool busy() const {
|
||||
if (streamCount_ == 0) return false;
|
||||
for (uint8_t i = 0; i < streamCount_; i++) {
|
||||
if (!streams_[i].active) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool start(IR_Encoder* enc, const uint8_t* packet, uint8_t len) {
|
||||
if (enc == nullptr) return false;
|
||||
for (uint8_t i = 0; i < streamCount_; i++) {
|
||||
if (streams_[i].enc == enc) {
|
||||
return startStream(streams_[i], packet, len);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void irqForStream(size_t streamIndex) {
|
||||
if (streamIndex >= streamCount_) return;
|
||||
HAL_DMA_IRQHandler(&streams_[streamIndex].hdma);
|
||||
}
|
||||
|
||||
DMA_HandleTypeDef* dmaHandle(size_t streamIndex) {
|
||||
if (streamIndex >= streamCount_) return nullptr;
|
||||
return &streams_[streamIndex].hdma;
|
||||
}
|
||||
|
||||
private:
|
||||
struct TxStream {
|
||||
DMA_HandleTypeDef hdma{};
|
||||
DMA_Channel_TypeDef* dmaInstance = nullptr;
|
||||
IRQn_Type dmaIrq = IRQn_Type(0);
|
||||
uint32_t dmamuxRequest = 0;
|
||||
|
||||
IR_Encoder* enc = nullptr;
|
||||
GPIO_TypeDef* port = nullptr;
|
||||
uint16_t mask = 0;
|
||||
uint32_t setWord = 0;
|
||||
uint32_t resetWord = 0;
|
||||
|
||||
uint32_t* dmaBuf = nullptr;
|
||||
uint16_t bufLen = 0;
|
||||
uint16_t halfLen = 0;
|
||||
|
||||
IR_Encoder::IR_TxGateRun* runs = nullptr;
|
||||
size_t maxRuns = 0;
|
||||
|
||||
size_t runCount = 0;
|
||||
size_t runIndex = 0;
|
||||
uint16_t ticksLeftInRun = 0;
|
||||
bool carrierPhase = false;
|
||||
|
||||
uint32_t totalTicks = 0;
|
||||
volatile uint32_t ticksOutput = 0;
|
||||
|
||||
bool active = false;
|
||||
|
||||
void resetWave() {
|
||||
runIndex = 0;
|
||||
carrierPhase = false;
|
||||
ticksOutput = 0;
|
||||
totalTicks = 0;
|
||||
runCount = 0;
|
||||
ticksLeftInRun = 0;
|
||||
}
|
||||
|
||||
IR_DMA_TX_HOT uint32_t nextWord() {
|
||||
if (runIndex >= runCount) {
|
||||
return resetWord;
|
||||
}
|
||||
const bool gate = runs[runIndex].gate;
|
||||
if (!gate) {
|
||||
carrierPhase = false;
|
||||
} else {
|
||||
carrierPhase = !carrierPhase;
|
||||
}
|
||||
const uint32_t out = (gate && carrierPhase) ? setWord : resetWord;
|
||||
|
||||
if (ticksLeftInRun > 0) {
|
||||
ticksLeftInRun--;
|
||||
}
|
||||
if (ticksLeftInRun == 0) {
|
||||
runIndex++;
|
||||
if (runIndex < runCount) {
|
||||
ticksLeftInRun = runs[runIndex].lenTicks;
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
IR_DMA_TX_HOT void fill(uint32_t* dst, uint16_t count) {
|
||||
if (dst == nullptr || count == 0) {
|
||||
return;
|
||||
}
|
||||
do {
|
||||
*dst++ = nextWord();
|
||||
} while (--count != 0);
|
||||
}
|
||||
|
||||
void onHalf() {
|
||||
ticksOutput += halfLen;
|
||||
fill(&dmaBuf[0], halfLen);
|
||||
}
|
||||
|
||||
void onComplete() {
|
||||
ticksOutput += halfLen;
|
||||
fill(&dmaBuf[halfLen], halfLen);
|
||||
}
|
||||
|
||||
void onError() {}
|
||||
};
|
||||
|
||||
static IrDmaTxStm32<MaxStreams>* s_instance;
|
||||
|
||||
Config cfg_{};
|
||||
TIM_HandleTypeDef* htim_ = nullptr;
|
||||
|
||||
TxStream streams_[MaxStreams]{};
|
||||
uint8_t streamCount_ = 0;
|
||||
|
||||
volatile uint8_t activeCount_ = 0;
|
||||
|
||||
static uint32_t u32ptr(const volatile void* p) {
|
||||
return (uint32_t)(uintptr_t)p;
|
||||
}
|
||||
|
||||
void startTimerIfNeeded() {
|
||||
if (htim_ == nullptr) return;
|
||||
if (activeCount_ != 1) return;
|
||||
|
||||
__HAL_TIM_DISABLE_DMA(htim_, TIM_DMA_UPDATE);
|
||||
__HAL_TIM_CLEAR_FLAG(htim_, TIM_FLAG_UPDATE);
|
||||
__HAL_TIM_SET_COUNTER(htim_, 0);
|
||||
__HAL_TIM_ENABLE_DMA(htim_, TIM_DMA_UPDATE);
|
||||
HAL_TIM_Base_Start(htim_);
|
||||
}
|
||||
|
||||
void stopTimerIfIdle() {
|
||||
if (htim_ == nullptr) return;
|
||||
if (activeCount_ != 0) return;
|
||||
|
||||
__HAL_TIM_DISABLE_DMA(htim_, TIM_DMA_UPDATE);
|
||||
HAL_TIM_Base_Stop(htim_);
|
||||
}
|
||||
|
||||
static TxStream* streamFromDma(DMA_HandleTypeDef* hdma) {
|
||||
if (s_instance == nullptr || hdma == nullptr) return nullptr;
|
||||
for (uint8_t i = 0; i < s_instance->streamCount_; i++) {
|
||||
if (hdma == &s_instance->streams_[i].hdma) {
|
||||
return &s_instance->streams_[i];
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static void dmaHalfCpltCb(DMA_HandleTypeDef* hdma) {
|
||||
auto* s = streamFromDma(hdma);
|
||||
if (s == nullptr || !s->active) return;
|
||||
s->onHalf();
|
||||
if (s_instance != nullptr && s->ticksOutput >= s->totalTicks) {
|
||||
s_instance->stopStream(*s);
|
||||
}
|
||||
}
|
||||
|
||||
static void dmaCpltCb(DMA_HandleTypeDef* hdma) {
|
||||
auto* s = streamFromDma(hdma);
|
||||
if (s == nullptr || !s->active) return;
|
||||
s->onComplete();
|
||||
if (s_instance != nullptr && s->ticksOutput >= s->totalTicks) {
|
||||
s_instance->stopStream(*s);
|
||||
}
|
||||
}
|
||||
|
||||
static void dmaErrorCb(DMA_HandleTypeDef* hdma) {
|
||||
auto* s = streamFromDma(hdma);
|
||||
if (s == nullptr) return;
|
||||
s->onError();
|
||||
if (s_instance != nullptr) {
|
||||
s_instance->stopStream(*s);
|
||||
}
|
||||
}
|
||||
|
||||
bool initStream(TxStream& s, const StreamCfg& chCfg) {
|
||||
s.enc = chCfg.enc;
|
||||
s.dmaInstance = chCfg.instance;
|
||||
s.dmaIrq = chCfg.irq;
|
||||
s.dmamuxRequest = chCfg.dmamuxRequest;
|
||||
|
||||
s.dmaBuf = chCfg.dmaWords;
|
||||
s.bufLen = chCfg.dmaWordCount;
|
||||
s.halfLen = (uint16_t)(chCfg.dmaWordCount / 2U);
|
||||
s.runs = chCfg.gateRuns;
|
||||
s.maxRuns = chCfg.maxGateRuns;
|
||||
|
||||
s.port = (s.enc != nullptr) ? s.enc->getPort() : nullptr;
|
||||
s.mask = (s.enc != nullptr) ? s.enc->getPinMask() : 0;
|
||||
s.setWord = (uint32_t)s.mask;
|
||||
s.resetWord = ((uint32_t)s.mask) << 16;
|
||||
|
||||
s.resetWave();
|
||||
|
||||
s.hdma.Instance = s.dmaInstance;
|
||||
s.hdma.Init.Request = s.dmamuxRequest;
|
||||
s.hdma.Init.Direction = DMA_MEMORY_TO_PERIPH;
|
||||
s.hdma.Init.PeriphInc = DMA_PINC_DISABLE;
|
||||
s.hdma.Init.MemInc = DMA_MINC_ENABLE;
|
||||
s.hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
|
||||
s.hdma.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
|
||||
s.hdma.Init.Mode = DMA_CIRCULAR;
|
||||
s.hdma.Init.Priority = DMA_PRIORITY_HIGH;
|
||||
|
||||
HAL_DMA_DeInit(&s.hdma);
|
||||
if (HAL_DMA_Init(&s.hdma) != HAL_OK) {
|
||||
return false;
|
||||
}
|
||||
|
||||
s.hdma.XferHalfCpltCallback = dmaHalfCpltCb;
|
||||
s.hdma.XferCpltCallback = dmaCpltCb;
|
||||
s.hdma.XferErrorCallback = dmaErrorCb;
|
||||
s.hdma.XferAbortCallback = nullptr;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool startStream(TxStream& s, const uint8_t* packet, uint8_t len) {
|
||||
if (s.enc == nullptr || s.port == nullptr || s.mask == 0) return false;
|
||||
if (s.active) return false;
|
||||
if (s.dmaBuf == nullptr || s.bufLen < 2 || s.halfLen == 0) return false;
|
||||
if (s.runs == nullptr || s.maxRuns == 0) return false;
|
||||
|
||||
s.resetWave();
|
||||
|
||||
s.runCount = IR_Encoder::buildGateRuns(packet, len, s.runs, s.maxRuns);
|
||||
if (s.runCount == 0) return false;
|
||||
|
||||
uint32_t total = 0;
|
||||
for (size_t i = 0; i < s.runCount; i++) total += s.runs[i].lenTicks;
|
||||
s.totalTicks = total;
|
||||
|
||||
s.runIndex = 0;
|
||||
s.ticksLeftInRun = s.runs[0].lenTicks;
|
||||
s.carrierPhase = false;
|
||||
|
||||
s.fill(&s.dmaBuf[0], s.bufLen);
|
||||
|
||||
s.port->BSRR = s.resetWord;
|
||||
|
||||
const uint32_t dst = u32ptr(&s.port->BSRR);
|
||||
if (HAL_DMA_Start_IT(&s.hdma, (uint32_t)(uintptr_t)s.dmaBuf, dst, s.bufLen) != HAL_OK) {
|
||||
return false;
|
||||
}
|
||||
|
||||
s.active = true;
|
||||
activeCount_++;
|
||||
startTimerIfNeeded();
|
||||
return true;
|
||||
}
|
||||
|
||||
void stopStream(TxStream& s) {
|
||||
if (!s.active) return;
|
||||
|
||||
s.active = false;
|
||||
HAL_DMA_Abort_IT(&s.hdma);
|
||||
|
||||
if (s.port != nullptr) {
|
||||
s.port->BSRR = s.resetWord;
|
||||
}
|
||||
|
||||
if (s.enc != nullptr) {
|
||||
s.enc->externalFinishSend();
|
||||
}
|
||||
|
||||
if (activeCount_ > 0) activeCount_--;
|
||||
stopTimerIfIdle();
|
||||
}
|
||||
};
|
||||
|
||||
template<size_t MaxStreams>
|
||||
IrDmaTxStm32<MaxStreams>* IrDmaTxStm32<MaxStreams>::s_instance = nullptr;
|
||||
|
||||
inline void IrDmaTxStm32_onDmaHandle(DMA_HandleTypeDef* hdma) {
|
||||
HAL_DMA_IRQHandler(hdma);
|
||||
}
|
||||
|
||||
#elif defined(ARDUINO_ARCH_STM32)
|
||||
|
||||
#error "IrDmaTxStm32: добавьте ветку HAL для вашей серии STM32 (сейчас только STM32G4xx)."
|
||||
|
||||
#else
|
||||
|
||||
template<size_t MaxStreams = irproto::kDefaultDmaTxMaxStreams>
|
||||
class IrDmaTxStm32 {};
|
||||
|
||||
#endif
|
||||
@ -43,6 +43,8 @@ namespace PacketTypes
|
||||
inline uint8_t getErrorOther() { return packInfo->err.other; };
|
||||
inline uint16_t getTunerTime() { return packInfo->rTime; };
|
||||
inline uint8_t *getDataRawPtr() { return packInfo->buffer; };
|
||||
/** Полный размер кадра в байтах (как packInfo.packSize); доступен для gotRaw (BasePack). */
|
||||
inline uint8_t getDataRawSize() { return _getDataRawSize(this); };
|
||||
};
|
||||
|
||||
class Data : public BasePack
|
||||
@ -61,7 +63,6 @@ namespace PacketTypes
|
||||
|
||||
inline uint8_t getDataSize() { return _getDataSize(this); };
|
||||
inline uint8_t *getDataPrt() { return _getDataPrt(this); };
|
||||
inline uint8_t getDataRawSize() { return _getDataRawSize(this); };
|
||||
|
||||
private:
|
||||
bool checkAddress() override;
|
||||
@ -83,7 +84,6 @@ namespace PacketTypes
|
||||
|
||||
inline uint8_t getDataSize() { return _getDataSize(this); };
|
||||
inline uint8_t *getDataPrt() { return _getDataPrt(this); };
|
||||
inline uint8_t getDataRawSize() { return _getDataRawSize(this); };
|
||||
|
||||
private:
|
||||
bool checkAddress() override;
|
||||
|
||||
174
ir_protocol_gate_runs_sim.py
Normal file
174
ir_protocol_gate_runs_sim.py
Normal file
@ -0,0 +1,174 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Симуляция логики IR_Encoder::buildGateRuns (IR-protocol) и утилиты CRC8.
|
||||
Запуск из корня репозитория: python docs/scripts/ir_protocol_gate_runs_sim.py
|
||||
Или: python ir_protocol_gate_runs_sim.py из каталога scripts/
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
|
||||
# --- IR_config.h (фрагмент) ---
|
||||
bitPauseTakts = 12
|
||||
bitActiveTakts = 25
|
||||
preambPulse = 3
|
||||
syncBits = 3
|
||||
bitPerByte = 8
|
||||
preambToggle = ((bitPauseTakts * 2 + bitActiveTakts) * 2 - 1)
|
||||
bitHigh = [(bitPauseTakts) * 2 - 1, (bitActiveTakts) * 2 - 1]
|
||||
bitLow = [(bitPauseTakts // 2 + bitActiveTakts) * 2 - 1, (bitPauseTakts) - 1]
|
||||
|
||||
preamb, data, sync, noSignal = 0, 1, 2, 3
|
||||
HIGH = True
|
||||
|
||||
|
||||
def crc8(data: bytes, start: int, end: int, poly: int) -> int:
|
||||
"""Как IR_FOX::crc8 в IR_config.cpp: [start, end)."""
|
||||
crc = 0xFF
|
||||
for i in range(start, end):
|
||||
crc ^= data[i]
|
||||
for _ in range(8):
|
||||
if (crc & 0x80) != 0:
|
||||
crc = ((crc << 1) ^ poly) & 0xFF
|
||||
else:
|
||||
crc = (crc << 1) & 0xFF
|
||||
return crc
|
||||
|
||||
|
||||
def crc_pair_over_wire(packet: bytes) -> tuple[int, int]:
|
||||
"""Два байта CRC как в IR_Encoder::sendDataFULL (poly1 старший, poly2 младший)."""
|
||||
ps = len(packet)
|
||||
if ps < 2:
|
||||
return 0, 0
|
||||
b1 = crc8(packet, 0, ps - 2, 0x31) & 0xFF
|
||||
b2 = crc8(packet, 0, ps - 1, 0x8C) & 0xFF
|
||||
return b1, b2
|
||||
|
||||
|
||||
# Как dataByteSizeMax в IR_config.h (msg+addr+addr+bytePerPack+crc)
|
||||
DATA_BYTE_SIZE_MAX = 1 + 2 + 2 + 31 + 2
|
||||
|
||||
|
||||
def build_gate_runs(packet: bytes):
|
||||
"""
|
||||
Повторяет IR_Encoder::buildGateRuns: список (gate: bool, lenTicks: int), сумма lenTicks = totalTicks DMA.
|
||||
Буфер дополняется нулями до dataByteSizeMax, как sendBufferLocal[dataByteSizeMax] в C++.
|
||||
"""
|
||||
send_len = len(packet)
|
||||
send_buf = bytearray(packet) + bytes(max(0, DATA_BYTE_SIZE_MAX - len(packet)))
|
||||
|
||||
toggle = preambToggle
|
||||
data_bit = bitPerByte - 1
|
||||
data_byte = 0
|
||||
preamb_front = preambPulse * 2 - 1
|
||||
data_seq = bitPerByte * 2
|
||||
sync_seq = syncBits * 2
|
||||
sync_last = False
|
||||
sig = preamb
|
||||
state = HIGH
|
||||
cur_seq = bitHigh
|
||||
|
||||
runs: list[tuple[bool, int]] = []
|
||||
outer_steps = 0
|
||||
|
||||
while True:
|
||||
outer_steps += 1
|
||||
gate = state
|
||||
run_len = toggle + 1 # как в C++: (uint16_t)toggleCounterLocal + 1U
|
||||
|
||||
if runs and runs[-1][0] == gate:
|
||||
g, ln = runs[-1]
|
||||
runs[-1] = (g, ln + run_len)
|
||||
else:
|
||||
runs.append((gate, run_len))
|
||||
|
||||
while True:
|
||||
if sig == noSignal:
|
||||
return runs, outer_steps
|
||||
|
||||
if sig == preamb:
|
||||
if preamb_front:
|
||||
preamb_front -= 1
|
||||
toggle = preambToggle
|
||||
break
|
||||
sig = data
|
||||
state = not False
|
||||
continue
|
||||
|
||||
if sig == data:
|
||||
if data_seq:
|
||||
if not (data_seq & 1):
|
||||
cur_seq = bitHigh if ((send_buf[data_byte] >> data_bit) & 1) else bitLow
|
||||
data_bit -= 1
|
||||
toggle = cur_seq[not state]
|
||||
data_seq -= 1
|
||||
break
|
||||
sync_last = send_buf[data_byte] & 1
|
||||
data_byte += 1
|
||||
data_bit = bitPerByte - 1
|
||||
data_seq = bitPerByte * 2
|
||||
sig = sync
|
||||
continue
|
||||
|
||||
if sig == sync:
|
||||
if sync_seq:
|
||||
if not (sync_seq & 1):
|
||||
if sync_seq == 2:
|
||||
cur_seq = bitLow if (send_buf[data_byte] & 0x80) else bitHigh
|
||||
else:
|
||||
cur_seq = bitLow if sync_last else bitHigh
|
||||
sync_last = not sync_last
|
||||
toggle = cur_seq[not state]
|
||||
sync_seq -= 1
|
||||
break
|
||||
sig = data
|
||||
sync_seq = syncBits * 2
|
||||
if data_byte >= send_len:
|
||||
sig = noSignal
|
||||
continue
|
||||
|
||||
return [], 0
|
||||
|
||||
state = not state
|
||||
|
||||
|
||||
def main() -> int:
|
||||
print("IR-protocol: preambToggle =", preambToggle)
|
||||
print()
|
||||
|
||||
# Пример из лога: 8-байтный эхо-пакет Version_Query (CRC OK на приёме)
|
||||
echo = bytes.fromhex("C8 FA 2A FD E8 5D AA B4")
|
||||
c1, c2 = crc_pair_over_wire(echo)
|
||||
print("8 байт (эхо): CRC вычисленный:", f"{c1:02X}", f"{c2:02X}", "| на проводе:", f"{echo[6]:02X}", f"{echo[7]:02X}")
|
||||
|
||||
runs8, steps8 = build_gate_runs(echo)
|
||||
total8 = sum(r[1] for r in runs8)
|
||||
print(" buildGateRuns: внешних шагов FSM =", steps8, ", totalTicks =", total8, ", число run-сегментов =", len(runs8))
|
||||
print()
|
||||
|
||||
# 31 байт из лога Frame reject (пример)
|
||||
reject = bytes.fromhex(
|
||||
"DF 00 00 FA 2A 5E 43 61 72 5F 76 34 2E 33 2E 38 5F 5B 31 32 4D 68 7A 5D 6B ED 1D 9A 53 96 62"
|
||||
)
|
||||
if len(reject) == 31:
|
||||
c1, c2 = crc_pair_over_wire(reject)
|
||||
print("31 байт (reject): CRC по телу 0..28 должен быть:", f"{c1:02X}", f"{c2:02X}", "| байты [29:31]:", f"{reject[29]:02X}", f"{reject[30]:02X}")
|
||||
print(" Совпадение с формулой:", c1 == reject[29] and c2 == reject[30])
|
||||
|
||||
runs31, steps31 = build_gate_runs(reject)
|
||||
total31 = sum(r[1] for r in runs31)
|
||||
print(" buildGateRuns: внешних шагов =", steps31, ", totalTicks =", total31, ", run-сегментов =", len(runs31))
|
||||
print()
|
||||
|
||||
# Связь totalTicks с моделью «N тиков на сегмент до шага FSM»
|
||||
# total_build = sum(toggle_i + 1); если бы было sum(toggle_i), разница = steps
|
||||
theoretical_isr_ticks = total31 - steps31
|
||||
print("Для 31-байт пакета: totalTicks (buildGateRuns) =", total31)
|
||||
print(" Если каждый внешний шаг даёт +1 к длине сегмента относительно ISR (runLen = toggle+1 vs toggle),")
|
||||
print(" оценка «ISR-тиков» как totalTicks - outer_steps =", theoretical_isr_ticks)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
41082
ref/DMA_no_send__extRX.txt
Normal file
41082
ref/DMA_no_send__extRX.txt
Normal file
File diff suppressed because it is too large
Load Diff
14922
ref/DMA_self_frontlog.txt
Normal file
14922
ref/DMA_self_frontlog.txt
Normal file
File diff suppressed because it is too large
Load Diff
64
ref/IR_DMA_TX_backend.md
Normal file
64
ref/IR_DMA_TX_backend.md
Normal file
@ -0,0 +1,64 @@
|
||||
# Контракт бэкенда DMA-TX ИК (`IrDmaTxStm32`)
|
||||
|
||||
Платформа: **STM32G4**, Arduino STM32. Передача: **DMA memory → GPIO BSRR**, запрос от **TIM UPDATE** (частота `carrierFrec×2` из `IR_Encoder::beginClockOnly`).
|
||||
|
||||
### Число потоков (шаблон)
|
||||
|
||||
Класс: **`IrDmaTxStm32<MaxStreams>`**. Число слотов в `Config::streams[]` и внутреннем массиве задаётся **в коде**, без `-D` и без макроса до инклюда:
|
||||
|
||||
```cpp
|
||||
constexpr size_t kStreams = 2;
|
||||
static IrDmaTxStm32<kStreams> dma;
|
||||
IrDmaTxStm32<kStreams>::Config cfg;
|
||||
// IRQ: IrDmaTxStm32<kStreams>::instance()
|
||||
```
|
||||
|
||||
По умолчанию: **`IrDmaTxStm32<>`** эквивалентно **`IrDmaTxStm32<irproto::kDefaultDmaTxMaxStreams>`** (`IR_config.h`, обычно 4). Реализация в заголовке (отдельного `.cpp` нет).
|
||||
|
||||
## Роль библиотеки
|
||||
|
||||
- Разбор пакета в RLE-пробеги: `IR_Encoder::buildGateRuns`.
|
||||
- Генерация слов для BSRR (несущая/тишина по тикам), предзаполнение буфера и дозаполнение по прерываниям half/complete.
|
||||
- Настройка канала DMA, DMAMUX, кольцевой режим, старт/стоп DMA и таймера, колбэки HAL.
|
||||
- В `begin()` только `HAL_NVIC_EnableIRQ` для каналов DMA (без `SetPriority`).
|
||||
|
||||
## Роль прошивки (клиента)
|
||||
|
||||
### Буферы и размеры
|
||||
|
||||
На **каждый** поток в `StreamCfg` клиент передаёт:
|
||||
|
||||
| Поле | Смысл |
|
||||
|------|--------|
|
||||
| `dmaWords` | Указатель на массив `uint32_t` — слова для записи в BSRR. |
|
||||
| `dmaWordCount` | Число **слов** (32-bit), **чётное**, ≥ 2. Половина — один «полубуфер» для HT/TC IRQ. |
|
||||
| `gateRuns` | Массив `IR_Encoder::IR_TxGateRun` для выхода `buildGateRuns`. |
|
||||
| `maxGateRuns` | Длина этого массива. Должен быть достаточен для самого длинного кадра. |
|
||||
|
||||
Память и выравнивание — ответственность клиента; типичные порядки: 4096 слов DMA, 1024 ранов (как в машинке).
|
||||
|
||||
### Таймер и DMA
|
||||
|
||||
- `HardwareTimer` / тот же TIM, что и `beginClockOnly`, без конкурирующего `attachInterrupt` на UPDATE.
|
||||
- `instance`, `irq`, `dmamuxRequest` (например `DMA_REQUEST_TIM17_UP`) — из схемы платы; оба потока на одном TIM обычно используют **один** `TIMx_UP` в DMAMUX.
|
||||
|
||||
### Приоритеты NVIC
|
||||
|
||||
Не задаются в библиотеке. После `begin()` клиент выставляет preempt/sub для `DMA1_ChannelN` (и согласует с приёмом EXTI и др.), например общей функцией вроде `Car_applyInterruptPriorities()`.
|
||||
|
||||
### Прерывания DMA
|
||||
|
||||
Библиотека **не** объявляет `DMA1_ChannelN_IRQHandler`. В одном `.cpp` прошивки — единственное определение на канал, внутри:
|
||||
|
||||
`IrDmaTxStm32<N>::instance()->irqForStream(i)` (тот же **N**, что у объекта бэкенда) или `IrDmaTxStm32_onDmaHandle(hdma)`.
|
||||
|
||||
## Контракт `IR_Encoder::setExternalTxBackend`
|
||||
|
||||
Подключение: `setExternalTxBackend(startFn, busyFn, ctx)`.
|
||||
|
||||
- **`startFn(ctx, enc, packet, len)`** — должен вызвать `IrDmaTxStm32<N>::start(enc, packet, len)` (или обёртку). Возвращает успех старта DMA.
|
||||
- **`busyFn(ctx)`** — пока возвращает «занято», новая отправка не стартует. У `IrDmaTxStm32<N>::busy()`: **true**, если **все** настроенные потоки в передаче (для двух передатчиков — оба активны); иначе можно запустить второй канал.
|
||||
|
||||
## Сбой `begin()`
|
||||
|
||||
При ошибке `HAL_DMA_Init` и т.п. `begin()` возвращает `false`, `instance()` не используется для IRQ до успешного `begin()`.
|
||||
87
ref/IR_EDGE_TRACE_FORMAT.md
Normal file
87
ref/IR_EDGE_TRACE_FORMAT.md
Normal file
@ -0,0 +1,87 @@
|
||||
# Формат журнала фронтов ИК (`IR_EDGE_TRACE`)
|
||||
|
||||
Включается в `IR_config.h`: раскомментируйте `#define IR_EDGE_TRACE`.
|
||||
Размер кольца задаётся `IR_EDGE_TRACE_CAPACITY` (по умолчанию 512 записей).
|
||||
Память: примерно `IR_EDGE_TRACE_CAPACITY × 6` байт на экземпляр `IR_DecoderRaw`.
|
||||
|
||||
## Назначение
|
||||
|
||||
В ISR на каждый аппаратный фронт на линии приёмника пишется запись: абсолютное время `micros()`, уровень линии после фронта, флаги. Это **отдельное** кольцо от `subBuffer`: при переполнении `subBuffer` фронты в журнале всё равно сохраняются, пока не заполнится это кольцо.
|
||||
|
||||
При **передаче ИК по DMA** на STM32 важно, чтобы **прерывание приёма (EXTI)** имело **более высокий приоритет NVIC**, чем DMA канала передачи — иначе метки времени и сам поток фронтов в логе искажаются. См. **[`IR_DMA_ISR_signal_analysis.md`](../IR_DMA_ISR_signal_analysis.md)** (раздел 2.1).
|
||||
|
||||
## Вывод в Serial
|
||||
|
||||
При включённом `IR_EDGE_TRACE` протокол **сам** сбрасывает накопленные фронты в конце каждого `IR_DecoderRaw::tick()` (и на ветке «subBuffer пуст»): в цикле вызывается `edgeTraceFlushChunk(Serial, 48)`, пока в кольце есть записи.
|
||||
|
||||
Вручную тот же смысл: `edgeTraceFlushChunk(Print &out, maxRec)` печатает **ровно одну строку** (если есть что выгрузить; при пустом кольце выход без печати):
|
||||
|
||||
1. Символ перевода строки `\n` (отделяет блок от предыдущего вывода).
|
||||
2. Литеральный префикс **`@IRF1v1:`** (удобно grep-ать; не используйте этот текст в других `Serial.print`, чтобы строки не сливались).
|
||||
3. **Нижний регистр hex** без пробелов: полезная нагрузка бинарного блока ниже.
|
||||
4. `\n` в конце.
|
||||
|
||||
Другой текст (например `IR raw:` из `IRDEBUG_SERIAL_PACK`) не содержит `@IRF1v1:`, поэтому визуально и по парсеру блоки разделимы.
|
||||
|
||||
Если авто-сброс в `tick()` отключён или нужен другой `Print`, вызывайте `edgeTraceFlushChunk` в цикле, пока возвращаемое значение > 0.
|
||||
|
||||
## Бинарная полезная нагрузка (до кодирования в hex)
|
||||
|
||||
Все многобайтовые целые — **little-endian**, порядок байт от младшего к старшему.
|
||||
|
||||
| Смещение | Размер | Поле |
|
||||
|----------|--------|------|
|
||||
| 0 | 1 | **meta** |
|
||||
| 1 | 2 | **count** — число записей в этой строке (`uint16_t`) |
|
||||
| 3 | `count × 6` | Массив записей |
|
||||
|
||||
### meta (байт)
|
||||
|
||||
| Бит | Значение |
|
||||
|-----|----------|
|
||||
| 0 | **overflow**: кольцо хотя бы раз переполнилось с момента последнего `edgeTraceClear()`; новые фронты терялись, пока не освободилось место. Сбрасывается только `edgeTraceClear()`. |
|
||||
| 1 | **truncated**: после этой выгрузки в буфере ещё есть записи (chunk урезан лимитом `maxRec` или внутренним максимумом 64). |
|
||||
|
||||
Биты 2–7 зарезервированы (0).
|
||||
|
||||
### Одна запись (6 байт)
|
||||
|
||||
| Смещение в записи | Размер | Поле |
|
||||
|-------------------|--------|------|
|
||||
| 0 | 4 | **t_us** — значение `micros()` на момент фронта (`uint32_t`). При переполнении `micros()` (~70 мин) разницы между соседними записями всё ещё корректны, если обрабатывать как unsigned. |
|
||||
| 4 | 1 | **level** — уровень входа приёмника после фронта: `0` = LOW, `1` = HIGH (как `port->IDR & mask` в ISR). |
|
||||
| 5 | 1 | **flags** |
|
||||
| | | бит 0 **SKIP_DECODE** (`IR_EDGE_TRACE_F_SKIP_DECODE`): фронт записан, но в `subBuffer` **не** попал, потому что был активен `isPairSending` (пара передаёт). Алгоритм декодирования этот фронт не видит. |
|
||||
|
||||
## Минимальный разбор (Python 3)
|
||||
|
||||
```python
|
||||
import binascii, re
|
||||
|
||||
def parse_irf1_line(line: str):
|
||||
m = re.search(r"@IRF1v1:([0-9a-f]+)\s*$", line.strip())
|
||||
if not m:
|
||||
return None
|
||||
raw = binascii.unhexlify(m.group(1))
|
||||
meta, cnt_lo, cnt_hi = raw[0], raw[1], raw[2]
|
||||
count = cnt_lo | (cnt_hi << 8)
|
||||
recs = []
|
||||
p = 3
|
||||
for _ in range(count):
|
||||
t = raw[p] | (raw[p+1]<<8) | (raw[p+2]<<16) | (raw[p+3]<<24)
|
||||
level, flags = raw[p+4], raw[p+5]
|
||||
recs.append((t, level, flags))
|
||||
p += 6
|
||||
return {
|
||||
"overflow": bool(meta & 1),
|
||||
"truncated": bool(meta & 2),
|
||||
"count": count,
|
||||
"records": recs,
|
||||
}
|
||||
```
|
||||
|
||||
## Рекомендации по съёму
|
||||
|
||||
- При очень плотном потоке фронтов кольцо всё же может переполниться до следующего `tick()` — увеличьте `IR_EDGE_TRACE_CAPACITY` или уменьшите нагрузку на ISR.
|
||||
- Для «чистого» лога отключите или сильно урежьте `IRDEBUG_SERIAL_PACK`, иначе объём Serial будет очень большим.
|
||||
- Для полного сброса состояния перед тестом: `edgeTraceClear()`.
|
||||
289
ref/ISR_self.txt
Normal file
289
ref/ISR_self.txt
Normal file
@ -0,0 +1,289 @@
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
IR sendTimer()
|
||||
IR Laser();
|
||||
IR SKIP LASER
|
||||
|
||||
IR sendTimer()
|
||||
IR irSend()
|
||||
|
||||
|
||||
IR raw: => ERROR: TIMEOUT, rx_data_size = 10, but only 10 bytes received
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
|
||||
IR raw: 110 01010 101 00000000 101 00000000 100 11111101 010 11101000 101 01011000 101 00000000 101 00000000 100 11011101 010 11011000 => OK: SendInfo_v1_1, Empty_Command, Empty_Command
|
||||
IR hex: CA 00 00 FD E8 58 00 00 DD D8
|
||||
17170
ref/ISR_self_frontlog.txt
Normal file
17170
ref/ISR_self_frontlog.txt
Normal file
File diff suppressed because it is too large
Load Diff
13744
ref/OtherCar_DMA_send__NoSelfTx.txt
Normal file
13744
ref/OtherCar_DMA_send__NoSelfTx.txt
Normal file
File diff suppressed because it is too large
Load Diff
13
ref/point response.txt
Normal file
13
ref/point response.txt
Normal file
@ -0,0 +1,13 @@
|
||||
IR raw: 110 01001 011 01111101 011 00100110 101 00000000 100 00000000 101 01110110 101 00100111 010 10011100 101 01101100 => OK: Laser_ON, LED_Left_BlinkTest
|
||||
IR hex: C9 7D 26 00 00 76 27 9C 6C
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
IR raw: 110 01001 011 01111101 011 00100110 101 00000000 100 00000000 101 01110110 101 00100111 010 10011100 101 01101100 => OK: Laser_ON, LED_Left_BlinkTest
|
||||
|
||||
|
||||
721
tools/ir_decoder_sim.py
Normal file
721
tools/ir_decoder_sim.py
Normal file
@ -0,0 +1,721 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Офлайн-симуляция IR_DecoderRaw::tick + writeToBuffer по журналу @IRF1v1:
|
||||
См. ref/IR_EDGE_TRACE_FORMAT.md
|
||||
|
||||
При FRAME_END: сводка (чистые биты / burst / отброшенные фронты), список точечных
|
||||
исправлений (преамбула, пропуск такта, поджатие low/high, sync), при crc_ok=False —
|
||||
разбор несовпадения CRC; в первой строке пакет как hex= и bin= (8 бит на байт MSB-first,
|
||||
байты через пробел); отдельная строка «синхро» — счётчик ошибок 1-го бита тройки (как
|
||||
err_syncBit в прошивке) и принятые тройки sync-битов между байтами (2-й и 3-й в прошивке
|
||||
не сверяются с шаблоном, только пишутся в поток — их значения для наглядности сдвига).
|
||||
WRONG_PACK_SYNC — отдельное событие с причиной и тем же блоком «синхро».
|
||||
|
||||
Флаг -v/--verbose: дополнительно каждая строка для «чистого» бита (aroundRise) и
|
||||
отброшенных фронтов; без флага эти события только в счётчиках сводки.
|
||||
|
||||
Не моделирует IRDEBUG_SERIAL_SOFT_REJECT (жёсткий Wrong sync).
|
||||
Таймауты: между фронтами, если gap > IR_timeout*2 и isRecive — checkTimeout.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import binascii
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
from dataclasses import dataclass, field
|
||||
from typing import List, Tuple
|
||||
|
||||
# --- IR_config.h (как в прошивке, целочисленно) ---
|
||||
CARRIER_FREC = 38000
|
||||
CARRIER_PERIOD = 1000000 // CARRIER_FREC
|
||||
BIT_ACTIVE_TAKTS = 25
|
||||
BIT_PAUSE_TAKTS = 12
|
||||
BIT_TAKTS = BIT_ACTIVE_TAKTS + BIT_PAUSE_TAKTS
|
||||
BIT_TIME = BIT_TAKTS * CARRIER_PERIOD
|
||||
TOLERANCE = 300
|
||||
SYNCBITS = 3
|
||||
BIT_PER_BYTE = 8
|
||||
MSGBYTES = 1
|
||||
CRC_BYTES = 2
|
||||
POLY1 = 0x31
|
||||
POLY2 = 0x8C
|
||||
IR_MASK_MSG_INFO = 0x1F
|
||||
PREAMB_PULSE = 3
|
||||
PREAMB_FRONTS = PREAMB_PULSE * 2
|
||||
BYTE_PER_PACK = 31
|
||||
DATA_BYTE_SIZE_MAX = MSGBYTES + 2 + 2 + BYTE_PER_PACK + CRC_BYTES
|
||||
FREE_FREC = False
|
||||
SKIP_DECODE_FLAG = 0x01
|
||||
|
||||
# Myagkie tsveta dlya terminala (256-color), ne iarkie default 31/32
|
||||
_ANSI_GREEN = "\033[38;5;107m" # priglushennyj zelenyj (ne iarkij 32)
|
||||
_ANSI_RED = "\033[38;5;174m" # pylno-rozovyj / myagkij krasnyj (ne iarkij 31)
|
||||
_ANSI_RESET = "\033[0m"
|
||||
# Zolotistyj / birjuzovyj + zhirnyj dlya hex i bin paketa v stroke FRAME_END
|
||||
_HEX_PACKET_FG = "\033[1;38;5;222m"
|
||||
_BIN_PACKET_FG = "\033[1;38;5;109m"
|
||||
|
||||
|
||||
def _bytes_bin_msb(data: bytes) -> str:
|
||||
"""8 bit na bajt (MSB pervyj, kak v writeToBuffer), bajty cherez probel."""
|
||||
return " ".join(f"{b:08b}" for b in data)
|
||||
|
||||
|
||||
def _use_terminal_color() -> bool:
|
||||
if os.environ.get("NO_COLOR"):
|
||||
return False
|
||||
try:
|
||||
return sys.stdout.isatty()
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def _colorize_block(text: str, ok: bool, enabled: bool) -> str:
|
||||
if not enabled:
|
||||
return text
|
||||
code = _ANSI_GREEN if ok else _ANSI_RED
|
||||
return f"{code}{text}{_ANSI_RESET}"
|
||||
|
||||
|
||||
def _highlight_hex_bin_in_frame_line(line: str, ok: bool, enabled: bool) -> str:
|
||||
"""Odna stroka s FRAME_END: vydeljaet hex= i bin=."""
|
||||
if not enabled or "FRAME_END" not in line:
|
||||
return line
|
||||
parent = _ANSI_GREEN if ok else _ANSI_RED
|
||||
after = "\033[22m" + parent
|
||||
spans: list[tuple[int, int, str]] = []
|
||||
mhx = re.search(r"hex=([0-9a-fA-F]+)", line)
|
||||
if mhx:
|
||||
spans.append((mhx.start(1), mhx.end(1), _HEX_PACKET_FG))
|
||||
mbn = re.search(r"bin=([01 ]+)$", line)
|
||||
if mbn:
|
||||
spans.append((mbn.start(1), mbn.end(1), _BIN_PACKET_FG))
|
||||
if not spans:
|
||||
return line
|
||||
spans.sort(key=lambda t: t[0])
|
||||
out: list[str] = []
|
||||
last = 0
|
||||
for s, e, col in spans:
|
||||
out.append(line[last:s])
|
||||
out.append(col + line[s:e] + after)
|
||||
last = e
|
||||
out.append(line[last:])
|
||||
return "".join(out)
|
||||
|
||||
|
||||
def _highlight_frame_end_payloads(ev: str, ok: bool, enabled: bool) -> str:
|
||||
"""Vo vseh strokah FRAME_END vydeljaet hex= i bin= (v tom chisle povtor svodki v konce)."""
|
||||
if not enabled:
|
||||
return ev
|
||||
return "\n".join(_highlight_hex_bin_in_frame_line(L, ok, enabled) for L in ev.split("\n"))
|
||||
|
||||
|
||||
def _packet_event_tone(ev: str) -> str | None:
|
||||
"""'ok' | 'bad' | None — dlya pokrashki celogo bloka sobytija."""
|
||||
head = ev.split("\n", 1)[0]
|
||||
if "FRAME_END" in head:
|
||||
if "crc_ok=True" in head:
|
||||
return "ok"
|
||||
if "crc_ok=False" in head:
|
||||
return "bad"
|
||||
if "WRONG_PACK_SYNC" in head:
|
||||
return "bad"
|
||||
return None
|
||||
|
||||
|
||||
def rise_time_max(rise_sync: int) -> int:
|
||||
return rise_sync + TOLERANCE
|
||||
|
||||
|
||||
def rise_time_min(rise_sync: int) -> int:
|
||||
return rise_sync - TOLERANCE
|
||||
|
||||
|
||||
def ir_timeout_us(rise_sync: int) -> int:
|
||||
return rise_time_max(rise_sync) * (8 + SYNCBITS + 1)
|
||||
|
||||
|
||||
def around_rise(t: int, rise_sync: int) -> bool:
|
||||
return rise_time_min(rise_sync) < t < rise_time_max(rise_sync)
|
||||
|
||||
|
||||
def ceil_div(val: int, divider: int) -> int:
|
||||
ret = val // divider
|
||||
if (val << 4) // divider - (ret << 4) >= 8:
|
||||
ret += 1
|
||||
return ret
|
||||
|
||||
|
||||
def crc8(data: bytes, start: int, end: int, poly: int) -> int:
|
||||
crc = 0xFF
|
||||
for i in range(start, end):
|
||||
crc ^= data[i]
|
||||
for _ in range(8):
|
||||
if crc & 0x80:
|
||||
crc = ((crc << 1) ^ poly) & 0xFF
|
||||
else:
|
||||
crc = (crc << 1) & 0xFF
|
||||
return crc
|
||||
|
||||
|
||||
def crc_compute_bytes(data: bytearray, pack_size: int) -> Tuple[int, int, int]:
|
||||
"""Ожидаемые байты CRC: (crc1_hi, crc2_lo, len_payload) или (-1,-1,-1) при неверном pack_size."""
|
||||
if pack_size < 1 + CRC_BYTES or pack_size > DATA_BYTE_SIZE_MAX:
|
||||
return (-1, -1, -1)
|
||||
ln = pack_size - CRC_BYTES
|
||||
c1 = crc8(bytes(data), 0, ln, POLY1)
|
||||
c2 = crc8(bytes(data), 0, ln + 1, POLY2)
|
||||
return (c1 & 0xFF, c2 & 0xFF, ln)
|
||||
|
||||
|
||||
def crc_check(data: bytearray, pack_size: int) -> bool:
|
||||
ln = pack_size - CRC_BYTES
|
||||
c1 = crc8(bytes(data), 0, ln, POLY1)
|
||||
c2 = crc8(bytes(data), 0, ln + 1, POLY2)
|
||||
crc = ((c1 << 8) & ~0xFF) | (c2 & 0xFF)
|
||||
return data[ln] == ((crc >> 8) & 0xFF) and data[ln + 1] == (crc & 0xFF)
|
||||
|
||||
|
||||
def crc_failure_lines(data: bytearray, pack_size: int) -> List[str]:
|
||||
"""Подробности при несовпадении CRC."""
|
||||
out: List[str] = []
|
||||
exp_hi, exp_lo, ln = crc_compute_bytes(data, pack_size)
|
||||
if ln < 0:
|
||||
out.append(f" некорректный pack_size={pack_size} (ожидается 1..{DATA_BYTE_SIZE_MAX})")
|
||||
return out
|
||||
got_hi = data[pack_size - 2]
|
||||
got_lo = data[pack_size - 1]
|
||||
hdr = data[0]
|
||||
msg_t = (hdr >> 5) & 0x07
|
||||
out.append(
|
||||
f" байт[0]=0x{hdr:02x} тип_сообщения={msg_t} заявл._длина_кадра={hdr & IR_MASK_MSG_INFO} байт"
|
||||
)
|
||||
out.append(
|
||||
f" правило CRC: crc8(data[0..{ln - 1}], poly1=0x{POLY1:02x}) -> байт[{ln}]; "
|
||||
f"crc8(data[0..{ln}], poly2=0x{POLY2:02x}) -> байт[{ln + 1}]"
|
||||
)
|
||||
out.append(f" ожидалось: {exp_hi:02x} {exp_lo:02x} принято в кадре: {got_hi:02x} {got_lo:02x}")
|
||||
if got_hi != exp_hi:
|
||||
out.append(
|
||||
f" первый байт CRC не совпал - искажены данные [0..{ln - 1}] и/или этот байт CRC"
|
||||
)
|
||||
if got_lo != exp_lo:
|
||||
out.append(
|
||||
" второй байт CRC не совпал - в poly2 входит уже первый байт CRC; типично сдвиг битовой границы"
|
||||
)
|
||||
pl = data[:ln].hex()
|
||||
out.append(f" полезная нагрузка без CRC ({ln} байт): {pl}")
|
||||
return out
|
||||
|
||||
|
||||
@dataclass
|
||||
class EdgeRec:
|
||||
t_us: int
|
||||
level: int # 0/1 после фронта
|
||||
flags: int
|
||||
|
||||
|
||||
def parse_irf1_lines(text: str) -> List[EdgeRec]:
|
||||
out: List[EdgeRec] = []
|
||||
pat = re.compile(r"@IRF1v1:([0-9a-fA-F]+)\s*")
|
||||
for m in pat.finditer(text):
|
||||
hx = m.group(1)
|
||||
if len(hx) % 2:
|
||||
continue
|
||||
try:
|
||||
raw = binascii.unhexlify(hx)
|
||||
except binascii.Error:
|
||||
continue
|
||||
if len(raw) < 3:
|
||||
continue
|
||||
meta = raw[0]
|
||||
count = raw[1] | (raw[2] << 8)
|
||||
need = 3 + count * 6
|
||||
if len(raw) < need or count > 2000:
|
||||
continue
|
||||
p = 3
|
||||
for _ in range(count):
|
||||
t = raw[p] | (raw[p + 1] << 8) | (raw[p + 2] << 16) | (raw[p + 3] << 24)
|
||||
lvl = raw[p + 4]
|
||||
flg = raw[p + 5]
|
||||
out.append(EdgeRec(t, lvl & 1, flg))
|
||||
p += 6
|
||||
if meta & 1:
|
||||
pass # overflow — запись могла обрезаться
|
||||
return out
|
||||
|
||||
|
||||
@dataclass
|
||||
class DecoderSim:
|
||||
prev_rise: int = 0
|
||||
prev_fall: int = 0
|
||||
rise_period: int = 0
|
||||
high_time: int = 0
|
||||
low_time: int = 0
|
||||
last_edge_time: int = 0
|
||||
preamb_front_counter: int = 0
|
||||
is_preamb: bool = False
|
||||
is_recive: bool = False
|
||||
is_recive_raw: bool = False
|
||||
is_wrong_pack: bool = False
|
||||
is_buffer_overflow: bool = False
|
||||
rise_sync_time: int = BIT_TIME
|
||||
high_count: int = 0
|
||||
low_count: int = 0
|
||||
all_count: int = 0
|
||||
i_data_buffer: int = 0
|
||||
buf_bit_pos: int = 0
|
||||
next_control_bit: int = BIT_PER_BYTE
|
||||
is_data: bool = True
|
||||
i_sync_bit: int = 0
|
||||
err_sync_bit: int = 0
|
||||
data_buffer: bytearray = field(default_factory=lambda: bytearray(DATA_BYTE_SIZE_MAX))
|
||||
pack_size: int = 0
|
||||
errors_other: int = 0
|
||||
events: List[str] = field(default_factory=list)
|
||||
verbose: bool = False
|
||||
"""Подстроеки/исправления как в IR_DecoderRaw::tick (за текущий пакет)."""
|
||||
packet_fixes: List[str] = field(default_factory=list)
|
||||
_fatal_sync_event_sent: bool = False
|
||||
stat_clean_bits: int = 0
|
||||
stat_burst_edges: int = 0
|
||||
stat_debounce_rise: int = 0
|
||||
stat_debounce_fall: int = 0
|
||||
# Mezhdu bajtami: trojki sync-bitov (kak v writeToBuffer); oshibka schetaetsja tolko za 1-j bit
|
||||
stat_sync_first_error: int = 0
|
||||
sync_groups: List[str] = field(default_factory=list)
|
||||
sync_bits_current_group: List[int] = field(default_factory=list)
|
||||
|
||||
def _fix(self, msg: str) -> None:
|
||||
self.packet_fixes.append(msg)
|
||||
|
||||
def _clear_packet_state(self) -> None:
|
||||
self.packet_fixes.clear()
|
||||
self._fatal_sync_event_sent = False
|
||||
self.stat_clean_bits = 0
|
||||
self.stat_burst_edges = 0
|
||||
self.stat_debounce_rise = 0
|
||||
self.stat_debounce_fall = 0
|
||||
self.stat_sync_first_error = 0
|
||||
self.sync_groups.clear()
|
||||
self.sync_bits_current_group.clear()
|
||||
|
||||
def _sync_bit_consumed(self, bit_val: int) -> None:
|
||||
"""Odin prinjatyj sync-bit (bufBitPos++ v vetke sync v proshivke)."""
|
||||
self.sync_bits_current_group.append(bit_val & 1)
|
||||
if len(self.sync_bits_current_group) == SYNCBITS:
|
||||
self.sync_groups.append("".join(str(b) for b in self.sync_bits_current_group))
|
||||
self.sync_bits_current_group.clear()
|
||||
|
||||
def _sync_summary_lines(self, *, with_firmware_note: bool = False) -> List[str]:
|
||||
"""Stroki svodki po sinhrobitam dlya FRAME_END i WRONG_PACK_SYNC."""
|
||||
sg = "/".join(self.sync_groups) if self.sync_groups else "—"
|
||||
lines = [
|
||||
f" синхро: ошибок_1-го_бита(как_в_IR_DecoderRaw)={self.stat_sync_first_error}; "
|
||||
f"полных_троек={len(self.sync_groups)}; биты_троек={sg}"
|
||||
]
|
||||
if self.sync_bits_current_group:
|
||||
tail = "".join(str(b) for b in self.sync_bits_current_group)
|
||||
lines.append(f" синхро: незавершённая_тройка (уже приняты биты): {tail}")
|
||||
if with_firmware_note:
|
||||
lines.append(
|
||||
" синхро: в прошивке при ошибке считается только случай «1-й бит тройки совпал с последним "
|
||||
"data-битом» (errors.other++, err_syncBit); 2-й и 3-й sync-биты не сравниваются с эталоном."
|
||||
)
|
||||
return lines
|
||||
|
||||
def _emit_wrong_sync_fatal(self, t: int) -> None:
|
||||
lines = [
|
||||
f"t={t} WRONG_PACK_SYNC (аналог ERROR: Wrong sync bit в прошивке, err_sync_bit>={SYNCBITS})"
|
||||
]
|
||||
if self.packet_fixes:
|
||||
lines.append(" подстройки и исправления до ошибки:")
|
||||
for fx in self.packet_fixes:
|
||||
lines.append(f" - {fx}")
|
||||
lines.extend(self._sync_summary_lines(with_firmware_note=True))
|
||||
lines.append(
|
||||
" причина фатала: повторы неверного 1-го sync-бита накапливают err_syncBit до порога syncBits."
|
||||
)
|
||||
self.events.append("\n".join(lines))
|
||||
|
||||
def first_rx(self) -> None:
|
||||
self.is_buffer_overflow = False
|
||||
self.pack_size = 0
|
||||
self.buf_bit_pos = 0
|
||||
self.is_data = True
|
||||
self.i_data_buffer = 0
|
||||
self.next_control_bit = BIT_PER_BYTE
|
||||
self.i_sync_bit = 0
|
||||
self.err_sync_bit = 0
|
||||
self.is_wrong_pack = False
|
||||
self.data_buffer[:] = bytes(DATA_BYTE_SIZE_MAX)
|
||||
self.rise_sync_time = BIT_TIME
|
||||
self.stat_sync_first_error = 0
|
||||
self.sync_groups.clear()
|
||||
self.sync_bits_current_group.clear()
|
||||
|
||||
def listen_start(self, now: int) -> None:
|
||||
to = ir_timeout_us(self.rise_sync_time)
|
||||
if self.is_recive_raw and (now - self.prev_rise) > to * 2:
|
||||
self.events.append(f"t={now} listenStart abort raw (gap from prev_rise)")
|
||||
self.is_recive_raw = False
|
||||
self._clear_packet_state()
|
||||
self.first_rx()
|
||||
|
||||
def check_timeout(self, now: int) -> None:
|
||||
if not self.is_recive:
|
||||
return
|
||||
to = ir_timeout_us(self.rise_sync_time)
|
||||
if now - self.last_edge_time > to * 2:
|
||||
self.events.append(f"t={now} checkTimeout (gap since last edge)")
|
||||
self.is_recive = False
|
||||
self.last_edge_time = now
|
||||
|
||||
def write_to_buffer(self, bit_val: int) -> None:
|
||||
if self.i_data_buffer > DATA_BYTE_SIZE_MAX * 8:
|
||||
self.is_buffer_overflow = True
|
||||
self._fix("переполнение буфера битов (writeToBuffer: i_dataBuffer > dataByteSizeMax*8)")
|
||||
if self.is_buffer_overflow or self.is_preamb or self.is_wrong_pack:
|
||||
self.is_recive = False
|
||||
self.is_recive_raw = False
|
||||
return
|
||||
|
||||
if self.buf_bit_pos == self.next_control_bit:
|
||||
self.next_control_bit += SYNCBITS if self.is_data else BIT_PER_BYTE
|
||||
self.is_data = not self.is_data
|
||||
self.i_sync_bit = 0
|
||||
self.err_sync_bit = 0
|
||||
|
||||
if self.is_data:
|
||||
bi = self.i_data_buffer // 8
|
||||
self.data_buffer[bi] |= (bit_val & 1) << (7 - (self.i_data_buffer % 8))
|
||||
self.i_data_buffer += 1
|
||||
self.buf_bit_pos += 1
|
||||
else:
|
||||
if self.i_sync_bit == 0:
|
||||
prev_bit = (
|
||||
self.data_buffer[(self.i_data_buffer - 1) // 8]
|
||||
>> (7 - (self.i_data_buffer - 1) % 8)
|
||||
) & 1
|
||||
if bit_val != prev_bit:
|
||||
self.buf_bit_pos += 1
|
||||
self.i_sync_bit += 1
|
||||
self._sync_bit_consumed(bit_val)
|
||||
else:
|
||||
self.i_sync_bit = 0
|
||||
self.errors_other += 1
|
||||
self.err_sync_bit += 1
|
||||
self.stat_sync_first_error += 1
|
||||
self._fix(
|
||||
f"sync: 1-й sync-бит совпал с последним data-битом (data={prev_bit}); "
|
||||
f"err_sync_bit={self.err_sync_bit}/{SYNCBITS} (как в прошивке)"
|
||||
)
|
||||
if self.err_sync_bit >= SYNCBITS:
|
||||
self.is_wrong_pack = True
|
||||
if not self._fatal_sync_event_sent:
|
||||
self._fatal_sync_event_sent = True
|
||||
self._emit_wrong_sync_fatal(self.last_edge_time)
|
||||
else:
|
||||
self.buf_bit_pos += 1
|
||||
self.i_sync_bit += 1
|
||||
self._sync_bit_consumed(bit_val)
|
||||
self.is_wrong_pack = self.err_sync_bit >= SYNCBITS
|
||||
|
||||
if self.is_data and not self.is_wrong_pack:
|
||||
if self.i_data_buffer == 8 * MSGBYTES:
|
||||
self.pack_size = self.data_buffer[0] & IR_MASK_MSG_INFO
|
||||
if self.pack_size and self.i_data_buffer == self.pack_size * BIT_PER_BYTE:
|
||||
ok = crc_check(self.data_buffer, self.pack_size)
|
||||
raw = self.data_buffer[: self.pack_size]
|
||||
hx = raw.hex()
|
||||
bstr = _bytes_bin_msb(raw)
|
||||
frame_line = (
|
||||
f"t={self.last_edge_time} FRAME_END pack={self.pack_size} crc_ok={ok} hex={hx} bin={bstr}"
|
||||
)
|
||||
sync_lines = self._sync_summary_lines()
|
||||
tick_summary = (
|
||||
f" сводка тактов: чистых_битов_aroundRise={self.stat_clean_bits}, "
|
||||
f"фронтов_с_burst-коррекцией={self.stat_burst_edges}, "
|
||||
f"отброшенных_фронтов_up={self.stat_debounce_rise}, down={self.stat_debounce_fall}"
|
||||
)
|
||||
|
||||
def _frame_summary_block() -> List[str]:
|
||||
return [frame_line, *sync_lines, tick_summary]
|
||||
|
||||
lines: List[str] = []
|
||||
lines.extend(_frame_summary_block())
|
||||
if self.packet_fixes:
|
||||
if self.verbose:
|
||||
lines.append(
|
||||
" подстройки и исправления за пакет, подробный режим (-v) (аналог IR_DecoderRaw::tick):"
|
||||
)
|
||||
else:
|
||||
lines.append(
|
||||
" подстройки и исправления за пакет (преамбула, пропуск такта, burst, sync; "
|
||||
"без строк по каждому «чистому» биту — включите -v):"
|
||||
)
|
||||
for fx in self.packet_fixes:
|
||||
lines.append(f" - {fx}")
|
||||
else:
|
||||
lines.append(
|
||||
" дополнительных исправлений нет (см. сводку; для строк по каждому биту: -v/--verbose)"
|
||||
)
|
||||
if not ok:
|
||||
lines.append(" неуспешный пакет — причина:")
|
||||
lines.extend(crc_failure_lines(self.data_buffer, self.pack_size))
|
||||
lines.append(" --- сводка пакета (конец записи) ---")
|
||||
lines.extend(_frame_summary_block())
|
||||
self.events.append("\n".join(lines))
|
||||
self.is_recive = False
|
||||
self.is_recive_raw = False
|
||||
self._clear_packet_state()
|
||||
self.first_rx()
|
||||
|
||||
def tick_edge(self, t: int, level: int) -> None:
|
||||
"""Один фронт: level = состояние линии ПОСЛЕ фронта (как dir в C++)."""
|
||||
self.listen_start(t)
|
||||
self.last_edge_time = t
|
||||
rising = level == 1
|
||||
|
||||
if rising:
|
||||
cond = (t - self.prev_rise > rise_time_max(self.rise_sync_time) // 4) or self.high_count or self.low_count
|
||||
if cond:
|
||||
self.rise_period = t - self.prev_rise
|
||||
self.high_time = t - self.prev_fall
|
||||
self.low_time = self.prev_fall - self.prev_rise
|
||||
self.prev_rise = t
|
||||
else:
|
||||
self.errors_other += 1
|
||||
self.stat_debounce_rise += 1
|
||||
if self.verbose:
|
||||
self._fix(
|
||||
f"t={t} отброшен фронт ↑: слишком короткий интервал до предыдущего ↑ "
|
||||
f"(<= riseTimeMax/4 при hc=lc=0), errors.other++"
|
||||
)
|
||||
else:
|
||||
if t - self.prev_fall > rise_time_min(self.rise_sync_time) // 4:
|
||||
self.prev_fall = t
|
||||
else:
|
||||
self.errors_other += 1
|
||||
self.stat_debounce_fall += 1
|
||||
if self.verbose:
|
||||
self._fix(
|
||||
f"t={t} отброшен фронт ↓: слишком короткий интервал до предыдущего ↓ (<= riseTimeMin/4), errors.other++"
|
||||
)
|
||||
|
||||
rt = self.rise_sync_time
|
||||
to = ir_timeout_us(rt)
|
||||
if t > self.prev_rise and (t - self.prev_rise) > to * 2 and not self.is_recive_raw:
|
||||
self.preamb_front_counter = PREAMB_FRONTS - 1
|
||||
self.is_preamb = True
|
||||
self.is_recive = True
|
||||
self.is_recive_raw = True
|
||||
self.is_wrong_pack = False
|
||||
self._clear_packet_state()
|
||||
self.events.append(f"t={t} PACKET_START (long idle)")
|
||||
|
||||
if self.preamb_front_counter:
|
||||
if rising and self.rise_period < to:
|
||||
if self.rise_period < rise_time_min(rt) // 2:
|
||||
self.preamb_front_counter += 2
|
||||
self.errors_other += 1
|
||||
self._fix(
|
||||
f"преамбула: «рваная единица» risePeriod={self.rise_period} us < riseTimeMin/2 "
|
||||
f"({rise_time_min(rt) // 2} us) -> preambFrontCounter += 2, errors.other++"
|
||||
)
|
||||
elif FREE_FREC:
|
||||
old = self.rise_sync_time
|
||||
self.rise_sync_time = (self.rise_sync_time + self.rise_period // 2) // 2
|
||||
self._fix(
|
||||
f"преамбула: подстройка riseSyncTime {old}->{self.rise_sync_time} us (freeFrec)"
|
||||
)
|
||||
self.preamb_front_counter -= 1
|
||||
else:
|
||||
if self.is_preamb:
|
||||
self.is_preamb = False
|
||||
half = self.rise_period // 2
|
||||
self.prev_rise += half
|
||||
self._fix(
|
||||
f"после преамбулы: prev_rise += risePeriod/2 (+{half} us) - фазовая привязка к центру бита"
|
||||
)
|
||||
return
|
||||
|
||||
if self.is_preamb:
|
||||
return
|
||||
|
||||
if self.rise_period > to or self.is_buffer_overflow or self.rise_period < rise_time_min(rt) or self.is_wrong_pack:
|
||||
if self.is_recive and rising and (self.rise_period > to or self.rise_period < rise_time_min(rt)):
|
||||
reason = (
|
||||
f"risePeriod={self.rise_period} us: "
|
||||
+ (f"> IR_timeout={to} us " if self.rise_period > to else "")
|
||||
+ (f"< riseTimeMin={rise_time_min(rt)} us " if self.rise_period < rise_time_min(rt) else "")
|
||||
)
|
||||
self._fix(f"t={t} пропуск такта (goto END): {reason.strip()}")
|
||||
return
|
||||
|
||||
if not rising:
|
||||
return
|
||||
|
||||
self.high_count = 0
|
||||
self.low_count = 0
|
||||
self.all_count = 0
|
||||
invert_err = False
|
||||
rt = self.rise_sync_time
|
||||
|
||||
if around_rise(self.rise_period, rt):
|
||||
self.stat_clean_bits += 1
|
||||
bit = 1 if self.high_time > self.low_time else 0
|
||||
if self.verbose:
|
||||
self._fix(
|
||||
f"t={t} «чистый» бит: aroundRise (risePeriod={self.rise_period} us в [{rise_time_min(rt)}..{rise_time_max(rt)}]), "
|
||||
f"highTime={self.high_time} lowTime={self.low_time} us -> bit {bit}"
|
||||
)
|
||||
self.write_to_buffer(bit)
|
||||
else:
|
||||
self.stat_burst_edges += 1
|
||||
self.high_count = ceil_div(self.high_time, rt)
|
||||
self.low_count = ceil_div(self.low_time, rt)
|
||||
self.all_count = ceil_div(self.rise_period, rt)
|
||||
self._fix(
|
||||
f"t={t} пропуск такта / растяжение: risePeriod={self.rise_period} us вне aroundRise "
|
||||
f"[{rise_time_min(rt)}..{rise_time_max(rt)}]; "
|
||||
f"ceil_div: highTime/{rt}->{self.high_count}, lowTime/{rt}->{self.low_count}, risePeriod/{rt}->{self.all_count}"
|
||||
)
|
||||
if self.high_count == 0 and self.high_time > rt // 3:
|
||||
self.high_count += 1
|
||||
self.errors_other += 1
|
||||
self._fix(
|
||||
f"доп. коррекция: highCount был 0 при highTime={self.high_time} > riseTime/3 ({rt // 3}) -> highCount++"
|
||||
)
|
||||
if self.low_count + self.high_count > self.all_count:
|
||||
lo, hi, ac = self.low_count, self.high_count, self.all_count
|
||||
if self.low_count > self.high_count:
|
||||
self.low_count = self.all_count - self.high_count
|
||||
self._fix(
|
||||
f"поджатие: low+high>{ac} и low>high -> lowCount {lo}->{self.low_count} (лишние нули)"
|
||||
)
|
||||
elif self.low_count < self.high_count:
|
||||
self.high_count = self.all_count - self.low_count
|
||||
self._fix(
|
||||
f"поджатие: low+high>{ac} и low<high -> highCount {hi}->{self.high_count} (лишние единицы)"
|
||||
)
|
||||
elif self.low_count == self.high_count:
|
||||
invert_err = True
|
||||
self.errors_other += self.all_count
|
||||
self._fix(
|
||||
f"поджатие: low==high при low+high>{ac} -> invertErr (последний из low-цикла пишется как 1)"
|
||||
)
|
||||
i = 0
|
||||
while i < self.low_count and (8 - i):
|
||||
if i == self.low_count - 1 and invert_err:
|
||||
invert_err = False
|
||||
self.write_to_buffer(1)
|
||||
else:
|
||||
self.write_to_buffer(0)
|
||||
i += 1
|
||||
i = 0
|
||||
while i < self.high_count and (8 - i):
|
||||
if i == self.high_count - 1 and invert_err:
|
||||
invert_err = False
|
||||
self.write_to_buffer(0)
|
||||
else:
|
||||
self.write_to_buffer(1)
|
||||
i += 1
|
||||
|
||||
|
||||
def timing_stats(edges: List[EdgeRec]) -> None:
|
||||
dts: List[int] = []
|
||||
for i in range(1, len(edges)):
|
||||
d = edges[i].t_us - edges[i - 1].t_us
|
||||
if 0 <= d < 1_000_000:
|
||||
dts.append(d)
|
||||
if not dts:
|
||||
print("Нет интервалов для статистики.")
|
||||
return
|
||||
dts.sort()
|
||||
def pct(p: float) -> int:
|
||||
return dts[int(len(dts) * p)]
|
||||
print("--- Inter-edge deltas in log (us) ---")
|
||||
print(f" N={len(dts)} min={dts[0]} p50={pct(0.5)} p90={pct(0.9)} max={dts[-1]}")
|
||||
print(
|
||||
f" bitTime(ref)~{BIT_TIME} us aroundRise window ({rise_time_min(BIT_TIME)}..{rise_time_max(BIT_TIME)}) us"
|
||||
)
|
||||
# грубые корзины
|
||||
buckets = [0, 0, 0, 0, 0]
|
||||
for d in dts:
|
||||
if d < 200:
|
||||
buckets[0] += 1
|
||||
elif d < 600:
|
||||
buckets[1] += 1
|
||||
elif d < 1200:
|
||||
buckets[2] += 1
|
||||
elif d < 3000:
|
||||
buckets[3] += 1
|
||||
else:
|
||||
buckets[4] += 1
|
||||
print(f" корзины [0-200) [200-600) [600-1200) [1200-3000) [3000+): {buckets}")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
ap = argparse.ArgumentParser(description="Симуляция IR decode по @IRF1v1 логу")
|
||||
ap.add_argument("logfile", nargs="?", default=None, help="Текстовый лог с @IRF1v1:")
|
||||
ap.add_argument("--include-skipped", action="store_true", help="Подмешивать фронты с SKIP_DECODE (обычно нет)")
|
||||
ap.add_argument("--max-events", type=int, default=80, help="Макс. событий FRAME_START/END в отчёте")
|
||||
ap.add_argument(
|
||||
"--no-color",
|
||||
action="store_true",
|
||||
help="Bez ANSI-tsvetov (ili zadajte NO_COLOR v okruzhenii)",
|
||||
)
|
||||
ap.add_argument(
|
||||
"-v",
|
||||
"--verbose",
|
||||
action="store_true",
|
||||
help="Podrobnyj vyvod: kazhdyj chistyj bit (aroundRise), otbrosy frontov; inache tolko svodka",
|
||||
)
|
||||
args = ap.parse_args()
|
||||
if not args.logfile:
|
||||
print("Укажите путь к логу, например: python tools/ir_decoder_sim.py ref/ISR_self_frontlog.txt")
|
||||
return 1
|
||||
text = open(args.logfile, "r", encoding="utf-8", errors="replace").read()
|
||||
raw_edges = parse_irf1_lines(text)
|
||||
edges = [e for e in raw_edges if args.include_skipped or not (e.flags & SKIP_DECODE_FLAG)]
|
||||
edges.sort(key=lambda e: (e.t_us, id(e)))
|
||||
print(f"Записей фронтов (после фильтра SKIP): {len(edges)} (всего распарсено: {len(raw_edges)})")
|
||||
timing_stats(edges)
|
||||
|
||||
dec = DecoderSim(verbose=args.verbose)
|
||||
for e in edges:
|
||||
to_us = ir_timeout_us(dec.rise_sync_time)
|
||||
if dec.is_recive and dec.last_edge_time > 0 and (e.t_us - dec.last_edge_time) > to_us * 2:
|
||||
dec.check_timeout(e.t_us)
|
||||
dec.tick_edge(e.t_us, e.level)
|
||||
|
||||
print("--- События декодера (первые N), пакеты разделены пустой строкой ---")
|
||||
slice_ev = dec.events[: args.max_events]
|
||||
first_packet = True
|
||||
use_color = _use_terminal_color() and not args.no_color
|
||||
for ev in slice_ev:
|
||||
head = ev.split("\n", 1)[0]
|
||||
if "PACKET_START" in head:
|
||||
if not first_packet:
|
||||
print()
|
||||
first_packet = False
|
||||
tone = _packet_event_tone(ev)
|
||||
if tone is not None:
|
||||
ok = tone == "ok"
|
||||
ev_out = _highlight_frame_end_payloads(ev, ok=ok, enabled=use_color)
|
||||
print(_colorize_block(ev_out, ok=ok, enabled=use_color))
|
||||
else:
|
||||
print(ev)
|
||||
if len(dec.events) > args.max_events:
|
||||
print(f"... всего событий: {len(dec.events)}")
|
||||
print(f"errors_other={dec.errors_other} wrong_pack_end={dec.is_wrong_pack} recive={dec.is_recive}")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Reference in New Issue
Block a user