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

addr check flag added

Browse Source
This commit is contained in:
DashyFox 2024-02-20 16:35:02 +03:00
parent 2afb7cff23
commit 024888e841
4 changed files with 105 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
IR_Decoder.cpp
View File

@ -1,7 +1,7 @@
#include "IR_Decoder.h" #include "IR_Decoder.h"
#include "IR_Encoder.h" #include "IR_Encoder.h"
#define IRDEBUG_INFO
#define checkAddr(h, l) (\ #define checkAddr(h, l) (\
((uint16_t)((dataBuffer[h] << 8) | dataBuffer[l]) == id) || \ ((uint16_t)((dataBuffer[h] << 8) | dataBuffer[l]) == id) || \
@ -360,25 +360,48 @@ void IR_Decoder::writeToBuffer(bool bit) {
if ((i_dataBuffer >= (8 * msgBytes)) && !isCrcCorrect) { if ((i_dataBuffer >= (8 * msgBytes)) && !isCrcCorrect) {
uint16_t crcValue; uint16_t crcValue;
uint8_t packSize;
switch ((dataBuffer[0] >> 5) & IR_MASK_MSG_TYPE) { switch ((dataBuffer[0] >> 5) & IR_MASK_MSG_TYPE) {
case IR_MSG_BACK: case IR_MSG_BACK:
packSize = (dataBuffer[0] & (IR_MASK_MSG_INFO >> 1)) + crcBytes;
if (i_dataBuffer != packSize * bitPerByte) break;
if ((dataBuffer[0] & 0b00010000)) { // С адресацией
packToOutClass( packToOutClass(
(((dataBuffer[0] & (IR_MASK_MSG_INFO >> 1)) + crcBytes)), // packSize packSize, // packSize
gotData, // obj gotData, // obj
PackOffsets { PackOffsets {
0, // msgOffset 0, // msgOffset
1, // addrFromOffset 1, // addrFromOffset
NULL, // addrToOffset 3, // addrToOffset
5, // dataOffset
NULL // crcOffset
},
true
);
} else { // Без адресации
packToOutClass(
packSize, // packSize
gotData, // obj
PackOffsets {
0, // msgOffset
1, // addrFromOffset
3, // addrToOffset
3, // dataOffset 3, // dataOffset
NULL // crcOffset NULL // crcOffset
} },
false
); );
}
break; break;
case IR_MSG_ACCEPT: case IR_MSG_ACCEPT:
packSize = msgBytes + addrBytes + crcBytes;
if (i_dataBuffer != packSize * bitPerByte) break;
packToOutClass( packToOutClass(
((msgBytes + addrBytes + crcBytes)), // packSize packSize, // packSize
gotAccept, // obj gotAccept, // obj
PackOffsets { PackOffsets {
0, // msgOffset 0, // msgOffset
@ -391,8 +414,11 @@ void IR_Decoder::writeToBuffer(bool bit) {
break; break;
case IR_MSG_REQUEST: case IR_MSG_REQUEST:
packSize = msgBytes + addrBytes + addrBytes + crcBytes;
if (i_dataBuffer != packSize * bitPerByte) break;
packToOutClass( packToOutClass(
((msgBytes + addrBytes + addrBytes + crcBytes)), // packSize packSize, // packSize
gotRequest, // obj gotRequest, // obj
PackOffsets { PackOffsets {
0, // msgOffset 0, // msgOffset
@ -407,8 +433,11 @@ void IR_Decoder::writeToBuffer(bool bit) {
case IR_MSG_DATA_ACCEPT: case IR_MSG_DATA_ACCEPT:
case IR_MSG_DATA_NOACCEPT: case IR_MSG_DATA_NOACCEPT:
packSize = (dataBuffer[0] & IR_MASK_MSG_INFO) + crcBytes;
if (i_dataBuffer != packSize * bitPerByte) break;
packToOutClass( packToOutClass(
(((dataBuffer[0] & IR_MASK_MSG_INFO) + crcBytes)), // packSize packSize, // packSize
gotData, // obj gotData, // obj
PackOffsets { PackOffsets {
0, // msgOffset 0, // msgOffset
@ -427,33 +456,20 @@ void IR_Decoder::writeToBuffer(bool bit) {
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
} }
void IR_Decoder::packToOutClass(uint8_t packSize, IDataPack& obj, PackOffsets offsets) { void IR_Decoder::packToOutClass(uint8_t packSize, IDataPack& obj, PackOffsets offsets, bool isNeedAddressCheck = true) {
if (i_dataBuffer == packSize * bitPerByte) {
PackOutInfo packInfo; PackOutInfo packInfo;
#ifdef IRDEBUG_INFO #ifdef IRDEBUG_INFO
Serial.print(" IN "); Serial.print(" IN ");
#endif #endif
isCrcCorrect = crcCheck(packSize - crcBytes, packInfo.crc); isCrcCorrect = crcCheck(packSize - crcBytes, packInfo.crc);
if (isCrcCorrect) { if (isCrcCorrect) {
// if ((addressForCheckOffset >= 0 ? checkAddr(addressForCheckOffset, addressForCheckOffset + 1) : 1)) {// адрес верен
// #ifdef IRDEBUG_INFO
// Serial.println(" OK ");
// #endif
// } else { // адресс не верен
// #ifdef IRDEBUG_INFO
// Serial.println(" NOT MY ");
// #endif
// }
packInfo.ptr = dataBuffer; packInfo.ptr = dataBuffer;
packInfo.packSize = packSize; packInfo.packSize = packSize;
packInfo.offsets = offsets; packInfo.offsets = offsets;
packInfo.offsets.crcOffset = packInfo.packSize - crcBytes; packInfo.offsets.crcOffset = packInfo.packSize - crcBytes;
packInfo.err = errors; packInfo.err = errors;
packInfo.rTime = riseSyncTime; packInfo.rTime = riseSyncTime;
obj.set(packInfo); obj.set(packInfo, isNeedAddressCheck);
} else { } else {
#ifdef IRDEBUG_INFO #ifdef IRDEBUG_INFO
Serial.println(" CRC WRONG "); Serial.println(" CRC WRONG ");
@ -461,7 +477,6 @@ void IR_Decoder::packToOutClass(uint8_t packSize, IDataPack& obj, PackOffsets of
} }
isRecive = false; isRecive = false;
}
} }

10
IR_Decoder.h
View File

@ -29,10 +29,10 @@ class IR_Decoder : private IR_FOX {
public: public:
uint16_t id; uint16_t id;
Data gotData = Data(id); /// @brief Контейнер с данными Data gotData = Data(&id); /// @brief Контейнер с данными
Data gotRawData = Data(id); Data gotRawData = Data(&id);
Accept gotAccept = Accept(id); /// @brief Контейнер с подтверждением Accept gotAccept = Accept(&addrWaitingFrom); /// @brief Контейнер с подтверждением
Request gotRequest = Request(id); /// @brief Контейнер с запросом Request gotRequest = Request(&id); /// @brief Контейнер с запросом
RawTune gotTune; /// @brief Контейнер с информацией подстройки RawTune gotTune; /// @brief Контейнер с информацией подстройки
const uint8_t isrPin; // Пин прерывания const uint8_t isrPin; // Пин прерывания
@ -109,7 +109,7 @@ private:
/// @brief Запиь бита в буффер, а так же проверка битов синхранизации и их фильтрация /// @brief Запиь бита в буффер, а так же проверка битов синхранизации и их фильтрация
/// @param Бит данных /// @param Бит данных
void writeToBuffer(bool); void writeToBuffer(bool);
void packToOutClass(uint8_t packSize, IDataPack& obj, PackOffsets offsets); void packToOutClass(uint8_t packSize, IDataPack& obj, PackOffsets offsets, bool isNeedAddressCheck = true);
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// @brief Установка и сброс начальных значений и флагов в готовность к приёму данных /// @brief Установка и сброс начальных значений и флагов в готовность к приёму данных

49
IR_Output.h
View File

@ -5,7 +5,7 @@ class IR_Decoder;
class IDataPack : protected IR_FOX { class IDataPack : protected IR_FOX {
friend IR_Decoder; friend IR_Decoder;
public: public:
IDataPack(uint16_t id) : id(id) {}; IDataPack(uint16_t* id) : id(id) {};
public: public:
bool avaliable() { return isAvaliable; }; bool avaliable() { return isAvaliable; };
@ -22,7 +22,7 @@ public:
void resetAvaliable() { isAvaliable = false; }; void resetAvaliable() { isAvaliable = false; };
protected: protected:
uint16_t id; uint16_t* id;
inline static uint8_t data[dataByteSizeMax] { 0 }; inline static uint8_t data[dataByteSizeMax] { 0 };
bool isAvaliable = false; bool isAvaliable = false;
@ -38,14 +38,29 @@ protected:
uint16_t bitPeriod; uint16_t bitPeriod;
uint16_t crcCalcVal; uint16_t crcCalcVal;
virtual bool checkAddress(PackOutInfo* packInfo) { return true; }; virtual bool checkAddress(PackOutInfo* packInfo) {
bool ret;
void set(PackOutInfo packInfo) { uint8_t targetAddrOffset = packInfo->offsets.addrToOffset;
uint16_t address = (packInfo->ptr[targetAddrOffset] << 8) | (packInfo->ptr[targetAddrOffset + 1]);
if (checkAddress(&packInfo)) { checkaddressRuleApply(address, *id, ret);
return ret;
};
void set(PackOutInfo packInfo, bool isNeedAddressCheck) {
if (!isNeedAddressCheck || checkAddress(&packInfo)) {
onPackAddressCorrect(&packInfo); onPackAddressCorrect(&packInfo);
#ifdef IRDEBUG_INFO
Serial.println(" OK ");
#endif
} else { } else {
onPackAddressIncorrect(&packInfo); onPackAddressIncorrect(&packInfo);
#ifdef IRDEBUG_INFO
Serial.println(" NOT MY ");
#endif
} }
} }
@ -81,19 +96,6 @@ public:
uint8_t getDataRawSize() { return packRawSize; }; uint8_t getDataRawSize() { return packRawSize; };
uint8_t* getDataRawPtr() { return data; }; uint8_t* getDataRawPtr() { return data; };
bool isNeedAccept() { return ((msgPtr[0] >> 5) & IR_MASK_MSG_TYPE) == IR_MSG_DATA_ACCEPT; }; bool isNeedAccept() { return ((msgPtr[0] >> 5) & IR_MASK_MSG_TYPE) == IR_MSG_DATA_ACCEPT; };
private:
bool checkAddress(PackOutInfo* packInfo) override {
bool ret;
uint8_t addrOffset = packInfo->offsets.addrToOffset;
uint16_t address = (packInfo->ptr[addrOffset] << 8) | (packInfo->ptr[addrOffset + 1]);
checkaddressRuleApply(address, id, ret);
return ret;
}
}; };
// class RawData : public Data { // class RawData : public Data {
@ -103,6 +105,17 @@ class Accept : public IDataPack {
using IDataPack::IDataPack; using IDataPack::IDataPack;
public: public:
uint16_t getAddrFrom() { return addrFromPtr[0] << 8 | addrFromPtr[1]; }; uint16_t getAddrFrom() { return addrFromPtr[0] << 8 | addrFromPtr[1]; };
private:
bool checkAddress(PackOutInfo* packInfo) override {
bool ret;
uint8_t targetAddrOffset = packInfo->offsets.addrFromOffset;
uint16_t address = (packInfo->ptr[targetAddrOffset] << 8) | (packInfo->ptr[targetAddrOffset + 1]);
ret = address == *id;
return ret;
}
}; };
class Request : public IDataPack { class Request : public IDataPack {

7
IR_config.h
View File

@ -1,5 +1,7 @@
#pragma once #pragma once
#include <Arduino.h> #include <Arduino.h>
#define IRDEBUG_INFO
/*////////////////////////////////////////////////////////////////////////////////////// /*//////////////////////////////////////////////////////////////////////////////////////
Для работы в паре положить декодер в энкодер Для работы в паре положить декодер в энкодер
@ -38,7 +40,7 @@ msg type:
                                        // | xxx..... | = тип сообщения                                         // | xxx..... | = тип сообщения
                                        // | ...xxxxx | = длина (максимум 31 бита)                                         // | ...xxxxx | = длина (максимум 31 бита)
                                        //  ---------- */                                         //  ---------- */
#define IR_MSG_BACK 0U // | 000..... | = Задний сигнал машинки #define IR_MSG_BACK 0U // | 0000B.... | = Задний сигнал машинки
;// // | \\\x---- | = нужна ли адресация ;// // | \\\x---- | = нужна ли адресация
;// // | \\\-xxxx | = длина данных (Равна нулю при отсутствии сквозных команд) ;// // | \\\-xxxx | = длина данных (Равна нулю при отсутствии сквозных команд)
#define IR_MSG_ACCEPT 1U // | 001..... | = подтверждение #define IR_MSG_ACCEPT 1U // | 001..... | = подтверждение
@ -173,8 +175,9 @@ public:
protected: protected:
ErrorsStruct errors; ErrorsStruct errors;
void checkaddressRuleApply(uint16_t &address, uint16_t &id, bool &flag) { void checkaddressRuleApply(uint16_t address, uint16_t id, bool &flag) {
flag = false; flag = false;
flag |= id == 0;
flag |= address == id; flag |= address == id;
flag |= address >= IR_Broadcast; flag |= address >= IR_Broadcast;
} }