#include "main.h"
#include "ReadKey.h"
#include "key.h"
#include "ReadKey.h"
#include "crc8.h"
#include "led.h"
#include "eventUnit.h"
#include "myADC.h"
#include "myInputCapture.h"
#include "myLcd.h"
#include "myDisplayUnit.h"
#include "myFlashData.h"
#include "myTim.h"
#include "myUart.h"
#include "myUart3.h"
#include "myRadio.h"

#define SOFT_VERSION 0x03
#define SET_RF_FREQ_HZ(base, ch,step) base+ch*step*10*1000
//---------------key
KeyParamExt_ts *getKeyReturn;
key_value_te keyPressValue;


static uint16_t present_adcValue;
static uartPacket_ts uart3Packet;

static bool startToCountingRx = false;
static float present_moduleCurrendValue;
static float packageCount = 1;
static float validPackageCount = 0;
static uint32_t rfContinuousFreq = 1;
static float rfRxTestRate = 1;

static rfRxPacket_ts rfRecvPacket;
static rfTxPacket_ts rfTxPacket;
static uint32_t rfTxCount = 0;
static uint32_t rfRxCount = 0;
static uint32_t rfTxAndGetAckTime_ms = 0;
static uint32_t rfTxAndGetAckTimeSet_ms = 1000;
static uint32_t rfTxReTmCount = 0;
static bool rfTxGetAckStatus = false;
static uint8_t rfCtrlMode;
const uint32_t rfBaseFreqList[] = 
{
    /*"0"*/433000000,
    /*"1"*/490000000,
    /*"2"*/868000000,
    /*"3"*/915000000,
    /*"4"*/170000000,
    /*"5"*/433000000,
    /*"6"*/490000000,
    /*"7"*/868000000,
    /*"8"*/915000000,
    /*"9"*/490000000,
};
const uint32_t rfBaudrateList[] = 
{
    90, 610, 1220, 2441, 5022, 12500, 37500
};
#define MAX_NAME_LIST_LEN 10
static char deviceNameList[MAX_NAME_LIST_LEN][20] = 
{
    /*"0"*/"VG4139S433N0S1",
    /*"1"*/"VG4139S490N0S1",
    /*"2"*/"VG4139S868N0S1",
    /*"3"*/"VG4139S915N0S1",
    /*"4"*/"VG4142S170N0S1",
    /*"5"*/"VG4142S433N0S1",
    /*"6"*/"VG4142S490N0S1",
    /*"7"*/"VG4142S868N0S1",
    /*"8"*/"VG4142S915N0S1",
    /*"9"*/"VGxxxxS470N0S1",
};

userParams_ts deviceInforDef = 
{
    .deviceID = 1,
    .rfChannel = 0,
    .channelStep = 100,
    .txPower = RF_TX_PWR_P_20,
    .rfBaudrate = RF_BAUDRATE_1220,
    .chipType = 0,
    .beepNumb = 0,
};
userParams_ts deviceInfor;

