433M遥控器无线解码1527协议

这篇具有很好参考价值的文章主要介绍了433M遥控器无线解码1527协议。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

433M遥控器无线解码1527协议,定时器轮询法

1527协议,最前面是引导码,紧接着前20位为地址码,每个遥控器不一样,后4位是按键码,每个遥控器都是一样的,

逻辑分析仪捕捉图形如下图:

ev1527解码程序,stm32,单片机,Powered by 金山文档

分别按下遥控器的四个按键结果如下图:

ev1527解码程序,stm32,单片机,Powered by 金山文档

ev1527.c文件

/*
 * user_1527.c
 *
 *  Created on: 2023-3-20
 *      Author: Administrator
 */

#include "user_1527.h"
#include "drivers.h"
#include <string.h>
#include "user_flash.h"
#include "multi_timer.h"

#define NUMBER_COUNT  1 //1判断1次    2判断2次    3 判断3次

static Timer LedTimeHandle;//led闪烁定时器句柄

#define LED_OFF_TIME         (10*1000)//ms
static Timer LedOffTimeHandle;//led自动关闭定时器句柄

#define MOTOR_OFF_TIME         (2*60*1000)//ms 4分钟
static Timer MotorOffTimeHandle;//电机自动关闭句柄

#define MOTOR_ON_TIME         (600)//ms     600豪秒
static Timer MotorOnTimeHandle;//电机延迟启动句柄

#if (NUMBER_COUNT == 1)
    #define K433_OFF_TIME         (110)
#endif
#if (NUMBER_COUNT == 2)
    #define K433_OFF_TIME         (140)
#endif
#if (NUMBER_COUNT == 3)
    #define K433_OFF_TIME         (170)
#endif
static Timer K433TimeHandle;//433超时关闭

unsigned char learning_flag = 0;//学习遥控器flag,1开始学习,0学习结束
LED_TypeDef LedFlag = ON;//led状态

void timer_irq_handler(void)//放irq_handler();里面
{
//    static unsigned char a = 0;
    static unsigned char msindex = 0;
#if GPIO_IRQ
    if((reg_irq_src & FLD_IRQ_GPIO_EN)==FLD_IRQ_GPIO_EN){
        reg_irq_src |= FLD_IRQ_GPIO_EN; // clear the relevant irq
        gpio_irqsrc = (reg_gpio_irq_from_pad & KEY);
        DBG("KEY = %d\n", gpio_irqsrc);
        gpio_irq_cnt++;
    }
#endif

    if(timer_get_interrupt_status(FLD_TMR_STA_TMR0))
    {
        timer_clear_interrupt_status(FLD_TMR_STA_TMR0); //clear irq status
#if !GPIO_LUOFEN
        ev1527decode();
#endif
#if GPIO_LUOFEN
        static int gpio_irq_cnt = 0;
        if(gpio_irq_cnt++ % 2) gpio_write(LED, 0);
        else gpio_write(LED, 1);
#endif
    }

    if(msindex++ >= 20)
    {
        msindex = 0;
        software_timer_ticks();
    }
}

void ev1527_init(void)
{
#if GPIO_IRQ
    gpio_set_func(LED ,AS_GPIO);
    gpio_set_output_en(LED, 1);         //enable output
    gpio_set_input_en(LED ,0);            //disable input
    gpio_write(LED, 0);

    gpio_set_func(KEY ,AS_GPIO);
    gpio_set_output_en(KEY, 0);             // disable output
    gpio_set_input_en(KEY ,1);                // enable input

    gpio_setup_up_down_resistor(KEY, PM_PIN_PULLUP_10K);
    /****GPIO_IRQ POL_FALLING   Press SW2 to connect KEY1 and KEY3 to trigger an interrupt. **/
    /* POL_FALLING(下降沿)   POL_FALLING(上升沿) */
    gpio_set_interrupt(KEY, POL_FALLING);    //When SW2 is pressed, the falling edge triggers the interrupt.
    irq_enable();
#endif

    gpio_set_func(KEY ,AS_GPIO);
    gpio_set_output_en(KEY, 0);             // disable output
    gpio_set_input_en(KEY ,1);                // enable input
    gpio_setup_up_down_resistor(KEY, PM_PIN_PULLUP_10K);
#if GPIO_LUOFEN
    gpio_set_func(LED ,AS_GPIO);
    gpio_set_output_en(LED, 1);         //enable output
    gpio_set_input_en(LED ,0);            //disable input
    gpio_write(LED, 0);
#endif
    timer0_set_mode(TIMER_MODE_SYSCLK, 0, 50 * CLOCK_SYS_CLOCK_1US);// set timer 50us
    timer_start(TIMER0);
    irq_enable();
    //timer_stop(TIMER0);
}

