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

STM First Test

Browse Source
This commit is contained in:
DashyFox
2024-04-16 15:52:59 +03:00
parent ff306e7fae
commit 27a5b28a17
6 changed files with 375 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

519
IR-protocol.ino
View File

@ -4,13 +4,18 @@
#include "MemoryCheck.h" #include "MemoryCheck.h"
/////////////// Pinout /////////////// /////////////// Pinout ///////////////
#define encForward_PIN 5 #define encForward_PIN PB5
#define encBackward_PIN 6 #define encBackward_PIN PB4
#define LoopOut 12 #define dec1_PIN PB7
#define ISR_Out 10 #define dec2_PIN PB8
#define TestOut 13 #define LoopOut PB3
// #define ISR_Out 10
// #define TestOut 13
#define SignalDetectLed PB15
//////////////// Ini ///////////////// //////////////// Ini /////////////////
@ -19,173 +24,183 @@
//////////////// Var ///////////////// //////////////// Var /////////////////
IR_Decoder decForward(2, 555); IR_Decoder decForward(PB7, 555);
IR_Decoder decBackward(3, 777); IR_Decoder decBackward(PB8, 777);
IR_Encoder encForward(42/* , &decBackward */); IR_Encoder encForward(42 /* , &decBackward */);
// IR_Encoder encBackward(321, encBackward_PIN); // IR_Encoder encBackward(321, encBackward_PIN);
// IR_Encoder encTree(325, A2); // IR_Encoder encTree(325, A2);
//////////////////////// Функции прерываний //////////////////////// //////////////////////// Функции прерываний ////////////////////////
void decForwardISR() { void decForwardISR()
{
decForward.isr(); decForward.isr();
// Serial.println("ISR");
} }
// void decBackwardISR() { void decBackwardISR()
// decBackward.isr(); {
// } decBackward.isr();
// Serial.println("ISR");
}
static uint8_t* portOut; static uint8_t *portOut;
ISR(TIMER2_COMPA_vect) {
void EncoderISR()
{
encForward.isr(); encForward.isr();
// encBackward.isr(); // encBackward.isr();
// encTree.isr(); // encTree.isr();
//TODO: Сделать выбор порта // TODO: Сделать выбор порта
*portOut = (*portOut & 0b11001111) | // *portOut = (*portOut & 0b11001111) |
( // (
encForward.ir_out_virtual << 5U // encForward.ir_out_virtual << 5U
// | encBackward.ir_out_virtual << 6U // // | encBackward.ir_out_virtual << 6U
// | encTree.ir_out_virtual << 2U // // | encTree.ir_out_virtual << 2U
); // );
digitalWrite(PB5, encForward.ir_out_virtual);
} }
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
uint8_t data0 [] = { }; uint8_t data0[] = {};
uint8_t data1 [] = { 42 }; uint8_t data1[] = {42};
uint8_t data2 [] = { 42 , 127 }; uint8_t data2[] = {42, 127};
uint8_t data3 [] = { 42 , 127, 137 }; uint8_t data3[] = {42, 127, 137};
uint8_t data4 [] = { 42 , 127, 137, 255 }; uint8_t data4[] = {42, 127, 137, 255};
uint32_t loopTimer; uint32_t loopTimer;
uint8_t sig = 0; uint8_t sig = 0;
uint16_t targetAddr = IR_Broadcast; uint16_t targetAddr = IR_Broadcast;
Timer t1(500, millis, []() { Timer t1(500, millis, []()
{
// Serial.println(sig);
// Serial.println(sig); switch (sig)
{
case 0:
encForward.sendData(targetAddr);
break;
case 1:
encForward.sendData(targetAddr, data1, sizeof(data1));
break;
case 2:
encForward.sendData(targetAddr, data2, sizeof(data2));
break;
case 3:
encForward.sendData(targetAddr, data3, sizeof(data3));
break;
case 4:
encForward.sendData(targetAddr, data4, sizeof(data4));
break;
switch (sig) { case 10:
case 0: encForward.sendData(targetAddr, data0, sizeof(data0), true);
encForward.sendData(targetAddr); break;
break; case 11:
case 1: encForward.sendData(targetAddr, data1, sizeof(data1), true);
encForward.sendData(targetAddr, data1, sizeof(data1)); break;
break; case 12:
case 2: encForward.sendData(targetAddr, data2, sizeof(data2), true);
encForward.sendData(targetAddr, data2, sizeof(data2)); break;
break; case 13:
case 3: encForward.sendData(targetAddr, data3, sizeof(data3), true);
encForward.sendData(targetAddr, data3, sizeof(data3)); break;
break; case 14:
case 4: encForward.sendData(targetAddr, data4, sizeof(data4), true);
encForward.sendData(targetAddr, data4, sizeof(data4)); break;
break;
case 10: case 20:
encForward.sendData(targetAddr, data0, sizeof(data0), true); encForward.sendBack();
break; break;
case 11: case 21:
encForward.sendData(targetAddr, data1, sizeof(data1), true); encForward.sendBack(data1, sizeof(data1));
break; break;
case 12: case 22:
encForward.sendData(targetAddr, data2, sizeof(data2), true); encForward.sendBack(data2, sizeof(data2));
break; break;
case 13: case 23:
encForward.sendData(targetAddr, data3, sizeof(data3), true); encForward.sendBack(data3, sizeof(data3));
break; break;
case 14: case 24:
encForward.sendData(targetAddr, data4, sizeof(data4), true); encForward.sendBack(data4, sizeof(data4));
break; break;
case 30:
encForward.sendBackTo(targetAddr);
break;
case 31:
encForward.sendBackTo(targetAddr, data1, sizeof(data1));
break;
case 32:
encForward.sendBackTo(targetAddr, data2, sizeof(data2));
break;
case 33:
encForward.sendBackTo(targetAddr, data3, sizeof(data3));
break;
case 34:
encForward.sendBackTo(targetAddr, data4, sizeof(data4));
break;
case 41:
encForward.sendRequest(targetAddr);
break;
case 42:
encForward.sendAccept(targetAddr);
break;
case 20: default:
encForward.sendBack(); break;
break; }
case 21: // encBackward.sendData(IR_Broadcast, data2);
encForward.sendBack(data1, sizeof(data1)); // encTree.sendData(IR_Broadcast, rawData3);
break; });
case 22: Timer t2(500, millis, []()
encForward.sendBack(data2, sizeof(data2)); { digitalToggle(LED_BUILTIN); });
break;
case 23:
encForward.sendBack(data3, sizeof(data3));
break;
case 24:
encForward.sendBack(data4, sizeof(data4));
break;
case 30: Timer signalDetectTimer;
encForward.sendBackTo(targetAddr);
break;
case 31:
encForward.sendBackTo(targetAddr, data1, sizeof(data1));
break;
case 32:
encForward.sendBackTo(targetAddr, data2, sizeof(data2));
break;
case 33:
encForward.sendBackTo(targetAddr, data3, sizeof(data3));
break;
case 34:
encForward.sendBackTo(targetAddr, data4, sizeof(data4));
break;
case 41:
encForward.sendRequest(targetAddr);
break;
case 42:
encForward.sendAccept(targetAddr);
break;
default:
break;
}
// encBackward.sendData(IR_Broadcast, data2);
// encTree.sendData(IR_Broadcast, rawData3);
});
Timer t2(500, millis, []() {
digitalToggle(13);
});
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
void setup() { void setup()
IR_Encoder::timerSetup(); {
portOut = &PORTD; // disableDebugPorts();
Timer3.setPeriod(1000000U / carrierFrec / 2);
// Timer3.attachCompare1Interrupt(EncoderISR);
Timer1.setMode(1,timer_mode::TIMER_INPUT_CAPTURE);
Serial.begin(SERIAL_SPEED); Serial.begin(SERIAL_SPEED);
Serial.println(F(INFO)); Serial.println(F(INFO));
pinMode(A0, INPUT_PULLUP); // pinMode(A0, INPUT_PULLUP);
pinMode(A1, INPUT_PULLUP); // pinMode(A1, INPUT_PULLUP);
pinMode(A2, INPUT_PULLUP); // pinMode(A2, INPUT_PULLUP);
pinMode(A3, INPUT_PULLUP); // pinMode(A3, INPUT_PULLUP);
pinMode(LoopOut, OUTPUT); pinMode(LoopOut, OUTPUT);
pinMode(ISR_Out, OUTPUT); pinMode(SignalDetectLed, OUTPUT);
// pinMode(ISR_Out, OUTPUT);
pinMode(2, INPUT_PULLUP); pinMode(2, INPUT_PULLUP);
pinMode(3, INPUT_PULLUP); pinMode(3, INPUT_PULLUP);
pinMode(8, OUTPUT); // pinMode(8, OUTPUT);
pinMode(9, OUTPUT); // pinMode(9, OUTPUT);
pinMode(11, OUTPUT); // pinMode(11, OUTPUT);
pinMode(13, OUTPUT); // pinMode(13, OUTPUT);
pinMode(encForward_PIN, OUTPUT); pinMode(encForward_PIN, OUTPUT);
pinMode(encBackward_PIN, OUTPUT); pinMode(encBackward_PIN, OUTPUT);
pinMode(13, OUTPUT); pinMode(LED_BUILTIN, OUTPUT);
// IR_DecoderRaw* blindFromForward [] { &decForward, &decBackward }; // IR_DecoderRaw* blindFromForward [] { &decForward, &decBackward };
// encForward.setBlindDecoders(blindFromForward, sizeof(blindFromForward) / sizeof(IR_DecoderRaw*)); // encForward.setBlindDecoders(blindFromForward, sizeof(blindFromForward) / sizeof(IR_DecoderRaw*));
attachInterrupt(dec1_PIN, decForwardISR, CHANGE); // D2
attachInterrupt(0, decForwardISR, CHANGE); // D2 // attachInterrupt(dec2_PIN, decBackwardISR, CHANGE); // D3
// attachInterrupt(1, decBackwardISR, CHANGE); // D3
} }
void loop() { void loop()
{
digitalToggle(LoopOut); digitalToggle(LoopOut);
Timer::tick(); Timer::tick();
@ -195,61 +210,80 @@ void loop() {
status(decForward); status(decForward);
// status(decBackward); // status(decBackward);
// Serial.println(micros() - loopTimer); // Serial.println(micros() - loopTimer);
// loopTimer = micros(); // loopTimer = micros();
// delayMicroseconds(120*5); // delayMicroseconds(120*5);
if (Serial.available()) { if (Serial.available())
{
uint8_t in = Serial.parseInt(); uint8_t in = Serial.parseInt();
switch (in) { switch (in)
case 100: {
targetAddr = IR_Broadcast; case 100:
break; targetAddr = IR_Broadcast;
case 101: break;
targetAddr = 555; case 101:
break; targetAddr = 555;
case 102: break;
targetAddr = 777; case 102:
break; targetAddr = 777;
break;
default: default:
sig = in; sig = in;
break; break;
} }
} }
} }
void detectSignal()
{
digitalWrite(SignalDetectLed, HIGH);
signalDetectTimer.delay(50, millis, []()
{ digitalWrite(SignalDetectLed, LOW); });
}
// test
void status(IR_Decoder &dec)
{
if (dec.gotData.available())
//test {
void status(IR_Decoder& dec) { detectSignal();
if (dec.gotData.available()) {
String str; String str;
if (/* dec.gotData.getDataPrt()[1] */1) { if (/* dec.gotData.getDataPrt()[1] */ 1)
str += ("Data on pin "); str += (dec.isrPin); str += "\n"; {
str += ("Data on pin ");
str += (dec.isrPin);
str += "\n";
uint8_t msg = dec.gotData.getMsgRAW(); uint8_t msg = dec.gotData.getMsgRAW();
str += (" MSG: "); str += (" MSG: ");
for (size_t i = 0; i < 8; i++) { for (size_t i = 0; i < 8; i++)
if (i == 3) str += " "; {
if (i == 3)
str += " ";
str += (msg >> (7 - i)) & 1U; str += (msg >> (7 - i)) & 1U;
} }
str += "\n"; str += "\n";
str += (" DATA SIZE: "); str += (dec.gotData.getDataSize()); str += "\n"; str += (" DATA SIZE: ");
str += (" ADDRESS FROM: "); str += (dec.gotData.getAddrFrom()); str += "\n"; str += (dec.gotData.getDataSize());
str += (" ADDRESS TO: "); str += (dec.gotData.getAddrTo()); str += "\n"; str += "\n";
str += (" ADDRESS FROM: ");
str += (dec.gotData.getAddrFrom());
str += "\n";
str += (" ADDRESS TO: ");
str += (dec.gotData.getAddrTo());
str += "\n";
// str += (" CRC PACK: "); str += (dec.gotData.getCrcIN()); str += "\n"; // str += (" CRC PACK: "); str += (dec.gotData.getCrcIN()); str += "\n";
// str += (" CRC CALC: "); str += (dec.gotData.getCrcCALC()); str += "\n"; // str += (" CRC CALC: "); str += (dec.gotData.getCrcCALC()); str += "\n";
str += "\n"; str += "\n";
for (size_t i = 0; i < min(10, dec.gotData.getDataSize()); i++) { for (size_t i = 0; i < min(10, dec.gotData.getDataSize()); i++)
switch (i) { {
switch (i)
{
// case 0: // case 0:
// str += (" ADDR: "); // str += (" ADDR: ");
// break; // break;
@ -257,49 +291,71 @@ void status(IR_Decoder& dec) {
// str += (" CMD: "); // str += (" CMD: ");
// break; // break;
default: default:
str += (" Data["); str += (i); str += ("]: "); str += (" Data[");
break; str += (i);
str += ("]: ");
break;
} }
str += (dec.gotData.getDataPrt()[i]); str += "\n"; str += (dec.gotData.getDataPrt()[i]);
str += "\n";
} }
str += ("\n*******ErrAll: ");
str += ("\n*******ErrAll: "); str += (dec.gotData.getErrorCount()); str += "\n"; str += (dec.gotData.getErrorCount());
str += ("**ErrDistance: "); str += ((int)(dec.gotData.getErrorHighSignal() - dec.gotData.getErrorLowSignal())); str += "\n"; str += "\n";
str += ("**ErrDistance: ");
str += ((int)(dec.gotData.getErrorHighSignal() - dec.gotData.getErrorLowSignal()));
str += "\n";
str += "\n"; str += "\n";
} else { }
str += ("SELF"); str += "\n"; else
{
str += ("SELF");
str += "\n";
str += "\n"; str += "\n";
} }
// obj->resetAvailable(); // obj->resetAvailable();
Serial.write(str.c_str()); Serial.write(str.c_str());
} }
if (dec.gotBackData.available()) { if (dec.gotBackData.available())
{
detectSignal();
String str; String str;
if (/* dec.gotData.getDataPrt()[1] */1) { if (/* dec.gotData.getDataPrt()[1] */ 1)
str += ("BackData on pin "); str += (dec.isrPin); str += "\n"; {
str += ("BackData on pin ");
str += (dec.isrPin);
str += "\n";
uint8_t msg = dec.gotBackData.getMsgRAW(); uint8_t msg = dec.gotBackData.getMsgRAW();
str += (" MSG: "); str += (" MSG: ");
for (size_t i = 0; i < 8; i++) { for (size_t i = 0; i < 8; i++)
if (i == 3) str += " "; {
if (i == 3)
str += " ";
str += (msg >> (7 - i)) & 1U; str += (msg >> (7 - i)) & 1U;
} }
str += "\n"; str += "\n";
str += (" DATA SIZE: "); str += (dec.gotBackData.getDataSize()); str += "\n"; str += (" DATA SIZE: ");
str += (" ADDRESS FROM: "); str += (dec.gotBackData.getAddrFrom()); str += "\n"; str += (dec.gotBackData.getDataSize());
str += "\n";
str += (" ADDRESS FROM: ");
str += (dec.gotBackData.getAddrFrom());
str += "\n";
// str += (" ADDRESS TO: "); str += (dec.gotBackData.getAddrTo()); str += "\n"; // str += (" ADDRESS TO: "); str += (dec.gotBackData.getAddrTo()); str += "\n";
// str += (" CRC PACK: "); str += (dec.gotBackData.getCrcIN()); str += "\n"; // str += (" CRC PACK: "); str += (dec.gotBackData.getCrcIN()); str += "\n";
// str += (" CRC CALC: "); str += (dec.gotBackData.getCrcCALC()); str += "\n"; // str += (" CRC CALC: "); str += (dec.gotBackData.getCrcCALC()); str += "\n";
str += "\n"; str += "\n";
for (size_t i = 0; i < min(10, dec.gotBackData.getDataSize()); i++) { for (size_t i = 0; i < min(10, dec.gotBackData.getDataSize()); i++)
switch (i) { {
switch (i)
{
// case 0: // case 0:
// str += (" ADDR: "); // str += (" ADDR: ");
// break; // break;
@ -307,98 +363,135 @@ void status(IR_Decoder& dec) {
// str += (" CMD: "); // str += (" CMD: ");
// break; // break;
default: default:
str += (" Data["); str += (i); str += ("]: "); str += (" Data[");
break; str += (i);
str += ("]: ");
break;
} }
str += (dec.gotBackData.getDataPrt()[i]); str += "\n"; str += (dec.gotBackData.getDataPrt()[i]);
str += "\n";
} }
str += ("\n*******ErrAll: ");
str += ("\n*******ErrAll: "); str += (dec.gotBackData.getErrorCount()); str += "\n"; str += (dec.gotBackData.getErrorCount());
str += ("**ErrDistance: "); str += ((int)(dec.gotBackData.getErrorHighSignal() - dec.gotBackData.getErrorLowSignal())); str += "\n"; str += "\n";
str += ("**ErrDistance: ");
str += ((int)(dec.gotBackData.getErrorHighSignal() - dec.gotBackData.getErrorLowSignal()));
str += "\n";
str += "\n"; str += "\n";
} else { }
str += ("SELF"); str += "\n"; else
{
str += ("SELF");
str += "\n";
str += "\n"; str += "\n";
} }
// obj->resetAvailable(); // obj->resetAvailable();
Serial.write(str.c_str()); Serial.write(str.c_str());
} }
if (dec.gotAccept.available()) { if (dec.gotAccept.available())
{
detectSignal();
String str; String str;
if (/* dec.gotData.getDataPrt()[1] */1) { if (/* dec.gotData.getDataPrt()[1] */ 1)
str += ("Accept on pin "); str += (dec.isrPin); str += "\n"; {
str += ("Accept on pin ");
str += (dec.isrPin);
str += "\n";
uint8_t msg = dec.gotAccept.getMsgRAW(); uint8_t msg = dec.gotAccept.getMsgRAW();
str += (" MSG: "); str += (" MSG: ");
for (size_t i = 0; i < 8; i++) { for (size_t i = 0; i < 8; i++)
if (i == 3) str += " "; {
if (i == 3)
str += " ";
str += (msg >> (7 - i)) & 1U; str += (msg >> (7 - i)) & 1U;
} }
str += "\n"; str += "\n";
// str += (" DATA SIZE: "); str += (dec.gotAccept.getDataSize()); str += "\n"; // str += (" DATA SIZE: "); str += (dec.gotAccept.getDataSize()); str += "\n";
str += (" ADDRESS FROM: "); str += (dec.gotAccept.getAddrFrom()); str += "\n"; str += (" ADDRESS FROM: ");
str += (dec.gotAccept.getAddrFrom());
str += "\n";
// str += (" ADDRESS TO: "); str += (dec.gotAccept.getAddrTo()); str += "\n"; // str += (" ADDRESS TO: "); str += (dec.gotAccept.getAddrTo()); str += "\n";
// str += (" CRC PACK: "); str += (dec.gotAccept.getCrcIN()); str += "\n"; // str += (" CRC PACK: "); str += (dec.gotAccept.getCrcIN()); str += "\n";
// str += (" CRC CALC: "); str += (dec.gotAccept.getCrcCALC()); str += "\n"; // str += (" CRC CALC: "); str += (dec.gotAccept.getCrcCALC()); str += "\n";
str += "\n"; str += "\n";
str += (" Data: "); str += (dec.gotAccept.getCustomByte()); str += (" Data: ");
str += (dec.gotAccept.getCustomByte());
str += ("\n\n*******ErrAll: ");
str += (dec.gotAccept.getErrorCount());
str += ("\n\n*******ErrAll: "); str += (dec.gotAccept.getErrorCount()); str += "\n"; str += "\n";
str += ("**ErrDistance: "); str += ((int)(dec.gotAccept.getErrorHighSignal() - dec.gotAccept.getErrorLowSignal())); str += "\n"; str += ("**ErrDistance: ");
str += ((int)(dec.gotAccept.getErrorHighSignal() - dec.gotAccept.getErrorLowSignal()));
str += "\n";
str += "\n"; str += "\n";
} else { }
str += ("SELF"); str += "\n"; else
{
str += ("SELF");
str += "\n";
str += "\n"; str += "\n";
} }
// obj->resetAvailable(); // obj->resetAvailable();
Serial.write(str.c_str()); Serial.write(str.c_str());
} }
if (dec.gotRequest.available()) { if (dec.gotRequest.available())
{
detectSignal();
String str; String str;
if (/* dec.gotData.getDataPrt()[1] */1) { if (/* dec.gotData.getDataPrt()[1] */ 1)
str += ("Request on pin "); str += (dec.isrPin); str += "\n"; {
str += ("Request on pin ");
str += (dec.isrPin);
str += "\n";
uint8_t msg = dec.gotRequest.getMsgRAW(); uint8_t msg = dec.gotRequest.getMsgRAW();
str += (" MSG: "); str += (" MSG: ");
for (size_t i = 0; i < 8; i++) { for (size_t i = 0; i < 8; i++)
if (i == 3) str += " "; {
if (i == 3)
str += " ";
str += (msg >> (7 - i)) & 1U; str += (msg >> (7 - i)) & 1U;
} }
str += "\n"; str += "\n";
// str += (" DATA SIZE: "); str += (dec.gotRequest.getDataSize()); str += "\n"; // str += (" DATA SIZE: "); str += (dec.gotRequest.getDataSize()); str += "\n";
str += (" ADDRESS FROM: "); str += (dec.gotRequest.getAddrFrom()); str += "\n"; str += (" ADDRESS FROM: ");
str += (" ADDRESS TO: "); str += (dec.gotRequest.getAddrTo()); str += "\n"; str += (dec.gotRequest.getAddrFrom());
str += "\n";
str += (" ADDRESS TO: ");
str += (dec.gotRequest.getAddrTo());
str += "\n";
// str += (" CRC PACK: "); str += (dec.gotRequest.getCrcIN()); str += "\n"; // str += (" CRC PACK: "); str += (dec.gotRequest.getCrcIN()); str += "\n";
// str += (" CRC CALC: "); str += (dec.gotRequest.getCrcCALC()); str += "\n"; // str += (" CRC CALC: "); str += (dec.gotRequest.getCrcCALC()); str += "\n";
str += "\n"; str += "\n";
str += ("\n*******ErrAll: ");
str += ("\n*******ErrAll: "); str += (dec.gotRequest.getErrorCount()); str += "\n"; str += (dec.gotRequest.getErrorCount());
str += ("**ErrDistance: "); str += ((int)(dec.gotRequest.getErrorHighSignal() - dec.gotRequest.getErrorLowSignal())); str += "\n"; str += "\n";
str += ("**ErrDistance: ");
str += ((int)(dec.gotRequest.getErrorHighSignal() - dec.gotRequest.getErrorLowSignal()));
str += "\n";
str += "\n"; str += "\n";
} else { }
str += ("SELF"); str += "\n"; else
{
str += ("SELF");
str += "\n";
str += "\n"; str += "\n";
} }
// obj->resetAvailable(); // obj->resetAvailable();
Serial.write(str.c_str()); Serial.write(str.c_str());
} }
} }

27
IR_DecoderRaw.cpp
View File

@ -1,7 +1,7 @@
#include "IR_DecoderRaw.h" #include "IR_DecoderRaw.h"
#include "IR_Encoder.h" #include "IR_Encoder.h"
IR_DecoderRaw::IR_DecoderRaw(const uint8_t isrPin, uint16_t addr, IR_Encoder *encPair = nullptr) : isrPin(isrPin), encoder(encPair) IR_DecoderRaw::IR_DecoderRaw(const uint8_t isrPin, uint16_t addr, IR_Encoder *encPair) : isrPin(isrPin), encoder(encPair)
{ {
id = addr; id = addr;
prevRise = prevFall = prevPrevFall = prevPrevRise = 0; prevRise = prevFall = prevPrevFall = prevPrevRise = 0;
@ -9,6 +9,13 @@ IR_DecoderRaw::IR_DecoderRaw(const uint8_t isrPin, uint16_t addr, IR_Encoder *en
{ {
encPair->decPair = this; encPair->decPair = this;
} }
#ifdef IRDEBUG
pinMode(wrHigh, OUTPUT);
pinMode(wrLow, OUTPUT);
pinMode(writeOp, OUTPUT);
pinMode(errOut, OUTPUT);
#endif
} }
//////////////////////////////////// isr /////////////////////////////////////////// //////////////////////////////////// isr ///////////////////////////////////////////
@ -19,7 +26,7 @@ void IR_DecoderRaw::isr()
return; return;
subBuffer[currentSubBufferIndex].next = nullptr; subBuffer[currentSubBufferIndex].next = nullptr;
subBuffer[currentSubBufferIndex].dir = (PIND >> isrPin) & 1; subBuffer[currentSubBufferIndex].dir = digitalRead(isrPin);
subBuffer[currentSubBufferIndex].time = micros(); subBuffer[currentSubBufferIndex].time = micros();
if (firstUnHandledFront == nullptr) if (firstUnHandledFront == nullptr)
@ -95,17 +102,16 @@ void IR_DecoderRaw::listenStart()
void IR_DecoderRaw::tick() void IR_DecoderRaw::tick()
{ {
FrontStorage currentFront; FrontStorage currentFront;
uint8_t oldSREG = SREG; noInterrupts();
cli();
listenStart(); listenStart();
if (firstUnHandledFront == nullptr) if (firstUnHandledFront == nullptr)
{ {
isSubBufferOverflow = false; isSubBufferOverflow = false;
SREG = oldSREG; interrupts();
return; return;
} // Если данных нет - ничего не делаем } // Если данных нет - ничего не делаем
currentFront = *((FrontStorage *)firstUnHandledFront); // найти следующий необработанный фронт/спад currentFront = *((FrontStorage *)firstUnHandledFront); // найти следующий необработанный фронт/спад
SREG = oldSREG; interrupts();
if (currentFront.next == nullptr) if (currentFront.next == nullptr)
{ {
isRecive = false; isRecive = false;
@ -161,7 +167,7 @@ void IR_DecoderRaw::tick()
{ {
if (isPreamb) if (isPreamb)
{ // первый фронт после { // первый фронт после
// gotTune.set(riseSyncTime); // gotTune.set(riseSyncTime);
} }
isPreamb = false; isPreamb = false;
} }
@ -187,7 +193,7 @@ void IR_DecoderRaw::tick()
if (aroundRise(risePeriod)) if (aroundRise(risePeriod))
{ // тактирование есть, сигнал хороший - без ошибок(?) { // тактирование есть, сигнал хороший - без ошибок(?)
if (highTime > riseTimeMin >> 1) if (highTime > riseTimeMin / 2U)
{ // 1 { // 1
#ifdef IRDEBUG #ifdef IRDEBUG
digitalWrite(wrHigh, 1); digitalWrite(wrHigh, 1);
@ -344,13 +350,12 @@ void IR_DecoderRaw::tick()
digitalWrite(writeOp, isPreamb); digitalWrite(writeOp, isPreamb);
#endif #endif
//////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////
oldSREG = SREG; // noInterrupts();
cli();
if (firstUnHandledFront != nullptr) if (firstUnHandledFront != nullptr)
{ {
firstUnHandledFront = firstUnHandledFront->next; // переместить флаг на следующий элемент для обработки (next or nullptr) firstUnHandledFront = firstUnHandledFront->next; // переместить флаг на следующий элемент для обработки (next or nullptr)
} }
SREG = oldSREG; // interrupts();
} }
void IR_DecoderRaw::writeToBuffer(bool bit) void IR_DecoderRaw::writeToBuffer(bool bit)

16
IR_DecoderRaw.h
View File

@ -1,15 +1,15 @@
#pragma once #pragma once
#include "IR_config.h" #include "IR_config.h"
// #define IRDEBUG #define IRDEBUG
#ifdef IRDEBUG #ifdef IRDEBUG
#define wrHigh A3 // Запись HIGH инициирована // green #define wrHigh PA1 // Запись HIGH инициирована // green
#define wrLow A3 // Запись LOW инициирована // blue #define wrLow PA0 // Запись LOW инициирована // blue
#define writeOp 13 // Операция записи, 1 пульс для 0 и 2 для 1 // orange #define writeOp PA5 // Операция записи, 1 пульс для 0 и 2 для 1 // orange
// Исправленные ошибки // purle // Исправленные ошибки // purle
// 1 пульс: fix // 1 пульс: fix
#define errOut A3 #define errOut PA4
#endif #endif
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
@ -58,10 +58,10 @@ public:
bool isOverflow() { return isBufferOverflow; }; // Буффер переполнился bool isOverflow() { return isBufferOverflow; }; // Буффер переполнился
bool isSubOverflow() bool isSubOverflow()
{ {
uint8_t oldSREG = SREG;
cli(); // noInterrupts();
volatile bool ret = isSubBufferOverflow; volatile bool ret = isSubBufferOverflow;
SREG = oldSREG; // interrupts();
return ret; return ret;
}; };
bool isReciving() { return isBufferOverflow; }; // Возвращает true, если происходит приём пакета bool isReciving() { return isBufferOverflow; }; // Возвращает true, если происходит приём пакета

51
IR_Encoder.cpp
View File

@ -5,7 +5,7 @@
#define ISR_Out 10 #define ISR_Out 10
#define TestOut 13 #define TestOut 13
IR_Encoder::IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair = nullptr) IR_Encoder::IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair)
{ {
id = addr; id = addr;
this->decPair = decPair; this->decPair = decPair;
@ -40,7 +40,7 @@ IR_Encoder::~IR_Encoder()
delete[] bitHigh; delete[] bitHigh;
}; };
void IR_Encoder::sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept = false) void IR_Encoder::sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept)
{ {
uint8_t *dataPtr = new uint8_t[1]; uint8_t *dataPtr = new uint8_t[1];
dataPtr[0] = dataByte; dataPtr[0] = dataByte;
@ -48,7 +48,7 @@ void IR_Encoder::sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept = f
delete[] dataPtr; delete[] dataPtr;
} }
void IR_Encoder::sendData(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false) void IR_Encoder::sendData(uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept)
{ {
if (len > bytePerPack) if (len > bytePerPack)
{ {
@ -92,7 +92,7 @@ void IR_Encoder::sendData(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len
rawSend(sendBuffer, packSize); rawSend(sendBuffer, packSize);
} }
void IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte = 0) void IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte)
{ {
constexpr uint8_t packsize = msgBytes + addrBytes + 1U + crcBytes; constexpr uint8_t packsize = msgBytes + addrBytes + 1U + crcBytes;
memset(sendBuffer, 0x00, dataByteSizeMax); memset(sendBuffer, 0x00, dataByteSizeMax);
@ -141,12 +141,12 @@ void IR_Encoder::sendBack(uint8_t data)
{ {
_sendBack(false, 0, &data, 1); _sendBack(false, 0, &data, 1);
} }
void IR_Encoder::sendBack(uint8_t *data = nullptr, uint8_t len = 0) void IR_Encoder::sendBack(uint8_t *data , uint8_t len)
{ {
_sendBack(false, 0, data, len); _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, uint8_t len)
{ {
_sendBack(true, addrTo, data, len); _sendBack(true, addrTo, data, len);
} }
@ -210,7 +210,7 @@ void IR_Encoder::rawSend(uint8_t *ptr, uint8_t len)
setDecoder_isSending(); setDecoder_isSending();
cli(); // noInterrupts();
sendLen = len; sendLen = len;
toggleCounter = preambToggle; // Первая генерация для первого signal toggleCounter = preambToggle; // Первая генерация для первого signal
@ -227,7 +227,7 @@ void IR_Encoder::rawSend(uint8_t *ptr, uint8_t len)
currentBitSequence = bitHigh; currentBitSequence = bitHigh;
isSending = true; isSending = true;
sei(); // interrupts();
} }
void IR_Encoder::isr() void IR_Encoder::isr()
@ -332,32 +332,6 @@ void IR_Encoder::isr()
} }
} }
void old()
{ ///////////////////////////////////////////////////////
// void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
// /*tmp*/bool LOW_FIRST = false;/*tmp*/
// if (decoders != nullptr) { decoders->isPairSending = true; }
// bool prev = 1;
// bool next;
// send_EMPTY(preambPulse); // преамбула
// for (uint16_t byteNum = 0; byteNum < len; byteNum++) {
// sendByte(ptr[byteNum], &prev, LOW_FIRST);
// if (byteNum < len - 1) {
// next = ptr[byteNum + 1] & (LOW_FIRST ? 0b00000001 : 0b10000000);
// } else {
// next = 0;
// }
// addSync(&prev, &next);
// }
// if (decoders != nullptr) { decoders->isPairSending = false; }
// }
}
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; uint8_t mask = LOW_FIRST ? 0b00000001 : 0b10000000;
@ -395,7 +369,7 @@ void IR_Encoder::addSync(bool *prev, bool *next)
} }
} }
void IR_Encoder::send_HIGH(bool prevBite = 1) void IR_Encoder::send_HIGH(bool prevBite)
{ {
// if (/* prevBite */1) { // if (/* prevBite */1) {
@ -422,3 +396,10 @@ void IR_Encoder::send_EMPTY(uint8_t count)
// } // }
// meanderBlock(bitPauseTakts * 2 + bitActiveTakts, halfPeriod, 0); //TODO: Отодвинуть преамбулу // meanderBlock(bitPauseTakts * 2 + bitActiveTakts, halfPeriod, 0); //TODO: Отодвинуть преамбулу
} }
uint8_t* IR_Encoder::bitHigh = new uint8_t[2]{
(bitPauseTakts * 2) * 2 - 1,
(bitActiveTakts) * 2 - 1};
uint8_t* IR_Encoder::bitLow = new uint8_t[2]{
(bitPauseTakts + bitActiveTakts) * 2 - 1,
(bitPauseTakts) * 2 - 1};

