PAN3060_CIU32F003_RX/User/main.c

/************************************************************************************************/
/**
* @file               main.c
* @author             MCU Ecosystem Development Team
* @brief              该示例展示的SN模块用法。
*                     
*
**************************************************************************************************
* @attention
* Copyright (c) CEC Huada Electronic Design Co.,Ltd. All rights reserved.
*
**************************************************************************************************
*/

/*------------------------------------------includes--------------------------------------------*/
#include "main.h"
#include "common.h"
#include "SN_GPIO.h"
#include "SN_ADC.h"
#include "SN_PWM.h"
#include "SN_EXIT.h"
#include "SN_TIM3_INIT.h"
#include "SN_TIM1_INIT.h"
#include "SN_UART.h"
#include "SN_FLASH.h"
#include "SN_RCC.h"
#include "SN_SPI.h"
#include "SN_DDQ.h"
#include "i2c_bsp.h"
#include "SN_STOP.h"
#include <stdio.h>
#include "myRadio.h"
#include "eventUnit.h"
#include "cmdDecode.h"
#include "ReadKey.h"

#define CAD_ENABLE 0
#define SOFTWARE_VERSION        0x10

#define EVENT_TIME_CYCLE_10ms           0
#define EVENT_TIME_CYCLE_500ms          1
#define EVENT_TEST_RX_TIMEOUT           2
#define EVENT_RF_AUTO_PACKET_TX         3
#define EVENT_UART1_RECV                4
#define EVENT_RF_CONTINUOUS_TX          5
#define EVENT_RF_CONTINUOUS_RX          6
#define EVENT_RF_IDLE                   7
#define EVENT_RESET_DEVICE              8
#define EVENT_TIMEOUT_TO_SAVE_PARAMS    9
#define EVENT_RF_GET_PACKET             10
#define EVENT_RF_PACKET_TX              11
#define EVENT_RF_PACKET_RX              12
#define EVENT_UART1_TRASMIT             13
#define EVENT_TIME_CYCLE_1s              14
#define EVENT_DEVICE_POWERON            15
/*------------------------------------------functions-------------------------------------------*/

#define BOARD_PIN_MOTOR       GPIO_PIN_7     //
#define BOARD_PORT_MOTOR      GPIOA          //
#define BOARD_GPIO_MOTOR      BOARD_PORT_MOTOR, BOARD_PIN_MOTOR          //

#define BOARD_PIN_BEEP       GPIO_PIN_5     //
#define BOARD_PORT_BEEP      GPIOB          //
#define BOARD_GPIO_BEEP      BOARD_PORT_BEEP, BOARD_PIN_BEEP          //

#define BOARD_PIN_LAMP       GPIO_PIN_7     //
#define BOARD_PORT_LAMP      GPIOB          //
#define BOARD_GPIO_LAMP      BOARD_PORT_LAMP, BOARD_PIN_LAMP          //

#define BOARD_PIN_KEY1       GPIO_PIN_6     //
#define BOARD_PORT_KEY1      GPIOA          //
#define BOARD_GPIO_KEY1      BOARD_PORT_KEY1, BOARD_PIN_KEY1          //

#define BOARD_PIN_ELECTRIAL       GPIO_PIN_4     //
#define BOARD_PORT_ELECTRIAL      GPIOB          //
#define BOARD_GPIO_ELECTRIAL      BOARD_PORT_ELECTRIAL, BOARD_PIN_ELECTRIAL          //

#define BOARD_PIN_CHG_OH       GPIO_PIN_5     //
#define BOARD_PORT_CHG_OH      GPIOA          //
#define BOARD_GPIO_CHG_OH      BOARD_PORT_CHG_OH, BOARD_PIN_CHG_OH          //

#define BOARD_PIN_CHG_CH       GPIO_PIN_1     //
#define BOARD_PORT_CHG_CH      GPIOC          //
#define BOARD_GPIO_CHG_CH      BOARD_PORT_CHG_CH, BOARD_PIN_CHG_CH          //

uint16_t ADC_VAL = 0;
float MCU_VDD = 0;

const uint32_t rfFreqBandList[] = {300920000, 420920000, 480920000, 858920000, 905920000, 155920000};


