/*******************************************************************************
 * File Name         : App.c
 * Description       :
 * Created on        : 2021Äê5ÔÂ07ÈÕ
 * Author            : www.hido-studio.com
 *******************************************************************************/

/*******************************************************************************
 *                              Include Files                                  *
 *******************************************************************************/
#include <string.h>
#include <math.h>
#include <stdio.h>
#include "App.h"
#include "stm32l0xx_hal.h"
#include "HIDO_Timer.h"
#include "Module.h"
#include "GPS.h"
#include "main.h"
#include "DBG.h"
#include "global_param.h"
#include "AIR780EDriver.h"
#include "Uart.h"
#include "Internet.h"
#include "HIDO_ATLite.h"
#include "UDPClient.h"
#include "global_param.h"
#include "SPIFlash.h"
#include "App.h"
#include "dw_driver.h"
#include "deca_device_api.h"
#include "dw_app.h"
#include "Lora.h"
#include "radio.h"
#include "DBG.h"
#include "WS2812.h"
#include "dw_mbx_tag.h"
/*******************************************************************************
 *                                  Macro                                      *
 *******************************************************************************/

/*******************************************************************************
 *                             Type Definition                                 *
 *******************************************************************************/

/*******************************************************************************
 *                             Local Variable                                  *
 *******************************************************************************/
static HIDO_BOOL l_bDismantle = HIDO_FALSE;
static HIDO_BOOL l_bCancelAlarm = HIDO_FALSE;
static HIDO_UINT32 l_u32DismantleAlarmTick = 0;

static HIDO_BOOL l_bCharge = HIDO_FALSE;
static HIDO_BOOL l_u32CancelChargeReport = HIDO_FALSE;
static HIDO_UINT32 l_u32ChargeTick = 0;

static HIDO_UINT32 l_u32LocationTick = 0;
extern ST_GPS l_stGPS;
extern uint32_t uwbled,gpsled,loraled,powerled;
uint8_t uwb_send[200]={0x55,0xaa};
void Uwb_Zubao_Poll();
extern IWDG_HandleTypeDef hiwdg;
/*******************************************************************************
 *                        Local Function Declaration                           *
 *******************************************************************************/

/*******************************************************************************
 *                             Local Function                                  *
 *******************************************************************************/
