bsp.aun2402/source/main.c

/* Includes ------------------------------------------------------------------*/
#include "main.h"

#include "instance.h"
#include "bsp_esp8266.h"
#include "message.h"

/* Private typedef -----------------------------------------------------------*/

typedef enum _reset_reason_ {
    RESET_BOR = 0x00000001,
    //RESET_OBL    = 0x00000002,
    RESET_PIN = 0x00000004,
    //RESET_FW     = 0x00000010,
    //RESET_RMV    = 0x00000020,
    RESET_SFT = 0x00000040,
    RESET_IWDG = 0x00000100,
    RESET_WWDG = 0x00000200,
    RESET_LPWR = 0x00000400,
} eResetReason;

typedef enum _net_type {
    NET_EtherNet = 0,
    NET_Wifi
} eNetType;

/* Private define ------------------------------------------------------------*/
#define BOOTLOADER_DELAY_TIME       (3 * 1000)
#define RCV_TOF_MAXDELAY            14400000
#define BAT_POWER_PEROID            20
/* Private macro -------------------------------------------------------------*/
char cStr[] = {"123458"};


/* Private variables ---------------------------------------------------------*/
const RTC_DateTypeDef factoryDate = {
    .Month = 1,
    .Date = 1,
    .Year = 18,
};
const RTC_TimeTypeDef factoryTime = {
    .Hours = 0,
    .Minutes = 0,
    .Seconds = 0,
    .TimeFormat = 0,
};

//static RTC_TimeTypeDef currentTime={0};
//static RTC_DateTypeDef currentDate={0};

__IO uint32_t
wkup_status = 0;
__IO uint32_t
rtc_status = 0;
static __IO uint32_t
seconds = 0;

eNetType curNetType = NET_EtherNet;

stLedStatus ledStatus = {0};

stPowerVoltage powerVoltage = {0};

uint32_t beforeRak = 0, afterRak = 0;

stFactoryTestStatus testStatus = {0};
uAnchorStatus anchorStatus = {0};

uint8_t debugBuffer[DEBUG_BUF_LEN] = {0};
int debugLen = 0;

uint8_t TEA_KEY[TEA_KEY_LEN] = { 'S', 'c', 'e', 'n', 'A', 'u', 't', 'o', '1', '2', '3', '4', '!', '@', '#', '$' };

#if (WIFITEST == 1)
uint32_t wificount = 0;
const char* teststr = "0123456789\r\n";
//const char* teststr = "ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210_0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\r\n";
#endif

/* Private function prototypes -----------------------------------------------*/
void ReadConfigFromEEROM(void);
int SaveRunStatus(uint8_t pos,uint8_t val);
int SaveRunStatus2(uint8_t pos,uint8_t val);
uint8_t GetRunStatus(uint8_t pos);
void WriteDefaultConfigToEEROM(void);
uint32_t ClearResetFlags(void);
void GetSystemClock(void);
void Lndicator_LampRun(void);
void InitNetwork(void);
void NetworkRun(uint32_t);
void InitializeLEDStatus(void);
void UpdateLedStatus(void);

uint8_t UpdatePowerShortValue(uint16_t adcvalue);

extern void ReportRangeResult(int rx);
extern void ReportRange(uint32_t flag);
extern unsigned int ReceivedReply;

void KeyScan(void);
void WaitAdcStart(void);
void GetAdcResult(void);

/* Main function -------------------------------------------------------------*/

/**
  * @brief  Main program
  * @param  None
  * @retval None
  */
