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

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

#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/multicore.h"

//#include "hardware/adc.h"
//#include <stdio.h>

#include <time.h>

#define BUFFER_SIZ 1024

// 闪烁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);

}

/*
int temperature() {
    // 数模转换器为 0~3.3v 最大值为 12bit
    const float conversion_factor = 3.3f / (1 << 12);

    float v;
    float t;
    stdio_init_all();
    printf("Use adc channel 4, measuring temptutre\n");
    // ADC初始化
    adc_init();
    adc_set_temp_sensor_enabled(true);
    adc_select_input(4);

    // 数字转换为电压
    v = adc_read() * conversion_factor;
    t = 27 - (v - 0.706) / 0.001721;
    printf("t:%.2f v:%.2f\n", t, v);
    
    sleep_ms(100);
    
    return 0;
}
*/

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 RADIO_TRANSMIT_PIN = 16; // 433发射模块引脚
    const uint BUTTON = 21;     // 按钮发射

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

    int RANDOM = 500;
    int LOOP_NUM = 1;           // 循环发送次数

    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)
{
    char s[] = "55";
    char d = '2';

    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()
{
    const uint RADIO_RECEIVER_PIN = 17;
    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;
    memset(str, 0, 270);
    memset(dest, 0, 270);

    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] == '5' && str[1] == '5')
                {
                    
                    multicore_fifo_push_blocking(atoi(dest));
                }
                else
                {
                    rcSwitch.resetAvailable();
                    val = 0;
                    continue;
                }
                
            }

            

            rcSwitch.resetAvailable();
            val = 0;
        }




/*
        if (multicore_fifo_rvalid()) {
            uint32_t i = multicore_fifo_pop_blocking();
            printf("核心1接收到核心0的数值%u\n", i);

        }
*/
        sleep_ms(130);
        
        
    }


    return ;
}

int main()
{
    stdio_init_all();

    multicore_reset_core1();
    multicore_launch_core1(core1_main);


    while (1) {

        if (multicore_fifo_rvalid()) {
            uint32_t i = multicore_fifo_pop_blocking();     // 读取核心1发送来的数据
            //printf("核心0接收到核心1的数值%u\n", i);
            
            //multicore_reset_core1();                // 关闭核心1
            //SEND(i);                                // 433MHZ发送
            //multicore_launch_core1(core1_main);     // 开启核心1
            //multicore_fifo_push_blocking(i);        // 给核心1发送数据
            
            
            
            
            
            SEND(i);
            printf("核心0转发433MHZ %u\n", i);

            
        }


        sleep_ms(130);
    }
    

    return 0;
}