#pragma once #include "IR_config.h" //#define IRDEBUG #ifdef IRDEBUG #define wrHigh A3 // Запись HIGH инициирована // green #define wrLow A3 // Запись LOW инициирована // blue #define writeOp 13 // Операция записи, 1 пульс для 0 и 2 для 1 // orange // Исправленные ошибки // purle // 1 пульс: fix #define errOut A3 #endif ///////////////////////////////////////////////////////////////////////////////////////////////// #define riseTime riseSyncTime //* bitTime */ 893U // TODO: Должно высчитываться медианой #define riseTolerance tolerance /* 250U */ // погрешность #define riseTimeMax (riseTime + riseTolerance) #define riseTimeMin (riseTime - riseTolerance) #define aroundRise(t) (riseTimeMin < t && t < riseTimeMax) #define IR_timeout (riseTimeMax * (8 + syncBits +1)) // us // таймаут в 8 data + 3 sync + 1 class IR_Encoder; class IR_Decoder : private IR_FOX { friend IR_Encoder; public: uint16_t addrSelf; /// @brief Конструктор /// @param isrPin Номер вывода прерывания/данных от приёмника (2 или 3 для atmega 328p) /// @param addr Адрес приёмника /// @param encPair Указатель на передатчик, работающий в паре IR_Decoder(const uint8_t isrPin, uint16_t addr, IR_Encoder* encPair = nullptr); ~IR_Decoder(); // @brief Функция прерывания void isr(); /// @brief Обработка приёмника, необходима для работы void tick(); // @return Буффер переполнился bool isOverflow() { return isBufferOverflow; }; /// @brief Флаг приёма /// @return Возвращает true, если происходит приём пакета bool isReciving() { return isRecive; }; // @brief Слушатель для работы isReciving() void listen(); ////////////////////////////////////////////////////////////////////////// struct ErrorsStruct { uint8_t lowSignal; uint8_t highSignal; uint8_t other; void reset() { lowSignal = 0; highSignal = 0; other = 0; } uint16_t all() { return lowSignal + highSignal + other; } } errors; public: class InputData : protected IR_FOX { friend IR_Decoder; protected: bool _isAvaliable = false; uint8_t _msgType = 0; uint16_t _addrFrom = 0; uint16_t _addrTo = 0; uint8_t _data[bytePerPack]; uint8_t _dataRawSize = 0; uint16_t _crcPackVal = 0; uint16_t _crcCalcVal = 0; ErrorsStruct _err; uint16_t _bitPeriod = 0; void _set(uint8_t* ptr, uint8_t len, uint16_t crc, ErrorsStruct err, uint16_t rTime) { _crcCalcVal = crc; _dataRawSize = len; _err = err; _bitPeriod = rTime; for (uint8_t i = 0; i < len && len> 5) & IR_MASK_MSG_TYPE; }; uint8_t msgRAW() { return _msgType; }; uint16_t errorCount() { return _err.all(); }; uint8_t errorLowSignal() { return _err.lowSignal; }; uint8_t errorHighSignal() { return _err.highSignal; }; uint8_t errorOther() { return _err.other; }; uint16_t crcIN() { return _crcPackVal; }; uint16_t crcCALC() { return _crcCalcVal; }; uint16_t tunerTime() { return _bitPeriod; }; void resetAvaliable() { _isAvaliable = false; }; }; ////////////////////////////////////////////////////////////////////////// class Data : public InputData { public: uint16_t addrFrom() { return _addrFrom; }; uint16_t addrTo() { return _addrTo; }; uint8_t dataSize() { return _dataRawSize - (msgBytes + addrBytes + addrBytes + crcBytes); }; uint8_t* data() { return &_data[msgBytes + addrBytes + addrBytes]; }; uint8_t dataRawSize() { return _dataRawSize; }; uint8_t* dataRaw() { return _data; }; bool isNeedAccept() { return ((_msgType >> 5) & IR_MASK_MSG_TYPE) == IR_MSG_DATA_ACCEPT; }; String printRawData(uint8_t mode = 10) { return printBytes(dataRaw(), dataRawSize(), mode); } String printData(uint8_t mode = 10) { return printBytes(data(), dataSize(), mode); } ~Data() {}; private: void ini() override { _addrFrom = (_data[1] << 8) | _data[2]; _addrTo = (_data[3] << 8) | _data[4]; _crcPackVal = (_data[_dataRawSize - 2] << 8) | _data[_dataRawSize - 1]; } }; // class RawData : public Data { // }; class Accept : public InputData { public: uint16_t addrFrom() { return _addrFrom; }; private: void ini() override { _addrFrom = (_data[1] << 8) | _data[2]; _crcPackVal = (_data[3] << 8) | _data[4]; } }; class Request : public Accept { public: uint16_t addrTo() { return _addrTo; }; private: void ini() override { _addrFrom = (_data[1] << 8) | _data[2]; _addrTo = (_data[3] << 8) | _data[4]; _crcPackVal = (_data[5] << 8) | _data[6]; } }; class RawTune { friend IR_Decoder; private: bool _isAvaliable = false; uint16_t _errCount = 0; uint16_t _tune = 0; public: bool avaliable() { return _isAvaliable; }; uint16_t getTune() { return _tune; }; uint16_t errorCount() { return _errCount; }; void resetAvaliable() { _isAvaliable = false; }; private: void _set(uint16_t val) { _tune = val; _isAvaliable = true; } }; /// @brief Контейнер с данными Data gotData; Data gotRawData; /// @brief Контейнер с подтверждением Accept gotAccept; /// @brief Контейнер с запросом Request gotRequest; /// @brief Контейнер с информацией подстройки RawTune gotTune; const uint8_t isrPin; // Пин прерывания private: IR_Encoder* encoder; // Указатель на парный передатчик volatile uint16_t isPairSending = 0; // Флаг передачи парного передатчика volatile bool isRecive = false; // Флаг приёма bool isWaitingAccept = false; // Флаг ожидания подтверждения uint16_t addrWaitingFrom = 0; // Адрес, от кого ожидается подтверждение uint16_t riseSyncTime = bitTime; // Подстраиваемое время бита в мкс bool isCrcCorrect = false; // Флаг корректности crc bool isBufferOverflow = false; // Флаг переполнения буффера данных bool isWrongPack = false; // Флаг битого пакета volatile bool isPreamb = false; // флаг начальной последовости bool HIGH_FIRST = true; //TODO: порядок приходящих битов //////////////////////////////////////////////////////////////////////// void noFunc(); volatile uint8_t currentSubBufferIndex; // Счетчик текущей позиции во вспомогательном буфере фронтов/спадов struct FrontStorage { // Структура для хранения времени и направления фронта/спада volatile uint32_t time = 0; // Время volatile bool dir = false; // Направление (true = ↑; false = ↓) volatile FrontStorage* next = nullptr; // Указатель на следующий связанный фронт/спад, или nullptr если конец }; volatile FrontStorage* lastFront = nullptr; // Указатель последнего фронта/спада volatile FrontStorage* firstUnHandledFront = nullptr; // Указатель первого необработанного фронта/спада volatile FrontStorage subBuffer[subBufferSize]; // вспомогательный буфер для хранения необработанных фронтов/спадов //////////////////////////////////////////////////////////////////////// uint8_t* dataBuffer = nullptr; // Указатель на буффер данных uint32_t prevRise, prevPrevRise, prevFall, prevPrevFall; // Время предыдущих фронтов/спадов uint16_t errorCounter = 0; // Счётчик ошибок int8_t preambFrontCounter = 0; // Счётчик __/``` ↑ преамбулы int16_t bufBitPos = 0; // Позиция для записи бита в буффер private: /// @brief Проверка CRC. Проверяет len байт со значением crc, пришедшим в пакете /// @param len Длина в байтах проверяемых данных /// @param crc Результат рассчёта crc (Выходной параметр) /// @return true если crc верно bool crcCheck(uint8_t len, uint16_t& crc); //////////////////////////////////////////////////////////////////////// bool isData = true; // Флаг относится ли бит к данным, или битам синхронизации uint16_t i_dataBuffer; // Счётчик буфера данных uint8_t nextControlBit = bitPerByte; // Метка для смены флага isData uint8_t i_syncBit; // Счётчик битов синхронизации uint8_t err_syncBit; // Счётчик ошибок синхронизации /// @brief Запиь бита в буффер, а так же проверка битов синхранизации и их фильтрация /// @param Бит данных void writeToBuffer(bool); void packToOutClass(uint8_t endBitOffset, uint8_t bytesToCheck, uint8_t addressForCheckOffset, InputData* objFine, InputData* objWrong = nullptr); //////////////////////////////////////////////////////////////////////// /// @brief Установка и сброс начальных значений и флагов в готовность к приёму данных void start_RX(); /// @brief Целочисленное деление с округлением вверх /// @param val Значение /// @param divider Делитель /// @return Результат uint16_t ceil_div(uint16_t val, uint16_t divider); #ifdef IRDEBUG inline void errPulse(uint8_t pin, uint8_t count); inline void infoPulse(uint8_t pin, uint8_t count); #endif };