char senddata[100];
void HexToAsciiSendUDP(uint8_t* data,u8 len)
{
   
	u8 i,temp;
	
	for(i=0;i<len;i++)
	{
		temp = *data++;
		sprintf(&senddata[2*i],"%x",temp>>4);
		sprintf(&senddata[2*i+1],"%x",temp&0xf);
	}
    senddata[2*len] = 0x0d;
    senddata[2*len+1] = 0x0a;
//    if(DBG_GetMode() == DBG_MODE_CFG)
//    Uart_Send(0, (HIDO_UINT8 *) senddata, 2*len+2);
	UDPClient_Uploadhex((uint8_t*)senddata,2*len+2);
}
extern uint8_t bat_percent;
uint8_t LBS_data[100]="$GNGGA,LBS,";
extern uint8_t fangchai_flag;
static HIDO_VOID LBSLocationCallback(ST_LBSLocation *_pstLBSLocation, HIDO_VOID *_pArg)
{  char LBS_dLon[16],LBS_dLat[16];
    // Éϱ¨LBSλÖÃ
    snprintf(LBS_dLon,sizeof(LBS_dLon),"%.8lf",_pstLBSLocation->m_dLon);
    snprintf(LBS_dLat,sizeof(LBS_dLat),"%.8lf",_pstLBSLocation->m_dLat);
    memcpy(&LBS_data[11],&LBS_dLon,12);
    LBS_data[23]=0x2C;
    memcpy(&LBS_data[24],&LBS_dLat,12);
    
    HIDO_UINT32 u32Len = HIDO_UtilSnprintf((HIDO_CHAR *)LBS_data, sizeof(LBS_data), "%s,,,,,0,00,00.0,,,,,,*00,%X,%02x,%x,%d,%d,%d%\r\n",
        LBS_data,g_com_map[DEV_ID], bat_percent,0,0,0,fangchai_flag);
    Socket_Send(0, (HIDO_UINT8 *)LBS_data, u32Len);
//    HexToAsciiSendUDP(LBS_data,u32Len);
//    UDPClient_UploadGPS((char*)LBS_data);
}
extern UART_HandleTypeDef huart2;
uint8_t chongdian_only_one_flag;
void Stop_chongdian_Mode_Poll()
{
    if(chongdian_only_one_flag==0)
    {
        chongdian_only_one_flag=1;
        GPS_PowerOff();
        HAL_UART_DeInit(&huart2);
        GPIO_InitTypeDef GPIO_InitStruct = {0};//
        GPIO_InitStruct.Pin = GPIO_PIN_4;
        GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
        HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);    
//        Radio.Sleep();
        dwt_configuresleep(DWT_PRESRV_SLEEP | DWT_CONFIG, DWT_WAKE_CS | DWT_WAKE_WK| DWT_SLP_EN);
        dwt_entersleep();
    }
}
uint8_t only_one_flag;
void Stop_Mode_Poll()
{
    if(only_one_flag==0)
    {
        only_one_flag=1;
        GPS_PowerOff();
        HAL_UART_DeInit(&huart2);
        GPIO_InitTypeDef GPIO_InitStruct = {0};//
        GPIO_InitStruct.Pin = GPIO_PIN_4;
        GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
        HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);    
//        Radio.Sleep();
        dwt_configuresleep(DWT_PRESRV_SLEEP | DWT_CONFIG, DWT_WAKE_CS | DWT_WAKE_WK| DWT_SLP_EN);
        dwt_entersleep();
    }
}
extern uint16_t nomove_count;
extern uint8_t bat_percent;
extern uint8_t chargedbg_flag;
u8 power_state = 0,chargeon = 0;
uint8_t chongman_flag;
extern uint8_t bat_percent;
extern uint16_t heart_time;
extern uint8_t nomove_flag;
uint16_t qidong_time;
#define QIDONG_TIME 60  //1·ÖÖÓ
#define DENGDAI_TIME 30//90s
//#define STOP_TIME 600-DENGDAI_TIME-QIDONG_TIME//600s 10·ÖÖÓ
#define YUNDONG_UWB_TIME 1
#define YUNDONG_GPS4G_TIME 100
uint8_t GPS_data[200];
uint8_t GPS_successful_flag;
uint8_t fangchai_flag;
uint8_t fangchai_state;
extern uint16_t fangchai_time;
extern uint8_t taglist_num;
uint16_t tagseq;
extern uint16_t tagid_list[ANC_MAX_NUM],tagdist_list[ANC_MAX_NUM];
extern uint8_t tagbat_list[ANC_MAX_NUM];
extern TIM_HandleTypeDef htim3;
extern uint8_t beep_state;
//extern uint8_t air780_state;
extern uint16_t sleep_time;
uint8_t zuihoufasong_falg;
extern uint8_t receive1_gotosleep_flag;
extern uint8_t receive2_gotosleep_flag;
extern uint8_t receive3_gotosleep_flag;
extern uint8_t chongdian_time;
extern uint8_t input5vtime;
extern uint16_t work_time;
uint8_t imu_enable;
extern uint32_t dev_id;
void Program_Init(void)
{
    float temp;
    uint16_t temp2;
    uint16_t i;
  
    parameter_init();
//    hardware_version = STMFLASH_ReadHalfWord(FLASH_HARDWARE_VERSION_MAP);
//    hardware_pici = STMFLASH_ReadHalfWord(FLASH_HARDWARE_VERSION_MAP + 2);
//    hardware_type = STMFLASH_ReadHalfWord(FLASH_HARDWARE_VERSION_MAP + 4);
    //deca_sleep(1000);

    g_com_map[GROUP_ID]=3;
	g_com_map[VERSION] = (3<<8)|1;

    if (g_com_map[COM_INTERVAL] <50)
    {
        g_com_map[COM_INTERVAL] = 100;
    }
    if (g_com_map[COM_INTERVAL] >1000)
    {
        g_com_map[COM_INTERVAL] = 1000;
    }
    if (g_com_map[IMU_THRES] > 10)
    {
        g_com_map[IMU_THRES] = 2;
    }
    if (g_com_map[POWERx] > MAX_RFPOWER)
    {
        g_com_map[POWERx] = MAX_RFPOWER;
    }
    if (g_com_map[POWERx] < 0)
    {
        g_com_map[POWERx] = 0;
    }
    if(g_com_map[STATIONARY_TIME] == 0xffff)
    {
        g_com_map[STATIONARY_TIME] = 10;
    }
    if(g_com_map[NEARBASE_ID2]>10000)
    {
        g_com_map[NEARBASE_ID2] = 0;
    }
    if(g_com_map[GPS_HZ]<180||g_com_map[GPS_HZ]>3600)
    {
      if(g_com_map[GPS_HZ]==1) 
      {g_com_map[GPS_HZ]=1;}
      else          
      {g_com_map[GPS_HZ]=600;}
    }
    g_com_map[GPS_HZ]=1;
    if(g_com_map[CHAICHUGPS_HZ]<180||g_com_map[CHAICHUGPS_HZ]>3600)
    {
      {g_com_map[CHAICHUGPS_HZ]=600;}
    }
    g_com_map[CHAICHUGPS_HZ]=1800;
    if(g_com_map[NOMOVESLEEP_TIME]>120)
    {
       g_com_map[NOMOVESLEEP_TIME]=120;
    }
//    g_com_map[GPS_HZ]=120;
    imu_enable=g_com_map[IMU_ENABLE];
//    module_power = g_com_map[POWERx];
//    imu_enable = g_com_map[IMU_ENABLE];
//    motor_enable = g_com_map[MOTOR_ENABLE];
    //g_com_map[COM_INTERVAL] = 100; 
    group_id = g_com_map[GROUP_ID];
    dev_id = g_com_map[DEV_ID];

    printf("É豸ID: %x .\r\n",dev_id);
    printf("¹Ì¼þ°æ±¾:  L071ÎÞUWB¹¤¿¨V%d.%d. \r\n",g_com_map[VERSION]>>8,g_com_map[VERSION]&0xff);
    printf("·þÎñÆ÷µØÖ·: %d.%d.%d.%d:%d.\r\n",g_com_map[IP_0],g_com_map[IP_1],g_com_map[IP_2],g_com_map[IP_3],g_com_map[PORT]);
    printf("µ±Ç°Ô˶¯Ê±GPS¹¤×÷¼ä¸ô: %d .\r\n",g_com_map[GPS_HZ]);
//    printf("µ±Ç°±»²ðʱGPS¹¤×÷¼ä¸ô: %d .\r\n",g_com_map[CHAICHUGPS_HZ]);
//       if(g_com_map[RTCMMODE_INDEX] == RTCMMODE_TCP)
//    {        printf("TCP_RTCMģʽ,·þÎñÆ÷µØÖ·: %d.%d.%d.%d:%d.\r\n",g_com_map[TCP_IP_0],g_com_map[TCP_IP_1],g_com_map[TCP_IP_2],g_com_map[TCP_IP_3],g_com_map[TCP_PORT]);
//    }else if(g_com_map[RTCMMODE_INDEX] == RTCMMODE_NTRIP)
//    {
////        sprintf((char *)&g_com_map[NTRIP_HOST_INDEX],"140.143.212.42");
////        g_com_map[NTRIP_PORT_INDEX] = 8005;
////        sprintf((char *)&g_com_map[NTRIP_USERNANME_INDEX],"test006");
////        sprintf((char *)&g_com_map[NTRIP_PASSWORD_INDEX],"hxzk20151102");
////        sprintf((char *)&g_com_map[NTRIP_SOURCENAME_INDEX],"RTCM32_GNSS2");
//        printf("NtripHost:%s.\r\n",(char *)&g_com_map[NTRIP_HOST_INDEX]);
//        printf("NtripPort:%d.\r\n",g_com_map[NTRIP_PORT_INDEX]);
//        printf("NtripUsername:%s.\r\n",(char *)&g_com_map[NTRIP_USERNANME_INDEX]);
//        printf("NtripPassword:%s.\r\n",(char *)&g_com_map[NTRIP_PASSWORD_INDEX]);
//        printf("NtripSourcename:%s.\r\n",(char *)&g_com_map[NTRIP_SOURCENAME_INDEX]);
//    }else if(g_com_map[RTCMMODE_INDEX] == RTCMMODE_NONE)
//    { 
//        printf("µ¥µã¶¨Î»Ä£Ê½Ä£Ê½. \r\n");
//    }
}
void PowerDownDetect(void)
{  
    static HIDO_UINT32 l_u32QXpowerTick = 0;    
    static uint32_t powercount=0;
   
    if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_12))
    {
       if((HIDO_TimerGetTick() - l_u32QXpowerTick) >=1000)
      {
          while(1)
          {
              gpsled=WHITE;
              uwbled=WHITE;
              loraled=WHITE;
              powerled=WHITE;
              
              if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_12)==0)
              {     
                  powercount = 0;
                  l_u32QXpowerTick = HIDO_TimerGetTick();
                  while(1)
                  {
                      
                  if((HIDO_TimerGetTick() - l_u32QXpowerTick) >=100)
                    {
                        HAL_GPIO_WritePin(GPIOA, GPIO_PIN_12, GPIO_PIN_RESET);
                        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);
                        HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
                    }
                }
              }
          }
      }
      }else{
           l_u32QXpowerTick = HIDO_TimerGetTick();
      }
}
void IdleTask(void)
{
  // APLPollTask();
        if(g_com_map[CNT_RESTART]==1)
        {
            g_com_map[CNT_RESTART]=0;
//            printf("%s URTRestart",__debug_info__);
//            URTRestart(); 
            HAL_NVIC_SystemReset();
        }
            if(g_com_map[MAP_SIGN_INDEX]!=0x55AA||g_com_map[COM_INTERVAL]==0)
        {
//            printf("%s URTRestart",__debug_info__);
//            URTRestart();
//              //  SCB->AIRCR = 0X05FA0000|(unsigned int)0x04; //Èí¸´Î»»Øµ½bootloader
            HAL_NVIC_SystemReset();
        }

}