deviceInfor_ts deviceInfor;
const deviceInfor_ts deviceInforDef =
    {
#ifdef DEF_FREQ_BAND_IS_315
        .freqBand     = FREQ_BAND_315,
#elif DEF_FREQ_BAND_IS_160
        .freqBand     = FREQ_BAND_160,
#elif DEF_FREQ_BAND_IS_433
        .freqBand     = FREQ_BAND_433,
#elif DEF_FREQ_BAND_IS_490
        .freqBand     = FREQ_BAND_490,
#elif DEF_FREQ_BAND_IS_868
        .freqBand     = FREQ_BAND_868,
#elif DEF_FREQ_BAND_IS_915
        .freqBand     = FREQ_BAND_915,
#endif
        .channel      = 1,
        .syncWord = 0x45,
#ifdef DEF_FREQ_BAND_IS_160
        .rfPower      = RF_TX_PWR_P_10,
#else
#ifdef DEVICE_IS_1W
        .rfPower      = RF_TX_PWR_P_4,
#else
        .rfPower      = RF_TX_PWR_P_20,
#endif
#endif
        .freqStep     = 100, //=100->1000kHz
        .dogABselect   = DOG_SLT_NONE,
        .targetImei   = 0xffffffff,

};
uint8_t beepHandle = 0;
bool beepStartFlag = false;
uint8_t beepWorkCount = 0;
uint8_t beepWorkLevel = 0;
uint16_t beepWorkTime = 0;
bool localOpenFlag = false;
uint32_t localRfSendTimeCount = 0;
static rfRxPacket_ts rfRecvPacket;
#define WORK_TIMEOUT_MS 20*1000
uint32_t workTimeout_ms = WORK_TIMEOUT_MS;
#define HEART_TIMEOUT_S 15*60
#define LOCAL_BACK_TIMEOUT_S 3*60
uint32_t heartTimeout_s = HEART_TIMEOUT_S;
uint8_t heatSendPackegeCount = 0;
uint8_t lastMode = 0;
uint8_t lastModeLevel = 2;
bool isDevicePairFlag = false;
bool isDevicePairOverFlag = false;
bool keyPowerOnFlag = false;
bool keyPowerOnClearFlag = false;
bool keyPowerOnStartFlag = false;
bool batLowVltFlag = false;
bool batLowVltSendFlag = false;
bool localBackFlag = false;
typedef struct
{
    uint32_t on_ms;
    uint32_t off_ms;
}beepParams_ts;
const beepParams_ts beepParams1[] = 
{
    {50, 100},
    {50, 100},
    {50, 100},
    {50, 100},
    {50, 100},
};
const beepParams_ts beepParams2[] = 
{
    {200, 100},
    {200, 100},
    {200, 100},
    {200, 100},
    {50, 100},
    {50, 100},
};
const beepParams_ts beepParams3[] = 
{
    {50, 50},
    {50, 50},
    {50, 50},
    {50, 50},
    {50, 50},
    {50, 50},
    {50, 50},
    {50, 50},
    {50, 50},
};
const beepParams_ts beepParams255[] = 
{
    {1000, 100},
};
const beepParams_ts beepParams254[] = 
{
    {50, 100},
};
const beepParams_ts beepParams253[] = 
{
    {100, 200},
    {100, 200},
};
void beep_init(void)
{
    SN_GPIO_PIN_init(BOARD_GPIO_BEEP , GPIO_MODE_OUTPUT ,GPIO_NOPULL ,GPIO_OUTPUT_PUSHPULL);
    beepHandle = 0x55;
}
void beep_driver(void)
{
    int workOnTime = 0;
    int workCount = 0;
    if (beepHandle != 0x55)
    {
        return;
    }
    
    if (beepWorkLevel)
    {
        if (beepWorkLevel == 1)
        {
            workOnTime = beepStartFlag?beepParams1[beepWorkCount].on_ms:beepParams1[beepWorkCount].off_ms;
            workCount = sizeof(beepParams1)/sizeof(beepParams1[0]);
        }
        if (beepWorkLevel == 2)
        {
            workOnTime = beepStartFlag?beepParams2[beepWorkCount].on_ms:beepParams2[beepWorkCount].off_ms;
            workCount = sizeof(beepParams2)/sizeof(beepParams2[0]);
        }
        if (beepWorkLevel == 3)
        {
            workOnTime = beepStartFlag?beepParams3[beepWorkCount].on_ms:beepParams3[beepWorkCount].off_ms;
            workCount = sizeof(beepParams3)/sizeof(beepParams3[0]);
        }
        if (beepWorkLevel == 255)
        {
            workOnTime = beepStartFlag?beepParams255[beepWorkCount].on_ms:beepParams255[beepWorkCount].off_ms;
            workCount = sizeof(beepParams255)/sizeof(beepParams255[0]);
        }
        if (beepWorkLevel == 254)
        {
            workOnTime = beepStartFlag?beepParams254[beepWorkCount].on_ms:beepParams254[beepWorkCount].off_ms;
            workCount = sizeof(beepParams254)/sizeof(beepParams254[0]);
        }
        if (beepWorkLevel == 253)
        {
            workOnTime = beepStartFlag?beepParams253[beepWorkCount].on_ms:beepParams253[beepWorkCount].off_ms;
            workCount = sizeof(beepParams253)/sizeof(beepParams253[0]);
        }
        if (++beepWorkTime >= workOnTime)
        {
            beepWorkTime = 0;
            beepStartFlag = !beepStartFlag;
            if (beepStartFlag == true)
            {
                beepWorkCount ++;
                if (beepWorkCount >= workCount)
                {
                    beepWorkLevel = 0;
                    return;
                }
            }
        }
        if (beepStartFlag)
        {
            SN_GPIO_PIN_write(BOARD_GPIO_BEEP, 1);
        }
        else
        {
            SN_GPIO_PIN_write(BOARD_GPIO_BEEP, 0);
        }
    }
    else
    {
        SN_GPIO_PIN_write(BOARD_GPIO_BEEP, 0);
    }
    
}
void beep_on(uint8_t level)
{
    if (beepHandle != 0x55)
    {
        return;
    }
    beepWorkLevel = level;//
    beepWorkCount = 0;
    beepWorkTime = 0;
    beepStartFlag = true;
}
uint8_t motorHandle = 0;
uint32_t motorWorkCount = 0;
uint32_t motorWorkTime = 0;
uint8_t motorWorkLevel = 0;
uint8_t motorProccessIndex = 0;
typedef struct
{
    uint8_t pwmDuty;
    uint32_t p_ms[3];
}motorParams_ts;
const motorParams_ts motorParams[] = 
{
    {40, {400, 0, 0}},
    {60, {420, 0, 0}},
    {80, {440, 0, 0}},
    {80, {460, 0, 0}},
    {90, {480, 0, 0}},
    {100, {500, 0, 0}},
    {100, {1000, 0, 0}},
    {100, {100, 0, 0}},
};
void motor_init(void)
{
    SN_PWM_TIM3_OUT_init(TIM3_CH2_PA7, 8); //
    std_tim_set_ocmode(TIM3, TIM_CHANNEL_2, TIM_OUTPUT_MODE_ACTIVE);
    // SN_GPIO_PIN_init(BOARD_GPIO_MOTOR , GPIO_MODE_OUTPUT ,GPIO_PULLUP ,GPIO_OUTPUT_PUSHPULL);
    motorHandle = 0x55;
}
void motor_driver(void)
{
    if (motorHandle != 0x55)
    {
        return;
    }
    int workCount = 0;
    if (motorWorkLevel)
    {
        if (++motorWorkTime >= motorParams[motorWorkLevel - 1].p_ms[motorProccessIndex])
        {
            motorWorkTime = 0;
            motorProccessIndex ++;
            if (motorProccessIndex >= 3)
            {
                motorWorkLevel = 0;
                motorProccessIndex = 0;
                printf("motorWorkLevel = 0\r\n");
                std_tim_set_ocmode(TIM3, TIM_CHANNEL_2, TIM_OUTPUT_MODE_ACTIVE);
                return;
            }
            else if (motorProccessIndex == 1)
            {
                std_tim_set_ocmode(TIM3, TIM_CHANNEL_2, TIM_OUTPUT_MODE_ACTIVE);
            }
            else
            {
                std_tim_set_ocmode(TIM3, TIM_CHANNEL_2, TIM_OUTPUT_MODE_PWM1);
            }
            
        }
    }
    else
    {
    }
    // if (motorWorkCount)
    // {
    //     motorWorkCount --;
    //     if (motorWorkCount)
    //     {
    //         // SN_GPIO_PIN_toggle(BOARD_GPIO_MOTOR);
    //     }
    //     else
    //     {
    //         // SN_GPIO_PIN_write(BOARD_GPIO_MOTOR, 0);
    //         std_tim_set_ocmode(TIM3, TIM_CHANNEL_2, TIM_OUTPUT_MODE_ACTIVE);
    //     }
    // }
}
void motor_on(uint8_t level)
{
    if (motorHandle != 0x55)
    {
        return;
    }
    motorWorkLevel = level;
    motorProccessIndex = 0;
    printf("motorWorkLevel = %d\r\n", motorWorkLevel);
    std_tim_set_ocmode(TIM3, TIM_CHANNEL_2, TIM_OUTPUT_MODE_PWM1);
    std_tim_set_ccx_value(TIM3,TIM_CHANNEL_2, std_tim_get_autoreload(TIM3)*(100-motorParams[motorWorkLevel - 1].pwmDuty)/100);
}
void motor_short(void)
{
    motor_on(8);
}
void motor_long(void)
{
    motor_on(7);
}
uint8_t lampHandle = 0;
uint32_t lampWorkCount = 0;
uint32_t lampWorkTimeCount = 0;
bool remoteLampFlag = false;
void lamp_init(void)
{
    SN_GPIO_PIN_init(BOARD_GPIO_LAMP , GPIO_MODE_OUTPUT ,GPIO_NOPULL ,GPIO_OUTPUT_PUSHPULL);
    lampHandle = 0x55;
}
void lamp_driver(void)
{
    if (lampHandle != 0x55)
    {
        return;
    }
    if (lampWorkCount)
    {
        lampWorkCount --;
        if (lampWorkCount)
        {
            SN_GPIO_PIN_toggle(BOARD_GPIO_LAMP);
        }
        else
        {
            SN_GPIO_PIN_write(BOARD_GPIO_LAMP, 0);
        }
    }
    else if (remoteLampFlag)
    {
        if (++lampWorkTimeCount>1000)
        {
            lampWorkTimeCount = 0;
            SN_GPIO_PIN_toggle(BOARD_GPIO_LAMP);
        }
    }
    
    
}
void lamp_on(uint32_t time_ms)
{
    if (lampHandle != 0x55)
    {
        return;
    }
    lampWorkCount = time_ms;
}
void lamp_remote_on(bool onFlag)
{
    if (lampHandle != 0x55)
    {
        return;
    }
    lampWorkTimeCount = 0;
    remoteLampFlag = onFlag;
}
uint8_t electrialHandle = 0;
uint8_t electrialWorkCount = 0;
uint32_t electrialWorkTime = 0;
uint32_t electrialIntervalTime = 0;
bool isElectrialOn = false;
typedef struct 
{
    uint8_t pwmDuty;
    uint32_t workTime;
    uint32_t intvTime;
}electrialParams_ts;
electrialParams_ts electrialParams;
void electrial_init(void)
{
    SN_PWM_TIM3_OUT_init(TIM3_CH4_PB4, 8); //
    std_tim_set_ocmode(TIM3, TIM_CHANNEL_4, TIM_OUTPUT_MODE_ACTIVE);
    electrialHandle = 0x55;
}
void electrial_driver(void)
{
    if (electrialHandle != 0x55)
    {
        return;
    }
    if (electrialIntervalTime == 0)
    {
        if (electrialWorkCount)
        {
            if (electrialWorkTime)
            {
                electrialWorkTime --;
                if (electrialWorkTime == 0)
                {
                    electrialWorkCount --;
                    if (electrialWorkCount)
                    {
                        if (electrialParams.intvTime)
                        {
                            std_tim_set_ocmode(TIM3, TIM_CHANNEL_4, TIM_OUTPUT_MODE_ACTIVE);
                        }
                        else
                        {
                            electrialWorkTime = electrialParams.workTime;
                        }
                        
                        electrialIntervalTime = electrialParams.intvTime;
                    }
                    else
                    {
                        std_tim_set_ocmode(TIM3, TIM_CHANNEL_4, TIM_OUTPUT_MODE_ACTIVE);
                    }
                }
            }
        }
    }
    else
    {
        electrialIntervalTime --;
        if (electrialIntervalTime == 0)
        {
            std_tim_set_ocmode(TIM3, TIM_CHANNEL_4, TIM_OUTPUT_MODE_PWM1);
            electrialWorkTime = electrialParams.workTime;
        }
    }
    
}
void pwm_setDuty(uint8_t pwm_duty)
{
    if (pwm_duty > 100)
    {
        pwm_duty = 100;
    }
    printf("std_tim_get_autoreload(TIM3)=%d\n", std_tim_get_autoreload(TIM3));
    std_tim_set_ccx_value(TIM3,TIM_CHANNEL_4, std_tim_get_autoreload(TIM3)*(100-pwm_duty)/100);
}
void electrial_on(uint8_t level)
{
    uint8_t setDuty = 1;
    if (electrialHandle != 0x55)
    {
        // return;
        SN_PWM_TIM3_OUT_init(TIM3_CH4_PB4, 8); //
        std_tim_set_ocmode(TIM3, TIM_CHANNEL_4, TIM_OUTPUT_MODE_ACTIVE);
        electrialHandle = 0x55;
    }
    if (level > 99)
    {
        level = 99;
    }
    
    electrialWorkCount = 2;
    electrialIntervalTime = 0;
    electrialParams.workTime = level * 4;
    electrialParams.intvTime = (99 - (level-1)) * 3;
    electrialWorkTime = electrialParams.workTime;
    if (level < 10)
    {
        setDuty = 2;
    }
    else if (level < 20)
    {
        setDuty = 5;
    }
    else if (level < 30)
    {
        setDuty = 7;
    }
    else if (level < 60)
    {
        setDuty = 8;
    }
    else
    {
        setDuty = 10;
    }
    
    std_tim_set_psc(TIM3, 8);
    std_tim_set_autoreload(TIM3, 184); 
    pwm_setDuty(setDuty);
    std_tim_set_ocmode(TIM3, TIM_CHANNEL_4, TIM_OUTPUT_MODE_PWM1);
}
uint8_t batAdcHandle = 0;
void batAdc_init(void)
{
    SN_ADC_IN_init(ADC_CHANNEL_2_PA4);
    batAdcHandle = 0x55;
}
uint16_t getBatAdcValue(void)
{
    if (batAdcHandle != 0x55)
    {
        return 0;
    }
    std_adc_enable();
    SN_ADC_start();
    float MCU_VDD = SN_ADC_MCU_VDD();
    uint16_t ADC_VAL = SN_ADC_Get(0);
    std_adc_disable();
    uint16_t retVlt = (uint32_t)ADC_VAL*MCU_VDD/4096 *2;
    if (retVlt < 3000)
    {
        if (batLowVltFlag == false)
        {
            
        }
        
        batLowVltFlag = true;
    }
    else if (retVlt > 3300)
    {
        batLowVltFlag = false;
        batLowVltSendFlag = false;
    }
    printf("hello world  %f %u\r\n", MCU_VDD, retVlt);
    return retVlt;
}
bool batChgStaFlag = false;
void  batChgSta_callback(void){
    workTimeout_ms = WORK_TIMEOUT_MS;

    // printf("BOARD_CH = %d\r\n", SN_GPIO_PIN_get(BOARD_GPIO_CHG_CH));
    // printf("BOARD_OH = %d\r\n", SN_GPIO_PIN_get(BOARD_GPIO_CHG_OH));
    workTimeout_ms = WORK_TIMEOUT_MS;
    if (SN_GPIO_PIN_get(BOARD_GPIO_CHG_CH) == 0)
    {
        batChgStaFlag = true;
    }
    else
    {
        if (SN_GPIO_PIN_get(BOARD_GPIO_CHG_OH))
        {
            batChgStaFlag = false;
        }
    }
}
void batChgSta_init(void)
{
    SN_EXIT_set(BOARD_GPIO_CHG_OH,GPIO_PULLUP,batChgSta_callback,EXTI_TRIGGER_RISING_FALLING,NVIC_PRIO_3);
    SN_EXIT_set(BOARD_GPIO_CHG_CH,GPIO_PULLUP,batChgSta_callback,EXTI_TRIGGER_RISING_FALLING,NVIC_PRIO_3);
}
bool checkLowPowerFlag(void)
{
    return (workTimeout_ms == 0 && 
            (rf_workProcess == RF_PRC_IDLE || rf_workProcess == RF_PRC_SLEEP) && 
            remoteLampFlag == false && 
            rf_workProcess != RF_PRC_TX && 
            keyPowerOnStartFlag == false && 
            isDevicePairFlag == false);
}
//---------------key
typedef enum
{
    KEY_VALUE_NONE = 0,
    KEY_VALUE_KEY_1,
};
KeyParamExt_ts *getKeyReturn;
uint8_t keyPressValue;
bool isKeyLowPowerFlag = false;