int main(void)
{
   
    int n;
    int blDelayTmFix = BOOTLOADER_DELAY_TIME;
    uint32_t bl_startTime;
    uint32_t rcv_startTime;
    uint32_t rcv_endTime;
#if defined(STM32F405_BOOTLOADER)
    uint32_t bl_currentTime, bl_status;
#else
    uint32_t bkValue = 0;
    int flagUWBRcv = 0;
    uint8_t swUWBLED = 0;
#endif

    /* STM32F4xx HAL library initialization:
       - Configure the Flash prefetch, instruction and Data caches
       - Configure the Systick to generate an interrupt each 1 msec
       - Set NVIC Group Priority to 4
       - Global MSP (MCU Support Package) initialization
    */
    HAL_Init();

    /* Configure the system clock to 160 MHz */
    BSP_SystemClock_Config();
    SetBORLevel();
    SetFlashWriteProtect();

    /* Configure LEDs */
    BSP_LED_Init(LED_UWB);
    BSP_LED_Init(LED_COM);
    BSP_LED_Init(LED_BAT);
    BSP_LED_Init(LED_RUN);

    BSP_LED_On(LED_UWB);
    BSP_LED_On(LED_COM);
    BSP_LED_On(LED_BAT);
    BSP_LED_On(LED_RUN);
    BSP_DDLED_Init();
    BSP_DDLED_Power_0n();
    BSP_DDLED_UWB_On();

    BSP_BAT_Init();

    BSP_LED_Off(LED_UWB);

    DebugUsart_Init();
#if defined(STM32F405_BOOTLOADER)
    sprintf((char*)debugBuffer, "************** Bootloader start %8x *************\r\n\r\n", BSP_BL_VERSION());
#else
    sprintf((char *) debugBuffer, "************** Anchor start %8x *************\r\n\r\n", BSP_APP_VERSION());
#endif
    DebugMessage(debugBuffer);

#if 1
    ClearResetFlags();
    GetSystemClock();
#endif
    
    BSP_LED_Off(LED_COM);

#if (I2C_EEROM_MODULE == 1) || (I2C_RTC_MODULE == 1)
#if defined(HAL_I2C_MODULE_ENABLED)
    BSP_I2C_Init();
    BSP_EEROM_EXT_Init();
    BSP_RTC_EXT_Init();
#else
    I2C_Device_Init();
#endif
#endif

#if (I2C_EEROM_MODULE == 1)
    bl_startTime = HAL_GetTick();
    Delay_ms(3000);
    
    if(isSettingEmpty())
    {
        WriteDefaultConfigToEEROM();
        for (n = 0; n < 5; n++)
        {
            BSP_DDLED_Power_0n();
            BSP_DDLED_UWB_On();
            Delay_ms(200);
            BSP_DDLED_Power_Off();
            BSP_DDLED_UWB_Off();
            Delay_ms(200);
        }

        BSP_DDLED_Power_0n();
        BSP_DDLED_UWB_On();
    }
    else
    {
        ReadConfigFromEEROM();
        if (isSettingError())
        {
            for (n = 0; n < 5; n++)
            {
                BSP_DDLED_Power_0n();
                BSP_DDLED_UWB_Off();
                Delay_ms(200);
                BSP_DDLED_Power_Off();
                BSP_DDLED_UWB_On();
                Delay_ms(200);
            }
            BSP_DDLED_Power_0n();
            BSP_DDLED_UWB_On();

            WriteDefaultConfigToEEROM();
        }
    }

    if(isRunStatusEmpty())
    {
        WriteDefaultRunStatusToEEROM();
    }
    else if (isRunStatusHold())
    {
#ifdef STM32F405_BOOTLOADER
        SetBootloaderStatus(1);
#endif
        SaveRunStatus(0, 0);
		SaveRunStatus2(0, 0);
    }

    Delay_ms((dwsConfig.address % 10) * 100);
    blDelayTmFix += (dwsConfig.address % 10) * 200;
#endif

#ifndef STM32F405_BOOTLOADER
    BSP_RTC_Init();
#if (I2C_RTC_MODULE == 1)
    TestDevice();

    Init8025();
    bkValue = HAL_RTCEx_BKUPRead(&hRTC_Handle,RTC_BKP_DR0);
    if(0xa5a5 != bkValue & 0x0000ffff)
    {
        HAL_RTC_SetDate(&hRTC_Handle, (RTC_DateTypeDef*)&factoryDate, RTC_FORMAT_BIN);
        HAL_RTC_SetTime(&hRTC_Handle, (RTC_TimeTypeDef*)&factoryTime, RTC_FORMAT_BIN);
        HAL_RTCEx_BKUPWrite(&hRTC_Handle, RTC_BKP_DR0, (bkValue & 0xffff0000) | 0xa5a5);

        stDateTime.year     = factoryDate.Year;
        stDateTime.month    = factoryDate.Month;
        stDateTime.day      = factoryDate.Year;
        stDateTime.hour     = factoryTime.Hours;
        stDateTime.minute   = factoryTime.Minutes;
        stDateTime.second   = factoryTime.Seconds;
        RtcSetDateTime(&stDateTime);

        BSP_WDG_Clear();
    }

    UpdateDateTime();
#endif
    wkup_status = 0;
#endif

    InitNetwork();

    BSP_ADC_Init();
    BSP_ADC_START_Convert(VBAT_CHANNEL);

    BSP_LED_Off(LED_RUN);

#ifndef STM32F405_BOOTLOADER
    BSP_DWM_Init();//last one to be initiallized
    port_DisableEXT_IRQ(); //disable ScenSor IRQ until we configure the device

    setup_DW1000RSTnPin(0);
    write_DW1000RstnPin(0);//RST low
    sprintf((char *) debugBuffer, "DW addr: %d; Encrypt:%d, PRF:%dM, CH:%d \r\n",
            dwsConfig.address, dwsConfig.signal.encrypt, dwsConfig.signal.prfMode ? 16 : 64, 
            dwsConfig.signal.channel);
    DebugMessage(debugBuffer);
    DebugRun();
    Delay_ms(5);
    write_DW1000RstnPin(1);//RST high

    n = inittestapplication(dwsConfig);
    if (n < 0)
    {
        
    }
    
    port_EnableEXT_IRQ(); //enable ScenSor IRQ before starting
    sprintf((char *) debugBuffer, "DW init=0x%08x\r\n\r\n", n);
    DebugMessage(debugBuffer);
#endif

    InitializeLEDStatus();

    bl_startTime = HAL_GetTick();
    sprintf((char *) debugBuffer, "start...%d\r\n\r\n", bl_startTime);
    DebugMessage(debugBuffer);

//#if defined(WATCHDOG_ENABLED)
#if 0
    BSP_IWDG_Init();
#endif
//////    BSP_WDG_Clear();//���Ź�������ʱע��

#ifndef STM32F405_BOOTLOADER
    rcv_startTime = HAL_GetTick();
    rcv_endTime = rcv_startTime;
#endif

    while (1)
    {
        //while(1){
#ifndef STM32F405_BOOTLOADER
        instance_run();
        n = instNewRange();//read out range value from struct, and clear the rang value;

    //if there is a new ranging report received or a new range has been calculated, then prepare data
    //to output over USB - Virtual COM port, and update the LCD
        if (n != TOF_REPORT_NUL)
        {
#ifndef STM32F405_BOOTLOADER
            rcv_startTime = HAL_GetTick();
#endif
            BSP_LED_Toggle(LED_UWB);
            ledStatus.ledUwbStatus = LED_TOGGLE;

            anchorStatus.status.range = 1;

            ReportRangePeriodically(1);
            flagUWBRcv = 2;
        } //if new range present
        else
        {
            anchorStatus.status.range = 0;
        }
#endif

        if (keyScanTimer.flag)
        {
            ClearTimer((pTickTimer) & keyScanTimer);

            KeyScan();

            powerVoltage.status = BSP_BAT_UpdateStatus();
            if (powerVoltage.statusOld != powerVoltage.status)
            {
                powerVoltage.statusOld = powerVoltage.status;
                powerVoltage.dcToggleFlag++;
                if (powerVoltage.dcToggleFlag > 10)
                {
                    powerVoltage.dcToggleFlag = 10;
                }
            }

            UpdateLedStatus();
        }

        if (recordTimer.flag)
        {
            ClearTimer((pTickTimer)(&recordTimer));

            ledStatus.ledRunStatus = LED_TOGGLE;
            anchorStatus.status.run++;

#ifdef STM32F405_BOOTLOADER
            ReportResetSignPeriodically();
#else
            ReportRangePeriodically(0);//
#endif

            WaitAdcStart();

#ifndef STM32F405_BOOTLOADER
//////            BSP_WDG_Clear();//���Ź�������ʱע��
            if (flagUWBRcv)
            {
                if (swUWBLED)
                {
                    swUWBLED = 0;
                    BSP_DDLED_UWB_Off();
                }
                else
                {
                    swUWBLED = 1;
                    BSP_DDLED_UWB_On();
                }
            }
            else
            {
                BSP_DDLED_UWB_Off();
            }
            
#endif            
        }

        if (secondTimer.flag)
        {
            ClearTimer((pTickTimer)(&secondTimer));
#ifndef STM32F405_BOOTLOADER             
             flagUWBRcv--;
            if (flagUWBRcv < 0)
            {
                flagUWBRcv = 0;
            }
#endif             
            if (powerVoltage.dcToggleFlag > 0)
            {
                powerVoltage.dcToggleFlag--;
            }

            ClearTimeSettingCommand();//in fast time flag

            instRangeSlotUpdate();
        }

        if (halfMntTimer.flag)
        {
            ClearTimer((pTickTimer)(&halfMntTimer));       
            // sprintf((char *) debugBuffer, "ADC V=%d\r\n", powerVoltage.batteryVoltage);
            // DebugMessage(debugBuffer);
        }

        GetAdcResult();

        if (rtc_status == 2)
        {
            rtc_status = 0;
#if (I2C_RTC_MODULE == 1)
            UpdateDateTime();
#endif
        }

        //Lndicator_LampRun();
        NetworkRun(HAL_GetTick());

        ProtocalRun();

        DebugRun();

#ifdef STM32F405_BOOTLOADER
        bl_currentTime = HAL_GetTick();
        bl_status = GetBootloaderStatus();
        if(((Inactive == bl_status) && (bl_currentTime - bl_startTime > blDelayTmFix))
           || (GoApp == bl_status))
        {
            BSP_LED_Off(LED_UWB);
            BSP_LED_Off(LED_COM);
            BSP_LED_Off(LED_BAT);
            BSP_LED_Off(LED_RUN);
            Delay_ms(500);
            BSP_Jumpto_APP();
        }
#endif

#ifndef STM32F405_BOOTLOADER
        rcv_endTime = HAL_GetTick();
        if (rcv_endTime - rcv_startTime > RCV_TOF_MAXDELAY)
        {
            BSP_Reboot();
        }
#endif
        //BSP_WDG_Clear();
    }
}