extern uint16_t testlorarecve;
void Uwb_Zubao_Poll()
{       
    uint16_t state_flag;
    u16 uwbchecksum;
    state_flag=fangchai_flag<<4;
        if(taglist_num>8)
        {taglist_num=8;}
        uwb_send[2] = 0x12;//Õý³£Ä£Ê½ 
        uwb_send[3] = 15+5*(taglist_num);//Êý¾Ý¶Î³¤¶È
        memcpy(&uwb_send[4],&dev_id,2);
        uwb_send[6] = tagseq;
        uwb_send[7] = (tagseq++)>>8;
        uwb_send[8] = bat_percent;
        uwb_send[9] = state_flag;
        memcpy(&uwb_send[10],&testlorarecve,2);
        testlorarecve=0;
        uwb_send[12] = 0;
        uwb_send[13] = 0;
        uwb_send[14] = 0;
        uwb_send[15] = 0;
        uwb_send[16] = taglist_num;

        memcpy(&uwb_send[17],&tagid_list,2*taglist_num);
        memcpy(&uwb_send[17+taglist_num*2],&tagdist_list,2*taglist_num);
        memcpy(&uwb_send[17+taglist_num*4],&tagbat_list,taglist_num);
        uwbchecksum = Checksum_u16(&uwb_send[2],15+5*taglist_num);
        memcpy(&uwb_send[17+5*taglist_num],&uwbchecksum,2);
}
u8 only_one_flag;
u16 chongman_time;
u8 bat_percent_old=100;
extern IWDG_HandleTypeDef hiwdg;
u32 adctick = 0;
u8 rtk_state = 1;
void CloseRTK4G(void)
{
      rtk_state = 0;
        
      loraled = LEDOFF;
      HAL_GPIO_WritePin(GPIOA, GPIO_PIN_12, GPIO_PIN_RESET);
}
void OpenRTK4G(void)
{
      loraled = 1;     
      HAL_GPIO_WritePin(GPIOA, GPIO_PIN_12, GPIO_PIN_SET);
}
void PowerLedTask(void)
{ 
    static u8 powerled_state=0;
  
    if(HAL_GPIO_ReadPin(INPUT_5V_GPIO_Port,INPUT_5V_Pin))
    {
        chongman_time=0;
        only_one_flag=0;
        uwbled=0;
        gpsled=0;
        loraled=0;
        powerled=0;
        if(!power_state&&!chargedbg_flag)
        {
            CloseRTK4G();  
            DBG_SetMode(DBG_MODE_CHARGE);
            power_state = 1;
//            Uart_ChongxinInit(UART_ID_DBG);
//            DBG_Init();
//            Shell_Init();
        }
        while(HAL_GPIO_ReadPin(INPUT_5V_GPIO_Port,INPUT_5V_Pin)&&DBG_GetMode() == DBG_MODE_CHARGE)
        {
            nomove_count = 0;
            if(HIDO_TimerGetTick()-adctick>6000)  //10·ÖÖÓ²ÉÑùÒ»´Î µçÁ¿
            {HAL_IWDG_Refresh(&hiwdg);
                chongman_time=chongman_time+6;
                adctick = HIDO_TimerGetTick();
                if( HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_10))
                {
                    bat_percent=Get_Battary();
                }else{
                    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_SET);
                    bat_percent=Get_Battary();
                    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);
                }
            }
            if(bat_percent>=99&&!only_one_flag)
            {
            only_one_flag=1;
            chongman_time=0;
            }
            if(bat_percent>=99&&chongman_time>=1800)
            {
                powerled = GREEN;
            }else{
                powerled = RED;
            }
            delay_ms(100);
            DBG_Poll();
            Internet_Poll();
            Set4LEDColor(0,0,0,powerled);
        }
    }

    chargeon = 0;
    if(power_state)
    {              
        DBG_SetMode(DBG_MODE_SHELL);
        power_state = 0;
        bat_percent_old=100;
        OpenRTK4G();              
    }
    if(!HAL_GPIO_ReadPin(INPUT_5V_GPIO_Port,INPUT_5V_Pin))
    {
     chargedbg_flag = 0;
    
    }
    if(HIDO_TimerGetTick()%1000<10 )
    {
        if(powerled_state==0)
        {
            if(bat_percent>15)
            {
                powerled = BLUE;
            }else{
                 powerled = RED;
            }
            powerled_state = 1;
          //  bat_percent = Battery_GetPercentage();
          Set4LEDColor(uwbled,gpsled,loraled,powerled);   
        }
        }else
        {
            if(powerled_state)
            {
                powerled_state = 0;
                powerled = LEDOFF;
                uwbled = LEDOFF;
                gpsled = LEDOFF;
                loraled = LEDOFF;
                Set4LEDColor(uwbled,gpsled,loraled,powerled);
            }
       
        } 
               
     
    if(HIDO_TimerGetTick()-adctick>6000)  //10·ÖÖÓ²ÉÑùÒ»´Î µçÁ¿
    {
        adctick = HIDO_TimerGetTick();
        if( HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_10))
        {
            bat_percent=Get_Battary();
            if(bat_percent>bat_percent_old)
            {
            bat_percent=bat_percent_old;
            }
            else
            {
            bat_percent_old=bat_percent;
            }
        }else{
            HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_SET);
            bat_percent=Get_Battary();
            HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);
            if(bat_percent>bat_percent_old)
            {
            bat_percent=bat_percent_old;
            }
            else
            {
            bat_percent_old=bat_percent;
            }
        }
    }
}

