DashyFox/IR-protocol
1
0
Fork 0
mirror of https://github.com/Show-maket/IR-protocol.git synced 2025-06-28 05:09:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor

Browse Source
This commit is contained in:
DashyFox
2024-02-19 15:45:11 +03:00
parent ba1d22ac29
commit e4aa7b47c5
4 changed files with 178 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
IR_Decoder.h
View File

@ -1,5 +1,6 @@
#pragma once
#include "IR_config.h"
#include "IR_Output.h"
//#define IRDEBUG
@ -26,182 +27,55 @@ class IR_Encoder;
class IR_Decoder : private IR_FOX {
friend IR_Encoder;
public:
uint16_t addrSelf;
uint16_t id;
Data gotData; /// @brief Контейнер с данными
Data gotRawData;
Accept gotAccept; /// @brief Контейнер с подтверждением
Request gotRequest; /// @brief Контейнер с запросом
RawTune gotTune; /// @brief Контейнер с информацией подстройки
const uint8_t isrPin; // Пин прерывания
//////////////////////////////////////////////////////////////////////////
/// @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();
void isr(); ///@brief Функция прерывания
void tick(); /// @brief Обработка приёмника, необходима для работы
// @return Буффер переполнился
bool isOverflow() { return isBufferOverflow; };
/// @brief Флаг приёма
/// @return Возвращает true, если происходит приём пакета
bool isReciving() { return isRecive; };
// @brief Слушатель для работы isReciving()
void listen();
//////////////////////////////////////////////////////////////////////////
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[dataByteSizeMax];
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;
memset(_data, 0, dataByteSizeMax);
memcpy(_data, ptr, min(len, dataByteSizeMax));
_msgType = _data[0];
ini();
_isAvaliable = true;
}
private:
virtual void ini();
public:
bool avaliable() { return _isAvaliable; };
uint8_t msgInfo() { return _msgType & IR_MASK_MSG_INFO; };
uint8_t msgType() { return (_msgType >> 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; // Флаг приёма
volatile bool isPreamb = 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: порядок приходящих битов
uint16_t addrWaitingFrom = 0; // Адрес, от кого ожидается подтверждение
uint16_t riseSyncTime = bitTime; // Подстраиваемое время бита в мкс
// bool HIGH_FIRST = true; //TODO: порядок приходящих битов
////////////////////////////////////////////////////////////////////////
void noFunc();
volatile uint8_t currentSubBufferIndex; // Счетчик текущей позиции во вспомогательном буфере фронтов/спадов
struct FrontStorage { // Структура для хранения времени и направления фронта/спада
@ -225,6 +99,7 @@ private:
/// @param crc Результат рассчёта crc (Выходной параметр)
/// @return true если crc верно
bool crcCheck(uint8_t len, uint16_t& crc);
////////////////////////////////////////////////////////////////////////
bool isData = true; // Флаг относится ли бит к данным, или битам синхронизации
uint16_t i_dataBuffer; // Счётчик буфера данных
@ -235,13 +110,12 @@ private:
/// @brief Запиь бита в буффер, а так же проверка битов синхранизации и их фильтрация
/// @param Бит данных
void writeToBuffer(bool);
void packToOutClass(uint8_t endBitOffset, uint8_t bytesToCheck, uint8_t addressForCheckOffset, InputData* objFine, InputData* objWrong = nullptr);
void packToOutClass(uint8_t endBitOffset, uint8_t bytesToCheck, uint8_t addressForCheckOffset, IDataPack* objFine, IDataPack* objWrong = nullptr);
////////////////////////////////////////////////////////////////////////
/// @brief Установка и сброс начальных значений и флагов в готовность к приёму данных
void start_RX();
/// @brief Целочисленное деление с округлением вверх
/// @param val Значение
/// @param divider Делитель
@ -254,4 +128,4 @@ private:
#endif
};
};