void KeyScan(void) {
    if (KEY_PRESSED == BSP_Button_GetState(BUTTON_KEY1))
    {
        testStatus.keyStatus |= (1 << BUTTON_KEY1);
    }
    else
    {
        testStatus.keyStatus &= (1 << BUTTON_KEY1);
    }

    if (KEY_PRESSED == BSP_Button_GetState(BUTTON_KEY2))
    {
        testStatus.keyStatus |= (1 << BUTTON_KEY2);
    }
    else
    {
        testStatus.keyStatus &= ~(1 << BUTTON_KEY2);
    }
}

void WaitAdcStart(void) {
    if (BSP_AdcStatus.status == ADC_WAIT && ++BSP_AdcStatus.count > BAT_POWER_PEROID)
    {
        BSP_AdcStatus.status = ADC_IDLE;
        BSP_AdcStatus.count = 0;
        BSP_AdcStatus.limit = BSP_ADC_PEROID;
    }
}

void GetAdcResult(void) {
    if (BSP_AdcStatus.status < ADC_WAIT)
    {
        if (ADC_COMPLETE == BSP_AdcStatus.status)
        {
            //beforeRak = HAL_GetTick();
            if (BSP_AdcStatus.currentChannel == VBAT_CHANNEL)
            {
                //n = sprintf((char*)debugBuffer, "VBAT_CHANNEL: %d\r\n", BSP_AdcStatus.currentValue);
                powerVoltage.batteryVoltage = BSP_AdcStatus.currentValue;
                BSP_ADC_START_Convert(V5IN_CHANNEL);

                powerVoltage.power = UpdatePowerShortValue(powerVoltage.batteryVoltage);
            }
            else
            {
                //n = sprintf((char*)debugBuffer, "V5IN_CHANNEL: %d\r\n", BSP_AdcStatus.currentValue);
                powerVoltage.dcInputVoltage = BSP_AdcStatus.currentValue;
                BSP_AdcStatus.status = ADC_WAIT;
            }
        }
        else if (ADC_IDLE == BSP_AdcStatus.status)//Start
        {
            BSP_ADC_START_Convert(VBAT_CHANNEL);
        }
        else if (ADC_ERROR == BSP_AdcStatus.status)
        {
            BSP_ADC_Init();

            BSP_AdcStatus.status = ADC_WAIT;
        }
    }
}

