CAME.ino

#define pinRX 2
#define pinTX 8

#define CM_MAX_TE 450
#define CM_MIN_TE 250
#define CM_BITS12 12
#define CM_BITS24 24
#define Te 320

volatile byte level = 255;
volatile unsigned long last;
volatile unsigned long len;
byte p_level;
unsigned long p_len;
unsigned long p_len_prev;
struct
{
    uint8_t state;
    uint8_t data[3], dat_bit;
} came;


void setup()
{
    Serial.begin(9600);
    while (!Serial);
    attachInterrupt(0, pinRX_int, CHANGE);
    pinMode(pinTX, OUTPUT);
    interrupts();
}

void loop()
{
    ////receive
    // RfReceive();

    ////send
    char *code = "111111110100011101001111"; // 0-0-0
    RfTransmitt(code, 4);
    delay(2000); 
}

void RfReceive()
{
    if (level != 255)
    {
        noInterrupts();
        p_level = level;
        p_len = len;
        len = 0;
        level = 255;
        interrupts();
        process_came();
        p_len_prev = p_len;
    }
    if (came.state == 100)
    {
        for (int i = 0; i < sizeof(came.data) - (came.dat_bit == CM_BITS12 ? 1 : 0); i++) {
            if (i > 0) {
                Serial.print("_");
            }
            Serial.print(stringWithPrefix(String(came.data[i], BIN), came.dat_bit == CM_BITS12 ? 6 : 8, '0'));
        }
        came.state = 0;
        Serial.println();
    }
}

void RfTransmitt(char *codeString, unsigned int numberOfShipments)
{
    int codeLength = strlen(codeString);
    if (codeLength != 12 && codeLength != 24)
    {
        Serial.println("incorrect code.");
        return;
    }

    byte code[codeLength];
    for (int i = 0; i < codeLength; i++) {
        code[i] = codeString[i] == '0' ? 0 : 1;
    }

    byte codeUpdate[codeLength];

    int number = 0;

    switch (codeLength) {
    case 12:
        //оратный порядок
        for (int i = 5; i >= 0; i--) {
            codeUpdate[number] = code[i];
            Serial.print(codeUpdate[number]);
            number++;
        }
        Serial.print(" ");
        //прямой порядок
        for (int i = 6; i < 12; i++) {
            codeUpdate[number] = code[i];
            Serial.print(codeUpdate[number]);
            number++;
        }
        break;
    case 24:
        //оратный порядок для всех символов
        for (int i = 1; i <= 3; i++) {
            for (int j = i * 8 - 1; j >= 8 * (i - 1); j--) {
                codeUpdate[number] = code[j];
                Serial.print(codeUpdate[number]);
                number++;
            }
            Serial.print("-");
        }
        break;
    }

    Serial.println();

    for (int i = 0; i < numberOfShipments; i++) // посылку посылаем как и брелок - NS раза подряд.
    {
        digitalWrite(pinTX, HIGH);
        delayMicroseconds(Te);
        digitalWrite(pinTX, LOW); // посылаем стартовый импульс
        for (int j = 0; j < codeLength; j++) {
            SendCameBit(codeUpdate[j]); // побитово перебираем и посылаем код
        }
        delay(16);
    }
}

void pinRX_int()
{
    if (level != 255) return;
    len = micros() - last;
    last = micros();
    if (digitalRead(pinRX) == HIGH) level = 0;
    else level = 1;
}

void process_came()
{
    unsigned char b;

    switch (came.state)
    {
    case 0:
        if (p_level) break;
        came.state = 1;
        break;
    case 1: //start
        if (!p_level) break;

        else if (p_len >= CM_MIN_TE && p_len <= CM_MAX_TE)
        {
            came.state = 2;
            came.dat_bit = 0;

            for (int i = 0; i < sizeof(came.data); i++) {
                came.data[i] = 0x00;
            }

        }
        else came.state = 0;
    case 2: //dat
        if (p_level)
        {
            if (came.dat_bit == CM_BITS24)
            {
                came.state = 0;
                break;
            }

            if (p_len_prev <= CM_MAX_TE && p_len_prev >= CM_MIN_TE &&
                    p_len <= CM_MAX_TE * 2 && p_len >= CM_MIN_TE * 2) b = 0;
            else if (p_len_prev <= CM_MAX_TE * 2 && p_len_prev >= CM_MIN_TE * 2 &&
                     p_len <= CM_MAX_TE && p_len >= CM_MIN_TE) b = 1;
            else
            {
                came.state = 0;
                break;
            }

            if (b) set_bit(came.data, came.dat_bit);
            came.dat_bit++;
            break;
        }
        else
        {
            if ((p_len > 5000) && (came.dat_bit == CM_BITS12 || came.dat_bit == CM_BITS24)) came.state = 100;
        }
        break;
    }
}

void SendCameBit(byte b)
{
    delayMicroseconds(Te);
    if (!b) digitalWrite(pinTX, HIGH);
    delayMicroseconds(Te);
    digitalWrite(pinTX, HIGH);
    delayMicroseconds(Te);
    digitalWrite(pinTX, LOW);
}

void set_bit(uint8_t *data, uint8_t n)
{
    data[n / 8] |= 1 << (n % 8);
}

String stringWithPrefix(String line, int len, char prefix)
{
    String addon = "";
    int n = len - line.length();
    for (int i = 0; i < n; i++) {
        addon += prefix;
    }
    return addon + line;
}