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

testMultiBlind

Browse Source
This commit is contained in:
DashyFox 2024-02-12 16:41:16 +03:00
parent 9d315c8f23
commit 1c79b812d3
5 changed files with 56 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
IR_Decoder.cpp
View File

@ -31,9 +31,9 @@ void IR_Decoder::isr() {
} else { } else {
if (firstUnHandledFront == &subBuffer[currentSubBufferIndex]) { // Если контроллер не успел обработать новый сигнал, принудительно пропускаем его if (firstUnHandledFront == &subBuffer[currentSubBufferIndex]) { // Если контроллер не успел обработать новый сигнал, принудительно пропускаем его
firstUnHandledFront = firstUnHandledFront->next; firstUnHandledFront = firstUnHandledFront->next;
Serial.println(); // Serial.println();
Serial.println("ERROR"); // Serial.println("ERROR");
Serial.println(); // Serial.println();
} }
} }
@ -278,12 +278,12 @@ void IR_Decoder::writeToBuffer(bool bit) {
isData = !isData; isData = !isData;
i_syncBit = 0; // сброс счетчика битов синхронизации i_syncBit = 0; // сброс счетчика битов синхронизации
err_syncBit = 0; // сброс счетчика ошибок синхронизации err_syncBit = 0; // сброс счетчика ошибок синхронизации
Serial.print(" "); // Serial.print(" ");
} }
if (isData) { // Запись битов в dataBuffer if (isData) { // Запись битов в dataBuffer
Serial.print(bit); // Serial.print(bit);
if (i_dataBuffer % 8 == 7) { if (i_dataBuffer % 8 == 7) {
// Serial.print("+"); // Serial.print("+");
@ -314,7 +314,7 @@ void IR_Decoder::writeToBuffer(bool bit) {
} }
////////////////////// Проверка наличия битов синхранизации ////////////////////// ////////////////////// Проверка наличия битов синхранизации //////////////////////
isWrongPack = err_syncBit >= syncBits; isWrongPack = err_syncBit >= syncBits;
if (isWrongPack) Serial.print("****************"); // if (isWrongPack) Serial.print("****************");
}//**************************************************************************************************// }//**************************************************************************************************//
// Serial.print(bit); // Serial.print(bit);

5
IR_Decoder.h
View File

@ -21,8 +21,6 @@
#define aroundRise(t) (riseTimeMin < t && t < riseTimeMax) #define aroundRise(t) (riseTimeMin < t && t < riseTimeMax)
#define IR_timeout (riseTimeMax * (8 + syncBits +1)) // us // таймаут в 8 data + 3 sync + 1 #define IR_timeout (riseTimeMax * (8 + syncBits +1)) // us // таймаут в 8 data + 3 sync + 1
#define subBufferSize 7 //Буфер для складирования фронтов, пока их не обработают
class IR_Encoder; class IR_Encoder;
class IR_Decoder : private IR_FOX { class IR_Decoder : private IR_FOX {
@ -179,8 +177,7 @@ private:
const uint8_t isrPin; // Пин прерывания const uint8_t isrPin; // Пин прерывания
IR_Encoder* encoder; // Указатель на парный передатчик IR_Encoder* encoder; // Указатель на парный передатчик
bool isPairSending = false; // Флаг передачи парного передатчика volatile uint16_t isPairSending = 0; // Флаг передачи парного передатчика
bool IsPairSendLOW = false; //
volatile bool isRecive = false; // Флаг приёма volatile bool isRecive = false; // Флаг приёма

64
IR_Encoder.cpp
View File

@ -5,15 +5,16 @@
#define ISR_Out 10 #define ISR_Out 10
#define TestOut 13 #define TestOut 13
IR_Encoder::IR_Encoder(uint16_t addr, uint8_t pin, uint8_t tune = 0, IR_Decoder* decPair) { IR_Encoder::IR_Encoder(uint16_t addr, uint8_t pin, uint8_t decPairCount = 0, void* decPair = nullptr) {
// sendBuffer = new uint8_t[dataByteSizeMax] { 0 }; // sendBuffer = new uint8_t[dataByteSizeMax] { 0 };
ir_out = pin; ir_out = pin;
pinMode(ir_out, OUTPUT); pinMode(ir_out, OUTPUT);
addrSelf = addr; id = addr;
decoder = decPair;
carrierTune = tune; decoders = (IR_Decoder*)decPair;
halfPeriod = (carrierPeriod / 2) - carrierTune; decodersCount = decPairCount;
dataBitCounter = 0 - preambFronts;
signal = noSignal; signal = noSignal;
}; };
@ -24,7 +25,7 @@ IR_Encoder::~IR_Encoder() {
// delete [] sendBuffer; // delete [] sendBuffer;
}; };
void IR_Encoder::sendData(uint16_t addrTo, uint8_t* data, uint8_t len, bool needAccept = false) { void IR_Encoder::sendData(uint16_t addrTo, uint8_t* data, uint8_t len, bool needAccept = false) {
uint8_t packSize = msgBytes + addrBytes + addrBytes + len + crcBytes; uint8_t packSize = msgBytes + addrBytes + addrBytes + len + crcBytes;
uint8_t msgType = uint8_t msgType =
((needAccept ? IR_MSG_DATA_ACCEPT : IR_MSG_DATA_NOACCEPT) << 5) | ((packSize - crcBytes) & IR_MASK_MSG_INFO); ((needAccept ? IR_MSG_DATA_ACCEPT : IR_MSG_DATA_NOACCEPT) << 5) | ((packSize - crcBytes) & IR_MASK_MSG_INFO);
@ -38,8 +39,8 @@ void IR_Encoder::sendACK(uint16_t addrTo, uint8_t addInfo, bool forAll = false)
// addr_self // addr_self
if (!forAll) { if (!forAll) {
sendBuffer[1] = addrSelf >> 8 & 0xFF; sendBuffer[1] = id >> 8 & 0xFF;
sendBuffer[2] = addrSelf & 0xFF; sendBuffer[2] = id & 0xFF;
} }
// data crc // data crc
@ -55,8 +56,8 @@ void IR_Encoder::sendRequest(uint16_t addrTo, uint8_t addInfo) {
sendBuffer[0] |= addInfo & IR_MASK_MSG_INFO; sendBuffer[0] |= addInfo & IR_MASK_MSG_INFO;
// addr_self // addr_self
sendBuffer[1] = addrSelf >> 8 & 0xFF; sendBuffer[1] = id >> 8 & 0xFF;
sendBuffer[2] = addrSelf & 0xFF; sendBuffer[2] = id & 0xFF;
//addr_to //addr_to
sendBuffer[3] = addrTo >> 8 & 0xFF; sendBuffer[3] = addrTo >> 8 & 0xFF;
@ -80,8 +81,8 @@ void IR_Encoder::_sendData(uint16_t addrTo, uint8_t* data, uint8_t len, uint8_t
sendBuffer[0] = msgType; sendBuffer[0] = msgType;
// addr_self // addr_self
sendBuffer[1] = addrSelf >> 8 & 0xFF; sendBuffer[1] = id >> 8 & 0xFF;
sendBuffer[2] = addrSelf & 0xFF; sendBuffer[2] = id & 0xFF;
// addr_to // addr_to
sendBuffer[3] = addrTo >> 8 & 0xFF; sendBuffer[3] = addrTo >> 8 & 0xFF;
@ -95,33 +96,39 @@ void IR_Encoder::_sendData(uint16_t addrTo, uint8_t* data, uint8_t len, uint8_t
sendBuffer[packSize - crcBytes] = crc8(sendBuffer, 0, packSize - crcBytes, poly1) & 0xFF; sendBuffer[packSize - crcBytes] = crc8(sendBuffer, 0, packSize - crcBytes, poly1) & 0xFF;
sendBuffer[packSize - crcBytes + 1] = crc8(sendBuffer, 0, packSize - crcBytes + 1, poly2) & 0xFF; sendBuffer[packSize - crcBytes + 1] = crc8(sendBuffer, 0, packSize - crcBytes + 1, poly2) & 0xFF;
if (decoder != nullptr) { if (decoders != nullptr) {
decoder->isWaitingAccept = ((msgType >> 5) & IR_MASK_MSG_TYPE == IR_MSG_DATA_ACCEPT); decoders->isWaitingAccept = ((msgType >> 5) & IR_MASK_MSG_TYPE == IR_MSG_DATA_ACCEPT);
decoder->addrWaitingFrom = addrTo; decoders->addrWaitingFrom = addrTo;
} }
// отправка // отправка
rawSend(sendBuffer, packSize); rawSend(sendBuffer, packSize);
} }
void IR_Encoder::setDecoder_isSending() {
if (decodersCount && decoders != nullptr) {
for (uint8_t i = 0; i < decodersCount; i++) {
(decoders + i)->isPairSending ^= id;
}
}
}
void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) { void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
if(isSending){ if (isSending) {
//TODO: Обработка повторной отправки //TODO: Обработка повторной отправки
return; return;
} }
digitalToggle(9); digitalToggle(9);
// memset(sendBuffer, 0x00, dataByteSizeMax);
// memcpy(sendBuffer, ptr, len);
sendLen = len; sendLen = len;
// *sendBuffer = 0b10010011;
isSending = true; isSending = true;
// setDecoder_isSending();
decoders->isPairSending ^= id;
cli(); cli();
if (decoder != nullptr) { decoder->isPairSending = isSending; }
// #define preambToggle 2*2-1 //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
#define preambToggle ((bitPauseTakts * 2 + bitActiveTakts) * 2 - 1) //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
toggleCounter = preambToggle; // Первая генерация для первого signal toggleCounter = preambToggle; // Первая генерация для первого signal
dataBitCounter = bitPerByte - 1; dataBitCounter = bitPerByte - 1;
@ -152,9 +159,12 @@ void IR_Encoder::isr() {
IsrStart: IsrStart:
switch (signal) { switch (signal) {
case noSignal: case noSignal:
signal = preamb;
// сброс счетчиков // сброс счетчиков
// ... // ...
isSending = false; isSending = false;
// setDecoder_isSending();
decoders->isPairSending ^= id;
return; return;
break; break;
@ -228,7 +238,7 @@ void old() {///////////////////////////////////////////////////////
// void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) { // void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
// /*tmp*/bool LOW_FIRST = false;/*tmp*/ // /*tmp*/bool LOW_FIRST = false;/*tmp*/
// if (decoder != nullptr) { decoder->isPairSending = true; } // if (decoders != nullptr) { decoders->isPairSending = true; }
// bool prev = 1; // bool prev = 1;
// bool next; // bool next;
@ -244,7 +254,7 @@ void old() {///////////////////////////////////////////////////////
// addSync(&prev, &next); // addSync(&prev, &next);
// } // }
// if (decoder != nullptr) { decoder->isPairSending = false; } // if (decoders != nullptr) { decoders->isPairSending = false; }
// } // }
} }

14
IR_Encoder.h
View File

@ -10,11 +10,9 @@ class IR_Encoder : IR_FOX {
public: public:
uint8_t ir_out; /// @brief Вывод передатчика uint8_t ir_out; /// @brief Вывод передатчика
uint16_t addrSelf; /// @brief Адрес передатчика uint16_t id; /// @brief Адрес передатчика
private: private:
uint8_t carrierTune; /// @brief Подстройка несущей частоты
uint8_t halfPeriod; /// @brief полупериод несущей частоты
public: public:
@ -23,7 +21,7 @@ public:
/// @param pin Вывод передатчика /// @param pin Вывод передатчика
/// @param tune Подстройка несущей частоты /// @param tune Подстройка несущей частоты
/// @param decPair Приёмник, для которого отключается приём в момент передачи передатчиком /// @param decPair Приёмник, для которого отключается приём в момент передачи передатчиком
IR_Encoder(uint16_t addr, uint8_t pin, uint8_t tune, IR_Decoder* decPair = nullptr); IR_Encoder(uint16_t addr, uint8_t pin, uint8_t decPairCount = 0, void* decPair = nullptr);
template<typename T> template<typename T>
void sendData(uint16_t addrTo, T& data, bool needAccept = false); void sendData(uint16_t addrTo, T& data, bool needAccept = false);
@ -36,7 +34,7 @@ public:
~IR_Encoder(); ~IR_Encoder();
volatile bool ir_out_virtual; volatile bool ir_out_virtual;
private: private:
IR_Decoder* decoder; void IR_Encoder::setDecoder_isSending();
void _sendData(uint16_t addrTo, uint8_t* data, uint8_t len, uint8_t msgType); void _sendData(uint16_t addrTo, uint8_t* data, uint8_t len, uint8_t msgType);
void sendByte(uint8_t byte, bool* prev, bool LOW_FIRST); void sendByte(uint8_t byte, bool* prev, bool LOW_FIRST);
void addSync(bool* prev, bool* next); void addSync(bool* prev, bool* next);
@ -51,13 +49,13 @@ private:
sync = 3 sync = 3
}; };
IR_Decoder* decoders;
uint8_t decodersCount;
uint8_t sendLen; uint8_t sendLen;
uint8_t sendBuffer[dataByteSizeMax] { 0 }; /// @brief Буффер данных для отправки uint8_t sendBuffer[dataByteSizeMax] { 0 }; /// @brief Буффер данных для отправки
// uint8_t
volatile bool isSending = false; volatile bool isSending = false;
// volatile bool genState = HIGH;
volatile bool state; /// @brief Текущий уровень генерации volatile bool state; /// @brief Текущий уровень генерации
volatile uint8_t dataByteCounter; volatile uint8_t dataByteCounter;

22
IR_config.h
View File

@ -76,13 +76,9 @@ typedef uint16_t crc_t;
#ifndef freeFrec #ifndef freeFrec
#define freeFrec true #define freeFrec true
#endif #endif
#define subBufferSize 17 //Буфер для складирования фронтов, пока их не обработают (передатчик)
//#define carrierTune 4
#define preambPulse 3 #define preambPulse 3
// 8 для gyverCore
// 4~5 для arduino nano
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
@ -95,27 +91,21 @@ typedef uint16_t crc_t;
#define syncBits 3U // количество битов синхронизации #define syncBits 3U // количество битов синхронизации
#define dataByteSizeMax (msgBytes + addrBytes + addrBytes + bytePerPack + crcBytes) #define dataByteSizeMax (msgBytes + addrBytes + addrBytes + bytePerPack + crcBytes)
// размер msg в битах // размер короткой посылки в битах
// #define dataBitSize ((8 + syncBits) * dataByteSizeMax) // размер посылки с данными в битах
// #define bufferBitSizeMax (dataBitSize) // Размер буффера в битах
//const auto x = bufferBitSizeMax; #define preambFronts (preambPulse*2) // количество фронтов преамбулы (Приём)
#define preambFronts (preambPulse*2) // количество фронтов преамбулы #define preambToggle ((bitPauseTakts * 2 + bitActiveTakts) * 2 - 1) // колличество переключений преамбулы (Передача)
#define carrierFrec 38000U // частота несущей #define carrierFrec 38000U // частота несущей (Приём/Передача)
#define carrierPeriod (1000000U/carrierFrec) // период несущей в us #define carrierPeriod (1000000U/carrierFrec) // период несущей в us (Приём)
// В процессе работы значения будут отклонятся в соответствии с предыдущим битом // В процессе работы значения будут отклонятся в соответствии с предыдущим битом
#define bitActiveTakts 25U // длительность высокого уровня в тактах #define bitActiveTakts 25U // длительность высокого уровня в тактах
#define bitPauseTakts 6U // длительность низкого уровня в тактах #define bitPauseTakts 6U // длительность низкого уровня в тактах
#define bitTakts (bitActiveTakts+(bitPauseTakts*2U)) // Общая длительность бита в тактах #define bitTakts (bitActiveTakts+(bitPauseTakts*2U)) // Общая длительность бита в тактах
#define bitTime (bitTakts*carrierPeriod) // Общая длительность бита #define bitTime (bitTakts*carrierPeriod) // Общая длительность бита
#define tolerance 300U #define tolerance 300U
#define preambToggle ((bitPauseTakts * 2 + bitActiveTakts) * 2 - 1)
class IR_FOX { class IR_FOX {
private: private:
bool isSending = false; bool isSending = false;