/* Private functions ---------------------------------------------------------*/

/**
  *            @arg @ref RCC_FLAG_BORRST  BOR reset
  *            @arg @ref RCC_FLAG_OBLRST  OBLRST reset
  *            @arg @ref RCC_FLAG_PINRST  Pin reset
  *            @arg @ref RCC_FLAG_FWRST  FIREWALL reset
  *            @arg @ref RCC_FLAG_RMVF  Remove reset Flag
  *            @arg @ref RCC_FLAG_SFTRST  Software reset
  *            @arg @ref RCC_FLAG_IWDGRST  Independent Watchdog reset
  *            @arg @ref RCC_FLAG_WWDGRST  Window Watchdog reset
  *            @arg @ref RCC_FLAG_LPWRRST  Low Power reset
****/
uint32_t ClearResetFlags(void)
{
    uint32_t retval = 0;
    if (__HAL_RCC_GET_FLAG(RCC_FLAG_BORRST))
    {
        ReportString("BORRST\r\n");
        retval |= RESET_BOR;
    }
#if 0
    if(__HAL_RCC_GET_FLAG(RCC_FLAG_OBLRST))
    {
        ReportString("Option Byte Loader reset\r\n");
        retval |= RESET_OBL;
    }
#endif
    if (__HAL_RCC_GET_FLAG(RCC_FLAG_PINRST))
    {
        ReportString("PINRST\r\n");
        retval |= RESET_PIN;
    }
#if 0
    if(__HAL_RCC_GET_FLAG(RCC_FLAG_FWRST))
    {
        ReportString("FimmwareRST\r\n");
        retval |= RESET_FW;
    }
    if(__HAL_RCC_GET_FLAG(RCC_FLAG_RMVF))
    {
        ReportString("RemoveRST\r\n");
        retval |= RESET_RMV;
    }
#endif
    if (__HAL_RCC_GET_FLAG(RCC_FLAG_SFTRST))
    {
        ReportString("SFTRST\r\n");
        retval |= RESET_SFT;
    }
    if (__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST))
    {
        ReportString("IWDGRST\r\n");
        retval |= RESET_IWDG;
    }
    if (__HAL_RCC_GET_FLAG(RCC_FLAG_WWDGRST))
    {
        ReportString("WWDGRST\r\n");
        retval |= RESET_WWDG;
    }
    if (__HAL_RCC_GET_FLAG(RCC_FLAG_LPWRRST))
    {
        ReportString("LPWRRST\r\n");
        retval |= RESET_LPWR;
    }
    __HAL_RCC_CLEAR_RESET_FLAGS();
    return retval;
}