extern uint32_t main_time;
extern uint16_t testlorarecve;
uint8_t delaysleep_count;
char str[17]= {"AT+IPR=9600;&W\r\n"};
extern  UART_HandleTypeDef huart5;
extern uint8_t stop_flag;
void Main_Poll()
{    
//    if(main_time>10&&only_one_flag==0)
//    {
//        only_one_flag=1;
//      Uart_ReConfigBaudRate(UART_ID_4G,115200);
//    HAL_UART_Transmit(&huart5, str,17,1000);
//    Uart_ReConfigBaudRate(UART_ID_4G,9600);
//    }
    if(stop_flag)
    {
        HAL_IWDG_Refresh(&hiwdg);
        HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON,PWR_STOPENTRY_WFI);
    }
    else
    {
        PowerLedTask();
        DBG_Poll();
        IdleTask();
        GPS_Poll();
        Internet_Poll();
        HIDO_TimerPoll();
        HIDO_ATLitePoll();
        UDPClient_Poll();
        HAL_IWDG_Refresh(&hiwdg); 
        PowerDownDetect();
        Sleep_Panduan_Poll();
    }
//    if(AIR780E_IsIPIdle() && Socket_IsSendQueueEmpty(0))
//    {
//        HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
//    }
//    if(delaysleep_count==0/*&&!gps_need_data_flag*/)
//    if(((IfTCPConnected()&&AIR780E_IsIPIdle()&&Socket_IsSendQueueEmpty(0))/*||((!flag_TCP_reconnectting)&&!IfTCPConnected())*/))
//    {
//         HAL_IWDG_Refresh(&hiwdg); 
//        printf("Òª½øÈëÐÝÃßÁË£¬µ±Ç°Ê±¼ä´Á%d\r\n",HIDO_TimerGetTick());
//    HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
//    }
}

//*/
////ÒÔÉÏÊÇÔ´´úÂ룬±»²ð³ýʱ¼ä½ÓÐԹرÕ4G