DashyFox/IR-protocol
1
0
Fork 0
mirror of https://github.com/Show-maket/IR-protocol.git synced 2025-05-04 07:10:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor

Browse Source
This commit is contained in:
DashyFox 2024-04-23 13:35:49 +03:00
parent 06d27f2590
commit e951111c53
11 changed files with 443 additions and 502 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

152
IR-protocol.ino
View File

@ -7,14 +7,36 @@
#define encForward_PIN PA0
#define encBackward_PIN PA1
#define dec1_PIN PB0
#define dec2_PIN PB1
#define dec0_PIN PB0
#define dec1_PIN PB1
#define dec2_PIN PA2
#define dec3_PIN PB3
#define dec4_PIN PB4
#define dec5_PIN PB5
#define dec6_PIN PB6
#define dec7_PIN PB7
#define dec8_PIN PB8
#define dec9_PIN PB9
#define dec10_PIN PB10
#define dec11_PIN PB11
#define dec12_PIN PB12
#define dec13_PIN PB13
#define dec14_PIN PB14
#define dec15_PIN PB15
#define LoopOut PA7
// #define TestOut 13
#define dec_ISR(n) \
void dec_##n##_ISR() { dec##n.isr(); }
#define dec_Ini(n) \
IR_Decoder dec##n(dec##n##_PIN, n); \
dec_ISR(n)
#define SignalDetectLed PA6
#define decPinMode(n) pinMode(dec##n##_PIN, INPUT_PULLUP);
#define decAttach(n) attachInterrupt(dec##n##_PIN, dec_##n##_ISR, CHANGE);
#define decSetup(n) /* decPinMode(n); */ decAttach(n);
#define decTick(n) dec##n.tick();
#define decStat(n) rx_flag |= statusSimple(dec##n);
//////////////// Ini /////////////////
@ -23,43 +45,35 @@
//////////////// Var /////////////////
IR_Decoder decForward(dec1_PIN, 555);
IR_Decoder decBackward(dec2_PIN, 777);
IR_Encoder encForward(42 /* , &decBackward */);
IR_Encoder encForward(PA5, 42 /* , &decBackward */);
// IR_Encoder encBackward(321, encBackward_PIN);
// IR_Encoder encTree(325, A2);
//////////////////////// Функции прерываний ////////////////////////
void decForwardISR()
{
decForward.isr();
// Serial.println("ISR");
}
void decBackwardISR()
{
decBackward.isr();
// Serial.println("ISR");
}
static uint8_t *portOut;
void EncoderISR()
{
encForward.isr();
// encBackward.isr();
// encTree.isr();
// TODO: Сделать выбор порта
// *portOut = (*portOut & 0b11001111) |
// (
// encForward.ir_out_virtual << 5U
// // | encBackward.ir_out_virtual << 6U
// // | encTree.ir_out_virtual << 2U
// );
digitalWrite(PB5, encForward.ir_out_virtual);
// Serial.println("EncoderISR");
IR_Encoder::isr();
}
//-------------------------------------------------------------------
dec_Ini(0);
dec_Ini(1);
dec_Ini(2);
dec_Ini(3);
dec_Ini(4);
dec_Ini(5);
dec_Ini(6);
dec_Ini(7);
dec_Ini(8);
dec_Ini(9);
dec_Ini(10);
dec_Ini(11);
dec_Ini(12);
dec_Ini(13);
/////////////////////////////////////////////////////////////////////
uint8_t data0[] = {};
uint8_t data1[] = {42};
@ -159,39 +173,44 @@ Timer t1(500, millis, []()
Timer signalDetectTimer;
/////////////////////////////////////////////////////////////////////
HardwareTimer IR_Timer(TIM3);
HardwareTimer MicrosTimer(TIM1);
void MicrosTimerISR(){
}
void setup()
{
// MicrosTimer.setOve
IR_Timer.setOverflow(carrierFrec*2, HERTZ_FORMAT);
IR_Timer.setOverflow(carrierFrec * 2, HERTZ_FORMAT);
IR_Timer.attachInterrupt(1, EncoderISR);
IR_Timer.resume();
Serial.begin(SERIAL_SPEED);
Serial.println(F(INFO));
pinMode(LoopOut, OUTPUT);
pinMode(SignalDetectLed, OUTPUT);
// pinMode(SignalDetectLed, OUTPUT);
pinMode(dec1_PIN, INPUT_PULLUP);
// pinMode(dec2_PIN, INPUT_PULLUP);
pinMode(encForward_PIN, OUTPUT);
pinMode(encBackward_PIN, OUTPUT);
pinMode(LED_BUILTIN, OUTPUT);
// IR_DecoderRaw* blindFromForward [] { &decForward, &decBackward };
// encForward.setBlindDecoders(blindFromForward, sizeof(blindFromForward) / sizeof(IR_DecoderRaw*));
attachInterrupt(dec1_PIN, decForwardISR, CHANGE); // D2
// attachInterrupt(dec2_PIN, decBackwardISR, CHANGE); // D3
decSetup(0);
decSetup(1);
decSetup(2);
decSetup(3);
decSetup(4);
decSetup(5);
decSetup(6);
decSetup(7);
decSetup(8);
decSetup(9);
decSetup(10);
decSetup(11);
decSetup(12);
decSetup(13);
}
void loop()
@ -199,10 +218,25 @@ void loop()
digitalToggle(LoopOut);
Timer::tick();
decForward.tick();
decBackward.tick();
IR_Decoder::tick();
status(decForward);
bool rx_flag;
decStat(0);
decStat(1);
decStat(2);
decStat(3);
decStat(4);
decStat(5);
decStat(6);
decStat(7);
decStat(8);
decStat(9);
decStat(10);
decStat(11);
decStat(12);
decStat(13);
// status(decForward);
// status(decBackward);
// Serial.println(micros() - loopTimer);
@ -230,12 +264,28 @@ void loop()
}
}
}
Timer statusSimpleDelay;
bool statusSimple(IR_Decoder &dec)
{
bool ret;
if (ret = dec.gotData.available())
{
Serial.print("DEC: ");
Serial.print(dec.getId());
Serial.print(" err: ");
Serial.print(dec.gotData.getErrorCount());
Serial.print("\n");
statusSimpleDelay.delay(100, millis, []()
{ Serial.print("\n\n\n\n"); });
}
return ret;
}
void detectSignal()
{
digitalWrite(SignalDetectLed, HIGH);
signalDetectTimer.delay(50, millis, []()
{ digitalWrite(SignalDetectLed, LOW); });
// digitalWrite(SignalDetectLed, HIGH);
// signalDetectTimer.delay(50, millis, []()
// { digitalWrite(SignalDetectLed, LOW); });
}
// test