void GetSystemClock(void) {
    uint32_t clock = HAL_RCC_GetSysClockFreq();
    int32_t rx = sprintf((char *) debugBuffer, "SysClock: %d\r\n", clock);
    ReportMessage(debugBuffer, rx);
    clock = HAL_RCC_GetHCLKFreq();
    rx = sprintf((char *) debugBuffer, "HCLK: %d\r\n", clock);
    ReportMessage(debugBuffer, rx);
    clock = HAL_RCC_GetPCLK1Freq();
    rx = sprintf((char *) debugBuffer, "PCLK1: %d\r\n", clock);
    ReportMessage(debugBuffer, rx);
    clock = HAL_RCC_GetPCLK2Freq();
    rx = sprintf((char *) debugBuffer, "PCLK2: %d\r\n", clock);
    ReportMessage(debugBuffer, rx);
}


void InitNetwork(void) {
    if (ETHNET_CLOSED == ethConfig.state)
    {
        ethConfig.state = ETHNET_UDP_CLIENT;
    }
    //wifiConfig.type = WIFITYPE_NONE;
#if W5500_MODULE == 1
    BSP_W5500_HW_Init();
    //Ethernet_SetDefault();//before readEEROM
    Init_server();
    curNetType = NET_EtherNet;
#endif

    if (wifiConfig.type != WIFITYPE_NONE)
    {
        sprintf((char *) debugBuffer, "WIFI svr: %s, %s; net: %s, %s, %s\r\nAP: %s,%s,%d\r\n\r\n",
                wifiServer.ip, wifiServer.port,
                wifiNetwork.ip, wifiNetwork.subnetmask, wifiNetwork.gateway,
                wifiConfig.name, wifiConfig.password, wifiConfig.type);
        DebugMessage(debugBuffer);
#if ESP8266_MODULE == 1
        Wifi_USART_Init(WIFI_LOWEST_BAUDRATE);
        curNetType = NET_Wifi;
#endif

#if RAK411_MODULE == 1
        BSP_RAK_SPI_Init();
        curNetType = NET_Wifi;
#endif
    }
}