//-------------------------------------------------------------------
unsigned char RxFlag = 0;//接收状态标记
unsigned int RxBuf[4+1];//多开一个,只有前3个有效,第4个有时候只有半截数据

static int t_high=0,t_low=0,gpio_sta=0,getdata=0;
//static int rx_index=0;
static unsigned int rxlong=0;

#define TIMEOUT 70//超时时间


void k433_clear(void)//超时清楚
{
    software_timer_stop(&K433TimeHandle);
    getdata = 0;
    DBG("getdata = 0\n");
}

//解码函数
// 50us 对应4k,容差1K,,,
//其他速率请 按比例调整定时器时间 比如8k对应20us,2k对应100us等,40k对应5us,速率高请保证单片机速率够快,
//getdata==1时候才是真正的数据接收到,其他非0都是中间状态
//当getdata==1就能提取数据了,取出完毕应当尽快的清零,否则会阻塞住

void ev1527decode(void)
{
    if(gpio_sta ==0)
    {
        if(gpio_read(KEY)==1)       // 如果高就一直循环
        {
            t_high++;                   //高时间计时
            if(t_high > TIMEOUT * 7)         //超时处理
            {
                t_high = TIMEOUT*7;       //  即使超时也不退出但是不再增加,防止溢出
            }
        }
        else
        {
            gpio_sta = 1;
            t_low=0;
        }
    }
    if(gpio_sta == 1)
    {
        if(gpio_read(KEY)==0)  //低计时
        {
            t_low++;
//            if(t_low > 150) DBG("t_low:%d\n", t_low);
            if(t_low >= TIMEOUT)//50*150 = 7500
            {

                if(t_low == TIMEOUT && RxFlag == 0)//开始信号触发,但是要等处理结束才收
                {
                    //tl_printf(">%d\n", getdata);
                    switch(getdata)//接收到的状态处理,1527如果接受到24个bit后,
                    {
#if (NUMBER_COUNT == 1)
                        case 0://第1波开始信号触发
                            getdata++;
                            memset(RxBuf, 0, sizeof(RxBuf));//接收前先清除一下
//                            software_timer_init(&K433TimeHandle, k433_clear, K433_OFF_TIME, 0);
//                            software_timer_start(&K433TimeHandle);//超时处理
                            break;
                        case 1://第2 3 4波开始信号触发,保存1 2 3波数据
                            RxBuf[getdata - 1] = (rxlong >> 1) & 0x00FFFFFF;
                            rxlong = 0;//clear
                            getdata++;
                            break;
                        case 2://结束
                            RxFlag = 1;
                            getdata = 0;
                            break;
                        default:break;
#endif
#if (NUMBER_COUNT == 2)
                        case 0://第1波开始信号触发
                            getdata++;
                            memset(RxBuf, 0, sizeof(RxBuf));//接收前先清除一下
                            software_timer_init(&K433TimeHandle, k433_clear, K433_OFF_TIME, 0);
                            software_timer_start(&K433TimeHandle);//超时处理
                            break;
                        case 1://第2 3 4波开始信号触发,保存1 2 3波数据
                        case 2:
                            RxBuf[getdata - 1] = (rxlong >> 1) & 0x00FFFFFF;
                            rxlong = 0;//clear
                            getdata++;
                            break;
                        case 3://结束
                            RxFlag = 1;
                            getdata = 0;
                            break;
                        default:break;
#endif
#if (NUMBER_COUNT == 3)
                        case 0://第1波开始信号触发
                            getdata++;
                            memset(RxBuf, 0, sizeof(RxBuf));//接收前先清除一下
                            software_timer_init(&K433TimeHandle, k433_clear, K433_OFF_TIME, 0);
                            software_timer_start(&K433TimeHandle);//超时处理
                            break;
                        case 1://第2 3 4波开始信号触发,保存1 2 3波数据
                        case 2:
                        case 3:
                            RxBuf[getdata - 1] = (rxlong >> 1) & 0x00FFFFFF;
                            rxlong = 0;//clear
                            getdata++;
                            break;
                        case 4://结束
                            RxFlag = 1;
                            getdata = 0;
                            break;
                        default:break;
#endif
                    }

                }
                if(t_low > TIMEOUT * 6 || t_high > TIMEOUT * 6)//超时处理,防止溢出,//70*6 *50 = 21ms
                {
                    getdata = 0;
                    t_low = TIMEOUT+1;
                }

            }
        }
        else
        {
            gpio_sta = 2;
        }
    }

    if(gpio_sta == 2)
    {
        if(t_low>TIMEOUT)             //超时
            t_low=0;            //超时与时间不够是一样的处理,反正都是错误
        if(t_high>TIMEOUT)            //同上
            t_high=0;

        if(getdata > 0)//确定数据tick在范围内
        {
            if(t_high > t_low)        //高电平时间大于低电平时间
            {
                //DBG("l\n");
                rxlong |=0x000001;
            }
            else
            {
                //DBG("0\n");
                rxlong &=0xfffffe;
            }
            rxlong<<=1;
        }

        gpio_sta = 0;
        t_high=0;
        t_low=0;
    }
}
static unsigned lock_button = 0;//锁键的flag,按一下上下没有反应,按停止解锁,或者再次按这个按键解锁
static unsigned lock_button1 = 0;
//放while(1)循环处理
void ev1527_task(void)
{
    unsigned int add = 0;//地值
    unsigned char data = 0;//码值

    if(RxFlag == 1)
    {
        RxFlag = 0;

#if (NUMBER_COUNT == 1)
        if(1)// 确认第一次 第二次按键的值一样
        {
            add  = RxBuf[0] >> 4;
            data = RxBuf[0] & 0x0F;
#endif

#if (NUMBER_COUNT == 2)
        if(RxBuf[0] == RxBuf[1])// 确认第一次 第二次按键的值一样
        {
            add  = RxBuf[0] >> 4;
            data = RxBuf[0] & 0x0F;
#endif
#if (NUMBER_COUNT == 3)
        //if(RxBuf[0] == RxBuf[1])// 确认第一次 第二次按键的值一样
        if(RxBuf[0] == RxBuf[1] || RxBuf[1] == RxBuf[2] || RxBuf[2] == RxBuf[0])//三次有两次是一样的
        {
            if(RxBuf[0] == RxBuf[1]){
                add  = RxBuf[0] >> 4;
                data = RxBuf[0] & 0x0F;
            }else if(RxBuf[1] == RxBuf[2]){
                add  = RxBuf[1] >> 4;
                data = RxBuf[1] & 0x0F;
            }else{
                add  = RxBuf[2] >> 4;
                data = RxBuf[2] & 0x0F;
            }
#endif
            if(learning_flag == 1)//开始学习遥控器按键
            {
                //任何按键都进行学习
                //if(data == 0x02)//按下遥控器的学习按键,才进行学习
                    learning_tasks(add);
                return;
            }

            for(int i = 0; i < REMOTE_LEN; i++)//判断遥控器是否已经录制
            {

                if(REMOTE_BUFF[i] == add)//匹配成功
                {
                    switch (data) {
                        case 0x08://up
                            if(lock_button) break;
                            motor_set(0);
                            break;
                        case 0x01://down
                            if(lock_button) break;
                            motor_set(2);
                            break;
                        case 0x04://stop
                            lock_button = 0;
                            motor_set(1);
                            break;
                        case 0x02://锁键,按一下上下没有反应,按停止解锁
                            //learning_key();
                            software_timer_init(&LedOffTimeHandle, led_auto_off1, 300, 300);
                            software_timer_start(&LedOffTimeHandle);
                            lock_button = 1;
                            lock_button1 = 1;
                            break;
                        default:
                            break;
                    }
                }
            }


        }
#if 0
        DBG("=1527_RX_OK=\n");
        DBG("%04x\n", RxBuf[0]);
        DBG("%04x\n", RxBuf[1]);
        DBG("%04x\n", RxBuf[2]);
//        DBG("%04x\n", RxBuf[3]);
//        DBG("%04x\n", RxBuf[4]);
        log_bin(RxBuf[0]);
        log_bin(RxBuf[1]);
        log_bin(RxBuf[2]);
//        log_bin(RxBuf[3]);
//        log_bin(RxBuf[4]);
        DBG("%04x, %01x\n", add, data);
#endif
        DBG("%04x, %01x\n", add, data);
        memset(RxBuf, 0, sizeof(RxBuf));
    }
}

//学习按键
void learning_key(void)
{
//    software_timer_init(&LedOffTimeHandle, led_auto_off, LED_OFF_TIME, 0);//LED自动关闭10秒
//    software_timer_start(&LedOffTimeHandle);

    if(learning_flag == 0)
    {
        LedFlag = OFF;
        learning_flag = 1;
    }
    else
    {
        LedFlag = ON;
        learning_flag = 0;
    }
}
static void motorup(void)
{
    software_timer_stop(&MotorOnTimeHandle);
    DBG("[AUTO]%s\n", __FUNCTION__);//log
    LedFlag = BLINK;
    MOTORUPON();
}
static void motordown(void)
{
    software_timer_stop(&MotorOnTimeHandle);
    DBG("[AUTO]%s\n", __FUNCTION__);//log
    LedFlag = BLINK;
    MOTORDOWNON();
}
static void motordelayset(unsigned char a)//1 up  2 down
{
    switch (a) {
        case 1:
            software_timer_init(&MotorOnTimeHandle, motorup, MOTOR_ON_TIME, 0);//电机延迟启动1s
            software_timer_start(&MotorOnTimeHandle);
            break;
        case 2:
            software_timer_init(&MotorOnTimeHandle, motordown, MOTOR_ON_TIME, 0);//电机延迟启动1s
            software_timer_start(&MotorOnTimeHandle);
            break;
        default:
            break;
    }
}

void motor_set(unsigned char a)// 0 up  1 stop  2 down 3 stop,  4 minute auto stop
{
    if(a > 3) return;

    software_timer_init(&MotorOffTimeHandle, motor_auto_stop, MOTOR_OFF_TIME, 0);//电机自动关闭4分钟
    software_timer_start(&MotorOffTimeHandle);
    static unsigned char lasta = 0;

    if(Remote_inversion)//遥控反转功能
    {
        if(a == 0) a = 2;
        else if(a == 2) a = 0;
    }

    if(a == lasta) return;

    switch (a)
    {
        case 0:
            DBG("MOTORUP\n");
            LedFlag = ON;
            MOTORDOWNOFF();
            if(lasta == 2){//由下降到上升延迟1s,
                motordelayset(1);
            }else{
                LedFlag = BLINK;
                MOTORUPON();
            }
            break;
        case 1:
            DBG("MOTORSTOP\n");
            LedFlag = ON;
            software_timer_stop(&MotorOnTimeHandle);//停止定时器,防止定时器在等待上升
            MOTORUPOFF();
            MOTORDOWNOFF();
            break;
        case 2:
            DBG("MOTORDOWN\n");
            LedFlag = ON;
            MOTORUPOFF();
            if(lasta == 0){//由上升到下降延迟1s,
                motordelayset(2);
            }else{
                LedFlag = BLINK;
                MOTORDOWNON();
            }
            break;
        case 3:
            DBG("MOTORSTOP\n");
            LedFlag = ON;
            software_timer_stop(&MotorOnTimeHandle);//停止定时器,防止定时器在等待上升
            MOTORUPOFF();
            MOTORDOWNOFF();
            break;
        default:
            break;
    }

    lasta = a;
}

void user_rest(void)//复位擦掉flash保存的信息
{
    LedFlag = BLINK;
    learning_flag = 0;
    REMOTE_LEN = 0;
    software_timer_init(&LedOffTimeHandle, led_auto_off, 2000, 0);//LED复位2秒
    software_timer_start(&LedOffTimeHandle);
    flash_erase_sector(FLASH_1527KEY_ADDR);
}
//--------------------------------------------------------------------------
void led_task(void)//200ms定时器
{
    //DBG("%s\n", __FUNCTION__);//log
    static unsigned char i = 0;
    if(lock_button1 == 1)
        return;
    switch (LedFlag) {
        case OFF:
                LED1OFF();
            break;
        case ON:
                LED1ON();
            break;
        case BLINK:
                if(i++ % 2)    LED1ON();
                else    LED1OFF();
            break;
        default:
            break;
    }
}
void motor_auto_stop(void)
{
    software_timer_stop(&MotorOffTimeHandle);
    DBG("[AUTO]%s\n", __FUNCTION__);//log
    LedFlag = ON;
    MOTORUPOFF();
    MOTORDOWNOFF();
}
void led_auto_off(void)//默认led为打开状态 所以LedFlag = ON;
{
    software_timer_stop(&LedOffTimeHandle);
    DBG("[AUTO]%s\n", __FUNCTION__);//log
    LedFlag = ON;
    learning_flag = 0;
}

void led_auto_off1(void)//shanshuo
{
    static unsigned char i = 0;
    if(i++ >= 4)
    {
        i = 0;
        lock_button1 = 0;//控制主线led
        software_timer_stop(&LedOffTimeHandle);
    }
    DBG("[AUTO]%s\n", __FUNCTION__);//log
    if(i % 2)    LED1OFF();
    else    LED1ON();
}

void user_led_key_init(void)
{
    //led
    gpio_set_func(LED1, AS_GPIO);
    gpio_set_output_en(LED1, 1);         //enable output
    gpio_set_input_en(LED1 ,0);            //disable input
    gpio_setup_up_down_resistor(LED1, PM_PIN_PULLUP_10K);
    gpio_write(LED1, 1);//off led

    //key
    gpio_set_func(KEY1, AS_GPIO);
    gpio_set_output_en(KEY1, 0);             // disable output
    gpio_set_input_en(KEY1, 1);                // enable input
    gpio_setup_up_down_resistor(KEY1, PM_PIN_PULLUP_10K);

    gpio_set_func(KEY2, AS_GPIO);
    gpio_set_output_en(KEY2, 0);             // disable output
    gpio_set_input_en(KEY2, 1);                // enable input
    gpio_setup_up_down_resistor(KEY2, PM_PIN_PULLUP_10K);

    //motor
    gpio_set_func(MOTORUP, AS_GPIO);
    gpio_set_output_en(MOTORUP, 1);         //enable output
    gpio_set_input_en(MOTORUP, 0);            //disable input
    gpio_setup_up_down_resistor(MOTORUP, PM_PIN_PULLDOWN_100K);
    gpio_write(MOTORUP, 0);//off motor

    gpio_set_func(MOTORDOWN, AS_GPIO);
    gpio_set_output_en(MOTORDOWN, 1);         //enable output
    gpio_set_input_en(MOTORDOWN, 0);            //disable input
    gpio_setup_up_down_resistor(MOTORDOWN, PM_PIN_PULLDOWN_100K);
    gpio_write(MOTORDOWN, 0);//off motor

    software_timer_init(&K433TimeHandle, k433_clear, K433_OFF_TIME, 0);//433延迟关闭,为了支持BQ3180
    software_timer_init(&LedOffTimeHandle, led_auto_off, LED_OFF_TIME, 0);//LED自动关闭10秒
    software_timer_init(&MotorOffTimeHandle, motor_auto_stop, MOTOR_OFF_TIME, 0);//电机自动关闭10秒
    software_timer_init(&LedTimeHandle, led_task, 100, 100);
    software_timer_start(&LedTimeHandle);
}



#define KEY_TIME_OUT    50//消抖时间,取决于while(1)的速度
KEY_TypeDef key_scan(void)
{
    static KEY_TypeDef status = NO_KEY;
    static unsigned int index = 0;

    if(gpio_read(KEY1) == 0 || gpio_read(KEY2) == 0)
    {
        index++;
        //DBG("index = %d\n", index);
        if(index == KEY_TIME_OUT)//根据scanf_key执行频率设置具体数值
        {
            if(gpio_read(KEY1) == 0){
                status = KEY1_PRESS;
                return status;
            }else if(gpio_read(KEY2) == 0){
                status = KEY2_PRESS;
                return status;
            }
        }
        if(index == KEY_TIME_OUT * 150)// 150 大概等于 3s 根据scanf_key执行频率设置具体数值
        {
            if(gpio_read(KEY1) == 0){
                status = KEY1_LONG_PRESS;
                return status;
            }else if(gpio_read(KEY2) == 0){
                status = KEY2_LONG_PRESS;
                return status;
            }
        }
    }
    else
    {
        switch (status) {
            case KEY1_PRESS:         status = KEY1_SHORT_RELEASE; return status; break;
            case KEY2_PRESS:         status = KEY2_SHORT_RELEASE; return status; break;
            case KEY1_LONG_PRESS:     status = KEY1_LONG_RELEASE; return status; break;
            case KEY2_LONG_PRESS:     status = KEY2_LONG_RELEASE; return status; break;
            default: break;
        }
        index = 0;
        status = NO_KEY;
    }

    return NO_KEY;
}



//放while(1)循环处理
void key_task(void)
{
    static unsigned char key_index = 0;// up stop down stop

    KEY_TypeDef key = key_scan();

    if(key) DBG("key = %d, key_index = %d\n", key, key_index);

    switch (key) {
        case KEY1_SHORT_RELEASE://学习配对按键
            learning_key();
            break;
        case KEY2_SHORT_RELEASE://电机控制按键
            motor_set(key_index++);
            key_index = key_index%4;//控制key_index范围 0-3
            break;
        case KEY1_LONG_PRESS:    //清楚配对按键
            user_rest();
            break;
        case KEY2_LONG_PRESS:    //遥控器上下转向
            Remote_inversion = !Remote_inversion;
            user_flash_Remote_write(Remote_inversion);//保存到flash
            LedFlag = BLINK;
            software_timer_init(&LedOffTimeHandle, led_auto_off, 2000, 0);
            software_timer_start(&LedOffTimeHandle);
            DBG("Remote_inversion = %d\n", Remote_inversion);
            break;
        default:
            break;
    }

}



//---------------------------------------BLE-------------------------------
#if 1
char * LE_CMD[] = {//接收sj的命令
    "AC00000001",//up
    "AC00000002",//down
    "AC00000003",//stop
    "AP12345678",//
};

extern unsigned char LE_Rx_Len;
extern unsigned char LE_Rx_Buf[30];
//放while(1)循环处理
void ble_task(void)
{
    if(LE_Rx_Len > 0)
    {
        DBG("BLERXLEN: %d BLERXDATA: %s\n", LE_Rx_Len, LE_Rx_Buf);
//        DBG("BLERX:%01x\n", LE_Rx_Buf[0]);
//        DBG("BLERX:%01x\n", LE_Rx_Buf[1]);
//        DBG("BLERX:%01x\n", LE_Rx_Buf[2]);
//        DBG("BLERX:%01x\n", LE_Rx_Buf[3]);
//        DBG("BLERX:%01x\n", LE_Rx_Buf[4]);

        for(int i = 0; i < sizeof(LE_CMD) / sizeof(LE_CMD[0]); i++)
        {
            if(memcmp(LE_Rx_Buf, LE_CMD[i], 10) == 0)
            {
                switch (i)
                {
                    case 0: DBG("000\n"); motor_set(0); break;
                    case 1: DBG("111\n"); motor_set(2); break;
                    case 2: DBG("222\n"); motor_set(1); break;
                    case 3: DBG("444\n"); learning_key(); break;
                    default: break;
                }
            }
        }

        memset(LE_Rx_Buf, 0, LE_Rx_Len);
        LE_Rx_Len = 0;
    }
}
#else

extern unsigned char LE_Rx_Len;
extern unsigned char LE_Rx_Buf[30];
//放while(1)循环处理
void ble_task(void)
{
    if(LE_Rx_Len > 0)
    {
        DBG("BLERXLEN: %d BLERXDATA: %s\n", LE_Rx_Len, LE_Rx_Buf);

        if(LE_Rx_Buf[0] == 0xAC)//电机命令
        {
            switch (LE_Rx_Buf[4])
            {
                case 0x01: DBG("000\n"); motor_set(0); break;
                case 0x02: DBG("111\n"); motor_set(2); break;
                case 0x03: DBG("222\n"); motor_set(1); break;
                default: break;
            }
        }
        else if(LE_Rx_Buf[0] == 0xAF)//设置命令
        {
            switch (LE_Rx_Buf[4])
            {
                case 0x78:
                    DBG("rest\n");
                    learning_key();
                    break;
                default: break;
            }
        }

        memset(LE_Rx_Buf, 0, LE_Rx_Len);
        LE_Rx_Len = 0;
    }
}

#endif

ev1527.h文件文章来源地址https://www.toymoban.com/news/detail-556019.html

/*
 * user_1527.h
 *
 *  Created on: 2023-3-20
 *      Author: Administrator
 */

#ifndef USER_1527_H_
#define USER_1527_H_

#define GPIO_IRQ         0//测试gpio硬件中断
#define GPIO_LUOFEN     0//测试逻辑分析

#define LED    GPIO_PB4//B4 需要关闭打印口
#define KEY    GPIO_PA0

extern unsigned char RxFlag;//接收状态标记
extern unsigned int RxBuf[4+1];//多开一个

void timer_irq_handler(void);
void ev1527_init(void);
void ev1527decode(void);
void ev1527_task(void);


//----------------------------------
typedef enum{
    OFF,
    ON,
    BLINK,
}LED_TypeDef;

typedef enum{
    NO_KEY,
    KEY1_PRESS,                /* 按下 */
    KEY1_SHORT_RELEASE,        /* 按下立马释放 */
    KEY1_LONG_PRESS,        /* 长按 */
    KEY1_LONG_RELEASE,        /* 长按后释放 */

    KEY2_PRESS,                /* 按下 */
    KEY2_SHORT_RELEASE,        /* 按下立马释放 */
    KEY2_LONG_PRESS,        /* 长按 */
    KEY2_LONG_RELEASE,        /* 长按后释放 */
}KEY_TypeDef;


#define KEY1        GPIO_PB7//S1   配对按键
#define KEY2        GPIO_PB6//S2 up stop down stop

#define LED1        GPIO_PB5//LED指示灯

#define MOTORUP        GPIO_PD3//上升
#define MOTORDOWN    GPIO_PD6//下降

#define LED1ON()            gpio_write(LED1, 0)
#define LED1OFF()            gpio_write(LED1, 1)

#define MOTORUPON()            gpio_write(MOTORUP, 1)
#define MOTORUPOFF()        gpio_write(MOTORUP, 0)
#define MOTORDOWNON()        gpio_write(MOTORDOWN, 1)
#define MOTORDOWNOFF()        gpio_write(MOTORDOWN, 0)

extern LED_TypeDef LedFlag;
extern unsigned char learning_flag;

void motor_set(unsigned char a);
void led_task(void);
void motor_auto_stop(void);
void led_auto_off(void);
void led_auto_off1(void);
void user_led_key_init(void);
unsigned char key_scan(void);
void key_task(void);
void led_task(void);
void learning_key(void);
void ble_task(void);
#endif /* USER_1527_H_ */

到了这里,关于433M遥控器无线解码1527协议的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 电视红外/蓝牙遥控器键值定义和适配

    一般来说,遥控器分蓝牙遥控器和红外遥控器。红外遥控器是指遥控器通过红外发射器把信号进行发射,接收设备则通过红外接收器进行信号接收;蓝牙遥控器是指遥控器通过蓝牙方式进行交互,遥控器和被连接设备均支持蓝牙则可以进行蓝牙操作。 每个遥控器的每个按键都

    2024年02月05日
    浏览(94)
  • 无人机遥控器方案定制_MTK平台无人设备手持遥控终端PCB板开发

    随着科技的不断发展和无人机技术的逐步成熟,无人机越来越受到人们的关注。作为一种高新技术,无人机的应用范围不断拓展,包括农业、环境监测、城市规划、运输物流等领域。同时,无人机的飞行控制技术也得到了不断的优化和提升。 早期,无人机的飞行控制大多以机

    2024年02月03日
    浏览(38)
  • uniapp监听TV电视遥控器的红外按键事件

    uniapp监听TV电视遥控器的红外按键事件 下面是小米电视遥控器的keyCode,供大家参考: 上 19 下 20 左 21 右 22 中 23 返回 音量+ 24 音量- 25 菜单 82

    2024年02月22日
    浏览(51)
  • 手机怎么操作电视遥控器,手机怎么操作excel表格

    大家好,小编为大家解答手机怎么操作退出电脑微信的问题。很多人还不知道手机怎么操作电脑远程控制,现在让我们一起来看看吧! Source code download: 本文相关源码   天天都在PC端运行Python代码的我,今天突然灵光一现,想着是不是能够在移动端运行Python代码呢?如果能

    2024年03月22日
    浏览(46)
  • DJI A3飞控 遥控器信号中断 会导致什么问题?

    在使用DJI A3 飞控的过程中,希望用OSDK完成自动化的任务。 DJI A3要求必须连接遥控器,可以是大疆Lightbridge的遥控器,也可以是SBUS协议的遥控器,比如航模的支持SBUS协议的遥控器即可。 当运行OSDK的过程中,遥控器出现问题,或者遥控器的信号出现干扰,导致出现连接问题时

    2024年02月04日
    浏览(94)
  • 探索控制领域:从电视遥控器到自动驾驶【基础概念理解、应用实例】

    当谈到控制学和控制系统时,你可能会联想到电视遥控器、自动驾驶汽车、飞机自动驾驶系统以及许多其他自动化系统。但控制学是一个更广泛的学科,它涵盖了各种领域,从工程到生物学,从经济学到环境科学。让我们深入了解控制学的基本概念以及它在各个领域的应用。

    2024年02月08日
    浏览(40)
  • 小米手机怎么开空调?3步让你的手机成为空调遥控器

    大家家里或者公司、学校宿舍等地方有空调吗?当你找不到空调遥控器或者空调遥控器损坏了的话该怎么办?这时候小米手机的红外线功能就派上用场了,小米手机怎么开空调? 没错,小米手机的红外线功能是可以连接大部分家用设备的,空调仅仅是其中一种,包括风扇、电

    2024年02月13日
    浏览(38)
  • 无人机基本知识,无人机遥控器功能详解与调试方法

    无人机作为一种新兴的飞行器,近年来在各个领域得到了广泛的应用。而无人机遥控器则是控制无人机飞行的重要工具。 无人机遥控器是一种无线设备,通过它来远程控制无人机的飞行。遥控器通常包括一个或多个摇杆,用于控制无人机的各种动作,如起飞、降落、前进、后

    2024年02月21日
    浏览(48)
  • 大疆无人机 MobileSDK(遥控器/手机端)开发 v4版<1>

    刚刚结束了项目交付,趁热打铁分享一下这次遇到的新东西。首先了解一下大疆的无人机,它大致可以分为三级。 入门级 :适合新手,没事干在野外飞一飞拍拍风景啥的。操作也简单,基本上看飞行教程都能懂,也不需要太高的专业性,飞机也相对较小安全系数相对较高。

    2024年02月06日
    浏览(43)
  • 大疆无人机 MobileSDK(遥控器/手机端)开发 v5版<2>

    v5.x版本的功能与v4.x基本相同,都是获取飞机的姿态信息、获取无人机多媒体文件、操作多媒体文件、航线规划等。不过在上一章节中也大致说了一些两个版本的中API的差别,下面是根据一些API使用所完成的一些功能,因为项目原因只能提供部分代码供参考,后续如果有这方

    2024年02月14日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包