55
IR_Encoder.h
View File

@ -20,31 +20,33 @@ public:
/// @param decPair Приёмник, для которого отключается приём в момент передачи передатчиком /// @param decPair Приёмник, для которого отключается приём в момент передачи передатчиком
IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair = nullptr); IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair = nullptr);
static void timerSetup() // static void timerSetup()
{ // {
// TIMER2 Ini // // // TIMER2 Ini
uint8_t oldSREG = SREG; // Save global interupts settings // // uint8_t oldSREG = SREG; // Save global interupts settings
cli(); // // cli();
// DDRB |= (1 << PORTB3); //OC2A (17) // // // DDRB |= (1 << PORTB3); //OC2A (17)
TCCR2A = 0; // // TCCR2A = 0;
TCCR2B = 0; // // TCCR2B = 0;
// TCCR2A |= (1 << COM2A0); //Переключение состояния // // // TCCR2A |= (1 << COM2A0); //Переключение состояния
TCCR2A |= (1 << WGM21); // Clear Timer On Compare (Сброс по совпадению) // // TCCR2A |= (1 << WGM21); // Clear Timer On Compare (Сброс по совпадению)
TCCR2B |= (1 << CS20); // Предделитель 1 // // TCCR2B |= (1 << CS20); // Предделитель 1
TIMSK2 |= (1 << OCIE2A); // Прерывание по совпадению // // TIMSK2 |= (1 << OCIE2A); // Прерывание по совпадению
OCR2A = /* 465 */ ((F_CPU / (38000 * 2)) - 2); // 38кГц // // OCR2A = /* 465 */ ((F_CPU / (38000 * 2)) - 2); // 38кГц
SREG = oldSREG; // Return interrupt settings // // SREG = oldSREG; // Return interrupt settings
}
static void timerOFFSetup()
{
TIMSK2 &= ~(1 << OCIE2A); // Прерывание по совпадению выкл
}
void IR_Encoder::setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count);
// }
// static void timerOFFSetup()
// {
// TIMSK2 &= ~(1 << OCIE2A); // Прерывание по совпадению выкл
// }
void setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count);
void rawSend(uint8_t *ptr, uint8_t len); void rawSend(uint8_t *ptr, uint8_t len);
void sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept = false); void sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept = false);
@ -63,9 +65,9 @@ public:
volatile bool ir_out_virtual; volatile bool ir_out_virtual;
private: private:
void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len); void _sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len);
void IR_Encoder::setDecoder_isSending(); void setDecoder_isSending();
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);
void send_HIGH(bool = 1); void send_HIGH(bool = 1);
@ -105,12 +107,9 @@ private:
uint8_t low; uint8_t low;
uint8_t high; uint8_t high;
}; };
static inline uint8_t *bitHigh = new uint8_t[2]{ static uint8_t *bitHigh;
(bitPauseTakts * 2) * 2 - 1, static uint8_t *bitLow;
(bitActiveTakts) * 2 - 1};
static inline uint8_t *bitLow = new uint8_t[2]{
(bitPauseTakts + bitActiveTakts) * 2 - 1,
(bitPauseTakts) * 2 - 1};
uint8_t *currentBitSequence = bitLow; uint8_t *currentBitSequence = bitLow;
volatile SignalPart signal; volatile SignalPart signal;
}; };

4
IR_config.h
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <Arduino.h> #include <Arduino.h>
// #define IRDEBUG_INFO #define IRDEBUG_INFO
/*////////////////////////////////////////////////////////////////////////////////////// /*//////////////////////////////////////////////////////////////////////////////////////
Для работы в паре положить декодер в энкодер Для работы в паре положить декодер в энкодер
@ -107,7 +107,7 @@ typedef uint16_t crc_t;
#endif #endif
#ifndef subBufferSize #ifndef subBufferSize
#define subBufferSize 25 //Буфер для складирования фронтов, пока их не обработают (передатчик) #define subBufferSize 11 //Буфер для складирования фронтов, пока их не обработают (передатчик)
#endif #endif
#define preambPulse 3 #define preambPulse 3