433M遙控器無線解碼1527協議，定時器輪詢法

1527協議,最前面是引導碼，緊接著前20位為地址碼，每個遙控器不一樣，后4位是按鍵碼，每個遙控器都是一樣的,

邏輯分析儀捕捉圖形如下圖:

分別按下遙控器的四個按鍵結果如下圖：

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狀態(tài)

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;//接收狀態(tài)標記
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都是中間狀態(tài)
//當getdata==1就能提取數據了，取出完畢應當盡快的清零，否則會阻塞住

void ev1527decode(void)
{
    if(gpio_sta ==0)
    {
        if(gpio_read(KEY)==1)       // 如果高就一直循環(huán)
        {
            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)//開始信號觸發(fā)，但是要等處理結束才收
                {
                    //tl_printf(">%d\n", getdata);
                    switch(getdata)//接收到的狀態(tài)處理，1527如果接受到24個bit后，
                    {
#if (NUMBER_COUNT == 1)
                        case 0://第1波開始信號觸發(fā)
                            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波開始信號觸發(fā)，保存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波開始信號觸發(fā)
                            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波開始信號觸發(fā)，保存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波開始信號觸發(fā)
                            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波開始信號觸發(fā)，保存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)循環(huán)處理
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為打開狀態(tài) 所以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執(zhí)行頻率設置具體數值
        {
            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執(zhí)行頻率設置具體數值
        {
            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)循環(huán)處理
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)循環(huán)處理
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)循環(huán)處理
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文件文章來源地址http://www.zghlxwxcb.cn/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;//接收狀態(tài)標記
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_ */