72
IR_Decoder.cpp Normal file
View File

@ -0,0 +1,72 @@
#include "IR_Decoder.h"
std::list<IR_Decoder*>& IR_Decoder::get_dec_list() // определение функции
{
static std::list<IR_Decoder*> dec_list; // статическая локальная переменная
return dec_list; // возвращается ссылка на переменную
}
IR_Decoder::IR_Decoder(const uint8_t isrPin, uint16_t addr, IR_Encoder *encPair)
: IR_DecoderRaw(isrPin, addr, encPair)
{
get_dec_list().push_back(this);
};
IR_Decoder::~IR_Decoder()
{
IR_Decoder::get_dec_list().remove(this);
}
void IR_Decoder::tick()
{
for (const auto &element : IR_Decoder::get_dec_list())
{
element->_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)
{
case IR_MSG_DATA_ACCEPT:
case IR_MSG_DATA_NOACCEPT:
gotData.set(&packInfo, id);
break;
case IR_MSG_BACK:
case IR_MSG_BACK_TO:
gotBackData.set(&packInfo, id);
break;
case IR_MSG_REQUEST:
gotRequest.set(&packInfo, id);
break;
case IR_MSG_ACCEPT:
gotAccept.set(&packInfo, id);
break;
default:
break;
}
if (gotData.isAvailable && (gotData.getMsgType() == IR_MSG_DATA_ACCEPT))
{
acceptSendTimer = millis();
addrAcceptSendTo = gotData.getAddrFrom();
acceptCustomByte = crc8(gotData.getDataPrt(), 0, gotData.getDataSize(), poly1);
if (addrAcceptSendTo && addrAcceptSendTo < IR_Broadcast)
isWaitingAcceptSend = true;
}
gotRaw.set(&packInfo, id);
}
if (isWaitingAcceptSend && millis() - acceptSendTimer > 75)
{
encoder->sendAccept(addrAcceptSendTo, acceptCustomByte);
isWaitingAcceptSend = false;
}
}

58
IR_Decoder.h
View File