int keyOutputValue = 0;
int keyOutputValueTemp = 0;
bool iskeyPressFlag = false;
void  key_callback(void){
    workTimeout_ms = WORK_TIMEOUT_MS;
    if (checkLowPowerFlag())
    {
        iskeyPressFlag = true;
    }
}
void key_init(void)
{
    // SN_GPIO_PIN_init(BOARD_GPIO_KEY1 , GPIO_MODE_INPUT ,GPIO_PULLUP ,GPIO_OUTPUT_PUSHPULL);
    SN_EXIT_set(BOARD_GPIO_KEY1,GPIO_PULLUP,key_callback,EXTI_TRIGGER_FALLING,NVIC_PRIO_3);
}

int key_driver(void)
{
    static uint32_t keyboundTime = 0;
    int keyScanIndex = 0;
    if (isKeyLowPowerFlag)
    {
        return KEY_VALUE_NONE;
    }
    
    keyOutputValue = KEY_VALUE_NONE;
    if (SN_GPIO_PIN_get(BOARD_GPIO_KEY1) == 0)
    {
        keyOutputValue = KEY_VALUE_KEY_1;
    }
    int ret = KEY_VALUE_NONE;
    if (keyOutputValueTemp != keyOutputValue)
    {
        keyboundTime = 7;
    }
    if (keyboundTime)
    {
        keyboundTime --;
    }
    else
    {
        ret = keyOutputValue;
    }
    
    keyOutputValueTemp = keyOutputValue;
    
    return ret;
}
void dealKeyPressProccess(void)
{
    if (getKeyReturn->haveKey == false)
    {
        return;
    }
    if (batChgStaFlag == true)
    {
        return;
    }
    getKeyReturn->haveKey = false;

    switch (getKeyReturn->value)
    {
    case KEY_VALUE_KEY_1: // 档位调节增加健
    {
        workTimeout_ms = WORK_TIMEOUT_MS;
        iskeyPressFlag = false;
        if(getLongKeySt() == true)
        {
            clearLongKey();
            clearDoubleKey();
            keyPowerOnStartFlag = false;
            if(keyPowerOnFlag == false)
            {
                beep_on(255);
                motor_long();
                lamp_on(1000);
                clearReleaseKey();
                keyPowerOnFlag = true;
                myRadio_receiver(0);
            }
            else
            {
                // beep_on(255);
                motor_long();
                keyPowerOnClearFlag = true;
            }
            
        }
        else if(getDoubleKeySt() == true)
        {
            clearReleaseKey();
            if (keyPowerOnFlag)
            {
                beep_on(254);
                myRadio_setFrequency(rfFreqBandList[deviceInfor.freqBand] +
                             (uint32_t)0 * deviceInfor.freqStep * 10 * 1000);
                myRadio_receiver(0);
                workTimeout_ms = 5*60000;
                isDevicePairFlag = true;
            }
        }
        else
        {
            if (getReleaseKeySt())
            {
                // NVIC_SystemReset();
                clearReleaseKey();
                // motor_on(50);
                iskeyPressFlag = false;
                if (keyPowerOnClearFlag)
                {
                    keyPowerOnFlag = false;
                    keyPowerOnClearFlag = false;
                }
            }
            else
            {
                EnableLongKey(2000);  
                EnableReleaseKey(); 
                EnableDoubleKey(); 
            }
        }
    }
        break;
    default:
        break;
    }
}
void rfRx_callback(uint8_t status, rfRxPacket_ts packet)
{
    printf("status:%d\r\n", status);
    switch (status)
    {
        case RX_STA_SECCESS:
        {
            printf("receive data:%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\r\n", packet.payload[0], packet.payload[1], packet.payload[2], packet.payload[3], packet.payload[4], packet.payload[5], packet.payload[6], packet.payload[7], packet.payload[8], packet.payload[9]);
            rfRecvPacket = packet;
            // RF_StopCad();
            myRadio_receiver(0);
            event_post(EVENT_RF_GET_PACKET);
            workTimeout_ms = WORK_TIMEOUT_MS;
            // myRadio_restartCadReceiver();
        }
        break;
        case RX_STA_TIMEOUT:
        {
            #if CAD_ENABLE == 1
            myRadio_receiver(0);
            #else
            myRadio_abort();
            #endif
            // myRadio_restartCadReceiver();
        }
        break;
        case RX_STA_PAYLOAD_ERROR:
        {
            myRadio_receiver(0);
            // myRadio_restartCadReceiver();
        }
        break;
        case TX_STA_SECCESS:
        {
            if (isDevicePairOverFlag)
            {
                isDevicePairOverFlag = false;
                myRadio_setFrequency(rfFreqBandList[deviceInfor.freqBand] +
                            (uint32_t)deviceInfor.channel * deviceInfor.freqStep * 10 * 1000);
                printf("pair success channel=%d\r\n", deviceInfor.channel);
            }
			myRadio_receiver(0);
            // myRadio_cadReceiver(500, 2000);
        }
        break;
        default:
            break;
    }
}