int8_t rfPowerTab[RF_TX_PWR_MAX_COUNT] = {-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

#define EVENT_TIME_CYCLE_10ms         0
#define EVENT_TIME_CYCLE_500ms      1
#define EVENT_UART3_RECV     2
#define EVENT_UART_RECV         3
#define EVENT_TEST_RX_TIMEOUT       4
#define EVENT_RF_CONTINUOUS_TX       5
#define EVENT_RF_CONTINUOUS_RX       6
#define EVENT_RF_IDLE       7
#define EVENT_RF_CONTINUOUS_TX_MD       8
#define EVENT_TIMEOUT_TO_SAVE_PARAMS       9
#define EVENT_RF_GET_RX_PACKET       10
#define EVENT_RF_PACKET_TX       11
#define EVENT_RF_PACKET_RX       12
#define EVENT_TIMEOUT_CHECK_RF_PACKET       13
#define EVENT_RF_RX_ERROR       14
static uint16_t eventReturn;

void dealKeyPressProccess(void)
{
    if (getKeyReturn->haveKey == false)
    {
        return;
    }
    getKeyReturn->haveKey = false;

    switch (getKeyReturn->value)
    {
    case LEFT_KEY:
    {
        if(getLongKeySt() == true)
        {
            clearLongKey(); 

            EnableReleaseKey();
            myDisplay_enter(ENTER_LAST_PAGE);
        }
        else
        {
            if (getReleaseKeySt())
            {

            }
            else
            {
                EnableLongKey(5);   
            }
        }
    }
        break;
    case RIGHT_KEY:
    {
        if(getLongKeySt() == true)
        {
            clearLongKey(); 

            EnableReleaseKey();
        }
        else
        {
            if (getReleaseKeySt())
            {

            }
            else
            {
                EnableLongKey(5);   
            }
        }
    }
        break;
    case TOP_KEY:
    {
        if(getCyclicKeySt() == true)
        {
            EnableCyclicKey(30); 
            myDisplay_change(1);
        }
        else
        {
            if (getReleaseKeySt())
            {
                beep_shortBeep();
                myDisplay_change(1);
            }
            else
            {
                EnableReleaseKey();
                EnableCyclicKey(300);   
            }
        }
    }
        break;
    case BOTTOM_KEY:
    {
        if(getCyclicKeySt() == true)
        {
            EnableCyclicKey(30); 
            myDisplay_change(0);
        }
        else
        {
            if (getReleaseKeySt())
            {
                beep_shortBeep();
                myDisplay_change(0);
            }
            else
            {
                EnableReleaseKey();
                EnableCyclicKey(300);   
            }
        }
    }
        break;
    case OK_KEY:
    {
        if(getLongKeySt() == true)
        {
            clearLongKey(); 

            EnableReleaseKey();
            beep_shortBeep();
            myDisplay_enter(ENTER_NEXT_PAGE);
        }
        else
        {
            if (getReleaseKeySt())
            {

            }
            else
            {
                EnableLongKey(5);   
            }
        }
    }
        break;
    default:
        break;
    }
}

/**
 * 
 * 串口回调函数，当串口有硬件超时时会调用该函数
*/
static void rcc_init(void)
{
    //---------普通IO口时钟使能
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE ); 
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE ); 
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOC, ENABLE ); 
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOD, ENABLE ); 

    //----------SPI1时钟使能
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_SPI1, ENABLE );  
    //----------复用功能时钟使能
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);

    #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)
    /* ADCCLK = PCLK2/2 */
    RCC_ADCCLKConfig(RCC_PCLK2_Div2);
    #else
    /* ADCCLK = PCLK2/4 */
    RCC_ADCCLKConfig(RCC_PCLK2_Div4); 
    #endif
}
/**
 * 
 * 串口回调函数，当串口有硬件超时时会调用该函数
*/
void UART1_CALLBACK(uint8_t *buf, uint16_t len)
{
//  if(uartPackage_Rx.isValid == 0)
//  {
//      memcpy(uartPackage_Rx.packet, buf, len);
//      uartPackage_Rx.len = len;
//      uartPackage_Rx.isValid = 1;
//      event_post(EVENT_UART_RECV);
//  }
}
void UART3_CALLBACK(uint8_t *buf, uint16_t len)
{
    if(uart3Packet.isValid == 0)
    {
        memcpy(uart3Packet.packet, buf, len);
        uart3Packet.len = len;
        uart3Packet.isValid = true;
        event_post(EVENT_UART3_RECV);
    }
}
/**
 * 
 * 定时器中断回调，当产生定时器中断会调用该函数
*/
void TIM3_CALLBACK(void)
{
    static uint8_t timeCnt_1ms = 0;

    beep_onDriver();
    if(timeCnt_1ms ++ == 5)
    {
        timeCnt_1ms = 0;
        rfTxAndGetAckTime_ms ++;
        eventDriver();
    }
}
// #define CHECK_BASE_FREQUENCE    2400
// #define MAX_OFFSET_FREQUENCE    200
#define CHECK_BASE_FREQUENCE 5000
#define MAX_OFFSET_FREQUENCE 500
void myInputCaptureCallback(uint32_t captureValue1, uint32_t captureValue2, uint32_t freq)
{
    uint32_t offsetFrequence;
    
    rfContinuousFreq = freq;
    //计算基准偏差值
    offsetFrequence = (freq > CHECK_BASE_FREQUENCE) ? 
                    (freq - CHECK_BASE_FREQUENCE) :
                    (CHECK_BASE_FREQUENCE - freq);

    if (startToCountingRx)
    {
        packageCount ++;
        if(offsetFrequence < MAX_OFFSET_FREQUENCE)
        {
            validPackageCount ++;
        }
        rfRxTestRate = validPackageCount / packageCount * 100;
    }
}
void uiEnterCallback(int pageId, int cursorCount, int status, int value)
{
    switch (pageId - 1)
    {
    case UI_PAGE_ID_ITEM_MODE:
    {

    }break;
    case UI_PAGE_ID_RF_CONTINUOUS:
    {
        switch (cursorCount)
        {
        case CNT_ITEM_INDEX_TX:
        {
            // event_post(status ? EVENT_RF_CONTINUOUS_TX : EVENT_RF_CONTINUOUS_RX);
            event_post(EVENT_RF_CONTINUOUS_TX);
            rfCtrlMode = status ? UI_PAGE_ID_RF_CONTINUOUS : 0;
        }
            break;
        case CNT_ITEM_INDEX_RX:
        {
            event_post(status ? EVENT_RF_CONTINUOUS_RX : EVENT_RF_IDLE);
        }
            break;
        case CNT_ITEM_INDEX_TX_MD:
        {
            event_post(status ? EVENT_RF_CONTINUOUS_TX_MD : EVENT_RF_IDLE);
        }
            break;
        default:
            break;
        }
    }
        break;
    case UI_PAGE_ID_TX_PACKET:
    {
        switch (cursorCount)
        {
        case 0:
        {
            setEvent(status ? EVENT_RF_PACKET_TX : EVENT_RF_IDLE, 
                    status ? true : false, 
                    status ? 500 : 0);
            rfCtrlMode = status ? UI_PAGE_ID_TX_PACKET : 0;
            rfTxCount = 0;
            rfRxCount = 0;
        }
            break;
        case 1:
        default:
            break;
        }
    }
        break;
    case UI_PAGE_ID_RX_PACKET:
    {
        switch (cursorCount)
        {
        case 0:
        {
            event_post(status ? EVENT_RF_PACKET_RX : EVENT_RF_IDLE);
            rfCtrlMode = status ? UI_PAGE_ID_RX_PACKET : 0;
            rfTxCount = 0;
            rfRxCount = 0;
        }
            break;
        default:
            break;
        }
    }
        break;
    case UI_PAGE_ID_SETTING:
    {
        switch (cursorCount)
        {
        case SET_ITEM_INDEX_TYPE://chipType
        {
            deviceInfor.chipType = value;
            myDisplay_ui_rf_setting_type(deviceNameList[deviceInfor.chipType]);
            myDisplay_ui_rf_setting_freq(SET_RF_FREQ_HZ(rfBaseFreqList[deviceInfor.chipType], deviceInfor.rfChannel, deviceInfor.channelStep));
            myRadio_setFrequency(SET_RF_FREQ_HZ(rfBaseFreqList[deviceInfor.chipType], deviceInfor.rfChannel, deviceInfor.channelStep));
            setEvent(EVENT_TIMEOUT_TO_SAVE_PARAMS, false, 200);
        }
            break;
        case SET_ITEM_INDEX_FREQ://Freq
        {
            deviceInfor.rfChannel = value;
            myDisplay_ui_rf_setting_freq(SET_RF_FREQ_HZ(rfBaseFreqList[deviceInfor.chipType], deviceInfor.rfChannel, deviceInfor.channelStep));
            myRadio_setFrequency(SET_RF_FREQ_HZ(rfBaseFreqList[deviceInfor.chipType], deviceInfor.rfChannel, deviceInfor.channelStep));
            setEvent(EVENT_TIMEOUT_TO_SAVE_PARAMS, false, 200);
        }
            break;
        case SET_ITEM_INDEX_STEP://channelStep
        {
            deviceInfor.channelStep = value;
            myDisplay_ui_rf_setting_channelStep(deviceInfor.channelStep*10*1000);
            myDisplay_ui_rf_setting_freq(SET_RF_FREQ_HZ(rfBaseFreqList[deviceInfor.chipType], deviceInfor.rfChannel, deviceInfor.channelStep));
            myRadio_setFrequency(SET_RF_FREQ_HZ(rfBaseFreqList[deviceInfor.chipType], deviceInfor.rfChannel, deviceInfor.channelStep));
            setEvent(EVENT_TIMEOUT_TO_SAVE_PARAMS, false, 200);
        }
            break;
        case SET_ITEM_INDEX_TXPOWER://TxPower
        {
            deviceInfor.txPower = value;

            myRadio_setTxPower(rfPowerTab[deviceInfor.txPower]);
            setEvent(EVENT_TIMEOUT_TO_SAVE_PARAMS, false, 200);
        }
        break;
        case SET_ITEM_INDEX_RFBAUDRATE://RFBAUDRATE
        {
            deviceInfor.rfBaudrate = value;
            myDisplay_ui_rf_setting_rfBr(rfBaudrateList[deviceInfor.rfBaudrate]);
            setEvent(EVENT_TIMEOUT_TO_SAVE_PARAMS, false, 200);
        }
            break;
        default:
            break;
        }
    }
        break;

    default:
        break;
    }
}
void rfRx_callback(uint8_t status, rfRxPacket_ts packet)
{
    
    rfRecvPacket = packet;
    
    switch (status)
    {
        case RX_STA_SECCESS:
        {
            myRadio_receiver();
            if (memcmp(rfRecvPacket.payload, "hel", 3) == 0)
            {
                event_post(EVENT_RF_GET_RX_PACKET);
                validPackageCount ++;
                if (startToCountingRx)
                {
                    
                    packageCount ++;
                }
                else
                {
                }
            }
        }
        break;
        case RX_STA_TIMEOUT:
        {
            event_post(EVENT_RF_RX_ERROR);
        }
        break;
        case RX_STA_PAYLOAD_ERROR:
        {
            packageCount ++;
            event_post(EVENT_RF_RX_ERROR);
        }
        break;
        case TX_STA_SECCESS:
        {
            LED1_ON_ONE();
            myRadio_receiver();
            // if (rfCtrlMode == UI_PAGE_ID_TX_PACKET)
            // {
            //     setEvent( EVENT_RF_PACKET_TX, false, 2000);
            // }
        }
        break;
        default:
            break;
    }
}
int main(void)
{
    userParams_ts userParamsTemp;
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
    rcc_init();
        
    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);//关闭jtag , 开启swd
    //读取本地保存数据
    myFlash_read((uint8_t*)&deviceInfor, sizeof(userParams_ts));
    if (crc8_gernCheckT((unsigned char*)&deviceInfor, 
                        sizeof(userParams_ts) - 1, 
                        deviceInfor.checkSum) == 0)
    {
        deviceInfor = deviceInforDef;
    }
    //初始化按键
    key_init();

    //初始化LED灯
    LED_Init();

    //初始化串口
    // myUart3_init(115200, UART3_CALLBACK);    //用于透传模块测试，需要时再打开
    myUart1_init(115200, UART1_CALLBACK);

    //初始化定时器
    myTim1_init(200, TIM3_CALLBACK);

    //初始化模拟转换ADC，用于无线模块驱动电流检测
    myADC_init();

    //初始化外部脉冲测量，用于接收灵敏度测试
    myInputCaptureTIM2_CH3_init(myInputCaptureCallback);

    //蜂鸣器初始化
    beep_init();
    beep_setFreq(deviceInfor.beepNumb);

    //初始化射频
    myRadio_setChipType(deviceInfor.chipType);
    myRadio_init(0, rfRx_callback);
    myRadio_setFrequency(SET_RF_FREQ_HZ(rfBaseFreqList[deviceInfor.chipType], deviceInfor.rfChannel, deviceInfor.channelStep));
    myRadio_setTxPower(rfPowerTab[deviceInfor.txPower]);
    myRadio_setBaudrate(deviceInfor.rfBaudrate);

    // LCD显示屏初始化界面显示
    myDisplay_init(uiEnterCallback);
    myDisplay_ui_firstUi_setDeviceName(deviceNameList[deviceInfor.chipType]);
    myDisplay_ui_firstUi_setFreq(SET_RF_FREQ_HZ(rfBaseFreqList[deviceInfor.chipType], deviceInfor.rfChannel, deviceInfor.channelStep));
    myDisplay_ui_firstUi_setRfPower(rfPowerTab[deviceInfor.txPower]);
    myDisplay_ui_firstUi_setRfBr(rfBaudrateList[deviceInfor.rfBaudrate]);
    myDisplay_setSettingParamsProfile(SET_ITEM_INDEX_TYPE, deviceInfor.chipType, 0, MAX_NAME_LIST_LEN);
    myDisplay_setSettingParamsProfile(SET_ITEM_INDEX_FREQ, deviceInfor.rfChannel, 0, 32 + 1);
    myDisplay_setSettingParamsProfile(SET_ITEM_INDEX_STEP, deviceInfor.channelStep, 25, 200 + 1);
    myDisplay_setSettingParamsProfile(SET_ITEM_INDEX_TXPOWER, deviceInfor.txPower, 0, RF_TX_PWR_MAX_COUNT + 1);
    myDisplay_setSettingParamsProfile(SET_ITEM_INDEX_RFBAUDRATE, deviceInfor.rfBaudrate, 2, sizeof(rfBaudrateList)/sizeof(uint32_t));
    myDisplay_ui_rf_setting_freq(SET_RF_FREQ_HZ(rfBaseFreqList[deviceInfor.chipType], deviceInfor.rfChannel, deviceInfor.channelStep));
    myDisplay_ui_rf_setting_channelStep(deviceInfor.channelStep*10*1000);
    myDisplay_ui_rf_setting_type(deviceNameList[deviceInfor.chipType]);
    myDisplay_ui_rf_setting_rfBr(rfBaudrateList[deviceInfor.rfBaudrate]);
    myDisplay_ui_deviceInfor_setVer(SOFT_VERSION);
    beep_longBeep();
    setEvent(EVENT_TIME_CYCLE_10ms, true, 10);
    setEvent(EVENT_TIME_CYCLE_500ms, true, 500);
    LED1_ON_ONE();
    LED2_ON_ONE();
    while(1)
    {   
        eventReturn = event_pend();

        if (getEvent(eventReturn, EVENT_TIME_CYCLE_10ms))
        {
            getKeyReturn = KeyValueChange(keyPressValue);
            dealKeyPressProccess();
        }
        if (getEvent(eventReturn, EVENT_TIME_CYCLE_500ms))
        {
            present_adcValue = myADC_getValue(); 
            present_moduleCurrendValue = (float)present_adcValue/4095*3.3/50/0.5*1000;
            myDisplay_ui_rf_continuos_txCurrent(present_moduleCurrendValue);
            myDisplay_ui_rf_rxPacket_rxCurrent(present_moduleCurrendValue);

            uiTimerFlash_callBack();
        }
        if (getEvent(eventReturn, EVENT_RF_CONTINUOUS_RX))
        {
            myRadio_setCtrl(RADIO_EXT_CONTROL_RX_SENSITIVITY, 
                        SET_RF_FREQ_HZ(rfBaseFreqList[deviceInfor.chipType], deviceInfor.rfChannel, deviceInfor.channelStep));
            startToCountingRx = true;
            validPackageCount = 0;
            packageCount = 1;
            // setEvent(EVENT_TEST_RX_TIMEOUT, true, 5000);
        }
        if (getEvent(eventReturn, EVENT_RF_CONTINUOUS_TX))
        {
            event_clear(EVENT_TEST_RX_TIMEOUT);
            myRadio_setCtrl(RADIO_EXT_CONTROL_TX_UNMODULATED, 
                        SET_RF_FREQ_HZ(rfBaseFreqList[deviceInfor.chipType], deviceInfor.rfChannel, deviceInfor.channelStep));
        }
        if (getEvent(eventReturn, EVENT_RF_CONTINUOUS_TX_MD))
        {
            myRadio_setTxPower(rfPowerTab[deviceInfor.txPower]);
            myRadio_setCtrl(RADIO_EXT_CONTROL_TX_MODULATED, 
                        SET_RF_FREQ_HZ(rfBaseFreqList[deviceInfor.chipType], deviceInfor.rfChannel, deviceInfor.channelStep));
        }
        if (getEvent(eventReturn, EVENT_RF_PACKET_TX))
        {
            rfTxPacket.len = strlen("hello world");
            memcpy(rfTxPacket.payload, "hello world", rfTxPacket.len);
            rfTxPacket.payload[rfTxPacket.len] = ((rfTxCount) & 0x0f) + 0x30;
            rfTxPacket.len ++;
            rfTxPacket.payload[rfTxPacket.len] = 0;
            myDisplay_ui_rf_tx_packet_buffer(rfTxPacket.payload);
            myDisplay_ui_rf_tx_packet_counts((float)rfRxCount/rfTxCount * 100 * 10, rfTxCount);
            myRadio_transmit(&rfTxPacket);
            event_clear(EVENT_TIMEOUT_CHECK_RF_PACKET);
            if (rfCtrlMode == UI_PAGE_ID_TX_PACKET)
            {   
                rfTxCount ++;
                if(rfTxAndGetAckTimeSet_ms == 0 || rfTxAndGetAckTimeSet_ms > 1500)
                {
                    setEvent( EVENT_RF_PACKET_TX, false, 1500);
                }
                else
                {
                    setEvent( EVENT_RF_PACKET_TX, false, rfTxAndGetAckTimeSet_ms*20/10);
                }
                rfTxAndGetAckTime_ms = 0;
                if (rfTxGetAckStatus == false)
                {
                    myDisplay_ui_rf_tx_packet_consumeTime(~(uint32_t)0);
                    rfTxReTmCount ++;
                    if (rfTxReTmCount == 10)
                    {
                        rfTxReTmCount = 0;
                        rfTxAndGetAckTimeSet_ms = 0;
                    }
                }
                rfTxGetAckStatus = false;
            }
        }
        if (getEvent(eventReturn, EVENT_RF_PACKET_RX))
        {
            myRadio_receiver();
            validPackageCount  = 0;
            packageCount = 0;
        }
        if (getEvent(eventReturn, EVENT_RF_GET_RX_PACKET))
        {
            rfRxCount ++;
            myDisplay_ui_rf_rxPacket_rssi(rfRecvPacket.rssi);
            myDisplay_ui_rf_rxPacket_count(rfRxCount);
            myDisplay_ui_rf_rxPacket_scroll_buffer(rfRecvPacket.payload, 0);
            myDisplay_ui_rf_rxContinue_scroll_buffer(rfRecvPacket.payload, 0);
            memset(rfRecvPacket.payload, 0, sizeof(rfRecvPacket.payload));
            myDisplay_ui_rf_continuos_rxLen((float)validPackageCount * 1000 / packageCount, validPackageCount);
            if (rfCtrlMode == UI_PAGE_ID_TX_PACKET)
            {   
                myDisplay_ui_rf_tx_packet_consumeTime(rfTxAndGetAckTime_ms);
                myDisplay_ui_rf_tx_packet_ackRssi(rfRecvPacket.rssi);
                myDisplay_ui_rf_tx_packet_counts((float)rfRxCount/rfTxCount * 100 * 10, rfTxCount);
                if(rfTxAndGetAckTime_ms == 0 || rfTxAndGetAckTime_ms >= 1500)
                {
                    setEvent( EVENT_RF_PACKET_TX, false, 1500);
                }
                else
                {
                    setEvent( EVENT_RF_PACKET_TX, false, rfTxAndGetAckTime_ms*20/10);
                }
                rfTxGetAckStatus = true;
                rfTxReTmCount = 0;
                rfTxAndGetAckTimeSet_ms = rfTxAndGetAckTime_ms;
                rfTxAndGetAckTime_ms = 0;
            }
            if (rfCtrlMode == UI_PAGE_ID_RX_PACKET)
            {   
                setEvent( EVENT_RF_PACKET_TX, false, 0);
            }
            if (startToCountingRx == true)
            {
                myDisplay_ui_rf_continuos_rxRssi(rfRecvPacket.rssi);
            }
            
            LED2_ON_ONE();
        }
        if (getEvent(eventReturn, EVENT_RF_RX_ERROR))
        {
            myRadio_receiver();
        }
        if (getEvent(eventReturn, EVENT_RF_IDLE))
        {
            startToCountingRx = false;
            myRadio_abort();
            event_clear(EVENT_RF_PACKET_TX);
        }
        if (getEvent(eventReturn, EVENT_TEST_RX_TIMEOUT))
        {
            if (startToCountingRx)
            {
                myDisplay_ui_rf_continuos_rxLen((float)validPackageCount * 1000 / packageCount, validPackageCount);
                packageCount = 1;
                validPackageCount = 0;
            }
        }
        if (getEvent(eventReturn, EVENT_UART_RECV))
        {
//          if (uartPackage_Rx.isValid)
//          {
//              uartPackage_Rx.packet = 0;
//          }
        }
        if (getEvent(eventReturn, EVENT_UART3_RECV))
        {
            if (uart3Packet.isValid)
            {
                uart3Packet.isValid = false;
                uart3Packet.len = 0;
                myDisplay_ui_rf_rxPacket_buffer(uart3Packet.packet, 0);
            }
        }
        if (getEvent(eventReturn, EVENT_TIMEOUT_TO_SAVE_PARAMS))
        {
            deviceInfor.checkSum = crc8_ger((unsigned char*)&deviceInfor, sizeof(userParams_ts) - 1);
            myFlash_write((uint8_t*)&deviceInfor, sizeof(userParams_ts));
        }
        
        keyPressValue = keyScan();
        myRadio_process();
        
    }     
}