DashyFox/IR-protocol
1
0
Fork 0
mirror of https://github.com/Show-maket/IR-protocol.git synced 2025-06-28 05:09:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

formatting

Browse Source
This commit is contained in:
DashyFox
2024-03-15 16:08:06 +03:00
parent 3e3601e009
commit 8d0f45ddf1
7 changed files with 689 additions and 468 deletions
Download Patch File Download Diff File Expand all files Collapse all files

302
IR_Encoder.cpp
View File

@ -5,43 +5,55 @@
#define ISR_Out 10
#define TestOut 13
IR_Encoder::IR_Encoder(uint16_t addr, IR_DecoderRaw* decPair = nullptr) {
IR_Encoder::IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair = nullptr)
{
id = addr;
this->decPair = decPair;
signal = noSignal;
isSending = false;
#if disablePairDec
if (decPair != nullptr) {
blindDecoders = new IR_DecoderRaw * [1] {decPair};
#if disablePairDec
if (decPair != nullptr)
{
blindDecoders = new IR_DecoderRaw *[1]
{ decPair };
decodersCount = 1;
}
#endif
if (decPair != nullptr) {
#endif
if (decPair != nullptr)
{
decPair->encoder = this;
}
};
void IR_Encoder::setBlindDecoders(IR_DecoderRaw* decoders [], uint8_t count) {
#if disablePairDec
if (blindDecoders != nullptr) delete [] blindDecoders;
#endif
void IR_Encoder::setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count)
{
#if disablePairDec
if (blindDecoders != nullptr)
delete[] blindDecoders;
#endif
decodersCount = count;
blindDecoders = decoders;
}
IR_Encoder::~IR_Encoder() {
delete [] bitLow;
delete [] bitHigh;
IR_Encoder::~IR_Encoder()
{
delete[] bitLow;
delete[] bitHigh;
};
void IR_Encoder::sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept = false) {
uint8_t* dataPtr = new uint8_t[1];
void IR_Encoder::sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept = false)
{
uint8_t *dataPtr = new uint8_t[1];
dataPtr[0] = dataByte;
sendData(addrTo, dataPtr, 1, needAccept);
delete[] dataPtr;
}
void IR_Encoder::sendData(uint16_t addrTo, uint8_t* data = nullptr, uint8_t len = 0, bool needAccept = false) {
if (len > bytePerPack) { return; }
void IR_Encoder::sendData(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false)
{
if (len > bytePerPack)
{
return;
}
constexpr uint8_t dataStart = msgBytes + addrBytes + addrBytes;
memset(sendBuffer, 0x00, dataByteSizeMax);
uint8_t packSize = msgBytes + addrBytes + addrBytes + len + crcBytes;
@ -60,8 +72,9 @@ void IR_Encoder::sendData(uint16_t addrTo, uint8_t* data = nullptr, uint8_t len
sendBuffer[3] = addrTo >> 8 & 0xFF;
sendBuffer[4] = addrTo & 0xFF;
for (uint16_t i = dataStart; (i < dataStart + len) && (data != nullptr); i++) {
sendBuffer[i] = ((uint8_t*)data)[i - dataStart];
for (uint16_t i = dataStart; (i < dataStart + len) && (data != nullptr); i++)
{
sendBuffer[i] = ((uint8_t *)data)[i - dataStart];
}
// data crc
@ -79,7 +92,8 @@ void IR_Encoder::sendData(uint16_t addrTo, uint8_t* data = nullptr, uint8_t len
rawSend(sendBuffer, packSize);
}
void IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte = 0) {
void IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte = 0)
{
constexpr uint8_t packsize = msgBytes + addrBytes + 1U + crcBytes;
memset(sendBuffer, 0x00, dataByteSizeMax);
sendBuffer[0] = IR_MSG_ACCEPT << 5;
@ -101,7 +115,8 @@ void IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte = 0) {
rawSend(sendBuffer, packsize);
}
void IR_Encoder::sendRequest(uint16_t addrTo) {
void IR_Encoder::sendRequest(uint16_t addrTo)
{
constexpr uint8_t packsize = msgBytes + addrBytes + addrBytes + crcBytes;
memset(sendBuffer, 0x00, dataByteSizeMax);
sendBuffer[0] = IR_MSG_REQUEST << 5;
@ -111,7 +126,7 @@ void IR_Encoder::sendRequest(uint16_t addrTo) {
sendBuffer[1] = id >> 8 & 0xFF;
sendBuffer[2] = id & 0xFF;
//addr_to
// addr_to
sendBuffer[3] = addrTo >> 8 & 0xFF;
sendBuffer[4] = addrTo & 0xFF;
@ -122,16 +137,22 @@ void IR_Encoder::sendRequest(uint16_t addrTo) {
rawSend(sendBuffer, packsize);
}
void IR_Encoder::sendBack(uint8_t* data = nullptr, uint8_t len = 0) {
void IR_Encoder::sendBack(uint8_t *data = nullptr, uint8_t len = 0)
{
_sendBack(false, 0, data, len);
}
void IR_Encoder::sendBackTo(uint16_t addrTo, uint8_t* data = nullptr, uint8_t len = 0) {
void IR_Encoder::sendBackTo(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0)
{
_sendBack(true, addrTo, data, len);
}
void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t* data, uint8_t len) {
if (len > bytePerPack) { return; }
void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len)
{
if (len > bytePerPack)
{
return;
}
memset(sendBuffer, 0x00, dataByteSizeMax);
uint8_t dataStart = msgBytes + addrBytes + (isAdressed ? addrBytes : 0);
@ -151,8 +172,9 @@ void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t* data, uint
sendBuffer[3] = addrTo >> 8 & 0xFF;
sendBuffer[4] = addrTo & 0xFF;
for (uint16_t i = dataStart; i < dataStart + len; i++) {
sendBuffer[i] = ((uint8_t*)data)[i - dataStart];
for (uint16_t i = dataStart; i < dataStart + len; i++)
{
sendBuffer[i] = ((uint8_t *)data)[i - dataStart];
}
// data crc
@ -163,18 +185,22 @@ void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t* data, uint
rawSend(sendBuffer, packSize);
}
void IR_Encoder::setDecoder_isSending() {
if (decodersCount) {
for (uint8_t i = 0; i < decodersCount; i++) {
void IR_Encoder::setDecoder_isSending()
{
if (decodersCount)
{
for (uint8_t i = 0; i < decodersCount; i++)
{
blindDecoders[i]->isPairSending ^= id;
}
}
}
void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
if (isSending) {
//TODO: Обработка повторной отправки
void IR_Encoder::rawSend(uint8_t *ptr, uint8_t len)
{
if (isSending)
{
// TODO: Обработка повторной отправки
return;
}
@ -200,94 +226,110 @@ void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
sei();
}
void IR_Encoder::isr() {
if (!isSending) return;
void IR_Encoder::isr()
{
if (!isSending)
return;
ir_out_virtual = !ir_out_virtual && state;
if (toggleCounter) {
if (toggleCounter)
{
toggleCounter--;
} else {
}
else
{
IsrStart:
switch (signal) {
case noSignal:
signal = preamb;
// сброс счетчиков
// ...
isSending = false;
setDecoder_isSending();
return;
break;
switch (signal)
{
case noSignal:
signal = preamb;
// сброс счетчиков
// ...
isSending = false;
setDecoder_isSending();
return;
break;
case preamb:
if (preambFrontCounter) {
preambFrontCounter--;
toggleCounter = preambToggle; // Вторая и последующие генерации для этого signal
} else {// Конец преамбулы, переход на следующий signal
signal = data;
state = !LOW; // Инверсное состояние первой генерации следующего signal
goto IsrStart; // Применение новых параметров в этй же итерации прерывания
case preamb:
if (preambFrontCounter)
{
preambFrontCounter--;
toggleCounter = preambToggle; // Вторая и последующие генерации для этого signal
}
else
{ // Конец преамбулы, переход на следующий signal
signal = data;
state = !LOW; // Инверсное состояние первой генерации следующего signal
goto IsrStart; // Применение новых параметров в этй же итерации прерывания
}
break;
case data:
if (dataSequenceCounter)
{
if (!(dataSequenceCounter & 1U))
{ // если чётный - смена бита
currentBitSequence = ((sendBuffer[dataByteCounter] >> dataBitCounter) & 1U) ? bitHigh : bitLow; // определение текущего бита
dataBitCounter--;
}
toggleCounter = currentBitSequence[!state];
dataSequenceCounter--;
}
else
{ // Конец data, переход на следующий signal
syncLastBit = ((sendBuffer[dataByteCounter]) & 1U);
dataByteCounter++;
dataBitCounter = bitPerByte - 1;
dataSequenceCounter = bitPerByte * 2;
signal = sync;
goto IsrStart; // Применение новых параметров в этй же итерации прерывания
}
break;
break;
case data:
if (dataSequenceCounter) {
if (!(dataSequenceCounter & 1U)) { // если чётный - смена бита
currentBitSequence = ((sendBuffer[dataByteCounter] >> dataBitCounter) & 1U) ? bitHigh : bitLow; // определение текущего бита
dataBitCounter--;
case sync:
if (syncSequenceCounter)
{
if (!(syncSequenceCounter & 1U))
{ // если чётный - смена бита
if (syncSequenceCounter == 2)
{ // Если последний бит
currentBitSequence = ((sendBuffer[dataByteCounter]) & 0b10000000) ? bitLow : bitHigh;
}
else
{
currentBitSequence = syncLastBit ? bitLow : bitHigh; // определение текущего бита
syncLastBit = !syncLastBit;
}
toggleCounter = currentBitSequence[!state];
dataSequenceCounter--;
} else { // Конец data, переход на следующий signal
syncLastBit = ((sendBuffer[dataByteCounter]) & 1U);
dataByteCounter++;
dataBitCounter = bitPerByte - 1;
dataSequenceCounter = bitPerByte * 2;
signal = sync;
goto IsrStart; // Применение новых параметров в этй же итерации прерывания
}
break;
toggleCounter = currentBitSequence[!state];
syncSequenceCounter--;
}
else
{ // Конец sync, переход на следующий signal
signal = data;
syncSequenceCounter = syncBits * 2;
case sync:
if (syncSequenceCounter) {
if (!(syncSequenceCounter & 1U)) { // если чётный - смена бита
if (syncSequenceCounter == 2) { // Если последний бит
currentBitSequence = ((sendBuffer[dataByteCounter]) & 0b10000000) ? bitLow : bitHigh;
} else {
currentBitSequence = syncLastBit ? bitLow : bitHigh; // определение текущего бита
syncLastBit = !syncLastBit;
}
}
toggleCounter = currentBitSequence[!state];
syncSequenceCounter--;
} else { // Конец sync, переход на следующий signal
signal = data;
syncSequenceCounter = syncBits * 2;
if (dataByteCounter >= sendLen) { // определение конца данных
signal = noSignal;
}
goto IsrStart; // Применение новых параметров в этй же итерации прерывания
if (dataByteCounter >= sendLen)
{ // определение конца данных
signal = noSignal;
}
break;
goto IsrStart; // Применение новых параметров в этй же итерации прерывания
}
break;
default:
return;
break;
default:
return;
break;
}
state = !state;
}
}
void old() {///////////////////////////////////////////////////////
void old()
{ ///////////////////////////////////////////////////////
// void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
// /*tmp*/bool LOW_FIRST = false;/*tmp*/
@ -312,12 +354,14 @@ void old() {///////////////////////////////////////////////////////
// }
}
void IR_Encoder::sendByte(uint8_t byte, bool* prev, bool LOW_FIRST) {
void IR_Encoder::sendByte(uint8_t byte, bool *prev, bool LOW_FIRST)
{
uint8_t mask = LOW_FIRST ? 0b00000001 : 0b10000000;
for (uint8_t bitShift = 8; bitShift; bitShift--) {
for (uint8_t bitShift = 8; bitShift; bitShift--)
{
// digitalWrite(9, HIGH);
// digitalWrite(9, LOW);
byte& mask ? send_HIGH(prev) : send_LOW();
byte &mask ? send_HIGH(prev) : send_LOW();
*prev = byte & mask;
LOW_FIRST ? mask <<= 1 : mask >>= 1;
// digitalWrite(9, HIGH);
@ -325,25 +369,30 @@ void IR_Encoder::sendByte(uint8_t byte, bool* prev, bool LOW_FIRST) {
}
}
void IR_Encoder::addSync(bool* prev, bool* next) {
switch (syncBits) {
case 0: break;
case 1:
void IR_Encoder::addSync(bool *prev, bool *next)
{
switch (syncBits)
{
case 0:
break;
case 1:
*prev ? send_LOW() : send_HIGH();
*prev = !*prev;
break;
default:
for (int16_t i = 0; i < syncBits - 1; i++)
{
*prev ? send_LOW() : send_HIGH();
*prev = !*prev;
break;
default:
for (int16_t i = 0; i < syncBits - 1; i++) {
*prev ? send_LOW() : send_HIGH();
*prev = !*prev;
}
*next ? send_LOW() : send_HIGH(0);
*prev = !*next;
break;
}
*next ? send_LOW() : send_HIGH(0);
*prev = !*next;
break;
}
}
void IR_Encoder::send_HIGH(bool prevBite = 1) {
void IR_Encoder::send_HIGH(bool prevBite = 1)
{
// if (/* prevBite */1) {
// meanderBlock(bitPauseTakts * 2, halfPeriod, LOW);
@ -352,21 +401,20 @@ void IR_Encoder::send_HIGH(bool prevBite = 1) {
// meanderBlock(bitTakts - (bitActiveTakts - bitPauseTakts), halfPeriod, LOW);
// meanderBlock(bitActiveTakts - bitPauseTakts, halfPeriod, HIGH);
// }
}
void IR_Encoder::send_LOW() {
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) {
void IR_Encoder::send_EMPTY(uint8_t count)
{
// for (size_t i = 0; i < count * 2; i++) {
// meanderBlock((bitPauseTakts * 2 + bitActiveTakts), halfPeriod, prevPreambBit);
// meanderBlock((bitPauseTakts * 2 + bitActiveTakts), halfPeriod, prevPreambBit);
// prevPreambBit = !prevPreambBit;
// }
// meanderBlock(bitPauseTakts * 2 + bitActiveTakts, halfPeriod, 0); //TODO: Отодвинуть преамбулу
}