void Lndicator_LampRun(void) {
    if (ReceivedReply>0)
    {
        BSP_DDLED_UWB_On();
    }
    else
    {
        BSP_DDLED_UWB_Off();
    }
}


void NetworkRun(uint32_t tick) 
{
    bool bEth = false;
    if (ethConfig.state != ETHNET_CLOSED)
    {
        bEth = true;
    }
    else if (wifiConfig.type == WIFITYPE_NONE)
    {
        bEth = true;
    }
    

    if (bEth)
    {
#if W5500_MODULE == 1
        //Run_Server();
        Run_Client(tick);
#endif
    }
    
    if (wifiConfig.type != WIFITYPE_NONE)
    {
#if ESP8266_MODULE == 1
        TcpClientWifiRun();
#endif

#if RAK411_MODULE == 1
        /*beforeRak = HAL_GetTick();
        TCP_Client_Run();
        afterRak = HAL_GetTick();
        if(afterRak-beforeRak >3)
        {
            n = sprintf((char*)debugBuffer,"RAK time: %d %d\r\n", beforeRak, afterRak);
            ReportMessage(debugBuffer, n);
        }*/
        TCP_Client_Run();
#endif
    }

    if (bEth)
    {
#if W5500_MODULE == 1
    Run_ClientDbg(tick);
#endif  
    }
}

/*
 *
 */