@ -5,6 +5,11 @@
class IR_Decoder : public IR_DecoderRaw
{
private:
// static std::list<IR_Decoder *> dec_list;
static std::list<IR_Decoder*>& get_dec_list();
void _tick();
uint32_t acceptSendTimer;
bool isWaitingAcceptSend;
uint16_t addrAcceptSendTo;
@ -19,59 +24,16 @@ public:
PacketTypes::Request gotRequest;
PacketTypes::BasePack gotRaw;
IR_Decoder(const uint8_t isrPin, uint16_t addr, IR_Encoder *encPair = nullptr) : IR_DecoderRaw(isrPin, addr, encPair) {}
IR_Decoder(const uint8_t isrPin, uint16_t addr, IR_Encoder *encPair = nullptr);
~IR_Decoder();
void 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)
{
case IR_MSG_DATA_ACCEPT:
case IR_MSG_DATA_NOACCEPT:
gotData.set(&packInfo, id);
break;
case IR_MSG_BACK:
case IR_MSG_BACK_TO:
gotBackData.set(&packInfo, id);
break;
case IR_MSG_REQUEST:
gotRequest.set(&packInfo, id);
break;
case IR_MSG_ACCEPT:
gotAccept.set(&packInfo, id);
break;
static void tick();
default:
break;
}
if (gotData.isAvailable && (gotData.getMsgType() == IR_MSG_DATA_ACCEPT))
{
acceptSendTimer = millis();
addrAcceptSendTo = gotData.getAddrFrom();
acceptCustomByte = crc8(gotData.getDataPrt(), 0, gotData.getDataSize(), poly1);
if (addrAcceptSendTo && addrAcceptSendTo < IR_Broadcast)
isWaitingAcceptSend = true;
}
gotRaw.set(&packInfo, id);
}
if (isWaitingAcceptSend && millis() - acceptSendTimer > 75)
{
encoder->sendAccept(addrAcceptSendTo, acceptCustomByte);
isWaitingAcceptSend = false;
}
}
void setAcceptDelay(uint16_t acceptDelay)
inline void setAcceptDelay(uint16_t acceptDelay)
{
this->acceptDelay = acceptDelay;
}
uint16_t getAcceptDelay()
inline uint16_t getAcceptDelay()
{
return this->acceptDelay;
}

33
IR_DecoderRaw.cpp
View File

