mirror of
https://github.com/Show-maket/IR-protocol.git
synced 2025-05-04 07:10:16 +00:00
610 lines
17 KiB
C++
610 lines
17 KiB
C++
#include "IR_Decoder.h"
|
|
#include "IR_Encoder.h"
|
|
#include "TimerStatic.h"
|
|
// #include "MemoryCheck.h"
|
|
/////////////// Pinout ///////////////
|
|
|
|
#define dec0_PIN 0
|
|
#define dec1_PIN 1
|
|
#define dec2_PIN 2
|
|
#define dec3_PIN 3
|
|
#define dec4_PIN 4
|
|
#define dec5_PIN 5
|
|
#define dec6_PIN 6
|
|
#define dec7_PIN 7
|
|
#define dec8_PIN 8
|
|
#define dec9_PIN 9
|
|
#define dec10_PIN 10
|
|
#define dec11_PIN 11
|
|
#define dec12_PIN 12
|
|
#define dec13_PIN 13
|
|
#define dec14_PIN 14
|
|
#define dec15_PIN 15
|
|
|
|
#define LoopOut 16
|
|
#define LoopOut1 17
|
|
|
|
#define dec_ISR(n) \
|
|
void dec_##n##_ISR() { dec##n.isr(); }
|
|
#define dec_Ini(n) \
|
|
IR_Decoder dec##n(dec##n##_PIN, n); \
|
|
dec_ISR(n)
|
|
|
|
#define decPinMode(n) pinMode(dec##n##_PIN, INPUT_PULLUP);
|
|
#define decAttach(n) attachInterrupt(dec##n##_PIN, dec_##n##_ISR, CHANGE);
|
|
#define decSetup(n) /* decPinMode(n); */ decAttach(n);
|
|
#define decTick(n) dec##n.tick();
|
|
#define decStat(n) rx_flag |= statusSimple(dec##n);
|
|
|
|
void digitalToggle(uint8_t pin){
|
|
digitalWrite(pin, !digitalRead(pin));
|
|
}
|
|
|
|
//////////////// Ini /////////////////
|
|
|
|
#define INFO "IR_FOX TEST"
|
|
#define SERIAL_SPEED 115200
|
|
|
|
//////////////// Var /////////////////
|
|
// IR_Encoder encForward(PA5, 42 /* , &decBackward */);
|
|
|
|
IR_Encoder enc0(18, 42 /* , &decBackward */);
|
|
IR_Encoder enc1(19, 127 /* , &decBackward */);
|
|
IR_Encoder enc2(20, 137 /* , &decBackward */);
|
|
IR_Encoder enc3(21, 777 /* , &decBackward */);
|
|
// IR_Encoder enc10(PC15, 555 /* , &decBackward */);
|
|
// IR_Encoder enc11(PC14, 127 /* , &decBackward */);
|
|
// IR_Encoder enc12(PC13, 137 /* , &decBackward */);
|
|
// IR_Encoder enc13(PA12, 777 /* , &decBackward */);
|
|
|
|
// IR_Encoder encTree(325, A2);
|
|
|
|
//////////////////////// Функции прерываний ////////////////////////
|
|
|
|
void EncoderISR()
|
|
{
|
|
IR_Encoder::isr();
|
|
// digitalToggle(LoopOut);
|
|
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
dec_Ini(0);
|
|
dec_Ini(1);
|
|
dec_Ini(2);
|
|
dec_Ini(3);
|
|
dec_Ini(4);
|
|
dec_Ini(5);
|
|
dec_Ini(6);
|
|
dec_Ini(7);
|
|
dec_Ini(8);
|
|
dec_Ini(9);
|
|
dec_Ini(10);
|
|
dec_Ini(11);
|
|
dec_Ini(12);
|
|
dec_Ini(13);
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
uint8_t data0[] = {};
|
|
uint8_t data1[] = {42};
|
|
uint8_t data2[] = {42, 127};
|
|
uint8_t data3[] = {42, 127, 137};
|
|
uint8_t data4[] = {42, 127, 137, 255};
|
|
|
|
uint32_t loopTimer;
|
|
uint8_t sig = 0;
|
|
uint16_t targetAddr = IR_Broadcast;
|
|
Timer t1(500, millis, []()
|
|
{
|
|
// Serial.println( digitalPinToBitMask(enc0.getPin()), BIN);
|
|
enc0.sendData(IR_Broadcast, data4, sizeof(data4));
|
|
enc1.sendData(IR_Broadcast, data3, sizeof(data3));
|
|
enc2.sendData(IR_Broadcast, data2, sizeof(data2));
|
|
enc3.sendData(IR_Broadcast, data1, sizeof(data1));
|
|
// enc10.sendData(IR_Broadcast, data4, sizeof(data4));
|
|
// enc11.sendData(IR_Broadcast, data3, sizeof(data3));
|
|
// enc12.sendData(IR_Broadcast, data2, sizeof(data2));
|
|
// enc13.sendData(IR_Broadcast, data1, sizeof(data1));
|
|
|
|
// 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;
|
|
|
|
// case 10:
|
|
// encForward.sendData(targetAddr, data0, sizeof(data0), true);
|
|
// break;
|
|
// case 11:
|
|
// encForward.sendData(targetAddr, data1, sizeof(data1), true);
|
|
// break;
|
|
// case 12:
|
|
// encForward.sendData(targetAddr, data2, sizeof(data2), true);
|
|
// break;
|
|
// case 13:
|
|
// encForward.sendData(targetAddr, data3, sizeof(data3), true);
|
|
// break;
|
|
// case 14:
|
|
// encForward.sendData(targetAddr, data4, sizeof(data4), true);
|
|
// break;
|
|
|
|
// case 20:
|
|
// encForward.sendBack();
|
|
// break;
|
|
// case 21:
|
|
// encForward.sendBack(data1, sizeof(data1));
|
|
// break;
|
|
// case 22:
|
|
// encForward.sendBack(data2, sizeof(data2));
|
|
// break;
|
|
// case 23:
|
|
// encForward.sendBack(data3, sizeof(data3));
|
|
// break;
|
|
// case 24:
|
|
// encForward.sendBack(data4, sizeof(data4));
|
|
// 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;
|
|
|
|
// default:
|
|
// break;
|
|
// }
|
|
// encBackward.sendData(IR_Broadcast, data2);
|
|
// encTree.sendData(IR_Broadcast, rawData3);
|
|
});
|
|
// Timer t2(50, millis, []()
|
|
// { digitalToggle(LED_BUILTIN); });
|
|
|
|
Timer signalDetectTimer;
|
|
/////////////////////////////////////////////////////////////////////
|
|
// HardwareTimer IR_Timer(TIM3);
|
|
// RPI_PICO_Timer IR_Timer(0);
|
|
struct repeating_timer timer;
|
|
|
|
bool TimerISRHandler(struct repeating_timer *t){
|
|
(void) t;
|
|
EncoderISR();
|
|
return true;
|
|
}
|
|
|
|
void setup()
|
|
{
|
|
pinMode(LoopOut1, OUTPUT);
|
|
add_repeating_timer_us(6, TimerISRHandler, NULL, &timer);
|
|
|
|
// IR_Timer.setOverflow(carrierFrec * 2, HERTZ_FORMAT);
|
|
// IR_Timer.attachInterrupt(1, EncoderISR);
|
|
// NVIC_SetPriority(IRQn_Type::TIM3_IRQn, 0);
|
|
// IR_Timer.resume();
|
|
|
|
Serial.begin(SERIAL_SPEED);
|
|
Serial.println(F(INFO));
|
|
|
|
pinMode(LoopOut, OUTPUT);
|
|
// pinMode(SignalDetectLed, OUTPUT);
|
|
|
|
pinMode(dec1_PIN, INPUT_PULLUP);
|
|
// pinMode(dec2_PIN, INPUT_PULLUP);
|
|
|
|
static IR_DecoderRaw *blind[]{
|
|
&dec0,
|
|
&dec1,
|
|
&dec2,
|
|
&dec3,
|
|
&dec4,
|
|
&dec5,
|
|
&dec6,
|
|
&dec7,
|
|
&dec8,
|
|
&dec9,
|
|
&dec10,
|
|
&dec11,
|
|
&dec12,
|
|
&dec13,
|
|
};
|
|
|
|
// enc0.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
|
|
// enc1.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
|
|
// enc2.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
|
|
// enc3.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
|
|
// enc10.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
|
|
|
|
decSetup(0);
|
|
// decSetup(1);
|
|
// decSetup(2);
|
|
// decSetup(3);
|
|
// decSetup(4);
|
|
// decSetup(5);
|
|
// decSetup(6);
|
|
// decSetup(7);
|
|
// decSetup(8);
|
|
// decSetup(9);
|
|
// decSetup(10);
|
|
decSetup(11);
|
|
decSetup(12);
|
|
decSetup(13);
|
|
}
|
|
|
|
void loop()
|
|
{
|
|
digitalToggle(LoopOut);
|
|
|
|
}
|
|
|
|
|
|
|
|
void loop1()
|
|
{
|
|
Timer::tick();
|
|
IR_Decoder::tick();
|
|
|
|
bool rx_flag;
|
|
decStat(0);
|
|
decStat(1);
|
|
decStat(2);
|
|
decStat(3);
|
|
decStat(4);
|
|
decStat(5);
|
|
decStat(6);
|
|
decStat(7);
|
|
decStat(8);
|
|
decStat(9);
|
|
decStat(10);
|
|
decStat(11);
|
|
decStat(12);
|
|
decStat(13);
|
|
|
|
// status(decForward);
|
|
// status(decBackward);
|
|
|
|
// Serial.println(micros() - loopTimer);
|
|
// loopTimer = micros();
|
|
// delayMicroseconds(120*5);
|
|
|
|
if (Serial.available())
|
|
{
|
|
uint8_t in = Serial.parseInt();
|
|
switch (in)
|
|
{
|
|
case 100:
|
|
targetAddr = IR_Broadcast;
|
|
break;
|
|
case 101:
|
|
targetAddr = 555;
|
|
break;
|
|
case 102:
|
|
targetAddr = 777;
|
|
break;
|
|
|
|
default:
|
|
sig = in;
|
|
break;
|
|
}
|
|
Serial.println(in);
|
|
}
|
|
digitalToggle(LoopOut1);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Timer statusSimpleDelay;
|
|
bool statusSimple(IR_Decoder &dec)
|
|
{
|
|
bool ret;
|
|
if (ret = dec.gotData.available())
|
|
{
|
|
Serial.print("DEC: ");
|
|
Serial.print(dec.getId());
|
|
Serial.print(" err: ");
|
|
Serial.print(dec.gotData.getErrorCount());
|
|
Serial.print("\n");
|
|
statusSimpleDelay.delay(100, millis, []()
|
|
{ Serial.print("\n\n\n\n"); });
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void detectSignal()
|
|
{
|
|
// digitalWrite(SignalDetectLed, HIGH);
|
|
// signalDetectTimer.delay(50, millis, []()
|
|
// { digitalWrite(SignalDetectLed, LOW); });
|
|
}
|
|
|
|
// test
|
|
void status(IR_Decoder &dec)
|
|
{
|
|
if (dec.gotData.available())
|
|
{
|
|
detectSignal();
|
|
Serial.println(micros());
|
|
String str;
|
|
if (/* dec.gotData.getDataPrt()[1] */ 1)
|
|
{
|
|
str += ("Data on pin ");
|
|
str += (dec.getPin());
|
|
str += "\n";
|
|
|
|
uint8_t msg = dec.gotData.getMsgRAW();
|
|
str += (" MSG: ");
|
|
for (size_t i = 0; i < 8; i++)
|
|
{
|
|
if (i == 3)
|
|
str += " ";
|
|
str += (msg >> (7 - i)) & 1U;
|
|
}
|
|
|
|
str += "\n";
|
|
|
|
str += (" DATA SIZE: ");
|
|
str += (dec.gotData.getDataSize());
|
|
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 CALC: "); str += (dec.gotData.getCrcCALC()); str += "\n";
|
|
str += "\n";
|
|
|
|
for (size_t i = 0; i < min(uint8_t(10), dec.gotData.getDataSize()); i++)
|
|
{
|
|
switch (i)
|
|
{
|
|
// case 0:
|
|
// str += (" ADDR: ");
|
|
// break;
|
|
// case 1:
|
|
// str += (" CMD: ");
|
|
// break;
|
|
|
|
default:
|
|
str += (" Data[");
|
|
str += (i);
|
|
str += ("]: ");
|
|
break;
|
|
}
|
|
str += (dec.gotData.getDataPrt()[i]);
|
|
str += "\n";
|
|
}
|
|
|
|
str += ("\n*******ErrAll: ");
|
|
str += (dec.gotData.getErrorCount());
|
|
str += "\n";
|
|
str += ("**ErrDistance: ");
|
|
str += ((int)(dec.gotData.getErrorHighSignal() - dec.gotData.getErrorLowSignal()));
|
|
str += "\n";
|
|
|
|
str += "\n";
|
|
}
|
|
else
|
|
{
|
|
str += ("SELF");
|
|
str += "\n";
|
|
str += "\n";
|
|
}
|
|
// obj->resetAvailable();
|
|
Serial.write(str.c_str());
|
|
}
|
|
|
|
if (dec.gotBackData.available())
|
|
{
|
|
detectSignal();
|
|
String str;
|
|
if (/* dec.gotData.getDataPrt()[1] */ 1)
|
|
{
|
|
str += ("BackData on pin ");
|
|
str += (dec.getPin());
|
|
str += "\n";
|
|
|
|
uint8_t msg = dec.gotBackData.getMsgRAW();
|
|
str += (" MSG: ");
|
|
for (size_t i = 0; i < 8; i++)
|
|
{
|
|
if (i == 3)
|
|
str += " ";
|
|
str += (msg >> (7 - i)) & 1U;
|
|
}
|
|
|
|
str += "\n";
|
|
|
|
str += (" DATA SIZE: ");
|
|
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 += (" CRC PACK: "); str += (dec.gotBackData.getCrcIN()); str += "\n";
|
|
// str += (" CRC CALC: "); str += (dec.gotBackData.getCrcCALC()); str += "\n";
|
|
str += "\n";
|
|
|
|
for (size_t i = 0; i < min(uint8_t(10), dec.gotBackData.getDataSize()); i++)
|
|
{
|
|
switch (i)
|
|
{
|
|
// case 0:
|
|
// str += (" ADDR: ");
|
|
// break;
|
|
// case 1:
|
|
// str += (" CMD: ");
|
|
// break;
|
|
|
|
default:
|
|
str += (" Data[");
|
|
str += (i);
|
|
str += ("]: ");
|
|
break;
|
|
}
|
|
str += (dec.gotBackData.getDataPrt()[i]);
|
|
str += "\n";
|
|
}
|
|
|
|
str += ("\n*******ErrAll: ");
|
|
str += (dec.gotBackData.getErrorCount());
|
|
str += "\n";
|
|
str += ("**ErrDistance: ");
|
|
str += ((int)(dec.gotBackData.getErrorHighSignal() - dec.gotBackData.getErrorLowSignal()));
|
|
str += "\n";
|
|
|
|
str += "\n";
|
|
}
|
|
else
|
|
{
|
|
str += ("SELF");
|
|
str += "\n";
|
|
str += "\n";
|
|
}
|
|
// obj->resetAvailable();
|
|
Serial.write(str.c_str());
|
|
}
|
|
|
|
if (dec.gotAccept.available())
|
|
{
|
|
detectSignal();
|
|
String str;
|
|
if (/* dec.gotData.getDataPrt()[1] */ 1)
|
|
{
|
|
str += ("Accept on pin ");
|
|
str += (dec.getPin());
|
|
str += "\n";
|
|
|
|
uint8_t msg = dec.gotAccept.getMsgRAW();
|
|
str += (" MSG: ");
|
|
for (size_t i = 0; i < 8; i++)
|
|
{
|
|
if (i == 3)
|
|
str += " ";
|
|
str += (msg >> (7 - i)) & 1U;
|
|
}
|
|
|
|
str += "\n";
|
|
|
|
// str += (" DATA SIZE: "); str += (dec.gotAccept.getDataSize()); str += "\n";
|
|
str += (" ADDRESS FROM: ");
|
|
str += (dec.gotAccept.getAddrFrom());
|
|
str += "\n";
|
|
// str += (" ADDRESS TO: "); str += (dec.gotAccept.getAddrTo()); str += "\n";
|
|
// str += (" CRC PACK: "); str += (dec.gotAccept.getCrcIN()); str += "\n";
|
|
// str += (" CRC CALC: "); str += (dec.gotAccept.getCrcCALC()); str += "\n";
|
|
str += "\n";
|
|
|
|
str += (" Data: ");
|
|
str += (dec.gotAccept.getCustomByte());
|
|
|
|
str += ("\n\n*******ErrAll: ");
|
|
str += (dec.gotAccept.getErrorCount());
|
|
str += "\n";
|
|
str += ("**ErrDistance: ");
|
|
str += ((int)(dec.gotAccept.getErrorHighSignal() - dec.gotAccept.getErrorLowSignal()));
|
|
str += "\n";
|
|
|
|
str += "\n";
|
|
}
|
|
else
|
|
{
|
|
str += ("SELF");
|
|
str += "\n";
|
|
str += "\n";
|
|
}
|
|
// obj->resetAvailable();
|
|
Serial.write(str.c_str());
|
|
}
|
|
|
|
if (dec.gotRequest.available())
|
|
{
|
|
detectSignal();
|
|
String str;
|
|
if (/* dec.gotData.getDataPrt()[1] */ 1)
|
|
{
|
|
str += ("Request on pin ");
|
|
str += (dec.getPin());
|
|
str += "\n";
|
|
|
|
uint8_t msg = dec.gotRequest.getMsgRAW();
|
|
str += (" MSG: ");
|
|
for (size_t i = 0; i < 8; i++)
|
|
{
|
|
if (i == 3)
|
|
str += " ";
|
|
str += (msg >> (7 - i)) & 1U;
|
|
}
|
|
|
|
str += "\n";
|
|
|
|
// str += (" DATA SIZE: "); str += (dec.gotRequest.getDataSize()); str += "\n";
|
|
str += (" ADDRESS FROM: ");
|
|
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 CALC: "); str += (dec.gotRequest.getCrcCALC()); str += "\n";
|
|
str += "\n";
|
|
|
|
str += ("\n*******ErrAll: ");
|
|
str += (dec.gotRequest.getErrorCount());
|
|
str += "\n";
|
|
str += ("**ErrDistance: ");
|
|
str += ((int)(dec.gotRequest.getErrorHighSignal() - dec.gotRequest.getErrorLowSignal()));
|
|
str += "\n";
|
|
|
|
str += "\n";
|
|
}
|
|
else
|
|
{
|
|
str += ("SELF");
|
|
str += "\n";
|
|
str += "\n";
|
|
}
|
|
// obj->resetAvailable();
|
|
Serial.write(str.c_str());
|
|
}
|
|
}
|