void InitializeLEDStatus(void)
{
    BSP_LED_Off(LED_UWB);
    BSP_LED_Off(LED_RUN);
    BSP_LED_Off(LED_COM);
    BSP_LED_Off(LED_BAT);

    ledStatus.ledBatLimit = 2;
    ledStatus.ledBatCount = 0;
    ledStatus.ledRunLimit = 10;
    ledStatus.ledRunCount = 0;
    ledStatus.ledComLimit = 0;
    ledStatus.ledComCount = 0;
    ledStatus.ledUwbLimit = 0;
    ledStatus.ledUwbCount = 0;
}

void InformRunLed(int32_t status)
{
    if (status >= 0)
    {
        ledStatus.ledComStatus = LED_TOGGLE;
        anchorStatus.status.communication = 1;
    }
    else
    {
        ledStatus.ledComStatus = LED_OFF;
        anchorStatus.status.communication = 0;
    }
}

void LEDAction(Led_TypeDef led, eLedPattern pattern)
{
    switch (pattern)
    {
        case LED_ON:
            BSP_LED_On(led);
            break;
        case LED_TOGGLE:
            BSP_LED_Toggle(led);
            break;
        default:
            BSP_LED_Off(led);
            break;
    }
}

void UpdateLedStatus(void)
{
    if (testStatus.testMode)
    {
        int n = 0;
        for (n = 0; n < LED_NUM; n++)
        {
            if ((0x01 << n) & testStatus.ledMask)
            {
                if ((0x01 << n) & testStatus.ledCommand)
                {
                    LEDAction(n, LED_ON);
                }
                else
                {
                    LEDAction(n, LED_OFF);
                }
            }
        }
    }
    else
    {
        //RUN
        if (ledStatus.ledRunStatus != LED_TOGGLE)
        {
            LEDAction(LED_RUN, ledStatus.ledRunStatus);
        }
        else
        {
            if (++ledStatus.ledRunCount > ledStatus.ledRunLimit)
            {
                LEDAction(LED_RUN, LED_TOGGLE);
                ledStatus.ledRunCount = 0;
            }
        }
        //BAT
        switch (powerVoltage.status)
        {
            case BAT_CHARGING:
                ledStatus.ledBatStatus = LED_TOGGLE;
                break;
            case BAT_FULL:
                ledStatus.ledBatStatus = LED_ON;
                break;
            case BAT_NODCIN:
                ledStatus.ledBatStatus = LED_OFF;
                break;
            default:
                ledStatus.ledBatStatus = LED_OFF;
                break;
        }
        if (ledStatus.ledBatStatus != LED_TOGGLE)
        {
            LEDAction(LED_BAT, ledStatus.ledBatStatus);
        }
        else
        {
            if (++ledStatus.ledBatCount > ledStatus.ledBatLimit)
            {
                LEDAction(LED_BAT, LED_TOGGLE);
                ledStatus.ledBatCount = 0;
            }
        }
        //COM
        if (ledStatus.ledComStatus != LED_TOGGLE)
        {
            LEDAction(LED_COM, ledStatus.ledComStatus);
        }
        else
        {
            if (++ledStatus.ledComCount > ledStatus.ledComLimit)
            {
                LEDAction(LED_COM, LED_TOGGLE);
                ledStatus.ledComCount = 0;
            }
        }
        //UWB
        if (ledStatus.ledUwbStatus != LED_TOGGLE)
        {
            LEDAction(LED_UWB, ledStatus.ledUwbStatus);
        }
        else
        {
            if (++ledStatus.ledUwbCount > ledStatus.ledUwbLimit)
            {
                LEDAction(LED_UWB, LED_TOGGLE);
                ledStatus.ledUwbCount = 0;
            }
        }
    }
}


const uint16_t BSP_MinPowerValue = 582; //3.7V
const uint16_t BSP_MaxPowerValue = 620; //4.0V
const uint16_t MaskPowerValue = 0x05;