@ -20,6 +20,27 @@ IR_DecoderRaw::IR_DecoderRaw(const uint8_t isrPin, uint16_t addr, IR_Encoder *en
#endif
}
bool IR_DecoderRaw::isSubOverflow()
{
noInterrupts();
volatile bool ret = isSubBufferOverflow;
interrupts();
return ret;
}
bool IR_DecoderRaw::availableRaw()
{
if (isAvailable)
{
isAvailable = false;
return true;
}
else
{
return false;
}
};
//////////////////////////////////// isr ///////////////////////////////////////////
volatile uint32_t time_;
@ -55,7 +76,6 @@ void IR_DecoderRaw::isr()
////////////////////////////////////////////////////////////////////////////////////
uint32_t wrCounter;
void IR_DecoderRaw::firstRX()
{
@ -77,9 +97,9 @@ void IR_DecoderRaw::firstRX()
isPreamb = true;
riseSyncTime = bitTime /* 1100 */;
#ifdef IRDEBUG
wrCounter = 0;
#endif
memset(dataBuffer, 0x00, dataByteSizeMax);
}
@ -92,6 +112,7 @@ void IR_DecoderRaw::listenStart()
firstRX();
}
}
void IR_DecoderRaw::tick()
{
FrontStorage currentFront;
@ -540,7 +561,7 @@ void IR_DecoderRaw::writeToBuffer(bool bit)
#ifdef BRUTEFORCE_CHECK
if (!isAvailable) // Исправление первого бита // Очень большая затычка...
for (size_t i = 0; i < min(uint16_t(packSize - crcBytes*2U), uint16_t(dataByteSizeMax)); ++i)
for (size_t i = 0; i < min(uint16_t(packSize - crcBytes * 2U), uint16_t(dataByteSizeMax)); ++i)
{
for (int j = 0; j < 8; ++j)
{
@ -552,9 +573,9 @@ void IR_DecoderRaw::writeToBuffer(bool bit)
if (isAvailable)
{
#ifdef IRDEBUG_INFO
#ifdef IRDEBUG_INFO
Serial.println("!!!INV!!!");
#endif
#endif
goto OUT_BRUTEFORCE;
}
else

30
IR_DecoderRaw.h
View File

@ -34,18 +34,7 @@ class IR_DecoderRaw : virtual public IR_FOX
protected:
PackInfo packInfo;
IR_Encoder *encoder; // Указатель на парный передатчик
bool availableRaw()
{
if (isAvailable)
{
isAvailable = false;
return true;
}
else
{
return false;
}
};
bool availableRaw();
public:
const uint8_t isrPin; // Пин прерывания
@ -59,18 +48,10 @@ public:
void isr(); // Функция прерывания
void tick(); // Обработка приёмника, необходима для работы
void tickOld();
bool isOverflow() { return isBufferOverflow; }; // Буффер переполнился
bool isSubOverflow()
{
// noInterrupts();
volatile bool ret = isSubBufferOverflow;
// interrupts();
return ret;
};
bool isReciving() { return isBufferOverflow; }; // Возвращает true, если происходит приём пакета
inline bool isOverflow() { return isBufferOverflow; }; // Буффер переполнился
bool isSubOverflow();
inline bool isReciving() { return isBufferOverflow; }; // Возвращает true, если происходит приём пакета
//////////////////////////////////////////////////////////////////////////
private:
@ -150,7 +131,8 @@ private:
/// @return Результат
uint16_t ceil_div(uint16_t val, uint16_t divider);
#if true //def IRDEBUG
#ifdef IRDEBUG
uint32_t wrCounter;
inline void errPulse(uint8_t pin, uint8_t count);
inline void infoPulse(uint8_t pin, uint8_t count);
#endif

53
IR_Encoder.cpp
View File

@ -5,8 +5,15 @@
#define ISR_Out 10
#define TestOut 13
IR_Encoder::IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair)
std::list<IR_Encoder*>& IR_Encoder::get_enc_list() // определение функции
{
static std::list<IR_Encoder*> dec_list; // статическая локальная переменная
return dec_list; // возвращается ссылка на переменную
}
IR_Encoder::IR_Encoder(uint8_t pin, uint16_t addr, IR_DecoderRaw *decPair)
{
this->pin = pin;
id = addr;
this->decPair = decPair;
signal = noSignal;
@ -23,7 +30,10 @@ IR_Encoder::IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair)
{
decPair->encoder = this;
}
pinMode(pin,OUTPUT);
get_enc_list().push_back(this);
};
void IR_Encoder::setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count)
{
#if disablePairDec
@ -38,6 +48,7 @@ IR_Encoder::~IR_Encoder()
{
delete[] bitLow;
delete[] bitHigh;
get_enc_list().remove(this);
};
void IR_Encoder::sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept)
@ -141,6 +152,7 @@ void IR_Encoder::sendBack(uint8_t data)
{
_sendBack(false, 0, &data, 1);
}
void IR_Encoder::sendBack(uint8_t *data , uint8_t len)
{
_sendBack(false, 0, data, len);
@ -230,12 +242,21 @@ void IR_Encoder::rawSend(uint8_t *ptr, uint8_t len)
// interrupts();
}
void IR_Encoder::isr()
void IR_Encoder::isr(){
// Serial.println(get_enc_list().size());
for(const auto &element : get_enc_list()){
element->_isr();
}
}
void IR_Encoder::_isr()
{
if (!isSending)
return;
ir_out_virtual = !ir_out_virtual && state;
digitalWrite(pin, ir_out_virtual);
if (toggleCounter)
{
@ -369,34 +390,6 @@ void IR_Encoder::addSync(bool *prev, bool *next)
}
}
void IR_Encoder::send_HIGH(bool prevBite)
{
// if (/* prevBite */1) {
// meanderBlock(bitPauseTakts * 2, halfPeriod, LOW);
// meanderBlock(bitActiveTakts, halfPeriod, HIGH);
// } else { // более короткий HIGH после нуля
// meanderBlock(bitTakts - (bitActiveTakts - bitPauseTakts), halfPeriod, LOW);
// meanderBlock(bitActiveTakts - bitPauseTakts, halfPeriod, HIGH);
// }
}
void IR_Encoder::send_LOW()
{
// meanderBlock(bitPauseTakts, halfPeriod, LOW);
// meanderBlock(bitActiveTakts, halfPeriod, LOW);
// meanderBlock(bitPauseTakts, halfPeriod, HIGH);
}
void IR_Encoder::send_EMPTY(uint8_t count)
{
// for (size_t i = 0; i < count * 2; i++) {
// meanderBlock((bitPauseTakts * 2 + bitActiveTakts), halfPeriod, prevPreambBit);
// prevPreambBit = !prevPreambBit;
// }
// meanderBlock(bitPauseTakts * 2 + bitActiveTakts, halfPeriod, 0); //TODO: Отодвинуть преамбулу
}
uint8_t* IR_Encoder::bitHigh = new uint8_t[2]{
(bitPauseTakts) * 2 - 1,
(bitActiveTakts) * 2 - 1};

35
IR_Encoder.h
View File

