ChinaUWBProject.git

			@@ -62,13 +62,15 @@
			#include "HIDO_Timer.h"
			#include "TCPClient.h"
			#include "mk_spi.h"
			#include "pan_port.h"
			//#include "pan_port.h"
			#include "mk_timer.h"
			//#include "pan_param.h"
			//#include "pan_rf.h"
			#include "lora_3029.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);
			@@ -83,8 +85,25 @@
			#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;
			@@ -137,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,
			@@ -152,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;
			@@ -178,7 +198,17 @@
			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)
			//{
			@@ -253,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;
			@@ -263,7 +294,7 @@
			MinuteTask();
			}
			//UWB更新列表
			TagListUpdate();
			// TagListUpdate();
			//GPS_Poll();
			gps_power_state=1;//测试gps长开
			//UWB状态检测
			@@ -285,35 +316,55 @@
			}

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

			}
			uint8_t flag_sleeptimer,flag_secondtask,secondtask_count;
			uint8_t lora_wg_up=0;
			// 定义状态
			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)
			{
			g_start_send_flag=1;
			// #ifdef DEBUG_BOXING
			//// gpio_pin_clr(IO_PIN_5);//测试
			// gpio_pin_set(IO_PIN_5);//测试
			// lora_wg_up=1;
			lora_tx_flag++;
			// 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)
			// {
			// flag_secondtask = 1;
			// }else{
			// flag_secondtask = 0;
			// }
			if (current_state == STATE_NORMAL)
			{
			sleep_time++;
			}
			if(!read_5v_input_pca())
			{
			if(bat_percent>15)
			{
			powerled=1;
			}
			else
			{
			powerled=0;
			}
			}

			// flag_sleeptimer = 1;

			input5v_time=1;
			//马达震动逻辑
			if(g_com_map[MOTOR_ENABLE])
			{
			@@ -331,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)
			{
			@@ -355,11 +464,14 @@
			void Program_Init(void)
			{
			Usart1ParseDataCallback = UsartParseDataHandler;//需改为默认为gps处理，UsartParseDataHandler为升级处理当调试时候改为
			Usart0ParseDataCallback = UsartParseDataHandler_1;
			parameter_init_anchor();//g_com_map表初始化角色默认为基站
			g_com_map[DEV_ID]=0x6789;
			g_com_map[GROUP_ID]=1;
			// 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;
			@@ -385,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)\|11;
			g_com_map[VERSION] = (1<<8)\|13;
			LOG_INFO(TRACE_MODULE_APP,"设备ID: %x .\r\n",dev_id);
			LOG_INFO(TRACE_MODULE_APP,"固件版本:UWB-4G手环 V%d.%d. \r\n",g_com_map[VERSION]>>8,g_com_map[VERSION]&0xff);
			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)
			@@ -448,11 +580,16 @@
			{
			//将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
			}
			@@ -467,22 +604,76 @@
			}

			}
			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 spi_gpio_init()

			void Board_gpio_init()
			{
			// SPI0 MOSI/MISO/CLK/CS
			//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);//spi中断
			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()
			{
			@@ -524,449 +715,223 @@
			uint8_t flag_4guart_needinit=0;
			#define TX_LEN 10
			#define RX_LEN 200
			uint8_t tx_test_buf[TX_LEN] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

			extern uint8_t RX_Buffer[RX_LEN];
			extern uint16_t BufferSize;
			static uint16_t source_id;
			extern struct RxDoneMsg RxDoneParams;
			uint32_t time_flag_lorarx=0;
			uint32_t lora_huanxing_count=0;
			uint16_t Lora_wangguanid=0;
			extern uint16_t wg_report_freq,wg_report_id;
			extern uint32_t wg_lost_count;
			wg_state_enum wg_state = WG_Lost;


			extern uint16_t current_count;
			extern uint8_t rec_index,rec_secdelay;
			extern uint8_t yuyin_no_sleep_flag,no_rx_flag;
			uint16_t wangguan_up_id;
			uint8_t LoraUp_flag;
			uint8_t imu_enable,motor_enable;
			extern uint8_t shengji_flag;
			uint16_t rec_wenjian_daxiao;
			uint16_t recnum[3];
			uint16_t recv_flag=0;
			uint16_t tx_flag=0;
			uint16_t CRC16=0;
			uint16_t DEST_ID=0;
			uint16_t rec_value,rec_delaytime,rx_count,datalen_offset;

			//
			uint16_t Loratx_flag=0;
			uint16_t Lorarx_flag=0;
			uint16_t Lorarx_time_out_flag=0;

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

			wg_state_enum wg_state = WG_Lost;
			/********************************************************************************************************/
			static void Lora_irq_handler(enum IO_PIN_T pin)
			{
			uint16_t checksum1;
			rf_irq_process();
			//这里根据SDK的那个逻辑用你的接口看看
			tx_flag=rf_get_transmit_flag();
			recv_flag=rf_get_recv_flag();
			if(recv_flag == RADIO_FLAG_RXDONE)
			{
			rf_set_recv_flag(RADIO_FLAG_IDLE);

			memcpy(RX_Buffer,RxDoneParams.Payload,RxDoneParams.Size);
			BufferSize=RxDoneParams.Size;
			lora_huanxing_count++;
			if(RX_Buffer[0]==0x04&&RX_Buffer[1]=='I'&&RX_Buffer[2]=='N'&&RX_Buffer[3]=='G')
			{

			time_flag_lorarx=phy_timer_count_get();
			UwbRange();
			//rf_enter_continous_rx(); //重新进入接收模式
			//LORA_REV_uwb_up=1;
			}
			if(RX_Buffer[MSG_TYPE_IDX]==LORA_MSGTYPE_WGRESPTAG)
			{
			checksum1=Checksum_u16(RX_Buffer,BufferSize-2);

			memcpy(&DEST_ID,&RX_Buffer[DEST_ID_IDX],2);
			memcpy(&CRC16,&RX_Buffer[BufferSize-2],2);
			if(!memcmp(&checksum1,&RX_Buffer[BufferSize-2],2))
			if(!memcmp(&dev_id,&RX_Buffer[DEST_ID_IDX],2))
			{
			memcpy(&source_id,&RX_Buffer[SOURCE_ID_IDX],2);
			if(wg_state==WG_Lost)
			{
			wg_state = WG_Connected;
			wg_report_id = source_id;
			}
			if(!memcmp(&wg_report_id,&RX_Buffer[SOURCE_ID_IDX],2))
			{
			wg_lost_count = 0;
			switch(RX_Buffer[PWTAG_RW_FLAG_IDX])
			{
			case WGRSP_RWTAG_NONE:
			// current_count = HAL_LPTIM_ReadCounter(&hlptim1);
			// wg_report_freq = RX_Buffer[POLL_FREQ_IDX]+400;
			// memcpy(&rec_delaytime,&RX_Buffer[NEXTPOLL_TIME_IDX],2);
			// if(report_ancnum<2)
			// {
			// datalen_offset = report_ancnum*85;
			// }else{
			// datalen_offset = (report_ancnum-1)*46+85;
			// }
			// rec_secdelay = RX_Buffer[PWTAG_SECDELAY_IDX];
			// if(BufferSize!=13\|\|rec_secdelay>20)
			// {
			// rec_secdelay = 0;
			// }
			//
			// target_count = current_count + rec_delaytime*3.2768 - delaytime-datalen_offset;
			// while(target_count>=32768)
			// target_count-=32768;
			// __HAL_LPTIM_COMPARE_SET(&hlptim1, target_count);
			// rx_count = HAL_LPTIM_ReadCounter(&hlptim1);
			// printf("tx %d,rx %d,delay %d",current_count>>5,rx_count>>5,rec_delaytime);
			break;
			case WGRSP_RWTAG_READ:
			no_rx_flag = 1;
			LoraSendComMap(WGRSP_RWTAG_READ);
			break;
			case WGRSP_RWTAG_WRITE:
			rec_index = RX_Buffer[PWTAG_WRITE_IDX_IDX];
			switch(rec_index)
			{
			case 0xdd: //语音下发
			break;
			// case 0x20: //蜂鸣
			// memcpy(&rec_value,&RX_Buffer[PWTAG_WRITE_VALUE_IDX],2);
			// motor_keeptime = rec_value;
			// break;
			default :
			memcpy(&rec_value,&RX_Buffer[PWTAG_WRITE_VALUE_IDX],2);
			g_com_map[rec_index/2] = rec_value;
			save_com_map_to_flash();
			LoraRspWriteCommap(SUBMSG_WRITE_ANCPARA);
			//flag_writepara_needreset = 1;
			no_rx_flag = 1;
			}

			break;
			case WGRSP_RWTAG_UPDATE:
			rec_index = RX_Buffer[PWTAG_WRITE_IDX_IDX];
			switch(rec_index)
			{
			case 0xaa: //升级下发
			memcpy(&rec_wenjian_daxiao,&RX_Buffer[WRITEPARA_VALUE_IDX],2);//文件大小
			if(rec_wenjian_daxiao>0XAC00\|\|rec_wenjian_daxiao==0)
			{}//文件过大，超出范围
			else
			{
			memcpy(&wangguan_up_id,&RX_Buffer[SOURCE_ID_IDX],2);//网关ID 占用2个字节
			shengji_flag=1;
			LoraUp_flag=1;
			imu_enable=0;
			}
			// LoraUp_Poll();
			break;
			}
			break;
			}
			}
			}

			}


			}
			if(tx_flag == RADIO_FLAG_TXDONE)
			{
			//rf_set_mode(RF_MODE_STB3);
			rf_set_transmit_flag(RADIO_FLAG_IDLE);
			Loratx_flag++;

			// #ifdef DEBUG_BOXING
			// //gpio_pin_clr(IO_PIN_5);//测试
			// gpio_pin_set(IO_PIN_5);//测试
			// #endif
			rf_enter_single_timeout_rx(100);
			// rf_enter_single_rx();
			// rf_enter_continous_rx();

			}
			if((recv_flag == RADIO_FLAG_RXTIMEOUT))
			{
			// #ifdef DEBUG_BOXING
			// gpio_pin_clr(IO_PIN_5);//测试
			// // gpio_pin_set(IO_PIN_5);//测试
			// #endif

			//这个超时接收是会自动重启的，所以必须将芯片状态置成STB3这样就退出了连续接收状态
			rf_set_mode(RF_MODE_STB3);
			//这个超时接收是会自动重启的，所以必须将芯片状态置成STB3这样就退出了连续接收状态

			Lorarx_time_out_flag++;
			rf_set_recv_flag(RADIO_FLAG_IDLE);

			// rf_clr_irq(REG_IRQ_RX_TIMEOUT);
			// rf_enter_single_timeout_rx(100);
			}
			if((recv_flag == RADIO_FLAG_RXERR))
			{
			rf_set_recv_flag(RADIO_FLAG_IDLE);
			}

			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);
			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};
			//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();

			// struct TIMER_CFG_T timer_cfg = {
			// .extin_type = TIMER_EXTIN_NONE,
			// .load = 0x1000000,
			// .int_en = true,
			// .callback = timer_callback,
			// };

			// timer_open(TIMER_ID0, &timer_cfg);
			spi_gpio_init();
			Board_gpio_init();

			//board_led_init();

			spi_init();
			//PCA9555_init();


			Board_LORA_NVIC_Init(Lora_irq_handler);
			Lora_init();
			//lora_freq=DEFAULT_up_FREQ+g_com_map[GROUP_ID];
			// rf_set_default_para(DEFAULT_up_FREQ+g_com_map[GROUP_ID],DEFAULT_up_SF);
			rf_set_default_para(DEFAULT_WG_SET_FREQ,DEFAULT_WG_SET_SF);
			//rf_enter_continous_rx();
			// rf_enter_continous_rx();
			// if((rf_single_tx_data(TXBuffer,10,0))!= OK)
			// {
			//
			// }
			//rf_set_default_para(DEFAULT_WG_SET_FREQ,DEFAULT_WG_SET_SF);
			// rf_set_default_para(DEFAULT_up_FREQ,DEFAULT_up_SF);
			//
			//rf_enter_continous_tx();
			// rf_set_transmit_flag(RADIO_FLAG_TXDONE);
			// rf_set_transmit_flag(RADIO_FLAG_TXDONE);
			// if(rf_continous_tx_send_data(tx_test_buf, TX_LEN) != 0)
			// {
			// error_cnt++;
			// }
			// else
			// {
			// successful_cnt ++;
			// }


			// while (rf_get_transmit_flag() == RADIO_FLAG_IDLE) ;
			//
			// rf_set_transmit_flag(RADIO_FLAG_IDLE);

			// adc_open(&usr_adc_cfg);
			// 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采样
			Program_Init();

			pca_input_detection_init(pca_handler);
			IIC2_Init();
			Accelerometer_Init();

			// rf_single_tx_data(TXBuffer,10,2);
			// 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(1000));//测试
			#ifdef DEBUG_BOXING
			io_pin_mux_set(IO_PIN_5,IO_FUNC0);
			gpio_pin_set_dir(IO_PIN_5,GPIO_DIR_OUT,0);
			io_pull_set(IO_PIN_5,IO_PULL_DOWN,IO_PULL_UP_LEVEL4);
			#endif
			//rf_enter_single_timeout_rx(1000);
			// board_acceleration_detection_init(move_handler);
			//rf_enter_single_timeout_rx(900);
			//rf_enter_single_timeout_rx(500);
			//rf_enter_single_rx();
			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)
			{
			// rf_irq_process();

			//rf_enter_single_rx();

			Lora_Tx_Poll();
			// if((rf_single_tx_data(TXBuffer,10,0))!= OK)
			// {
			//
			// }
			// #ifdef DEBUG_BOXING
			// gpio_pin_clr(IO_PIN_5);//测试
			// gpio_pin_set(IO_PIN_5);//测试
			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();

			// test_Delay_us(1000);
			// gpio_pin_set(IO_PIN_5);//测试
			// test_Delay_us(100000);
			// test_Delay_us(100000);
			// test_Delay_us(100000);
			// gpio_pin_clr(IO_PIN_5);//测试
			// test_Delay_us(2000);
			// gpio_pin_set(IO_PIN_5);//测试
			// test_Delay_us(1000);
			// gpio_pin_clr(IO_PIN_5);//测试
			// if(LORA_REV_uwb_up)
			// {
			// LORA_REV_uwb_up=0;
			// UwbRange();
			// }




			// UwbRange();
			// rf_irq_process();
			// if(rf_get_transmit_flag() == RADIO_FLAG_TXDONE)
			// {
			// rf_set_transmit_flag(RADIO_FLAG_IDLE);
			// rf_delay_ms(1000);
			// if(rf_continous_tx_send_data(tx_test_buf, TX_LEN) != 0)
			// {
			// error_cnt++;
			// }
			// else
			// {
			// successful_cnt ++;
			//// DDL_Printf("Tx cnt %d\r\n", cnt );
			// }
			// }


			////
			//
			//// io14_state=gpio_pin_get_val(LORA_DIO);
			// rf_set_transmit_flag(RADIO_FLAG_IDLE);
			// rf_delay_ms(1000);
			// rf_enter_continous_tx();
			//// rf_set_transmit_flag(RADIO_FLAG_TXDONE);
			// if(rf_continous_tx_send_data(tx_test_buf, TX_LEN) != OK)
			// {
			//// rf_enter_continous_rx();
			// }
			// else
			// {
			// successful_cnt ++;
			// }




			// while (rf_get_transmit_flag() == RADIO_FLAG_IDLE) ;
			//
			// rf_set_transmit_flag(RADIO_FLAG_IDLE);

			// if(flag_TCP_reconnectting\|\|IfTCPConnected())
			// {
			// 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();
			//
			// // 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())) //进入休眠条件（与关系，全满足才进）：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
			// // 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);
			// }
			}
			}