raspberrypi/433/rc-switch-pico/examples/Forward/Forward.cc

#include <iostream>
#include "pico/stdlib.h"
#include "../../radio-switch.h"
#include "pico/stdio.h"
#include "pico/multicore.h"
#include <map>                  // map
#include <time.h>


#define BUFFER_SIZ 1024


const uint RADIO_TRANSMIT_PIN = 16; // 433发射模块引脚
const uint RADIO_RECEIVER_PIN = 17; // 433接收模块引脚


// 闪烁LED
void light()
{
    const uint LED_PIN = PICO_DEFAULT_LED_PIN;
    gpio_init(LED_PIN);
    gpio_set_dir(LED_PIN, GPIO_OUT);
    gpio_put(LED_PIN, 1);
    sleep_ms(100);
    gpio_put(LED_PIN, 0);
    sleep_ms(100);

}

static char pool[] = {
    '1', '2', '3', '4', '5', '6', '7', '8', '9'
};

// 随即数
static int RAND()
{
    int PASSWD_LEN = 3;
    char password[BUFFER_SIZ];
    int i = 0;
    FILE *fp;

    memset(password, 0, BUFFER_SIZ);
    srand(time(NULL));

    while (i != PASSWD_LEN) {
        password[i++] = pool[rand() % sizeof(pool)];
    }

    //printf("%d\n", atoi(password));
    return atoi(password);
}

static void SEND(const int ID)
{

    const uint BUTTON = 21;             // 按钮
    int RANDOM = 500;
    int LOOP_NUM = 1;                   // 循环发送次数

    const uint PULSE_LENGTH = 169;      // set this to PULSELENGTH RECIEVED
    const uint REPEAT_TRANSMIT = 4;     // set this to whatever works best for you.    // 重复发送
    const uint PROTOCOL = 1;            // set this to PROTOCOL RECIEVED
    const uint BIT_LENGTH = 24;         // set this to BIT LENGTH RECIEVED

    gpio_init(RADIO_TRANSMIT_PIN);
    RCSwitch mySwitch = RCSwitch();
    mySwitch.enableTransmit(RADIO_TRANSMIT_PIN);
    mySwitch.setProtocol(PROTOCOL);
    mySwitch.setPulseLength(PULSE_LENGTH);
    mySwitch.setRepeatTransmit(REPEAT_TRANSMIT);


    

    for (int i = 0; i <= LOOP_NUM; i++) {
        RANDOM = RAND();
        light();                                // 灯闪烁

        sleep_ms(RANDOM * 2 / 3);               // 等待随机时间

        mySwitch.send(ID, BIT_LENGTH);          // 第一次发射
        sleep_ms(130);


        //mySwitch.send(ID + 1, BIT_LENGTH);      // 第二次发射
        //sleep_ms(130);
    }

}

int int_string(int val, char *string, int string_len, int *str_len, char *dest, int *dest_len)
{
    memset(string, 0, string_len);
    memset(dest, 0, string_len);

    char s[] = "55";
    char d = '1';

    snprintf(string, string_len, "%d", val);
    *str_len = strlen(string);

    if (0 == strncasecmp(string, s, 2)) {
        dest[0] = d;
        dest[1] = d;
        strncpy(dest + 2, string + 2, (*str_len) - 2);

        *dest_len = strlen(dest);
    }

    return 0;
}

// 核心0发送数据到核心1, 核心1判断是否有数据到来, 然后打印.
void core1_main()
{
    
    gpio_init(RADIO_RECEIVER_PIN);

    RCSwitch rcSwitch = RCSwitch();
    rcSwitch.enableReceive(RADIO_RECEIVER_PIN);

    char str[270];
    char dest[270];
    int str_len;
    int dest_len;
    const char s = '5';

    while (true)
    {
        if (rcSwitch.available())
        {
            light();

            uint32_t val = rcSwitch.getReceivedValue();
            //printf("核心1接收到的433MHZ数值%u\n", val);

            int_string(val, str, 270, &str_len, dest, &dest_len);

            if (val != 0) {
                if (str[0] == s && str[1] == s) {

                    //printf("核心1处理id后发射值%s\n", dest);
                    multicore_fifo_push_blocking(atoi(dest));
                } else {
                    rcSwitch.resetAvailable();
                    val = 0;
                    continue;
                }

            }

            rcSwitch.resetAvailable();
            val = 0;
        }


        sleep_ms(130);

    }

    return;
}

int main()
{
    stdio_init_all();
    
    std::map < int, int >idcode;
    int count=0;
    uint32_t i=0;
    
    
    multicore_reset_core1();
    multicore_launch_core1(core1_main);
    


    while (1)
    {
        if (multicore_fifo_rvalid()) {
            i = multicore_fifo_pop_blocking(); // 读取核心1发送来的数据

            idcode.insert( {                           // 插入map
                          i, i}
            );
            
        }
        
        if (idcode.size() >= 3) {       // 等于3个时发送
            for (auto it: idcode) {
                
                printf("核心0转发433MHZ %u\n", it.first);
                SEND(it.first);
            }

            idcode.clear();
        }
        else                            // 一直没有3个时候, 过一段时间发送
        {
            count++;                    // 计数
            
            if (count == 600)           // 60秒
            {
                for (auto it: idcode) {
                    printf("核心0转发433MHZ %u\n", it.first);
                    SEND(it.first);
                }

                idcode.clear();
                count = 0;
            }
        }


        sleep_ms(100);
    }


    return 0;
}