修改了串口读取的bug，现在是通过飞线控制的 PCA蓝牙IRQ拉低，修改灯的闪灯逻辑，

zhangbo

2025-05-21 59a4e01d92da432e9736b24c085089cd31963833

 keil/include/main/main.c

@@ -61,8 +61,17 @@
#include "HIDO_ATLite.h"
#include "HIDO_Timer.h"
#include "TCPClient.h"

//#define DEBUG_MODE
#include "mk_spi.h"
//#include "pan_port.h"
#include "mk_timer.h"
//#include "pan_param.h"
//#include "pan_rf.h"
#include "lora_1268.h"
//#include "pan_rf.h"
#include "PCA9555.h"
#include "mk_phy.h"
#include "HIDO_Timer.h"
#define DEBUG_MODE
extern int simple_main(void);
extern int temp_main(void);
#define TEST_UART_POLL_MODE 0
@@ -76,12 +85,30 @@
#define WARING_LIMIT_TIME 10
#define UPDATE_TIME 10

/****************************************************************引脚宏定义**************************************************/
#define ADC_PIN                              IO_PIN_0
#define UART0_TX                                  IO_PIN_5
#define UART0_RX                                           IO_PIN_6
#define UART1_TX                                          IO_PIN_1
#define UART1_RX                                           IO_PIN_14


/****************************************************************引脚宏定义**************************************************/
#define UWB_OPEN_COUNT 1                                              // UWB每次开启持续时间（秒）
#define UWB_MEASUREMENT_INTERVAL 3                               // 正常状态测距周期
#define UWB_MEASUREMENT_INTERVAL_SLEEP 60                      // 休眠状态测距周期
#define INACTIVE_TIMEOUT  30                           // 无步数变化超时时间（秒）
bool uwb_is_on = false;                                // UWB当前状态标记

void test_Delay_us(uint16_t time);
int LEDTask(uint8_t Uwb_led,uint8_t Bt_led,uint8_t Lora_led,uint8_t Power_led);
void Lora_UploadHeartBeartPoll(void);
void upload_apppoll();
extern uint8_t mUsartReceivePack[100];
extern uint8_t mUsart2ReceivePack[150];
extern uint8_t state5V_prase_flag,gps_prase_flag;
extern int distance;
extern uint8_t anchordata_num;
extern uint8_t anchordata_num;   //bat_percent
uint32_t dev_id;
uint8_t group_id;
uint16_t tag_frequency;
@@ -89,6 +116,7 @@
uint16_t warning_distance,prewarning_distance;
int16_t fVoltage_mv,first_search_flag;
uint8_t bat_percent,g_start_send_flag=1;
uint8_t LORA_REV_uwb_up =0;
uint8_t link_success_flag,motor_count;
uint16_t gps_wait_count;
uint8_t state5v = 1;
@@ -97,6 +125,7 @@
static uint32_t sample[NUM_SAMPLES] = {0};
uint8_t recev_error_num,send_messgae_count,send_flag,control_state;
uint8_t flag_4g_usart_rx_state = 1;  //4G 串口RX当前是 RX状态，不是GPIO状态
int input_5v_flag,air780e_flag1,air780e_flag2,air780e_flag3,air780e_flag4;
typedef enum
{      UN_BIND=0,
        LINK_SUCCESS,
@@ -127,7 +156,7 @@
    .flow = UART_FLOW_CONTROL_NONE,
    .rx_level = UART_RXFIFO_CHAR_1,
    .tx_level = UART_TXFIFO_EMPTY,
    .baud = BAUD_115200,
    .baud = BAUD_921600,
#if (TEST_UART_MODE == TEST_UART_POLL_MODE)
    .dma_en = false,
    .int_rx = false,
@@ -142,10 +171,11 @@
    .int_tx = false,
#endif
};
void uart_receive_callback(void *dev, uint32_t err_code)
{
    uart_receive(UART_ID1,m_EUART_DMA_RXBuf,EUART_RX_BUF_SIZE,uart_receive_callback);
}
//void uart_receive_callback(void *dev, uint32_t err_code)
//{
//    uart_receive(UART_ID1,m_EUART_DMA_RXBuf,EUART_RX_BUF_SIZE,uart_receive_callback);
//}

