IR-protocol/IR-Protocol.ino

#include "IR_Decoder.h"
#include "IR_Encoder.h"
#include "TimerStatic.h"
#include "MemoryCheck.h"
/////////////// Pinout ///////////////

#define encForward_PIN    5
#define encBackward_PIN   6

#define LoopOut 12
#define ISR_Out 10

#define TestOut 13

//////////////// Ini /////////////////

#define INFO "Машинка"
#define SERIAL_SPEED 115200

//////////////// Var /////////////////

IR_Decoder decForward(2, 555);
IR_Decoder decBackward(3, 777);

IR_Decoder* blindFromForward [] { &decBackward };
IR_Encoder encForward(42, encForward_PIN, &decForward);

IR_Encoder encBackward(321, encBackward_PIN);
IR_Encoder encTree(325, A2);

//////////////////////// Функции прерываний ////////////////////////

void decForwardISR() {
    decForward.isr();
}

void decBackwardISR() {
    decBackward.isr();
}

static uint8_t* portOut;
ISR(TIMER2_COMPA_vect) {
    encForward.isr();
    encBackward.isr();
    // encTree.isr();
    //TODO: Сделать выбор порта 
    *portOut = (*portOut & 0b11001111) |
        (
            encForward.ir_out_virtual << 5U
            | encBackward.ir_out_virtual << 6U
            // | encTree.ir_out_virtual << 2U
            );
}
/////////////////////////////////////////////////////////////////////
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 = 255;

uint16_t targetAddr = IR_Broadcast;
Timer t1(730, millis, []() {

    // Serial.println(sig);

    switch (sig) {
        case 0:
            encForward.sendData(targetAddr, data0, sizeof(data0));
            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, data0, sizeof(data0));
            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() {
    IR_Encoder::timerSetup();
    portOut = &PORTD;

    Serial.begin(SERIAL_SPEED);
    Serial.println(F(INFO));

    pinMode(A0, INPUT_PULLUP);
    pinMode(A1, INPUT_PULLUP);
    pinMode(A2, INPUT_PULLUP);
    pinMode(A3, INPUT_PULLUP);

    pinMode(LoopOut, OUTPUT);
    pinMode(ISR_Out, OUTPUT);

    pinMode(2, INPUT_PULLUP);
    pinMode(3, INPUT_PULLUP);

    pinMode(8, OUTPUT);
    pinMode(9, OUTPUT);
    pinMode(11, OUTPUT);
    pinMode(13, OUTPUT);
    pinMode(encForward_PIN, OUTPUT);
    pinMode(encBackward_PIN, OUTPUT);
    pinMode(13, OUTPUT);



    encForward.setBlindDecoders(blindFromForward, sizeof(blindFromForward) / sizeof(IR_Decoder*));


    attachInterrupt(0, decForwardISR, CHANGE);  // D2 
    attachInterrupt(1, decBackwardISR, CHANGE); // D3
}

void loop() {
    digitalToggle(LoopOut);
    Timer::tick();

    decForward.tick();
    decBackward.tick();

    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;
        }
    }
}






//test
void status(IR_Decoder& dec) {
    // if (dec.gotTune.avaliable()) {
    //     Serial.print("          Tune ");       Serial.print(&dec == &decForward ? "decForward" : (&dec == &decBackward ? "decBackward" : "??"));  Serial.print(": ");

    //     Serial.println(dec.gotTune.getTune());

    //     Serial.println();
    //     dec.gotTune.resetAvaliable();
    // }

    IR_Decoder::AnyData* infoArr [] = { &dec.gotData, &dec.gotBackData };

    for (auto&& obj : infoArr) {
        if (obj->avaliable()) {
            String str;
            if (obj->getDataPrt()[1]) {
                str += ("Data on pin ");        str += (dec.isrPin); str += "\n";

                uint8_t msg = obj->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 += (obj->getDataSize()); str += "\n";
                str += ("  ADDRESS FROM: "); str += (obj->getAddrFrom()); str += "\n";
                str += ("  ADDRESS TO: "); str += (obj->getAddrTo()); str += "\n";
                // str += ("  CRC PACK: "); str += (obj->getCrcIN()); str += "\n";
                // str += ("  CRC CALC: "); str += (obj->getCrcCALC()); str += "\n";
                str += "\n";

                for (size_t i = 0; i < obj->getDataSize(); i++) {
                    switch (i) {
                        // case 0:
                        //     str += ("  ADDR: ");
                        //     break;
                        // case 1:
                        //     str += ("  CMD: ");
                        //     break;

                        default:
                            str += ("  Data["); str += (i); str += ("]: ");
                            break;
                    }
                    str += (obj->getDataPrt()[i]); str += "\n";
                }


                str += ("\n*******ErrAll: ");     str += (obj->getErrorCount()); str += "\n";
                str += ("**ErrDistance: ");     str += ((int)(obj->getErrorHighSignal() - obj->getErrorLowSignal())); str += "\n";

                str += "\n";
            } else {
                str += ("SELF"); str += "\n";
                str += "\n";
            }
            obj->resetAvaliable();
            Serial.write(str.c_str());
        }
    }
}