uint32_t sendTimeout = 0;

void LPTIM1_IRQHandler(void)
{
    system_clock_config();
	if (std_lptim_get_flag(LPTIM_FLAG_ARRM) == LPTIM_FLAG_ARRM)
	{
        static uint8_t timeoutcount_1s = 0;
		std_lptim_clear_flag(LPTIM_CLEAR_ARRM);
        printf("LPTIM1_IRQHandler\r\n");
        if (timeoutcount_1s ++ >= 1)
        {
            timeoutcount_1s = 0;
            uint16_t getVlt = getBatAdcValue();
            if (batLowVltFlag == true)
            {
                if (batLowVltSendFlag == false)
                {
                    workTimeout_ms = WORK_TIMEOUT_MS;
                    batLowVltSendFlag = true;
                    devicePairFram_ts devicePairBuffer;
                    devicePairBuffer.clientInfor.infor.cmd = CMD_REBACK_SEND;
                    devicePairBuffer.clientInfor.infor.rfChannel = deviceInfor.channel;
                    devicePairBuffer.clientInfor.infor.type = deviceInfor.dogABselect;
                    devicePairBuffer.clientInfor.infor.deviceId = deviceInfor.targetImei;
                    devicePairBuffer.value = getBatAdcValue();
                    printf("batLowVltSendFlag  %d\n", devicePairBuffer.value);
                    completFramParams((uint8_t *)&devicePairBuffer, sizeof(devicePairBuffer));
                    myRadio_transmitArray((uint8_t *)&devicePairBuffer, sizeof(devicePairFram_ts));
                }
                
            }
            else
            {
                if (keyPowerOnFlag)
                {
                    if (heartTimeout_s)
                    {
                        heartTimeout_s --;
                        if (heartTimeout_s == 0)
                        {
                            workTimeout_ms = 5*1000;
                            if (localBackFlag)
                            {
                                heartTimeout_s = LOCAL_BACK_TIMEOUT_S;
                                if (heatSendPackegeCount >= 2)
                                {
                                    heatSendPackegeCount = 0;
                                    // 信号丢失
                                    if (lastMode == CMD_TRIGLE_VIRBRA)
                                    {
                                        motor_on(lastModeLevel);
                                    }
                                    else
                                    {
                                        beep_on(lastModeLevel);
                                    }
                                }
                                else
                                {
                                    heatSendPackegeCount ++;
                                }
                                
                            }
                            else
                            {
                                heartTimeout_s = HEART_TIMEOUT_S;
                            }
                            
                            devicePairFram_ts devicePairBuffer;
                            devicePairBuffer.clientInfor.infor.cmd = CMD_REBACK_SEND;
                            devicePairBuffer.clientInfor.infor.rfChannel = deviceInfor.channel;
                            devicePairBuffer.clientInfor.infor.type = deviceInfor.dogABselect;
                            devicePairBuffer.clientInfor.infor.deviceId = deviceInfor.targetImei;
                            devicePairBuffer.value = getBatAdcValue();
                            printf("batLowVltSendFlag  %d\n", devicePairBuffer.value);
                            completFramParams((uint8_t *)&devicePairBuffer, sizeof(devicePairBuffer));
                            myRadio_transmitArray((uint8_t *)&devicePairBuffer, sizeof(devicePairFram_ts));
                        }
                    }
                }
            }
        }
    }
}
void lptim1_init(void)
{
    /* 使能RCL时钟并等待时钟稳定 */
    std_rcc_rcl_enable();
    while(std_rcc_get_rcl_ready() != RCC_CSR2_RCLRDY);
    
    /* 选择LPTIM1的时钟源为RCL */
    std_rcc_set_lptim1clk_source(RCC_LPTIM1_ASYNC_CLK_SRC_RCL);
    
    /* 使能LPTIM1时钟 */
    std_rcc_apb1_clk_enable(RCC_PERIPH_CLK_LPTIM1);
    
    /* 设置LPTIM1预分频器 */
    std_lptim_set_prescaler(LPTIM_PRESCALER_DIV1);
    
    /* 使能LPTIM1中断唤醒 */
    std_exti_interrupt_enable(EXTI_LINE_LPTIM1);
    
    /* 禁止LPTIM1事件唤醒 */
    std_exti_event_disable(EXTI_LINE_LPTIM1);

    /* 使能自动重载匹配中断 */
    std_lptim_interrupt_enable(LPTIM_INTERRUPT_ARRM);
    
    /* 使能LPTIM1 */
    std_lptim_enable();
    // std_lptim_disable();
    
    /* 启动LPTIM1计数 */
    std_lptim_start_counter(LPTIM_COUNT_CONTINUOUS);
    std_lptim_set_auto_reload(600*32000/1000);
    // std_lptim_start_counter(LPTIM_COUNT_SINGLE);
    NVIC_SetPriority(LPTIM1_IRQn, NVIC_PRIO_0);
    NVIC_EnableIRQ(LPTIM1_IRQn);
}
void lptim1_restart(uint32_t time_ms)
{
    /* 启动LPTIM1计数 */
    std_lptim_set_auto_reload(time_ms*32000/1000);
    std_lptim_start_counter(LPTIM_COUNT_SINGLE);
}
void main_tim_callback(void)
{
    static uint16_t timeCnt_1ms = 0;
    static uint16_t pairTimeCnt_1ms = 0;
    static uint32_t couint = 0;
    if (++timeCnt_1ms == 5)
    {
        timeCnt_1ms = 0;
        eventDriver();
        if (couint++ == 1000)
        {
            couint = 0;
        }
        if (workTimeout_ms)
        {
            workTimeout_ms--;
            if (workTimeout_ms == 0)
            {
                if (isDevicePairFlag)
                {
                    isDevicePairFlag = false;
                    myRadio_setFrequency(rfFreqBandList[deviceInfor.freqBand] +
                         (uint32_t)deviceInfor.channel * deviceInfor.freqStep * 10 * 1000);
                }
                if (remoteLampFlag == false)
                {
                    // lamp_on(100);
                    #if CAD_ENABLE == 1
                    myRadio_cadReceiver(30, 500);
                    #else
                    if (batChgStaFlag == false)
                    {
                        myRadio_receiver(60);
                    }
                    else
                    {
                        myRadio_receiver(0);
                    }
                    
                    #endif
                }
            }
            else
            {
                if (isDevicePairFlag)
                {
                    if (pairTimeCnt_1ms++ >= 500)
                    {
                        pairTimeCnt_1ms = 0;
                        lamp_on(100);
                    }
                }
            }
            
        }
        myRadio_timCallback(1);
        motor_driver();
        lamp_driver();
        electrial_driver();
        beep_driver();
    }
}
int main(void)
{  
    SN_SYSCLK_set(SYSCLK_48MHZ);                  //设置系统时钟为48MHZ
    std_delay_init();                             //初始化延时（该延时是使用滴答定时器实现的）
    SN_FLASH_ReadE(0x00005e00, (uint8_t *)&deviceInfor, sizeof(deviceInfor_ts));
    if ((checkFramLegal((uint8_t *)&deviceInfor, sizeof(deviceInfor_ts)) == false))
    {
        deviceInfor = deviceInforDef;
    }
    // electrial_init();
    beep_init();
    motor_init();
    lamp_init();
    batAdc_init();
    std_delayms(1500);	
    SN_UART_init(UART1,921600, UART1_RX_PA2, UART1_TX_PB6); //初始化串口
    batChgSta_init();
    key_init();
    if (SN_GPIO_PIN_get(BOARD_GPIO_KEY1) == 0)
    {
        keyPowerOnStartFlag = true;
    }
    
    if(myRadio_init(0, rfRx_callback))
    {
        beep_on(254);
    }
    else
    {
        lamp_on(1000);
        beep_on(255);
    }
    if (deviceInfor.targetImei != 0xffffffff)
    {
        deviceInfor.channel = deviceInfor.targetImei & 0x001f;
    }
    
    myRadio_setTxPower(20);
    myRadio_setBaudrate(RF_BAUDRATE_1220);
    myRadio_setFrequency(rfFreqBandList[deviceInfor.freqBand] +
                         (uint32_t)deviceInfor.channel * deviceInfor.freqStep * 10 * 1000);
    myRadio_setSyncWord(0x45);
    // myRadio_cadReceiver(500, 2000);
    myRadio_receiver(0);
    SN_TIM1_CALL_set(9500, 0, main_tim_callback, NVIC_PRIO_0);
    lptim1_init();
    setEvent(EVENT_TIME_CYCLE_10ms, true, false, 10);
    setEvent(EVENT_TIME_CYCLE_500ms, true, false, 500);
    setEvent(EVENT_TIME_CYCLE_1s, true, false, 1000);
    printf("power on");

    printf("freqBand:%d\n", deviceInfor.freqBand);
    printf("channel:%d\n", deviceInfor.channel);
    printf("targetImei:%08X\n", deviceInfor.targetImei);
    printf("dogABselect:%d\n", deviceInfor.dogABselect);
    // motor_on(50);
    if(SN_GPIO_PIN_get(BOARD_GPIO_KEY1) == 0)
    {
        workTimeout_ms = 30*60*1000;
        SN_GPIO_PIN_write(BOARD_GPIO_LAMP, 1);
        myRadio_setFrequency(rfFreqBandList[deviceInfor.freqBand] +
                            (uint32_t)1 * deviceInfor.freqStep * 10 * 1000);
        myRadio_setCtrl(RADIO_EXT_CONTROL_TX_UNMODULATED, rfFreqBandList[deviceInfor.freqBand] +
                        (uint32_t)1 * deviceInfor.freqStep * 10 * 1000);
        while (1);
    }
    while(1){
        event_pend();
        // iwdgSetCounter();
        if (getEvent(EVENT_TIME_CYCLE_10ms))
        {
            keyPressValue = key_driver();
            getKeyReturn = KeyValueChange(keyPressValue);
            dealKeyPressProccess();
#if 0 //测试动态内存申请
            // for (size_t i = 0; i < 1000; i++)
            {
                static uint16_t i = 0;
                myUart_printf(0, "hello dma (%d)\r\n", i ++);
            }
#endif
        }
        if (getEvent(EVENT_TIME_CYCLE_500ms))
        {
//测试时钟是否准确，通过串口上位机打印的时间来判断
#if 0

            SN_ADC_start();
            float MCU_VDD = SN_ADC_MCU_VDD();
            uint16_t ADC_VAL = SN_ADC_Get(0);
            printf("hello world  %f %u\r\n", MCU_VDD, ADC_VAL);
#endif
        }
        if (getEvent(EVENT_TIME_CYCLE_1s))
        {
//测试时钟是否准确，通过串口上位机打印的时间来判断
#if 0
            myUart_printf(0, "hello world  %02x\r\n", lowPowerCtrlFlag.value);
#endif
        }
        if (getEvent(EVENT_DEVICE_POWERON))
        {
            // lowPowerCtrlFlag.bits.powerOn = 0;
        }
        if (getEvent(EVENT_RF_GET_PACKET))
        {
            // motor_long();
            if (checkFramLegal(rfRecvPacket.payload, rfRecvPacket.len))
            {
                devicePairFram_ts *devicePairFram = (devicePairFram_ts *)rfRecvPacket.payload;
                printf("EVENT_RF_GET_PACKET cmd:%02X\n", devicePairFram->clientInfor.infor.cmd);
                printf("EVENT_RF_GET_PACKET infor.rfChannel:%d\n", devicePairFram->clientInfor.infor.rfChannel);
                printf("EVENT_RF_GET_PACKET type:%d\n", devicePairFram->clientInfor.infor.type);
                printf("EVENT_RF_GET_PACKET batChgStaFlag:%d\n", batChgStaFlag);
                printf("EVENT_RF_GET_PACKET keyPowerOnFlag:%d\n", keyPowerOnFlag);
                printf("EVENT_RF_GET_PACKET batLowVltFlag:%d\n", batLowVltFlag);
                if ((batChgStaFlag == false) && (keyPowerOnFlag == true) && (batLowVltFlag == false))
                {
                    if (((devicePairFram->clientInfor.infor.rfChannel == deviceInfor.channel) && 
                            (deviceInfor.dogABselect == devicePairFram->clientInfor.infor.type || 
                            devicePairFram->clientInfor.infor.type == DOG_SLT_AB)) || 
                        (devicePairFram->clientInfor.infor.cmd == CMD_DEVICE_PAIR && devicePairFram->clientInfor.infor.rfChannel == 0))
                    {
                        workTimeout_ms = 2000;//WORK_TIMEOUT_MS; //
                        heatSendPackegeCount = 0;
                        switch (devicePairFram->clientInfor.infor.cmd)
                        {
                        case CMD_DEVICE_PAIR:
                            {
                                deviceInfor.targetImei = devicePairFram->clientInfor.infor.deviceId;
                                deviceInfor.channel = deviceInfor.targetImei & 0x001f;
                                deviceInfor.dogABselect = devicePairFram->clientInfor.infor.type;
                                completFramParams((uint8_t *)&deviceInfor, sizeof(deviceInfor_ts));
                                uint8_t ret = SN_FLASH_Write_PAGE(0x2f,(uint8_t *)&deviceInfor, sizeof(deviceInfor));
                                printf("CMD_DEVICE_PAIR  %d\n", ret);
                                if (devicePairFram->clientInfor.infor.type == DOG_SLT_B)
                                {
                                    std_delayms(200);
                                }
                                
                                devicePairFram_ts devicePairBuffer;
                                devicePairBuffer.clientInfor.infor.cmd = CMD_DEVICE_PAIR;
                                devicePairBuffer.clientInfor.infor.rfChannel = 0;
                                devicePairBuffer.clientInfor.infor.type = deviceInfor.dogABselect;
                                devicePairBuffer.clientInfor.infor.deviceId = devicePairFram->clientInfor.infor.deviceId;
                                devicePairBuffer.value = getBatAdcValue();
                                printf("CMD_DEVICE_PAIR  %d\n", devicePairBuffer.value);
                                completFramParams((uint8_t *)&devicePairBuffer, sizeof(devicePairBuffer));
                                myRadio_transmitArray((uint8_t *)&devicePairBuffer, sizeof(devicePairFram_ts));
                                beep_on(254);
                                isDevicePairFlag = false;
                                isDevicePairOverFlag = true;
                            }
                            break;
                        case CMD_TRIGLE_ELECTR:
                            {
                                electrial_on(devicePairFram->value);
                                devicePairFram_ts devicePairBuffer;
                                devicePairBuffer.clientInfor.infor.cmd = CMD_ACK;
                                devicePairBuffer.clientInfor.infor.rfChannel = deviceInfor.channel;
                                devicePairBuffer.clientInfor.infor.type = deviceInfor.dogABselect;
                                devicePairBuffer.clientInfor.infor.deviceId = devicePairFram->clientInfor.infor.deviceId;
                                devicePairBuffer.value = getBatAdcValue();
                                printf("CMD_DEVICE_PAIR  %d\n", devicePairBuffer.value);
                                completFramParams((uint8_t *)&devicePairBuffer, sizeof(devicePairBuffer));
                                myRadio_transmitArray((uint8_t *)&devicePairBuffer, sizeof(devicePairFram_ts));
                            }
                            break;
                        case CMD_TRIGLE_VIRBRA:
                            {
                                lastMode = CMD_TRIGLE_VIRBRA;
                                lastModeLevel = devicePairFram->value;
                                motor_on(devicePairFram->value);
                                devicePairFram_ts devicePairBuffer;
                                devicePairBuffer.clientInfor.infor.cmd = CMD_ACK;
                                devicePairBuffer.clientInfor.infor.rfChannel = deviceInfor.channel;
                                devicePairBuffer.clientInfor.infor.type = deviceInfor.dogABselect;
                                devicePairBuffer.clientInfor.infor.deviceId = devicePairFram->clientInfor.infor.deviceId;
                                devicePairBuffer.value = getBatAdcValue();
                                printf("CMD_DEVICE_PAIR  %d\n", devicePairBuffer.value);
                                completFramParams((uint8_t *)&devicePairBuffer, sizeof(devicePairBuffer));
                                myRadio_transmitArray((uint8_t *)&devicePairBuffer, sizeof(devicePairFram_ts));
                            }
                            break;
                        case CMD_TRIGLE_LAMP:
                            {
                                lamp_remote_on(devicePairFram->value);
                                devicePairFram_ts devicePairBuffer;
                                devicePairBuffer.clientInfor.infor.cmd = CMD_ACK;
                                devicePairBuffer.clientInfor.infor.rfChannel = deviceInfor.channel;
                                devicePairBuffer.clientInfor.infor.type = deviceInfor.dogABselect;
                                devicePairBuffer.clientInfor.infor.deviceId = devicePairFram->clientInfor.infor.deviceId;
                                devicePairBuffer.value = getBatAdcValue();
                                printf("CMD_DEVICE_PAIR  %d\n", devicePairBuffer.value);
                                completFramParams((uint8_t *)&devicePairBuffer, sizeof(devicePairBuffer));
                                myRadio_transmitArray((uint8_t *)&devicePairBuffer, sizeof(devicePairFram_ts));
                            }
                            break;
                        case CMD_TRIGLE_TRAIN_VOL:
                            {
                                lastMode = CMD_TRIGLE_TRAIN_VOL;
                                lastModeLevel = devicePairFram->value;
                                beep_on(devicePairFram->value);
                                devicePairFram_ts devicePairBuffer;
                                devicePairBuffer.clientInfor.infor.cmd = CMD_ACK;
                                devicePairBuffer.clientInfor.infor.rfChannel = deviceInfor.channel;
                                devicePairBuffer.clientInfor.infor.type = deviceInfor.dogABselect;
                                devicePairBuffer.clientInfor.infor.deviceId = devicePairFram->clientInfor.infor.deviceId;
                                devicePairBuffer.value = getBatAdcValue();
                                printf("CMD_DEVICE_PAIR  %d\n", devicePairBuffer.value);
                                completFramParams((uint8_t *)&devicePairBuffer, sizeof(devicePairBuffer));
                                myRadio_transmitArray((uint8_t *)&devicePairBuffer, sizeof(devicePairFram_ts));
                            }
                            break;
                        case CMD_REBACK_SEND:
                            {
                                localBackFlag = devicePairFram->value&0x0f?true:false;
                                if (localBackFlag)
                                {
                                    heartTimeout_s = LOCAL_BACK_TIMEOUT_S;
                                }
                                else
                                {
                                    heartTimeout_s = HEART_TIMEOUT_S;
                                }
                                devicePairFram_ts devicePairBuffer;
                                devicePairBuffer.clientInfor.infor.cmd = CMD_REBACK_SEND;
                                devicePairBuffer.clientInfor.infor.rfChannel = deviceInfor.channel;
                                devicePairBuffer.clientInfor.infor.type = deviceInfor.dogABselect;
                                devicePairBuffer.clientInfor.infor.deviceId = devicePairFram->clientInfor.infor.deviceId;
                                devicePairBuffer.value = getBatAdcValue();
                                printf("CMD_REBACK_SEND  %d\n", devicePairBuffer.value);
                                completFramParams((uint8_t *)&devicePairBuffer, sizeof(devicePairBuffer));
                                myRadio_transmitArray((uint8_t *)&devicePairBuffer, sizeof(devicePairFram_ts));
                            }
                            break;
                        case CMD_ACK:
                            {

                            }
                            break;
                        
                        default:
                            break;
                        }
                    }
                }
                else
                {
                    printf("batChgStaFlag=%d\n", batChgStaFlag);
                }
                
            }
            memset(&rfRecvPacket, 0, sizeof(rfRecvPacket));
        }
		myRadio_process();
		#if ENABLE_LOWPOWER == 1
        if (checkLowPowerFlag())
        {
            std_tim_disable(TIM1);
            printf("low power\r\n");
            if (keyPowerOnFlag && batLowVltFlag == false)
            {
                // lptim1_restart(500);
            }
            /* 进入Deepstop模式 最小功耗5ua 测试功耗要将仿真器断开 */  
            std_pmu_enter_stop(PMU_MODE_DEEPSTOP, PMU_ENTRY_LOWPOWER_MODE_WFI);
            
            system_clock_config();
            printf("low power wakeup\r\n");
            std_tim_enable(TIM1);
            if (iskeyPressFlag)
            {
                iskeyPressFlag = false;
                myRadio_receiver(0);
            }
            else
            {
                #if CAD_ENABLE == 1
                RF_ExitSleepState();
                myRadio_restartCadReceiver();
                #else
                myRadio_receiver(60);
                myRadio_delay(1);
                std_pmu_enter_stop(PMU_MODE_DEEPSTOP, PMU_ENTRY_LOWPOWER_MODE_WFI);
                #endif
            }
        }
		#endif
	}
}