static void adc_callback(void *data, uint32_t number)
{
    uint32_t *result = (uint32_t *)data;
@@ -168,8 +198,23 @@
            bat_percent = ((fVoltage_mv - 3300) /8);
        }
    }
  //  LOG_INFO(TRACE_MODULE_APP, "The voltage is %%%d \r\n",bat_percent);
            if(fVoltage_mv<3300)
            {
               //power_low_flag=1;
               //gps_air780_power_change(gps_power_state,0);//gps原样，关闭4G 
//               LOG_INFO(TRACE_MODULE_APP, "电池电压低于3.3V，4G，GPS停止工作\r\n");
            }else{
               //power_low_flag=0;
               //gps_air780_power_change(gps_power_state,1);//gps原样,开启4G
//               LOG_INFO(TRACE_MODULE_APP, "电池电压正常,4G，GPS,正常工作\r\n");
            }
      PCA9555_Set_One_Value_Output(PWR_GND,1);//拉高
}
//static void timer_callback(void *dev, uint32_t time)
//{
//    enum TIMER_DEV_T id = *(enum TIMER_DEV_T *)dev;
//    LOG_INFO(TRACE_MODULE_APP, "Timer %d elapsed time %d\r\n", id, time);
//}
//void UartInit(void)
//{
//board_pins_config();
@@ -238,7 +283,8 @@
}
void MinuteTask(void)
{
    adc_get(&sample[0], NUM_SAMPLES, adc_callback);//adc采样
         PCA9555_Set_One_Value_Output(PWR_GND,0);//拉低
      adc_get(&sample[0], NUM_SAMPLES, adc_callback);//adc采样
}
void SecondTask(void)
{static uint8_t second_count;
@@ -248,8 +294,9 @@
        MinuteTask();
    }
    //UWB更新列表
    TagListUpdate();
    GPS_Poll();
//    TagListUpdate();
    //GPS_Poll();
      gps_power_state=1;//测试gps长开
    //UWB状态检测

    if(IfTCPConnected())
@@ -269,27 +316,55 @@
        }

    }
    HIDO_TimerTick();
    nomove_count++;
//    HIDO_TimerTick();

}
uint8_t flag_sleeptimer,flag_secondtask,secondtask_count;
// 定义状态
typedef enum {
    STATE_NORMAL,    // 正常状态，3秒测距上传一次
    STATE_SLEEP      // 休眠状态，1分钟测距上传一次
} CountState_t;
// 全局变量
uint32_t uwb_time_count = 0;  // 定时器计数值
uint32_t step_count = 0;      // 步数计数
uint32_t last_step_count = 0; // 上一次步数
CountState_t current_state = STATE_NORMAL; // 当前状态
uint32_t state_start_time = 0; // 状态开始时间
uint8_t led_state;
uint8_t  stationary_flag;
extern uint8_t lora_tx_flag;
extern uint16_t sleep_time;
uint8_t input5v_time;
extern uint8_t uwbled,btled,loraled,powerled;
uint8_t jibu_flag;
static void sleep_timer_callback(void *dev, uint32_t time)
{
    IO_control_init();
    UWBPoll();
    
    
    MotorPoll();
     input5v_time=1;
//    g_start_send_flag=1;
     HIDO_TimerTick();
//     lora_tx_flag++;
     uwb_time_count++;
    jibu_flag=1;
    upload_apppoll();

    if(secondtask_count++%2==0)
      if (current_state == STATE_NORMAL)
     {
       sleep_time++;
      }
      if(!read_5v_input_pca())
    {
        flag_secondtask = 1;
    }else{
        flag_secondtask = 0;
    }
       if(bat_percent>15)
        {
             powerled=1;
        }
         else
            {
            powerled=0;
        }
      }			

    flag_sleeptimer = 1;

      input5v_time=1;
    //马达震动逻辑
    if(g_com_map[MOTOR_ENABLE])
    {
@@ -307,18 +382,76 @@
    }else{
        motor_power_state=1;
    }
 
    //GPS工作逻辑
    nomove_count++;

		
}
uint16_t sleep_time=0;
uint32_t state_start_time_jibu=0;
uint8_t exercise_state=0;
void check_step_and_update_state(void)
{
    if ((step_count != last_step_count))
      {
        // 步数有变化，重置状态为正常状态
      last_step_count = step_count;
			
         if(current_state == STATE_SLEEP)
         {
            state_start_time_jibu = uwb_time_count;
            state_start_time=uwb_time_count;
         }
//         if (current_state != STATE_NORMAL) 
//            {
//            // 关闭可能正在运行的UWB
//            if (uwb_is_on) {
//                CloseUWB();
//                UWB_LED_OFF;
//                uwb_is_on = false;
//            }
//            current_state = STATE_NORMAL;
//            state_start_time = uwb_time_count; // 重置测距周期
//        }
         current_state = STATE_NORMAL;
         exercise_state=1;
         last_step_count = step_count;
			
    } 
      else
      {
        // 步数没有变化，检查是否需要切换到休眠状态
        if (current_state == STATE_NORMAL)
               {	
            uint32_t inactive_time = uwb_time_count - state_start_time_jibu;
            if (inactive_time >= INACTIVE_TIMEOUT)
                  { // 30秒后切换到休眠状态
                current_state = STATE_SLEEP;
                       exercise_state=2;
                       state_start_time_jibu=uwb_time_count;
            }
          }
     }
}
//void phy_timer_callback(uint32_t time)
//{
// lora_tx_flag++;
//}