@ -11,40 +11,14 @@ class IR_Encoder : IR_FOX
public:
private:
uint16_t id; /// @brief Адрес передатчика
uint8_t pin;
public:
/// @brief Класс передатчика
/// @param addr Адрес передатчика
/// @param pin Вывод передатчика
/// @param tune Подстройка несущей частоты
/// @param decPair Приёмник, для которого отключается приём в момент передачи передатчиком
IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair = nullptr);
// static void timerSetup()
// {
// // // TIMER2 Ini
// // uint8_t oldSREG = SREG; // Save global interupts settings
// // cli();
// // // DDRB |= (1 << PORTB3); //OC2A (17)
// // TCCR2A = 0;
// // TCCR2B = 0;
// // // TCCR2A |= (1 << COM2A0); //Переключение состояния
// // TCCR2A |= (1 << WGM21); // Clear Timer On Compare (Сброс по совпадению)
// // TCCR2B |= (1 << CS20); // Предделитель 1
// // TIMSK2 |= (1 << OCIE2A); // Прерывание по совпадению
// // OCR2A = /* 465 */ ((F_CPU / (38000 * 2)) - 2); // 38кГц
// // SREG = oldSREG; // Return interrupt settings
// }
// static void timerOFFSetup()
// {
// TIMSK2 &= ~(1 << OCIE2A); // Прерывание по совпадению выкл
// }
IR_Encoder(uint8_t pin, uint16_t addr, IR_DecoderRaw *decPair = nullptr);
static void isr();
void setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count);
void rawSend(uint8_t *ptr, uint8_t len);
@ -59,13 +33,14 @@ public:
void sendBack(uint8_t *data = nullptr, uint8_t len = 0);
void sendBackTo(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0);
void isr();
~IR_Encoder();
volatile bool ir_out_virtual;
private:
static std::list<IR_Encoder*>& get_enc_list();
void _sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len);
void _isr();
void setDecoder_isSending();
void sendByte(uint8_t byte, bool *prev, bool LOW_FIRST);

27
IR_config.cpp Normal file
View File

@ -0,0 +1,27 @@
#include "IR_config.h"
void IR_FOX::checkAddressRuleApply(uint16_t address, uint16_t id, bool &flag)
{
flag = false;
flag |= id == 0;
flag |= address == id;
flag |= address >= IR_Broadcast;
}
uint8_t IR_FOX::crc8(uint8_t *data, uint8_t start, uint8_t end, uint8_t poly)
{ // TODO: сделать возможность межбайтовой проверки
uint8_t crc = 0xff;
size_t i, j;
for (i = start; i < end; i++)
{
crc ^= data[i];
for (j = 0; j < 8; j++)
{
if ((crc & 0x80) != 0)
crc = (uint8_t)((crc << 1) ^ poly);
else
crc <<= 1;
}
}
return crc;
};