uint8_t UpdatePowerShortValue(uint16_t adcvalue)
{
    uint8_t power;
    if (adcvalue <= BSP_MinPowerValue)
    {
        power = 1;
    }
    else if (adcvalue >= BSP_MaxPowerValue)
    {
        power = MaskPowerValue * 2;
    }
    else
    {
        uint32_t value = (adcvalue - BSP_MinPowerValue) * (MaskPowerValue);
        power = (uint8_t)((value * 1.0 / (BSP_MaxPowerValue - BSP_MinPowerValue)) + 1) * 2;
    }
    return power;
}

/**
  * @brief EXTI line detection callbacks
  * @param GPIO_Pin: Specifies the pins connected EXTI line
  * @retval None
  */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    if (GPIO_Pin == W5500_EXTI_IRQ_PIN)
    {
        W5500_Interrupt = 1;
        W5500_Interrupt_Process();
    }
    else if (BSP_RTC_INTERRUPT_PIN == GPIO_Pin)
    {
        uint8_t temp = 0;
        Get8025(RTC8025T_Flag, (uint8_t *) & temp, 1);
        rtc_status = 0;
        Set8025(RTC8025T_Flag, (uint8_t *) & rtc_status, 1);
        if (temp & RX8025T_FLAG_TF)
        {
            rtc_status = 1;
        }
        if (temp & RX8025T_FLAG_UF)
        {
            rtc_status = 2;
        }
        if (temp & RX8025T_FLAG_AF)
        {
            rtc_status = 3;
        }
        if (temp & RX8025T_FLAG_VLF)
        {
            rtc_status = 4;
        }
        if (temp & RX8025T_FLAG_VDET)
        {
            rtc_status = 5;
        }
    }
    /*else if(GPIO_Pin == KEYUP_BUTTON_PIN)
    {

    }*/
}

#if 0
void HAL_RTCEx_WakeUpTimerEventCallback(RTC_HandleTypeDef *hrtc)
#else

void RTC_WakeUpEventCallback(void)
#endif
{
    //uint32_t ticks;
    seconds++;
    //ticks = HAL_GetTick();
    /*ticks = seconds & 1;
    if(ticks)
    {
        wkup_status = 1;
    }*/
    wkup_status = 1;
}


#ifdef  USE_FULL_ASSERT

/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t* file, uint32_t line)
{
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

  /* Infinite loop */
    while (1)
    {
    }
}
#endif

#if (RAK411_MODULE == 0 && ESP8266_MODULE == 0)

int SendMessageWifi(uint8_t *buf, int len) {
    return 0;
}

#endif

void EncryptTEA(uint8_t* plainText, int startIndex, int bufLen)
{
    int i;
    uint32_t* k = (uint32_t*)TEA_KEY;

    int loop = 0;
    for ( loop=0; loop+8<=bufLen; loop+=8 )
    {
        uint32_t* v = (uint32_t*)&plainText[startIndex + loop];
    
        uint32_t y = v[0], z = v[1], sum = 0;            
	    uint32_t a = k[0],b = k[1],c = k[2],d = k[3];  
	
        for (i = 0;i < TEA_LOOP;i++) 
        {                        
            sum += TEA_DELTA;
            y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
            z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
        }
        v[0] = y;
        v[1] = z;
    }
}


void DecryptTEA(uint8_t* cipherText, int startIndex, int bufLen)
{
    int i;
    uint32_t* k = (uint32_t*)TEA_KEY;

    int loop = 0;
    for ( loop=0; loop+8<=bufLen; loop+=8)
    {
        uint32_t* v = (uint32_t*)&cipherText[startIndex + loop];

        uint32_t y = v[0], z = v[1], sum = TEA_DELTA_FIN;         
        uint32_t a = k[0],b = k[1],c = k[2],d = k[3];    
        
        for ( i=0; i<TEA_LOOP; i++ ) 
        {                         
            z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
            y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
            sum -= TEA_DELTA;                     
        }
        v[0] = y;
        v[1] = z;
    }   
}

/********************************* END OF FILE *********************************/