From e951111c53faad07409b876033a02d10d18833c5 Mon Sep 17 00:00:00 2001 From: DashyFox Date: Tue, 23 Apr 2024 13:35:49 +0300 Subject: [PATCH] refactor --- IR-protocol.ino | 152 +++++++++++++++-------- IR_Decoder.cpp | 72 +++++++++++ IR_Decoder.h | 58 ++------- IR_DecoderRaw.cpp | 67 ++++++---- IR_DecoderRaw.h | 30 +---- IR_Encoder.cpp | 53 ++++---- IR_Encoder.h | 35 +----- IR_config.cpp | 27 ++++ IR_config.h | 36 ++---- PacketTypes.cpp | 107 ++++++++++++++++ PacketTypes.h | 308 ++++++---------------------------------------- 11 files changed, 443 insertions(+), 502 deletions(-) create mode 100644 IR_Decoder.cpp create mode 100644 IR_config.cpp create mode 100644 PacketTypes.cpp diff --git a/IR-protocol.ino b/IR-protocol.ino index 8b113cc..2a9556f 100644 --- a/IR-protocol.ino +++ b/IR-protocol.ino @@ -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 diff --git a/IR_Decoder.cpp b/IR_Decoder.cpp new file mode 100644 index 0000000..eb829a4 --- /dev/null +++ b/IR_Decoder.cpp @@ -0,0 +1,72 @@ +#include "IR_Decoder.h" + +std::list& IR_Decoder::get_dec_list() // определение функции +{ + static std::list 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; + } +} \ No newline at end of file diff --git a/IR_Decoder.h b/IR_Decoder.h index d7555ea..49004d6 100644 --- a/IR_Decoder.h +++ b/IR_Decoder.h @@ -5,6 +5,11 @@ class IR_Decoder : public IR_DecoderRaw { +private: + // static std::list dec_list; + static std::list& 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; } diff --git a/IR_DecoderRaw.cpp b/IR_DecoderRaw.cpp index 2f2e581..96d6b29 100644 --- a/IR_DecoderRaw.cpp +++ b/IR_DecoderRaw.cpp @@ -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; @@ -539,31 +560,31 @@ void IR_DecoderRaw::writeToBuffer(bool bit) isAvailable = crcCheck(packSize - crcBytes, crcValue); #ifdef BRUTEFORCE_CHECK - if (!isAvailable) // Исправление первого бита // Очень большая затычка... - for (size_t i = 0; i < min(uint16_t(packSize - crcBytes*2U), uint16_t(dataByteSizeMax)); ++i) + if (!isAvailable) // Исправление первого бита // Очень большая затычка... + for (size_t i = 0; i < min(uint16_t(packSize - crcBytes * 2U), uint16_t(dataByteSizeMax)); ++i) + { + for (int j = 0; j < 8; ++j) { - for (int j = 0; j < 8; ++j) + // инвертируем бит + dataBuffer[i] ^= 1 << j; + + isAvailable = crcCheck(min(uint16_t(packSize - crcBytes), uint16_t(dataByteSizeMax - 1U)), crcValue); + // обратно инвертируем бит в исходное состояние + + if (isAvailable) + { +#ifdef IRDEBUG_INFO + Serial.println("!!!INV!!!"); +#endif + goto OUT_BRUTEFORCE; + } + else { - // инвертируем бит dataBuffer[i] ^= 1 << j; - - isAvailable = crcCheck(min(uint16_t(packSize - crcBytes), uint16_t(dataByteSizeMax - 1U)), crcValue); - // обратно инвертируем бит в исходное состояние - - if (isAvailable) - { - #ifdef IRDEBUG_INFO - Serial.println("!!!INV!!!"); - #endif - goto OUT_BRUTEFORCE; - } - else - { - dataBuffer[i] ^= 1 << j; - } } } - OUT_BRUTEFORCE:; + } + OUT_BRUTEFORCE:; #endif } } diff --git a/IR_DecoderRaw.h b/IR_DecoderRaw.h index de56567..2d2201d 100644 --- a/IR_DecoderRaw.h +++ b/IR_DecoderRaw.h @@ -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 diff --git a/IR_Encoder.cpp b/IR_Encoder.cpp index f97d05d..931c443 100644 --- a/IR_Encoder.cpp +++ b/IR_Encoder.cpp @@ -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::get_enc_list() // определение функции { + static std::list 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}; diff --git a/IR_Encoder.h b/IR_Encoder.h index 434cf75..c5ace21 100644 --- a/IR_Encoder.h +++ b/IR_Encoder.h @@ -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& 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); diff --git a/IR_config.cpp b/IR_config.cpp new file mode 100644 index 0000000..518261d --- /dev/null +++ b/IR_config.cpp @@ -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; +}; diff --git a/IR_config.h b/IR_config.h index 0edbf51..62882fc 100644 --- a/IR_config.h +++ b/IR_config.h @@ -1,7 +1,7 @@ #pragma once #include - -#define IRDEBUG_INFO +#include +// #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); }; diff --git a/PacketTypes.cpp b/PacketTypes.cpp new file mode 100644 index 0000000..d1c9dc4 --- /dev/null +++ b/PacketTypes.cpp @@ -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; + } +} \ No newline at end of file diff --git a/PacketTypes.h b/PacketTypes.h index 07d24fd..ea37677 100644 --- a/PacketTypes.h +++ b/PacketTypes.h @@ -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: -// };