DashyFox/IR-protocol
1
0
Fork 0
mirror of https://github.com/Show-maket/IR-protocol.git synced 2025-06-27 20:59:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

merge from TX and RX

Browse Source
This commit is contained in:
DashyFox
2023-10-10 18:06:13 +03:00
parent a4105021ce
commit e812f97f37
5 changed files with 107 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
IR_Decoder.cpp
View File

@ -1,6 +1,6 @@
#include "IR_Decoder.h"
#include "IR_Encoder.h"
#define checkAddr(h, l) (\
((uint16_t)((dataBuffer[h] << 8) | dataBuffer[l]) == addrSelf) || \
((uint16_t)((dataBuffer[h] << 8) | dataBuffer[l]) >= IR_Broadcast)\
@ -42,7 +42,7 @@ void IR_Decoder::writeToBuffer(bool bit) {
isRawAvaliable = true;
isMsgAvaliable = crcCheck(dataSize);
if (isMsgAvaliable && checkAddr(1, 2)) {
gotAccept._set(dataBuffer, msgBytes + addrBytes + crcBytes, crcValue, errorCounter);
gotAccept._set(dataBuffer, msgBytes + addrBytes + crcBytes, crcValue, errorCounter, riseSyncTime);
gotAccept._isAvaliable = true;
}
}
@ -55,7 +55,7 @@ void IR_Decoder::writeToBuffer(bool bit) {
isMsgAvaliable = (crcCheck(dataSize));
if (isMsgAvaliable && checkAddr(3, 4)) {
gotRequest._isAvaliable = true;
gotRequest._set(dataBuffer, msgBytes + addrBytes + addrBytes + crcBytes, crcValue, errorCounter);
gotRequest._set(dataBuffer, msgBytes + addrBytes + addrBytes + crcBytes, crcValue, errorCounter, riseSyncTime);
}
}
break;
@ -64,14 +64,17 @@ void IR_Decoder::writeToBuffer(bool bit) {
case IR_MSG_DATA_ACCEPT:
case IR_MSG_DATA_NOACCEPT:
if (bufBitPos >= ((bitPerByte + syncBits) * ((rawBuffer[0] & IR_MASK_MSG_INFO) + crcBytes)) - syncBits) {
const uint8_t dataSize = (rawBuffer[0] & IR_MASK_MSG_INFO);
const uint8_t dataSize = (rawBuffer[0] & IR_MASK_MSG_INFO);
isRawAvaliable = true;
isMsgAvaliable = crcCheck(dataSize);
if (isMsgAvaliable && checkAddr(3, 4)
) {
gotData._isAvaliable = true;
gotData._set(dataBuffer, (dataSize)+crcBytes, crcValue, errorCounter);
gotData._set(dataBuffer, (dataSize)+crcBytes, crcValue, errorCounter, riseSyncTime);
} else {
gotRawData._isAvaliable = true;
gotRawData._set(dataBuffer, (dataSize)+crcBytes, crcValue, errorCounter, riseSyncTime);
}
}
break;
@ -168,6 +171,11 @@ uint16_t IR_Decoder::ceil_div(uint16_t val, uint16_t divider) {
return ret;
}
////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////// isr ///////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
void IR_Decoder::isr() { // в прерывании вызываем isr()
if (isPairSending) return;
@ -175,21 +183,21 @@ void IR_Decoder::isr() { // в прерывании вызываем isr()
isPreamb = true;
frontCounter = preambFronts - 1U;
errorCounter = 0;
riseSyncTime = bitTime;
riseSyncTime = bitTime /* 1100 */;
start_RX();
}
}
if (frontCounter > 0) { // в преамбуле
uint32_t risePeriod = micros() - prevRise;
if ((PIND >> 2) & 1 && risePeriod < IR_timeout) { // __/``` ↑ и мы в внутри пакета
if (freeFrec) { riseSyncTime = (riseSyncTime + risePeriod / 2) / 2; } // tuner
if (risePeriod < riseTimeMin << 1) { // fix рваной единицы
frontCounter += 2;
errorCounter++;
} else {
if (freeFrec) { riseSyncTime = (riseSyncTime + risePeriod / 2) / 2; } // tuner
}
} else { riseSyncTime = bitTime; } // сброс тюнера
} else { /* riseSyncTime = bitTime; */ } // сброс тюнера
frontCounter--;
} else {
if (isPreamb) {// первый фронт после
@ -233,7 +241,7 @@ void IR_Decoder::isr() { // в прерывании вызываем isr()
lowCount = ceil_div(lowTime, riseTime); // предполагаемое колличество LOW битов
allCount = ceil_div(risePeriod, riseTime); // предполагаемое колличество всего битов
if (highCount == 0 && highTime > riseTime / 3) { // fix короткой единицы (?)после пропуска нулей(?)
if (highCount == 0 && highTime > riseTime / 4) { // fix короткой единицы (?)после пропуска нулей(?)
highCount++;
errorCounter++;
#ifdef IRDEBUG

50
IR_Decoder.h
View File

@ -4,12 +4,12 @@
//#define IRDEBUG
#ifdef IRDEBUG
#define wrHigh 3 // Запись HIGH инициирована // green
#define wrLow 4 // Запись LOW инициирована // blue
#define writeOp 6 // Операция записи, 1 пульс для 0 и 2 для 1 // orange
#define wrHigh A3 // Запись HIGH инициирована // green
#define wrLow A3 // Запись LOW инициирована // blue
#define writeOp 13 // Операция записи, 1 пульс для 0 и 2 для 1 // orange
// Исправленные ошибки // purle
// 1 пульс: fix
#define errOut 5
#define errOut A3
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////
@ -39,7 +39,7 @@ public:
//////////////////////////////////////////////////////////////////////////
class InputData {
class InputData : protected IR_FOX {
friend IR_Decoder;
protected:
bool _isAvaliable = false;
@ -51,11 +51,13 @@ public:
uint16_t _crcPackVal;
uint16_t _crcCalcVal;
uint16_t _errCount;
uint16_t _bitPeriod;
void _set(uint8_t* ptr, uint8_t len, uint16_t crc, uint16_t err) {
void _set(uint8_t* ptr, uint8_t len, uint16_t crc, uint16_t err, uint16_t rTime) {
_crcCalcVal = crc;
_dataRawSize = len;
_errCount = err;
_bitPeriod = rTime;
if (_data != nullptr) { delete _data; _data = nullptr; }
_data = new uint8_t[len];
for (uint8_t i = 0; i < len; i++) { _data[i] = ptr[i]; }
@ -74,6 +76,7 @@ public:
uint16_t errorCount() { return _errCount; };
uint16_t crcIN() { return _crcPackVal; };
uint16_t crcCALC() { return _crcCalcVal; };
uint16_t tunerTime() { return _bitPeriod; };
void resetAvaliable() { _isAvaliable = false; };
};
@ -88,12 +91,21 @@ public:
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);
}
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 {
};
@ -120,6 +132,7 @@ public:
};
Data gotData;
RawData gotRawData;
Accept gotAccept;
Request gotRequest;
@ -176,6 +189,31 @@ private:
//TODO: Сделать функцию медианы
void medi(uint16_t);
// class Medi {
// public:
// uint16_t* arr;
// uint8_t size;
// uint8_t center;
// Medi(uint8_t _size) : size(_size - 1) {
// arr = new uint16_t[size] { 0 };
// center = size / 2;
// };
// void add(uint16_t newVal) {
// _add(newVal, center);
// }
// void _add(uint16_t newVal, int8_t pos, bool f) {
// if (pos < 0 || pos > size) return;
// if (newVal < arr[pos]) _add(newVal, pos-1, f);
// if (newVal > arr[pos]) _add(newVal, pos+1, f);
// }
// ~Medi() { delete arr; }
// };
#ifdef IRDEBUG
inline void errPulse(uint8_t pin, uint8_t count);

3
IR_Encoder.cpp
View File

@ -1,9 +1,6 @@
#include "IR_Encoder.h"
#include "IR_Decoder.h"
#define halfPeriod ((carrierPeriod / 2) - 5) //13 //8 // 14 при работе с регистрами, 14 -6 = 8 для digitalWrite()
const auto _x_ = halfPeriod;
IR_Encoder::IR_Encoder(uint16_t addr, uint8_t pin, IR_Decoder* decPair) : ir_out(pin), addrSelf(addr), decoder(decPair) {};
IR_Encoder::~IR_Encoder() {};

2
IR_Encoder.h
View File

@ -15,7 +15,7 @@ public:
template<typename T>
void sendData(uint16_t addrTo, T& data, bool needAccept = false);
void sendACK(uint16_t addrTo, uint8_t addInfo, bool forAll = false);
void sendACK(uint16_t addrTo, uint8_t addInfo = 0, bool forAll = false);
void sendRequest(uint16_t addrTo, uint8_t addInfo = 0);

46
IR_config.h
View File

@ -63,6 +63,12 @@ msg type:
#define bytePerPack 3 // колличество байтов в пакете
#define freeFrec true
#define carrierTune 8
// 8 для gyverCore
// 4~5 для arduino nano
/////////////////////////////////////////////////////////////////////////////////////
#define bitPerByte 8U // Колличество бит в байте
@ -86,13 +92,17 @@ typedef uint16_t crc_t;
#define carrierFrec 38000U // частота несущей
#define carrierPeriod (1000000U/carrierFrec) // период несущей в us
#define halfPeriod ((carrierPeriod / 2) - carrierTune) //13 //8 // 14 при работе с регистрами, 14 -6 = 8 для digitalWrite()
const auto _x_ = halfPeriod;
// В процессе работы значения будут отклонятся в соответствии с предыдущим битом
#define bitActiveTakts 25U // длительность активной части бита в тактах
#define bitPauseTakts 5U // длительность промежутков в тактах
#define bitActiveTakts 30U // длительность активной части бита в тактах
#define bitPauseTakts 7U // длительность промежутков в тактах
#define bitTakts (bitActiveTakts+bitPauseTakts*2U) // Общая длительность бита в тактах
#define bitTime (bitTakts*carrierPeriod) // Общая длительность бита
//const auto viewValue = bitTime;
const auto viewValue = bitTime;
#define tolerance 300U
class IR_FOX {
@ -113,4 +123,34 @@ public:
}
return crc;
}
String printBytes(uint8_t* d ,uint8_t s , uint8_t mode = 10) {
String str = "";
uint8_t control = bitPerByte;
uint8_t* _data = d;
switch (mode) {
case 2:
for (size_t i = 0; i < s * 8; i++) {
if (i == control) {
str += " ";
control += bitPerByte;
}
str += _data[(i / 8)] >> (7 - (i % 8)) & 1;
}
break;
case 10:
for (size_t i = 0; i < s; i++) {
str += _data[i];
str += " ";
}
break;
default:
break;
}
str += " ";
return str;
}
};