void uart0_receive_callback()
{
   uart_receive(UART_ID0,m_EUART_DMA_RXBuf,EUART_RX_BUF_SIZE,uart0_receive_callback);
}

void uart1_receive_callback()
{
   uart_receive(UART_ID1,m_EUART_DMA_RXBuf_1,USART_RX_BUF_SIZE,uart1_receive_callback);
}    

static void voltage_input_handler(enum IO_PIN_T pin)
{

}
static void move_handler(enum IO_PIN_T pin)
{
    nomove_count=0;
}

uint8_t flag_4G_recdata;
static void _4gUsart_handler(enum IO_PIN_T pin)
{
@@ -331,9 +464,14 @@
void Program_Init(void)
{
    Usart1ParseDataCallback = UsartParseDataHandler;//需改为默认为gps处理，UsartParseDataHandler为升级处理当调试时候改为
     Usart0ParseDataCallback = UsartParseDataHandler_1;
    parameter_init_anchor();//g_com_map表初始化角色默认为基站
//    g_com_map[DEV_ID]=0x0721;
     g_com_map[STATIONARY_TIME] = 10;
//    g_com_map[GROUP_ID]=1;
    dev_id=g_com_map[DEV_ID];//这里不太对
    group_id=g_com_map[GROUP_ID];//组ID
//     group_id=0x04;
    tag_frequency = 1000/g_com_map[COM_INTERVAL];//测距频率这个存的是测距时间
    memcpy(&disoffset,&g_com_map[DIST_OFFSET],2);
//    g_com_map[ALARM_DISTANCE1] = 40;
@@ -359,44 +497,64 @@
    ip2 = (g_com_map[TCP_IP_2]>>12&0xf)*1000+(g_com_map[TCP_IP_2]>>8&0xf)*100+(g_com_map[TCP_IP_2]>>4&0xf)*10+(g_com_map[TCP_IP_2]&0xf);
    ip3 = (g_com_map[TCP_IP_3]>>12&0xf)*1000+(g_com_map[TCP_IP_3]>>8&0xf)*100+(g_com_map[TCP_IP_3]>>4&0xf)*10+(g_com_map[TCP_IP_3]&0xf);
    port = g_com_map[TCP_PORT];
    g_com_map[VERSION] = (1<<8)|4;
    LOG_INFO("设备ID: %x .\r\n",dev_id);
    LOG_INFO("固件版本:UWB-4G手环 V%d.%d. \r\n",g_com_map[VERSION]>>8,g_com_map[VERSION]&0xff);
    LOG_INFO("服务器地址: %d.%d.%d.%d:%d.\r\n",ip0,ip1,ip2,ip3,port);
    g_com_map[VERSION] = (1<<8)|13;
    LOG_INFO(TRACE_MODULE_APP,"设备ID: %x .\r\n",dev_id);
    LOG_INFO(TRACE_MODULE_APP,"固件版本:BGK-mk+蓝牙薄工卡V%d.%d. \r\n",g_com_map[VERSION]>>8,g_com_map[VERSION]&0xff);
    LOG_INFO(TRACE_MODULE_APP,"服务器地址: %d.%d.%d.%d:%d.\r\n",ip0,ip1,ip2,ip3,port);
}



uint32_t adctick = 0;
uint16_t chongman_time;
void IdleTask(void)
{
    if(gpio_pin_get_val(INPUT_5V_Pin))
    {

        if(state5v==0)
        {
            state5v=1;
            state5V_prase_flag=state5v;
            gps_prase_flag=0;//解除gps解析
            uart1_change_from_gps_to_debug();
         //   uart_receive(UART_ID1,m_EUART_DMA_RXBuf,EUART_RX_BUF_SIZE,uart_receive_callback);//开启dma
            //UartInit();
        }

        //UART_CheckSend();
    } else {
        if(state5v==1)
        {
            g_com_map[MODBUS_MODE] = 0;
            state5v=0;
            state5V_prase_flag=state5v;
            gps_prase_flag=1;//恢复gps解析
            uart1_change_from_debug_to_gps();
          //  uart_receive(UART_ID1,m_EUART_DMA_RXBuf,EUART_RX_BUF_SIZE,uart_receive_callback);//开启dma
            //UartDeinit();
        }
    }
      UART_CheckReceive();
{	
 UART0_CheckReceive();
 UART_CheckReceive();
if(read_5v_input_pca())
   {
            chongman_time=0;
                  RED_LED_OFF;
                  GREEN_LED_OFF;
                  UWB_LED_OFF;
                  BT_LED_OFF;
                  LORA_LED_OFF;
            while(1)
            {
                nomove_count = 0;
                adctick = HIDO_TimerGetTick();
                if(HIDO_TimerGetTick()-adctick>60)  //10分钟采样一次 电量
                {
                    chongman_time=chongman_time+60;
                    adctick = HIDO_TimerGetTick();
                    PCA9555_Set_One_Value_Output(PWR_GND,0);//拉低
                    adc_get(&sample[0], NUM_SAMPLES, adc_callback);//adc采样
                }
                if(bat_percent>=99&&chongman_time>=600)
                {
                   GREEN_LED_ON;
                            RED_LED_OFF;
                }
                        else
                        {
//                   RED_LED_ON;
                            GREEN_LED_OFF;
                }
								
               if(!read_5v_input_pca())
                {
                break;
                }
            }
                     sys_reset(0);
//            NVIC_SystemReset();
//            input5vflag=1;
      }
   else
   {
	
//    sys_reset(0);
   }
}

int bind_check(void)
{
    if(g_com_map[BIND_DEV_ID]!=0x00)
@@ -422,135 +580,358 @@
{
   //将boot中串口返回普通gpio
// UART0 TX/RX
    io_pin_mux_set(IO_PIN_5, IO_FUNC0);
    io_pin_mux_set(IO_PIN_6, IO_FUNC0);
    io_pin_mux_set(UART0_RX, IO_FUNC0);
    io_pin_mux_set(UART0_TX, IO_FUNC0);
	
      gpio_pin_set_dir(UART0_RX , GPIO_DIR_OUT, 0);
     gpio_pin_set_dir(UART0_TX , GPIO_DIR_OUT, 0);
    // UART1 RX/TX
    io_pin_mux_set(IO_PIN_10, IO_FUNC0);
    io_pin_mux_set(IO_PIN_9, IO_FUNC0);
    io_pin_mux_set(UART1_RX, IO_FUNC0);
    io_pin_mux_set(UART1_TX, IO_FUNC0);


    uart_close(UART_ID1);//解绑原来串口1
    uart_close(UART_ID0);//解绑原来串口0
}
void test_Delay_us(uint16_t time)
{
   for(int i=time;i>0;i--)
   {
      for(int j=1;j>0;j--)
      {
         __NOP();
   }
   }

}
void mcu_deep_sleep(void)
{
            uint32_t lock;
            trace_flush();
            lock = int_lock();
             boot_deinit();
                  LOG_INFO(TRACE_MODULE_APP, "进入休眠\r\n");
             //关闭蓝牙 灯
                  LORA_LED_OFF;
                  GREEN_LED_OFF;
                  UWB_LED_OFF;
                  RED_LED_OFF;
                  BT_LED_OFF;				
             PCA9555_Set_One_Value_Output(BT_EN,0);
//              PCA9555_Set_One_Value_Config(BT_IRQ,0);        //设置BT_IRQ为输出拉低
//             PCA9555_Set_One_Value_Output(BT_IRQ,0);
                  sleep_timer_stop();	
            power_enter_power_down_mode(1);
                  sys_reset(0);
            int_unlock(lock);
}
void IMUTask(void)
{
   if(nomove_count>g_com_map[NOMOVESLEEP_TIME]&&g_com_map[IMU_ENABLE]==1)
   {
      power_wakeup_enable((enum POWER_WAKEUP_SOURCE_T)PCA_INPUT_DETECT, POWER_WAKEUP_LEVEL_LOW);
      mcu_deep_sleep();

   }
}
#define TEST_SPI_MASTER 0
#define TEST_SPI_POLL_MODE 0
#define TEST_SPI_INTERUPT_MODE 1
#define TEST_SPI_DMA_MODE 2
#define TEST_SPI_MODE TEST_SPI_POLL_MODE

void Board_gpio_init()
{
    //SPI0/MOSI/MISO/CLK/CS
    io_pin_mux_set(LORA_CS, IO_FUNC0);
    gpio_pin_set_dir(LORA_CS , GPIO_DIR_OUT, 0);
    io_pull_set(LORA_CS, IO_HIGH_Z, IO_PULL_UP_NONE);
	
    io_pin_mux_set(LORA_MOSI, IO_FUNC2);
    io_pin_mux_set(LORA_MISO, IO_FUNC2);
    io_pin_mux_set(LORA_CLK, IO_FUNC2);
     io_pin_mux_set(LORA_DIO, IO_FUNC0);
	
	
     //ADC
     io_pin_mux_set(ADC_PIN, IO_FUNC1);
      io_pull_set(ADC_PIN, IO_HIGH_Z, IO_PULL_UP_NONE);
	
    //串口0
      io_pin_mux_set(UART0_RX, IO_FUNC4);
    io_pin_mux_set(UART0_TX, IO_FUNC4);
    uart_open(UART_ID0, &test_uart_cfg);	
//      io_pin_mux_set(UART0_RX, IO_FUNC0);
//     gpio_pin_set_dir(UART0_RX , GPIO_DIR_OUT, 0);
//    io_pin_mux_set(UART0_TX, IO_FUNC0);
//     gpio_pin_set_dir(UART0_TX , GPIO_DIR_OUT, 0);	
//     board_debug_console_open(TRACE_PORT_UART0);
     uart_receive(UART_ID0,m_EUART_DMA_RXBuf,EUART_RX_BUF_SIZE,uart0_receive_callback);//开启dma

     //串口1
      io_pin_mux_set(UART1_RX, IO_FUNC4);
    io_pin_mux_set(UART1_TX, IO_FUNC4);
		
      board_debug_console_open(TRACE_PORT_UART1,BAUD_115200);
      uart_receive(UART_ID1,m_EUART_DMA_RXBuf_1,USART_RX_BUF_SIZE,uart1_receive_callback);//开启dma
}
void spi_init()
{
    struct SPI_CFG_T usr_spi_cfg =
    {
        .bit_rate = 1000000,
        .data_bits = 8,
//#if TEST_SPI_MASTER
        .slave = 0,
//#else
//        .slave = 1,
//#endif
        .clk_phase = 0,
        .clk_polarity = 0,
        .ti_mode = 0,
//#if (TEST_SPI_MODE == TEST_SPI_POLL_MODE)
        .dma_rx = false,
        .dma_tx = false,
        .int_rx = false,
        .int_tx = false,
//#elif (TEST_SPI_MODE == TEST_SPI_INTERUPT_MODE)
//        .dma_rx = false,
//        .dma_tx = false,
//        .int_rx = true,
//        .int_tx = true,
//#elif (TEST_SPI_MODE == TEST_SPI_DMA_MODE)
//        .dma_rx = true,
//        .dma_tx = true,
//        .int_rx = false,
//        .int_tx = false,
//#endif
    };
    
     spi_open(SPI_ID0, &usr_spi_cfg);
}
uint8_t ceshi;
uint32_t error_cnt=0;
uint32_t successful_cnt=0;
uint8_t flag_4guart_needinit=0;
#define TX_LEN  10
#define RX_LEN  200

extern uint8_t RX_Buffer[RX_LEN];
extern uint16_t BufferSize;
static uint16_t source_id;
extern struct RxDoneMsg RxDoneParams;


extern uint16_t current_count;
extern uint8_t rec_index,rec_secdelay;
extern uint8_t  yuyin_no_sleep_flag,no_rx_flag;


/********************************************************************************************************/
/********************************************************************************************************/
/********************************************************************************************************/

wg_state_enum wg_state = WG_Lost;
/********************************************************************************************************/
static void Lora_irq_handler(enum IO_PIN_T pin)
{
   RadioIrqProcess();				
}

void Board_LORA_NVIC_Init(GPIO_IRQ_HANDLER_T irq_handler)  //LORA 中断配置
{
//        io_pin_mux_set(_4G_USART_RX_Pin,IO_FUNC0);//把原先io 变为普通GPIO
      gpio_pin_set_dir(LORA_DIO , GPIO_DIR_IN, 0);
      io_pull_set(LORA_DIO, IO_HIGH_Z, IO_PULL_UP_NONE);
    gpio_enable_irq(LORA_DIO, GPIO_IRQ_TYPE_RISING_EDGE, irq_handler);
}
extern uint8_t pca9555writedata_input[10];//暂存输入寄存器所有配置的数组
static void pca_handler(enum IO_PIN_T pin)
{
      PCA9555_readdata(PCA9555_DEVICE_ADDR,pca9555writedata_input);//读输入寄存器的值
      check_input_change();
}
extern uint32_t uwb_time_count;
uint8_t uwbled,btled,loraled,powerled;
uint8_t send_count=0;
void upload_apppoll()
{	
     uint32_t elapsed_time_jibu;

    switch (current_state) 
         {
        case STATE_NORMAL:
            elapsed_time_jibu = uwb_time_count - state_start_time;
                switch(elapsed_time_jibu)
                  {
                     case UWB_OPEN_COUNT:
                          CloseUWB();					     
                           LoraReportPoll();
                     break;
							
                     case UWB_MEASUREMENT_INTERVAL:
                           LEDTask(uwbled,btled,loraled,powerled);
                           LEDTask(0,0,0,2);
                             PCA9555_Set_One_Value_Output(IO_KONG,0);
                           delay_us(10000);
                           PCA9555_Set_One_Value_Output(IO_KONG,1);	
                              CloseUWB();
                              Uwbinit();
                              OpenUWB();
                              state_start_time = uwb_time_count;							
                     break;						
                  }
            break;

        case STATE_SLEEP:
            elapsed_time_jibu = uwb_time_count - state_start_time;
                switch(elapsed_time_jibu)
                  {
                     case UWB_OPEN_COUNT:
                            CloseUWB();	                   							
                           LoraReportPoll();
							      

                     break;
							
                     case UWB_MEASUREMENT_INTERVAL_SLEEP:
                           LEDTask(uwbled,btled,loraled,powerled);
                           LEDTask(0,0,0,2);
                             PCA9555_Set_One_Value_Output(IO_KONG,0);
                           delay_us(10000);
                           PCA9555_Set_One_Value_Output(IO_KONG,1);	
                              CloseUWB();
                              Uwbinit();
                              OpenUWB();											
                              state_start_time = uwb_time_count;	
							
							
                     break;						
                  }
            break;
         }	

}
int LEDTask(uint8_t Uwb_led,uint8_t Bt_led,uint8_t Lora_led,uint8_t Power_led)
{
   if(Uwb_led==1)
   {
    UWB_LED_ON;
   }else
   {
    UWB_LED_OFF;
   }
	
   if(Bt_led==1)
   {
    BT_LED_ON;
   }else
   {
    BT_LED_OFF;
   }
   if(Lora_led==1)
   {
    LORA_LED_ON;
   }else
   {
    LORA_LED_OFF;
   }
	
   if(powerled==1)
   {
    GREEN_LED_ON;
    GREEN_LED_OFF;;
   }
   else if(powerled==0)
   {
    RED_LED_ON;
    RED_LED_OFF;
	 
   }

//   PCA9555_Set_One_Value_Output(BT_IRQ ,0); 


}
uint8_t io14_state;
uint16_t  lora_freq=0;
uint16_t  lora_up_count=0;
//uint8_t TXBuffer[8]={0,1,2,3,4,5,6,7};
//uint8_t test_buf[10]={0,1,1,1,1,1,1,1,1,1};
int main(void)
{
    board_clock_run();
    boot_deinit();
    board_pins_config();
    board_debug_console_open(TRACE_PORT_UART1);
     boot_deinit();
    
    // Reset reason
    reset_cause_get();
    reset_cause_clear();

    // Load calibration parameters from NVM
    uint32_t internal_flash = (REG_READ(0x40000018) >> 17) & 0x1;
    uint32_t external_flash = (REG_READ(0x40010030) >> 28) & 0x3;
    if (internal_flash || external_flash == 1)
    {
        WsfNvmInit();
        board_calibration_params_load();
        flash_close(FLASH_ID0);
    }
    else
    {
        board_calibration_params_default();
    }

    reset_cause_clear(); 
    // Chip calibration
    calib_chip();

    // Disable watchdog timer
    wdt_close(WDT_ID0);
    LOG_INFO(TRACE_MODULE_APP, "UWB simple example\r\n");

    // open system timer
    //sys_timer_open();

    // TODO 4G
    Uart_Register(UART_ID_4G, UART_ID0);
    Internet_Init();
    TCPClient_Init();

    gpio_open();
    Board_gpio_init();
  	
    //board_led_init();
    spi_init();
	

    adc_open(&usr_adc_cfg);
    IIC2_Init();
    Board_LORA_NVIC_Init(Lora_irq_handler);
     pca_input_detection_init(pca_handler);
      IIC2_Init();
    Accelerometer_Init();
    IO_control_init();
    io_pin_mux_set(SCL_PIN, IO_FUNC0);//测试测距波形
    gpio_pin_set_dir(SCL_PIN , GPIO_DIR_OUT, 0);
    io_pull_set(SCL_PIN , IO_PULL_DOWN, IO_PULL_UP_LEVEL4);
    gps_air780_power_change(0,1);//开启gps，4G 
//加速度计初始化必须在IO_control_init之前因为复用SDA引脚
    adc_get(&sample[0], NUM_SAMPLES, adc_callback);//adc采样
    uart_open(UART_ID1, &test_uart_cfg);
    Program_Init();
   // uart1_change_from_gps_to_debug();   
    //Uart1GpsRecDebugSend();   
    uart_receive(UART_ID1,m_EUART_DMA_RXBuf,EUART_RX_BUF_SIZE,uart_receive_callback);
   
// Initialize low power mode
    power_init();
      AIR780E_Reset(); //4G模块重启，耗时1.5秒,这个是无法同步的关键

      PCA9555_init();
      adc_open(&usr_adc_cfg);
      Lora_1268_Init();
    SwitchLoraSettings(478,7,22);
      Program_Init();
     power_init();
    sleep_timer_open(true, SLEEP_TIMER_MODE_RELOAD, sleep_timer_callback);
    //sleep_timer_start(__MS_TO_32K_CNT(g_com_map[COM_INTERVAL]));//测试
    sleep_timer_start(__MS_TO_32K_CNT(SLEEP_TIMER_NUM));//测试
 //   board_5V_input_init(voltage_input_handler);
    board_acceleration_detection_init(move_handler);
//       LOG_INFO(TRACE_MODULE_APP, "测试进入app");
  
      sleep_timer_start(__MS_TO_32K_CNT(1000));//测试
    adc_get(&sample[0], NUM_SAMPLES, adc_callback);  
//#ifdef DEBUG_BOXING
//      io_pin_mux_set(BOXING_PIN,IO_FUNC0);
//      gpio_pin_set_dir(BOXING_PIN,GPIO_DIR_OUT,0);
//      io_pull_set(BOXING_PIN,IO_PULL_DOWN,IO_PULL_UP_LEVEL4);
//#endif
    Uwbinit();
//      OpenUWB();
//      boot_deinit();
    while (1)
    {
        if(flag_TCP_reconnectting||IfTCPConnected())
        {
            
        //    LOG_INFO(TRACE_MODULE_APP, "处理4G任务\r\n");
            air780_led_on();
            if(flag_4guart_needinit)
            {
                flag_4guart_needinit = 0;
                AIR780EUartInit();
            }
            Internet_Poll();
            HIDO_ATLitePoll();
            HIDO_TimerPoll();
            TCPClient_Poll();
            air780_led_off();
        }
        if(flag_secondtask)
        {
            flag_secondtask = 0;
            SecondTask();
        }
        IdleTask();
        //3种情况后都要发包和休眠
        //if(send_flag){
        //message_construct();
        //send_udp;
        //air780_success_state=0;//关闭4G成功发送灯
        //blink_led(&air780_success_state);//成功测距闪烁4G状态灯
        //air780_success_state=0;
        //}
#ifndef DEBUG_MODE
//if(flag_sleeptimer)
    //    if(!gpio_pin_get_val(INPUT_5V_Pin)&&((IfTCPConnected()&&Socket_IsSendQueueEmpty(0))||!flag_TCP_reconnectting&&!IfTCPConnected())&&!flag_4G_recdata) //进入休眠条件（与关系，全满足才进）：1.没有5V输入 2 TCP已连接时发送队列为空||TCP无连接时不在重连状态。
        {
            //     if(!flag_4guart_needinit)
            {
                //           LOG_INFO(TRACE_MODULE_APP, "4G RX 中断打开\r\n");
                //             board_4GUsart_detection_init(_4gUsart_handler);
//
            }
//               flag_sleeptimer =0;
//            LOG_INFO(TRACE_MODULE_APP, "进入休眠\r\n");
            //    flag_4guart_needinit = 1;
//
//        trace_flush();
//        uint32_t lock = int_lock();
//        //LOG_INFO(TRACE_MODULE_APP, "进入低功耗");
//        power_enter_power_down_mode(0);
//        int_unlock(lock);
        }
#endif
    { 
         if(jibu_flag)
         {
            jibu_flag=0;
           step_count = mir3da_get_step(); // 获取步数
         }
		  
//       Lora_Tx_Poll();
         uwb_app_poll();
         check_step_and_update_state();
//         upload_apppoll();
      IdleTask();
         IMUTask();
			
//         if(1) 
//       {
////               test1=gpio_pin_get_val(_4G_USART_RX_Pin);
//            uint32_t lock;
//            //flag_4guart_needinit = 1;
////            Internet_Poll();
////            HIDO_ATLitePoll();
////            HIDO_TimerPoll();
////            TCPClient_Poll();
//            
//           // delay_us(300000);
//            trace_flush();
//            lock = int_lock();            
//            power_enter_power_down_mode(0);
//                  uart_receive(UART_ID0,m_EUART_DMA_RXBuf,EUART_RX_BUF_SIZE,uart0_receive_callback);
////               test3=gpio_pin_get_val(_4G_USART_RX_Pin);
//               //LOG_INFO(TRACE_MODULE_APP, "进入休眠\r\n");
//            int_unlock(lock);
//       }
    }
}