36
IR_config.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <Arduino.h>
#define IRDEBUG_INFO
#include <list>
// #define IRDEBUG_INFO
/*//////////////////////////////////////////////////////////////////////////////////////
Для работы в паре положить декодер в энкодер
@ -140,8 +140,12 @@ typedef uint16_t crc_t;
#define bitTakts (bitActiveTakts+bitPauseTakts) // Общая длительность бита в тактах
#define bitTime (bitTakts*carrierPeriod) // Общая длительность бита
#define tolerance 300U
class IR_FOX {
public:
struct PackOffsets {
uint8_t msgOffset;
uint8_t addrFromOffset;
@ -172,32 +176,14 @@ public:
uint16_t rTime = 0;
};
static void checkAddressRuleApply(uint16_t address, uint16_t id, bool& flag) {
flag = false;
flag |= id == 0;
flag |= address == id;
flag |= address >= IR_Broadcast;
}
uint16_t getId() { return id; }
void setId(uint16_t id) { this->id = id; }
inline uint16_t getId() { return id; }
inline void setId(uint16_t id) { this->id = id; }
static void checkAddressRuleApply(uint16_t address, uint16_t id, bool& flag);
protected:
ErrorsStruct errors;
uint16_t id;
uint8_t crc8(uint8_t* data, uint8_t start, uint8_t end, uint8_t poly) { //TODO: сделать возможность межбайтовой проверки
uint8_t crc = 0xff;
size_t i, j;
for (i = start; i < end; i++) {
crc ^= data[i];
for (j = 0; j < 8; j++) {
if ((crc & 0x80) != 0)
crc = (uint8_t)((crc << 1) ^ poly);
else
crc <<= 1;
}
}
return crc;
}
ErrorsStruct errors;
uint8_t crc8(uint8_t* data, uint8_t start, uint8_t end, uint8_t poly);
};

107
PacketTypes.cpp Normal file
View File

@ -0,0 +1,107 @@
#include "PacketTypes.h"
namespace PacketTypes
{
bool BasePack::checkAddress() { return true; };
void BasePack::set(IR_FOX::PackInfo *packInfo, uint16_t id)
{
this->packInfo = packInfo;
this->id = id;
if (checkAddress())
{
isAvailable = true;
isRawAvailable = true;
#ifdef IRDEBUG_INFO
Serial.print(" OK ");
#endif
}
else
{
isRawAvailable = true;
#ifdef IRDEBUG_INFO
Serial.print(" NOT-OK ");
#endif
}
}
uint16_t BasePack::_getAddrFrom(BasePack *obj)
{
return (obj->packInfo->buffer[obj->addressFromOffset] << 8) | obj->packInfo->buffer[obj->addressFromOffset + 1];
};
uint16_t BasePack::_getAddrTo(BasePack *obj)
{
return (obj->packInfo->buffer[obj->addressToOffset] << 8) | obj->packInfo->buffer[obj->addressToOffset + 1];
};
uint8_t BasePack::_getDataSize(BasePack *obj)
{
return obj->packInfo->packSize - crcBytes - obj->DataOffset;
};
uint8_t *BasePack::_getDataPrt(BasePack *obj)
{
return obj->packInfo->buffer + obj->DataOffset;
};
uint8_t BasePack::_getDataRawSize(BasePack *obj)
{
return obj->packInfo->packSize;
};
bool BasePack::available()
{
if (isAvailable)
{
isAvailable = false;
isRawAvailable = false;
return true;
}
else
{
return false;
}
};
bool BasePack::availableRaw()
{
if (isRawAvailable)
{
isRawAvailable = false;
return true;
}
else
{
return false;
}
};
bool Data::checkAddress()
{
bool ret;
IR_FOX::checkAddressRuleApply(getAddrTo(), this->id, ret);
return ret;
}
bool DataBack::checkAddress()
{
bool ret;
if (getMsgType() == IR_MSG_BACK_TO)
{
DataOffset = 5;
IR_FOX::checkAddressRuleApply((packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1], this->id, ret);
}
else
{
DataOffset = 3;
ret = true;
}
return ret;
}
bool Accept::checkAddress() { return true; }
bool Request::checkAddress()
{
bool ret;
IR_FOX::checkAddressRuleApply(getAddrTo(), this->id, ret);
return ret;
}
}

308
PacketTypes.h
View File

@ -21,86 +21,28 @@ namespace PacketTypes
IR_FOX::PackInfo *packInfo;
uint16_t id;
virtual bool checkAddress() { return true; };
void set(IR_FOX::PackInfo *packInfo, uint16_t id)
{
this->packInfo = packInfo;
this->id = id;
virtual bool checkAddress();
void set(IR_FOX::PackInfo *packInfo, uint16_t id);
if (checkAddress())
{
isAvailable = true;
isRawAvailable = true;
#ifdef IRDEBUG_INFO
Serial.print(" OK ");
#endif
}
else
{
isRawAvailable = true;
#ifdef IRDEBUG_INFO
Serial.print(" NOT-OK ");
#endif
}
}
static uint16_t _getAddrFrom(BasePack *obj)
{
return (obj->packInfo->buffer[obj->addressFromOffset] << 8) | obj->packInfo->buffer[obj->addressFromOffset + 1];
};
static uint16_t _getAddrTo(BasePack *obj)
{
return (obj->packInfo->buffer[obj->addressToOffset] << 8) | obj->packInfo->buffer[obj->addressToOffset + 1];
};
static uint8_t _getDataSize(BasePack *obj)
{
return obj->packInfo->packSize - crcBytes - obj->DataOffset;
};
static uint8_t *_getDataPrt(BasePack *obj)
{
return obj->packInfo->buffer + obj->DataOffset;
};
static uint8_t _getDataRawSize(BasePack *obj)
{
return obj->packInfo->packSize;
};
static uint16_t _getAddrFrom(BasePack *obj);
static uint16_t _getAddrTo(BasePack *obj);
static uint8_t _getDataSize(BasePack *obj);
static uint8_t *_getDataPrt(BasePack *obj);
static uint8_t _getDataRawSize(BasePack *obj);
public:
bool available()
{
if (isAvailable)
{
isAvailable = false;
isRawAvailable = false;
return true;
}
else
{
return false;
}
};
bool availableRaw()
{
if (isRawAvailable)
{
isRawAvailable = false;
return true;
}
else
{
return false;
}
};
uint8_t getMsgInfo() { return packInfo->buffer[0] & IR_MASK_MSG_INFO; };
uint8_t getMsgType() { return (packInfo->buffer[0] >> 5) & IR_MASK_MSG_TYPE; };
uint8_t getMsgRAW() { return packInfo->buffer[0]; };
uint16_t getErrorCount() { return packInfo->err.all(); };
uint8_t getErrorLowSignal() { return packInfo->err.lowSignal; };
uint8_t getErrorHighSignal() { return packInfo->err.highSignal; };
uint8_t getErrorOther() { return packInfo->err.other; };
uint16_t getTunerTime() { return packInfo->rTime; };
uint8_t *getDataRawPtr() { return packInfo->buffer; };
bool available();
bool availableRaw();
inline uint8_t getMsgInfo() { return packInfo->buffer[0] & IR_MASK_MSG_INFO; };
inline uint8_t getMsgType() { return (packInfo->buffer[0] >> 5) & IR_MASK_MSG_TYPE; };
inline uint8_t getMsgRAW() { return packInfo->buffer[0]; };
inline uint16_t getErrorCount() { return packInfo->err.all(); };
inline uint8_t getErrorLowSignal() { return packInfo->err.lowSignal; };
inline uint8_t getErrorHighSignal() { return packInfo->err.highSignal; };
inline uint8_t getErrorOther() { return packInfo->err.other; };
inline uint16_t getTunerTime() { return packInfo->rTime; };
inline uint8_t *getDataRawPtr() { return packInfo->buffer; };
};
class Data : public BasePack
@ -114,20 +56,15 @@ namespace PacketTypes
DataOffset = 5;
}
uint16_t getAddrFrom() { return _getAddrFrom(this); };
uint16_t getAddrTo() { return _getAddrTo(this); };
inline uint16_t getAddrFrom() { return _getAddrFrom(this); };
inline uint16_t getAddrTo() { return _getAddrTo(this); };
uint8_t getDataSize() { return _getDataSize(this); };
uint8_t *getDataPrt() { return _getDataPrt(this); };
uint8_t getDataRawSize() { return _getDataRawSize(this); };
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
{
bool ret;
IR_FOX::checkAddressRuleApply(getAddrTo(), this->id, ret);
return ret;
}
bool checkAddress() override;
};
class DataBack : public BasePack
@ -141,29 +78,15 @@ namespace PacketTypes
DataOffset = 3;
}
uint16_t getAddrFrom() { return _getAddrFrom(this); };
uint16_t getAddrTo() { return _getAddrTo(this); };
inline uint16_t getAddrFrom() { return _getAddrFrom(this); };
inline uint16_t getAddrTo() { return _getAddrTo(this); };
uint8_t getDataSize() { return _getDataSize(this); };
uint8_t *getDataPrt() { return _getDataPrt(this); };
uint8_t getDataRawSize() { return _getDataRawSize(this); };
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
{
bool ret;
if (getMsgType() == IR_MSG_BACK_TO)
{
DataOffset = 5;
IR_FOX::checkAddressRuleApply((packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1], this->id, ret);
}
else
{
DataOffset = 3;
ret = true;
}
return ret;
}
bool checkAddress() override;
};
class Accept : public BasePack
@ -176,11 +99,11 @@ namespace PacketTypes
DataOffset = 3;
}
uint16_t getAddrFrom() { return _getAddrFrom(this); };
uint8_t getCustomByte() { return packInfo->buffer[DataOffset]; };
inline uint16_t getAddrFrom() { return _getAddrFrom(this); };
inline uint8_t getCustomByte() { return packInfo->buffer[DataOffset]; };
private:
bool checkAddress() override { return true; }
bool checkAddress() override;
};
class Request : public BasePack
@ -194,168 +117,11 @@ namespace PacketTypes
DataOffset = 3;
}
uint16_t getAddrFrom() { return _getAddrFrom(this); };
uint16_t getAddrTo() { return _getAddrTo(this); };
inline uint16_t getAddrFrom() { return _getAddrFrom(this); };
inline uint16_t getAddrTo() { return _getAddrTo(this); };
private:
bool checkAddress() override
{
bool ret;
IR_FOX::checkAddressRuleApply(getAddrTo(), this->id, ret);
return ret;
}
bool checkAddress() override;
};
}
// class IOffsets {
// protected:
// uint8_t msgOffset;
// uint8_t addressFromOffset;
// uint8_t addressToOffset;
// uint8_t DataOffset;
// };
// class IPackInfo {
// public:
// IR_FOX::PackInfo* packInfo;
// };
// class IBaseEmptyPack : virtual public IOffsets, virtual public IPackInfo {
// };
// class IR_Decoder;
// class IEmptyPack : virtual protected IBaseEmptyPack, virtual public IR_FOX {
// friend IR_Decoder;
// bool isAvailable;
// bool isRawAvailable;
// bool isNeedAccept;
// protected:
// uint16_t id;
// virtual bool checkAddress() {};
// virtual void set(IR_FOX::PackInfo* packInfo, uint16_t id, bool isNeedAccept = false) {
// IBaseEmptyPack::IPackInfo::packInfo = packInfo;
// this->id = id;
// this->isNeedAccept = isNeedAccept;
// if (isAvailable = checkAddress()) {
// isAvailable = true;
// isRawAvailable = true;
// Serial.print(" OK ");
// } else {
// isRawAvailable = true;
// Serial.print(" NOT-OK ");
// }
// }
// public:
// virtual bool available() { if (isAvailable) { isAvailable = false; isRawAvailable = false; return true; } else { return false; } };
// virtual bool availableRaw() { if (isRawAvailable) { isRawAvailable = false; return true; } else { return false; } };
// virtual uint8_t getMsgInfo() { return packInfo->buffer[0] & IR_MASK_MSG_INFO; };
// virtual uint8_t getMsgType() { return (packInfo->buffer[0] >> 5) & IR_MASK_MSG_TYPE; };
// virtual uint8_t getMsgRAW() { return packInfo->buffer[0]; };
// virtual uint16_t getErrorCount() { return packInfo->err.all(); };
// virtual uint8_t getErrorLowSignal() { return packInfo->err.lowSignal; };
// virtual uint8_t getErrorHighSignal() { return packInfo->err.highSignal; };
// virtual uint8_t getErrorOther() { return packInfo->err.other; };
// virtual uint16_t getTunerTime() { return packInfo->rTime; };
// };
// class IHasAddresFrom : virtual protected IBaseEmptyPack {
// public:
// virtual uint16_t getAddrFrom() { return (packInfo->buffer[addressFromOffset] << 8) | packInfo->buffer[addressFromOffset + 1]; };
// };
// class IHasAddresTo : virtual protected IBaseEmptyPack {
// public:
// virtual uint16_t getAddrTo() { return (packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1]; };
// };
// class IHasAddresData : virtual protected IBaseEmptyPack {
// public:
// virtual uint8_t getDataSize() { return packInfo->packSize - crcBytes - DataOffset; };
// virtual uint8_t* getDataPrt() { return packInfo->buffer + DataOffset; };
// virtual uint8_t getDataRawSize() { return packInfo->packSize; };
// virtual uint8_t* getDataRawPtr() { return packInfo->buffer; };
// };
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// class Data :
// virtual public IEmptyPack,
// virtual public IHasAddresFrom,
// virtual public IHasAddresTo,
// virtual public IHasAddresData {
// public:
// Data() {
// msgOffset = 0;
// addressFromOffset = 1;
// addressToOffset = 3;
// DataOffset = 5;
// }
// protected:
// bool checkAddress() override {
// bool ret;
// checkAddressRuleApply(getAddrTo(), this->id, ret);
// return ret;
// }
// };
// class DataBack :
// virtual public IEmptyPack,
// virtual public IHasAddresFrom,
// virtual public IHasAddresData {
// public:
// DataBack() {
// msgOffset = 0;
// addressFromOffset = 1;
// addressToOffset = 3;
// DataOffset = 3;
// }
// protected:
// bool checkAddress() override {
// bool ret;
// if (getMsgType() == IR_MSG_BACK_TO) {
// DataOffset = 5;
// checkAddressRuleApply((packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1], this->id, ret);
// } else {
// DataOffset = 3;
// ret = true;
// }
// return ret;
// }
// };
// class Request :
// virtual public IEmptyPack,
// virtual public IHasAddresFrom,
// virtual public IHasAddresTo {
// public:
// Request() {
// msgOffset = 0;
// addressFromOffset = 1;
// addressToOffset = 3;
// DataOffset = 3;
// }
// protected:
// bool checkAddress() override {
// bool ret;
// checkAddressRuleApply(getAddrTo(), this->id, ret);
// return ret;
// }
// };
// class Accept :
// virtual public IEmptyPack,
// virtual public IHasAddresFrom {
// public:
// Accept() {
// msgOffset = 0;
// addressFromOffset = 1;
// DataOffset = 1;
// }
// protected:
// };