0301309

APP/app.c

@@ -0,0 +1,562 @@
+#include "led.h"
+#include "app.h"
+#include "device.h"
+#include "ch455g.h"
+#include "net_proc.h"
+#include "bsp.h"
+#include "at_module.h"
+#include "net_ctrl.h"
+#include "me3616.h"
+#include "./gateway_collect/gateway_collect.h"
+#include "downlink.h"
+#include "uart_conf.h"
+#include "../APP/network/nettimer.h"
+#include "../APP/network_mgr/net_proc.h"
+extern ME3616  air;
+/*
+*********************************************************************************************************
+*                                            LOCAL VARIABLES
+*********************************************************************************************************
+*/
+extern float Temp_test(void);
+
+OS_TCB   LED_TASK_HandleTCB;
+CPU_STK  LED_TASK_HandleStk[APP_TASK_START_STK_SIZE];
+void 		 LED_TASK_Handle(void * p_arg);
+
+OS_TCB   UART_TASK_HandleTCB;
+CPU_STK  UART_TASK_HandleStk[UART_TASK_START_STK_SIZE];
+void 		 UART_TASK_Handle(void * p_arg);
+
+OS_TCB   PROG_TASK_HandleTCB;
+CPU_STK  PROG_TASK_HandleStk[PROG_TASK_START_STK_SIZE];
+void 		 PROG_TASK_Handle(void * p_arg);
+
+OS_TCB   SVC_TASK_HandleTCB;
+CPU_STK  SVC_TASK_HandleStk[SVC_TASK_START_STK_SIZE];
+void 		 SVC_TASK_Handle(void * p_arg);
+
+OS_TCB   LORA_TASK_HandleTCB;
+CPU_STK  LORA_TASK_HandleStk[LORA_TASK_START_STK_SIZE];
+void 		 LORA_TASK_Handle(void * p_arg);
+
+OS_TCB   INFO_TASK_HandleTCB;
+CPU_STK  INFO_TASK_HandleStk[INFO_TASK_START_STK_SIZE];
+void 		 INFO_TASK_Handle(void * p_arg);
+
+/*
+*********************************************************************************************************
+*                                          STARTUP TASK
+*
+* Description : This is an example of a startup task.  As mentioned in the book's text, you MUST
+*               initialize the ticker only once multitasking has started.
+*
+* Arguments   : p_arg   is the argument passed to 'AppTaskStart()' by 'OSTaskCreate()'.
+*
+* Returns     : none
+*
+* Notes       : 1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
+*                  used.  The compiler should not generate any code for this statement.
+*********************************************************************************************************
+*/
+extern u8 USART3_RX_BUF[128];     //接收缓冲,最大USART_REC_LEN个字节.
+//接收状态
+//bit15，	接收完成标志
+//bit14，	接收到0x0d
+//bit13~0，	接收到的有效字节数目
+extern u16 USART3_RX_STA; 
+extern int rcv_flag;
+int len;
+
+
+void init_powerup_ledstatus(void)
+{
+    uint16_t ledstatus = 0;
+    volatile uint32_t i = 0;
+
+    ledstatus = (~ledstatus&0xFFFF);
+    set_led_no_init_sn(ledstatus);
+    for(i=0;i<500000;i++);
+    //ledstatus = (~ledstatus&0x0FFF);
+   //   set_led_no_init_sn(ledstatus);
+}
+
+
+void  AppTaskStart (void *p_arg)
+{
+    OS_ERR err;
+    uint16_t flash_size, ram_size;
+    uint8_t chip_id[12];
+    uint16_t data = 0;
+    uint8_t usmflag = 0;
+        g_ptTest.bTestStart = 0;
+    BSP_Init();        // Initialize BSP functions
+    CPU_Init();        // Initialize the uC/CPU services
+    CH455_Init();
+ //   cmd_init(UART_DEBUG);
+    init_powerup_ledstatus();
+    cpuidGetId(); //读取芯片ID
+    getcpuTypeIdcode();
+
+     printf("\r\ App Start \r\n");
+
+    data = BKP_ReadBackupRegister(BKP_DR2); // 升级标志
+    if(data != 0){
+        if(updata_state_cmp(data)){
+            if((data&0x00ff) == 0x82){ // 升级成功
+                data = set_updata_state(UPDATE_SUCCESS);
+                BKP_WriteBackupRegister(BKP_DR3, data);
+                printf("\r\n send to net update sucess\r\n");
+
+            }
+            else if((data&0x00ff) == 0x83) { // 回退成功
+                data = set_updata_state(UPDATE_RETURN_SUCESS);
+                BKP_WriteBackupRegister(BKP_DR3, data);
+                 printf("\r\n send to net return sucess\r\n");
+            }
+            printf("\r\n update status1 = %x\r\n",data);
+            data = BKP_ReadBackupRegister(BKP_DR3);
+            BKP_WriteBackupRegister(BKP_DR2, 0);
+            g_runData.bsendUpdateStatus = data&0xFF;
+            data = BKP_ReadBackupRegister(BKP_DR5);
+            if(data == UP_PROG_FROM_NET) g_runData.bResetUpdate = 1;
+            else g_runData.bResetUpdate = 2;
+            BKP_WriteBackupRegister(BKP_DR5, 0);
+        }
+    }
+    else{
+        g_runData.bResetUpdate = 0;
+        printf("\r\n no update program, data = %x\r\n",data);
+    }
+
+  //  printf("coll_msg size = %d\r\n",sizeof(collect_conf_t));
+    check_usim_status(0);
+
+	
+#if OS_CFG_STAT_TASK_EN > 0u                                    //如果使能（默认使能）了统计任务
+    OSStatTaskCPUUsageInit(&err);                               //计算没有应用任务（只有空闲任务）运行时 CPU 的（最大）
+#endif                                                          //容量（决定 OS_Stat_IdleCtrMax 的值，为后面计算 CPU 
+    //使用率使用）。
+
+	board_info_get(&flash_size, &ram_size, chip_id);
+#if 0//for test
+	adc_test();
+	SPI_FLASH_Test();
+	SPI_E2PROM_Test();
+	I2C_Test();
+	can_test();
+#endif	
+
+    OSTaskCreate((OS_TCB     *)&LED_TASK_HandleTCB, 
+                 (CPU_CHAR   *)"LED TASK Handle",
+                 (OS_TASK_PTR )LED_TASK_Handle,
+                 (void       *)0,
+                 (OS_PRIO     )LED_TASK_PRIO,
+                 (CPU_STK    *)&LED_TASK_HandleStk[0],
+                 (CPU_STK_SIZE)APP_TASK_START_STK_SIZE / 10,
+                 (CPU_STK_SIZE)APP_TASK_START_STK_SIZE,
+                 (OS_MSG_QTY  )0,
+                 (OS_TICK     )0,
+                 (void       *)0,
+                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
+                 (OS_ERR     *)&err);
+
+    OSTaskCreate((OS_TCB     *)&UART_TASK_HandleTCB,
+                 (CPU_CHAR   *)"UART TASK Handle",
+                 (OS_TASK_PTR )UART_TASK_Handle,  //串口数据查询
+                 (void       *)0,
+                 (OS_PRIO     )UART_TASK_PRIO,
+                 (CPU_STK    *)&UART_TASK_HandleStk[0],
+                 (CPU_STK_SIZE)UART_TASK_START_STK_SIZE / 10,
+                 (CPU_STK_SIZE)UART_TASK_START_STK_SIZE,
+                 (OS_MSG_QTY  )0,
+                 (OS_TICK     )0,
+                 (void       *)0,
+                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
+                 (OS_ERR     *)&err);
+
+    OSTaskCreate((OS_TCB     *)&LORA_TASK_HandleTCB,
+                 (CPU_CHAR   *)"LORA TASK Handle",
+                 (OS_TASK_PTR )LORA_TASK_Handle, // lora数据处理
+                 (void       *)0,
+                 (OS_PRIO     )LORA_TASK_PRIO,
+                 (CPU_STK    *)&LORA_TASK_HandleStk[0],
+                 (CPU_STK_SIZE)LORA_TASK_START_STK_SIZE / 10,
+                 (CPU_STK_SIZE)LORA_TASK_START_STK_SIZE,
+                 (OS_MSG_QTY  )0,
+                 (OS_TICK     )0,
+                 (void       *)0,
+                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
+                 (OS_ERR     *)&err);
+
+    OSTaskCreate((OS_TCB     *)&PROG_TASK_HandleTCB,
+                 (CPU_CHAR   *)"PROG TASK Handle",
+                 (OS_TASK_PTR )PROG_TASK_Handle, // 4G模块收发处理
+                 (void       *)0,
+                 (OS_PRIO     )PROG_TASK_PRIO,
+                 (CPU_STK    *)&PROG_TASK_HandleStk[0],
+                 (CPU_STK_SIZE)PROG_TASK_START_STK_SIZE / 10,
+                 (CPU_STK_SIZE)PROG_TASK_START_STK_SIZE,
+                 (OS_MSG_QTY  )0,
+                 (OS_TICK     )0,
+                 (void       *)0,
+                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
+                 (OS_ERR     *)&err);
+
+    OSTaskCreate((OS_TCB     *)&SVC_TASK_HandleTCB,
+                 (CPU_CHAR   *)"SVC TASK Handle",
+                 (OS_TASK_PTR )SVC_TASK_Handle,  // 设备初始化
+                 (void       *)0,
+                 (OS_PRIO     )SVC_TASK_PRIO,
+                 (CPU_STK    *)&SVC_TASK_HandleStk[0],
+                 (CPU_STK_SIZE)SVC_TASK_START_STK_SIZE / 10,
+                 (CPU_STK_SIZE)SVC_TASK_START_STK_SIZE,
+                 (OS_MSG_QTY  )0,
+                 (OS_TICK     )0,
+                 (void       *)0,
+                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
+                 (OS_ERR     *)&err);
+								 
+    OSTaskCreate((OS_TCB     *)&INFO_TASK_HandleTCB,
+                 (CPU_CHAR   *)"INFO TASK Handle",
+                 (OS_TASK_PTR )INFO_TASK_Handle, //网关查询采集器的信息 0x86 0x83 0x89这组协议是明文
+                 (void       *)0,
+                 (OS_PRIO     )INFO_TASK_PRIO,
+                 (CPU_STK    *)&INFO_TASK_HandleStk[0],
+                 (CPU_STK_SIZE)INFO_TASK_START_STK_SIZE / 10,
+                 (CPU_STK_SIZE)INFO_TASK_START_STK_SIZE,
+                 (OS_MSG_QTY  )0,
+                 (OS_TICK     )0,
+                 (void       *)0,
+                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
+                 (OS_ERR     *)&err);
+    OSTaskDel(&AppTaskStartTCB, &err);
+		
+}
+
+uint8_t rcv_buf_pt[128], rcv_size = 0;
+uint8_t lora_buf[13] = "this is gw";
+void LED_TASK_Handle(void * p_arg)//信息传输装置
+{
+    uint8_t i = 0;
+    uint8_t key = 0;
+    char val = 0;
+    OS_ERR  err;
+    float vol=0.0,sumVol = 0.0,temperature = 0.0, sumTemperature = 0.0;
+    uint16_t temp=0,updata_state_save= 0;
+    static uint16_t times = 0,ledstatus = 0;
+    static uint8_t flag = 0;
+    (void)p_arg;
+    SysTick_init();
+    g_ledStatus.ledM = LED_M_LOW;
+    while (1)
+    {
+        if(flag>=g_ledStatus.ledM){
+        LED_RUN = !LED_RUN;
+            flag = 0;
+            if(downlink_config.gateway_id==0x00000000 || downlink_config.gateway_id==0xFFFFFFFF) {
+              ledstatus = (~ledstatus&0x0FFF);
+              ledstatus = ((g_firmwareExpl.dd<<4)&0xF000) | ledstatus;
+                set_led_no_init_sn(ledstatus);
+            }
+        }
+        flag++;
+
+        key=KEY_Scan(0);	//
+        if(key == KEY0_PRES){
+            printf("\n this is key \n");
+            printf("Alarm Time:%d-%d-%d %d:%d:%d\n",calendar.w_year,calendar.w_month,calendar.w_date,calendar.hour,calendar.min,calendar.sec);//输出闹铃时间
+        }
+        else if(key == KEY1_PRES){ //
+            if(key_info.state == 0){
+                key_info.state = 1;
+                key_info.num = 0;
+                timeout_setValue(&key_info.tt_key_state,5*1000);//
+                timeout_start(&key_info.tt_key_state);
+            }
+            key_info.num++;
+            key_info.keyvalue = key;
+            printf("key num:%d\n",key_info.num);
+        }
+        else if(key == KEY2_PRES){
+            printf("按键k2 \n");
+            updata_state = UPDATA_DATA_SUCCESS;
+            updata_state_save = set_updata_state(updata_state);
+            BKP_WriteBackupRegister(BKP_DR3, updata_state_save);
+            //置升级标志
+            updata_state_info.updata_flag = set_updata_state(UPDATA_FLAG);
+            BKP_WriteBackupRegister(BKP_DR2, updata_state_info.updata_flag);
+        }
+        if(key_info.keyvalue == KEY1_PRES) {
+            if(timeout_isOut(&key_info.tt_key_state))//按键计时
+            {
+                  key_info.state = 0;
+                  if(key_info.num == 3) { // 5S内按三次，进行升级任务
+                    printf("key = 3\r\n");
+                    gateway_update_gateway_proc();
+                  }
+                key_info.num = 0;
+            }
+
+            //lora组号灯计时
+            if(timeout_isOut(&key_info.tt_key_state))//灯亮超时
+            {
+                if(key_info.optcmd == 3){
+                    key_info.optcmd = 0;
+                }
+              key_info.keyvalue = 0;
+            }
+
+        }
+        if(times<5) {
+            temp = get_adc(ADC_Channel_0, 1, ADC_SampleTime_239Cycles5);
+            vol = (float)temp*3300/4096;
+            sumVol += vol;//
+
+            temp = get_adc(ADC_Channel_16, 1, ADC_SampleTime_239Cycles5);
+            temperature = (1.42 - temp*3.3/4096)*1000/4.35;// + 25;
+            sumTemperature += temperature;//
+
+
+            if(times>=4){
+                vol = sumVol/5.0;
+                sumVol = 0.0;
+                g_firmwareMsg.gatewayMsg.fVol.fvoltage = vol/1000.0;
+                temperature = sumTemperature/5.0;
+                sumTemperature = 0.0;
+                g_firmwareMsg.gatewayMsg.fTemper.ftemperature = temperature;
+              // printf("ADC_Channel_0 Voltage measurement is : %f mV\r\n",vol);	//
+             //  printf("ADC_Channel_16 Temper measurement is : %f C\r\n",temperature);	//
+                times= 0;
+            }
+            else
+                times++;
+        }
+
+        OSTimeDlyHMSM(0, 0, 0, 100, OS_OPT_TIME_DLY, &err);
+
+
+
+    /******************************/
+    /*
+            //屏蔽// uart_rs232_init(Console_UID, cmd_rcv);
+    */
+    rcv_size = uart_blocking_read((char *)rcv_buf_pt, UART_DEBUG, 10);
+    if(rcv_size)
+    {
+            uart_cmd_task(rcv_buf_pt,rcv_size);
+    }
+    /******************************/
+			
+		
+    }
+
+}
+
+extern u8 uart_redirect_cfg[UART_MAX];
+
+static int uart_rcv(u8 uartid, void *arg, u8 *pbuf, u16 buflen,u8 version)
+{
+	int i;
+#if 0
+	if(uart_redirect_cfg[uartid]) {
+		uart_msg_send(uart_redirect_cfg[uartid] - 1, pbuf, buflen);
+	} else {
+		uart_msg_send(uartid, pbuf, buflen);
+	}
+#endif
+	printf("uart%d receive %d %s:\r\n", uartid+1, buflen, pbuf);
+
+	for(i = 0;i < buflen;i++) {
+		printf("%c", *(pbuf + i));
+	}
+	printf("\r\n");
+
+	return 0;
+}
+
+u8 gps_buff[100];
+u8 gps_index = 0;
+static int gps_data_rcv(u8 uartid, void *arg, u8 *pbuf, u16 buflen,u8 version)
+{
+	int i;
+
+	for(i = 0;i < buflen;i++) {
+		gps_buff[gps_index] = *(pbuf+i);
+		if(gps_buff[gps_index] == '$') {
+			gps_index = 0;
+			gps_buff[gps_index] = *(pbuf+i);
+		} else if((gps_buff[gps_index] == 0x0a)&&
+					(gps_buff[gps_index-1] == 0x0d)) {
+			if(strstr(gps_buff, "RMC")) {
+				//printf("%s",  gps_buff);
+			}
+			memset(gps_buff, 0 , gps_index);
+			gps_index = 0;
+			continue;
+		}
+		gps_index++;
+	}	
+	
+	return 0;
+}
+
+void UART_TASK_Handle(void * p_arg)//信息传输装置
+{
+    u8 i;
+    OS_ERR  err;
+    (void)p_arg;
+    //char hello[32] = "hello world!!\n"
+
+    SysTick_init();
+    for(i = 0;i < UART_MAX;i++) {
+        if(i == UART_DEBUG) {
+            uart_rs232_init(i, NULL);
+            continue;
+        }
+        else if(i == UART2_ID) {
+            uart_rs232_init(i, gps_data_rcv);
+            continue;
+        } else {
+            uart_rs232_init(i, NULL);
+            continue;
+        }
+    }
+
+    while (1)
+    {
+        for(i = 0;i < UART_MAX;i++) { //5个串口数据接收
+            uart_rcv_process(i);
+            //uart_msg_send(i, hello, sizeof(hello));
+            OSTimeDlyHMSM(0, 0, 0, 10, OS_OPT_TIME_DLY, &err);
+        }
+
+    }
+
+}
+
+void PROG_TASK_Handle(void * p_arg)//信息传输装置
+{
+    (void)p_arg; 
+	//char hello[32] = "hello world!!\n"
+	
+	SysTick_init();	
+	net_proc();		
+}
+
+void SVC_TASK_Handle(void * p_arg)//信息传输装置
+{
+    sys_eeprom_info_t info;
+    (void)p_arg;
+
+    SysTick_init();
+
+    system_info_get(&info);
+    gateway_power_info_get();
+
+    info.DevId = g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn;
+    svc_proc(info.DevType, info.DevId);
+}
+
+void LORA_TASK_Handle(void * p_arg)//信息传输装置
+{
+    OS_ERR  err;
+    (void)p_arg;
+
+    SysTick_init();
+    lora_init("golden_beans");
+
+    while(1) {
+        if(g_ptTest.bTestStart == PT_OFF ){
+            lora_task();
+            ota_process_handle();
+        }
+        OSTimeDlyHMSM(0, 0, 0, 1, OS_OPT_TIME_DLY, &err);
+    }
+}
+extern void lora_send(char *tx_data, uint32_t tx_len);
+float tmper = 0.0;
+void INFO_TASK_Handle(void * p_arg)//
+{
+    static uint8_t flag = 0;
+    uint8_t ret = 0;
+    OS_ERR  err;
+    (void)p_arg;
+
+
+    SysTick_init();
+    nettimer_init();
+    timeout_setValue(&g_usmTimeOut,60*1000);
+    //	tax_init1();
+    while(1) {
+
+        if(g_ptTest.bTestStart == PT_ON ){
+            OSTimeDlyHMSM(0, 0, 17, 0, OS_OPT_TIME_DLY, &err);
+            continue;
+        }
+
+        if(sys_net.net_hdl && (downlink_config.config_flag == CONFIG_WRITE) && (g_runData.bInitNetProc==1))
+        {
+            gateway_net_send_gatewayMsg();
+            gateway_reset_send_update_status();// 上报服务器网关自己的升级状态
+        }
+
+        if(((g_runData.cregStatus!=1) || (g_data4G.errorTime>=2) || (air.State.MQTT_State==0)) \
+             && (sys_net.net_hdl!=NULL)  && (g_runData.bUpdate==0)) { // 网络注册失败
+               ret = check_usim_status(1);
+               if((ret!=0) && (timeout_isOut(&g_usmTimeOut) ||(g_data4G.errorTime>=2) )){
+                   timeout_stop(&g_usmTimeOut);
+                   sys_net.net_hdl = NULL;
+                   sys_net.net_hdl = uplink_net_init((char*)g_upLinkTopic);
+                   sys_net.uplink_send = uplink_net_send; //上传数据的函数指针 4G
+                   sys_net.downlink_send = lora_send; // 下发数据的函数指针 lora
+                   device_init(0x0101, downlink_config.gateway_id);
+                   flag++;
+                   if(flag==1) timeout_setValue(&g_usmTimeOut,3*60*1000);
+                   else if(flag==2) timeout_setValue(&g_usmTimeOut,5*60*1000);
+                   else {
+                       flag = 3;
+                       timeout_setValue(&g_usmTimeOut,10*60*1000);
+                   }
+                   timeout_start(&g_usmTimeOut);
+                   if(g_data4G.errorTime>=2){
+                       printf("mqtt can not connect\r\n");
+                   }
+                   g_data4G.errorTime = 0;
+                   g_mqttRunDa.connectNum++;
+                    if(g_mqttRunDa.connectNum>=3) {
+                      g_mqttRunDa.bChangeSuc = 2; // 切换连接失败
+                    }
+               }
+        }
+        else if(g_runData.cregStatus==1 && flag!=0){
+            flag = 0;
+            timeout_setValue(&g_usmTimeOut,60*1000);
+            timeout_stop(&g_usmTimeOut);
+
+        }
+        if(g_mqttRunDa.bChangeMqtt == 1){ // 切换mqtt
+            if(air.State.MQTT_State==1) { // 切换成功// 保存mqtt地址
+                memset(&(g_firmwareMsg.mqttidport),0,sizeof(MqttIdPort));
+                memcpy(g_firmwareMsg.mqttidport.ip,g_mqttRunDa.mqttMsg.ip,g_mqttRunDa.mqttIdlen);
+                memcpy(g_firmwareMsg.mqttidport.port,g_mqttRunDa.mqttMsg.port,g_mqttRunDa.mqttPortlen);
+                memcpy(g_firmwareMsg.mqttidport.admin,g_mqttRunDa.mqttMsg.admin,g_mqttRunDa.mqttUserlen);
+                memcpy(g_firmwareMsg.mqttidport.password,g_mqttRunDa.mqttMsg.password,g_mqttRunDa.mqttPwdlen);
+                g_firmwareMsg.mqttidport.flag = 1;
+                fram_write_mqtt_msg();
+                printf("mqtt 切换成功,并保存mqtt的地址\r\n");
+                g_mqttRunDa.bChangeMqtt = 0;
+                g_mqttRunDa.connectNum = 0;
+            }
+            else if((air.State.MQTT_State==0) && (g_mqttRunDa.bChangeSuc==2)){ // 切换失败
+                // 恢复mqtt地址，进行重新连接
+                g_mqttRunDa.bChangeMqtt = 0;
+                g_mqttRunDa.connectNum = 0;
+                timeout_stop(&g_usmTimeOut);
+                printf("mqtt 切换失败，切换到原来的地址上\r\n");
+            }
+
+        }
+        OSTimeDlyHMSM(0, 0, 17, 0, OS_OPT_TIME_DLY, &err);
+    }
+}

APP/app.h

@@ -0,0 +1,15 @@
+#ifndef _APP_H
+#define _APP_H
+
+#include "../User/includes.h"
+#include "app_cfg.h"
+
+extern  OS_TCB   AppTaskStartTCB;
+extern  OS_TCB   AppTask_OTA_HandleTCB;
+extern  OS_TCB   AppTask_Server_ComTCB;
+
+
+extern OS_SEM M5311_ota_rx_sem;       //ÊÇ·ñʹÄܶÓÁÐ
+
+
+#endif

APP/app_cfg.h

@@ -0,0 +1,126 @@
+/*
+*********************************************************************************************************
+*                                              EXAMPLE CODE
+*
+*                              (c) Copyright 2009; Micrium, Inc.; Weston, FL
+*
+*               All rights reserved.  Protected by international copyright laws.
+*               Knowledge of the source code may NOT be used to develop a similar product.
+*               Please help us continue to provide the Embedded community with the finest
+*               software available.  Your honesty is greatly appreciated.
+*********************************************************************************************************
+*/
+
+/*
+*********************************************************************************************************
+*                                      APPLICATION CONFIGURATION
+*
+*                                     ST Microelectronics STM32
+*                                              on the
+*
+*                                     Micrium uC-Eval-STM32F107
+*                                         Evaluation Board
+*
+* Filename      : app_cfg.h
+* Version       : V1.00
+* Programmer(s) : JJL
+*                 EHS
+*********************************************************************************************************
+*/
+
+#ifndef  __APP_CFG_H__
+#define  __APP_CFG_H__
+
+
+/*
+*********************************************************************************************************
+*                                            BSP CONFIGURATION
+*********************************************************************************************************
+*/
+
+#define  BSP_CFG_LED_SPI2_EN                    DEF_ENABLED     /* Enable/disable LEDs on SPI port.                   */
+#define  BSP_CFG_LED_PIOC_EN                    DEF_ENABLED     /* Enable/disable PIOC LEDs.                          */
+
+
+/*
+*********************************************************************************************************
+*                                            TASK PRIORITIES
+*********************************************************************************************************
+*/
+
+
+//#define  UART_TASK_PRIO		  1
+//#define  APP_TASK_START_PRIO  2
+//#define  PROG_TASK_PRIO		  3
+//#define  LORA_TASK_PRIO		  4
+//#define  LED_TASK_PRIO		  5
+//#define  SVC_TASK_PRIO		  6
+//#define  INFO_TASK_PRIO		  7
+
+#define  UART_TASK_PRIO		  1
+#define  APP_TASK_START_PRIO      2
+#define  PROG_TASK_PRIO		  6
+#define  LORA_TASK_PRIO		  4
+#define  LED_TASK_PRIO		  5
+#define  SVC_TASK_PRIO		  3
+#define  INFO_TASK_PRIO		  7
+#define  NETTIM_TASK_PRIO		  8
+/*
+*********************************************************************************************************
+*                                            TASK STACK SIZES
+*                             Size of the task stacks (# of OS_STK entries)
+*********************************************************************************************************
+*/
+
+#define  APP_TASK_START_STK_SIZE        512
+#define  UART_TASK_START_STK_SIZE       128
+#define  PROG_TASK_START_STK_SIZE       1280//512
+#define  SVC_TASK_START_STK_SIZE        400
+#define  LORA_TASK_START_STK_SIZE       256
+#define INFO_TASK_START_STK_SIZE        256
+/*
+*********************************************************************************************************
+*                                           uC/LIB CONFIGURATION
+*********************************************************************************************************
+*/
+
+#include <lib_cfg.h>
+
+/*
+*********************************************************************************************************
+*                                          uC/Probe CONFIGURATION
+*********************************************************************************************************
+*/
+
+#define  APP_CFG_PROBE_OS_PLUGIN_EN    DEF_DISABLED
+#define  APP_CFG_PROBE_COM_EN          DEF_DISABLED
+
+/*
+*********************************************************************************************************
+*                                    BSP CONFIGURATION: RS-232
+*********************************************************************************************************
+*/
+
+#define  BSP_SER_COMM_EN                         DEF_ENABLED
+#define  BSP_CFG_SER_COMM_SEL           BSP_SER_COMM_UART_02
+#define  BSP_CFG_TS_TMR_SEL                                2
+
+
+/*
+*********************************************************************************************************
+*                                     TRACE / DEBUG CONFIGURATION
+*********************************************************************************************************
+*/
+
+#define  TRACE_LEVEL_OFF                                   0
+#define  TRACE_LEVEL_INFO                                  1
+#define  TRACE_LEVEL_DEBUG                                 2
+
+#define  APP_TRACE_LEVEL                    TRACE_LEVEL_INFO
+#define  APP_TRACE                            BSP_Ser_Printf
+
+#define  APP_TRACE_INFO(x)            ((APP_TRACE_LEVEL >= TRACE_LEVEL_INFO)  ? (void)(APP_TRACE x) : (void)0)
+#define  APP_TRACE_DEBUG(x)           ((APP_TRACE_LEVEL >= TRACE_LEVEL_DEBUG) ? (void)(APP_TRACE x) : (void)0)
+
+
+#endif

APP/command/console.c

@@ -0,0 +1,438 @@
+#include "macro_common.h"
+#include "uart.h"
+#include "trace.h"
+#include "console.h"
+
+/*TRACE模式使用的输出函数，cli模块借用trace模块的输出函数进行输出，cli初始化时根据
+指定uart端口指定输出函数*/
+extern trace_msg_send g_msg_msg_send;
+
+/*console口的命令信息*/
+console_cmd_info g_cmd_info;
+
+/*记录上一个输入的命令，用于上箭头时重复执行，目前只支持一条历史命令*/
+char g_cmd_last_cmd[CMD_LINE_LEN_MAX];
+
+/*存储console使用的串口ID*/
+u8 Console_UID;
+
+
+/*用于保存用户注册的所有命令的数据结构*/
+S_CLI_CMD_LIST	g_cli_cmd_list;
+
+/*功能*/
+const u32 escape_sequences[] =
+{
+    0x001B4F50,                 /* PF1 */
+    0x001B4F51,                 /* PF2 */
+    0x001B4F52,                 /* PF3 */
+    0x001B4F53,                 /* PF4 */
+    0x001B5B41,                 /* UP */
+    0x001B5B42,                 /* DOWN */
+    0x001B5B43,                 /* RIGHT */
+    0x001B5B44,                 /* LEFT */
+    0
+};
+
+
+/**************************************************************************************************
+*cmd_cmdline_parse --命令行解析函数
+*Input:
+*	pcmd	--需要解析的命令字符串；
+*	cmdlen	--需要解析的字符串的长度；
+*Output:
+*	argv	--解析出的参数变量
+*	argc	--解析出的参数数目
+*Return:
+*	0		--正确解析
+*	-1	--命令字符串有错误
+*/
+static int cmd_cmdline_parse(char *pcmd, u8 cmdlen, char **argv, u8 *argc)
+{
+	char *ptemp = NULL;
+	u8 argnum = 0;
+	
+	if(pcmd == NULL || cmdlen == 0)
+	{
+		return -1;
+	}
+	
+	ptemp = pcmd;
+
+	while((*ptemp == ' ')&&(ptemp))
+	{
+		ptemp++;
+	}
+
+	argv[argnum++] = ptemp;
+	
+	ptemp = strstr(pcmd, " ");
+
+	while(ptemp != NULL)
+	{
+		ptemp++;
+		*(ptemp-1) = '\0';
+		/*lint -save -e779*/
+		while(( " " ==ptemp)&&(ptemp))
+		{
+			ptemp++;
+		}
+		/*lint -restore*/
+		argv[argnum++] = ptemp;
+		ptemp = strstr(ptemp, " ");
+	}
+
+	*argc = argnum;
+	
+	return 0;
+	
+}
+
+#define CMD_CHECK_0	0	/*正确的命令*/
+#define INCOMPLET_CMD	1	/*不完整的命令*/
+#define UNKOWN_CMD		2	/*未知命令*/
+#define UNCONFIRM_CMD	3	/*不确定命令*/
+
+/**************************************************************************************************
+*cmd_cmdstr_check --命令行参数检查
+*Input:
+*	argv	--解析出来的参数变量
+*	argc	--解析出来的参数数量
+*Output:
+*	pcmdelement	--如果参数检查正确，输出对应的命令数据结构的指针
+*Return:
+*	CMD_CHECK_0
+*	INCOMPLET_CMD
+*	UNKOWN_CMD
+*	UNCONFIRM_CMD
+*/
+/*lint -save -e818*/
+static int cmd_cmdstr_check(char **argv, u8 argc, u32 *pcmdelement)
+{
+	u8 	i = 0,  cmdnum = 0, samecmd = 0;
+	char 	*arg[CMD_PARAM_NUM_MAX] = {NULL};
+	PS_CLI_CMD  pcmd = NULL;
+	char buf[CMD_LINE_LEN_MAX];
+	
+	if(argc >= CMD_PARAM_NUM_MAX)
+	{
+		return UNKOWN_CMD;
+	}
+	memset(buf,0,sizeof(buf));
+	for(i=0; i<CMD_MAX_NUM; i++)
+	{
+		if(g_cli_cmd_list.cmd[i]!=0)
+		{	
+			pcmd = (PS_CLI_CMD)g_cli_cmd_list.cmd[i];
+
+			if(strncmp(argv[0], pcmd->cmd, strlen(argv[0])) != 0)
+			{
+				continue;
+			}
+			*pcmdelement = g_cli_cmd_list.cmd[i];
+			
+			samecmd++;
+		}
+	}
+	if(samecmd == 0)
+	{
+		return UNKOWN_CMD;
+	}
+	if(samecmd > 1)
+	{
+		return UNCONFIRM_CMD;
+	}
+
+	pcmd = (PS_CLI_CMD)(*pcmdelement);
+
+	strncpy(buf, pcmd->cmd, strlen(pcmd->cmd));
+	(void)cmd_cmdline_parse(buf, strlen(buf), arg, &cmdnum);
+
+	if(argc < cmdnum)
+	{
+		return INCOMPLET_CMD;
+	}
+
+/*	if(argc > cmdnum)
+	{
+		return UNKOWN_CMD;
+	}
+*/
+		
+   return 0;
+	
+}
+/*lint -restore*/
+
+/******************************************************************************
+*cmd_run	--运行命令函数
+*Input:	
+*	None
+*Output:
+*	None
+*Return:
+*	None
+*/
+static void cmd_run(void)
+{
+	u8 	argc = 0;
+	char 	*arg[CMD_PARAM_NUM_MAX] = {NULL};
+	PS_CLI_CMD pcmd = NULL;
+	u32 cmdelement = 0;
+	int ret = 0;
+
+	(void)cmd_out(NEWLINE);
+	
+	if( 0 == g_cmd_info.cmdLineLen)
+	{
+		(void)cmd_out("%s", CMD_PROMPT);
+		return;
+	}
+
+	memset(g_cmd_last_cmd, 0, sizeof(g_cmd_last_cmd));
+	strncpy(g_cmd_last_cmd, g_cmd_info.cmdLine, g_cmd_info.cmdLineLen);
+
+	if( 0 != cmd_cmdline_parse(g_cmd_info.cmdLine, g_cmd_info.cmdLineLen, arg, &argc) )
+	{
+		(void)cmd_out(NEWLINE);
+		(void)cmd_out("%%\"%s\" unknown commond"NEWLINE, g_cmd_last_cmd);
+		/*szb add*/
+		(void)cmd_out("%s",CMD_PROMPT);
+		return;
+	}
+
+	ret = cmd_cmdstr_check(arg, argc, &cmdelement);
+
+	if(ret == CMD_CHECK_0)
+	{
+		pcmd = (PS_CLI_CMD)cmdelement;
+		if(pcmd->func(argc,arg) != 0)
+		{
+			(void)cmd_out("%%\"%s\" unknown commond"NEWLINE, g_cmd_last_cmd);
+		}
+	}
+	else
+	{
+		switch(ret)
+		{
+			case INCOMPLET_CMD:
+				(void)cmd_out("%% \"%s\" incomplete command"NEWLINE,arg[0]);
+				break;
+			case UNKOWN_CMD:
+				(void)cmd_out("%% \"%s\" unknown command"NEWLINE,arg[0]);
+				break;
+			case UNCONFIRM_CMD:
+				(void)cmd_out("%% \"%s\" unconfirm command"NEWLINE,arg[0]);
+				break;
+			default:
+				break;
+		}
+	}
+/*szb add*/
+	(void)cmd_out("%s",CMD_PROMPT);
+}
+
+/*****************************************************************************
+*cmd_rcv		--命令字符串接收函数	
+*
+*Input:
+*	prt		--协议类型，固定为PRTTYPE_CONSOLE，校验用
+*	pbuf	--接收到的数据缓冲头指针
+*	buflen	--接收到的字符串的长度
+*     version 
+*Output:
+*	None
+*Return:
+*	0		--正确执行
+*	-1	--执行失败
+*/
+/*lint -save -e818*/
+static int cmd_rcv(u8 uartid, void *arg, u8 *pbuf, u16 buflen,u8 version)
+{
+	u32 i = 0, j = 0;
+	u8 curpos = 0;
+	static u32 key = 0;
+
+	NO_USE(uartid);
+ 	NO_USE(arg);
+	NO_USE(version);
+		
+	curpos = g_cmd_info.curentpos;
+		
+	for(i=0; i<buflen; i++)
+	{
+		if(pbuf[i] == ESC_KEY)
+		{
+			continue;
+		}
+		else
+		{
+			key = pbuf[i];
+		}
+	
+		switch(key)
+		{/*根据需要增减case*/
+			case ENTER_KEY:
+			
+				//if(uart_msg_send_disable(uartid)==FALSE)
+				{
+					cmd_run();
+				}
+
+				curpos = 0;
+				memset(&g_cmd_info, 0, sizeof(g_cmd_info));
+				break;
+				
+			case '\t':
+				/*cmd_out("%c%c%c", 0x1b,0x5b,0x43);*/
+				break;
+			
+			case BS_KEY:
+				if((curpos > 0)&&(curpos == g_cmd_info.cmdLineLen))
+				{
+					curpos--;	
+					g_cmd_info.cmdLineLen--;
+					g_cmd_info.cmdLine[curpos] = '\0';
+					(void)cmd_out("%c %c", pbuf[i], pbuf[i]);
+				}				
+				break;
+			case ESC_KEY:
+				break;
+
+			case RIGHTARROW_KEY:
+					
+				break;
+				
+			case LEFTARROW_KEY:
+			/*	if(curpos >0)
+				{
+					curpos--;
+					cmd_out("%c", BS_KEY); 
+				}*/
+				break;
+			case DOWNARROW_KEY:
+			case UPARROW_KEY:			
+				for(j=0; j<g_cmd_info.cmdLineLen; j++)
+				{
+					(void)cmd_out("%c %c", BS_KEY, BS_KEY);
+				}
+				g_cmd_info.cmdLineLen = 0;
+				memset(g_cmd_info.cmdLine, 0, sizeof(g_cmd_info.cmdLineLen));
+				strncpy(g_cmd_info.cmdLine, g_cmd_last_cmd, strlen(g_cmd_last_cmd));
+				g_cmd_info.cmdLineLen = strlen(g_cmd_last_cmd);
+				g_cmd_info.curentpos = strlen(g_cmd_last_cmd);
+				curpos = g_cmd_info.curentpos;
+				(void)cmd_out("%s", g_cmd_info.cmdLine);
+				
+				break;
+				
+			case DEL_KEY:
+			
+			default:
+				(void)cmd_out("%c", pbuf[i]);				
+				if(curpos<(CMD_LINE_LEN_MAX-1))
+				{
+					g_cmd_info.cmdLine[curpos++] = (char)pbuf[i];
+					g_cmd_info.cmdLineLen++;
+				}
+				break;
+		}
+	}
+
+	g_cmd_info.curentpos = curpos;
+	
+	return 0;
+}
+/*lint -restore*/
+ 
+
+/************************************************************
+*cmd_install --命令行安装命令函数
+*
+*Input:	
+*	待安装的命令行结构
+*Output:
+*	Noen
+*Return:
+*	0		--安装成功
+*	-1	--安装失败
+*/
+int cmd_install(CPS_CLI_CMD pcmdelement)
+{
+
+	if(pcmdelement == NULL)
+	{
+		return -1;
+
+	}
+	
+	if(g_cli_cmd_list.num >= CMD_MAX_NUM)
+	{/*位置不够了*/
+		return -1;
+	}
+	if(strlen(pcmdelement->cmd) > CMD_LINE_LEN_MAX)
+	{/*命令字符串太长了，不能解析*/
+		return -1;
+	}
+
+	g_cli_cmd_list.cmd[g_cli_cmd_list.num] = (u32)pcmdelement;
+	
+	g_cli_cmd_list.num++;
+	
+	return 0;
+}
+
+u8 uart_redirect_cfg[UART_MAX];
+DEFCLICMD(uart_redirect_cmd, uart_redirect_struct,
+			"redirect uart SRC_ID to uart DST_ID","redirect")
+{
+	u8 src_id = 0, dst_id = 0;
+	NO_USE(argc);
+	NO_USE(argv);
+
+	src_id = atoi(argv[2]);
+	dst_id = atoi(argv[5]);
+	if(src_id&&(src_id <= UART_MAX)&&(dst_id <= UART_MAX)) {
+		(void)cmd_out(NEWLINE"redirect uart src %d to uart %d ", src_id, dst_id);
+		uart_redirect_cfg[src_id - 1] = dst_id;
+		(void)cmd_out(NEWLINE);
+	}
+
+	return 0;
+}
+
+DEFCLICMD(uart_redirect_show, uart_redirect_show_struct,
+			"uart redirect show","show redirect")
+{
+	u8 id;
+	NO_USE(argc);
+	NO_USE(argv);
+
+	cmd_out("%8s %8s"NEWLINE, "SrcUart", "DstUart");
+	for(id = 0;id < UART_MAX;id++) {
+		cmd_out("%7s%d %7s%d"NEWLINE, "Uart", id+1, "Uart", uart_redirect_cfg[id]);
+	}
+
+	return 0;
+}
+
+extern void cmd_test_install(void);
+extern int uart_msg_send(u8 uartid, const char *buf, u32 buflen);
+int cmd_init(u8 uartid)
+{
+	Console_UID=uartid;
+	g_msg_msg_send = uart_msg_send;
+
+	//ESC_check_delay_htmr=0;
+	
+	memset(&g_cli_cmd_list,0,sizeof(g_cli_cmd_list));
+	memset(&g_cmd_info, 0, sizeof(g_cmd_info));
+
+	cmd_test_install();
+	cmd_install(&uart_redirect_struct);
+	cmd_install(&uart_redirect_show_struct);
+   //     uart_rs232_init(Console_UID, cmd_rcv);
+
+	cmd_out("%s", BOOT_LOGO_INFO);	
+	return 0;
+}

APP/command/console.h

@@ -0,0 +1,128 @@
+#ifndef __INCLUDE_CONSOLE_H
+#define	__INCLUDE_CONSOLE_H
+
+#define BS_KEY      	0x08		/*Back Space */
+#define ENTER_KEY		0x0d		/*Enter*/
+#define SPACE_KEY   	0x20		/*Space */
+#define DEL_KEY     	0x7F		/*Delete */
+
+#define UPARROW_KEY 				0x1b5b41
+#define DOWNARROW_KEY 				0x1b5b42
+#define LEFTARROW_KEY 				0x1b5b44
+#define RIGHTARROW_KEY 				0x1b5b43
+#define ESC_KEY						0x1b
+	
+
+#define CMD_PASS_CHAR(c) (((c)>=UPARROW_KEY)&&((c)<=LEFTARROW_KEY))
+#define CMD_KEY_WORD(c) (((c)>='a') && ((c)<='z'))
+
+
+#define	CMD_PROMPT	"GoldenBeans#"
+#define UNKNOWNCMD	"Unknown commond\r\n"
+
+typedef enum E_CONSOLE_FSM_ENUM
+{
+	E_CONSOLE_FSM_NONE 			= 1,
+	E_CONSOLE_FSM_GETING_CMD 	= 2,
+	E_CONSOLE_FSM_GOT_CMD 		= 3,
+	E_CONSOLE_FSM_GETING_PARAM 	= 4,
+	E_CONSOLE_FSM_GOT_PARAM 	= 5,
+}E_CONSOLE_FSM;
+
+
+#define	CMD_LINE_LEN_MAX			64	/*命令行最大长度,包含参数*/
+#define	CMD_DESCRIPTION_LEN_MAX		64	/*命令行帮助信息最大长度*/
+#define CMD_PARAM_NUM_MAX			8	/*命令行中参数的最大数目，包括命令字*/
+
+#ifndef CMD_MAX_NUM	
+#define CMD_MAX_NUM	100
+#endif
+
+#define CMD_ESC_TIMOUT				100	/*组合键的超时时间*/
+
+
+typedef struct _console_cmd_info
+{
+	int		escpressed;
+	u8 	cmdLineLen;
+	char 	cmdLine[CMD_LINE_LEN_MAX];
+	u8 	curentpos;
+}console_cmd_info;
+
+typedef u8  CMDNODE;
+
+typedef struct _cmd_node_element
+{
+	CMDNODE cmdnode;
+	
+}cmd_node_element;
+
+
+
+typedef struct S_CLI_CMD_LIST_STRUCT
+{
+	u8	num;
+	u32	cmd[CMD_MAX_NUM];
+}S_CLI_CMD_LIST;
+
+
+typedef int (*console_func)(u8	argc,char **argv);
+
+
+typedef struct S_CLI_CMD_STRUCT
+{
+	char			*cmd;
+	char        	*description;
+	console_func		func;	
+}S_CLI_CMD;
+
+#define DEFCLICMD(funcname, cmdname, cmdstr, helpstr) \
+int funcname (u8,char **); \
+const S_CLI_CMD cmdname = \
+{\
+	cmdstr,\
+	helpstr,\
+	funcname\
+};\
+int funcname(u8 argc,char **argv)
+
+
+typedef S_CLI_CMD *PS_CLI_CMD;
+typedef const S_CLI_CMD *CPS_CLI_CMD;
+
+/*存储console使用的串口ID*/
+extern u8 Console_UID;
+
+/*******************************************************
+函数定义
+********************************************************/
+
+/************************************************************
+*cmd_install --命令行安装命令函数
+*
+*Input:	
+*	待安装的命令行结构
+*Output:
+*	Noen
+*Return:
+*	0		--安装成功
+*	-1	--安装失败
+*/
+int cmd_install(CPS_CLI_CMD pcmdelement);
+
+
+/****************************************************************************
+*cmd_init    --命令行的初始化函数，完成命令行数据结构的初始化工作
+*
+*Input:
+*	uartid	--命令行使用的串口编号，0，1；
+*Output:
+*	None
+*Return:
+*	None
+*/
+int cmd_init(u8 uartid);
+
+#endif
+
+

APP/command/macro_common.h

@@ -0,0 +1,172 @@
+/* macro_common.h -- 平台公共宏定义 Id: macro_common.h,v 1.5 2006/08/31 08:56:59 wangjiong Exp $ */
+
+/********************************************************
+    Copyright(C), 1999-2004 Raisecom, Inc. 
+    filename:      //文件名
+    Author： XXX      version:2004/12/20      //初始作者和版本时间
+    Others: 
+        THIS DOCUMENT IS GENERATED BY TORNADO TOOLS refgen.exe.
+        EXAMPLE:
+        ->torVars.bat
+        ->refgen -mg -out doc driver.c
+        ->cd doc 
+        ->htmllink
+***********************************************************/
+/*  
+DESCRIPTION  
+        平台公共宏定义
+
+
+SEE ALSO
+       
+*/
+
+/***********************************************************
+    Modified History:   //文件的修改历史记录列表，
+                        //在提交文件到版本服务器时一定要填入信息，该信息会自动放在此处 
+*       Log: macro_common.h,v $
+*       Revision 1.5  2006/08/31 08:56:59  wangjiong
+*       为pc-lint修改代码
+*
+*       Revision 1.4  2006/06/26 08:16:06  wangjiong
+*       修改BIT_CLEAR宏的错误
+*
+*       Revision 1.3  2006/03/14 06:14:49  zhangrongtao
+*       转换为dos格式
+*
+*       Revision 1.2  2006/03/13 03:08:56  zhangrongtao
+*       修改了opcom_dev和sadp对设备相关的剪裁方式
+*
+*       Revision 1.1.1.2  2006/03/02 05:32:46  zhangrongtao
+*       no message
+*
+*       Revision 1.1.1.1  2006/02/23 10:53:30  lch
+*       init
+*
+
+***********************************************************/  
+
+#ifndef _MACRO_COMMON_H
+#define _MACRO_COMMON_H
+
+
+/*返回a和b中的最小数*/
+#ifndef MIN
+#define MIN(a, b)       ((a) < (b)? (a): (b))
+#endif
+
+/*返回a和b中的最大数*/
+#ifndef MAX
+#define MAX(a, b)       ((a) > (b)? (a): (b))
+#endif
+
+/*返回不小于d的m的整数倍的最小整数*/
+#ifndef RND_UP
+#define RND_UP(d,m)	( ((d)%(m)) ? ((d)-(d)%(m)+(m)) :(d))
+#endif
+
+/*编译时取得数组a的元素个数*/
+#ifndef ARRAY_NITEM
+#define ARRAY_NITEM(a)		(sizeof(a)/sizeof((a)[0]))
+#endif
+
+/*假装使用一下x变量，去掉编译告警*/
+#ifndef NO_USE
+#define NO_USE(x)		((void)(x))
+#endif
+
+/*可以当作空语句使用*/
+#ifndef OTP_NULL
+#define OTP_NULL		((void)NULL)
+#endif
+
+/*函数的输入参数*/
+#ifndef OTP_IN
+#define OTP_IN		
+#endif
+
+/*函数的输出参数*/
+#ifndef OTP_OUT
+#define OTP_OUT		
+#endif
+
+/*函数的输入输出参数*/
+#ifndef OTP_INOUT
+#define OTP_INOUT		
+#endif
+
+/*判断flag中的mask标志是否有置位了的*/
+#define BIT_IS_SET(flag,mask)	(((flag)&(mask)) == (mask))
+
+/*清除flag中的mask标志*/
+//#define BIT_CLEAR(flag,mask)	((flag)&=(~(mask)))
+
+/*设置 flag中的mask标志*/
+//#define BIT_SET(flag,mask)	((flag)|=(mask))
+
+#define OTP_PACK_ALIGN(x) __attribute__((packed, aligned(x)))
+
+/*获得单独一个bit*/
+#define BIT_SIGNAL(x)  (1 << (x))
+
+/*包括第shift比特,向左取size比特置1,其它置0. shift从0开始,size至少1*/
+/*#define BIT_MASK(shift, size)    (((1 << (size)) - 1) << (shift))*/ /*wangzaizhong  20081201 修改*/
+#define BIT_MASK(shift, size)   (((1 << (size + shift))) - (1 << shift))
+
+
+/*包括第shift比特,向左取出size比特*/
+#define GET_BITS(x, shift, size) (((x) >>(shift)) & (((1 << (size)) - 1))) 
+
+#define BIT_RD(val, shift, size)	 (((val) >> (shift)) & ((1 << (size)) - 1))
+#define BIT_WR(val, shift)			((val) << (shift))
+
+/* 没有lint告警的不循环
+	如果写在lint的配置文件中，对DEBUG宏的定义就不能起作用，不知道原因
+	Info 717: do ... while(0)
+*/
+#define WHILE_0	/*lint -save -e717 */while(0)/*lint -restore */
+
+/* 没有lint告警的死循环
+	Info 716: while(1) ... 
+*/
+#define WHILE_1	/*lint -save -e716 */while(1)/*lint -restore */
+
+/* 把四个单字节无符号整数组织成一个4字节的无符号整数,	
+	B4为数值最大的字节，B1为数值最小的字节 */
+#define UINT8_MAKE_UINT32(B4,B3,B2,B1)	\
+			((OTP_UINT32)( ((B4)<<24) + ((B3)<<16) + ((B2)<<8) + (B1) ))
+
+
+/* 用位域表示端口的时候需要的字节数 */
+#define BYTES_FOR_PORT(nport)	(((nport)+7)/8)
+
+#define OTP_LITTLE_ENDIAN
+
+#ifdef	OTP_LITTLE_ENDIAN
+#define ntohl(x)	((((x) & 0x000000ff) << 24) | \
+			 (((x) & 0x0000ff00) <<  8) | \
+			 (((x) & 0x00ff0000) >>  8) | \
+			 (((x) & 0xff000000) >> 24))
+
+#define htonl(x)	((((x) & 0x000000ff) << 24) | \
+			 (((x) & 0x0000ff00) <<  8) | \
+			 (((x) & 0x00ff0000) >>  8) | \
+			 (((x) & 0xff000000) >> 24))
+
+#define ntohs(x)	((((x) & 0x00ff) << 8) | \
+			 (((x) & 0xff00) >> 8))
+
+#define htons(x)	/*lint -save -e778 -e572*/((((x) & 0x00ff) << 8) | \
+			 (((x) & 0xff00) >> 8)) /*lint -restore*/
+
+#else    
+#define	ntohl(x)	(x)
+#define	ntohs(x)	(x)
+#define	htonl(x)	(x)
+#define	htons(x)	(x)
+#endif
+
+
+#endif
+
+

APP/command/strfunc.c

@@ -0,0 +1,549 @@
+/*
+从rotpV3平台拷贝过来的函数，考虑到cpu特性和应用，没有全部拷贝过来，只拷贝了常用的几个函数
+** Description: 字符串相关的工具函数
+**
+*/
+
+#include <stdarg.h>
+#include <ctype.h>
+#include "stdio.h"
+#include "string.h"
+#include "macro_common.h"
+
+/*lint -save -e713 -e715 -e732 -e737 -e415 -e661 -e530*/
+static void dopr (char *buffer, size_t maxlen, const char *format,
+                  va_list args);
+static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
+		    const char *value, int flags, int min, int max);
+static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
+		    long value, int base, int min, int max, int flags);
+static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c );
+
+/*
+ * dopr(): poor man's version of doprintf
+ */
+
+/* format read states */
+#define DP_S_DEFAULT 0
+#define DP_S_FLAGS   1
+#define DP_S_MIN     2
+#define DP_S_DOT     3
+#define DP_S_MAX     4
+#define DP_S_MOD     5
+#define DP_S_CONV    6
+#define DP_S_DONE    7
+
+/* format flags - Bits */
+#define DP_F_MINUS 	(1 << 0)
+#define DP_F_PLUS  	(1 << 1)
+#define DP_F_SPACE 	(1 << 2)
+#define DP_F_NUM   	(1 << 3)
+#define DP_F_ZERO  	(1 << 4)
+#define DP_F_UP    	(1 << 5)
+#define DP_F_UNSIGNED 	(1 << 6)
+
+/* Conversion Flags */
+#define DP_C_SHORT   1
+#define DP_C_LONG    2
+
+#define char_to_int(p) (p - '0')
+#define chisdigit(ch) (((ch)>='0')&&((ch)<='9'))
+static void dopr (char *buffer, size_t maxlen, const char *format, va_list args)
+{
+	char ch;
+	long value;
+	char *strvalue;
+	int min;
+	int max;
+	int state;
+	int flags;
+	int cflags;
+	size_t currlen;
+
+	state = DP_S_DEFAULT;
+	currlen = flags = cflags = min = 0;
+	max = -1;
+	ch = *format++;
+	while (state != DP_S_DONE) 
+	{
+	  	if ((ch == '\0') || (currlen >= maxlen))
+	  	{
+			state = DP_S_DONE;
+	  	}
+	    switch(state) 
+		{
+		    case DP_S_DEFAULT:
+				if (ch == '%')
+				{
+					state = DP_S_FLAGS;
+				}
+				else
+				{
+					dopr_outch (buffer, &currlen, maxlen, ch);
+				}
+				ch = *format++;
+				
+				break;
+		    case DP_S_FLAGS:
+				switch (ch) 
+				{
+					case '-':
+						flags |= DP_F_MINUS;
+						ch = *format++;
+						break;
+					case '+':
+						flags |= DP_F_PLUS;
+						ch = *format++;
+						break;
+					case ' ':
+						flags |= DP_F_SPACE;
+						ch = *format++;
+						break;
+					case '#':
+						flags |= DP_F_NUM;
+						ch = *format++;
+						break;
+					case '0':
+						flags |= DP_F_ZERO;
+						ch = *format++;
+						break;
+					default:
+						state = DP_S_MIN;
+						break;
+				}
+				break;
+		    case DP_S_MIN:
+				if(chisdigit(ch))
+				{
+					min = 10*min + char_to_int (ch);
+					ch = *format++;
+				}
+				else if (ch == '*') 
+				{
+					min = va_arg (args, int);
+					ch = *format++;
+					state = DP_S_DOT;
+				}
+				else 
+				{
+					state = DP_S_DOT;
+				}
+				break;
+		    case DP_S_DOT:
+				if (ch == '.') 
+				{
+					state = DP_S_MAX;
+					ch = *format++;
+				} 
+				else 
+				{
+					state = DP_S_MOD;
+				}
+				break;
+		    case DP_S_MAX:
+				if (chisdigit((int) ch)) 
+				{
+					if (max < 0)
+					{
+						max = 0;
+					}
+					max = 10*max + char_to_int (ch);
+					ch = *format++;
+				} 
+				else if(ch == '*') 
+				{
+					max = va_arg (args, int);
+					ch = *format++;
+					state = DP_S_MOD;
+				} 
+				else 
+				{
+					state = DP_S_MOD;
+				}
+				break;
+			case DP_S_MOD:
+				/* Currently, we don't support Long Long, bummer */
+				switch (ch) 
+				{
+					case 'h':
+						cflags = DP_C_SHORT;
+						ch = *format++;
+						break;
+					case 'l':
+						cflags = DP_C_LONG;
+						ch = *format++;
+						break;
+					default:
+						break;
+				}
+				state = DP_S_CONV;
+				break;
+			case DP_S_CONV:
+				switch (ch) 
+				{
+					case 'd':
+					case 'i':
+						if (cflags == DP_C_SHORT)
+						{
+#if ( defined(OTP_COMPILER) && OTP_COMPILER == TORNADO_2_2 )
+							value = va_arg (args, int);
+#else
+							value = va_arg (args, int);
+#endif
+						}
+						else if (cflags == DP_C_LONG)
+						{
+							value = va_arg (args, long int);
+						}
+						else
+						{
+							value = va_arg (args, int);
+						}
+						fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
+						break;
+					case 'o':
+						flags |= DP_F_UNSIGNED;
+						if (cflags == DP_C_SHORT)
+						{
+#if ( defined(OTP_COMPILER) && OTP_COMPILER == TORNADO_2_2 )
+							value = va_arg (args, int);
+#else
+							value = va_arg (args, unsigned int);
+#endif
+						}
+						else if (cflags == DP_C_LONG)
+						{
+							value = va_arg (args, unsigned long int);
+						}
+						else
+						{
+							value = va_arg (args, unsigned int);
+						}
+						fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
+						break;
+					case 'u':
+						flags |= DP_F_UNSIGNED;
+						if (cflags == DP_C_SHORT)
+						{
+#if ( defined(OTP_COMPILER) && OTP_COMPILER == TORNADO_2_2 )
+							value = va_arg (args, int);
+#else
+							 value = va_arg (args, unsigned int);
+#endif
+						}
+						else if (cflags == DP_C_LONG)
+						{
+							value = va_arg (args, unsigned long int);
+						}
+						else
+						{
+							value = va_arg (args, unsigned int);
+						}
+						fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
+						break;
+					/*lint -save -e616 -e825*/	
+					case 'X':
+						flags |= DP_F_UP;
+					case 'x':
+						flags |= DP_F_UNSIGNED;
+						if (cflags == DP_C_SHORT)
+						{
+#if ( defined(OTP_COMPILER) && OTP_COMPILER == TORNADO_2_2 )
+							value = va_arg (args, int);
+#else
+							value = va_arg (args, unsigned int);
+#endif
+						}
+						else if (cflags == DP_C_LONG)
+						{
+							value = va_arg (args, unsigned long int);
+						}
+						else
+						{
+							value = va_arg (args, unsigned int);
+						}
+						fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
+						break;
+					/*lint -restore*/
+					case 'c':
+						dopr_outch (buffer, &currlen, maxlen,(char) va_arg (args, int));
+						break;
+					case 's':
+						strvalue = va_arg (args, char *);
+						if (max < 0)
+						{
+							max = maxlen; /* ie, no max */
+						}
+						fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
+						break;
+					case 'p':
+						strvalue = va_arg (args, void *);
+						fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
+						break;
+					case 'n':
+						if (cflags == DP_C_SHORT) 
+						{
+							short int *num;
+							num = va_arg (args, short int *);
+							*num = currlen;
+
+						} 
+						else if (cflags == DP_C_LONG) 
+						{
+							long int *num;
+							num = va_arg (args, long int *);
+							*num = currlen;
+						} 
+						else 
+						{
+							int *num;
+							num = va_arg (args, int *);
+							*num = currlen;
+						}
+						break;
+					case '%':
+						dopr_outch (buffer, &currlen, maxlen, ch);
+						break;
+					case 'w':
+						/* not supported yet, treat as next char */
+						ch = *format++;
+						break;
+					default:
+						/* Unknown, skip */
+						break;
+				}
+				ch = *format++;
+				state = DP_S_DEFAULT;
+				flags = cflags = min = 0;
+				max = -1;
+				break;
+			case DP_S_DONE:
+				break;
+			default:			/* hmm? */
+				break;			/* some picky compilers need this */
+		}
+	}
+	if (currlen < maxlen - 1)
+	{
+		buffer[currlen] = '\0';
+	}
+	else
+	{
+		buffer[maxlen - 1] = '\0';
+	}
+}
+
+static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
+		    const char *value, int flags, int min, int max)
+{
+  int padlen;			/* amount to pad */
+  int cnt = 0;
+
+  if (value == 0)
+	value = "<NULL>";
+
+  /*lint -save -e64*/
+  padlen = min - strlen(value);
+  /*lint -restore*/
+  if (padlen < 0)
+    padlen = 0;
+  if (flags & DP_F_MINUS)
+    padlen = -padlen; /* Left Justify */
+
+  while ((padlen > 0) && (cnt < max)) {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    --padlen;
+    ++cnt;
+  }
+  while (*value && (cnt < max)) {
+    dopr_outch (buffer, currlen, maxlen, *value++);
+    ++cnt;
+  }
+  while ((padlen < 0) && (cnt < max)) {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    ++padlen;
+    ++cnt;
+  }
+}
+
+/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
+
+static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
+		    long value, int base, int min, int max, int flags)
+{
+  char signvalue = 0;
+  unsigned long uvalue;
+  char convert[20];
+  int place = 0;
+  int spadlen = 0; /* amount to space pad */
+  int zpadlen = 0; /* amount to zero pad */
+  char *chars = ((flags & DP_F_UP)
+		 ? "0123456789ABCDEF"
+		 : "0123456789abcdef");
+
+  if (max < 0)
+    max = 0;
+
+  uvalue = value;
+
+  if (!(flags & DP_F_UNSIGNED)) {
+    if (value < 0) {
+      signvalue = '-';
+      uvalue = -value;
+    } else if (flags & DP_F_PLUS) {	/* Do a sign (+/i) */
+      signvalue = '+';
+    } else if (flags & DP_F_SPACE) {
+      signvalue = ' ';
+    }
+  }
+
+  do {
+    convert[place++] = chars[uvalue % (unsigned) base];
+    uvalue = (uvalue / (unsigned)base );
+  } while(uvalue && (place < 20));
+  if (place == 20)
+    place--;
+  convert[place] = 0;
+
+  zpadlen = max - place;
+  spadlen = (min - MAX (max, place)) - (signvalue ? 1 : 0);
+  if (zpadlen < 0)
+    zpadlen = 0;
+  if (spadlen < 0)
+    spadlen = 0;
+  if (flags & DP_F_ZERO) {
+    zpadlen = MAX(zpadlen, spadlen);
+    spadlen = 0;
+  }
+  if (flags & DP_F_MINUS)
+    spadlen = -spadlen; /* Left Justifty */
+
+  /* Spaces */
+  while (spadlen > 0) {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    --spadlen;
+  }
+
+  /* Sign */
+  if (signvalue)
+    dopr_outch (buffer, currlen, maxlen, signvalue);
+
+  /* Zeros */
+  if (zpadlen > 0) {
+    while (zpadlen > 0) {
+      dopr_outch (buffer, currlen, maxlen, '0');
+      --zpadlen;
+    }
+  }
+
+  /* Digits */
+  while (place > 0)
+    dopr_outch (buffer, currlen, maxlen, convert[--place]);
+
+  /* Left Justified spaces */
+  while (spadlen < 0) {
+    dopr_outch (buffer, currlen, maxlen, ' ');
+    ++spadlen;
+  }
+}
+
+static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c)
+{
+  if (*currlen < maxlen)
+    buffer[(*currlen)++] = c;
+}
+
+/*
+	王炯从snprintf.c拷贝过来
+*/
+unsigned int otp_vsnprintf (char *str, size_t count, const char *fmt, va_list args)
+{
+	if(count==0)
+	{
+		return 0;
+	}
+	
+  str[0] = 0;
+  dopr(str, count, fmt, args);
+  /*lint -save -e64*/
+  return(strlen(str));
+  /*lint -restore*/
+}
+
+
+/*
+	王炯从snprintf.c拷贝过来
+	向str中打印字符串，最多只打印count-1个字符。
+	如果打印了count-1个字符，则第count个字符为'\0'。
+*/
+unsigned int otp_snprintf (char *str, unsigned int count, const char *fmt, ...)
+{
+	int len;
+  va_list ap;
+  
+	if(count==0 || !str )
+	{
+		return 0;
+	}
+	
+  va_start(ap, fmt);
+  len = otp_vsnprintf(str, count, fmt, ap);
+  va_end(ap);
+  
+  return len;
+}
+
+/*
+	把输入的字符串转换成小写。
+	该函数会转换str中的所有大写字母为小写，非大写字母保持不变。
+	遇到'\0'会结束转换,达到了缓冲区长度count也会结束转换
+	输入参数:
+		str,	需要转换的字符串指针，
+		count,	str的缓冲区长度。
+	返回
+		str的值
+*/
+char * otp_strtolower (char *str, int count)
+{
+	int i=0;
+	if( !str )
+	{
+		return str;
+	}
+	while( i<count && str[i]!='\0' )
+	{
+		str[i]= (char)tolower(str[i]);
+		i++;
+	}
+	return str;
+}
+
+/*
+	把输入的字符串转换成大写。
+	该函数会转换str中的所有小写字母为大写，非小写字母保持不变。
+	遇到'\0'会结束转换,达到了缓冲区长度count也会结束转换
+	输入参数:
+		str,	需要转换的字符串指针，
+		count,	str的缓冲区长度。
+	返回
+		str的值
+*/
+char * otp_strtoupper (char *str, int count)
+{
+	int i=0;
+	if( !str )
+	{
+		return str;
+	}
+	while( i<count && str[i]!='\0' )
+	{
+		str[i]= (char)toupper(str[i]);
+		i++;
+	}
+	return str;
+}
+
+/*lint -restore*/
+
+
+

APP/command/strfunc.h

@@ -0,0 +1,47 @@
+#ifndef _STRFUNC_H
+#define _STRFUNC_H
+
+
+
+/*
+	把输入的字符串转换成小写。
+	该函数会转换str中的所有大写字母为小写，非大写字母保持不变。
+	遇到'\0'会结束转换,达到了缓冲区长度count也会结束转换
+	输入参数:
+		str,	需要转换的字符串指针，
+		count,	str的缓冲区长度。
+	返回
+		str的值
+*/
+extern char * otp_strtolower (char *str, int count);
+
+/*
+	把输入的字符串转换成大写。
+	该函数会转换str中的所有小写字母为大写，非小写字母保持不变。
+	遇到'\0'会结束转换,达到了缓冲区长度count也会结束转换
+	输入参数:
+		str,	需要转换的字符串指针，
+		count,	str的缓冲区长度。
+	返回
+		str的值
+*/
+extern char * otp_strtoupper (char *str, int count);
+
+
+/*
+	向str中打印字符串，最多只打印count-1个字符。
+	如果打印了count-1个字符，则第count个字符为'\0'。
+*/
+extern unsigned int otp_snprintf (char *str,unsigned  int count, const char *fmt, ...)
+	__attribute__((__format__(__printf__,3,4)));
+
+
+/*
+	王炯从snprintf.c拷贝过来
+*/
+unsigned int otp_vsnprintf (char *str, size_t count, const char *fmt, va_list args);
+
+
+#endif
+
+

APP/command/test_cli.c

@@ -0,0 +1,158 @@
+#include "includes.h"
+#include <stdarg.h>
+#include <ctype.h>
+#include "macro_common.h"
+#include "trace.h"
+#include "console.h"
+
+extern S_CLI_CMD_LIST	g_cli_cmd_list;
+int	g_db_on;
+
+/*lint -save -e715*/
+/*extern int enable_show_cmd_cmd(u8 argc,const char **argv);*/
+/*lint -restore*/	
+DEFCLICMD(enable_show_cmd_cmd,enable_show_cmd_struct,
+			"list","List all command string")
+{
+	u8 i = 0;
+	NO_USE(argc);
+	NO_USE(argv);
+	for( i = 0; i < g_cli_cmd_list.num;i++ )
+	{
+		(void)cmd_out("%s"NEWLINE,((PS_CLI_CMD)(g_cli_cmd_list.cmd[i]))->cmd);
+		(void)cmd_out("	%s"NEWLINE,((PS_CLI_CMD)(g_cli_cmd_list.cmd[i]))->description);
+	}
+
+	return 0;
+}
+
+/*extern int enable_cmd_help_cmd(u8 argc,const char **argv);*/
+/*lint -save -e818*/	
+DEFCLICMD(enable_cmd_help_cmd,enable_cmd_help_struct,
+			"help CMDSTRING",	"show help")
+{
+	u8 i = 0;
+
+	if(argc < 2)
+	{
+		(void)cmd_out("Argument -1!"NEWLINE);
+		return -1;
+	}
+
+	for( i = 0; i < g_cli_cmd_list.num;i++ )
+	{
+		if(strncmp(((PS_CLI_CMD)(g_cli_cmd_list.cmd[i]))->cmd, argv[1], strlen(argv[1])) == 0)
+		{
+			(void)cmd_out("%s"NEWLINE,((PS_CLI_CMD)(g_cli_cmd_list.cmd[i]))->description);
+			return 0;
+		}
+	}
+	(void)cmd_out("%s",UNKNOWNCMD);
+
+	return 0;
+}
+/*lint -restore*/
+
+
+/*lint -save -e818*/	
+DEFCLICMD(enable_cmd_debug_cmd,enable_cmd_debug_struct,
+			"debug (on|off)","turn on/off debug infomation")
+{
+	NO_USE(argc);
+	if(strncmp("on",argv[1], strlen(argv[1])) == 0)
+	{
+		g_db_on = TRUE;
+		(void)cmd_out("open the debug msg"NEWLINE);
+	}
+	else if(strncmp("off",argv[1], strlen(argv[1])) == 0)
+	{
+		g_db_on = FALSE;
+		(void)cmd_out("shutdown the debug msg"NEWLINE);
+	}
+	else
+	{
+		return -1;
+	}
+
+	return 0;
+}
+
+/*lint -restore*/
+#define SOFTWARE_VERSION			"1.1.2"
+
+/*打印本版本软件信息*/
+static void cli_print_softinfo(void)
+{
+	(void)cmd_out("\r\n 编译时间:   %s %s",__TIME__,__DATE__);
+	(void)cmd_out("\r\n 软件版本:   ");
+	(void)cmd_out(SOFTWARE_VERSION);
+}
+
+
+DEFCLICMD(enable_cmd_show_cmd,enable_cmd_show_struct,
+			"show","show all int")
+{
+	NO_USE(argc);
+	NO_USE(argv);
+	if(strncmp("",argv[1], strlen(argv[1])) == 0)
+	{
+		(void)cmd_out("\r\n	缺少参数:");
+		(void)cmd_out("\r\n	version:	查看版本");
+		(void)cmd_out("\r\n	softinfo:	查看软件版本信息");
+	}
+	else if(strncmp("softinfo",argv[1], strlen(argv[1])) == 0)
+	{
+		cli_print_softinfo();
+	}
+	else
+	{
+		(void)cmd_out("\r\n	缺少参数:");
+		(void)cmd_out("\r\n	version:	查看版本");
+		(void)cmd_out("\r\n	softinfo:	查看软件版本信息");
+	}
+	(void)cmd_out(NEWLINE);
+	return 0;
+}
+
+DEFCLICMD(enable_cpu_usage_cmd,enable_cpu_usage_struct,
+			"cpu usage","cpu")
+{
+	NO_USE(argc);
+	NO_USE(argv);
+
+	(void)cmd_out("\r\n	CPU 利用率 : %d %%", OSStatTaskCPUUsage);
+	(void)cmd_out(NEWLINE);
+
+	return 0;
+}
+extern int maqtt_check_connect_status(uint8_t type);
+DEFCLICMD(enable_cmd_mqtt_cmd,enable_cmd_mqtt_struct,
+                        "mqtt","mqtt_status")
+{
+    NO_USE(argc);
+    NO_USE(argv);
+    if(strncmp("",argv[1], strlen(argv[1])) == 0)
+    {
+        (void)cmd_out("\r\n	缺少参数:");
+    }
+    else if(strncmp("connect",argv[1], strlen(argv[1])) == 0)
+    {
+        maqtt_check_connect_status(1);
+    }
+    else
+    {
+        (void)cmd_out("\r\n	缺少参数:");
+    }
+    (void)cmd_out(NEWLINE);
+    return 0;
+}
+
+void cmd_test_install(void)
+{
+    (void)cmd_install(&enable_show_cmd_struct);
+    (void)cmd_install(&enable_cmd_help_struct);
+    (void)cmd_install(&enable_cmd_debug_struct);
+    (void)cmd_install(&enable_cmd_show_struct);
+    (void)cmd_install(&enable_cpu_usage_struct);
+    (void)cmd_install(&enable_cmd_mqtt_struct);
+}

APP/command/trace.c

@@ -0,0 +1,98 @@
+/****************************************************************
+	Copyright(C), 1999-2004 Raisecom, Inc.
+	filename: trace.c，trace函数，可以向串口输出信息
+	Author	: qiaoqiangguo
+	version	: 1.0
+	date	: 2008/6/21
+	Others	:
+        THIS DOCUMENT IS GENERATED BY TORNADO TOOLS refgen.exe
+        EXAMPLE:
+        ->torVars.bat
+        ->refgen -mg -out doc trace.c
+        ->cd doc
+        ->htmllink
+*****************************************************************/
+#include "includes.h"
+#include "strfunc.h"
+#include "trace.h"
+#include "console.h"
+
+/*trace使用的发送函数*/
+trace_msg_send g_msg_msg_send = NULL;
+
+/*定义临时使用的字符数组*/
+u8 g_trace_buf[TRACE_BUF_LEN_MAX];
+
+/* 格式输出到trace的目的地
+	输入参数:
+		fmt,	输出格式，printf相同的格式约定
+		...,	可选参数，printf相同的格式约定
+	返回值:
+		格式化后的字符串长度，与printf的返回值的约定相同		
+*/
+u32 trace_otp_trace(const char * fmt, ...)
+{
+	u32 len = 0;
+	va_list	  vaList;
+
+	va_start (vaList, fmt);
+	/*lint -save -e530*/
+	len = otp_vsnprintf((char *)g_trace_buf, TRACE_BUF_LEN_MAX, fmt, vaList);
+	/*lint -restore*/
+	if(g_msg_msg_send)
+	{
+		if(g_msg_msg_send(Console_UID, (char *)g_trace_buf, len) != 0)
+		{
+			va_end (vaList);
+			return 0;
+		}
+	}
+    va_end (vaList);
+	
+    return len;
+}
+
+/* 格式输出到trace的目的地
+	输入参数:
+		fmt,	输出格式，printf相同的格式约定
+		...,	可选参数，printf相同的格式约定
+	返回值:
+		格式化后的字符串长度，与printf的返回值的约定相同		
+*/
+u32 trace_otp_trace1(trace_msg_send msg_send_cb, u8 uartid, const char * fmt, ...)
+{
+	u32 len = 0;
+	va_list	  vaList;
+
+	va_start (vaList, fmt);
+	/*lint -save -e530*/
+	len = otp_vsnprintf((char *)g_trace_buf, TRACE_BUF_LEN_MAX, fmt, vaList);
+	/*lint -restore*/
+	if(msg_send_cb)
+	{
+		if(msg_send_cb(uartid, (char *)g_trace_buf, len) != 0)
+		{
+			va_end (vaList);
+			return 0;
+		}
+	}
+    va_end (vaList);
+	
+    return len;
+}
+
+/*****************************************************************************
+*trace_init		trace初始化函数
+*Input:
+*	None
+*Output:
+*	None
+*Return:
+*	0/-1
+*/
+int trace_init(void)
+{
+	memset(g_trace_buf, 0, sizeof(g_trace_buf));
+
+	return 0;
+}

APP/command/trace.h

@@ -0,0 +1,58 @@
+#ifndef _TRACE_H
+#define _TRACE_H
+
+#ifndef TRACE_BUF_LEN_MAX
+/*定义trace的buf长度*/
+#define TRACE_BUF_LEN_MAX	1024
+#endif
+
+typedef int(* trace_msg_send)(u8 uartid, const char *buf, u32 buflen);
+
+
+
+/* 格式输出到trace的目的地
+	输入参数:
+		fmt,	输出格式，printf相同的格式约定
+		...,	可选参数，printf相同的格式约定
+	返回值:
+		格式化后的字符串长度，与printf的返回值的约定相同		
+*/
+u32 trace_otp_trace(const char * fmt, ...);
+u32 trace_otp_trace1(trace_msg_send msg_send_cb, u8 uartid, const char * fmt, ...);
+
+/*****************************************************************************
+*trace_init		trace初始化函数
+*Input:
+*	None
+*Output:
+*	None
+*Return:
+*	0/-1
+*/
+int trace_init(void);
+
+#define NEWLINE "\r\n"
+#define SPACE 0x20
+
+#define cmd_out trace_otp_trace
+
+#define OTP_TRACE trace_otp_trace
+#define OTP_TRACE_LINE OTP_TRACE( "TRC-ERR : %d@%s"NEWLINE, __LINE__, __FILE__)
+#define OTP_TRACE_FMT_ERR(fmt,arg...)	OTP_TRACE("TRC-ERR : %d@%s, " fmt NEWLINE, __LINE__,__FILE__, ##arg)
+
+//#define	EXE_ASSERT
+#ifdef EXE_ASSERT
+/*此处的assert暂时无法调试，暂时屏蔽 test */
+#define ASSERT(c) \
+	do{\
+		if(!(c)) \
+		{\
+				(void)trace_otp_trace( NEWLINE"ASSERT : %d@%s"NEWLINE"%s"NEWLINE, __LINE__, __FILE__,__FUNCTION__);\
+		}\
+	}while(0)
+#else
+#define ASSERT(c);
+#endif
+#endif
+
+

APP/command/uart_conf.c

@@ -0,0 +1,340 @@
+#include "uart_conf.h"
+#include "includes.h"
+#include "BSP.h"
+#include "AT24c128.h"
+#include "../globalDef.h"
+#include "../storage/AT24C128Opt.h"
+//volatile int USER_DEBUG_OUTPUT_EN = 1;
+
+//uint8_t 						USART1_receive_buf[USART1_BUF_SIZE],USART1_ready_buf[USART1_BUF_SIZE];
+//static 		int32_t 	USART1_ReceiveTimeCounter = 0;
+//volatile 	uint16_t 	USART1_receive_index=0;
+//volatile 	uint8_t 	USART1_ready_buf_ok = 0;
+//volatile 	int 	USART1_ready_buf_len = 0;
+
+////uint8_t 						USART2_receive_buf[USART2_BUF_SIZE],USART2_ready_buf[USART2_BUF_SIZE];
+//static 		int32_t 	USART2_ReceiveTimeCounter = 0;
+//volatile 	uint16_t 	USART2_receive_index=0;
+//volatile 	uint8_t 	USART2_ready_buf_ok = 0;
+//volatile 	int 	USART2_ready_buf_len = 0;
+
+////uint8_t 						USART3_receive_buf[USART3_BUF_SIZE],USART3_ready_buf[USART3_BUF_SIZE];
+//static 		int32_t 	USART3_ReceiveTimeCounter = 0;
+//volatile 	uint16_t 	USART3_receive_index=0;
+//volatile 	uint8_t 	USART3_ready_buf_ok = 0;
+//volatile 	int 	USART3_ready_buf_len = 0;
+
+PtTest g_ptTest;
+char *answer[] = {
+   "+PTMOD:ON,00000001\r\n",
+   "+PTMOD:ON,00000001\r\n",
+   "+PTMOD:OFF,00000001\r\n",
+   "+INITDEVINFO:OK\r\n",
+    "+EEPROMERASE:OK\r\n",
+    "+RST:OK\r\n",
+    "+EEPROMWR:OK\r\n",
+};
+extern uint8_t rcv_buf_pt[256];
+void gw_net_send_02(char *data, char *send_buf,  uint16_t len, uint16_t *llen)
+{
+    int i;
+  //  char send_buf[32];
+    char value = 0;
+    int send_len=0;
+    const uint16_t len1 = len;
+
+//   memset(send_buf,0,sizeof(send_buf));
+    for(i = 0;i < len1;i++) {
+        value = data[i];
+        send_len += snprintf((char *)send_buf + send_len, sizeof(send_buf), "%02x", value);
+    }
+        *llen = send_len;
+
+ //   return &(send_buf[0]);
+}
+
+void uart_cmd_task(uint8_t *data, uint8_t len)
+{
+    int i=0,j=0,flag =0;
+    int result = 0;
+    int n = 0,len1 = 0;
+    uint32_t id=0;
+    uint16_t addr,len11;
+		
+    char sendbuff[256] = {0};
+    char *pstr = NULL;
+   char tempbuff[128] = {0};
+   char type[4] = {0};
+   char ssn[11] = {0};
+   char pcbVr[3] = {0};
+   char bn[5] = {0};
+   char mfrs[5] = {0};
+   char pd[9] = {0};
+   char port[6] = {0};
+   char user01[8] = {0};
+   char password[16] = {0};
+   uint8_t temp1 = 0, temp2 = 0;
+   if(len<3) return;
+  // uart_msg_send(UART_DEBUG, (char *)data, len);
+
+    if(strstr((char*)data,"AT+PTMOD=ON\r\n")){ // 产测开始指令
+        pstr = strstr((char*)data,"AT+PTMOD=ON\r\n");
+        g_ptTest.bTestStart = 1;
+        uart_msg_send(UART1_ID, (char *)answer[0], strlen(answer[0]));
+      //  uart_msg_send(UART1_ID,data,len);
+        memset(pstr,0xFF,13);
+    }
+    else if(strstr((char*)data,"AT+PTMOD=OFF\r\n")){ //产测结束指令
+			pstr = strstr((char*)data,"AT+PTMOD=OFF\r\n");
+        g_ptTest.bTestStart = 0;
+        uart_msg_send(UART1_ID, (char *)answer[0], strlen(answer[0]));
+        memset(pstr,0xFF,13);
+    }
+    if(g_ptTest.bTestStart == 0) { // 没有进行产测
+        memset(&rcv_buf_pt,0,sizeof(rcv_buf_pt));
+        return;
+    }
+    if(strstr((char*)data,"AT+INITDEVINFO=WBJW,")){ // 初始化信息 设备类型 sn 批次号  生产厂商 生产日期
+     // if( g_ptTest.bTestStart == 0) return;
+     //   uart_msg_send(UART1_ID,"--------1\r\n",10);
+     //   uart_msg_send(UART1_ID,data,len);
+         pstr = strstr((char*)data,"AT+INITDEVINFO=WBJW,");
+         if(strstr(pstr,"\r\n")) {
+     //        uart_msg_send(UART1_ID,"--------2\r\n",10);
+            pstr =  pstr + strlen("AT+INITDEVINFO=WBJW,");//strstr((char*)data,"AT+INITDEVINFO=WBJW,");
+            result = sscanf((char*)pstr,"%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%s",type,ssn,pcbVr,bn,mfrs,pd,tempbuff,port,sendbuff);
+           //sscanf((char*)sendbuff,"%[^,],%s",user01, password);
+        i = 0; flag = 0; j=0;
+        do{
+            if(sendbuff[i]!=',' ){
+                if(flag==0){
+                    user01[i] = sendbuff[i];
+                }
+                else if(flag==1){
+                    password[j ] = sendbuff[i];
+                    j++;
+                }
+            }
+            else {
+                if(flag==0) flag = 1;
+            }
+            i++;
+        }while(sendbuff[i]!='\0');
+        sscanf(type,"%04X",&g_firmwareMsg.gatewayMsg.hardwareMsg.devicType); // 设备类型
+            if(g_firmwareMsg.gatewayMsg.hardwareMsg.devicType!=GATEWAY_DEVICE_TYPE){
+                memset(tempbuff,0,sizeof(tempbuff));
+                strcpy(tempbuff,(char*)"+INITDEVINFO:ERR,Device_mismatch\r\n");
+                uart_msg_send(UART1_ID, (char *)tempbuff, strlen(tempbuff));
+                memset(&rcv_buf_pt,0,sizeof(rcv_buf_pt));
+                return;
+            }
+            fram_init_mqtt_msg();
+            sscanf(ssn,"%010u",&g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn);  //sn
+            sscanf(pcbVr,"%02X",&g_firmwareMsg.gatewayMsg.hardwareMsg.pcbVersion); // PCB版本号
+            sscanf(bn,"%04X",&g_firmwareMsg.gatewayMsg.hardwareMsg.factoryMsg); // 生产厂商
+            sscanf(mfrs,"%04X",&g_firmwareMsg.gatewayMsg.hardwareMsg.seqNo); //批次号
+            sscanf(pd,"%08X",&g_firmwareMsg.gatewayMsg.hardwareMsg.data); // 生产日期
+            sscanf(tempbuff,"%s",g_firmwareMsg.mqttidport.ip); // mqtt 服务器地址
+            sscanf(port,"%s",g_firmwareMsg.mqttidport.port); //mqtt 端口号
+            sscanf(user01,"%s",g_firmwareMsg.mqttidport.admin);
+            sscanf(password,"%s",g_firmwareMsg.mqttidport.password);
+            g_firmwareMsg.gatewayMsg.hardwareMsg.bInit = 1;
+            fram_write_gateway_hardware_msg(); // 写入EEPROOM
+            g_firmwareMsg.mqttidport.flag = 1;
+            fram_write_mqtt_msg();
+            fram_write_eeprom_powerUpFlag();
+            uart_msg_send(UART1_ID, (char *)answer[3], strlen(answer[3]));
+            memset(&rcv_buf_pt,0,sizeof(rcv_buf_pt));
+        //    uart_msg_send(UART1_ID,"--------3\r\n",10);
+         }
+    }
+    else if(strstr((char*)data,"AT+DEVINFO\r\n")){ // 读取信息
+			if( g_ptTest.bTestStart == 0) return;
+        fram_read_gateway_hardware_msg();
+        fram_read_mqtt_msg();
+        memset(sendbuff,0,sizeof(sendbuff));
+        strcpy(sendbuff,"+DEVINFO:"); // 文件头
+
+        memset(tempbuff,0,sizeof(tempbuff));
+        sprintf(tempbuff,"%04x,%010u,%02x,%04x,",g_firmwareMsg.gatewayMsg.hardwareMsg.devicType,\
+                g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn,\
+                g_firmwareMsg.gatewayMsg.hardwareMsg.pcbVersion,g_firmwareMsg.gatewayMsg.devicTypeID);
+        strcat(sendbuff,tempbuff);
+
+        memset(tempbuff,0,sizeof(tempbuff));
+        gw_net_send_02((char*)g_firmwareMsg.gatewayMsg.Uuid,(char*)tempbuff,12,&len11);
+        strcat(sendbuff,tempbuff);
+        strcat(sendbuff,",");
+
+        memset(tempbuff,0,sizeof(tempbuff));
+        strncpy(tempbuff,(char*)g_firmwareMsg.gatewayMsg.Imei,15);
+        strcat(sendbuff,tempbuff);
+
+        memset(tempbuff,0,sizeof(tempbuff));
+        sprintf(tempbuff,",%08x,%08x,%04x,%04x,%08x",g_firmwareMsg.gatewayMsg.verMsg.gate_bootloaderVr,\
+                g_firmwareMsg.gatewayMsg.verMsg.gate_appVr,g_firmwareMsg.gatewayMsg.hardwareMsg.factoryMsg,\
+                g_firmwareMsg.gatewayMsg.hardwareMsg.seqNo,g_firmwareMsg.gatewayMsg.hardwareMsg.data);
+        strcat(sendbuff,tempbuff);
+
+        memset(tempbuff,0,sizeof(tempbuff));
+        sprintf(tempbuff,",%s,%s,%s,%s",g_firmwareMsg.mqttidport.ip,g_firmwareMsg.mqttidport.port, \
+                                        g_firmwareMsg.mqttidport.admin,g_firmwareMsg.mqttidport.password);
+
+        strcat(sendbuff,tempbuff);
+
+        len1 = strlen(sendbuff);
+
+        sendbuff[len1] = 0x0D;
+        sendbuff[len1+1] = 0x0A;
+
+
+        uart_msg_send(UART1_ID, sendbuff, strlen(sendbuff));
+        memset(&rcv_buf_pt,0,sizeof(rcv_buf_pt));
+
+    }
+    else if(strstr((char*)data,"AT+EEPROMERASE=")){ // 撤除EEPROM
+        if( g_ptTest.bTestStart == 0) return;
+        pstr = strstr((char*)data,"AT+EEPROMERASE=");
+        if(strstr(pstr,"\r\n")){
+            pstr =  pstr + strlen("AT+EEPROMERASE=");
+             memset(type,0,sizeof(type));
+             result = sscanf((char*)pstr,"%[^,]",type);
+             sscanf(type,"%04X",&g_firmwareMsg.gatewayMsg.hardwareMsg.devicType); // 设备类型
+             if(g_firmwareMsg.gatewayMsg.hardwareMsg.devicType!=GATEWAY_DEVICE_TYPE){
+                 memset(tempbuff,0,sizeof(tempbuff));
+                 strcpy(tempbuff,(char*)"+EEPROMERASE:ERR,Device_mismatch\r\n");
+                 uart_msg_send(UART1_ID, (char *)tempbuff, strlen(tempbuff));
+                 memset(&rcv_buf_pt,0,sizeof(rcv_buf_pt));
+                 return;
+             }
+            fram_init();
+            uart_msg_send(UART1_ID, (char *)answer[4], strlen(answer[4]));
+            uart_blocking_read(sendbuff,UART1_ID,1);
+            memset(&rcv_buf_pt,0,sizeof(rcv_buf_pt));
+
+        }
+    }
+    else if(strstr((char*)data,"AT+EEPROMWR=")) { // EEPROM 写
+        if( g_ptTest.bTestStart == 0) return;
+        pstr = strstr((char*)data,"AT+EEPROMWR=");
+        if(strstr(pstr,"\r\n")){
+            pstr =  pstr + strlen("AT+EEPROMWR=");
+
+            memset(type,0,sizeof(type));
+            memset(mfrs,0,sizeof(mfrs));
+            memset(bn,0,sizeof(bn));
+            memset(tempbuff,0,sizeof(tempbuff));
+            result = sscanf((char*)pstr,"%[^,],%[^,],%[^,],%s",bn,type,mfrs,tempbuff);
+            sscanf(type,"%04x",&addr);  //sn
+            sscanf(mfrs,"%04x",&len11); // PCB版本号
+            sscanf(bn,"%04X",&g_firmwareMsg.gatewayMsg.hardwareMsg.devicType); // 设备类型
+            if(g_firmwareMsg.gatewayMsg.hardwareMsg.devicType!=GATEWAY_DEVICE_TYPE){
+                memset(tempbuff,0,sizeof(tempbuff));
+                strcpy(tempbuff,(char*)"+EEPROMWR:ERR,Device_mismatch\r\n");
+                uart_msg_send(UART1_ID, (char *)tempbuff, strlen(tempbuff));
+                return;
+            }
+            len1 = 0;
+            for(i = 0; i < len11*2; i+=2)
+            {
+                    temp1 = HexToChar(tempbuff[i]);
+                    temp2 = HexToChar(tempbuff[i+1]);
+                    sendbuff[len1] = (temp1<<4) | temp2;
+                    len1++;
+            }
+            AT24CXX_Write(addr,(uint8_t*)sendbuff,len11);
+            uart_msg_send(UART1_ID, (char *)answer[6], strlen(answer[6]));
+            memset(&rcv_buf_pt,0,sizeof(rcv_buf_pt));
+
+        }
+    }
+    else if(strstr((char*)data,"AT+EEPROMRD")){ // EEPROM 读取
+				if( g_ptTest.bTestStart == 0) return;
+        pstr = strstr((char*)data,"AT+EEPROMRD");
+        if(strstr(pstr,"\r\n")){
+            pstr =  pstr + strlen("AT+EEPROMRD=");
+            memset(type,0,sizeof(type));
+            memset(mfrs,0,sizeof(type));
+            memset(tempbuff,0,sizeof(tempbuff));
+            result = sscanf((char*)pstr,"%[^,],%s",type,mfrs);
+            sscanf(type,"%04x",&addr);  //sn
+            sscanf(mfrs,"%04x",&len11); // PCB???
+
+            AT24CXX_Read(addr,tempbuff,len11);
+
+            memset(sendbuff,0,sizeof(sendbuff));
+            sprintf(sendbuff,"+EEPROMRD:%04x,",len11);
+            result = 15;
+            for(i=0;i<len11;i++){
+                len1 += snprintf((char *)sendbuff + result + len1, sizeof(sendbuff), "%02x", tempbuff[i]);
+            }
+            uart_msg_send(UART1_ID, sendbuff, len1+result);
+            memset(&rcv_buf_pt,0,sizeof(rcv_buf_pt));
+
+        }
+    }
+    else if(strstr((char*)data,"AT+RST\r\n")) { //复位
+			if( g_ptTest.bTestStart == 0) return;
+         uart_msg_send(UART1_ID, (char *)answer[5], strlen(answer[5]));
+        delay_ms(100);//延时100ms
+        NVIC_SystemReset();//复位
+    }
+    else if(strstr((char*)data,"AT+PTMOD\r\n")){ // 查询当前是否在产测模式下 产测版本
+        pstr = strstr((char*)data,"AT+PTMOD\r\n");
+        if(g_ptTest.bTestStart==1) uart_msg_send(UART1_ID, (char *)answer[1], strlen(answer[1]));
+        else uart_msg_send(UART1_ID, (char *)answer[2], strlen(answer[2]));
+        memset(pstr,0xFF,10);
+    }
+		
+
+
+//    if(strstr((char*)data,"AT+HSN="))
+//    {
+//        result = sscanf((char*)data,"AT+HSN=%08X%n",&id,&n);
+//        if(result==1)
+//        {
+//            g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn = id;
+//            fram_read_gateway_hardware_msg();
+
+//            printf("+HSN:OK\r\n");
+//            NVIC_SystemReset();//复位
+//        }
+//        else
+//        {
+//            printf("ERR4:%s\r\n",(char*)data);//Parameter error
+//        }
+//    }
+//    else if(strstr((char*)data,"AT+HSN\r\n"))
+//    {
+//        printf("+HSN:%08X\r\n",g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn);
+//    }
+//    else if(strstr((char*)data,"AT+DSN="))
+//    {
+//        result = sscanf((char*)data,"AT+DSN=%d\r\n%n",&id,&n);
+//        if(result==1)
+//        {
+//            g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn = id;
+//            fram_read_gateway_hardware_msg();
+//            printf("+DSN:OK\r\n");
+//            NVIC_SystemReset();//复位
+//        }
+//        else
+//        {
+//            printf("ERR4:%s\r\n",(char*)data);//Parameter error
+//        }
+//    }
+//    else if(strstr((char*)data,"AT+DSN\r\n"))
+//    {
+
+//        printf("+DSN:%010d\r\n",g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn);
+//    }
+//    else if(strstr((char*)data,"AT+HELP\r\n"))
+//    {
+//        printf("\r\n提示符  \"<\"  \">\"  不用输入\r\n");
+//        printf("AT+DSN=<COINNOVATION>,<DSN>            设置SN(DSN十进制设备编号)\r\n");
+//        printf("AT+DSN                                 查询SN（十进制）\r\n");
+//        printf("AT+HSN                                 查询SN（十六进制）\r\n");
+
+//    }
+}
+

APP/command/uart_conf.h

@@ -0,0 +1,18 @@
+#ifndef __UART_CONF_H__
+#define __UART_CONF_H__
+
+#include "stm32f10x.h"
+
+#define USART1_BUF_SIZE 					256			//接收一、二级缓冲区大小，缺省值2000
+enum {
+    PT_OFF = 0,
+    PT_ON  = 1,
+};
+typedef struct _PT_TEST_{
+    uint8_t bTestStart; // 产测开始
+
+}PtTest;
+extern PtTest g_ptTest;
+void uart_cmd_task(uint8_t *data, uint8_t len);
+#endif
+

APP/command/uart_conf333.c

@@ -0,0 +1,399 @@
+#include "uart_conf.h"
+#include "includes.h"
+#include "BSP.h"
+#include "AT24c128.h"
+#include "net_proc.h"
+#include "lora.h"
+#include "ota.h"
+
+
+PtTest g_ptTest;
+char *answer[] = {
+	"+PTMOD:ON,00000001\r\n",//0
+	"+PTMOD:ON,00000001\r\n",//1
+	"+PTMOD:OFF,00000001\r\n",//2
+	"+INITDEVINFO:OK\r\n",//3
+	"+INITDEVINFO:ERR,DEVICE_TYPE_MISMATCH\r\n",//4
+	"+EEPROMERASE:OK\r\n",//5
+	"+EEPROMERASE:ERR,DEVICE_TYPE_MISMATCH\r\n",//6
+	"+RST:OK\r\n",//7
+	"+EEPROMWR:OK\r\n",//8
+	"+EEPROMWR:ERR\r\n",//9
+	"+INITLORAPARAINDEX:OK\r\n",//10
+	"+INITLORAPARAINDEX:ERR\r\n",//11
+	"+OFFLINE:OK\r\n",//12
+	"+OFFLINE:ERR\r\n",//13
+};
+
+
+
+char Send_Buf_Char[320];
+char *gw_net_send_02(char *data,  uint16_t len, uint16_t *llen)
+{
+    int i;
+    //char send_buf[320];
+    char value = 0;
+    int send_len=0;
+    const uint16_t len1 = len;
+
+    memset(Send_Buf_Char,0,sizeof(Send_Buf_Char));
+    for(i = 0;i < len1;i++) {
+        value = data[i];
+        send_len += snprintf((char *)Send_Buf_Char + send_len, sizeof(Send_Buf_Char), "%02x", value);
+    }
+        *llen = send_len;
+
+    return &(Send_Buf_Char[0]);
+}
+
+extern uint8_t rcv_buf_pt[256]; 
+char sendbuff[320] = {0};
+uint8_t eeprom_buf[64] = {0};
+uint32_t eeprom_addr=0;
+#define EEPROM_PAGE 256
+#define EEPROM_BUF_LEN 64
+void uart_cmd_task(uint8_t *data, uint8_t len)
+{
+	OS_ERR  err;
+	uint16_t eeprom_first = 0;
+	int      i            = 0;
+	int      result       = 0;
+	int      len1         = 0;
+    uint16_t len11;
+	unsigned int lora_index;
+
+	uint32_t device_id;            //设备sn
+	uint32_t device_type;          //设备类型
+	uint32_t manufactures;         //产品制造商
+	uint32_t batch_number;         //批次号
+	uint32_t production_data;      //出厂日期
+	uint32_t pcb_ver;              //PCB版本
+   
+    char tempbuff[130] = {0};
+    char type[5]       = {0};
+    char ssn[11]       = {0};
+    char pcb[3]        = {0};
+    char bn[5]         = {0};
+    char mfrs[5]       = {0};
+    char pd[9]         = {0};
+    char port[6]       = {0};
+    char usr[40]       = {0};
+    char pwd[40]       = {0};
+	
+	//eeprom
+	char     eepaddr[5]   = {0};
+	char     eeplen[5]    = {0};
+	uint32_t eep_addr     = 0;
+	uint32_t eep_len      = 0;
+	uint16_t eep_len_temp = 0;
+	char     * p_data     = NULL;
+
+	//测试离线升级
+	char     master_snb[15] = {0};
+	char     slave_snb[15]  = {0};
+	char     des_snb[15]    = {0};
+	unsigned int master_sn      = 0;
+	unsigned int slave_sn       = 0;
+	unsigned int des_sn         = 0;
+
+    if(0 == strncmp((char*)data,"AT+PTMOD=ON\r\n",len)){ // 产测开始指令
+        g_ptTest.bTestStart = PT_ON;
+        uart_msg_send(UART1_ID, (char *)answer[0], strlen(answer[0]));
+			
+			device_fixed_info.Work_State = DEV_WORK_STATE_PT;
+			//关闭所有灯
+			close_all_led();
+		
+//		if(hd_id == PCB_V1)//关闭编码器中断
+		{
+			encoder_irq_set(DISABLE);
+		}
+    }
+		else if(strstr((char*)data,"AT+PTMOD\r\n")){ // 查询当前是否在产测模式下 产测版本
+					if(g_ptTest.bTestStart==PT_ON) uart_msg_send(UART1_ID, (char *)answer[1], strlen(answer[1]));
+					else uart_msg_send(UART1_ID, (char *)answer[2], strlen(answer[2]));
+
+		}
+		if(g_ptTest.bTestStart == PT_ON)
+		{
+			 if(0 == strncmp((char*)data,"AT+PTMOD=OFF\r\n",len)){ //产测结束指令
+					g_ptTest.bTestStart = PT_OFF;
+					uart_msg_send(UART1_ID, (char *)answer[2], strlen(answer[2]));
+				
+				if(device_info.alrd == DEVICE_ALRD)//已初始化
+				{
+					device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL;
+				}
+				else
+				{
+					device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT;
+					//未初始化时，将设备sn置为0xffffffff；设备类型是默认的
+					device_info.device_id = 0xffffffff;
+					device_info.device_type = (SOFTWARE_VERSION_APP&0xffff0000)>>16;
+				}
+				
+//				if(hd_id == PCB_V1)//打开编码器中断
+				{
+					encoder_irq_set(ENABLE);
+				}
+			}
+			
+			else if(strstr((char*)data,"AT+INITDEVINFO=WBJW,")){ // 初始化信息 设备类型 sn 批次号  生产厂商 生产日期
+				p_data=strstr((char*)data,"AT+INITDEVINFO=WBJW,");	
+				if(strstr(p_data,"\r\n"))
+				{
+					result = sscanf((char*)p_data,"AT+INITDEVINFO=WBJW,%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,]\r\n",type,ssn,pcb,bn,mfrs,pd,tempbuff,port,usr,pwd);
+
+					sscanf(type,"%04X",&device_type); // 设备类型
+					sscanf(ssn,"%010u",&device_id);  //sn
+					sscanf(pcb,"%02X",&pcb_ver);     //PCB版本
+					sscanf(bn,"%04X",&batch_number); //批次号 
+					sscanf(mfrs,"%04X",&manufactures); //生产厂商
+					sscanf(pd,"%08X",&production_data); // 生产日期
+
+					if(device_type_cmp(SOFTWARE_VERSION_APP,(u16)device_type) == 0)
+					{
+							uart_msg_send(UART1_ID, (char *)answer[4], strlen(answer[4]));
+							memset(&rcv_buf_pt,0,sizeof(rcv_buf_pt));
+							return;
+					}
+					
+					device_info.alrd = DEVICE_ALRD;
+					device_info.device_type = device_type;
+					device_info.device_id = device_id;
+					device_info.batch_number = batch_number;
+					device_info.manufactures = manufactures;
+					device_info.production_data = production_data;
+					device_info.pcb_ver = pcb_ver;
+					
+					device_info_update();//写eeprom
+				
+					eeprom_first = EEPROM_FIRST_INIT_FLAG;
+					AT24CXX_Write(EECFG_FIRST_INIT0, (uint8_t *)&eeprom_first, 2);
+
+					uart_msg_send(UART1_ID, (char *)answer[3], strlen(answer[3]));
+				}
+			}
+			else if(0 == strncmp((char*)data,"AT+DEVINFO\r\n",len)){ // 读取信息
+
+					device_info_get();//读取eeprom中的设备信息
+					memset(sendbuff,0,sizeof(sendbuff));
+					strcpy(sendbuff,"+DEVINFO:"); // 文件头
+
+					memset(tempbuff,0,sizeof(tempbuff));
+					sprintf(tempbuff,"%04x,%010u,%02x,%04x,",device_info.device_type,\
+									device_info.device_id,\
+									device_info.pcb_ver,device_fixed_info.MCU_Type_ID);
+					strcat(sendbuff,tempbuff);
+
+					gw_net_send_02((char*)device_fixed_info.MCU_UUID,12,&len11);
+					memset(tempbuff,0,sizeof(tempbuff));
+					memcpy(tempbuff,Send_Buf_Char,len11);
+					strcat(sendbuff,tempbuff);
+					strcat(sendbuff,",");
+
+					memset(tempbuff,0,sizeof(tempbuff));
+
+					sprintf(tempbuff,"%s,%08x,%08x,%04x,%04x,%08x,,,,","", device_fixed_info.Soft_ver_boot,\
+									device_fixed_info.Soft_ver_app,device_info.batch_number,\
+									device_info.manufactures,device_info.production_data);
+					strcat(sendbuff,tempbuff);
+
+					len1 = strlen(sendbuff);
+
+					sendbuff[len1] = 0x0D;
+					sendbuff[len1+1] = 0x0A;
+
+
+					uart_msg_send(UART1_ID, sendbuff, strlen(sendbuff));
+			}
+			else if(strstr((char*)data,"AT+EEPROMERASE="))//擦除整片eeprom
+			{
+				p_data = strstr((char*)data,"AT+EEPROMERASE=");
+				if(strstr(p_data,"\r\n"))
+				{
+					result = sscanf((char*)p_data,"AT+EEPROMERASE=%[^,]\r\n",type);
+					sscanf(type,"%04X",&device_type); // 设备类型
+					if(device_type_cmp(SOFTWARE_VERSION_APP,(u16)device_type) == 0)
+					{
+							uart_msg_send(UART1_ID, (char *)answer[6], strlen(answer[6]));
+							memset(&rcv_buf_pt,0,sizeof(rcv_buf_pt));
+							return;
+					}
+					
+					eeprom_addr = 0;
+					memset(eeprom_buf,0,EEPROM_BUF_LEN);
+
+					for(i = 0; i < EEPROM_PAGE; i++)
+					{
+						AT24CXX_Write(eeprom_addr, eeprom_buf, EEPROM_BUF_LEN);
+						eeprom_addr += EEPROM_BUF_LEN;
+					}
+					
+					uart_msg_send(UART1_ID, (char *)answer[5], strlen(answer[5]));
+					
+					//清除接收数据FIFO
+					uart_blocking_read((char *)tempbuff, UART_DEBUG, 1);
+				}
+			}
+			else if(strstr((char*)data,"AT+RST\r\n"))//复位
+			{
+				uart_msg_send(UART1_ID, (char *)answer[7], strlen(answer[7]));
+				OSTimeDlyHMSM(0, 0, 0, 100, OS_OPT_TIME_DLY, &err);
+				NVIC_SystemReset();
+			}
+			else if(strstr((char*)data,"AT+EEPROMWR="))//测外部eeprom写
+			{
+				p_data=strstr((char*)data,"AT+EEPROMWR=");
+				if(strstr(p_data,"\r\n"))
+				{
+					memset(tempbuff,0,sizeof(tempbuff));
+					result = sscanf((char*)p_data,"AT+EEPROMWR=%[^,],%[^,],%[^,]\r\n",eepaddr,eeplen,tempbuff);
+
+					sscanf(eepaddr,"%04X",&eep_addr); //地址
+					sscanf(eeplen,"%04X",&eep_len);  //长度
+					eep_len_temp = asciitohex(tempbuff,eeprom_buf,strlen(tempbuff)-2);			
+					
+					if(eep_len == eep_len_temp) //OK
+					{
+						AT24CXX_Write(eep_addr,(uint8_t *)eeprom_buf,eep_len);
+						uart_msg_send(UART1_ID, (char *)answer[8], strlen(answer[8]));
+					}
+					else//ERR
+					{
+						uart_msg_send(UART1_ID, (char *)answer[9], strlen(answer[9]));
+					}
+				}
+				
+			}
+			else if(strstr((char*)data,"AT+EEPROMRD="))//测外部eeprom读
+			{
+				p_data=strstr((char*)data,"AT+EEPROMRD=");
+				if(strstr(p_data,"\r\n"))
+				{
+					result = sscanf((char*)p_data,"AT+EEPROMRD=%[^,],%[^,]\r\n",eepaddr,eeplen);
+
+					sscanf(eepaddr,"%04X",&eep_addr); //地址
+					sscanf(eeplen,"%04X",&eep_len);  //长度
+					
+					AT24CXX_Read(eep_addr,eeprom_buf,eep_len);
+					
+					memset(Send_Buf_Char,0,sizeof(Send_Buf_Char));
+					gw_net_send_02((char*)eeprom_buf,eep_len,&len11);
+					
+					memset(sendbuff,0,sizeof(sendbuff));
+					strcpy(sendbuff,"+EEPROMRD:"); // 文件头
+					
+					memset(tempbuff,0,sizeof(tempbuff));
+					len11 = sprintf(tempbuff,"%04x,%04x,",eep_addr,eep_len);
+					strcat(sendbuff,tempbuff);
+					
+					strcat(sendbuff,Send_Buf_Char);
+					
+					len1 = strlen(sendbuff);
+
+					sendbuff[len1] = 0x0D;
+					sendbuff[len1+1] = 0x0A;
+
+
+					uart_msg_send(UART1_ID, sendbuff, strlen(sendbuff));	
+				}
+			}
+			else if(strstr((char*)data,"AT+INITLORAPARAINDEX=WBJW,")) //写LoRa参数当前组索引号
+			{
+				p_data=strstr((char*)data,"AT+INITLORAPARAINDEX=WBJW,");
+				if(strstr(p_data,"\r\n"))
+				{
+					result = sscanf((char*)p_data,"AT+INITLORAPARAINDEX=WBJW,%[^,]\r\n",type);
+					sscanf(type,"%u",&lora_index); // 设备类型
+					if(lora_index < LORA_GROUP_MAX)//正确
+					{
+						eepaddr[0] = lora_index;
+						eepaddr[1] = ~eepaddr[0];
+						AT24CXX_Write(LORA_ADDR,(uint8_t *)eepaddr,2);
+						uart_msg_send(UART1_ID, (char *)answer[10], strlen(answer[10]));
+					}
+					else
+					{
+						uart_msg_send(UART1_ID, (char *)answer[11], strlen(answer[11]));
+					}
+				}
+			}
+			else if(strstr((char*)data,"AT+LORAPARAINDEX\r\n")) //读LoRa参数当前组索引号
+			{
+				memset(sendbuff,0,sizeof(sendbuff));
+				strcpy(sendbuff,"+LORAPARAINDEX:"); // 文件头
+				
+				AT24CXX_Read(LORA_ADDR,(uint8_t *)eepaddr,2);
+				
+				memset(tempbuff,0,sizeof(tempbuff));
+				sprintf(tempbuff,"%u",eepaddr[0]);
+				strcat(sendbuff,tempbuff);
+				
+				len1 = strlen(sendbuff);
+				sendbuff[len1] = 0x0D;
+				sendbuff[len1+1] = 0x0A;
+				uart_msg_send(UART1_ID, sendbuff, strlen(sendbuff));
+			}
+			else if(strstr((char*)data,"AT+ENCRYPT\r\n")) //读连接器加密状态
+			{
+				memset(sendbuff,0,sizeof(sendbuff));
+				strcpy(sendbuff,"+ENCRYPT:"); // 文件头
+				
+				memset(tempbuff,0,sizeof(tempbuff));
+				sprintf(tempbuff,"%u",device_fixed_info.Encrypt);
+				strcat(sendbuff,tempbuff);
+				
+				len1 = strlen(sendbuff);
+				sendbuff[len1] = 0x0D;
+				sendbuff[len1+1] = 0x0A;
+				uart_msg_send(UART1_ID, sendbuff, strlen(sendbuff));
+			}
+			else if(strstr((char*)data,"AT+OFFLINE=")) //测试。下发离线升级指令
+			{
+				p_data=strstr((char*)data,"AT+OFFLINE=");
+				if(strstr(p_data,"\r\n"))
+				{
+					result = sscanf((char*)p_data,"AT+OFFLINE=%[^,],%[^,],%[^,]\r\n",master_snb,slave_snb,des_snb);
+
+					sscanf(master_snb,"%u",&master_sn);
+					sscanf(slave_snb,"%u",&slave_sn);
+					sscanf(des_snb,"%u",&des_sn);
+
+					if(slave_sn != des_sn)//失败
+					{
+						uart_msg_send(UART1_ID, (char *)answer[13], strlen(answer[13]));
+						printf("slave sn:%010u, des sn:%010u\n",slave_sn,des_sn);
+					}
+					else //成功
+					{
+						uart_msg_send(UART1_ID, (char *)answer[12], strlen(answer[12]));
+
+						//退出产测
+						g_ptTest.bTestStart = PT_OFF;
+						uart_msg_send(UART1_ID, (char *)answer[2], strlen(answer[2]));
+						
+						if(device_info.alrd == DEVICE_ALRD)//已初始化
+						{
+							device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL;
+						}
+						else
+						{
+							device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT;
+							//未初始化时，将设备sn置为0xffffffff；设备类型是默认的
+							device_info.device_id = 0xffffffff;
+							device_info.device_type = (SOFTWARE_VERSION_APP&0xffff0000)>>16;
+						}
+
+						//Lora发送命令
+						lora_offline_update(master_sn,slave_sn,des_sn);
+					}
+					
+				}
+			}
+		}
+		
+		memset(&rcv_buf_pt,0,sizeof(rcv_buf_pt));
+
+}
+

APP/command/uart_conf3333.h

@@ -0,0 +1,15 @@
+#ifndef __UART_CONF_H__
+#define __UART_CONF_H__
+
+#include "stm32f10x.h"
+
+#define USART1_BUF_SIZE 					256			//接收一、二级缓冲区大小，缺省值2000
+
+typedef struct _PT_TEST_{
+    uint8_t bTestStart; // 产测开始
+
+}PtTest;
+extern PtTest g_ptTest;
+void uart_cmd_task(uint8_t *data, uint8_t len);
+#endif
+

APP/des/des.c

@@ -0,0 +1,798 @@
+//#include "..\SourceFile\Main.h"
+#include ".\des.h"
+
+#define EN0    0    /* MODE == encrypt */
+#define DE1    1    /* MODE == decrypt */
+
+
+
+void scrunch(uint8 *, uint32 *);
+void unscrun(uint32 *, uint8 *);
+void desfunc(uint32 *, uint32 *);
+
+//uint32 KnL[32] = { 0L };
+//uint32 KnR[32] = { 0L };
+//uint32 Kn3[32] = { 0L };
+
+uint16 const bytebit[8] = {
+      0200, 0100, 040, 020, 010, 04, 02, 01 };
+
+uint32 const bigbyte[24] = {
+   0x800000L,    0x400000L,    0x200000L,    0x100000L,
+   0x80000L,    0x40000L,    0x20000L,    0x10000L,
+   0x8000L,    0x4000L,    0x2000L,    0x1000L,
+   0x800L,     0x400L,     0x200L,     0x100L,
+   0x80L,        0x40L,        0x20L,        0x10L,
+   0x8L,        0x4L,        0x2L,        0x1L };
+
+/* Use the key schedule specified in the Standard (ANSI X3.92-1981). */
+
+uint8 const pc1[56] = {
+   56, 48, 40, 32, 24, 16,  8,     0, 57, 49, 41, 33, 25, 17,
+    9,  1, 58, 50, 42, 34, 26,    18, 10,  2, 59, 51, 43, 35,
+   62, 54, 46, 38, 30, 22, 14,     6, 61, 53, 45, 37, 29, 21,
+   13,  5, 60, 52, 44, 36, 28,    20, 12,  4, 27, 19, 11,  3 };
+
+uint8 const totrot[16] = {
+    1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28 };
+
+uint8 const pc2[48] = {
+    13, 16, 10, 23,  0,  4,  2, 27, 14,  5, 20,  9,
+    22, 18, 11,  3, 25,  7, 15,  6, 26, 19, 12,  1,
+    40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,
+    43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31 };
+
+//===============================
+//S Box
+//{/*{{{*/
+uint32 const SP1[64] = {
+    0x01010400L, 0x00000000L, 0x00010000L, 0x01010404L,
+    0x01010004L, 0x00010404L, 0x00000004L, 0x00010000L,
+    0x00000400L, 0x01010400L, 0x01010404L, 0x00000400L,
+    0x01000404L, 0x01010004L, 0x01000000L, 0x00000004L,
+    0x00000404L, 0x01000400L, 0x01000400L, 0x00010400L,
+    0x00010400L, 0x01010000L, 0x01010000L, 0x01000404L,
+    0x00010004L, 0x01000004L, 0x01000004L, 0x00010004L,
+    0x00000000L, 0x00000404L, 0x00010404L, 0x01000000L,
+    0x00010000L, 0x01010404L, 0x00000004L, 0x01010000L,
+    0x01010400L, 0x01000000L, 0x01000000L, 0x00000400L,
+    0x01010004L, 0x00010000L, 0x00010400L, 0x01000004L,
+    0x00000400L, 0x00000004L, 0x01000404L, 0x00010404L,
+    0x01010404L, 0x00010004L, 0x01010000L, 0x01000404L,
+    0x01000004L, 0x00000404L, 0x00010404L, 0x01010400L,
+    0x00000404L, 0x01000400L, 0x01000400L, 0x00000000L,
+    0x00010004L, 0x00010400L, 0x00000000L, 0x01010004L };
+
+uint32 const SP2[64] = {
+    0x80108020L, 0x80008000L, 0x00008000L, 0x00108020L,
+    0x00100000L, 0x00000020L, 0x80100020L, 0x80008020L,
+    0x80000020L, 0x80108020L, 0x80108000L, 0x80000000L,
+    0x80008000L, 0x00100000L, 0x00000020L, 0x80100020L,
+    0x00108000L, 0x00100020L, 0x80008020L, 0x00000000L,
+    0x80000000L, 0x00008000L, 0x00108020L, 0x80100000L,
+    0x00100020L, 0x80000020L, 0x00000000L, 0x00108000L,
+    0x00008020L, 0x80108000L, 0x80100000L, 0x00008020L,
+    0x00000000L, 0x00108020L, 0x80100020L, 0x00100000L,
+    0x80008020L, 0x80100000L, 0x80108000L, 0x00008000L,
+    0x80100000L, 0x80008000L, 0x00000020L, 0x80108020L,
+    0x00108020L, 0x00000020L, 0x00008000L, 0x80000000L,
+    0x00008020L, 0x80108000L, 0x00100000L, 0x80000020L,
+    0x00100020L, 0x80008020L, 0x80000020L, 0x00100020L,
+    0x00108000L, 0x00000000L, 0x80008000L, 0x00008020L,
+    0x80000000L, 0x80100020L, 0x80108020L, 0x00108000L };
+
+uint32 const SP3[64] = {
+    0x00000208L, 0x08020200L, 0x00000000L, 0x08020008L,
+    0x08000200L, 0x00000000L, 0x00020208L, 0x08000200L,
+    0x00020008L, 0x08000008L, 0x08000008L, 0x00020000L,
+    0x08020208L, 0x00020008L, 0x08020000L, 0x00000208L,
+    0x08000000L, 0x00000008L, 0x08020200L, 0x00000200L,
+    0x00020200L, 0x08020000L, 0x08020008L, 0x00020208L,
+    0x08000208L, 0x00020200L, 0x00020000L, 0x08000208L,
+    0x00000008L, 0x08020208L, 0x00000200L, 0x08000000L,
+    0x08020200L, 0x08000000L, 0x00020008L, 0x00000208L,
+    0x00020000L, 0x08020200L, 0x08000200L, 0x00000000L,
+    0x00000200L, 0x00020008L, 0x08020208L, 0x08000200L,
+    0x08000008L, 0x00000200L, 0x00000000L, 0x08020008L,
+    0x08000208L, 0x00020000L, 0x08000000L, 0x08020208L,
+    0x00000008L, 0x00020208L, 0x00020200L, 0x08000008L,
+    0x08020000L, 0x08000208L, 0x00000208L, 0x08020000L,
+    0x00020208L, 0x00000008L, 0x08020008L, 0x00020200L };
+
+uint32 const SP4[64] = {
+    0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,
+    0x00802080L, 0x00800081L, 0x00800001L, 0x00002001L,
+    0x00000000L, 0x00802000L, 0x00802000L, 0x00802081L,
+    0x00000081L, 0x00000000L, 0x00800080L, 0x00800001L,
+    0x00000001L, 0x00002000L, 0x00800000L, 0x00802001L,
+    0x00000080L, 0x00800000L, 0x00002001L, 0x00002080L,
+    0x00800081L, 0x00000001L, 0x00002080L, 0x00800080L,
+    0x00002000L, 0x00802080L, 0x00802081L, 0x00000081L,
+    0x00800080L, 0x00800001L, 0x00802000L, 0x00802081L,
+    0x00000081L, 0x00000000L, 0x00000000L, 0x00802000L,
+    0x00002080L, 0x00800080L, 0x00800081L, 0x00000001L,
+    0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,
+    0x00802081L, 0x00000081L, 0x00000001L, 0x00002000L,
+    0x00800001L, 0x00002001L, 0x00802080L, 0x00800081L,
+    0x00002001L, 0x00002080L, 0x00800000L, 0x00802001L,
+    0x00000080L, 0x00800000L, 0x00002000L, 0x00802080L };
+
+uint32 const SP5[64] = {
+    0x00000100L, 0x02080100L, 0x02080000L, 0x42000100L,
+    0x00080000L, 0x00000100L, 0x40000000L, 0x02080000L,
+    0x40080100L, 0x00080000L, 0x02000100L, 0x40080100L,
+    0x42000100L, 0x42080000L, 0x00080100L, 0x40000000L,
+    0x02000000L, 0x40080000L, 0x40080000L, 0x00000000L,
+    0x40000100L, 0x42080100L, 0x42080100L, 0x02000100L,
+    0x42080000L, 0x40000100L, 0x00000000L, 0x42000000L,
+    0x02080100L, 0x02000000L, 0x42000000L, 0x00080100L,
+    0x00080000L, 0x42000100L, 0x00000100L, 0x02000000L,
+    0x40000000L, 0x02080000L, 0x42000100L, 0x40080100L,
+    0x02000100L, 0x40000000L, 0x42080000L, 0x02080100L,
+    0x40080100L, 0x00000100L, 0x02000000L, 0x42080000L,
+    0x42080100L, 0x00080100L, 0x42000000L, 0x42080100L,
+    0x02080000L, 0x00000000L, 0x40080000L, 0x42000000L,
+    0x00080100L, 0x02000100L, 0x40000100L, 0x00080000L,
+    0x00000000L, 0x40080000L, 0x02080100L, 0x40000100L };
+
+uint32 const SP6[64] = {
+    0x20000010L, 0x20400000L, 0x00004000L, 0x20404010L,
+    0x20400000L, 0x00000010L, 0x20404010L, 0x00400000L,
+    0x20004000L, 0x00404010L, 0x00400000L, 0x20000010L,
+    0x00400010L, 0x20004000L, 0x20000000L, 0x00004010L,
+    0x00000000L, 0x00400010L, 0x20004010L, 0x00004000L,
+    0x00404000L, 0x20004010L, 0x00000010L, 0x20400010L,
+    0x20400010L, 0x00000000L, 0x00404010L, 0x20404000L,
+    0x00004010L, 0x00404000L, 0x20404000L, 0x20000000L,
+    0x20004000L, 0x00000010L, 0x20400010L, 0x00404000L,
+    0x20404010L, 0x00400000L, 0x00004010L, 0x20000010L,
+    0x00400000L, 0x20004000L, 0x20000000L, 0x00004010L,
+    0x20000010L, 0x20404010L, 0x00404000L, 0x20400000L,
+    0x00404010L, 0x20404000L, 0x00000000L, 0x20400010L,
+    0x00000010L, 0x00004000L, 0x20400000L, 0x00404010L,
+    0x00004000L, 0x00400010L, 0x20004010L, 0x00000000L,
+    0x20404000L, 0x20000000L, 0x00400010L, 0x20004010L };
+
+uint32 const SP7[64] = {
+    0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L,
+    0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L,
+    0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L,
+    0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L,
+    0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L,
+    0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L,
+    0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L,
+    0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L,
+    0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L,
+    0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L,
+    0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L,
+    0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L,
+    0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L,
+    0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L,
+    0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L,
+    0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L };
+
+uint32 const SP8[64] = {
+    0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L,
+    0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L,
+    0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L,
+    0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L,
+    0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L,
+    0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L,
+    0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L,
+    0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L,
+    0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L,
+    0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L,
+    0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L,
+    0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L,
+    0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L,
+    0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L,
+    0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L,
+    0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L };
+///}/*}}}*/
+//===============================
+
+void MyMemCopy(uint8 * _aimMem,uint8 * _surMem,uint32 _len)
+{/*{{{*/
+    uint32 i;
+    for(i=0;i<_len;i++)
+        _aimMem[i]=_surMem[i];
+}/*}}}*/
+
+void MyMemSet(uint8 * _mem,uint32 _val,uint32 _len)
+{/*{{{*/
+    uint32 i;
+    for(i=0;i<_len;i++)
+        _mem[i]=_val;
+}/*}}}*/
+
+void cookey(uint32 * raw1,uint32 * _knBuff)
+{/*{{{*/
+    uint32 * cook, * raw0;
+    //uint32 dough[32];
+    int i;
+
+    cook = _knBuff;
+    for (i = 0; i < 16; i++, raw1++)
+    {
+        raw0 = raw1++;
+        *cook = (*raw0 & 0x00fc0000L) << 6;
+        *cook |= (*raw0 & 0x00000fc0L) << 10;
+        *cook |= (*raw1 & 0x00fc0000L) >> 10;
+        *cook++ |= (*raw1 & 0x00000fc0L) >> 6;
+        *cook = (*raw0 & 0x0003f000L) << 12;
+        *cook |= (*raw0 & 0x0000003fL) << 16;
+        *cook |= (*raw1 & 0x0003f000L) >> 4;
+        *cook++ |= (*raw1 & 0x0000003fL);
+    }
+    //MyMemCopy((uint8 *)_knBuff,(uint8 *)dough, 32 * 4);
+    return;
+}/*}}}*/
+
+void deskey(uint8 * key,uint32 * _knBuff,uint8 edf) 
+{/*{{{*/
+    uint8 i, j, l, m, n;
+    uint8 pc1m[56], pcr[56];
+    uint32 kn[32];
+
+    for (j = 0; j < 56; j++)
+    {
+        l = pc1[j];
+        m = l & 07;
+        pc1m[j] = (key[l >> 3] & bytebit[m]) ? 1 : 0;
+    }
+    for (i = 0; i < 16; i++)
+    {
+        if (edf == DE1)
+            m = (15 - i) << 1;
+        else
+            m = i << 1;
+        n = m + 1;
+        kn[m] = kn[n] = 0L;
+        for (j = 0; j < 28; j++)
+        {
+            l = j + totrot[i];
+            if (l < 28)
+                pcr[j] = pc1m[l];
+            else
+                pcr[j] = pc1m[l - 28];
+        }
+        for (j = 28; j < 56; j++)
+        {
+            l = j + totrot[i];
+            if (l < 56)
+                pcr[j] = pc1m[l];
+            else
+                pcr[j] = pc1m[l - 28];
+        }
+        for (j = 0; j < 24; j++)
+        {
+            if (pcr[pc2[j]])
+                kn[m] |= bigbyte[j];
+            if (pcr[pc2[j + 24]])
+                kn[n] |= bigbyte[j];
+        }
+    }
+    cookey(kn,_knBuff);
+    return;
+}/*}}}*/
+
+void des(uint8 * inblock, uint8 * outblock,uint32 * _knBuff)
+{/*{{{*/
+    uint32 work[2];
+
+    scrunch(inblock, work);
+    desfunc(work, _knBuff);
+    unscrun(work, outblock);
+    return;
+}/*}}}*/
+
+void scrunch(uint8 * outof, uint32 * into)
+{/*{{{*/
+    uint8 * p = (uint8 *)into;
+
+    p[0] = outof[3];
+    p[1] = outof[2];
+    p[2] = outof[1];
+    p[3] = outof[0];
+
+    p += 4;
+    outof += 4;
+
+    p[0] = outof[3];
+    p[1] = outof[2];
+    p[2] = outof[1];
+    p[3] = outof[0];
+
+}/*}}}*/
+
+void unscrun(uint32 * outof, uint8 * into)
+{/*{{{*/
+    uint8 * p = (uint8 *)outof;
+
+    into[0] = p[3];
+    into[1] = p[2];
+    into[2] = p[1];
+    into[3] = p[0];
+
+    into += 4;
+    p += 4;
+
+    into[0] = p[3];
+    into[1] = p[2];
+    into[2] = p[1];
+    into[3] = p[0];
+}/*}}}*/
+
+void desfunc(uint32 * block, uint32 * keys)
+{/*{{{*/
+    uint32 fval, work, right, leftt;
+    int round;
+
+    leftt = block[0];
+    right = block[1];
+    work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;
+    right ^= work;
+    leftt ^= (work << 4);
+    work = ((leftt >> 16) ^ right) & 0x0000ffffL;
+    right ^= work;
+    leftt ^= (work << 16);
+    work = ((right >> 2) ^ leftt) & 0x33333333L;
+    leftt ^= work;
+    right ^= (work << 2);
+    work = ((right >> 8) ^ leftt) & 0x00ff00ffL;
+    leftt ^= work;
+    right ^= (work << 8);
+    right = ((right << 1) | ((right >> 31) & 1L)) & 0xffffffffL;
+    work = (leftt ^ right) & 0xaaaaaaaaL;
+    leftt ^= work;
+    right ^= work;
+    leftt = ((leftt << 1) | ((leftt >> 31) & 1L)) & 0xffffffffL;
+
+    for (round = 0; round < 8; round++)
+    {
+        work = (right << 28) | (right >> 4);
+        work ^= *keys++;
+        fval = SP7[(int)(work & 0x3fL)];
+        fval |= SP5[(int)((work >> 8) & 0x3fL)];
+        fval |= SP3[(int)((work >> 16) & 0x3fL)];
+        fval |= SP1[(int)((work >> 24) & 0x3fL)];
+        work = right ^ *keys++;
+        fval |= SP8[(int)(work & 0x3fL)];
+        fval |= SP6[(int)((work >> 8) & 0x3fL)];
+        fval |= SP4[(int)((work >> 16) & 0x3fL)];
+        fval |= SP2[(int)((work >> 24) & 0x3fL)];
+        leftt ^= fval;
+        work = (leftt << 28) | (leftt >> 4);
+        work ^= *keys++;
+        fval = SP7[(int)(work & 0x3fL)];
+        fval |= SP5[(int)((work >> 8) & 0x3fL)];
+        fval |= SP3[(int)((work >> 16) & 0x3fL)];
+        fval |= SP1[(int)((work >> 24) & 0x3fL)];
+        work = leftt ^ *keys++;
+        fval |= SP8[(int)(work & 0x3fL)];
+        fval |= SP6[(int)((work >> 8) & 0x3fL)];
+        fval |= SP4[(int)((work >> 16) & 0x3fL)];
+        fval |= SP2[(int)((work >> 24) & 0x3fL)];
+        right ^= fval;
+    }
+
+    right = (right << 31) | (right >> 1);
+    work = (leftt ^ right) & 0xaaaaaaaaL;
+    leftt ^= work;
+    right ^= work;
+    leftt = (leftt << 31) | (leftt >> 1);
+    work = ((leftt >> 8) ^ right) & 0x00ff00ffL;
+    right ^= work;
+    leftt ^= (work << 8);
+    work = ((leftt >> 2) ^ right) & 0x33333333L;
+    right ^= work;
+    leftt ^= (work << 2);
+    work = ((right >> 16) ^ leftt) & 0x0000ffffL;
+    leftt ^= work;
+    right ^= (work << 16);
+    work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL;
+    leftt ^= work;
+    right ^= (work << 4);
+    *block++ = right;
+    *block = leftt;
+    return;
+}/*}}}*/
+
+void des2key(uint8 * hexkey,uint32 * _knBuff, uint8 mode)  /* stomps on Kn3 too */
+{/*{{{*/
+    uint8 revmod;
+
+    revmod = (mode == EN0) ? DE1 : EN0;
+    deskey(hexkey,_knBuff,mode);
+    MyMemCopy((uint8 *)(&_knBuff[64]), (uint8 *)_knBuff, 32 * 4);  // Kn3 = KnL
+    deskey(&hexkey[8],&_knBuff[32],revmod);
+    return;
+}/*}}}*/
+
+void des3key(uint8 * hexkey, uint32 * _knBuff,uint8 mode)  /* stomps on Kn3 too */
+{/*{{{*/
+    uint8 revmod;
+
+    revmod = (mode == EN0) ? DE1 : EN0;
+    deskey(hexkey,_knBuff,mode);
+    deskey(&hexkey[8],&_knBuff[32],revmod);
+    deskey(&hexkey[16],&_knBuff[64],mode);
+    return;
+}/*}}}*/
+
+void Ddes(uint8 * from, uint8 * into,uint32 * _knBuff)
+{/*{{{*/
+    uint32 work[2];
+
+    scrunch(from, work);
+    desfunc(work, _knBuff);
+    desfunc(work, _knBuff+32);
+    desfunc(work, _knBuff+64);
+    unscrun(work, into);
+    return;
+}/*}}}*/
+
+void D2des(uint8 * from, uint8 * into,uint32 * _knBuff)
+{/*{{{*/
+    uint32 * right, * l1, swap;
+    uint32 leftt[2], bufR[2];
+
+    right = bufR;
+    l1 = &leftt[1];
+    scrunch(from, leftt);
+    scrunch(&from[8], right);
+    desfunc(leftt, _knBuff);
+    desfunc(right, _knBuff);
+    swap = *l1;
+    *l1 = *right;
+    *right = swap;
+    desfunc(leftt, _knBuff+32);
+    desfunc(right, _knBuff+32);
+    swap = *l1;
+    *l1 = *right;
+    *right = swap;
+    desfunc(leftt, _knBuff+64);
+    desfunc(right, _knBuff+64);
+    unscrun(leftt, into);
+    unscrun(right, &into[8]);
+    return;
+}/*}}}*/
+
+void D3des(uint8 * from, uint8 * into,uint32 * _knBuff) /* amateur theatrics */
+{/*{{{*/
+    uint32 swap, leftt[2], middl[2], right[2];
+
+    scrunch(from, leftt);
+    scrunch(&from[8], middl);
+    scrunch(&from[16], right);
+    desfunc(leftt, _knBuff);
+    desfunc(middl, _knBuff);
+    desfunc(right, _knBuff);
+    swap = leftt[1];
+    leftt[1] = middl[0];
+    middl[0] = swap;
+    swap = middl[1];
+    middl[1] = right[0];
+    right[0] = swap;
+    desfunc(leftt, _knBuff+32);
+    desfunc(middl, _knBuff+32);
+    desfunc(right, _knBuff+32);
+    swap = leftt[1];
+    leftt[1] = middl[0];
+    middl[0] = swap;
+    swap = middl[1];
+    middl[1] = right[0];
+    right[0] = swap;
+    desfunc(leftt, _knBuff+64);
+    desfunc(middl, _knBuff+64);
+    desfunc(right, _knBuff+64);
+    unscrun(leftt, into);
+    unscrun(middl, &into[8]);
+    unscrun(right, &into[16]);
+    return;
+}/*}}}*/
+
+#if 0
+void DesOperate(uint8 * _inData,uint8 * _outData,uint8 * _key,uint32 _mode)
+{/*{{{*/
+    uint8 des_key[8];
+    uint8 plain[8];
+    uint8 encipher[8];
+    uint32 knBuff[32];
+
+    //MyMemSet(des_key, 0, sizeof(des_key));
+    //MyMemSet(plain, 0, 8);
+    MyMemSet(encipher, 0, 8);
+    MyMemCopy(plain, _inData, 8);
+    //MyMemCopy(encipher, _outData, 8);
+
+    MyMemCopy(des_key, _key, 8);
+    deskey(des_key,knBuff,_mode);
+    des(plain, encipher,knBuff);
+    MyMemCopy(_outData, encipher, 8);
+}/*}}}*/
+
+uint32 DesEncrypt(uint8 * _inData,uint8 * _outData,uint8 * _key,uint32 _len)
+{/*{{{*/
+    uint32 loops;
+    uint32 offset;
+
+    if((_len&0x07)!=0x00)
+        return False;
+    loops=(_len>>3);
+    offset=0;
+
+    do{
+        DesOperate(_inData+offset,_outData+offset,_key,EN0);
+        loops--;
+        offset+=8;
+    }while(loops>0);
+    return True;
+}/*}}}*/
+
+uint32 DesDecrypt(uint8 * _inData,uint8 * _outData,uint8 * _key,uint32 _len)
+{/*{{{*/
+    uint32 loops;
+    uint32 offset;
+
+    if((_len&0x07)!=0x00)
+        return False;
+    loops=(_len>>3);
+    offset=0;
+
+    do{
+        DesOperate(_inData+offset,_outData+offset,_key,DE1);
+        loops--;
+        offset+=8;
+    }while(loops>0);
+    return True;
+}/*}}}*/
+#else
+uint32 DesOperate(uint8 * _inData,uint8 * _outData,uint8 * _key, uint32 _len,uint32 _mode)
+{/*{{{*/
+    uint32 loops;
+    uint32 offset;
+
+    uint8 des_key[8];
+    uint8 plain[8];
+    uint8 encipher[8];
+    uint32 knBuff[32];
+
+    if((_len&0x07)!=0x00)
+        return False;
+    loops=(_len>>3);
+    offset=0;
+
+    MyMemCopy(des_key, _key, 8);
+    deskey(des_key,knBuff,_mode);
+    do{
+
+        //MyMemSet(_outData+offset, 0, 8);
+        MyMemSet(encipher, 0, 8);
+        MyMemCopy(plain, _inData+offset, 8);
+
+        des(plain, encipher,knBuff);
+        MyMemCopy(_outData+offset,encipher, 8);
+        //TripleDesOperate(_inData+offset,_outData+offset,_key,EN0);
+        loops--;
+        offset+=8;
+    }while(loops>0);
+    return True;
+}/*}}}*/
+#endif
+
+#if 0
+void TripleDesOperate(uint8 * _inData,uint8 * _outData,uint8 * _key,uint32 _mode)
+{/*{{{*/
+    uint8 des_key[16];
+    uint8 plain[8];
+    uint8 encipher[8];
+    uint32 knBuff[32*3];
+
+    //MyMemSet(des_key, 0, sizeof(des_key));
+    //MyMemSet(plain, 0, 8);
+    MyMemSet(encipher, 0, 8);
+    MyMemCopy(plain, _inData, 8);
+    //MyMemCopy(encipher, _outData, 8);
+    MyMemCopy(des_key, _key, 16);
+    des2key(des_key,knBuff,_mode);
+    Ddes(plain, encipher,knBuff);
+    MyMemCopy(_outData, encipher, 8);
+}/*}}}*/
+
+uint32 TripleDesEncrypt(uint8 * _inData,uint8 * _outData,uint8 * _key, uint32 _len)
+{/*{{{*/
+    uint32 loops;
+    uint32 offset;
+
+    if((_len&0x07)!=0x00)
+        return False;
+    loops=(_len>>3);
+    offset=0;
+
+    do{
+        TripleDesOperate(_inData+offset,_outData+offset,_key,EN0);
+        loops--;
+        offset+=8;
+    }while(loops>0);
+    return True;
+}/*}}}*/
+
+uint32 TripleDesDecrypt(uint8 * _inData,uint8 * _outData, uint8 * _key, uint32 _len)
+{/*{{{*/
+    uint32 loops;
+    uint32 offset;
+
+    if((_len&0x07)!=0x00)
+        return False;
+    loops=(_len>>3);
+    offset=0;
+
+    do{
+        TripleDesOperate(_inData+offset,_outData+offset,_key,DE1);
+        loops--;
+        offset+=8;
+    }while(loops>0);
+    return True;
+}/*}}}*/
+
+#else
+uint32 TripleDesOperate(uint8 * _inData,uint8 * _outData,uint8 * _key, uint32 _len,uint32 _mode)
+{/*{{{*/
+    uint32 loops;
+    uint32 offset;
+
+    uint8 des_key[16];
+    uint8 plain[8];
+    uint8 encipher[8];
+    uint32 knBuff[32*3];
+
+    if((_len&0x07)!=0x00)
+        return False;
+    loops=(_len>>3);
+    offset=0;
+
+    MyMemCopy(des_key, _key, 16);
+    des2key(des_key,knBuff,_mode);
+    do{
+
+        //MyMemSet(_outData+offset, 0, 8);
+        MyMemSet(encipher, 0, 8);
+        MyMemCopy(plain, _inData+offset, 8);
+
+        Ddes(plain,encipher,knBuff);
+        MyMemCopy(_outData+offset,encipher, 8);
+        //TripleDesOperate(_inData+offset,_outData+offset,_key,EN0);
+        loops--;
+        offset+=8;
+    }while(loops>0);
+    return True;
+}/*}}}*/
+#endif
+
+#if 0
+void TripleDesOperate3Key(uint8 * _inData,uint8 * _outData,uint8 * _key,uint32 _mode)
+{/*{{{*/
+    uint8 des_key[24];
+    uint8 plain[8];
+    uint8 encipher[8];
+    uint32 knBuff[32*3];
+
+    //MyMemSet(des_key, 0, sizeof(des_key));
+    //MyMemSet(plain, 0, 10);
+    MyMemSet(encipher, 0, 8);
+    MyMemCopy(plain, _inData, 8);
+    //MyMemCopy(encipher, _outData, 8);
+    MyMemCopy(des_key, _key, 24);
+    des3key(des_key,knBuff,_mode);
+    Ddes(plain, encipher,knBuff);
+    MyMemCopy(_outData, encipher, 8);
+}/*}}}*/
+
+uint32 TripleDesEncrypt3Key(uint8 * _inData,uint8 * _outData,uint8 * _key, uint32 _len)
+{/*{{{*/
+    uint32 loops;
+    uint32 offset;
+
+    if((_len&0x07)!=0x00)
+        return False;
+    loops=(_len>>3);
+    offset=0;
+
+    do{
+        TripleDesOperate3Key(_inData+offset,_outData+offset,_key,EN0);
+        loops--;
+        offset+=8;
+    }while(loops>0);
+    return True;
+}/*}}}*/
+
+uint32 TripleDesDecrypt3Key(uint8 * _inData,uint8 * _outData, uint8 * _key, uint32 _len)
+{/*{{{*/
+    uint32 loops;
+    uint32 offset;
+
+    if((_len&0x07)!=0x00)
+        return False;
+    loops=(_len>>3);
+    offset=0;
+
+    do{
+        TripleDesOperate3Key(_inData+offset,_outData+offset,_key,DE1);
+        loops--;
+        offset+=8;
+    }while(loops>0);
+    return True;
+}/*}}}*/
+#else
+uint32 TripleDesOperate3Key(uint8 * _inData,uint8 * _outData,uint8 * _key, uint32 _len,uint32 _mode)
+{/*{{{*/
+    uint32 loops;
+    uint32 offset;
+
+    uint8 des_key[24];
+    uint8 plain[8];
+    uint8 encipher[8];
+    uint32 knBuff[32*3];
+
+    if((_len&0x07)!=0x00)
+        return False;
+    loops=(_len>>3);
+    offset=0;
+
+    MyMemCopy(des_key, _key, 24);
+    des3key(des_key,knBuff,_mode);
+    do{
+
+        //MyMemSet(_outData+offset, 0, 8);
+        MyMemSet(encipher, 0, 8);
+        MyMemCopy(plain, _inData+offset, 8);
+
+        Ddes(plain,encipher,knBuff);
+        MyMemCopy(_outData+offset,encipher, 8);
+        //TripleDesOperate(_inData+offset,_outData+offset,_key,EN0);
+        loops--;
+        offset+=8;
+    }while(loops>0);
+    return True;
+}/*}}}*/
+#endif
+
+uint32 DesEncryptFunc(uint8 * _inData,uint8 *_outData,uint8 * _key,uint32 _len,uint32 _keyLen)
+{/*{{{*/
+    if(_keyLen==E_DKL_DES)
+        return DesOperate(_inData,_outData,_key,_len,EN0);
+        //return DesEncrypt(_inData,_outData,_key,_len);
+    else if(_keyLen==E_DKL_TRIPLE16)
+        return TripleDesOperate(_inData,_outData,_key,_len,EN0);
+        //return TripleDesEncrypt(_inData,_outData,_key,_len);
+    else if(_keyLen==E_DKL_TRIPLE24)
+        return TripleDesOperate3Key(_inData,_outData,_key,_len,EN0);
+        //return TripleDesEncrypt3Key(_inData,_outData,_key,_len);
+    else 
+        return False;
+}/*}}}*/
+
+uint32 DesDecryptFunc(uint8 * _inData,uint8 *_outData,uint8 * _key,uint32 _len,uint32 _keyLen)
+{/*{{{*/
+    if(_keyLen==E_DKL_DES)
+        return DesOperate(_inData,_outData,_key,_len,DE1);
+        //return DesDecrypt(_inData,_outData,_key,_len);
+    else if(_keyLen==E_DKL_TRIPLE16)
+        return TripleDesOperate(_inData,_outData,_key,_len,DE1);
+        //return TripleDesDecrypt(_inData,_outData,_key,_len,DE1);
+    else if(_keyLen==E_DKL_TRIPLE24)
+        return TripleDesOperate3Key(_inData,_outData,_key,_len,DE1);
+        //return TripleDesDecrypt3Key(_inData,_outData,_key,_len);
+    else 
+        return False;
+}/*}}}*/
+
+
+
+
+
+
+
+
+

APP/des/des.h

@@ -0,0 +1,56 @@
+#ifndef __DES_H__
+#define __DES_H__
+
+//#include "..\CommFiles\DataTypeDefine.h"
+#include "stm32f10x.h"
+		
+#define uint8  uint8_t
+#define uint16 uint16_t
+#define uint32 uint32_t
+
+#ifndef FALSE
+#define FALSE			0
+#endif
+#ifndef TRUE
+#define TRUE			1
+#endif
+
+#define False FALSE
+#define True  TRUE
+    
+    typedef struct STRUCT_DES_KEY_STRUCT
+    {
+        uint8 keyA[8];
+        uint8 keyB[8];
+        uint8 keyC[8];
+    }STRUCT_DES_KEY;
+    #define DES_KEY_LEN sizeof(STRUCT_DES_KEY)
+
+    typedef union UNION_DES_KEY_UNION
+    {
+        STRUCT_DES_KEY sDesKey;
+        uint8 unionArray[DES_KEY_LEN];
+    }UNION_DES_KEY;
+
+    typedef enum {
+        E_DKL_DES=8,            //8×Ö½ÚÃÜÔ¿
+        E_DKL_TRIPLE16=16,        //16×Ö½ÚÃÜÔ¿
+        E_DKL_TRIPLE24=24        //24×Ö½ÚÃÜÔ¿
+    }E_DES_KEY_LEN;
+
+#if 0
+    uint32 DesEncrypt(uint8 * _inData,uint8 * _outData,uint8 * _key,uint32 _len);
+    uint32 DesDecrypt(uint8 * _inData,uint8 * _outData,uint8 * _key,uint32 _len);
+    uint32 TripleDesEncrypt(uint8 * _inData,uint8 * _outData,uint8 * _key, uint32 _len);
+    uint32 TripleDesDecrypt(uint8 * _inData,uint8 * _outData, uint8 * _key, uint32 _len);
+    uint32 TripleDesEncrypt3Key(uint8 * _inData,uint8 * _outData,uint8 * _key, uint32 _len);
+    uint32 TripleDesDecrypt3Key(uint8 * _inData,uint8 * _outData, uint8 * _key, uint32 _len);
+#endif
+    uint32 DesEncryptFunc(uint8 * _inData,uint8 *_outData,uint8 * _key,uint32 _len,uint32 _keyLen);
+    uint32 DesDecryptFunc(uint8 * _inData,uint8 *_outData,uint8 * _key,uint32 _len,uint32 _keyLen);
+
+
+#endif
+
+
+

APP/des/说明.txt

@@ -0,0 +1,8 @@
+
+
+1、本文件中的所有函数均支持一次运算多个数据包
+2、为了加快多包运算速度，函数中定义了一个暂存交换密钥的局部变量数组(knBuff)，比较长，当采用3DES算法时，为384bytes，如果不想使此变量数组占用栈数据，可以定位为全局变量来节省栈的开销
+3、文件中的uint8,uint32,uint16需要根据程序自定义一下
+4、运算效率：单个包加解密，再CPU=50MHz时，一次运算大概2.3ms，两个包，一次运算2.4左右，依次类推
+
+

APP/dev_mgr/common/device.c

@@ -0,0 +1,107 @@
+#include "includes.h"
+#include "device.h"
+#include "net_proc.h"
+
+gb_device_info_t	dev_mgr;
+
+void device_info_dump(inner_msg_format_t *p_msg)
+{
+	gb_device_info_t *p_dev = (gb_device_info_t *)p_msg->info;
+	
+	printf("frame_header: 0x%04x\r\n", p_msg->frame_header);
+	printf("fcs: 0x%04x\r\n", p_msg->fcs);
+	printf("seq_no: 0x%08x\r\n", p_msg->seq_no);
+	printf("proto_ver: 0x%02x\r\n", p_msg->proto_ver);
+	printf("type: 0x%02x\r\n", p_msg->type);
+	printf("len: 0x%04x\r\n", p_msg->len);
+	printf("vendor: %s\r\n", p_dev->vendor);
+	printf("hw_ver: 0x%08x\r\n", p_dev->hw_ver);
+	printf("manufacture_date: %d\r\n", p_dev->manufacture_date);
+	printf("bootrom_ver: 0x%08x\r\n", p_dev->bootrom_ver);
+	printf("bootrom_date: %d\r\n", p_dev->bootrom_date);
+	printf("sw_ver: 0x%08x\r\n", p_dev->sw_ver);
+	printf("build_date: %d\r\n", p_dev->build_date);
+	printf("device_type: 0x%08x\r\n", p_dev->device_type);
+	printf("device_id: 0x%08x\r\n", p_dev->device_id);
+	printf("imei: %s\r\n", p_dev->imei);
+	printf("iccid: %s\r\n", p_dev->iccid);
+	printf("collect_time: %d\r\n", p_dev->collect_time);	
+}
+
+//void device_msg_timer(void *p_tmr, void *p_arg)
+//{
+//	inner_msg_format_t *p_msg = NULL;
+
+//	dev_mgr.collect_time = RTC_GetCounter();
+//	p_msg = (inner_msg_format_t *)net_queue_mem_calloc();
+//	if(p_msg) {
+//		memcpy(p_msg->info, &dev_mgr, sizeof(gb_device_info_t));
+//		net_msg_frame_fill(p_msg, net_msg_type_lot, sizeof(gb_device_info_t));
+//		//device_info_dump(p_msg);
+//		net_queue_insert((char *)p_msg, sizeof(inner_msg_format_t));
+//		//data_dump(MQTT_UPLINK_LOT_TOPIC, (uint8_t *)p_msg, sizeof(inner_msg_format_t));
+//	}
+//}
+
+int device_type_and_id_cmp(u16 device_type, u32 device_id)
+{
+	int ret = 0;
+
+        if(device_type != 0x0301) {
+            return ret;
+        }
+        else if(device_id == 0xFFFFFFFF) {
+		ret = 1;
+	} else {					
+		if((device_type == dev_mgr.device_type)&&
+				(device_id == dev_mgr.device_id)) {
+			ret = 1;
+		}
+	}
+
+	return ret;
+}
+
+void device_type_and_id_get(u32 *device_type, u32 *device_id)
+{
+	if(device_type) {
+		*device_type = dev_mgr.device_type;
+	}
+	if(device_id) {
+		*device_id = dev_mgr.device_id;
+	}
+}
+
+uint32_t device_type_get(void)
+{
+	return dev_mgr.device_type;
+}
+
+OS_TMR dev_timer;
+int device_init(u32 dev_type, u32 dev_id)
+{
+	OS_ERR err;
+	gb_device_info_t *p_dev_mgr = &dev_mgr;
+	uint32_t temp;
+
+	memset(p_dev_mgr, 0, sizeof(gb_device_info_t));
+	snprintf((char *)p_dev_mgr->vendor, sizeof(p_dev_mgr->vendor), "goldenbeans");
+	p_dev_mgr->sw_ver = SOFT_VERSION;
+	p_dev_mgr->build_date = 0;
+
+	/* read from e2prom. */
+	//AT24CXX_Read(0, (uint8_t *)&p_dev_mgr->device_type, 8);
+	p_dev_mgr->device_type = dev_type;
+	p_dev_mgr->device_id = dev_id;
+	p_dev_mgr->hw_ver = HARD_VERSION;
+	p_dev_mgr->manufacture_date = 0;
+	p_dev_mgr->bootrom_ver = BOOT_VERSION;
+	p_dev_mgr->bootrom_date = 0;
+
+	NET_IMEI_ICCID_INFO_GET((char *)p_dev_mgr->imei, (char *)p_dev_mgr->iccid);
+
+//	OSTmrCreate(&dev_timer, "device_tmr", DEVICE_MSG_PERIOD + 5, DEVICE_MSG_PERIOD, OS_OPT_TMR_PERIODIC, device_msg_timer, NULL, &err);
+//	OSTmrStart(&dev_timer, &err);	
+
+	return 0;
+}

APP/dev_mgr/common/device.h

@@ -0,0 +1,52 @@
+#ifndef _GB_DEVICE_INFO_H_
+#define _GB_DEVICE_INFO_H_
+
+typedef enum DEV_TYPE {
+	DEV_TYPE_COLLECT_STATION = 1,
+	DEV_TYPE_GATEWAY,		
+	DEV_TYPE_OILTANK_STATION,
+	DEV_TYPE_OILTANK_CAR,	
+	DEV_TYPE_OILTANK_DEPOT,	
+	
+	DEV_TYPE_MAX
+} DEV_TYPE;
+
+typedef enum ONLINE_TYPE {
+	ONLINE_TYPE_LORA = 1,
+	ONLINE_TYPE_NB,
+	ONLINE_TYPE_LTE,
+
+	ONLINE_TYPE_MAX
+} ONLINE_TYPE;
+
+#define SOFT_VERSION	0x01010001
+#define HARD_VERSION	0x01010001
+#define BOOT_VERSION	0x01010001
+#define DEVICE_TYPE		DEV_TYPE_COLLECT_STATION
+#define DEVICE_MSG_PERIOD 10
+
+#define DEVICE_ID_LENGTH	4
+typedef struct _gb_device_info {
+	uint8_t vendor[16];
+	uint32_t hw_ver;
+	uint32_t manufacture_date;
+	uint32_t bootrom_ver;
+	uint32_t bootrom_date;
+	uint32_t sw_ver;
+	uint32_t build_date;
+	uint32_t device_type;
+	uint32_t device_id;
+	uint8_t	imei[16];
+	uint8_t iccid[20];
+	uint32_t collect_time;
+} gb_device_info_t;
+
+#define		STORAGE_POS_DEVICE_TYPE		0
+#define		STORAGE_POS_DEVICE_ID		4
+
+int device_type_and_id_cmp(u16 device_type, u32 device_id);
+void device_type_and_id_get(u32 *device_type, u32 *device_id);
+uint32_t device_type_get(void);
+int device_init(u32 dev_type, u32 dev_id);
+
+#endif

APP/dev_mgr/gateway/gateway.c

@@ -0,0 +1,48 @@
+#include "includes.h"
+#include "device.h"
+#include "gateway.h"
+#include "net_proc.h"
+
+typedef struct _gb_gateway_info {
+	gb_gateway_bind_info_t bind;
+	u16 gw_echo_fail_count;
+	u16 node_echo_fail_count[GB_SUPPORT_MAX_NODE];
+} gb_gateway_info_t;
+
+gb_gateway_info_t gw_mgr;
+
+int gateway_gw_id_flush(u32 gw_device_id)
+{
+	int ret = 0;
+	gw_mgr.bind.gw_device_id = gw_device_id;
+	gw_mgr.gw_echo_fail_count = 0;
+	
+	return ret;
+}
+	
+int gateway_id_cmp(u32 gw_device_id)
+{
+	int ret = 0;
+	
+	if(gw_mgr.bind.gw_device_id == gw_device_id) {
+		ret = 1;
+	}
+
+	return ret;
+}
+
+int gateway_gw_id_get(u32 *gw_device_id)
+{
+	int ret = 0;
+
+	if(gw_device_id) {
+		*gw_device_id = gw_mgr.bind.gw_device_id;
+	}
+	
+	if(gw_mgr.bind.gw_device_id) {
+		ret = 1;
+	}
+	
+	return ret;
+}
+

APP/dev_mgr/gateway/gateway.h

@@ -0,0 +1,28 @@
+#ifndef _GB_GATEWAY_H_
+#define _GB_GATEWAY_H_
+
+#define GW_MSG_PERIOD 10
+
+typedef struct _gb_node_bind_info {
+	u32  gw_device_id;
+	u32  device_type;
+	u32  device_id;
+} gb_node_bind_info_t;
+
+#define GB_SUPPORT_MAX_NODE		12
+#define GATEWAY_ECHO_MAX_COUNT	10
+typedef struct _gb_node_info {
+	u32  device_type;
+	u32  device_id;
+} gb_node_info_t;
+
+typedef struct _gb_gateway_bind_info {
+	u32  gw_device_id;
+	gb_node_info_t node[GB_SUPPORT_MAX_NODE];
+} gb_gateway_bind_info_t;
+
+int gateway_gw_id_flush(u32 gw_device_id);
+int gateway_id_cmp(u32 gw_device_id);
+int gateway_gw_id_get(u32 *gw_device_id);
+
+#endif

APP/dev_mgr/gps/atgm336h.c

@@ -0,0 +1,149 @@
+/**********************************************************
+                                                作者：神秘藏宝室
+接线说明：
+STM32                                        GPS
+VCC                ------>        VCC
+GND                ------>        GND
+RX1                <------        TXD
+
+
+STM32                                        USB-TTL模块
+GND                ------>        GND
+TX1                ------>        RXD
+***********************************************************/
+
+#include "stm32f10x.h"
+#include "delay.h"
+#include "usart.h"
+#include "led.h"
+
+//声明
+void errorLog(int num);
+void parseGpsBuffer(void);
+void printGpsBuffer(void);
+
+int main(void)
+{        
+        delay_init();
+        
+        NVIC_Configuration();          //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
+        uart_init(9600);         //串口初始化为9600
+        Init_LEDpin();
+        LED1 = 1;
+        
+        clrStruct();
+        
+        printf("Welcome to use!\r\n");
+        printf("ILoveMcu.taobao.com!\r\n");
+        while(1)
+        {
+                parseGpsBuffer();
+                printGpsBuffer();
+               
+   
+        }
+}
+
+void errorLog(int num)
+{
+        
+        while (1)
+        {
+                  printf("ERROR%d\r\n",num);
+        }
+}
+
+void parseGpsBuffer()
+{
+        char *subString;
+        char *subStringNext;
+        char i = 0;
+        if (Save_Data.isGetData)
+        {
+                Save_Data.isGetData = false;
+                printf("**************\r\n");
+                printf(Save_Data.GPS_Buffer);
+
+               
+                for (i = 0 ; i <= 6 ; i++)
+                {
+                        if (i == 0)
+                        {
+                                if ((subString = strstr(Save_Data.GPS_Buffer, ",")) == NULL)
+                                        errorLog(1);        //解析错误
+                        }
+                        else
+                        {
+                                subString++;
+                                if ((subStringNext = strstr(subString, ",")) != NULL)
+                                {
+                                        char usefullBuffer[2];
+                                        switch(i)
+                                        {
+                                                case 1:memcpy(Save_Data.UTCTime, subString, subStringNext - subString);break;        //获取UTC时间
+                                                case 2:memcpy(usefullBuffer, subString, subStringNext - subString);break;        //获取UTC时间
+                                                case 3:memcpy(Save_Data.latitude, subString, subStringNext - subString);break;        //获取纬度信息
+                                                case 4:memcpy(Save_Data.N_S, subString, subStringNext - subString);break;        //获取N/S
+                                                case 5:memcpy(Save_Data.longitude, subString, subStringNext - subString);break;        //获取经度信息
+                                                case 6:memcpy(Save_Data.E_W, subString, subStringNext - subString);break;        //获取E/W
+
+                                                default:break;
+                                        }
+
+                                        subString = subStringNext;
+                                        Save_Data.isParseData = true;
+                                        if(usefullBuffer[0] == 'A')
+                                                Save_Data.isUsefull = true;
+                                        else if(usefullBuffer[0] == 'V')
+                                                Save_Data.isUsefull = false;
+
+                                }
+                                else
+                                {
+                                        errorLog(2);        //解析错误
+                                }
+                        }
+
+
+                }
+        }
+}
+
+void printGpsBuffer()
+{
+        if (Save_Data.isParseData)
+        {
+                Save_Data.isParseData = false;
+               
+                printf("Save_Data.UTCTime = ");
+                printf(Save_Data.UTCTime);
+                printf("\r\n");
+
+                if(Save_Data.isUsefull)
+                {
+                        Save_Data.isUsefull = false;
+                        printf("Save_Data.latitude = ");
+                        printf(Save_Data.latitude);
+                        printf("\r\n");
+
+
+                        printf("Save_Data.N_S = ");
+                        printf(Save_Data.N_S);
+                        printf("\r\n");
+
+                        printf("Save_Data.longitude = ");
+                        printf(Save_Data.longitude);
+                        printf("\r\n");
+
+                        printf("Save_Data.E_W = ");
+                        printf(Save_Data.E_W);
+                        printf("\r\n");
+                }
+                else
+                {
+                        printf("GPS DATA is not usefull!\r\n");
+                }
+               
+        }
+}
+

APP/dev_mgr/oiltank/oiltank.c

@@ -0,0 +1,274 @@
+#include "includes.h"
+#include "device.h"
+#include "tax_ctrl.h"
+#include "net_proc.h"
+#include "oiltank.h"
+
+typedef union {
+	u8	c[5];
+	u32 i;
+} uData_t;
+
+typedef union {
+	u32 i;
+	float f;
+} uData1_t;
+
+system_oiltank_info_t system_oiltank;
+
+//CRC校验（本质和校验）
+static u32 _check_sum(u8 buf[], u32 len)
+{
+    u32 i, check_sum = 0;
+	uData_t data;
+	
+    for(i=0; i< len; i++) {
+        check_sum += buf[i];
+    }
+#if 0
+	check_sum = ~check_sum;	
+    check_sum &= 0xffff;
+    check_sum += 1;
+#else
+  check_sum &= 0xffff;
+  check_sum = 0xffff-check_sum+1;
+#endif
+	snprintf(data.c, sizeof(data.c), "%04X", check_sum);
+    return data.i;
+}
+
+static u32 _str_to_hex(uint8_t *data)
+{
+	u8 i, ch;
+	u32 hex = 0;
+
+	//data_dump("====", data, 8);
+	for(i = 0;i < 8;i++) {
+		if(isdigit(data[i])) {
+			ch = data[i] - '0' + 0x0;
+		} else if(isalpha(data[i])){
+			ch = data[i] - 'A' + 0xA;
+		}
+		
+		hex = (hex<<4)|ch;
+	}
+
+	//printf("%08x, %0.2f\r\n", hex, (float)(hex));
+	return (hex);
+}
+
+int oiltank_data_update(I201_FUELTANK_DATA *p_data)
+{
+	uData1_t data;
+	oiltank_info_t *p_tank = NULL;
+	u8 id = 0;
+
+	id = p_data->TT[1] - '0';
+	if(id > OILTANK_VALID_COUNT) {
+		return 0;
+	}
+	//data_dump("******", (uint8_t * )p_data, YB_SS160_RCV_DATASIZE);
+	p_tank = &system_oiltank.oiltank[id];
+	printf("罐号: %c%c\r\n", p_data->TT[0], p_data->TT[1]);
+	printf("油品: %c\r\n", p_data->P);
+	printf("油罐状态: %c%c%c%c\r\n", p_data->SSSS[0], p_data->SSSS[1], p_data->SSSS[2], p_data->SSSS[3]);
+	printf("%c%c 组数据\r\n", p_data->NN[0], p_data->NN[1]);
+	p_tank->id = id;
+	BIT_SET(system_oiltank.valid, p_tank->id);
+	
+	p_tank->quality = p_data->P;
+	
+/*     首先来看单精度浮点型float。
+	float占用4字节空间，也就是32位。
+	从左向右数，第1位是符号位（0代表正数，1代表负数），接着是8位指数位，剩下的23位是数据位。如下所示
+	S EEEEEEEE DDDDDDDDDDDDDDDDDDDDDDD
+*/
+	
+	//1、容积；2、TC 容积；3、罐空；4 高度；5、水位；6、温度；7、水容积 
+	p_tank->volume = _str_to_hex(p_data->TankVolume);
+	printf("Tank Volume  : 0x%08x\r\n", p_tank->volume);
+	//printf("Tank Volume  :%0.2f\r\n", data.f);
+	p_tank->oil_volume = _str_to_hex(p_data->NetVolume);
+	//printf("Net Volume   :%0.2f\r\n", data.f);
+	data.i = _str_to_hex(p_data->CrossVolume);
+	//printf("Cross Volume :%0.2f\r\n", data.f);
+	p_tank->height = _str_to_hex(p_data->Height);
+	//printf("Height       :%0.2f\r\n", data.f);
+	data.i = _str_to_hex(p_data->Water);
+	//printf("Water        :%0.2f\r\n", data.f);
+	p_tank->temperature = _str_to_hex(p_data->Temp);
+	//printf("Temp         :%0.2f\r\n", data.f);
+	p_tank->water_volume = _str_to_hex(p_data->WaterVolume);
+	//printf("Water Volume :%0.2f\r\n", data.f);
+	p_tank->valid_num++;
+	
+	return 0;
+}
+
+int oiltank_YB_SS160_cmd_comm(uint8_t uart)
+{
+	int ret = -1;
+	uint8_t rcv_buf[1024], send_buf[128];
+	uint32_t i, rcv_size = 0, send_size = YB_SS160_SEND_SIZE, crc;
+	RS232_YB_SS160_SEND *p_tank_tx = (RS232_YB_SS160_SEND *)send_buf;
+	RS232_YB_SS160_RECEIVE_HEAD *p_tank_rx_head = (RS232_YB_SS160_RECEIVE_HEAD *)rcv_buf;
+	RS232_YB_SS160_RECEIVE_TAIL *p_tank_rx_tail = NULL;
+	I201_FUELTANK_DATA *p_data = NULL;
+	int FuelTank_Num = 0;
+	oiltank_info_t *p_tank = NULL;
+
+	/* 查询所有油管数据 */
+	//<SOH>i201TT,
+	/* <SOH>i201TT
+		YYMMDDHHmm 日期和时间（年/月/日/时/分）
+		TTpssssNNFFFFFFFF... 
+		TTpssssNNFFFFFFFF...
+		
+		&&CCCC<ETX> 
+	*/
+	p_tank_tx->SOH = 0x01;
+	strcpy((char *)p_tank_tx->FCN_CODE, "i20100");
+    p_tank_tx->EXT = 0x03;
+
+	data_dump("YB_SS160 oiltank send", send_buf, send_size);
+	uart_msg_send(uart, (char *)p_tank_tx, send_size);
+	rcv_size = uart_blocking_read((char *)rcv_buf, uart, 5000);
+	if(rcv_size) {
+		data_dump("YB_SS160 oiltank recv", rcv_buf, rcv_size);
+		if(memcmp((char *)p_tank_rx_head->FCN_CODE, "i20100", sizeof(p_tank_rx_head->FCN_CODE)) == 0) {
+			/* check sum */
+			p_tank_rx_tail = (RS232_YB_SS160_RECEIVE_TAIL *)(rcv_buf + rcv_size - YB_SS160_RCV_TAILSIZE);
+			crc = _check_sum(rcv_buf, rcv_size - YB_SS160_RCV_TAILSIZE + 2);
+			printf("headsize : %d, datasize : %d, tailsize : %d, rcv_size : %d, %x, %x, %x\r\n", 
+				YB_SS160_RCV_HEADSIZE,
+				YB_SS160_RCV_DATASIZE, 
+				YB_SS160_RCV_TAILSIZE, rcv_size,
+				p_tank_rx_tail->FCN_FLAG, p_tank_rx_tail->CheckCode , crc);
+			if((p_tank_rx_tail->FCN_FLAG == YB_SS160_FCN_FLAG)&&
+				(p_tank_rx_tail->CheckCode == crc)) {
+				rcv_size -= (YB_SS160_RCV_HEADSIZE + YB_SS160_RCV_TAILSIZE);
+				FuelTank_Num = rcv_size/YB_SS160_RCV_DATASIZE;
+				for(i = 0;i < FuelTank_Num;i++) {
+					p_data = (I201_FUELTANK_DATA *)(rcv_buf + YB_SS160_RCV_HEADSIZE + i*YB_SS160_RCV_DATASIZE);
+					oiltank_data_update(p_data);
+				}
+			}
+		}
+	}
+
+	for(i = 0;i < OILTANK_VALID_COUNT;i++) {		
+		if(BIT_IS_SET(system_oiltank.valid, 1<<system_oiltank.current)) {
+			p_tank = &system_oiltank.oiltank[i];
+			if(p_tank->valid_num == 0) {
+				BIT_CLC(system_oiltank.valid, i);
+				memset(p_tank, 0, sizeof(oiltank_info_t));
+			} else {
+				p_tank->valid_num = 0;
+			}
+		}
+	}
+
+	return ret;
+}
+		
+void oiltank_polling(void)
+{
+	uint8_t uart = OILTANK_UART;
+
+	YTSF_GPIO_RS485_RESET();
+	YTSF_GPIO_YTSF_RESET();
+	YTSF_GPIO_AB_SET();
+	oiltank_YB_SS160_cmd_comm(uart);
+}
+
+void oiltank_msg_timer(void *p_tmr, void *p_arg)
+{
+	inner_msg_format_t *p_msg = NULL;
+	uint32_t *p_collect_time = NULL, i;
+	gb_oiltank_header_t *p_oiltank_header = NULL;
+	oiltank_info_t *p_oiltank_info = NULL;
+
+	if(system_oiltank.valid == 0) {/* 没有有效数据 */
+		return ;
+	}
+	
+	p_msg = (inner_msg_format_t *)net_queue_mem_calloc();
+	if(p_msg == NULL) {
+		return ;
+	}
+	//HEADER
+	p_oiltank_header = (gb_oiltank_header_t *)p_msg->info;
+	device_type_and_id_get(&p_oiltank_header->device_type, &p_oiltank_header->device_id);
+	p_oiltank_header->device_status = 0;
+	p_oiltank_header->oiltank_count = 1;
+
+	//OILTANK_INFO
+	for(i = 0;i < OILTANK_VALID_COUNT;i++) {
+		system_oiltank.current += i + 1;
+		system_oiltank.current = system_oiltank.current%OILTANK_VALID_COUNT;
+		if(BIT_IS_SET(system_oiltank.valid, 1<<system_oiltank.current)) {
+			break;
+		}		
+	}
+
+	if(i == OILTANK_VALID_COUNT) {
+		return ;
+	}
+	p_oiltank_info = (oiltank_info_t *)(p_msg->info + GB_OILTANK_HEADER_LEN);
+#if 0
+	p_oiltank_info->id = 1;
+	p_oiltank_info->quality = QUALITY_95;
+	p_oiltank_info->volume = 100;
+	p_oiltank_info->oil_volume = 200;
+	p_oiltank_info->water_volume = 300;
+	p_oiltank_info->temperature = 50;
+	p_oiltank_info->height = 400;
+#else 
+	memcpy(p_oiltank_info, &system_oiltank.oiltank[system_oiltank.current], GB_OILTANK_INFO_LEN);
+#endif
+	//timestamp
+	p_collect_time = (uint32_t *)(p_msg->info + GB_OILTANK_HEADER_LEN + GB_OILTANK_INFO_LEN);
+	*p_collect_time = RTC_GetCounter();
+	net_msg_frame_fill(p_msg, net_msg_type_oiltank, GB_OILTANK_HEADER_LEN + GB_OILTANK_INFO_LEN + 4);
+	net_queue_insert((char *)p_msg, sizeof(inner_msg_format_t));
+	data_dump(MQTT_UPLINK_TANK_TOPIC, (uint8_t *)p_msg, sizeof(inner_msg_format_t));
+}
+
+OS_TMR oiltank_timer;
+int oiltank_init(void)
+{
+	OS_ERR err;
+	
+	//GUN CHECK，PC0 - PC 3
+	GPIO_COMM_Init(RCC_APB2Periph_GPIOC, GPIOC, 
+			GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 , GPIO_Mode_IN_FLOATING, GPIO_Speed_2MHz);
+
+	//SW_PORT_RS485、SW_PORT_AB、SW_PORT_CD、SW_PORT_YTSF
+	GPIO_COMM_Init(RCC_APB2Periph_GPIOD, GPIOD, GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6, GPIO_Mode_Out_PP, GPIO_Speed_2MHz);
+	
+	//YTSF_REV2
+	GPIO_COMM_Init(RCC_APB2Periph_GPIOD, GPIOD, GPIO_Pin_7, GPIO_Mode_IPU, GPIO_Speed_2MHz);
+
+	//YTSF_RST_N
+	GPIO_COMM_Init(RCC_APB2Periph_GPIOB, GPIOB, GPIO_Pin_5, GPIO_Mode_Out_PP, GPIO_Speed_2MHz);
+	YTSF_GPIO_EN();
+
+	//YTSF_POSITION_N
+	GPIO_COMM_Init(RCC_APB2Periph_GPIOB, GPIOB, GPIO_Pin_6, GPIO_Mode_IPU, GPIO_Speed_2MHz);
+
+	//YTSF_EN_N
+	GPIO_COMM_Init(RCC_APB2Periph_GPIOB, GPIOB, GPIO_Pin_7, GPIO_Mode_Out_PP, GPIO_Speed_2MHz);
+	YTSF_GPIO_DN();
+ 
+	OSTmrCreate(&oiltank_timer, "oiltank_tmr", 
+		OILTANK_MSG_PERIOD, OILTANK_MSG_PERIOD, OS_OPT_TMR_PERIODIC, oiltank_msg_timer, NULL, &err);
+	OSTmrStart(&oiltank_timer, &err);	
+	
+	YTSF_GPIO_DN();
+
+	memset(&system_oiltank, 0 ,sizeof(system_oiltank_info_t));
+	system_oiltank.valid = 0;
+	system_oiltank.current = 0;
+	
+	return 0;
+}

APP/dev_mgr/oiltank/oiltank.h

@@ -0,0 +1,120 @@
+#ifndef _OILTANK_H_
+#define _OILTANK_H_
+
+#define YB_SS160_SOH        0x01		//起始码<SOH> 
+#define YB_SS160_EXT        0x03		//结束标志位 
+
+#define YB_SS160_FCN_FLAG			0x2626//"&&"
+
+//波特率 9600，帧格式为：起始位 1，  数据位 8，停止位 1，共 10 位，无校验(N)。
+/*
+1 i201 读储油罐状态及数据 
+		读储油罐状态及数据，包括油罐的温度、水位、油位、水量、油量、标准油量等 信息。
+2 i205 读储油罐报警信息 
+		读取高低液位报警、水位过高报警、高低温度报警、油品泄漏报警、探针失灵报 警。
+3 i20C 读储油罐最近一次进油报告 
+4 i501 读取系统时间
+5 i602 读取油品数据 
+6 i607 读取油罐直径 
+7 s501 设置系统时间 
+8 i10100 系统状态 
+*/
+
+//SS160控制器后台通讯协发送
+typedef struct {
+    unsigned char                  SOH;              //协议头
+    unsigned char                  FCN_CODE[6];      //本机地址
+    unsigned char                  EXT;              //功能码或命令字
+} BYTE1 RS232_YB_SS160_SEND;
+
+//SS160控制器后台通讯协接收
+typedef struct {
+    u8                  SOH;               //协议头
+    u8                  FCN_CODE[4];       //实时数据命令为i201TT
+    u8					FuelTank_No[2];
+
+    //时间, YYMMDDHHmm 日期和时间（年/月/日/时/分）
+    u8                  year[2];           //年
+    u8                  month[2];          //月
+    u8                  date[2];           //日
+    u8                  hour[2];           //时
+    u8                  minute[2];         //分
+} BYTE1 RS232_YB_SS160_RECEIVE_HEAD;
+
+typedef struct {
+    u8      TT[2];             //罐号（如果数字为 00，则返回所有油罐数据，如 果未 01 或 02 等油罐编码，则仅返回该油罐的一 组数据）
+    u8      P;                 //产品代码(油品) 
+    u8      SSSS[4];           //油罐状态 Bit 位。Bit1：正在进油；Bit2：正在漏 油检测；Bit3：无效的高度报警（仅用于测试）； bit4-16：未应用
+    u8      NN[2];             //随后的浮点数个数 
+    //实际数据，共有7组，每组占8字节
+    u8      TankVolume[8];     //1油水体积
+    u8      NetVolume[8];      //2油水体积
+    u8      CrossVolume[8];    //3剩余体积
+    u8      Height[8];         //4油高
+    u8      Water[8];          //5水高
+    u8      Temp[8];           //6温度
+    u8      WaterVolume[8];    //7水体积
+} BYTE1 I201_FUELTANK_DATA; //油罐数据
+
+typedef struct {
+    u16     FCN_FLAG;       //数据结束标志 固定值&&符号
+    u32		CheckCode;      //校验
+    u8      EXT;            //功能码或命令字
+} BYTE1 RS232_YB_SS160_RECEIVE_TAIL;
+
+#define YB_SS160_SEND_SIZE 		sizeof(RS232_YB_SS160_SEND)
+#define YB_SS160_RCV_HEADSIZE 	sizeof(RS232_YB_SS160_RECEIVE_HEAD)
+#define YB_SS160_RCV_DATASIZE 	sizeof(I201_FUELTANK_DATA)
+#define YB_SS160_RCV_TAILSIZE 	sizeof(RS232_YB_SS160_RECEIVE_TAIL)
+
+
+typedef struct _oiltank_info {
+	u32 id;
+	u32 quality;
+	u32 volume;
+	u32 oil_volume;
+	u32 water_volume;
+	u32 temperature;
+	u32 height;
+
+	/* 监控有效性 */
+	u32 valid_num;
+} oiltank_info_t ;
+
+#define OILTANK_VALID_COUNT 16
+typedef struct _system_oiltank_info {
+	uint32_t current;
+	uint32_t valid;
+	oiltank_info_t oiltank[OILTANK_VALID_COUNT];
+} system_oiltank_info_t;
+extern system_oiltank_info_t system_oiltank;
+typedef struct _gb_oiltank_header {
+	uint32_t device_type;
+	uint32_t device_id;
+	uint8_t device_status;
+	uint8_t oiltank_count;
+} gb_oiltank_header_t;
+
+#define GB_OILTANK_HEADER_LEN 		10
+#define GB_OILTANK_INFO_LEN 		28
+
+#define OILTANK_MSG_PERIOD 10
+#define OILTANK_UART	UART4_ID
+
+typedef enum OIL_QUALITY{
+	QUALITY_90, //90#汽油
+	QUALITY_92,//93#汽油
+	QUALITY_95,//95#汽油
+	QUALITY_98,//97#汽油
+	QUALITY_0,//0#柴油
+	QUALITY_10,//10#柴油
+	QUALITY_NEG_10,//-10#柴油
+	QUALITY_NEG_20,//-20#柴油
+	QUALITY_NEG_35,//-35#柴油
+	QUALITY_NEG_50,//-50#柴油
+} OIL_QUALITY;
+
+void oiltank_polling(void);
+int oiltank_init(void);
+
+#endif

APP/dev_mgr/taxctrl/tax_ctrl.c

@@ -0,0 +1,108 @@
+#include "includes.h"
+#include "device.h"
+#include "tax_ctrl.h"
+#include "net_proc.h"
+#include "uart.h"
+#include "des.h"
+#include "BSP.h"
+#include "net_ctrl.h"
+
+int rs485_send_flag = 0;
+#define CRC_INIT_VALUE 0x0000
+
+uint8_t XSP_ADDRESS = 0x81;
+
+
+
+/**
+  * @brief hex convert ascii
+  * @par param[in] *ascii:ascii data
+  * @par param[in] *hex:hex data
+  * @par param[in] hexLen:length of hex
+  * @retval length
+  */
+uint32_t Hex2Dec(uint8_t *hex, uint16_t hexLen)
+{
+	uint32_t data = 0;	
+    uint8_t i;
+	
+    for(i=0;i<hexLen;i++) {
+		data = data * 100;
+        data += (hex[i]>>4)*10 + (hex[i]&0x0F);
+    }
+    return data;
+}
+
+
+uint16_t _crc16_get(uint8_t *_buff,uint32_t _len)
+{
+    uint32_t i,j;
+    uint16_t crc;
+    uint16_t temp;
+
+    crc=(uint16_t)CRC_INIT_VALUE;
+    for(i=0;i<_len;i++) {
+        temp=_buff[i];
+        temp &=0x00FF;
+        crc^=temp;
+
+        for(j=0;j<8;j++) {
+            if((crc&0x0001)!=0x00) {
+                crc>>=1;
+                crc^=0xA001;
+            } else {
+                crc>>=1;
+            }
+        }
+    }
+ 
+    return crc;
+}
+
+
+static uint16_t _crc_get(uint8_t *data, uint8_t size)
+{
+	uint8_t i, crc = 0;
+	
+	for(i = 0;i < size;i++){
+		crc ^=data[i];
+	}
+ 
+	return crc;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//显示屏通信过程
+/////////////////////////////////////////////////////////////////////////////
+
+//取反函数
+int reverse_get(uint8_t* buffer, uint8_t* result,uint8_t data_len)
+{
+	int ret = 0;
+	int i;
+	for(i = 0; i < data_len; i++)
+	{
+		*(result+i) = ~(*(buffer+i));
+	}
+	
+	return ret;
+}
+
+
+//比较两个字符串
+static int _my_strcmp(uint8_t *buff1, uint8_t *buff2, uint8_t len)
+{
+	int i, ret = 1;
+	for(i = 0; i < len; i++)
+	{
+		if(buff1[i] != buff2[i])
+		{
+			return ret;
+		}
+	}
+	ret = 0;
+	return ret;
+}
+
+
+

APP/dev_mgr/taxctrl/tax_ctrl.h

@@ -0,0 +1,60 @@
+#ifndef _TAX_CTRL_H_
+#define _TAX_CTRL_H_
+
+#include "stm32f10x.h"
+#include "includes.h"
+
+#define UART_RS485 UART3_ID
+
+extern int rs485_send_flag;
+
+
+#define GB_TAX_HEADER_LEN 		10
+#define GB_TAX_INFO_LEN 		53
+#define GB_GUN_INFO_LEN 		22
+
+#define YTSF_GPIO_RS485_RESET()  {GPIO_ResetBits(GPIOD, GPIO_Pin_3);}
+#define YTSF_GPIO_RS485_SET()    {GPIO_SetBits(GPIOD, GPIO_Pin_3);}
+
+#define YTSF_GPIO_AB_RESET()  {GPIO_ResetBits(GPIOD, GPIO_Pin_4);}
+#define YTSF_GPIO_AB_SET()    {GPIO_SetBits(GPIOD, GPIO_Pin_4);}
+
+#define YTSF_GPIO_CD_RESET()  {GPIO_ResetBits(GPIOD, GPIO_Pin_5);}
+#define YTSF_GPIO_CD_SET()    {GPIO_SetBits(GPIOD, GPIO_Pin_5);}
+
+#define YTSF_GPIO_YTSF_RESET()  {GPIO_ResetBits(GPIOD, GPIO_Pin_6);}
+#define YTSF_GPIO_YTSF_SET()    {GPIO_SetBits(GPIOD, GPIO_Pin_6);}
+
+//#define YTSF_GPIO_REV2_RESET()  {GPIO_ResetBits(GPIOD, GPIO_Pin_7);}
+//#define YTSF_GPIO_REV2_SET()    {GPIO_SetBits(GPIOD, GPIO_Pin_7);}
+
+//#define YTSF_GPIO_SET()  {GPIO_SetBits(GPIOB, GPIO_Pin_5);}
+//#define YTSF_GPIO_RST()  {GPIO_ResetBits(GPIOB, GPIO_Pin_5);}
+
+//#define YTSF_GPIO_DETECT  GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_6)
+
+//#define YTSF_GPIO_EN()  {GPIO_ResetBits(GPIOB, GPIO_Pin_7);}
+//#define YTSF_GPIO_DN()  {GPIO_SetBits(GPIOB, GPIO_Pin_7);}
+
+
+/************************************************************/
+#define YTSF_GPIO_REV2_RESET()  {GPIO_ResetBits(GPIOC, GPIO_Pin_0);}
+#define YTSF_GPIO_REV2_SET()    {GPIO_SetBits(GPIOC, GPIO_Pin_0);}
+
+#define YTSF_GPIO_SET()  {GPIO_SetBits(GPIOC, GPIO_Pin_1);}
+#define YTSF_GPIO_RST()  {GPIO_ResetBits(GPIOC, GPIO_Pin_1);}
+
+#define YTSF_GPIO_DETECT  GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_2)
+
+#define YTSF_GPIO_EN()  {GPIO_ResetBits(GPIOC, GPIO_Pin_3);}
+#define YTSF_GPIO_DN()  {GPIO_SetBits(GPIOC, GPIO_Pin_3);}
+/************************************************************/
+
+#define BIT_SET(p, bit)		((p) |= (1<<(bit)))
+#define BIT_CLC(p, bit)		((p) &= ~(1<<(bit)))
+
+#define TAX_UART	UART1_ID
+#define FAIL_THRESHOLD	3
+#define TAX_MSG_PERIOD 10
+
+#endif

APP/gateway_collect/gateway_collect.c

@@ -0,0 +1,69 @@
+#include "gateway_collect.h"
+#include "../../User/includes.h"
+#include "../network_mgr/net_ctrl.h"
+#include "../dev_mgr/taxctrl/tax_ctrl.h"
+#include "../network/uplink.h"
+#include "../storage/AT24C128Opt.h"
+#include "../network/downlink.h"
+void * lora_queue_mem_calloc_must(void);
+int lora_queue_mem_free(void * p_msg);
+void lora_queue_insert(char *p_msg, uint32_t msg_len);
+
+
+static uint16_t _crc_get_gw(uint8_t *data, uint8_t size)
+{
+	uint8_t i, crc = 0;
+	
+	for(i = 0;i < size;i++){
+		crc ^=data[i];
+	}
+ 
+	return crc;
+}
+
+
+static uint16_t _crc_get1(uint8_t *data, uint8_t size)
+{
+	uint8_t i, crc = 0;
+	
+	for(i = 0;i < size;i++){
+		crc ^=data[i];
+	}
+ 
+	return crc;
+}
+
+/*-----------------------------------
+ *  向服务器发送网关的信息
+ * ----------------------------------*/
+void gateway_net_send_gatewayMsg(void)
+{
+    uint8_t sendBuff[160];
+    uint8_t sendLen = 0;
+    static uint8_t bfirstPowerup = 0;
+    static uint8_t timer = 0;
+    if(bfirstPowerup==0){
+        g_runData.bsendGatewaySttus = 1;
+        g_runData.bsendGatewayVersion = 3;
+        bfirstPowerup = 1;
+        timer = 3;
+    }
+    if(g_runData.bsendGatewaySttus>=1){
+        uplink_tax_statusmcmd_0x2002(sendBuff,&sendLen,DEVICE_OILL,0);
+        tax_net_send(sendBuff,sendLen,FIRST_TYPE_STATUS,COLL_UP_STATUS_CMD2002);
+        g_runData.bsendGatewaySttus = 0;
+    }
+    else if(g_runData.bsendGatewayVersion >= timer) {
+        uplink_tax_statusmcmd_0x2001(sendBuff,&sendLen,DEVICE_OILL,0);
+        tax_net_send(sendBuff,sendLen,FIRST_TYPE_STATUS,COLL_UP_STATUS_CMD2001);
+        if(timer ==3) timer = 10;
+        else if(timer == 10) timer = 60;
+        else timer = 60;
+
+        g_runData.bsendGatewayVersion = 0;
+        printf("send gateway msg to server\r\n");
+    }
+		
+    return;
+}
+

APP/gateway_collect/gateway_collect.h

@@ -0,0 +1,111 @@
+#ifndef __GATEWAY_COLLECT_H__
+#define __GATEWAY_COLLECT_H__
+
+#include "stm32f10x.h"
+//#include "downlink.h"
+#include "../../APP/network/downlink.h"
+#include "../globalDef.h"
+#include "../ota/ota.h"
+/*采集器与网关通信的消息类型*/
+#define GATE_COLL_HEART_QUERY       0x56	//网关与采集器的下行心跳包
+#define COLL_GATE_HEART_QUERY       0x66	//网关与采集器的上行心跳包
+#define GATE_COLL_TAX_QUERY         0x57    //业务数据下行发送消息
+#define COLL_GATE_TAX_QUERY         0x67    //业务数据上行接收消息
+#define GATE_COLL_FIRMMSG_QUERY     0x58	//网关下发查询固件信息
+#define COLL_GATE_FIRMMSG_QUERY     0x68	//采集器上发固件信息
+#define COLL_GATE_RESTART_QUERY     0x59	//采集器设备重新启动
+
+
+
+
+#define YTSF_0XA2_0X00   0xA2
+#define YTSF_0XA1_0X11   0xA1
+#define YTSF_0XA1_0X14   0xA4
+
+#define FRAME_LEN 19
+
+#define PLAINTEXT   1  //明文
+#define CIPHERTEXT  2  //密文
+#define DISPLAY     3  //显示屏
+
+#define GATE_COLL_HEAD_LEN 12 // 网关与采集器通信的协议头为12个字节
+#define GATE_COLL_CMD5767_LEN 11 //0x57 0x67指令的长度
+#define GATE_COLL_CMD56_LEN 5 // 56命令的长度
+#define GATE_COLL_CMD58_LEN 5 // 58命令的长度
+#define GATE_COLL_CMD59_LEN 5 // 59命令的长度
+
+#define GATE_COLL_PROTOTYPE 0x11 // 网关与采集器通信协议的版本
+/*业务数据头0x17 0x27*/
+typedef struct _tax_query_info
+{
+    uint32_t device_sn;         //设备编号
+    uint8_t device_type;        // 设备类型 1：报税口 2：显示屏
+    uint8_t msg_com;            //串口号
+    uint8_t coll_no;            // 采集器索引 从1开始
+    uint8_t tax_no;             //报税口号 从1开始
+    uint8_t gun_msgid;          //枪号  从1开始
+    uint8_t prot_type;          //协议类型 1:明文 2：密文
+    uint8_t status;             //1:成功 2：数据超时
+    char  info[160];
+}__attribute__((packed)) tax_query_info_t;
+
+/* 心跳0x56 查询固件信息0x58 设备重新启动0x59*/
+typedef struct _TAX_COMM_HEAD_{
+    uint32_t device_sn; // 设备编号
+    uint8_t coll_no;            // 采集器索引 从1开始
+}__attribute__((packed))taxComHead;
+
+/*心跳返回的数据0x56*/
+typedef struct _TAX_Encry_STATUS_{
+    uint32_t device_sn; // 设备编号
+    uint8_t coll_no;            // 采集器索引 从1开始
+    uint8_t factory; // 1：明文  2：密文
+}__attribute__((packed))taxEncryptStatus;
+
+/*固件信息返回0x58*/
+typedef struct _TAX_FIRM_MSG_{
+    uint32_t device_sn;    //设备SN
+    uint8_t coll_no;            // 采集器索引 从1开始
+    uint32_t bootloaderVr; // bootloader版本事情
+    uint32_t appVr;       //APP版本号
+    uint32_t resetNum;    //复位次数
+    uint8_t resetType;    //最后一次复位类型
+    uint32_t runTime;     //运行时间
+    uint8_t updateStatus; // 升级状态码
+    uint8_t uuid[12];       //UUID
+    char info[160];       //数据内容
+}__attribute__((packed))taxFirmMsg;
+
+typedef  union TAX_DATA_INFO_{
+    tax_query_info_t data; // 业务数据
+    taxComHead comdata; //心跳 查询固件信息 设备重新启动信息
+    taxFirmMsg firmMsg; //固件信息
+    taxEncryptStatus taxEnStatus; // 心跳包的返回
+    char info[160];
+}__attribute__((packed))taxDaInfo;
+
+/*网关向采集发送或是接收消息的结构体*/
+typedef struct _gateway_collect_com
+{
+    uint16_t frame_header;      //帧头
+    uint8_t  proto_ver;         //协议版本 0x11
+    uint32_t seq_no;            //消息序列号
+    uint8_t  type;              //一级消息类型
+    uint16_t secondType;        // 2级消息类型
+    uint16_t len;               //消息长度
+    taxDaInfo taxinfo;            //
+}__attribute__((packed)) gateway_collect_com_t;
+
+
+///////////////////////////
+
+
+
+
+
+
+extern void gateway_net_send_gatewayMsg(void);
+
+#endif
+
+

APP/globalDef.c

@@ -0,0 +1,19 @@
+#include "globalDef.h"
+
+CurTick g_curTick; // 时间信息
+RunData g_runData; //运行数据
+FirmwareMsg g_firmwareMsg; // 网关 采集器固件信息存储
+FirmwareExpl g_firmwareExpl; //固件信息版本格式
+Da4G g_data4G; // 4G模块连接情况
+LedStatus g_ledStatus; // led灯的情况
+char g_upLinkTopic[64] = {0};
+oilReadMsg g_oilReadMsg; // 油罐的信息，由服务器下发的
+updateProg g_updateProg;
+key_func_t key_info;
+MqttRunDa g_mqttRunDa;
+OilRunData g_oilreadDa;
+/*时间信息初始化*/
+
+/*系统信息*/
+
+/*运行数据*/

APP/globalDef.h

@@ -0,0 +1,215 @@
+#ifndef _GLOBALDEF_H_
+#define _GLOBALDEF_H_
+
+#include "../_Lib-3.5/CMSIS/stm32f10x.h"
+#include "./network/timeout.h"
+#include "./network/nettimer.h"
+
+
+#define READ_TIMER 3
+
+
+
+#define UP_DEVICE_TYPE_GATE 0x0101 // 网关A
+#define UP_DEVICE_FIRMWARE 0x03 // APP程序
+enum {
+    UPDATE_PROG_NULL = 0x00,
+    UPDATE_PROG_FROM_NET = 0x01,
+    UPDATE_PROG_FROM_GATEWAY = 0x02,
+};
+typedef struct _updata_prog {
+    uint32_t sn[4];
+    uint32_t appVr[4];
+    uint8_t status[4];// 状态码
+    uint16_t num;
+    uint8_t upCount; // 上报的次数
+    uint8_t updateProgFrom; // 升级程序的开源
+    timeout_t upStatusOut;
+    uint8_t rec0x16; // 接收到16指令，
+    OS_TMR update_total_time;
+}updateProg;
+extern updateProg g_updateProg;
+
+
+extern char g_upLinkTopic[64];
+
+/* LED 灯的记录 */
+#define LED_M_QUICK 1
+#define LED_M_LOW 5
+
+#pragma pack(push,1)
+typedef union _LED_16_{
+    uint16_t status;
+    struct {
+        uint16_t led01 : 1;
+        uint16_t led02 : 1;
+        uint16_t led03 : 1;
+        uint16_t led04 : 1;
+        uint16_t led05 : 1;
+        uint16_t led06 : 1;
+        uint16_t led07 : 1;
+        uint16_t led08 : 1;
+        uint16_t led09 : 1;
+        uint16_t led10 : 1;
+        uint16_t led11 : 1;
+        uint16_t led12 : 1;
+        uint16_t led13 : 1;
+        uint16_t led14 : 1;
+        uint16_t led15 : 1;
+        uint16_t led16 : 1;
+    }led;
+}Led16;
+#pragma pack(pop)
+typedef struct _LED_STATUS_{
+    uint8_t ledM; // M灯的情况 快闪还是慢闪
+    Led16 led16;
+    uint16_t collNum; // 采集器个数
+}LedStatus;
+extern LedStatus g_ledStatus;
+/*时间信息记录*/
+typedef struct _CUR_TICK_{
+    uint32_t powerTime; // 上电时间
+    uint32_t curTime; // 当前时间
+
+}CurTick;
+extern CurTick g_curTick;
+typedef struct _FIRMWARE_EXPLAIN_{
+    uint16_t dd;
+    uint8_t ff;
+    uint16_t nn;
+}__attribute__((packed)) FirmwareExpl;
+extern FirmwareExpl g_firmwareExpl;
+
+#define UPDATE_COLLECT_TOTALTIME 90000 // 升级总的时间
+#define UPDATE_CONTINUE_TIME 300 // 升级续传每条间隔的时候300毫秒
+#define UPDATE_REPEAT_TIME  7000 // 接收重传超时的时间 2S
+#define UPDATE_READSTATUS_TIME 10000 // 升级完成 到读取升级状态的时间
+#define UPDATE_READSTATUS_TIME_GATEWAY 60000 // 升级完成 到读取升级状态的时间
+/*运行数据*/
+typedef struct _RUN_DATA_{
+    uint16_t rssi_lora; // lora信息强度
+    uint16_t rssi_4G; // 4G信息强度
+    uint8_t timeSendStatus; // 第5分钟发送一次状态信息的标志 0：不发送 1：发送
+    uint8_t bInitNetProc; // 是否创建网络队列
+    uint16_t updateDeviceTyp; // 升级类型 0x0101：网关；0x0201；采集器：0x0301:液位仪采集器；0x0401：屏采集器
+    uint8_t bUpdate; // 正在升级中
+    uint32_t startUpdateTotalTime; // 重传开始时间记录
+    uint32_t repeatUpdateTime; // 接收到重传指令型时间记录
+    uint32_t readUpdateStatusTime; // 读取升级状态的时间记录
+    uint8_t bsendOilData; // 发送油罐数据到服务器
+    uint8_t bAutoReadOilData; // 自动读取油罐数据
+    uint8_t bsendUpdateStatus; // 向服务器发送状态码
+    uint8_t bResetUpdate; // 升级完成后，需要上报服务器
+    uint8_t bsendGatewaySttus; //
+    uint8_t bsendGatewayVersion;
+    uint8_t frameNo; // 是否为多帧
+    uint8_t cregStatus;  // 网络注册状态
+    uint8_t bUpdateHost;  //是否是主设备  1：为主设备  其它为从设备，升级时，从设备不处理0x22指令
+    uint16_t loraConnectTime;  // lora  连接的时间
+    uint8_t bread; // 服务器下发的读取液位仪的指令
+}RunData;
+extern RunData g_runData;
+typedef struct _DATA_4G_{
+    uint8_t bconnect4G; // 是否连接4G
+    uint8_t errorTime; // 4G断开的时间 如果断开1小时，则芯片复位重新启动
+}Da4G;
+extern Da4G g_data4G;
+
+/* 网关固件信息存储 这个只有在产测时写入，要程序中不再写入*/
+typedef struct _GATEWAY_HARDWARE_MSG_{
+    uint8_t bInit; // 是否初始化过
+    uint32_t gateway_sn; // 网关的sn
+    uint16_t devicType;  // 类型
+    uint16_t factoryMsg; // 厂家信息
+    uint16_t seqNo ; // 生产批次号
+    uint32_t data; // 生产日期
+    uint8_t pcbVersion; // 硬件（PCB）版本
+    uint32_t sqare; //备用
+}__attribute__((packed)) GateHareWareMsg;
+
+/* 网关的固件信息存储*/
+typedef struct _GATEWAY_SOFT_MSG_{
+    uint16_t bInit; // 是否配置过
+    uint8_t coll_num; // 此网关对应采集器的数量
+    uint16_t sqare; // 备用
+}__attribute__((packed)) GateConfigMsg;
+/* 网关的版本信息*/
+typedef struct _GATEWAY_VERSION_MSG_{
+    uint32_t gate_bootloaderVr; //网关的bootloaderVr
+    uint32_t pt_version; // 产测版本
+    uint32_t gate_appVr; // appt版本
+    uint32_t gate_appVr2; // app2的版本
+    uint32_t gate_appVr3; // app3的版本
+}__attribute__((packed)) GateVersionMsg;
+
+typedef union _VOLTAGE_{
+    uint32_t voltage; // 电压
+    float fvoltage;
+}voltage;
+typedef union _TEMPERATURE_{
+   uint32_t temperature; // 温度
+   float ftemperature;
+}temperature;
+
+typedef struct _GATEWAY_MSG_{
+    GateHareWareMsg hardwareMsg; //
+    GateConfigMsg configmsg; // 软件信息
+    GateVersionMsg verMsg; // 版本信息
+    uint32_t gate_resetnum; //复位次数
+    uint8_t gate_resetType; //最后一次复位类型
+    uint32_t gate_runTime; // 运行时长
+    voltage fVol;
+    temperature fTemper;
+    uint8_t Uuid[12];//UUID
+    uint8_t Imei[15]; //IMEI
+    uint8_t Iccid1[20];//ICCID1
+    uint8_t Iccid2[20];//ICCID2
+    uint8_t Iccid3[20];//ICCID3
+    uint16_t devicTypeID; // 103 303  这个是读取上来的
+
+}GateWayMsg;
+/* mqtt IP地址 端口号*/
+typedef struct _MQTT_IP_PORT_{
+    uint8_t flag;
+    char port[6]; // 端口号
+    char ip[32]; //IP地址
+    char admin[8]; // 用户名
+    char password[16]; // 密码
+}__attribute__((packed)) MqttIdPort;
+
+typedef struct _FIRMWARE_MSG_{ // 固件信息存储
+    GateWayMsg gatewayMsg; // 网关固件信息
+    MqttIdPort mqttidport; // mqtt的IP地址和端口
+}FirmwareMsg;
+extern FirmwareMsg g_firmwareMsg; // 网关 采集器固件信息存储
+
+typedef struct _OIL_READ_MSG_{
+    uint8_t bInit; // 是否初始化
+    uint16_t paraLen; // 参数长度
+    char param[48]; // 参数
+}__attribute__((packed)) oilReadMsg;
+extern oilReadMsg g_oilReadMsg;
+
+
+typedef struct _run_mqtt_data_{
+    uint8_t bChangeMqtt; // 1：为切换mqtt 服务器
+    uint8_t bChangeSuc; // 0：初始值 1: 切换成功 2： 切换连接失败
+    uint8_t connectNum;  // 连接次数
+    uint8_t mqttIdlen;
+    uint8_t mqttPortlen;
+    uint8_t mqttUserlen;
+    uint8_t mqttPwdlen;
+    MqttIdPort mqttMsg; // mqtt的IP地址和端口
+}__attribute__((packed)) MqttRunDa;
+extern MqttRunDa g_mqttRunDa;
+
+typedef struct{
+        uint8_t oil_buff[1024]; //
+        uint16_t len; //数据长度
+        uint16_t len1; // 用于没有结束符的长度
+        uint8_t bfinish; // 收到03 结束
+        uint8_t bAutoRead; // 是否自动读取
+        uint8_t bstart;   // 收到了 i20100指令
+}__attribute__((packed))OilRunData;
+extern OilRunData g_oilreadDa;
+#endif

APP/network/downlink.c

@@ -0,0 +1,330 @@
+#include "downlink.h"
+#include "uplink.h"
+#include "device.h"
+#include "gateway.h"
+#include "../network_mgr/net_proc.h"
+#include "../../User/includes.h"
+#include "../storage/AT24c128.h"
+#include "../gateway_collect/gateway_collect.h"
+#include "../dev_mgr/taxctrl/tax_ctrl.h"
+#include "../globalDef.h"
+#include "../storage/AT24C128Opt.h"
+#include "../network_mgr/net_ctrl.h"
+#include "../storage/AT24C128Opt.h"
+#include "nettimer.h"
+
+#include "me3616.h"
+
+extern ME3616  air;
+
+downlink_config_t downlink_config;
+void downlink_init(void)
+{
+    int ret;
+    int i;
+    uint32_t flag = 0;
+//    memset(&downlink_config.collect_conf,0,sizeof(downlink_config.collect_conf));
+//    printf("downlink size %d\n",sizeof(downlink_config));
+ //   printf("gateway_read size %d\n",sizeof(gateway_read));
+
+    sprintf(g_upLinkTopic,"%s%04x/%010u",(char*)MQTT_UPLINK_TOPIC,GATEWAY_DEVICE_TYPE, g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn);
+
+
+  //  fram_read_config_msg();
+   // if(downlink_config.config_flag == CONFIG_WRITE)
+    {
+        
+        g_ledStatus.collNum =  g_ledStatus.led16.status;
+        g_runData.timeSendStatus = 1;
+        g_runData.bUpdate = 0;
+        g_runData.bsendOilData = 0;
+        downlink_config.config_flag =  1;
+        g_ledStatus.led16.status = 0x8000;
+        set_led_update_status(g_ledStatus.led16.status);
+    }
+
+}
+
+int downlink_gateway_para(uint8_t *data, uint16_t len)
+{
+    int ret=-1;
+    int i,j,k;
+    downlinkSysCmd0x1011 *p_msg = NULL;
+    uint16_t flag = 0x01;
+    uint8_t *tempdata;
+    tempdata = data+5;
+
+
+
+
+
+    p_msg = (downlinkSysCmd0x1011 *)data;
+
+
+
+    memset(&downlink_config,0,sizeof(downlink_config));
+
+
+   // if(p_msg->gateway_id != g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn)
+   //     return ret;
+
+    downlink_config.gateway_id = p_msg->gateway_id;
+//    downlink_config.collect_num = p_msg->collect_num;
+//    g_firmwareMsg.gatewayMsg.configmsg.coll_num = p_msg->collect_num;
+   // g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn = p_msg->gateway_id;
+   // if(p_msg->collect_num > COLLECT_MAX_NUM) //采集器个数大于最大值，数据错误，直接返回
+  //      return ret;
+
+
+    downlink_config.config_flag = CONFIG_WRITE;
+    fram_write_config_msg(flag);
+    //fram_write_gateway_soft_msg();
+    downlink_config.config_flag = flag;
+
+    g_runData.timeSendStatus = 1;
+    g_runData.bUpdate = 0;
+    g_runData.bsendOilData = 0;
+ //   AT24CXX_Write(CONFIG_ADDR,(uint8_t *)&downlink_config,sizeof(downlink_config));
+    NVIC_SystemReset();//复位
+	  return 0;
+}
+/*--------------------------------------------------------------
+ *  解析网络下发的 系统类（0x01)的 0x1003指令 切换mqtt服务器
+ * -------------------------------------------------------------*/
+void downlink_analyze_system_cmd0x1003(uint8_t *data,uint16_t size)
+{
+    uint8_t len = 0;
+    downlinkSysCmd0x1003 *msg = NULL;
+
+    msg = (downlinkSysCmd0x1003*)data;
+
+    if(msg->gateway_sn != downlink_config.gateway_id) return;
+    //if(msg->targettype != GATEWAY_DEVICE_TYPE) return;
+
+    memset(&(g_mqttRunDa.mqttMsg),0,sizeof(MqttIdPort));
+
+    memcpy(g_mqttRunDa.mqttMsg.ip,msg->str,msg->iplen);
+    len = msg->iplen;
+    memcpy(g_mqttRunDa.mqttMsg.port,msg->str+len,msg->portlen);
+    len += msg->portlen;
+    memcpy(g_mqttRunDa.mqttMsg.admin,msg->str+len,msg->userlen);
+    len += msg->userlen;
+    memcpy(g_mqttRunDa.mqttMsg.password,msg->str+len,msg->pwdlen);
+
+    g_mqttRunDa.mqttIdlen = msg->iplen;
+    g_mqttRunDa.mqttPortlen = msg->portlen;
+    g_mqttRunDa.mqttUserlen = msg->userlen;
+    g_mqttRunDa.mqttPwdlen = msg->pwdlen;
+
+    close_tcp_mqtt();
+    g_mqttRunDa.bChangeMqtt = 1;
+    air.State.MQTT_State= 0;
+    //g_mqttRunDa.bChangeSuc = 0;
+    g_mqttRunDa.connectNum = 0;
+    g_runData.cregStatus = 0;
+
+
+}
+
+/*--------------------------------------------------------------
+ *  刷新税控序列号0x1012
+ * --------------------------------------------------------------*/
+void downlink_analyze_system_cmd0x1012(uint8_t *data,uint16_t size)
+{
+
+}
+
+/*--------------------------------------------------------------
+ *  设备重新启动 0x1021
+ * --------------------------------------------------------------*/
+void downlink_analyze_system_cmd0x1021(uint8_t *data,uint16_t size)
+{
+
+    downlinkSysCmd0x1021 *p_msg = NULL;
+
+    p_msg = (downlinkSysCmd0x1021*)data;
+
+
+    switch(p_msg->targetType){
+    case 0x0101: // 网关
+        if(p_msg->sn != downlink_config.gateway_id) break;
+        NVIC_SystemReset();//复位//设备重新启动
+        break;
+    case 0x0201: // 采集器
+        break;
+    case 0x0301: // 液位仪采集器
+        if(p_msg->sn != downlink_config.gateway_id) break;
+        NVIC_SystemReset();//复位//设备重新启动
+        break;
+    case 0x0401: // 显示器
+
+        break;
+    }
+}
+/*---------------------------------------------------------------
+ *  液位仪的配置信息初始化
+ * --------------------------------------------------------------*/
+void downlink_oil_sys_cmd0x1031(uint8_t *data, uint16_t size)
+{
+    downlinkSysOilCmd0x1031 *pmsg = NULL;
+  //  char sendbuff[32] = {0};
+  //  uint16_t len = 0;
+ //   downlinkDataOilCmd0x1021 *msg = (downlinkDataOilCmd0x1021*)sendbuff;
+
+    pmsg = (downlinkSysOilCmd0x1031*)data;
+
+    if((pmsg->gateway_sn!=downlink_config.gateway_id) && (pmsg->gateway_sn!=0xFFFFFFFF) ) return;
+    g_oilReadMsg.paraLen = pmsg->paraLen;
+    memset(g_oilReadMsg.param,0,sizeof(g_oilReadMsg.param));
+    memcpy(g_oilReadMsg.param,pmsg->param,pmsg->paraLen);
+    g_oilReadMsg.bInit = 0x5;
+    fram_write_oil_msg();
+    timeout_stop(&g_timeOut);
+    g_runData.bsendOilData = READ_TIMER;
+//    msg->gateway_sn = downlink_config.gateway_id;
+
+//    len = sizeof(downlinkDataOilCmd0x1021);
+//    tax_net_send(sendbuff,len,0x01,0x2031);
+}
+
+/*--------------------------------------------------------------
+ *  解析网络下发的 系统类（0x01）的数据
+ * --------------------------------------------------------------*/
+void downlink_analyze_system_cmd(uint16_t type, uint8_t *data, uint16_t size)
+{
+    switch(type){
+    case COLL_DN_SYS_CMD1011: //系统类 采集路由信息初始化下行
+        downlink_gateway_para(data,size);
+        break;
+    case COLL_DN_SYS_CMD1012: // 系统类，刷新税控序列号
+        downlink_analyze_system_cmd0x1012(data,size);
+        break;
+    case COLL_DN_SYS_CMD1021: // 系统类，系统重新启动
+        downlink_analyze_system_cmd0x1021(data,size);
+        break;
+    case GATEWAY_DN_SYS_CMD1003: //配置mqtt服务器
+        downlink_analyze_system_cmd0x1003(data,size);
+        break;
+    case COLL_DN_SYS_CMD1001: // 升级
+        gateway_update_proc(data,size);
+        break;
+    case OILL_DN_SYS_CMD1031: // 系统类，油罐下行配置
+        downlink_oil_sys_cmd0x1031(data,size);
+        break;
+    }
+}
+/*----------------------------------------------------------------------
+ *  解析网络下发的  状态类的信息   固件信息下行指令 0x1001
+ * ---------------------------------------------------------------------*/
+void downlink_analyze_status_cmd0x1001(uint16_t type, uint8_t *data,uint16_t size)
+{
+    uint8_t index = 0;
+    uint8_t sendBuff[160];
+    uint8_t sendLen = 0;
+
+    downlinkStatusCmd0x1001 *pMsg = NULL;
+
+    pMsg = (downlinkStatusCmd0x1001*)data;
+
+    if(pMsg->gateway_sn!=downlink_config.gateway_id) return;
+    memset(sendBuff,0,sizeof(sendBuff));
+    switch(pMsg->targetType){
+    case 0x0101: // 网关
+        uplink_tax_statusmcmd_0x2001(sendBuff,&sendLen,pMsg->targetType,0);
+        tax_net_send(sendBuff,sendLen,FIRST_TYPE_STATUS,COLL_UP_STATUS_CMD2001);
+        break;
+    case 0x0201: // 采集器
+        
+        break;
+    case 0x0301: // 液位仪采集器
+        uplink_tax_statusmcmd_0x2001(sendBuff,&sendLen,pMsg->targetType,0);
+        tax_net_send(sendBuff,sendLen,FIRST_TYPE_STATUS,COLL_UP_STATUS_CMD2001);
+        break;
+    case 0x0401: // 显示器
+
+        break;
+    }
+}
+
+/*--------------------------------------------------------------
+ *  解析网络下发的状态类（0x02）的数据
+ * --------------------------------------------------------------*/
+void downlink_analyze_status_cmd(uint16_t type,uint8_t *data, uint16_t size)
+{
+    switch(type){
+    case COLL_DN_STATUS_CMD1001: // 固件信息下行
+        downlink_analyze_status_cmd0x1001(type,data,size);
+        break;
+    }
+}
+/*--------------------------------------------------------------------
+ *  读取液位仪的数据
+ * --------------------------------------------------------------------*/
+void downlink_oil_data_cmd0x1021(uint8_t *data,uint16_t size)
+{
+    downlinkDataOilCmd0x1021 *pmsg = NULL;
+
+    pmsg = (downlinkDataOilCmd0x1021*)data;
+
+    if((pmsg->gateway_sn!=downlink_config.gateway_id) && (pmsg->gateway_sn!=0xFFFFFFFF)) return ;
+
+	timeout_stop(&g_timeOut);
+        g_runData.bsendOilData = READ_TIMER;
+        g_runData.bread = 1;
+}
+
+/*--------------------------------------------------------------------
+ * 数据类 0x03 类的信息
+ * -------------------------------------------------------------------*/
+void downlink_analyze_data_cmd(uint16_t type,uint8_t *data, uint16_t size)
+{
+    switch(type){
+    case SECOND_TYPE_DATA_TAX : //报税口类
+
+        break;
+    case SECOND_TYPE_DATA_LED : // 显示屏
+
+        break;
+    case COLL_OIL_DATA_CMD1021 : // 液位仪
+        downlink_oil_data_cmd0x1021(data,size);
+        break;
+    }
+}
+
+
+extern uint16_t crc16_get(uint8_t *data, uint8_t size);
+int downlink_gateway_analyze(uint8_t *data, uint16_t len)
+{
+    int ret = 1;
+    uint16_t crc,fcrc;
+    uint8_t msg_type = 0;
+    sverMsgHeader *p_msg = (sverMsgHeader *)data;
+
+    if(p_msg->len > 128)
+        return ret;
+
+    crc = _crc16_get(data,p_msg->len+FRAME_HEADER_LEN-2);// len-2);
+    fcrc = p_msg->info[p_msg->len-1];
+    fcrc = (fcrc<<8)|p_msg->info[p_msg->len-2];
+
+    if(p_msg->frame_header != 0xfefe){printf("rcv net data head error\r\n"); return 0;}
+    if(crc != fcrc) {printf("rcv net data crc error\r\n"); return 0;}
+
+    msg_type = p_msg->msgtypeFirst;
+    printf("msg_type:%d\n",msg_type);
+    switch(msg_type)
+    {
+        case FIRST_TYPE_SYST: //0x01
+            downlink_analyze_system_cmd(p_msg->msgtypeSecd,(uint8_t*)p_msg->info,p_msg->len);
+            break;
+        case FIRST_TYPE_STATUS: // 0x02
+            downlink_analyze_status_cmd(p_msg->msgtypeSecd,(uint8_t*)p_msg->info,p_msg->len);
+            break;
+        case FIRST_TYPE_DATA: // 0x03
+            downlink_analyze_data_cmd(p_msg->msgtypeSecd,(uint8_t*)p_msg->info,p_msg->len);
+            break;
+        default:
+            break;
+    }
+    return 0;
+}

APP/network/downlink.h

@@ -0,0 +1,120 @@
+#ifndef __DOWNLINK_H__
+#define __DOWNLINK_H__
+
+#include "stm32f10x.h"
+#include "../network_mgr/net_proc.h"
+
+#define COLLECT_MAX_NUM 16
+#define TAX_MAX_NUM     2
+#define GUN_MAX_NUM     8
+
+#define DOWNLINK_CONFIG_TYPE 0x10 //0x65
+
+#define CONFIG_ADDR          0X100
+#define CONFIG_WRITE         0x01
+
+//typedef struct _tax_conf
+//{
+//	uint8_t tax_id;                //报税口编号
+//	uint8_t gun_num;               //加油枪数量
+//	uint8_t gunid[GUN_MAX_NUM];    //加油枪编号
+//        uint8_t alrd_sn;             //是否查询过加油机的信息
+//        uint8_t factory;	      /*厂家 1：英泰 2：拓盛 */
+//        uint8_t status;              // 报税口的状态 ，是否连接
+//        uint8_t encryption;          // 报税口的加密状态 ，由服务器下发的，暂停没有用于
+//        uint8_t monitor_serino[16];  //序列号
+//}__attribute__((packed)) tax_conf_t;
+//	
+//typedef struct _collect_conf
+//{
+//	uint32_t collect_no; //采集器编号
+//	uint8_t tax_num;     //报税口数量
+//	uint8_t tax_type;    //报税口类型，明文或密文
+//        uint8_t collect_status; // 采集器的状态 在线或是离线 0 离线 1：在线
+//        uint8_t coll_send_num; // 采集器发送的次数
+//        tax_conf_t tax_conf[TAX_MAX_NUM];
+//}__attribute__((packed)) collect_conf_t;
+
+
+typedef struct _downlink_config
+{
+    uint8_t config_flag;   //采集器配置标记
+    uint32_t gateway_id;   //网关id
+//    uint8_t collect_num;   //采集器数量
+  //  collect_conf_t collect_conf[COLLECT_MAX_NUM];
+}__attribute__((packed)) downlink_config_t;
+extern downlink_config_t downlink_config;
+
+/*==============================================================*/
+/* 以下是服务器下发 需要用到的解析*/
+
+/* 升级信息下行 0x1001 */
+typedef struct _downlink_system_cmd_0x1001 {
+    uint16_t targetType; // 设备类型（0x0101：网关；0x0201；采集器：0x0301:液位仪采集器；0x0401：屏采集器）
+    uint32_t sn; // sn 编号
+    uint16_t taskNo; // 任务号
+    uint8_t urlLen; // URL长度
+    char url[128]; // url地址
+}__attribute__((packed)) downlinkSysCmd0x1001;
+/* 切换mqtt IP地址 0x1003 */
+typedef struct _downlink_system_cmd_0x1003 {
+    uint32_t gateway_sn; //  网关SN
+    uint16_t targettype; // 类型 0x0101网关  0x0201:采集器 0x0301:液位仪
+    uint8_t iplen; // ip地址长度
+    uint8_t portlen; // 端口长度
+    uint8_t userlen; // 用户名长度
+    uint8_t pwdlen;   // 密码长度
+//    char port[6]; // 端口号
+//    char ip[32]; //IP地址
+//    char admin[8]; // 用户名
+//    char password[16]; // 密码
+    uint8_t str[76];
+}__attribute__((packed)) downlinkSysCmd0x1003;
+/* 采集器路由信息初始化 0x1011 */
+typedef struct _configmsg_{
+    uint32_t  collectSn;
+    uint8_t  comEncrypt[2]; //报税口的加密状态
+
+}__attribute__((packed)) configMsg;
+
+typedef struct _downlink_system_cmd_0x1011 {
+    uint32_t gateway_id;   //网关SN
+    uint8_t collect_num;   //采集器数量
+    configMsg cfigMsg[16];
+}__attribute__((packed)) downlinkSysCmd0x1011;
+
+/* 刷新税控序列号 0x1012*/
+typedef struct _downlink_system_cmd_0x1012_{
+    uint32_t gateway_sn; // 网关SN
+    uint32_t coll_sn;    // 采集器编号
+    uint8_t tax_no;  // 报税口编号
+}__attribute__((packed)) downlinkSysCmd0x1012;
+
+/* 设备重新启动 0x1021*/
+typedef struct _downlink_system_cmd_0x1021_{
+    uint16_t targetType; // 设备类型（0x0101：网关；0x0201；采集器：0x0301:液位仪采集器；0x0401：屏采集器）
+    uint32_t sn; // 设备sn号
+}__attribute__((packed)) downlinkSysCmd0x1021;
+
+/* 状态信息 固件信息下行 0x1001*/
+typedef struct _downlink_status_cmd_0x1001_{
+    uint32_t gateway_sn; // 网关ID
+    uint16_t targetType; // 设备类型（0x0101：网关；0x0201；采集器：0x0301:液位仪采集器；0x0401：屏采集器）
+    uint32_t sn; // 设备编号
+}__attribute__((packed)) downlinkStatusCmd0x1001;
+
+typedef struct _downlink_data_oil_cmd_0x1021_{
+    uint32_t gateway_sn; // 网关编号
+}__attribute__((packed)) downlinkDataOilCmd0x1021;
+
+typedef struct _downlink_sys_oil_cmd_0x1031_{
+    uint32_t gateway_sn; // 网关编号
+    uint16_t paraLen; // 参数长度
+    char param[48]; // 参数
+}__attribute__((packed)) downlinkSysOilCmd0x1031;
+
+void downlink_init(void);
+
+int downlink_gateway_analyze(uint8_t *data, uint16_t len);
+#endif
+

APP/network/nettimer.c

@@ -0,0 +1,67 @@
+#include "nettimer.h"
+#include "../network_mgr/net_ctrl.h"
+#include "../network_mgr/sx1268/lora.h"
+
+
+OS_TMR netsend_timer; // 5分钟的定时器
+OS_TMR netsend_hour_timer; // 24小时的定时器
+
+
+timeout_t g_timeOut;
+timeout_t g_usmTimeOut; // 4G模块的连接超时状态
+
+timeout_t g_uart4Time; // 串口4的接收中断计时
+timeout_t g_uart5Time; // 串口5的接收中断计时
+timeout_t g_uart2Time; // 串口2的接收中断计时
+
+/*-----------------------------------------------------
+ * 一分钟一次
+ * ----------------------------------------------------*/
+void netsend_msg_timer(void *p_tmr, void *p_arg)
+{
+    uint8_t i=0,j=0,k=0;
+    static uint8_t _tick = 0;
+    uint8_t sendbuff[160] = {0};
+    uint8_t len = 0;
+    if(g_runData.bUpdate!=0) return;
+
+    if(sys_net.net_hdl && downlink_config.config_flag == CONFIG_WRITE){
+        _tick++;
+        g_runData.timeSendStatus = 1;
+        printf("netsend hour start %d \r\n",TickCounter);
+
+        if(!g_data4G.bconnect4G) { // 判断4G模块 mqtt是否连接
+            g_data4G.errorTime++;
+            if(g_data4G.errorTime>=60){ // mqtt 一个小时没有连接上，则芯片复位
+                 NVIC_SystemReset();//复位
+            }
+        }
+        else g_data4G.errorTime = 0;
+        g_runData.bsendOilData++;
+        g_runData.bAutoReadOilData++;
+        g_runData.bsendGatewaySttus++;
+        g_runData.bsendGatewayVersion++;
+        if(g_runData.loraConnectTime>=1) g_runData.loraConnectTime++;
+    }
+		
+//		 uplink_tax_statusmcmd_0x2002(sendbuff,&len,DEVICE_OILL,0);
+//        tax_net_send(sendbuff,len,FIRST_TYPE_STATUS,COLL_UP_STATUS_CMD2002);
+//    if(_tick>=3){
+//			memset(sendbuff,0,sizeof(sendbuff));
+//        uplink_tax_statusmcmd_0x2001(sendbuff,&len,DEVICE_OILL,0);
+//        tax_net_send(sendbuff,len,0x02,0x2001);
+//        _tick = 0;
+//    }
+}
+
+void nettimer_init(void)
+{
+    OS_ERR err;
+
+    OSTmrCreate(&netsend_timer, "netsend_tmr", NETSEND_MSG_PERIOD, NETSEND_MSG_PERIOD, OS_OPT_TMR_PERIODIC, netsend_msg_timer, NULL, &err);
+    OSTmrStart(&netsend_timer, &err);
+
+//    OSTmrCreate(&netsend_timer, "netsend_tmr", NETSEND_MSG_PERIOD, NETSEND_MSG_PERIOD, OS_OPT_TMR_PERIODIC, netsend_msg_timer, NULL, &err);
+//    OSTmrStart(&netsend_timer, &err);
+}
+

APP/network/nettimer.h

@@ -0,0 +1,38 @@
+#ifndef _NET_TIM_H_
+#define _NET_TIM_H_
+
+#include "../../_Lib-3.5/CMSIS/stm32f10x.h"
+#include "../../User/includes.h"
+#include "../globalDef.h"
+#include "uplink.h"
+#include "../gateway_collect/gateway_collect.h"
+#include "timeout.h"
+
+#define NETSEND_MSG_PERIOD (1*60)//(5*60) //(500*10)//*60) // 1为1S， 5为5S 5*60：5分钟
+#define NETSEND_HOUR_PERIOD (24*60*60) // 24小时
+extern volatile uint32_t TickCounter;
+
+extern void nettimer_init(void);
+
+typedef struct _key_func
+{
+  uint8_t state;
+  uint16_t num;
+  timeout_t tt_key_state;
+  uint8_t keyvalue;
+  uint8_t optcmd; // 执行的动作
+}key_func_t;
+extern key_func_t key_info;
+
+
+extern timeout_t g_timeOut;
+extern timeout_t g_usmTimeOut;
+extern timeout_t g_uart4Time; // 串口4的接收中断计时
+extern timeout_t g_uart5Time; // 串口5的接收中断计时
+extern timeout_t g_uart2Time; // 串口5的接收中断计时
+
+extern void timeout_setValue(timeout_t *tt,uint32_t val);
+extern void timeout_start(timeout_t *tt);
+extern void timeout_stop(timeout_t *tt);
+extern uint8_t timeout_isOut(timeout_t *tt);
+#endif

APP/network/oiltank.c

@@ -0,0 +1,146 @@
+#include "oiltank.h"
+#include "../network_mgr/net_proc.h"
+#include "nettimer.h"
+//uint8_t oil_buff[1024] = {0};
+
+#define DATA_LEN  450 //479
+int oiltank_operation(uint8_t uart)
+{
+
+   // uint8_t rcv_buf[1024]= {0};
+    uint8_t send_buf[128]= {0};
+    uint32_t i, rcv_size = 0, send_size = YB_SS160_SEND_SIZE;
+    uint32_t remainSize = 0;
+    oiltankDataCmd0x2021 pmsg;
+    RS232_YB_SS160_SEND *p_tank_tx = (RS232_YB_SS160_SEND *)send_buf;
+    static uint8_t flag = 0, bread = 0,bfirstread = 1;
+    OS_ERR      err;
+
+    if(g_runData.bUpdate!=0) return 0;
+		
+    uart = OILTANK_UART;
+   // memset(oil_buff,0,sizeof(oil_buff));
+    if((g_runData.bread==1) && (bread == 0)) { // 服务器读取的数据
+        p_tank_tx->SOH = 0x01;
+        strcpy((char *)p_tank_tx->FCN_CODE, "i20100");
+        p_tank_tx->EXT = 0x03;
+
+        data_dump("server read", send_buf, send_size);
+        uart_msg_send(uart, (char *)p_tank_tx, send_size);//
+        //uart_msg_send(UART2_ID, (char *)p_tank_tx, send_size);//
+        timeout_start(&g_timeOut);
+        flag = 2;
+        bread = 1;
+    }
+    else
+    {
+        if((timeout_isOut(&g_timeOut)==1) || (bfirstread == 1)){ // 液位仪定时读取
+             timeout_stop(&g_timeOut);
+            if(g_oilReadMsg.bInit==0x05){
+                memcpy(send_buf,g_oilReadMsg.param,g_oilReadMsg.paraLen);
+            }
+            else {
+               p_tank_tx->SOH = 0x01;
+               strcpy((char *)p_tank_tx->FCN_CODE, "i20100");
+               p_tank_tx->EXT = 0x03;
+            }
+
+           data_dump("YB_SS160 uart 5 oiltank send", send_buf, send_size);
+           uart_msg_send(uart, (char *)p_tank_tx, send_size);//
+           //uart_msg_send(UART2_ID, (char *)p_tank_tx, send_size);
+           timeout_start(&g_timeOut);
+           flag = 2;
+           bfirstread = 0;
+        }
+        else{
+            if(timeout_isOut(&g_uart4Time)==1){
+        //        rcv_size = uart_blocking_read_len((char *)oil_buff, UART4_ID);//透传口
+                if(rcv_size){
+                   set_led_status(0,1);
+                   data_dump("uart 4 recv", g_oilreadDa.oil_buff, rcv_size);
+                   uart_msg_send(uart, (char *)g_oilreadDa.oil_buff, rcv_size);//
+                   flag = 1;
+                }
+            }
+        }
+    }
+
+    if((g_oilreadDa.bfinish == 1 && g_oilreadDa.len!=0)) {
+        data_dump("oil_buff", g_oilreadDa.oil_buff, g_oilreadDa.len);
+        rcv_size = g_oilreadDa.len;
+        g_oilreadDa.bfinish = 0;
+        g_oilreadDa.len = 0;
+        g_oilreadDa.len1 = 0; // 收到有结束符的了，不再处理没有结束符的
+        printf("test_01\n");
+    }
+    else if( timeout_isOut(&g_uart5Time)==1 && g_oilreadDa.len1!=0){
+        data_dump("oil_buff_01", g_oilreadDa.oil_buff, g_oilreadDa.len1);
+         rcv_size = g_oilreadDa.len1;
+        g_oilreadDa.bfinish = 0;
+        g_oilreadDa.len = 0;
+        g_oilreadDa.len1 = 0;
+         printf("test_02\n");
+
+    }
+    else {
+        if(timeout_isOut(&g_uart5Time)==0) return 0;
+    }
+
+    set_led_status(4,1);
+   // rcv_size = uart_blocking_read_len((char *)oil_buff, uart); //接收液位仪返回的数据
+
+    if(rcv_size) {
+        set_led_status(4,0);
+      //  if(flag==1) uart_msg_send(UART4_ID, (char *)oil_buff, rcv_size);// 发送给加油站的控制机
+        printf("\r\n rcv_size = %d,flag = %d \r\n",rcv_size,flag);
+        if(flag==1) {
+            set_led_status(0,0);
+            if(g_runData.bsendOilData<READ_TIMER) return 0;
+        }
+					
+        pmsg.sn = downlink_config.gateway_id;
+        if(flag != 2) return 0;  // 液位仪控制器产生的指令，不再向服务器上报
+        if(rcv_size<=DATA_LEN){
+             printf("test_03\n");
+            if((flag == 2) || (g_runData.bread==1)){ //(g_runData.bsendOilData>=READ_TIMER)
+                pmsg.len = rcv_size;
+                pmsg.frameNo = 0xFF;
+                memset(pmsg.rcv_buf,0,sizeof(pmsg.rcv_buf));
+                memcpy(pmsg.rcv_buf,g_oilreadDa.oil_buff,rcv_size);
+                tax_net_send((uint8_t*)&pmsg,rcv_size+7,0x03,SECOND_TYPE_DATA_OIL);
+                printf("send oiltank data to server\r\n");
+                g_runData.bsendOilData = 0;
+                g_runData.bread = 0;
+                bread = 0;
+            }
+        }
+        else {
+             printf("test_04  bsend = %d\n",g_runData.bsendOilData);
+            if((flag == 2) || (g_runData.bread==1)){//g_runData.bsendOilData>=READ_TIMER
+                pmsg.len = DATA_LEN;
+                pmsg.frameNo = 0x82;
+                memset(pmsg.rcv_buf,0,sizeof(pmsg.rcv_buf));
+                memcpy(pmsg.rcv_buf,g_oilreadDa.oil_buff,DATA_LEN);
+              //  data_dump("YB_SS160 oiltank send_01", pmsg.rcv_buf, DATA_LEN);
+                printf("send oiltank data the first\r\n");
+                tax_net_send((uint8_t*)&pmsg,DATA_LEN+7,0x03,SECOND_TYPE_DATA_OIL);
+                OSTimeDlyHMSM(0, 0, 1, 0, OS_OPT_TIME_DLY, &err);
+
+                pmsg.frameNo = 0x01;
+                remainSize = rcv_size-DATA_LEN;
+                pmsg.len = remainSize;
+                memset(pmsg.rcv_buf,0,sizeof(pmsg.rcv_buf));
+                memcpy(pmsg.rcv_buf,g_oilreadDa.oil_buff+DATA_LEN,remainSize);
+                printf("send oiltank data the second\r\n");
+              //  data_dump("YB_SS160 oiltank send_02", pmsg.rcv_buf, remainSize);
+                tax_net_send((uint8_t*)&pmsg,remainSize+7,0x03,SECOND_TYPE_DATA_OIL);
+                g_runData.bsendOilData = 0;
+                g_runData.bread = 0;
+                bread = 0;
+                timeout_start(&g_timeOut);
+            }
+        }
+    }
+
+    return 0;
+}

APP/network/oiltank.h

@@ -0,0 +1,44 @@
+#ifndef _OILTANK_H_
+#define _OILTANK_H_
+
+#include "../../_Lib-3.5/CMSIS/stm32f10x.h"
+#include "../../User/includes.h"
+#include "../globalDef.h"
+#include "uplink.h"
+
+
+#define YB_SS160_SOH        0x01		//起始码<SOH>
+#define YB_SS160_EXT        0x03		//结束标志位
+
+#define YB_SS160_FCN_FLAG			0x2626//"&&"
+
+//波特率 9600，帧格式为：起始位 1，  数据位 8，停止位 1，共 10 位，无校验(N)。
+/*
+1 i201 读储油罐状态及数据
+                读储油罐状态及数据，包括油罐的温度、水位、油位、水量、油量、标准油量等 信息。
+2 i205 读储油罐报警信息
+                读取高低液位报警、水位过高报警、高低温度报警、油品泄漏报警、探针失灵报 警。
+3 i20C 读储油罐最近一次进油报告
+4 i501 读取系统时间
+5 i602 读取油品数据
+6 i607 读取油罐直径
+7 s501 设置系统时间
+8 i10100 系统状态
+*/
+
+//SS160控制器后台通讯协发送
+typedef struct {
+    unsigned char                  SOH;              //协议头
+    unsigned char                  FCN_CODE[6];      //本机地址
+    unsigned char                  EXT;              //功能码或命令字
+} BYTE1 RS232_YB_SS160_SEND;
+
+
+#define YB_SS160_SEND_SIZE 		sizeof(RS232_YB_SS160_SEND)
+
+#define OILTANK_UART	UART5_ID //UART4_ID
+
+
+extern int oiltank_operation(uint8_t uart);
+
+#endif

APP/network/timeout.c

@@ -0,0 +1,55 @@
+#include "timeout.h"
+
+
+/**
+  * @brief 设置定时器
+  * @par param[timeout_t] *tt
+  * @par param[uint32_t] val，延时ms
+  * @par param[uint8_t] flg。0:不使能；1单次使能；0xFF连续使能
+  */
+void timeout_setValue(timeout_t *tt,uint32_t val){
+  tt->counter = Get_SysTick();
+  tt->timeout = val;
+}
+/**
+ * @brief 启动定时器
+ * @param  tt               定时器指针
+ * @param  flg              是否开启
+ */
+void timeout_start(timeout_t *tt){
+    tt->counter = Get_SysTick();
+    tt->flag = 1;
+
+}
+
+/**
+ * @brief 停止定时器
+ * @param  tt               定时器指针
+ */
+void timeout_stop(timeout_t *tt){
+  tt->flag = 0;
+}
+
+
+/**
+ * @brief 返回定时器是否超时
+ * @param  tt               定时器指针
+ * @return uint8_t 1:超时（或flag==0），0:未超时
+ */
+uint8_t timeout_isOut(timeout_t *tt){
+  if(tt->flag){
+    if((Get_SysTick() - tt->counter) > tt->timeout){
+      tt->counter = Get_SysTick();
+      if(tt->flag == 1){
+        tt->flag = 0;
+      }
+      return 1;
+    }
+    else{
+      return 0;
+    }
+  }
+  else{
+    return 1;
+  }
+}

APP/network/timeout.h

@@ -0,0 +1,21 @@
+#ifndef _TIMEOUT_H_
+#define _TIMEOUT_H_
+
+#include "../../_Lib-3.5/CMSIS/stm32f10x.h"
+#include "../../User/includes.h"
+
+
+
+typedef struct
+{
+  uint8_t flag;
+  uint32_t counter;
+  uint32_t timeout;
+}timeout_t;
+
+extern void timeout_setValue(timeout_t *tt,uint32_t val);
+extern void timeout_start(timeout_t *tt);
+extern void timeout_stop(timeout_t *tt);
+extern uint8_t timeout_isOut(timeout_t *tt);
+
+#endif

APP/network/uplink.c

@@ -0,0 +1,167 @@
+#include "uplink.h"
+#include "device.h"
+#include "../dev_mgr/gateway/gateway.h"
+#include "../network_mgr/net_proc.h"
+#include "../../BSP/BSP.h"
+#include "downlink.h"
+#include "me3616.h"
+
+extern ME3616  air;
+extern volatile uint32_t TickCounter;
+//uplink_tax_t uplink_tax;
+/* 上报报税口的业务数据类(0x03)  0x2001*/
+int uplink_tax_comb(uint8_t *outdata,uint8_t *len, uint8_t node,uint8_t port,uint8_t gun,uint32_t seq_no)
+{
+    uplink_tax_t *p_msg = (uplink_tax_t *)outdata;
+
+//    p_msg->gateway_id = downlink_config.gateway_id;//GATEWAY_ID;
+//    p_msg->collect_id = downlink_config.collect_conf[node].collect_no; //nodeConf.taxconf[node].device_id;
+//    p_msg->tax_no = downlink_config.collect_conf[node].tax_conf[port].tax_id;//nodeConf.taxconf[node].port[port].tax_id;
+//    p_msg->gun_no = downlink_config.collect_conf[node].tax_conf[port].gunid[gun];//nodeConf.taxconf[node].port[port].gun[gun].gun_no;
+//    p_msg->seq_no = seq_no;//此号需要加BCD码 nodeConf.taxconf[node].port[port].gun[gun].rcv_seq;
+//  
+    *len = sizeof(uplink_tax_t);
+	
+	return 0;
+}
+/* 上报液位仪的数据 数据类（0x03) 0x2021 */
+int uplink_oiltank_datacmd_0x2021(uint8_t *outdata, uint16_t *len)
+{
+
+	return 0;
+}
+
+/*上报的系统类(0x01)的 税控序列号 以及枪的个数 0x2011*/
+void uplink_tax_systemcmd_0x2011(uint8_t *outdata,uint8_t *len, uint8_t node,uint8_t port,uint8_t gun)
+{
+    syscmd0x2011 *pmsg = (syscmd0x2011 *)outdata;
+
+//    pmsg->gateway_sn = downlink_config.gateway_id; // 网关sn号
+//    pmsg->coll_sn = downlink_config.collect_conf[node].collect_no;; // 采集器SN
+//    pmsg->tax_no = downlink_config.collect_conf[node].tax_conf[port].tax_id; // 报税口号
+//    pmsg->encrypt = downlink_config.collect_conf[node].tax_type; //明文  密文
+//    pmsg->tax_factory = downlink_config.collect_conf[node].tax_conf[port].factory; // 厂家
+//    pmsg->gun_num = downlink_config.collect_conf[node].tax_conf[port].gun_num;
+//    memcpy(pmsg->minor_num,downlink_config.collect_conf[node].tax_conf[port].monitor_serino+5,10);
+
+    *len = sizeof(syscmd0x2011);
+	return ;
+}
+/* 上报的系统类(0x01)的 升级信息状态 0x2001 */
+void uplink_update_systemcmd_0x2001(uint8_t *outdata,uint8_t *len,uint16_t type,uint32_t sn,uint16_t taskNo,uint8_t status)
+{
+    syscmd0x2001 *pmsg = (syscmd0x2001*)outdata;
+
+    pmsg->targetType = type;
+    pmsg->deviceSn = sn;
+    pmsg->taskNo = taskNo;
+    pmsg->status = status;
+    *len = sizeof(syscmd0x2001);
+	
+	return;
+}
+
+/*上报的状态类(0x02)的 固件信息 0x2001*/
+void uplink_tax_statusmcmd_0x2001(uint8_t *outdata,uint8_t *len,uint16_t type, uint8_t index)
+{
+    statusCmd0x2001 *pmsg = (statusCmd0x2001 *)outdata;
+
+    memset(pmsg->Uuid,0,12);//UUID
+    memset(pmsg->Imei,0,15); //IMEI
+    memset(pmsg->Iccid1,0,20);//ICCID1
+    memset(pmsg->Iccid2,0,20);//ICCID2
+    memset(pmsg->Iccid3,0,20);//ICCID3
+    pmsg->gateway_Sn        = g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn; //网关编号
+    pmsg->target_Type       = type;//设备类型（0x0101：网关；0x0201；采集器：0x0301:液位仪采集器；0x0401：屏采集器）
+    switch (type){
+    case DEVICE_GATEWAY: // 网关的
+        pmsg->sn                = g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn;//设备SN
+        pmsg->bootloader_Version= g_firmwareMsg.gatewayMsg.verMsg.gate_bootloaderVr; //bootloader版本
+        pmsg->app_Version       = g_firmwareMsg.gatewayMsg.verMsg.gate_appVr;//APP版本
+        pmsg->reset_Times       = g_firmwareMsg.gatewayMsg.gate_resetnum;//复位次数
+        pmsg->last_Reset_Type   = g_firmwareMsg.gatewayMsg.gate_resetType;//最后一次复位类型
+       
+        memcpy(pmsg->Uuid  ,g_firmwareMsg.gatewayMsg.Uuid,12);//UUID
+        memcpy(pmsg->Imei  ,g_firmwareMsg.gatewayMsg.Imei,15); //IMEI
+        memcpy(pmsg->Iccid1,g_firmwareMsg.gatewayMsg.Iccid1,20);//ICCID1
+        memcpy(pmsg->Iccid2,g_firmwareMsg.gatewayMsg.Iccid2,20);//ICCID2
+        memcpy(pmsg->Iccid3,g_firmwareMsg.gatewayMsg.Iccid3,20);//ICCID3
+        break;
+    case DEVICE_COLLECT: // 采集器的
+       
+        break;
+    case DEVICE_OILL: // 油罐车的
+        pmsg->sn                = g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn;//设备SN
+        pmsg->bootloader_Version= g_firmwareMsg.gatewayMsg.verMsg.gate_bootloaderVr; //bootloader版本
+        pmsg->app_Version       = g_firmwareMsg.gatewayMsg.verMsg.gate_appVr;//APP版本
+        pmsg->reset_Times       = g_firmwareMsg.gatewayMsg.gate_resetnum;//复位次数
+        pmsg->last_Reset_Type   = g_firmwareMsg.gatewayMsg.gate_resetType;//最后一次复位类型
+       
+        memcpy(pmsg->Uuid  ,g_firmwareMsg.gatewayMsg.Uuid,12);//UUID
+        memcpy(pmsg->Imei  ,g_firmwareMsg.gatewayMsg.Imei,15); //IMEI
+        memcpy(pmsg->Iccid1,g_firmwareMsg.gatewayMsg.Iccid1,20);//ICCID1
+        memcpy(pmsg->Iccid2,g_firmwareMsg.gatewayMsg.Iccid2,20);//ICCID2
+        memcpy(pmsg->Iccid3,g_firmwareMsg.gatewayMsg.Iccid3,20);//ICCID3
+        break;
+    case DEVICE_LED: // 显示屏的
+
+        break;
+    default:
+        break;
+    }
+
+    *len = sizeof(statusCmd0x2001);
+    return;
+}
+/*上报的状态类(0x02)的 状态信息 0x2002*/
+void uplink_tax_statusmcmd_0x2002(uint8_t *outdata, uint8_t *len, uint16_t type, uint8_t index)
+{
+    statusCmd0x2002 *pmsg = (statusCmd0x2002 *)outdata;
+
+    pmsg->gateway_sn = downlink_config.gateway_id; // 网关sn号
+    pmsg->target_Type = type;
+    g_runData.rssi_4G = air.State.dBm+1000;
+    g_firmwareMsg.gatewayMsg.gate_runTime = TickCounter/1000;
+    pmsg->reserver = 0;
+    pmsg->loraRcvNum = 0;
+    pmsg->loraSendNum = 0;
+    pmsg->loraPaIndex = 0;
+    switch (type)
+    {
+    case DEVICE_GATEWAY: // 网关的
+        pmsg->sn = downlink_config.gateway_id; //
+        pmsg->rssi_lora = 0;
+        pmsg->rssi_4G = g_runData.rssi_4G;
+        pmsg->status = 1;
+        pmsg->taxstatus[0] = 0;
+        pmsg->taxstatus[1] = 0;
+        pmsg->run_Time          = g_firmwareMsg.gatewayMsg.gate_runTime;//运行时常
+        pmsg->voltage           = g_firmwareMsg.gatewayMsg.fVol.voltage; // 电压
+        pmsg->tempperature      = g_firmwareMsg.gatewayMsg.fTemper.temperature; // 温度
+        break;
+    case DEVICE_COLLECT: // 采集器的
+       
+        break;
+    case DEVICE_OILL: // 油罐车的
+        pmsg->sn = downlink_config.gateway_id; //
+        pmsg->rssi_lora = 0;
+        pmsg->rssi_4G = g_runData.rssi_4G;
+        pmsg->status = 1;
+        pmsg->taxstatus[0] = 0;
+        pmsg->taxstatus[1] = 0;
+        pmsg->run_Time          = g_firmwareMsg.gatewayMsg.gate_runTime;//运行时常
+        pmsg->voltage           = g_firmwareMsg.gatewayMsg.fVol.voltage; // 电压
+        pmsg->tempperature      = g_firmwareMsg.gatewayMsg.fTemper.temperature; // 温度
+        break;
+    case DEVICE_LED: // 显示屏的
+
+        break;
+    default:
+        break;
+    }
+    *len = sizeof(statusCmd0x2002);
+    return;
+}
+
+
+

APP/network/uplink.h

@@ -0,0 +1,145 @@
+#ifndef __UPLINK_H__
+#define __UPLINK_H__
+
+#include "stm32f10x.h"
+
+// 设备类型
+enum {
+    DEVICE_GATEWAY = 0x0101, // 网关
+    DEVICE_COLLECT = 0x0201, //采集器
+    DEVICE_OILL    = 0x0301, //油罐车
+    DEVICE_LED     = 0x0401, // 显示屏
+};
+
+
+#define GATEWAY_ID  0X01
+
+#define TAX_UPLINK_LEN 34
+
+#define TAX_UPLINK_TYPE 0X20 // 上行
+
+#define FIRST_TYPE_SYST 0x01 // 系统类
+#define FIRST_TYPE_STATUS 0x02 // 状态类
+#define FIRST_TYPE_DATA 0x03 //数据类
+#define FIRST_TYPE_TEST 0x04 // 产测类
+
+enum {
+    SECOND_TYPE_DATA_TAX = 0x2001 , //报税口类
+    SECOND_TYPE_DATA_LED = 0x2011, // 显示屏
+    SECOND_TYPE_DATA_OIL = 0x2021, // 液位仪
+};
+
+// 系统类数据 0x01
+enum {
+    COLL_DN_SYS_CMD1001 = 0x1001,  // 升级下行
+
+    GATEWAY_DN_SYS_CMD1003 = 0x1003, // 系统类，配置mqtt服务器
+
+    COLL_DN_SYS_CMD1011 = 0x1011, //系统类 采集路由信息初始化下行
+    COLL_DN_SYS_CMD1012 = 0x1012, // 系统类，刷新税控序列号
+    COLL_DN_SYS_CMD1021 = 0x1021, // 系统类，系统重新启动
+
+    OILL_DN_SYS_CMD1031 = 0x1031, // 系统类，油罐下行配置
+
+    COLL_UP_SYS_CMD2001 = 0x2001, //  升级状态上行
+
+    COLL_UP_SYS_CMD2011 = 0x2011, // 系统类0x2011数据上报
+};
+// 状态类信息  0x02
+enum {
+    COLL_DN_STATUS_CMD1001 = 0x1001, // 状态类  固件信息下行
+
+    COLL_UP_STATUS_CMD2001 = 0x2001, // 固件信息
+    COLL_UP_STATUS_CMD2002 = 0x2002, // 状态信息上行
+};
+// 数据类 0x03
+enum {
+    COLL_TAX_DA_CMD_UP = 0x2001, // 业务数据上报
+    COLL_OIL_DATA_CMD1021 = 0x1021, // 油罐信息下行
+};
+
+/*业务数据上报服务器 0x2001*/
+typedef struct _uplink_tax
+{
+    uint32_t gateway_id; //网关id
+    uint32_t collect_id;  //采集器id
+    uint8_t tax_no;  // 报税口编号
+    uint8_t gun_no;  // 枪号
+    uint32_t seq_no;  // 流水号
+    uint32_t unit_price;//单价
+    uint32_t oil_volume;//当次加油量
+    uint32_t price;//当次金额
+    uint64_t total_oil_volume;  //总油量
+    uint64_t total_price; //总金额
+}__attribute__((packed)) uplink_tax_t;
+
+/*  系统信息(0x01)上报 0x2011 指令*/
+typedef struct _syscmd_0x2011_{
+    uint32_t gateway_sn; // 网关编号
+    uint32_t coll_sn;  // 采集器编号
+    uint8_t  tax_no; // 报税口编号
+    char minor_num[10]; // 税控序列号
+    uint8_t tax_factory; // 税控厂家
+    uint8_t encrypt; // 加密状态
+    uint8_t gun_num;  // 枪的个数
+
+}__attribute__((packed)) syscmd0x2011;
+/* 系统升级状态信息(0x01)上报 0x2001 */
+typedef struct _syscmd_0x2001_{
+    uint16_t targetType; // 设备类型
+    uint32_t deviceSn; // 设备SN号
+    uint16_t taskNo; // 任务号
+    uint8_t status;   // 当前状态
+}__attribute__((packed)) syscmd0x2001;
+
+/* 状态信息类0x02 上报 固件信息消息 0x2001 */
+typedef struct _status_cmd_0x2001_{
+    uint32_t gateway_Sn; //网关编号
+    uint16_t target_Type;//设备类型（0x0101：网关；0x0201；采集器：0x0301:液位仪采集器；0x0401：屏采集器）
+    uint32_t sn	;//设备SN
+    uint32_t bootloader_Version; //bootloader版本
+    uint32_t app_Version;//APP版本
+    uint32_t reset_Times;//复位次数
+    uint8_t last_Reset_Type;//最后一次复位类型
+    char Uuid[12];//UUID
+    char Imei[15]; //IMEI
+    char Iccid1[20];//ICCID1
+    char Iccid2[20];//ICCID2
+    char Iccid3[20];//ICCID3
+}__attribute__((packed)) statusCmd0x2001;
+
+/*状态信息类0x02 上报 状态信息0x2002*/
+typedef struct _status_cmd_0x2002_{
+    uint32_t gateway_sn;// 网关编号
+    uint16_t target_Type;//设备类型（0x0101：网关；0x0201；采集器：0x0301:液位仪采集器；0x0401：屏采集器）
+    uint32_t sn; //编号
+    uint32_t run_Time;//运行时常
+    uint32_t voltage; // 电压
+    uint32_t tempperature; // 温度
+    uint8_t loraPaIndex;  // lora信道的索引 用的为第几号信道
+    uint16_t rssi_lora;//Lora信号强度（+1000）
+    uint16_t loraSendNum; // lora发送包个数
+    uint16_t loraRcvNum; // lora接收包个数
+    uint16_t rssi_4G;//4G信号强度
+    uint8_t status;//状态(0x00：离线；0x01：在线)
+    uint8_t taxstatus[2]; // 两个报税口的状态(0x00:离线  0x01:在线)
+    uint32_t reserver; // 预留
+}__attribute__((packed)) statusCmd0x2002;
+
+
+/* 液位仪数据类0x03, 上报 数据：0x2021 */
+typedef struct _oiltank_data_cmd_0x2021_{
+    uint32_t sn;
+    uint8_t frameNo;
+    uint16_t len;
+    uint8_t rcv_buf[1024];
+}__attribute__((packed)) oiltankDataCmd0x2021;
+
+extern int uplink_tax_comb(uint8_t *outdata, uint8_t *len, uint8_t node, uint8_t port, uint8_t gun, uint32_t seq_no);
+extern void uplink_tax_systemcmd_0x2011(uint8_t *outdata,uint8_t *len, uint8_t node,uint8_t port,uint8_t gun);
+extern void uplink_update_systemcmd_0x2001(uint8_t *outdata, uint8_t *len, uint16_t type, uint32_t sn, uint16_t taskNo, uint8_t status);
+
+extern void uplink_tax_statusmcmd_0x2001(uint8_t *outdata, uint8_t *len, uint16_t type, uint8_t index);
+extern void uplink_tax_statusmcmd_0x2002(uint8_t *outdata,uint8_t *len, uint16_t type,uint8_t index);
+#endif
+

APP/network_mgr/air72x/air72x.c

@@ -0,0 +1,762 @@
+/** ******************************************************************************
+ * @file    AIR.c
+ * @author  度云未来 DOIOT
+ * @brief   EC20模块AT指令简易串口驱动
+ ******************************************************************************
+ * @attention
+ * <h2><center>&copy; Copyright (c) 2019 成都度云未来
+ * All rights reserved.</center></h2>
+ * 注意:本程序针对cubemx 生成的hal库快速开发
+ * 环境:keil5.0
+ * 描述：
+ * 文件版本：1.3		更新时间2020/10/15   已支持TCP,LWM2M的连接
+ ********************************************************************************/
+/*必备依赖*/
+#include "includes.h"
+#include "trace.h"
+#include "me3616.h"				 	/*文件的头文件*/
+#include "at_module.h"		 	/*AT指令相关的头文件*/
+#include "string_fuc.h"
+#include "bsp.h"
+
+#include <stdarg.h>		
+#include <string.h>		
+#include <stdlib.h>		
+#include <stdio.h>	
+/********************************************************************************/
+/*
+测试了strstr和kmp的性能，最终用strstr。
+*/
+/* AIR类的句柄,该句柄会默认调用 */
+ME3616  air;
+	
+/**
+* @brief  AIR硬件开机
+* @param	flug = 1,阻塞开机，会直到开机成功，且读取完全部开机信息后才会退出
+* @param	flug = 0,操作完硬件开机后立即返回
+* @param  [Antiphase_flug]额外参数	: 以宏形式的标志，1为反相，0为不反相
+* 【是否反相根据硬件电路决定，如果mcu拉低，模组也被拉低，则不需要反相，否则给反相位置1即可】
+* 	如果在计时器启动前调用了，建议选择直接返回[针对RTOS]
+*/	
+uint8_t AIR_Power_On(uint8_t flug)
+{
+	OS_ERR err;
+	char buff[200]={0};
+	
+  OSTimeDlyHMSM(0, 0, 0, 500, OS_OPT_TIME_DLY, &err);	
+	GPIO_SetBits(GPIOC, GPIO_Pin_3);
+	GPIO_ResetBits(GPIOD,  GPIO_Pin_14);	
+	
+	OSTimeDlyHMSM(0, 0, 2, 0, OS_OPT_TIME_DLY, &err);	
+	GPIO_SetBits(GPIOD, GPIO_Pin_14);
+	OSTimeDlyHMSM(0, 0, 1, 0, OS_OPT_TIME_DLY, &err);	
+
+	if(flug)
+	{
+		/*这里是为了吃掉三条开机信息，如果直接开始往下运行，开就信息可能会干扰*/
+		memset(buff,0,200);
+		if(Module_Blocking_Read(buff,13000))
+		{
+			printf("Power on info : %s\r\n", buff);
+//			printf("\nPower test\r\n");
+			air.State.pwr=1;
+			if(strstr(buff,"*CGEV:")) 
+			{
+				/*完整开机需要的时常很长*/
+				AT_CMD_Polling("AT\r\n","OK",200,15000);
+				AT_CMD_Polling("AT\r\n","OK",200,15000);
+				AT_CMD_Polling("AT\r\n","OK",200,15000);
+				
+				ME3616_INFO("AIR Hardware Power On OK!");
+
+                                module_printf("AT+CREG=1\r\n");
+                                if(Module_Read_A_CRC("OK\r\n", 300)){
+                                    printf("\r\n set AT+CREG = OK \r\n");
+                                }
+                                module_printf("AT+CREG=?\r\n"); // 查询网络注册状态
+				return 1;
+			}
+		}
+	}
+
+	return 0;
+}
+
+/**
+* @brief  AIR硬件复位
+*	@param  flug:复位标志，1，阻塞复位，会直到开机成功才退出，开机时间较长，2，立即返回*/
+uint8_t AIR_HARD_Rest(uint8_t flug)
+{		
+	return 0;
+}
+
+/**
+* @brief  AIR软件复位
+*	@param  flug:复位标志，1，阻塞复位，会直到开机成功才退出，软复位很快，2，立即返回*/
+uint8_t AIR_SOFT_Rest(uint8_t flug)
+{
+	return 0;
+}
+
+/**
+* @brief  AIR读取网络状态并打印数据
+**/
+uint8_t AIR_READ_EPS()
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	char get_buff[100];
+	int log;
+	ME3616_INFO("Start to query network registration status");
+	module_printf("AT+CEREG?\r\n");
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"+CEREG:"))
+		{
+			AT_GET_Data_2Param(buff,(uint8_t*)get_buff,",","OK");
+			log=atoi(get_buff);
+			air.State.eps=log;	/*装载标数据*/
+			air.flug.eps=1;		/*装载成功标志*/
+			switch(log)
+			{			
+				case 0: ME3616_INFO("You are not logged on to the network. You are not searching the network at present"); break;
+				case 1: ME3616_INFO("Local network already logged in"); break;
+				case 2: ME3616_INFO("\r\nYou are not logged on to the network. You are currently searching the network\r\n"); break;
+				case 3: ME3616_INFO("\r\nRegistration denied\r\n"); break;
+				case 4: ME3616_INFO("\r\nUnknown state\r\n"); break;
+				case 5: ME3616_INFO("\r\nYou have logged in to the network and are roaming\r\n"); break;
+				default: 
+				{
+					ME3616_ERROR("Response ME3616_ERROR:%s",buff);
+					return  33;//设定的错误码
+				}
+			}
+			return log+1;
+		}else {
+			ME3616_ERROR("%s",buff);
+			return 0;
+		}
+	} 
+	
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+
+/**
+* @brief  AIR读取网络信号强度
+* @param  rssi:用来装载的参数，会装载信号强度原文[弃用]
+* @param  ber:用来装载的参数， 会装载错码率原文[弃用]
+*	*/
+uint8_t AIR_READ_CSQ()
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	char get_buff[100]={0};
+	int log;
+	
+	#if(config_CHINESE_LOG)
+	ME3616_INFO("开始查询网络信号强度");
+	#else
+	ME3616_INFO("Start querying network signal strength");
+	#endif
+
+	module_printf("AT+CSQ\r\n");
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"+CSQ:"))
+		{
+			AT_GET_Data_2Param(buff,(uint8_t*)get_buff,"+CSQ:",",");
+			log=atoi(get_buff);
+			air.State.rssi=log;
+			air.flug.rssi=1;		/*装载成功标志*/
+			if(log==99) 							{air.State.dBm = 0; ME3616_INFO("signal intensity:there is no signal");}
+			else if(log>=31&&log<=99) {air.State.dBm = log*2-113; ME3616_INFO("signal intensity:-51dBm or higher");}
+			else if(log>=2&&log<31)		{air.State.dBm = log*2-113; ME3616_INFO("signal intensity:-109dBm ~ -53dBm");}
+			else if(log==1)						{air.State.dBm = -111; ME3616_INFO("signal intensity:-111dBm");}
+			else 											{air.State.dBm = log*2-113; ME3616_INFO("signal intensity:-111dBm or less");}
+			
+			AT_GET_Data_2Param(buff,(uint8_t*)get_buff,",","OK");
+			log=atoi(get_buff);
+			air.State.ber=log;
+			air.flug.ber=1;		/*装载成功标志*/
+			//*ber=log;
+			switch(log)
+			{	
+				case 0: ME3616_INFO("Bit error rate:<0.01%"); break;
+				case 1: ME3616_INFO("Bit error rate:0.01% --- 0.1%"); break;
+				case 2: ME3616_INFO("Bit error rate:0.1% --- 0.5%"); break;
+				case 3: ME3616_INFO("Bit error rate:0.5% --- 1.0%"); break;
+				case 4: ME3616_INFO("Bit error rate:1.0% --- 2.0%"); break;
+				case 5: ME3616_INFO("Bit error rate:2.0% --- 4.0%"); break;
+				case 6: ME3616_INFO("Bit error rate:4.0% --- 8.0%"); break;
+				case 7: ME3616_INFO("Bit error rate:> 8.0%"); break;
+				case 8: ME3616_INFO("Bit error rate:So far or not measurable");break;
+				default: 
+				{
+					ME3616_ERROR("So far or not measurable");
+					return  33;//设定的错误码
+				}
+			}
+		return log+1;
+		}
+		{
+		ME3616_ERROR("%s",buff);
+		return 0;
+		}
+	} 
+	
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+
+/**
+* @brief  AIR读取精确的网络信号强度
+*	*/
+int AIR_READ_CESQ()
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	char get_buff[100]={0};
+	int log;
+	ME3616_INFO("Start querying network signal strength");
+	module_printf("AT+CESQ\r\n");
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"+CESQ:"))
+		{
+			AT_GET_Data_2Param(buff,(uint8_t*)get_buff,"+CESQ: ",",");
+			log=atoi(get_buff);
+			//me3616.State.rssi=log;
+			air.flug.dBm=1;		/*装载成功标志*/
+			log=atoi(get_buff);
+			
+			log+=-110;/*转化成dBm*/
+			air.State.dBm=log;
+			
+			ME3616_INFO("signal intensity:%ddBm");
+		return log+1;
+		}
+		{
+		ME3616_ERROR("%s",buff);
+		return 0;
+		}
+	} 
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+
+/**
+* @brief  AIR读取SIM卡的CCID
+* @param  rssi:用来装载的参数，会装载信号强度原文
+* @param  ber:用来装载的参数， 会装载错码率原文
+*	*/
+uint8_t AIR_READ_CCID()
+{
+    char buff[MODULE_RDA_MAXlen]={0};
+    char get_buff[32]={'\0'};
+
+    ME3616_INFO("Start to query SIM card iccid");
+    module_printf("AT+ICCID\r\n");
+    if(Module_Blocking_Read(buff,3000))
+    {
+        if(strstr(buff,"+ICCID:"))
+        {
+            if(AT_GET_Data_2Param(buff,(uint8_t*)get_buff, "+ICCID: ", "\r\n"))//0d0a
+            {
+                strcpy(air.State.iccid,get_buff);
+                air.flug.iccid=1;		/*装载成功标志*/
+                debug_printf("\r\nICCID:%s\r\n", get_buff);
+            }
+            else
+            {
+                ME3616_ERROR("%s",buff);
+                return 0;
+            }
+            return 1;
+        } else {
+            if(strstr(buff,"SIM not inserted"))
+            {
+                ME3616_ERROR("SIM card not inserted,Please check the SIM card");
+                return 0;
+            }
+            else
+            {
+                ME3616_ERROR("%s",buff);
+                return 0;
+            }
+        }
+    }
+    ME3616_ERROR("Response timeout");
+    return 0;
+}
+
+
+/**
+* @brief  AIR查询pin状态
+* @param  return 1 为ready，0 其他
+*	*/
+uint8_t AIR_READ_PIN()
+{
+	char buff[256]={0};
+
+	#if(config_CHINESE_LOG)
+	ME3616_INFO("开始查询PIN状态");
+	#else
+	ME3616_INFO("Start to query pin status");
+	#endif
+	
+	module_printf("AT+CPIN?\r\n");
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"+CPIN:"))
+		{
+			
+			air.State.pin=1;
+			air.flug.pin=1;		/*装载成功标志*/
+			
+			#if(config_CHINESE_LOG)
+			if(strstr(buff,"READY")) 				{ME3616_INFO("PIN状态: READY,已准备好");return 1;}
+			else if(strstr(buff,"SIM PIN")) {ME3616_INFO("PIN状态: 需要pin码");return 1;}
+			else if(strstr(buff,"SIM PUK")) {ME3616_INFO("PIN状态: PIN 码解锁密码");return 1;}
+			else if(strstr(buff,"PH-SIM PIN")) {ME3616_INFO("PIN状态: SIM 卡绑定密码");return 1;}
+			else if(strstr(buff,"SIM PIN2")) {ME3616_INFO("PIN状态: PIN2 码密码");return 1;}
+			else if(strstr(buff,"SIM PUK2")) {ME3616_INFO("PIN状态: PIN2 码解锁密码");return 1;}
+			else if(strstr(buff,"PH-NET PIN")) {ME3616_INFO("PIN状态: 网络密码");return 1;}
+			#else
+			if(strstr(buff,"READY")) 					 {ME3616_INFO("Pin status: READY");return 1;}
+			else if(strstr(buff,"SIM PIN"))	   {ME3616_INFO("Pin status: need pin");return 1;}
+			else if(strstr(buff,"SIM PUK")) 	 {ME3616_INFO("Pin status: Pin code unlock password");return 1;}
+			else if(strstr(buff,"PH-SIM PIN")) {ME3616_INFO("Pin status: SIM card binding password");return 1;}
+			else if(strstr(buff,"SIM PIN2"))   {ME3616_INFO("Pin status: Pin2 code");return 1;}
+			else if(strstr(buff,"SIM PUK2"))   {ME3616_INFO("Pin status: Pin2 code unlock password");return 1;}
+			else if(strstr(buff,"PH-NET PIN")) {ME3616_INFO("Pin status: Network password");return 1;}
+			#endif
+		}
+		else{
+		ME3616_ERROR("%s",buff);
+		return 0;
+		}
+	} 
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+
+/**
+* @brief  AIR查询CIMI状态
+*	*/
+uint8_t AIR_READ_CIMI()
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	#if(config_CHINESE_LOG)
+	ME3616_INFO("开始查询PIN状态");
+	#else
+	ME3616_INFO("Start to query pin status");
+	#endif
+	module_printf("AT+CIMI\r\n");
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"OK"))
+		{
+			AT_Extract_numbers(buff);							/*提纯数字*/
+			strcat(air.State.imsi,buff);
+			air.flug.imsi=1;
+			ME3616_INFO("CIMI:%s",buff);
+			return 1;
+		}
+		else{		
+			ME3616_ERROR("%s",buff);
+			return 0;
+		}
+	} 
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+
+/**
+* @brief  AIR查询IMEI并装载至寄存器
+* @param  
+*	*/
+uint8_t AIR_READ_IMEI()
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+
+	ME3616_INFO("Start query IMEI");
+	module_printf("AT+CGSN\r\n");
+	if(Module_Blocking_Read(buff,3000))
+	{
+		if(strstr(buff,"OK"))
+		{
+			char temp[32]={0};
+			AT_GET_Data_2Param(buff,(uint8_t*)temp, "", "OK");	/*头尾提取方法*/
+			AT_Extract_numbers(temp);							/*提纯数字*/
+			strcpy(air.State.imei,temp);
+			air.flug.imei=1;
+			debug_printf("\r\nIMEI:%s\r\n", temp);
+			return 1;
+		} else {
+			ME3616_ERROR("%s",buff);
+			return 0;
+		}
+	} 
+	ME3616_ERROR("Response timeout");
+	return 0;
+}
+
+/**
+* @brief  AIR查询IMEI并装载至寄存器
+* @param  
+*	*/
+uint8_t AIR_READ_Revision()
+{
+	return 0;
+}
+
+int AIR_HTTP_GET(const char *url, uint32_t len, uint32_t *pLen)
+{
+	int ret = 0;
+	char buff[MODULE_RDA_MAXlen]={0};
+	
+    //关闭UDP或TCP
+    module_printf("AT+CIPCLOSE\r\n");
+	Module_Read_A_CRC("CLOSE OK", 200);
+
+	//设置HTTP功能的承载类型
+    module_printf("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"\r\n");
+	Module_Read_A_CRC("OK", 200);
+
+	//设置pdp承载参数之APN
+	module_printf("AT+SAPBR=3,1,\"APN\",\"\"\r\n");
+	Module_Read_A_CRC("OK", 200);
+
+	//激活该承载的GPRS PDP上下文
+	module_printf("AT+SAPBR=1,1\r\n");
+	Module_Read_A_CRC("OK", 200);
+
+	//查询下承载的状态
+	module_printf("AT+SAPBR=2,1\r\n");
+	Module_Read_A_CRC("OK", 200);
+	
+	//HTTP协议栈初始化
+	module_printf("AT+HTTPINIT\r\n");
+	Module_Read_A_CRC("OK", 200);
+
+	//建立http链接
+	module_printf("AT+HTTPPARA=\"URL\",\"%s\"\r\n", url);
+	Module_Read_A_CRC("OK", 300);
+
+	//设置HTTP会话参数：CID
+	//module_printf("AT+HTTPPARA=\"CID\",1", url);
+	//Module_Read_A_CRC("OK", 300);	
+	
+	//发送的命令, 提取数据		AT+HTTPACTION=<method>
+	module_printf("AT+HTTPACTION=0\r\n");
+	/* OK
+	   +HTTPACTION: <Method>,<StatusCode>,<DataLen>
+	   +HTTPACTION: <Method>,<StatusCode>,<DataLen>
+	   +HTTPACTION: <Method>,<StatusCode>,<DataLen>
+	*/
+	Module_Read_A_CRC("OK", 300);
+
+	//TODO 提取数据长度
+	if(Module_Blocking_Read(buff,6000)) {
+		char *strx;
+
+		printf("%s\r\n", buff);
+		//+HTTPACTION: 0,200,55420
+		strx = strstr(buff, "," );
+		if(strx) {
+			printf("%s\r\n", strx);
+			strx += 1;
+			strx = strstr(strx, "," );
+			if(strx) {
+				printf("%s\r\n", strx);
+				strx += 1;
+				*pLen = atoi(strx);//获取接收长度
+			}
+		}
+		//sscanf(buff, "+HTTPACTION: %d,%d,%d", &method, &status_code, pLen);
+		//printf("%d, %d, %d\r\n", method, status_code, *pLen);
+		ret = 1;
+	} 	
+	
+    return ret;
+}
+
+char http_buffer[1024];
+uint8_t * AIR_HTTP_READ(uint32_t start_addr, uint32_t data_len)
+{
+	uint8_t *p_buf = NULL;
+	uint32_t read_len;
+	
+	//AT+HTTPREAD=<start_address>,<byte_size>
+	module_printf("AT+HTTPREAD=%d,%d\r\n", start_addr, data_len);
+	/* +HTTPREAD:<date_len>
+		<data>
+		OK
+	*/
+	memset(http_buffer, 0, sizeof(http_buffer));
+	if(Module_Blocking_Read(http_buffer, 300)) {
+		char temp[32]={0};
+		if(AT_GET_Data_2Param(http_buffer,(uint8_t*)temp, "+HTTPREAD: ", "\r\n")) {	/*头尾提取方法*/
+			read_len = atoi(temp);
+			if(data_len == read_len) {
+				//printf("%s", http_buffer);
+				p_buf = (uint8_t *)strstr(http_buffer, "+HTTPREAD: ");
+				p_buf = (uint8_t *)strstr((char *)p_buf, "\r\n");
+				p_buf += 2;/* data position. */
+			}
+		}
+	}
+
+	return p_buf;
+}
+
+/*--------------------------------MQTT------------------------------------------------------*/
+uint8_t AIR_MQTT_Set_Net(char *ip,char *port)
+{
+	if(strcpy(air.State.mqtt_ip,ip)) {
+		if(strcpy(air.State.mqtt_port,port)) {
+			air.flug.mqtt_ip=1;
+			air.flug.mqtt_port=1;
+			ME3616_INFO("Net Set OK!");
+			return 1;
+		}
+	}
+	return 0;
+}
+
+uint8_t AIR_MQTT_Connet(char *_productID,char *_deviceID,char *_secret)
+{
+	int mqttid;
+
+	if(!(air.flug.mqtt_ip&&air.flug.mqtt_port)) {
+		ME3616_INFO("The network port has not been configured");
+		return 0;
+	}
+
+	//AT+MCONFIG=<clientid>, XXXX, $$$$
+	module_printf("AT+MCONFIG=%s,%s,%s\r\n",_deviceID,_productID,_secret);
+        //printf("AT+MCONFIG=%s,%s,%s\r\n",_deviceID,_productID,_secret);
+	if(Module_Read_A_CRC("OK", 300)) {
+		//AT+MIPSTART=”ip或域名”,”port”
+		module_printf("AT+MIPSTART=\"%s\",\"%s\"\r\n",air.State.mqtt_ip,air.State.mqtt_port);	
+//		module_printf("AT+MIPSTART=\"%s\",\"%s\"\r\n","mqtt.cpyypt.cn","9000");	
+		
+		if(Module_Read_A_CRC("CONNECT OK", 1000)) {
+			module_printf("AT+MCONNECT=1,60\r\n");
+			if(Module_Read_A_CRC("CONNACK OK", 300)) {			
+				air.State.mqtt_id=mqttid;
+				air.State.MQTT_State=1;
+				ME3616_INFO("Connect MQTT Successful,MQTT id");
+				/***********************************/
+					module_printf("AT+MQTTMODE=1\r\n");
+					if(Module_Read_A_CRC("OK", 300))
+					{
+						ME3616_INFO("MQTTMODE Successful,MQTT MODE 1");
+					}
+					else
+					{
+						ME3616_ERROR("AT+MQTTMODE error");
+					}
+				/***********************************/
+					module_printf("ATE0\r\n");
+			    if(Module_Read_A_CRC("OK", 300)){
+				     ME3616_ERROR("ATE success\r\n");
+			    }
+			    else {
+				    ME3616_ERROR("ATE error\r\n");
+			    }
+				return 1;
+			} else {
+				ME3616_ERROR("AT+MCONNECT error");
+			}
+			
+		} else {
+			ME3616_ERROR("AT+MCONFIG error");
+		}
+	} else {
+		ME3616_INFO("Response timeout");
+	}
+	
+	return 0;
+}
+
+uint8_t AIR_MQTT_SUB(char * topic)
+{
+	if(!air.State.MQTT_State) {
+		ME3616_INFO("Cannot Connect MQTT");
+		return 0;
+	}
+
+	//AT+MSUB=<topic>,<qos>
+        module_printf("AT+MSUB=\"%s\", 0\r\n", topic);
+	if(Module_Read_A_CRC("SUBACK", 300)) {
+                //ME3616_INFO("Sub \"%s\" Successful", topic);
+               ME3616_INFO("Sub topic Successful");
+		return 1;
+	} else {
+		ME3616_INFO("Sub ERROR");
+		return 0;
+	}
+}
+
+uint8_t AIR_MQTT_PUB(char * topic, char *data, uint32_t len)
+{
+	if(!air.State.MQTT_State) {
+		ME3616_INFO("Cannot Connect MQTT");
+		return 0;
+	}
+#if ( 1 )
+//	printf("test  %s\n",data);
+	//AT+MPUB=<topic>,<qos>,<retain>,<message>
+    module_printf("AT+MPUB=\"%s\",0,0,\"%s\"\r\n",topic,data);
+	
+	if(Module_Read_A_CRC("OK", 300)) {
+		//ME3616_INFO("Pub Successful \r\n[%s]<-[%s]",topic,data);
+		return 1;
+	} else {
+		ME3616_INFO("Pub ERROR");
+		return 0;
+	}
+#else	
+	module_printf("AT+MPUBEX=\"%s\",2,0,%d\r\n",topic,len);
+	if(Module_Read_A_CRC(">", 300)) {
+		//ME3616_INFO("return >\r\n");
+		//module_printf(data);
+		uart_msg_send(UART3_ID,data,len);
+		//data_dump("net sendx", (uint8_t *)data, len);
+		if(Module_Read_A_CRC_DA("OK","FEFE",len, 300)){
+		//		ME3616_INFO("return success\r\n");
+			return 1;
+		}
+		else {
+			ME3616_INFO("return failed\r\n");
+			return 0;
+		}
+	} else {
+		ME3616_INFO("Pub ERROR");
+		return 0;
+	}
+#endif
+}
+
+void AIR_IMEI_ICCID_INFO_GET(char *imei, char *iccid)
+{
+	memcpy(imei, air.State.imei, strlen(air.State.imei));
+	memcpy(iccid, air.State.iccid, strlen(air.State.iccid));
+}
+
+/*发送的指令组，需要校验的响应组，校验组数量，校验等级，重发次数，跳转位置，超时时间*/
+
+/**
+* @brief  AIR句柄的构造函数
+* @param  该函数会对本文件核心全局句柄进行函数构造
+*/		
+ME3616 * AIR_Init(void)
+{
+	ME3616 * me=&air;
+
+	memset(me, 0, sizeof(ME3616));
+#if(config_MQTT_Enable)
+	me->MQTT.SetNet=AIR_MQTT_Set_Net;
+	me->MQTT.Connect=AIR_MQTT_Connet;
+	me->MQTT.Sub=AIR_MQTT_SUB;
+	me->MQTT.Pub=AIR_MQTT_PUB;
+#endif
+
+	me->imei_iccid_get = AIR_IMEI_ICCID_INFO_GET;
+
+	me->PowerOn=AIR_Power_On;
+#if(Hvertion_data)
+	me->HardRest=AIR_HARD_Rest;
+#endif
+
+#if(SoftRest_fun)
+	me->SoftRest=AIR_SOFT_Rest;
+#endif
+#if(GetEPS_fun)
+	me->GetEPS=AIR_READ_EPS;
+#endif
+#if(GetCSQ_fun)
+	me->GetCSQ=AIR_READ_CSQ;
+#endif
+	me->GetCESQ=AIR_READ_CESQ;
+#if(GetCCID_fun)
+	me->GetCCID=AIR_READ_CCID;
+#endif
+	me->GetPIN=AIR_READ_PIN;
+	me->GetIMEI=AIR_READ_IMEI;
+
+#if(Svertion_data)
+	me->Version=AIR_READ_Revision;
+#endif
+#if 0
+	me->flug.iccid=0;
+	memset(me->State.iccid,0,50);
+
+	me->flug.imei=0;
+	memset(me->State.imei,0,50);
+
+	me->flug.imsi=0;
+	memset(me->State.imsi,0,50);
+
+#if(Hvertion_data)
+	me->flug.Hvertion=0;
+	memset(me->State.Hvertion,0,50);
+#endif
+#if(Svertion_data)
+	me->flug.Svertion=0;
+	memset(me->State.Svertion,0,50);
+#endif
+
+	me->flug.pwr=0;
+	me->flug.rssi=0;
+	me->flug.ber=0;
+	me->flug.eps=0;
+	me->flug.pin=0;
+	me->flug.rest=0;	
+#endif
+	return me;
+}
+
+void AIR_CLOSE_TCP(void)
+{
+    module_printf("AT+MDISCONNECT\r\n"); // 先关闭mqtt连接
+    if(Module_Read_A_CRC("OK", 300)){
+        printf("mqtt  connect close");
+    }
+    module_printf("AT+MDISCONNECT\r\n"); // 再关闭TCP连接
+    if(Module_Read_A_CRC("OK", 300)){
+        printf("tcp  connect close");
+    }
+
+   // maqtt_check_connect_status(1);
+}
+
+int maqtt_check_connect_status(uint8_t type)
+{
+    char buff[64]={0};
+   // char get_buff[32]={'\0'};
+
+    switch(type){
+    case 0x01: // 查询MQTT连接状态
+        module_printf("AT+MQTTSTATU\r\n");
+        if(Module_Read_A_CRC("OK", 300)){
+            printf("mqtt  connect ok");
+        }
+        if(Module_Blocking_Read(buff,5000))
+        {
+            if(strstr(buff,"+MQTTSTATU:"))
+            {
+                printf("mqtt status : %s\r\n",buff);
+            }
+            else {
+                printf("\r\n mqtt opt \r\n");
+            }
+        }
+        else {
+            printf("\r\n mqtt connect failed \r\n");
+        }
+
+        break;
+    }
+		
+		return 0;
+}

APP/network_mgr/air72x/at.h

@@ -0,0 +1,262 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-03-30     chenyong     first version
+ * 2018-08-17     chenyong     multiple client support
+ */
+
+#ifndef __AT_H__
+#define __AT_H__
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define AT_SW_VERSION                  "1.3.0"
+
+#define AT_CMD_NAME_LEN                16
+#define AT_END_MARK_LEN                4
+
+#ifndef AT_CMD_MAX_LEN
+#define AT_CMD_MAX_LEN                 128
+#endif
+
+/* the server AT commands new line sign */
+#if defined(AT_CMD_END_MARK_CRLF)
+#define AT_CMD_END_MARK                "\r\n"
+#elif defined(AT_CMD_END_MARK_CR)
+#define AT_CMD_END_MARK                "\r"
+#elif defined(AT_CMD_END_MARK_LF)
+#define AT_CMD_END_MARK                "\n"
+#endif
+
+#ifndef AT_SERVER_RECV_BUFF_LEN
+#define AT_SERVER_RECV_BUFF_LEN        256
+#endif
+
+#ifndef AT_SERVER_DEVICE
+#define AT_SERVER_DEVICE               "uart2"
+#endif
+
+/* the maximum number of supported AT clients */
+#ifndef AT_CLIENT_NUM_MAX
+#define AT_CLIENT_NUM_MAX              1
+#endif
+
+#define AT_CMD_EXPORT(_name_, _args_expr_, _test_, _query_, _setup_, _exec_)   \
+    RT_USED static const struct at_cmd __at_cmd_##_test_##_query_##_setup_##_exec_ SECTION("RtAtCmdTab") = \
+    {                                                                          \
+        _name_,                                                                \
+        _args_expr_,                                                           \
+        _test_,                                                                \
+        _query_,                                                               \
+        _setup_,                                                               \
+        _exec_,                                                                \
+    };
+
+enum at_status
+{
+    AT_STATUS_UNINITIALIZED = 0,
+    AT_STATUS_INITIALIZED,
+    AT_STATUS_CLI,
+};
+typedef enum at_status at_status_t;
+#define AT_USING_SERVER
+#ifdef AT_USING_SERVER
+enum at_result
+{
+    AT_RESULT_OK = 0,                  /* AT result is no error */
+    AT_RESULT_FAILE = -1,              /* AT result have a generic error */
+    AT_RESULT_NULL = -2,               /* AT result not need return */
+    AT_RESULT_CMD_ERR = -3,            /* AT command format error or No way to execute */
+    AT_RESULT_CHECK_FAILE = -4,        /* AT command expression format is error */
+    AT_RESULT_PARSE_FAILE = -5,        /* AT command arguments parse is error */
+};
+typedef enum at_result at_result_t;
+
+struct at_cmd
+{
+    char name[AT_CMD_NAME_LEN];
+    char *args_expr;
+    at_result_t (*test)(void);
+    at_result_t (*query)(void);
+    at_result_t (*setup)(const char *args);
+    at_result_t (*exec)(void);
+};
+typedef struct at_cmd *at_cmd_t;
+
+struct at_server
+{
+char recv_buffer[AT_SERVER_RECV_BUFF_LEN];
+
+};
+typedef struct at_server *at_server_t;
+#endif /* AT_USING_SERVER */
+
+#ifdef AT_USING_CLIENT
+enum at_resp_status
+{
+     AT_RESP_OK = 0,                   /* AT response end is OK */
+     AT_RESP_ERROR = -1,               /* AT response end is ERROR */
+     AT_RESP_TIMEOUT = -2,             /* AT response is timeout */
+     AT_RESP_BUFF_FULL= -3,            /* AT response buffer is full */
+};
+typedef enum at_resp_status at_resp_status_t;
+
+struct at_response
+{
+    /* response buffer */
+    char *buf;
+    /* the maximum response buffer size, it set by `at_create_resp()` function */
+    rt_size_t buf_size;
+    /* the length of current response buffer */
+    rt_size_t buf_len;
+    /* the number of setting response lines, it set by `at_create_resp()` function
+     * == 0: the response data will auto return when received 'OK' or 'ERROR'
+     * != 0: the response data will return when received setting lines number data */
+    rt_size_t line_num;
+    /* the count of received response lines */
+    rt_size_t line_counts;
+    /* the maximum response time */
+    rt_int32_t timeout;
+};
+
+typedef struct at_response *at_response_t;
+
+struct at_client;
+
+/* URC(Unsolicited Result Code) object, such as: 'RING', 'READY' request by AT server */
+struct at_urc
+{
+    const char *cmd_prefix;
+    const char *cmd_suffix;
+    void (*func)(struct at_client *client, const char *data, rt_size_t size);
+};
+typedef struct at_urc *at_urc_t;
+
+struct at_urc_table
+{
+    size_t urc_size;
+    const struct at_urc *urc;
+};
+typedef struct at_urc *at_urc_table_t;
+
+struct at_client
+{
+    rt_device_t device;
+
+    at_status_t status;
+    char end_sign;
+
+    /* the current received one line data buffer */
+    char *recv_line_buf;
+    /* The length of the currently received one line data */
+    rt_size_t recv_line_len;
+    /* The maximum supported receive data length */
+    rt_size_t recv_bufsz;
+    rt_sem_t rx_notice;
+    rt_mutex_t lock;
+
+    at_response_t resp;
+    rt_sem_t resp_notice;
+    at_resp_status_t resp_status;
+
+    struct at_urc_table *urc_table;
+    rt_size_t urc_table_size;
+
+    rt_thread_t parser;
+};
+typedef struct at_client *at_client_t;
+#endif /* AT_USING_CLIENT */
+
+#ifdef AT_USING_SERVER
+/* AT server initialize and start */
+int at_server_init(void);
+
+/* AT server send command execute result to AT device */
+void at_server_printf(const char *format, ...);
+void at_server_printfln(const char *format, ...);
+void at_server_print_result(at_result_t result);
+size_t at_server_send(at_server_t server, const char *buf, size_t size);
+size_t at_server_recv(at_server_t server, char *buf, size_t size, int32_t timeout);
+
+/* AT server request arguments parse */
+int at_req_parse_args(const char *req_args, const char *req_expr, ...);
+#endif /* AT_USING_SERVER */
+
+#ifdef AT_USING_CLIENT
+
+/* AT client initialize and start*/
+int at_client_init(const char *dev_name,  rt_size_t recv_bufsz);
+
+/* ========================== multiple AT client function ============================ */
+
+/* get AT client object */
+at_client_t at_client_get(const char *dev_name);
+at_client_t at_client_get_first(void);
+
+/* AT client wait for connection to external devices. */
+int at_client_obj_wait_connect(at_client_t client, rt_uint32_t timeout);
+
+/* AT client send or receive data */
+rt_size_t at_client_obj_send(at_client_t client, const char *buf, rt_size_t size);
+rt_size_t at_client_obj_recv(at_client_t client, char *buf, rt_size_t size, rt_int32_t timeout);
+
+/* set AT client a line end sign */
+void at_obj_set_end_sign(at_client_t client, char ch);
+
+/* Set URC(Unsolicited Result Code) table */
+int at_obj_set_urc_table(at_client_t client, const struct at_urc * table, rt_size_t size);
+
+/* AT client send commands to AT server and waiter response */
+int at_obj_exec_cmd(at_client_t client, at_response_t resp, const char *cmd_expr, ...);
+
+/* AT response object create and delete */
+at_response_t at_create_resp(rt_size_t buf_size, rt_size_t line_num, rt_int32_t timeout);
+void at_delete_resp(at_response_t resp);
+at_response_t at_resp_set_info(at_response_t resp, rt_size_t buf_size, rt_size_t line_num, rt_int32_t timeout);
+
+/* AT response line buffer get and parse response buffer arguments */
+const char *at_resp_get_line(at_response_t resp, rt_size_t resp_line);
+const char *at_resp_get_line_by_kw(at_response_t resp, const char *keyword);
+int at_resp_parse_line_args(at_response_t resp, rt_size_t resp_line, const char *resp_expr, ...);
+int at_resp_parse_line_args_by_kw(at_response_t resp, const char *keyword, const char *resp_expr, ...);
+
+/* ========================== single AT client function ============================ */
+
+/**
+ * NOTE: These functions can be used directly when there is only one AT client.
+ * If there are multiple AT Client in the program, these functions can operate on the first initialized AT client.
+ */
+
+#define at_exec_cmd(resp, ...)                   at_obj_exec_cmd(at_client_get_first(), resp, __VA_ARGS__)
+#define at_client_wait_connect(timeout)          at_client_obj_wait_connect(at_client_get_first(), timeout)
+#define at_client_send(buf, size)                at_client_obj_send(at_client_get_first(), buf, size)
+#define at_client_recv(buf, size, timeout)       at_client_obj_recv(at_client_get_first(), buf, size, timeout)
+#define at_set_end_sign(ch)                      at_obj_set_end_sign(at_client_get_first(), ch)
+#define at_set_urc_table(urc_table, table_sz)    at_obj_set_urc_table(at_client_get_first(), urc_table, table_sz)
+
+
+#endif /* AT_USING_CLIENT */
+
+/* ========================== User port function ============================ */
+
+#ifdef AT_USING_SERVER
+/* AT server device reset */
+void at_port_reset(void);
+
+/* AT server device factory reset */
+void at_port_factory_reset(void);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __AT_H__ */

APP/network_mgr/air72x/atair720.c

@@ -0,0 +1,2080 @@
+#include "stm32f4xx.h"
+#include <type-spec.h>
+#include "at.h"
+#include <string.h>
+#include "queue.h"
+#include "atair720.h"
+#include "flash_if.h"
+#include "board-config.h"
+#include "usart.h"
+#include "WatchDog.h"
+#include "sys_tick.h"
+#include "sx1276_api.h"
+#include "para-config.h"
+#include "led.h"
+
+#include "type-spec.h"
+#include <stdlib.h>
+#include "atoi.h"
+#include "main.h"
+#include "ota.h"
+//#include "usart.h"
+#define TEST_TEST_TEST 1
+
+#define UART2_Buffer_Max_LEN 256
+#define USART_REC_LEN  			200  	//定义最大接收字节数 200
+#define RevOK  1
+#define Idle 0
+#define Reving 2
+
+uint8_t Air_IMEI[32]={0};
+uint8_t Air_ICCID[32]={0};
+
+//TCP连接超时
+u16 TcpConnectTimeOut = 0;
+uint16_t USART1RxSta = 0;
+
+//TCP连接OK标识
+u8 CONNECTISOK = 0;
+extern struct UsartRxBuffer Usart2RxBuffer;
+
+/**
+  * @brief	向 AIR 模块发送命令后，检测接收到的应答
+  * @param	str		期待的应答结果
+  * @retval 0		没有得到期待的应答结果
+			其他 	期待应答结果的位置
+  */
+char* air_check_cmd(char *str)
+{
+	char *strx = 0;
+	char *CONNECTOK = "CONNECT OK";
+
+	if(str == NULL)
+		return strx;
+		/* 添加结束符 */
+		strx = strstr((const char*)Usart2RxBuffer.pBuffer, (const char*)str);
+		if( NULL != strstr((const char*)Usart2RxBuffer.pBuffer, (const char*)CONNECTOK ) )
+		{ 
+			CONNECTISOK = 1;
+			TcpConnectTimeOut = 0;
+			
+		}
+
+
+	return (char*)strx;
+}
+/**
+  * @brief	实现下载
+  * @param	cmd			发送的命令
+  * @param	ack			期待的应答结果
+  * @param	waittime 	等待时间(单位:10ms)
+  * @retval	0 发送成功
+			1 发送失败
+  */
+uint8_t * air_send_HTTPREADCmd(uint16_t srcadr,uint16_t downcLen, uint16_t waittime)
+{
+	uint8_t  res,cmdtmp[100],tmp[50],len;
+	u8 times = 3;
+	uint32_t wait = waittime,readlen,cmdLen,codelen = downcLen;
+	 char *cmdTmp;
+	 char *AckTmp = "+HTTPACTION:",*pstrx,*pchar,*pres=NULL;
+
+	memset(cmdtmp,0,50);
+	cmdLen = strlen("AT+HTTPREAD=");
+	memcpy(cmdtmp,"AT+HTTPREAD=",cmdLen);
+	memset(tmp,0,50);
+	len = myitoa(srcadr,(char *)&tmp[0]);//address
+	strcat((char *)&cmdtmp[0],(char *)&tmp);
+	cmdLen += len;
+	memset(tmp,0,50);
+	strcat((char *)&cmdtmp[0],",");//,
+	cmdLen += 1;
+	memset(tmp,0,50);
+	myitoa(codelen,(char *)&tmp[0]);//data len
+	strcat((char *)&cmdtmp[0],(char *)&tmp);
+	cmdLen += strlen((char *)&tmp[0]);
+	
+	strcat((char *)&cmdtmp[0],"\r\n");
+	cmdLen +=strlen("\r\n");
+	times = 10;
+	res = 0;
+	AT_AIR720_DEBUG_F("%s",cmdtmp);
+
+	USART2_ready_buf_ok = 0;
+	while(times)
+	{
+		times--;
+		/* 发送下一条命令之前，清接收状态 */
+		
+		memset(Usart2RxBuffer.pBuffer , 0 , USART2_BUF_SIZE);
+		Usart2RxBuffer.Buffer_Len = 0;
+		
+    USART2_ready_buf_ok = Idle;
+		USART2_SendNByte((uint8_t *)cmdtmp, cmdLen);
+	
+		wait=waittime;
+		if(wait)
+		{
+			while(--wait)
+			{
+				delay_ms(100);
+				/* 接收到一帧数据 */
+				//AT_AIR720_DEBUG_F("%s:wait!!!!","+HTTPREAD:");
+				if (USART2_ready_buf_ok == RevOK)
+				{
+            USART2_ready_buf_ok = Idle;
+            AT_AIR720_DEBUG_F("cmd rcv =%s\r\n",Usart2RxBuffer.pBuffer);
+						/* 添加结束符 */
+						pstrx = strstr((const char*)Usart2RxBuffer.pBuffer, "+HTTPREAD:");
+						if(pstrx == NULL)
+					  {
+							break;
+						}
+						pstrx += strlen("+HTTPREAD: ");
+						pchar = strstr((const char*)pstrx, "\r\n");
+						*pchar = '\0';
+					
+						
+						readlen = atoi(pstrx);
+						
+						if(readlen == downcLen)
+						{
+							pres = pchar+2;
+							res = 1;
+							break;
+						}
+							
+						//AT_AIR720_DEBUG_F("%s:send ok!!!!",cmd);
+						break;
+					}
+					USART2_ready_buf_ok = Idle;
+			}
+      IWDG_Feed();														//喂狗
+
+		}
+
+		return (uint8_t *)pres;
+	}
+  return NULL;
+}
+
+/**
+  * @brief	向 AIR 模块发送命令
+  * @param	cmd			发送的命令
+  * @param	ack			期待的应答结果
+  * @param	waittime 	等待时间(单位:10ms)
+  * @retval	0 发送成功
+			1 发送失败
+  */
+uint8_t  air_send_cmd(char *cmd, char *ack, uint16_t waittime)
+{
+	uint8_t res = 0;
+	u8 times = 3;
+	uint16_t wait = waittime;
+	//memset(Usart2_RX_BUF , 0 , 64);
+	//AT_AIR720_DEBUG_F("%s!!!!",cmd);
+	times = 10;
+	while(times)
+	{
+		times--;
+		/* 发送下一条命令之前，清接收状态 */
+		
+		memset(Usart2RxBuffer.pBuffer , 0 , USART2_BUF_SIZE);
+		Usart2RxBuffer.Buffer_Len = 0;
+		USART2_ready_buf_ok = Idle;
+		USART2_SendNByte((uint8_t *)cmd, strlen((const char *)cmd));
+		//AT_AIR720_DEBUG_F("%s:send!!!!",cmd);
+		wait=waittime;
+		if(ack && wait)
+		{
+			while(--wait)
+			{
+				delay_ms(10);
+				/* 接收到一帧数据 */
+				//AT_AIR720_DEBUG_F("%s:wait!!!!",cmd);
+				if (USART2_ready_buf_ok == RevOK)
+				{
+					USART2_ready_buf_ok = Idle;
+          AT_AIR720_DEBUG_F("cmd rcv =%s\r\n",Usart2RxBuffer.pBuffer);
+					/* 接收到期待的应答结果 */
+					if (air_check_cmd(ack))
+					{
+						AT_AIR720_DEBUG_F("air_send_cmd:2:%s ACK OK!!!!!!!!!!\r\n",cmd);
+						times = 0;
+						res = 1;
+						//AT_AIR720_DEBUG_F("%s:send ok!!!!",cmd);
+						break;
+					}
+				}
+        
+        IWDG_Feed();														//喂狗
+			}
+
+			
+		}
+	}
+	return res;
+}
+/**
+  * @brief	air_send_HTTPACTIONCmd
+  * @param	cmd			发送的命令
+  * @param	ack			期待的应答结果
+  * @param	waittime 	等待时间(单位:10ms)
+  * @retval	0 发送成功
+			1 发送失败
+  */
+uint8_t  air_send_HTTPACTIONCmd(uint8_t index, uint32_t *pLen, uint16_t waittime)
+{
+	uint8_t res = 0;
+	u8 times = 3,get_Wait_flg;
+	uint16_t wait = waittime,len,i;
+	const char *cmdTmp = "AT+HTTPACTION=0\r\n";
+	const char *AckTmp = "+HTTPACTION:",*strx;
+	//memset(Usart2_RX_BUF , 0 , 64);
+	char *ACkOK = "OK";
+	USART2_ready_buf_ok = 0;
+	res=air_send_cmd(( char *)cmdTmp, ACkOK, 300);
+	while(res &&waittime)
+	{
+		
+		waittime--;	
+		delay_ms(10);
+		//AT_AIR720_DEBUG_F("%s:wait len!!!!","AT+HTTPACTION");
+		if (USART2_ready_buf_ok == RevOK)
+		{
+      
+        USART2_ready_buf_ok = Idle;
+        AT_AIR720_DEBUG_F("cmd rcv =%s\r\n",Usart2RxBuffer.pBuffer);
+      
+				strx = strstr((const char*)Usart2RxBuffer.pBuffer, (const char*)AckTmp );
+				for(i = 0;i< USART2_ready_buf_len;i++)
+					printf("%02X ",USART2_ready_buf[i]);
+				if(strx == NULL)
+				{ 
+					AT_AIR720_DEBUG_F("%s NULL!!!!",AckTmp);
+					break;						
+				}
+				strx = strstr((const char*)strx, "," );
+				if(strx == NULL)
+				{
+					break;
+				}
+				strx+=1;
+				strx = strstr((const char*)strx, "," );
+				if(strx == NULL)
+				{
+					break;
+				}
+				strx +=1;
+				*pLen = atoi(strx);//获取接收长度
+
+				res = 1;
+				break;
+	
+			}
+
+    IWDG_Feed();														//喂狗
+		}
+
+		return res;
+
+}
+
+/**
+  * @brief	air_send_IMEI_Cmd
+  * @param	cmd			发送的命令
+  * @param	ack			期待的应答结果
+  * @param	waittime 	等待时间(单位:10ms)
+  * @retval	0 发送成功
+			1 发送失败
+  */
+uint8_t  air_send_IMEI_Cmd(uint16_t waittime)
+{
+	uint8_t res = 1;
+	u8 times = 3,get_Wait_flg;
+	uint16_t wait = waittime,len,i;
+	const char *cmdTmp = "AT+CGSN\r\n";
+	const char *strx,*stry;
+	//memset(Usart2_RX_BUF , 0 , 64);
+	char *ACkOK = "OK";
+  times = 10;
+	while(times--){
+    USART2_ready_buf_ok = 0;
+    memset(USART2_ready_buf,0,USART2_BUF_SIZE);
+    USART2_SendNByte((uint8_t *)cmdTmp, strlen((const char *)cmdTmp));
+    while(waittime)
+    {
+      
+      waittime--;	
+      delay_ms(10);
+      //AT_AIR720_DEBUG_F("%s:wait len!!!!","AT+HTTPACTION");
+      if (USART2_ready_buf_ok == RevOK)
+      {   
+        strx = (const char*)USART2_ready_buf;
+        //打印返回指令
+        for(i = 0;i< USART2_ready_buf_len;i++)
+          printf("%02X ",USART2_ready_buf[i]);
+        printf("\r\n");
+      
+        //检索8 6 6 7 1 4 0 4 6 8 1 8 3 5 6 之前的"\r\n" 
+        strx = strstr((const char*)strx, "\r\n86" );
+        if(strx == NULL)
+        {
+          AT_AIR720_DEBUG_F("strx == NULL\r\n");
+          break;
+        }
+        strx+=2;
+        //检索8 6 6 7 1 4 0 4 6 8 1 8 3 5 6 之后的"\r\n" 
+        stry = strstr((const char*)(strx), "\r\n" );
+        if(stry == NULL)
+        {
+          AT_AIR720_DEBUG_F("stry == NULL\r\n");
+          break;
+        }
+        len = (int)(stry)-(int)(strx);
+        
+        //
+        if((len<=0)||(len>17)||(len>sizeof(Air_IMEI)))
+        {
+          AT_AIR720_DEBUG_F("((len<=0)||(len>17)||(len>sizeof(Air_IMEI)))\r\n");
+          AT_AIR720_DEBUG_F("len=%d,stry=0x%8X,strx=0x%8X\r\n",len,(int)stry,(int)strx);
+          break;
+        }
+        //中间段为IMEI
+        memset(Air_IMEI,0,sizeof(Air_IMEI));
+        for(i = 0;i < len;i++)
+        {
+          if((*(strx+i)>='0')||(*(strx+i)<='9'))
+          {
+            Air_IMEI[i]= *(strx+i);
+          }
+          else{
+            memset(Air_IMEI,0,sizeof(Air_IMEI));
+            AT_AIR720_DEBUG_F("((*(strx+i)<'0')||(*(strx+i)>'9'))\r\n");
+            return 0;
+          }
+        }
+        AT_AIR720_DEBUG_F("IMEI=%s\r\n",Air_IMEI);
+        //USART2_SendNByte(Air_IMEI,len);
+        //AT_AIR720_DEBUG("\r\n");
+        
+        
+        return 0;
+  
+      }
+    
+      delay_ms(300);
+    }
+  }
+  return res;
+
+}
+
+/**
+  * @brief	air_send_ICCID_Cmd
+  * @param	cmd			发送的命令
+  * @param	ack			期待的应答结果
+  * @param	waittime 	等待时间(单位:10ms)
+  * @retval	0 发送成功
+			1 发送失败
+  */
+uint8_t  air_send_ICCID_Cmd(uint16_t waittime)
+{
+	uint8_t res = 1;
+	u8 times = 3,get_Wait_flg;
+	uint16_t wait = waittime,len,i;
+	const char *cmdTmp = "AT+ICCID\r\n";
+	const char *strx,*stry;
+	//memset(Usart2_RX_BUF , 0 , 64);
+	char *ACkOK = "OK";
+  times = 10;
+	while(times--){
+    USART2_ready_buf_ok = 0;
+    memset(USART2_ready_buf,0,USART2_BUF_SIZE);
+    USART2_SendNByte((uint8_t *)cmdTmp, strlen((const char *)cmdTmp));
+    while(waittime)
+    {
+      
+      waittime--;	
+      delay_ms(10);
+      //AT_AIR720_DEBUG_F("%s:wait len!!!!","AT+HTTPACTION");
+      if (USART2_ready_buf_ok == RevOK)
+      {   
+        strx = (const char*)USART2_ready_buf;
+        //打印返回指令
+        for(i = 0;i< USART2_ready_buf_len;i++)
+          printf("%02X ",USART2_ready_buf[i]);
+        printf("\r\n");
+      
+      /*
+      AT+ICCID
+
+      +ICCID: 89860464011970002199
+
+      OK
+      */
+        //检索89860464011970002199之前的"\r\n" 
+        strx = strstr((const char*)strx, "\r\n+ICCID: 8986" );
+        if(strx == NULL)
+        {
+          AT_AIR720_DEBUG_F("strx == NULL\r\n");
+          break;
+        }
+        strx+=10;
+        //检索89860464011970002199之后的"\r\n" 
+        stry = strstr((const char*)(strx), "\r\n" );
+        if(stry == NULL)
+        {
+          AT_AIR720_DEBUG_F("stry == NULL\r\n");
+          break;
+        }
+        len = (int)(stry)-(int)(strx);
+        
+        //
+        if((len<=0)||(len>20)||(len>sizeof(Air_ICCID)))
+        {
+          AT_AIR720_DEBUG_F("((len<=0)||(len>17)||(len>sizeof(Air_ICCID)))\r\n");
+          AT_AIR720_DEBUG_F("len=%d,stry=0x%8X,strx=0x%8X\r\n",len,(int)stry,(int)strx);
+          break;
+        }
+        //中间段为IMEI
+        memset(Air_ICCID,0,sizeof(Air_ICCID));
+        for(i = 0;i < len;i++)
+        {
+          if((*(strx+i)>='0')||(*(strx+i)<='9'))
+          {
+            Air_ICCID[i]= *(strx+i);
+          }
+          else{
+            memset(Air_ICCID,0,sizeof(Air_ICCID));
+            AT_AIR720_DEBUG_F("((*(strx+i)<'0')||(*(strx+i)>'9'))\r\n");
+            return 0;
+          }
+        }
+        AT_AIR720_DEBUG_F("Air_ICCID=%s\r\n",Air_ICCID);
+        //USART2_SendNByte(Air_IMEI,len);
+        //AT_AIR720_DEBUG("\r\n");
+        
+        
+        return 0;
+  
+      }
+    
+      delay_ms(300);
+    }
+  }
+  return res;
+
+}
+
+uint8_t bcd_h_asc ( uint8_t data)
+{
+	return ((data>>4)+0x30);
+}
+uint8_t bcd_l_asc ( uint8_t data)
+{
+	return ((data&0x0f)+0x30);
+}
+static uint8_t check_code(uint8_t size,uint8_t *buf)
+{
+	uint8_t i;
+	uint8_t check_c ;
+	if(size<5)
+		return 0;
+	
+	check_c =buf[2];                               //            
+	for(i=3;i<(size-1);i++)
+	check_c =check_c^buf[i];
+	 
+	return check_c;
+}
+extern config_t Config;
+extern uint8_t LoRa_receive_buf[LoRa_RCV_BUF_SIZE];
+
+extern volatile uint32_t Air720RestCounter;
+#define AIR720_SQ_DEPTH (8)
+#define AIR720_SQ_WIDTH (128)
+extern sequeue_t *SX1276_Send_sq_init(uint8_t row,uint16_t col);
+
+	
+sequeue_t * Air720_Send_Sq;
+sequeue_t * Air720_SqInit(void)
+{    	 
+	return Create_Empty_Sequeue(AIR720_SQ_DEPTH,AIR720_SQ_WIDTH);
+
+}
+
+sequeue_t * Air720_Rev_Sq;
+sequeue_t * Air720_RevSqInit(void)
+{    	 
+	return Create_Empty_Sequeue(AIR720_SQ_DEPTH,AIR720_SQ_WIDTH);
+
+}
+tCounterTimeOut_t time_gw_heartbeat;
+tCounterTimeOut_t time_gw_force_rst;
+void Air720_Init(void)
+{    	 
+	GPIO_InitTypeDef    GPIO_InitStructure;
+
+  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);//使能GPIOB时钟
+
+  //GPIO初始化设置
+  GPIO_InitStructure.GPIO_Pin = AIR720_RESET_PIN;
+  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
+  GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;//推挽输出
+  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
+  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
+  GPIO_Init(GPIOD, &GPIO_InitStructure);//初始化
+	GPIO_ResetBits(GPIOD,  AIR720_RESET_PIN);
+
+	delay_ms(500);
+	GPIO_SetBits(GPIOD,AIR720_RESET_PIN);
+	
+
+	Air720_Send_Sq = Air720_SqInit();
+	Air720_Rev_Sq = Air720_RevSqInit();
+  
+  time_gw_heartbeat.counter =TickCounter;
+  time_gw_heartbeat.timeOut =60*1000;
+  
+	
+}
+Uint8 AT[]="AT\r\n";
+#define SERVICE_IP 
+tAT_AIRE720_StateCodes AT_aire720_State = AT_AIRE720_STATE_INIT;
+extern GATE_CONFIG_T gt_config_para;
+tCounterTimeOut_t time_at_air720_receive;
+#define UDP_CONNECT_RETRY_TIMES (50)
+void Air720_send(uint8_t*pbuf, uint8_t Size)
+{
+  char at_cmd[32];
+  uint8_t at_len;
+  at_len = sprintf((char *)at_cmd,"AT+CIPSEND=%d\r\n",Size);
+  
+  USART2_SendNByte((uint8_t *)at_cmd, at_len);	
+  delay_ms(10);
+  USART2_SendNByte((uint8_t *)pbuf, Size);	
+  /*
+	if(air_send_cmd(at_cmd, ">", 2))
+	{
+		USART2_SendNByte((uint8_t *)pbuf, Size);	
+		//AT_AIR720_DEBUG_F("UDP send ready!!!!");
+	
+	}	
+*/
+}
+uint16_t  UDP_0C_frame(void)
+{	
+
+	uint8_t temp,index;
+	uint8_t check;
+
+	uint8_t i;
+  uint8_t frame[128];
+	tUNION32_T ptmp_32;
+  
+  index = 0;
+	frame[index++]=0xFF;			
+	frame[index++]=0xEE;
+	frame[index++]=0x00;			
+	frame[index++]=0x00;
+	
+	frame[index++]=0x0C;  // 1        
+		
+	frame[index++]=gt_config_para.DevId[0]; 	//网关ID(4B)              
+	frame[index++]=gt_config_para.DevId[1];
+	frame[index++]=gt_config_para.DevId[2]; 
+	frame[index++]=gt_config_para.DevId[3];
+
+	frame[index++]=0x00;			//预留
+	frame[index++]=0x00;			//预留
+	frame[index++]=0x00;			//
+	frame[index++]=0x00;      //是否加密，网关自己的0c指令不关注
+  
+	frame[index++]=gt_config_para.DevId[0]; 	//网关ID(4B)              
+	frame[index++]=gt_config_para.DevId[1];
+	frame[index++]=gt_config_para.DevId[2]; 
+	frame[index++]=gt_config_para.DevId[3];
+  
+	frame[index++]=gt_config_para.DevType;    //网关类型  0x1,网关  0x2,液位仪  0x3,采集器  0x4,NB油机  0x5,NB液位仪  0x9,英泰赛福模块
+	frame[index++]=0x00;                      //通道号
+  
+  ptmp_32.data_32=CURRENT_SOFTWARE_VER;
+	frame[index++]=ptmp_32.data_8[0]; 	      //网关App版本号(4B)              
+	frame[index++]=ptmp_32.data_8[1];
+	frame[index++]=ptmp_32.data_8[2]; 
+	frame[index++]=ptmp_32.data_8[3];
+
+
+	frame[index++]=gt_config_para.BLVer[0]; 	//网关BL版本(4B)              
+	frame[index++]=gt_config_para.BLVer[1];
+	frame[index++]=gt_config_para.BLVer[2]; 
+	frame[index++]=gt_config_para.BLVer[3];
+
+
+	frame[index++]=gt_config_para.BLVer[0]; 	//网关Set版本(2B)   低16位           
+	frame[index++]=gt_config_para.BLVer[1];
+	frame[index++]=gt_config_para.RstCnt[0];  //复位次数
+	frame[index++]=gt_config_para.RstCnt[1];
+
+
+	frame[index++]=0x00;  //逻辑和校验
+
+	frame[2] = ((index-5) >> 0) & 0xff;
+	frame[3] = ((index-5) >> 8) & 0xff;
+	
+  
+  //计算逻辑和校验
+	check =0x00;
+	for(i=0;i<(index-1);i++)
+	{
+		check = check ^ frame[i];
+		
+	}	
+		
+	frame[index-1]=check;
+	
+	
+  AT_AIR720_DEBUG_F("0C len=%02d,msg=\r\n",index);
+  AT_AIR720_DEBUG_H(frame,index);
+  AT_AIR720_DEBUG("\r\n");
+  
+  //将组装好的0D包，入队列
+  En_Queue(Air720_Send_Sq,frame,sizeof(frame),index);
+	
+
+//      
+	return (index+1);
+}
+
+int Air720_analysis(uint8_t *sbuf,uint8_t slen){
+	int ReturnCode = -1;
+	uint8_t  check=0;
+	uint8_t  scrc=0x00;
+  uint8_t  at720frame[128];
+  uint8_t  index;
+  uint8_t  temp;
+  uint32_t uTemp_32=0;
+  int i;
+	tUNION32_T *ptmp_32 = NULL;
+	tUNION16_T *ptmp_16 = NULL;
+	uint8_t  findChannel=0;
+  uint8_t   offset=0;
+	uint32_t  fCMD1=0;
+	uint32_t  fGwID=0;
+  uint8_t   fencrypt=0;
+	uint32_t  fNodeID=0;
+  uint32_t  fport=0;
+  uint32_t  fgun=0;
+  uint8_t   fDevType=0;
+  uint8_t   fChannel=0;
+  uint32_t  fAppVer=0;
+  uint32_t  fBLVer=0;
+  uint32_t  fSetVer=0;
+  
+  
+  IWDG_Feed();														//喂狗
+	//校验
+	if((sbuf==NULL)||(slen == 0))
+	{
+		AT_AIR720_DEBUG_F("error:sbuf == NULL,or slen == 0\r\n");
+		return ReturnCode;
+	}
+	//帧头(1Byte)
+	if((sbuf[0]!=0xFF)||(sbuf[1]!=0xEE))
+	{
+		AT_AIR720_DEBUG_F("error:帧头错误,0x%02X%02X\r\n",sbuf[0],sbuf[1]);
+		return ReturnCode;
+	}
+	//帧长度(1Byte)
+	if((sbuf[2]!=slen-5)||(sbuf[3]!=0))
+	{
+		AT_AIR720_DEBUG_F("error:sbuf[2]!=slen-5,sbuf[2]=0x%02X,slen=0x%02X\r\n",sbuf[2],slen);
+		return ReturnCode;
+	}
+	//和校验
+  check = 0;
+  for(i=0;i<slen-1;i++)
+		{
+			check = check ^ sbuf[i];
+		}
+	scrc = sbuf[slen-1];
+	if(check != scrc)
+	{
+		AT_AIR720_DEBUG_F("error:Sum check error!,check=0x%02X,scrc=0x%02X\r\n",check,scrc);
+		return ReturnCode;
+	}
+  //
+  //网关ID是否匹配
+  offset = 5;
+  fGwID = ((tUNION32_T *)(sbuf+offset))->data_32;
+  uTemp_32 = ((tUNION32_T *)&gt_config_para.DevId[0])->data_32;
+  if(fGwID!=uTemp_32){
+    AT_AIR720_DEBUG_F("error:网关ID不匹配thisGwID=0x%08X,fGwID=0x%08X\r\n",uTemp_32,fGwID);
+		return ReturnCode;
+  }
+  
+  IWDG_Feed();														//喂狗
+  //解析
+  if(sbuf[4]==0x0C){//心跳相关的指令
+    offset = 13;
+    fNodeID = ((tUNION32_T *)(sbuf+offset))->data_32;
+  
+    //NodeID是否匹配
+    //查询设备是否已在列表中
+    findChannel=0;
+    for(i=0;i<NODE_NUM;i++){
+      ptmp_32 = (tUNION32_T *)&node_config_para[i].DevId[0];
+      if(ptmp_32->data_32==fNodeID){
+        findChannel=i+1;
+        break;
+      }
+    }
+    if(findChannel){
+      AT_AIR720_DEBUG_F("找到设备绑定信息!ID=0x%08X,Channel=%d\r\n",fNodeID,findChannel);
+      
+      AT_AIR720_DEBUG_F("0C len=%02d,msg=\r\n",slen);
+      AT_AIR720_DEBUG_H(sbuf,slen);
+      AT_AIR720_DEBUG("\r\n");
+      
+      //帧结构完全一致，只需转发
+      En_Queue(Air720_Send_Sq,sbuf,slen,slen);
+      set_led_en_process();
+      start_led(findChannel-1,500,80,400);
+      //心跳计数器清零
+      //time_gw_heartbeat.counter = TickCounter;
+      return 0;
+    }
+    else{
+      AT_AIR720_DEBUG_F("未找到设备绑定信息!ID=0x%08X\r\n",fNodeID);
+      return -1;
+    }
+  }
+  //非加密FFEE45000DFFFFFFFF00000000190001630101303030303030313133303638303030303030353933303939BB1AFF8601303130323033303035383034303239363538303531317481
+  //加  密FFEE37000D03000161000000011B00016301000000123456789000001234567890BB188101A111000101010112345678901234567890000100E51254
+  else if(sbuf[4]==0x0D){//业务上报相关的指令
+    offset = 13;
+    fNodeID = ((tUNION32_T *)(sbuf+offset))->data_32;
+  
+    //NodeID是否匹配
+    //查询设备是否已在列表中
+    findChannel=0;
+    for(i=0;i<NODE_NUM;i++){
+      ptmp_32 = (tUNION32_T *)&node_config_para[i].DevId[0];
+      if(ptmp_32->data_32==fNodeID){
+        findChannel=i+1;
+        break;
+      }
+    }
+    if(findChannel){
+      
+      set_led_en_process();
+      start_led(findChannel-1,500,20,400);
+      AT_AIR720_DEBUG_F("找到设备绑定信息!ID=0x%08X,Channel=%d\r\n",fNodeID,findChannel);
+      //创建0D上报帧
+      index=0;
+      for(i=0;i<17;i++){
+        //前17个字节一致，
+        at720frame[index++] = sbuf[i];
+      }
+      fport = sbuf[17];
+      at720frame[index++] = (findChannel-1)*2 + fport + 1;  //端口号（1-12）
+      fgun = sbuf[18];
+      at720frame[index++] = fgun+ 1;  //枪号（1-8）
+      
+      fencrypt = sbuf[12];//是否加密，指英泰赛福
+      
+      //如果是加密的
+      if(fencrypt){
+        
+        //UDP总累计油量(12B)  比如0000001234.56
+        offset=20;
+        index+=Hex2Ascii(at720frame+index,sbuf+offset,6);
+        
+        //UDP总累计金额(12B), 比如0000002222.56
+        offset=27;
+        index+=Hex2Ascii(at720frame+index,sbuf+offset,6);
+        
+        temp = index;						// 记录当前长度
+        //  非加密真实返回数据
+        //	BB 1A FF 86 01   32 34 31 36 31 35    30 30 30 30 30 31     30 30 30 30 35 33      35 33 31 39     74 												
+        at720frame[index++]=0xBB;   //32		   //帧头                                      35
+        at720frame[index++]=0x1A;   //33			 //帧长度                                    36      
+        at720frame[index++]=0xFF;   //34		   //帧号                                      37  
+        at720frame[index++]=0x86;   //35		   //86表示当次加油数据                        38
+        
+        at720frame[index++]=0x01;   //36      //状态                                		   39
+        
+        
+        //日期,(6B),05日14时19分
+        offset=41;
+        index+=Hex2Ascii(at720frame+index,sbuf+offset,3);
+        
+        //加油机返回记录   1升
+        offset=46;
+        index+=Hex2Ascii(at720frame+index,sbuf+offset,3);
+        
+        //加油机返回记录金额
+        offset=51;
+        index+=Hex2Ascii(at720frame+index,sbuf+offset,3);
+        //单价  53.19				
+        offset=55;
+        index+=Hex2Ascii(at720frame+index,sbuf+offset,2);
+        
+        at720frame[index++] = 0x00; //小帧逻辑和校验
+        
+        //计算小帧长度，固定0x1A
+        //小帧逻辑和校验
+        check = 0;
+        
+        AT_AIR720_DEBUG_F("temp=%d\r\n",temp);
+        for(i=temp+2;i<index-1;i++)
+        {
+          check = check ^ at720frame[i];
+        }
+        at720frame[index-1] = check; //小帧逻辑和校验
+        
+        
+        
+        at720frame[index++] = 0x00; //UDP大帧逻辑和校验校验
+        //计算UDP帧长度，
+        at720frame[2] = ((index-5) >> 0) & 0xff;
+        at720frame[3] = ((index-5) >> 8) & 0xff;
+        check = 0;
+        for(i=0;i<index-1;i++)
+        {
+          check = check ^ at720frame[i];
+        }
+        //计算UDP帧逻辑和校验
+        at720frame[index-1] = check;//UDP大帧逻辑和校验校验
+        
+        AT_AIR720_DEBUG_F("0D len=%02d,msg=\r\n",index);
+        AT_AIR720_DEBUG_H(at720frame,index);
+        AT_AIR720_DEBUG("\r\n");
+        
+        //将组装好的0D包，入队列
+        En_Queue(Air720_Send_Sq,at720frame,sizeof(at720frame),index);
+        //心跳计数器清零
+//        time_gw_heartbeat.counter = TickCounter;
+        return 0;
+      }
+      //否则为非加密的
+      else{
+        
+        //从第19-69，共51个数是一致的
+        memcpy(at720frame+index,sbuf+index,51);
+        index+=51;
+        at720frame[index++] = 0x00; //小帧逻辑和校验
+        
+        //计算小帧长度，固定0x1A
+        at720frame[44]=0x1A;
+        //小帧逻辑和校验
+        check = 0;
+        temp = 43;
+        AT_AIR720_DEBUG_F("temp=%d\r\n",temp);
+        for(i=temp+2;i<index-1;i++)
+        {
+          check = check ^ at720frame[i];
+        }
+        at720frame[index-1] = check; //小帧逻辑和校验
+        
+        
+        
+        at720frame[index++] = 0x00; //UDP大帧逻辑和校验校验
+        //计算UDP帧长度，
+        at720frame[2] = ((index-5) >> 0) & 0xff;
+        at720frame[3] = ((index-5) >> 8) & 0xff;
+        check = 0;
+        for(i=0;i<index-1;i++)
+        {
+          check = check ^ at720frame[i];
+        }
+        //计算UDP帧逻辑和校验
+        at720frame[index-1] = check;//UDP大帧逻辑和校验校验
+        
+        AT_AIR720_DEBUG_F("0D len=%02d,msg=\r\n",index);
+        AT_AIR720_DEBUG_H(at720frame,index);
+        AT_AIR720_DEBUG("\r\n");
+        
+        //将组装好的0D包，入队列
+        En_Queue(Air720_Send_Sq,at720frame,sizeof(at720frame),index);
+        //心跳计数器清零
+//        time_gw_heartbeat.counter = TickCounter;
+        return 0;
+      }
+      
+    }
+    else{
+      AT_AIR720_DEBUG_F("未找到设备绑定信息!ID=0x%08X\r\n",fNodeID);
+      return -1;
+    }
+    
+  }
+  else if(sbuf[4]==0x0E){
+  }
+  return 0;
+}
+
+/**
+  * @brief	实现升级包的读，并完成写
+  * @param	cmd			发送的命令
+  * @param	ack			期待的应答结果
+  * @param	waittime 	等待时间(单位:10ms)
+  * @retval	0 发送成功
+			1 发送失败
+  */
+int   Update_Read_Write(uint16_t srclen)
+{
+#define DOWM_BYTE_SIZE (1024)//每次下载的字节大小,必须为整字节数
+#define DOWM_WORD_SIZE (DOWM_BYTE_SIZE>>2)//	
+	
+	uint16_t packetsize = DOWM_BYTE_SIZE;
+	
+	int16_t res =-1;
+  uint16_t i,j;
+	uint16_t cnt = 0 ,len_tail,cnt_tail,byte_tail,dlen,wlen;
+	uint8_t *pBuff = NULL ;
+  uint8_t flg,cntOk;
+	Uint32 BuffTmp,addr;
+	BuffTmp = 0;
+	BuffTmp += packetsize + 41;//总bufer大小，41为指令的大小
+	if(BuffTmp>USART2_BUF_SIZE)
+	{
+		AT_AIR720_DEBUG_F("buffer is SMALLL!!!");
+		return 1;
+	}
+	
+	cnt = srclen/(packetsize);//计算下载次数
+	len_tail = srclen%(packetsize);//不够一包剩余字节
+
+	addr = APP3_SECTOR1_START_ADD;//flash编程地址
+	FLASH_If_EraseSector(addr);
+	//packetsize = 10;
+	cntOk = 0;
+	//while(1)
+	{
+
+	for(i=0;i<cnt;i++)
+  {
+    AT_AIR720_DEBUG_F("down: %d\n!!!",i);
+    pBuff = air_send_HTTPREADCmd(addr,packetsize,300);
+    if(pBuff != NULL)//1024
+    { 
+      //写flash
+      for(j = 0; j<(packetsize>>2) ;j++)
+      {
+        BuffTmp = *(Uint32*)(pBuff + j*sizeof(Uint32)); 
+        FLASH_ProgramWord((uint32_t)(addr + j*sizeof(Uint32)), BuffTmp);
+      }
+      cntOk++;
+      addr +=packetsize;
+    }
+   //指示在下载
+   if(gt_config_para.pcb_ver ==0){
+     LED_Set(0,LED_FLASH); 
+   }
+   else{
+     LED_MODE_Set(LED_FLASH);
+   }
+  }
+
+} 
+    if(i != cntOk)
+    {
+      AT_AIR720_DEBUG_F("down is FAIL!!!");
+      return -1;
+    }
+		if(len_tail)
+		{
+      pBuff = air_send_HTTPREADCmd(addr,len_tail,300);
+			if(pBuff != NULL)//1024
+			{
+				cnt_tail= len_tail>>2;
+				//写flash
+				for(i = 0; i<cnt_tail ;i++)
+				{
+					BuffTmp = *(Uint32*)(pBuff + i*sizeof(Uint32)); 
+					FLASH_ProgramWord((uint32_t)(addr + i*sizeof(Uint32)), BuffTmp);
+				}
+	
+        res = 0;
+			}
+	
+		}
+    return res;
+	
+	}
+
+int aire720_closeUDP_openHTTP(const Uint8 *pSrc,Uint8 len){
+  
+  Uint8 sout[128];
+  Uint32 lout;
+  int res=255;
+  Uint32 uTemp32 = 0;
+  
+    AT_AIR720_DEBUG_F("关闭UDP或TCP,AT+CIPCLOSE!!!!,%d\r\n",uTemp32++);
+    if(air_send_cmd("AT+CIPCLOSE\r\n", "CLOSE OK", 200))
+		{
+			AT_AIR720_DEBUG_F("AT+CIPCLOSE  ok!!!!\r\n");
+		}
+    else{
+      AT_AIR720_DEBUG_F("AT+CIPCLOSE  failed!!!!\r\n");
+    }
+    
+    AT_AIR720_DEBUG_F("设置HTTP功能的承载类型,AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"!!!!,%d\r\n",uTemp32++);
+		if(air_send_cmd("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"\r\n", "OK", 200))
+		{
+			AT_AIR720_DEBUG_F("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"! ok!!!!\r\n");
+		}
+    else{
+      AT_AIR720_DEBUG_F("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"! failed!!!!\r\n");
+    }
+    
+		AT_AIR720_DEBUG_F("设置pdp承载参数之APN,AT+SAPBR=3,1,\"APN\",\"\"!!!!,%d\r\n",uTemp32++);
+		if(air_send_cmd("AT+SAPBR=3,1,\"APN\",\"\"\r\n", "OK", 200))
+		{
+			AT_AIR720_DEBUG_F("AT+SAPBR=3,1,\"APN\",\"\" ok!!!!\r\n");
+		}
+    else{
+      AT_AIR720_DEBUG_F("AT+SAPBR=3,1,\"APN\",\"\" failed!!!!\r\n");
+    }
+    
+		IWDG_Feed();	
+		AT_AIR720_DEBUG_F("激活该承载的GPRS PDP上下文,AT+SAPBR=1,1!!!!,%d\r\n",uTemp32++);
+		if(air_send_cmd("AT+SAPBR=1,1\r\n", "OK", 200))	      /* 激活该承载的GPRS PDP上下文 模式 */
+		{
+			AT_AIR720_DEBUG_F("AT+SAPBR=1,1 ok!!!!\r\n");
+		}
+    else{
+      AT_AIR720_DEBUG_F("AT+SAPBR=1,1 failed!!!!\r\n");
+    }
+
+		AT_AIR720_DEBUG_F("查询下承载的状态,AT+SAPBR=2,1!!!!,%d\r\n",uTemp32++);
+		if(air_send_cmd("AT+SAPBR=2,1\r\n", "OK", 200))
+		{
+			AT_AIR720_DEBUG_F("AT+SAPBR=2,1 ok!!!!\r\n");
+		}
+    else{
+      AT_AIR720_DEBUG_F("AT+SAPBR=2,1 failed!!!!\r\n");
+    }
+    
+		IWDG_Feed();	
+		AT_AIR720_DEBUG_F("HTTP协议栈初始化,AT+HTTPINIT!!!!,%d\r\n",uTemp32++);
+		if(air_send_cmd("AT+HTTPINIT\r\n", "OK", 200))	      /* 设置为快发模式 */
+		{
+			AT_AIR720_DEBUG_F("AT+HTTPINIT ok!!!!\r\n");
+		}
+    else{
+      AT_AIR720_DEBUG_F("AT+HTTPINIT failed!!!!\r\n");
+    }
+    
+    memset(sout,0,sizeof(sout));
+    lout=sprintf((char *)(sout),"AT+HTTPPARA=\"URL\",\"");
+    memcpy(sout+lout,(char *)pSrc,len);
+    lout+=len;
+    lout=sprintf((char *)(sout+lout),"\"\r\n");
+    
+		IWDG_Feed();	
+		AT_AIR720_DEBUG_F("建立http链接,%s!!!!,%d\r\n",sout,uTemp32++);
+		if(air_send_cmd((char *)&sout[0], "OK", 300))/*建立http链接*/
+		{
+			AT_AIR720_DEBUG_F("AT+HTTPPARA OK!!!!\r\n");
+      res=0;
+		}
+    else{
+      AT_AIR720_DEBUG_F("AT+HTTPPARA failed!!!!\r\n");
+    }
+    return res;
+}
+
+//const char *pURl = "http://47.104.15.180:8081/chfs/shared/A61010002.bin";//
+int32_t Down_Update_Packet(const Uint8 *pSrc,Uint8 len/*路径长度*/)
+{
+	int8_t res=-1;
+  Uint8 tmp[100];
+	 char *ptmp;
+	Uint16 cmdLen;
+	Uint16 reTry=0;
+	static Uint32 codelen,vaildcodelen;
+	 //关闭之前的链接
+	
+	//http配置
+	#if 1//ok
+    //一旦关闭之前的连接，则等待一段时间后，必须重新建立连接，可通过强制复位实现
+    time_gw_force_rst.counter=TickCounter;
+    time_gw_force_rst.timeOut=5*60*1000;
+    AT_AIR720_DEBUG_F("复位时间设为5分钟\r\n");
+  
+  
+    aire720_closeUDP_openHTTP(pSrc,len);
+  #if 0
+		if(air_send_cmd("AT+CIPCLOSE\r\n", "CLOSE OK", 200))
+		{
+			AT_AIR720_DEBUG_F("AT+CIPCLOSE  ok!!!!\r\n");
+		}
+		if(air_send_cmd("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"\r\n", "OK", 200))
+		{
+			AT_AIR720_DEBUG_F("AT+SAPBR=3,1 ok!!!!\r\n");
+		}
+		
+		if(air_send_cmd("AT+SAPBR=3,1,\"APN\",\"\"\r\n", "OK", 200))
+		{
+			AT_AIR720_DEBUG_F("AT+SAPBR=3,1 ok!!!!\r\n");
+		}
+		IWDG_Feed();	
+		if(air_send_cmd("AT+SAPBR=1,1\r\n", "OK", 200))	      /* 激活该承载的GPRS PDP上下文 模式 */
+		{
+			AT_AIR720_DEBUG_F("AT+SAPBR ok!!!!\r\n");
+		}
+
+		if(air_send_cmd("AT+SAPBR=2,1\r\n", "OK", 200))
+		{
+			AT_AIR720_DEBUG_F("AT+SAPBR=2,1 ok!!!!\r\n");
+		}
+		IWDG_Feed();	
+		if(air_send_cmd("AT+HTTPINIT\r\n", "OK", 200))	      /* 设置为快发模式 */
+		{
+			AT_AIR720_DEBUG_F("AT+HTTPINIT ok!!!!\r\n");
+		}
+
+		ptmp ="AT+HTTPPARA=\"URL\",\"";
+		memcpy(tmp,(void *)ptmp,strlen(ptmp));
+    memcpy(tmp+strlen(ptmp),(char *)pSrc,len);
+    //strcat((char *)&tmp[0],(char *)pSrc);
+    memcpy(tmp+strlen(ptmp)+len,"\"\r\n",strlen("\"\r\n"));
+		//strcat((char *)&tmp[0],"\"\r\n");
+		IWDG_Feed();	
+		if(air_send_cmd((char *)&tmp[0], "OK", 300))/*建立http链接*/
+		{
+		
+			AT_AIR720_DEBUG_F("AT+HTTPPARA OK!!!!\r\n");
+			
+		}
+    #endif
+		#endif
+		IWDG_Feed();	
+		//发送"AT+HTTPACTION=0\r\n"，等待get数据成功，并且获取数据长度
+    for(reTry=0;reTry<5;reTry++){
+      if(air_send_HTTPACTIONCmd(NULL, &codelen, 500))/*建立http链接*/
+      {
+        
+        AT_AIR720_DEBUG_F("AT+HTTPACTION=0,get len=%d!!!!,reTry=%d\r\n",codelen,reTry);
+        if((codelen>=10)&&(codelen<=128*1024)){
+          break;
+        }
+      }
+    }    
+    if((codelen<10)||(codelen>128*1024)){
+      AT_AIR720_DEBUG_F("升级包长度错误\r\n");
+      NVIC_SystemReset();// 强制复位
+    }
+		IWDG_Feed();	
+#if 0	
+		if(air_send_HTTPREADCmd(0,codelen,  300))/*读取数据codelen = 10; */
+		{
+		
+			AT_AIR720_DEBUG_F("AT+HTTPREADCmd=0!!!!,%d\r\n",vaildcodelen);
+			res = 0;
+		}
+	#else
+return	Update_Read_Write(codelen);
+
+#endif		
+}
+
+#define F1_CMD2_DOWM_SVR2WG_START_UPDATE  0x01      //下行，网关->采集器，启动升级
+tUpdare_Paras  Updare_Paras_form_S;
+/********************************
+  * @brief  Air720_Update_Down
+  * @par    pddata  	[tUpdare_Paras*]  
+  * @
+  * @retval 0初始成功，非0失败
+  ********************************/
+int8_t Air720_Update_Down(void)
+{
+	//切换模式
+	tUpdare_Paras *ptmp = &Updare_Paras_form_S;
+	
+	//Uint16 len = strlen((const char *)pURl);
+	//ptmp->srcUrlLen = len;
+	if((ptmp == NULL) || (ptmp->srcUrlLen < 30 ))//URL太短，小于50个字符，认为不合法
+	{
+		AT_AIR720_DEBUG_F("input para error:pddata == NULL\r\n");
+		return -EINVAL;
+	}
+	AT_AIR720_DEBUG_F("Air720_Update_Down\r\n");
+	//模式切换
+	if(Down_Update_Packet(&ptmp->ppath[0],ptmp->srcUrlLen)!=0){
+		AT_AIR720_DEBUG_F("Air720_Update_Down exit: dowm fail!!!!!!!!!!!\r\n");
+  }
+	else
+  {
+    Clr_Queue(lora_rx_sq);
+    Clr_Queue(lora_tx_sq);
+    set_ota_http_time_init();
+    
+    if(Updare_Paras_form_S.desDeviceType == DEVICE_TYPE_OIL_GATEWAY){//升级网关
+      set_ota_upstate(0x71,Updare_Paras_form_S.firmWareType);
+      set_main_WorkMode(GATEWAY_UPDATE_MODE);
+    }
+    if(Updare_Paras_form_S.desDeviceType == DEVICE_TYPE_NODE){//升级采集器
+      
+      OTA_Wg2Node(DEVICE_TYPE_NODE,0xFFFFFFFF,OTA_UPDATE_FIREWARE_TYPE_APP,0xFFFFFFFF);// 
+      set_main_WorkMode(NODE_UPDATE_MODE);
+    }
+		AT_AIR720_DEBUG_F("Air720_Update_Down OK!!\r\n");
+  }
+  return 0;
+}
+
+/********************************
+  * @brief  Air720_Receive_Handle
+  * @par    sbuf  	[uint8_t*]  帧缓存地址
+  * @par    slen    [uint8_t]   帧长度
+  * @retval 0初始成功，非0失败
+  ********************************/
+DEV_WORK_MODE_T Air720_Receive_Handle(uint8_t *sbuf,uint16_t slen)
+{
+	int8_t ReturnCode = -1;
+	uint8_t  scrc=0x0000,cmd1Tmp,cmd2Tmp;
+	DEV_WORK_MODE_T GtWorkMode =DEV_MODE_ALL ;
+  uint8_t  O9cmd2=0;
+	int  i,j;
+	uint8_t  check=0;
+	uint8_t  uTemp_8=0;
+	uint8_t  findChannel=0;
+	uint32_t uTemp_32=0;
+  uint8_t  data_offset=0;
+	uint32_t addrPkg=0;
+  uint32_t id=0;
+  uint32_t ver=0;
+  uint8_t  state=0;
+  //uint8_t  arair720[8][128]={0};
+	uint16_t sendLen,RevLen,sumCheck;
+  static uint32_t cmdCnt=0;
+  
+	tUNION32_T *ptmp_32 = NULL,*ptmp_32_2=NULL;
+	tUNION16_T *ptmp_16 = NULL;
+  uint8_t *pbuf;
+  //Frame09_t *pdst;
+	//校验
+	
+	if((sbuf == NULL)||(slen == 0))
+	{
+		AT_AIR720_DEBUG_F("error:sbuf == NULL,or slen == 0,%p\r\n",sbuf);
+		return GtWorkMode;
+	}
+  
+  AT_AIR720_DEBUG_F("len=%d,msg=\r\n",USART2_ready_buf_len);
+  for(i=0;i<USART2_ready_buf_len;i++)
+    printf("%02X ",sbuf[i]);
+  printf("\r\n");
+  
+  pbuf = sbuf;
+  
+  
+	if((pbuf[0]==0xFF)&&(pbuf[1]==0xEE)){
+    En_Queue(Air720_Rev_Sq,pbuf+2,AIR720_SQ_WIDTH,pbuf[2]+5);//AIR720_SQ_DEPTH,AIR720_SQ_WIDTH);
+  }
+  
+  for(i=0;i<USART2_ready_buf_len;i++){
+    if((pbuf[i+0]==0x0D)&&(pbuf[i+1]==0x0A)&&(pbuf[i+2]==0xFF)&&(pbuf[i+3]==0xEE)){
+      En_Queue(Air720_Rev_Sq,pbuf+2,AIR720_SQ_WIDTH,pbuf[i+4]+5);//AIR720_SQ_DEPTH,AIR720_SQ_WIDTH);
+    }
+  }
+  
+  //0D 0A FF EE 05 00 0D 0E 00 01 61 77 0D 0A 
+  
+  
+	//帧头(1Byte)
+	if((pbuf[0]==0xFF)&&(pbuf[1]==0xEE)){
+    slen = pbuf[2]+5;
+    //接收到任何FF EE的数据，复位时间后延
+    time_gw_force_rst.counter=TickCounter;
+    AT_AIR720_DEBUG_F("接收到服务器指令,CMD=0x%02X,cmdCnt=%010d\r\n",pbuf[4],cmdCnt++);
+  }
+	else
+	{
+//		AT_AIR720_DEBUG_F("非服务器指令");
+//		for(i=0;i<USART2_ready_buf_len;i++)
+//		printf("%02X ",pbuf[i]);
+//		return ReturnCode;
+    
+    for(i=0;i<USART2_ready_buf_len;i++){
+      
+    }
+    
+    for(i=0;i<USART2_ready_buf_len;i++){
+      
+      if((pbuf[i+0]==0x0D)&&(pbuf[i+1]==0x0A)&&(pbuf[i+2]==0xFF)&&(pbuf[i+3]==0xEE)&&(pbuf[i+4]==0xF1)){
+        //接收到任何FF EE的数据，复位时间后延
+        time_gw_force_rst.counter=TickCounter;
+        AT_AIR720_DEBUG_F("接收到服务器指令,CMD=0x%02X,cmdCnt=%010d\r\n",(pbuf[i+6]),cmdCnt++);
+        slen = pbuf[i+4]+5;
+        pbuf = pbuf+i+2;
+        break;
+      }
+      if(i==USART2_ready_buf_len-1){
+        AT_AIR720_DEBUG_F("非服务器指令,Rx=\r\n");
+        AT_AIR720_DEBUG_NB(pbuf,USART2_ready_buf_len);
+        printf("\r\n");
+        return GtWorkMode;
+      }
+    }
+	}
+  
+ 	//和校验
+  check = 0;
+  for(i=0;i<slen-1;i++)
+	{
+		check = check ^ pbuf[i];
+	}
+	scrc = pbuf[slen-1];
+	if(check != scrc)
+	{
+		AT_AIR720_DEBUG_F("error:Sum check error!,check0x%02X,scrc=0x%02X\r\n",check,scrc);
+		return GtWorkMode;
+	}
+
+	pbuf+=2;//指向长度
+	//帧长度(1Byte)
+	ptmp_16 =(tUNION16_T *)pbuf;
+	RevLen = ptmp_16->data_16 ;
+	pbuf+=2;//指向命令字
+
+   //解析
+	ptmp_16 =(tUNION16_T *)pbuf;
+	cmd1Tmp = ptmp_16->data_8[0];
+	cmd2Tmp = ptmp_16->data_8[1];
+	pbuf  +=2;//指向设备ID
+	if(cmd1Tmp == F1_CMD2)
+	{
+		switch(cmd2Tmp)
+		{
+			case 0xFF://启动升级，F1_CMD2_DOWM_SVR2WG_START_UPDATE
+				//
+        AT_AIR720_DEBUG_F("接收到升级指令!!!!!!!!!!!!!!!!!!!!!!\r\n");
+				ptmp_32 = (tUNION32_T *)pbuf;
+				ptmp_32_2 = (tUNION32_T *)&gt_config_para.DevId;
+				pbuf+=4;//指向参数信息
+				if((ptmp_32->data_32 == ptmp_32_2->data_32) ||(ptmp_32->data_32== 0xFFFFFFFF))
+				{//提取信息
+					pbuf+=1;
+					Updare_Paras_form_S.firmWareType = *pbuf++;//提取固件类型
+					Updare_Paras_form_S.desDeviceType = *pbuf++;
+					ptmp_32 =(tUNION32_T *)pbuf;
+					ptmp_32_2 = (tUNION32_T *)&Updare_Paras_form_S.desDeviceID;
+					ptmp_32_2->data_32 = ptmp_32->data_32;
+					pbuf +=4;
+					
+					Updare_Paras_form_S.desDeviceChannel = *pbuf++;
+					
+					ptmp_32 =(tUNION32_T *)pbuf;
+					ptmp_32_2 = (tUNION32_T *)&Updare_Paras_form_S.softWareOldVer;
+					ptmp_32_2->data_32 = ptmp_32->data_32;
+					pbuf +=4;
+					
+					ptmp_32 =(tUNION32_T *)pbuf;
+					ptmp_32_2 = (tUNION32_T *)&Updare_Paras_form_S.softWareNewVer;
+					ptmp_32_2->data_32 = ptmp_32->data_32;
+					pbuf +=4;
+					//路径长度
+					Updare_Paras_form_S.srcUrlLen = *pbuf++;
+          AT_AIR720_DEBUG_F("路径长度=%d\r\n",Updare_Paras_form_S.srcUrlLen);
+					//路径
+					memcpy(Updare_Paras_form_S.ppath,pbuf,Updare_Paras_form_S.srcUrlLen);
+          AT_AIR720_DEBUG_F("url=\r\n");
+          AT_AIR720_DEBUG_NB(Updare_Paras_form_S.ppath,Updare_Paras_form_S.srcUrlLen);
+          printf("\r\n");
+					//
+					GtWorkMode = GATEWAY_UPDATE_DOWN_MODE;
+					AT_AIR720_DEBUG_F("F1_CMD2_DOWM_SVR2WG_START_UPDATE\r\n");
+					
+				}else
+				{
+					//id不匹配不做处理
+				}
+				break;
+			case O9_CMD2:
+				
+			
+				break;
+      default:
+        break;
+		
+		}
+	
+	
+	}
+
+    IWDG_Feed();														//喂狗
+ 
+    return GtWorkMode; 
+}
+
+/********************************
+  * @brief  Air720_Receive_Handle
+  * @par    sbuf  	[uint8_t*]  帧缓存地址
+  * @par    slen    [uint8_t]   帧长度
+  * @retval 0初始成功，非0失败
+  ********************************/
+DEV_WORK_MODE_T Air720_Receive_Handler2(uint8_t *pbuf,uint16_t plen)//接收，拆包，入队列
+{
+  uint32_t i=0;
+  static uint32_t rcvCnt=0;
+	DEV_WORK_MODE_T GtWorkMode =DEV_MODE_ALL ;
+	
+  AT_AIR720_DEBUG_F("接收,rcvCnt=%d,plen=%d:\r\n",rcvCnt++,plen);
+  if(plen<10)
+    return DEV_MODE_ALL;
+  AT_AIR720_DEBUG_NB(pbuf,plen);
+  AT_AIR720_DEBUG("\r\n");
+  
+	if((pbuf[0]==0xFF)&&(pbuf[1]==0xEE)){
+    En_Queue(Air720_Rev_Sq,pbuf,AIR720_SQ_WIDTH,pbuf[2]+5);//AIR720_SQ_DEPTH,AIR720_SQ_WIDTH);
+    AT_AIR720_DEBUG_F("单独，接收到服务器指令,len=%d\r\n",pbuf[2]+5);
+    AT_AIR720_DEBUG_H(pbuf,pbuf[2]+5);
+  }
+  
+  for(i=0;i<plen-5;i++){
+    if((pbuf[i+0]==0x0D)&&(pbuf[i+1]==0x0A)&&(pbuf[i+2]==0xFF)&&(pbuf[i+3]==0xEE)){
+      En_Queue(Air720_Rev_Sq,pbuf+i+2,AIR720_SQ_WIDTH,pbuf[i+4]+5);//AIR720_SQ_DEPTH,AIR720_SQ_WIDTH);
+      AT_AIR720_DEBUG_F("复合，接收到服务器指令,len=%d\r\n",pbuf[i+4]+5);
+      AT_AIR720_DEBUG_H(pbuf+i+2,pbuf[i+4]+5);
+    }
+    else{
+     
+    }
+  }
+  return GtWorkMode;
+}
+
+/********************************
+  * @brief  Air720_Receive_process
+  * @par    sbuf  	[uint8_t*]  帧缓存地址
+  * @par    slen    [uint8_t]   帧长度
+  * @retval 0初始成功，非0失败
+  ********************************/
+DEV_WORK_MODE_T Air720_Receive_process()//接收，拆包，入队列
+{
+  uint32_t i=0;
+  uint8_t  sout[128]={0};
+  uint8_t  lout=0;
+  uint8_t *pbuf;
+  uint8_t  slen=0;
+	uint8_t  check=0;
+	uint8_t  scrc=0x00;
+  uint8_t  cmd1Tmp,cmd2Tmp;
+  
+	tUNION32_T *ptmp_32 = NULL;
+  tUNION32_T *ptmp_32_2=NULL;
+	tUNION16_T *ptmp_16 = NULL;
+  
+  tUpdate_t *pUpdateS =NULL;
+  
+	DEV_WORK_MODE_T GtWorkMode =DEV_MODE_ALL ;
+  uint16_t RevLen;
+  static uint32_t cmdCnt=0;
+  
+  
+	if(!Check_Seqeue_Empty(Air720_Rev_Sq))
+	{
+    
+		De_Queue(Air720_Rev_Sq,sout,sizeof(sout),(uint8_t *)&lout);
+    
+    AT_AIR720_DEBUG_F("处理服务器指令,cmdCnt=%d\r\n",cmdCnt++);
+    
+    pbuf=sout;
+    slen = pbuf[2]+5;
+    //和校验
+    check = 0;
+    for(i=0;i<slen-1;i++)
+    {
+      check = check ^ pbuf[i];
+    }
+    scrc = pbuf[slen-1];
+    if(check != scrc)
+    {
+      AT_AIR720_DEBUG_F("error:Sum check error!,check0x%02X,scrc=0x%02X\r\n",check,scrc);
+      return GtWorkMode;
+    }
+
+    pbuf+=2;//指向长度
+    //帧长度(1Byte)
+    ptmp_16 =(tUNION16_T *)pbuf;
+    RevLen = ptmp_16->data_16 ;
+    pbuf+=2;//指向命令字
+
+     //解析
+    ptmp_16 =(tUNION16_T *)pbuf;
+    cmd1Tmp = ptmp_16->data_8[0];
+    cmd2Tmp = ptmp_16->data_8[1];
+    pbuf  +=2;//指向设备ID
+    
+    
+    AT_AIR720_DEBUG_F("处理服务器指令,cmdCnt=%d,cmd1Tmp=0x%02X,cmd2Tmp=0x%02X,\r\n",cmdCnt,cmd1Tmp,cmd2Tmp);
+    
+    if(cmd1Tmp == F1_CMD2)
+    {
+      switch(cmd2Tmp)
+      {
+        case F1_CMD2_DOWM_SVR2WG_START_UPDATE://启动升级，
+          //
+          AT_AIR720_DEBUG_F("接收到升级指令!!!!!!!!!!!!!!!!!!!!!!\r\n");
+          ptmp_32 = (tUNION32_T *)pbuf;
+          ptmp_32_2 = (tUNION32_T *)&gt_config_para.DevId;
+          pbuf+=4;//指向参数信息
+          if((ptmp_32->data_32 == ptmp_32_2->data_32) ||(ptmp_32->data_32== 0xFFFFFFFF))
+          {//提取信息
+            pbuf+=1;
+            Updare_Paras_form_S.firmWareType = *pbuf++;//提取固件类型
+            Updare_Paras_form_S.desDeviceType = *pbuf++;
+            ptmp_32 =(tUNION32_T *)pbuf;
+            ptmp_32_2 = (tUNION32_T *)&Updare_Paras_form_S.desDeviceID;
+            ptmp_32_2->data_32 = ptmp_32->data_32;
+            pbuf +=4;
+            
+            Updare_Paras_form_S.desDeviceChannel = *pbuf++;
+            
+            ptmp_32 =(tUNION32_T *)pbuf;
+            ptmp_32_2 = (tUNION32_T *)&Updare_Paras_form_S.softWareOldVer;
+            ptmp_32_2->data_32 = ptmp_32->data_32;
+            pbuf +=4;
+            
+            ptmp_32 =(tUNION32_T *)pbuf;
+            ptmp_32_2 = (tUNION32_T *)&Updare_Paras_form_S.softWareNewVer;
+            ptmp_32_2->data_32 = ptmp_32->data_32;
+            pbuf +=4;
+            //路径长度
+            Updare_Paras_form_S.srcUrlLen = *pbuf++;
+            AT_AIR720_DEBUG_F("路径长度=%d\r\n",Updare_Paras_form_S.srcUrlLen);
+            //路径
+            memcpy(Updare_Paras_form_S.ppath,pbuf,Updare_Paras_form_S.srcUrlLen);
+            AT_AIR720_DEBUG_F("url=\r\n");
+            AT_AIR720_DEBUG_NB(Updare_Paras_form_S.ppath,Updare_Paras_form_S.srcUrlLen);
+            printf("\r\n");
+//            //
+//            i=10;
+//            while(i--){
+//              IWDG_Feed();														//喂狗
+//              AT_AIR720_DEBUG_F("F1_CMD2_DOWM_SVR2WG_START_UPDATE\r\n");
+//              delay_ms(1000);
+//            }
+//            return GtWorkMode;
+            gt_config_para.is_udp_update = 1;//是UDP升级
+            
+            GtWorkMode = GATEWAY_UPDATE_DOWN_MODE;
+            set_main_WorkMode(GtWorkMode);
+            AT_AIR720_DEBUG_F("F1_CMD2_DOWM_SVR2WG_START_UPDATE\r\n");
+            
+          }else
+          {
+            //id不匹配不做处理
+          }
+          break;
+        default:
+          break;
+      
+      }
+    
+    }
+    else if(0x0C){
+      //接收到任何FF EE的数据，复位时间后延
+      time_gw_force_rst.counter=TickCounter;
+      AT_AIR720_DEBUG_F("心跳清零\r\n");
+    }
+    else if(0x0D){
+    }
+    else if(0xF2){
+      if(cmd2Tmp==0x11){
+        AT_AIR720_DEBUG_F("接收到复位网关指令!!!!!!!!!!!!!!!!!!!!!!\r\n");
+        NVIC_SystemReset();// 复位
+      }
+    }
+    
+	}
+  
+  return GtWorkMode;
+}
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+int aire720_closeHTTP_openUDP(int AireConnectState){
+  
+  Uint8 sout[128];
+  Uint32 lout;
+  int res=255;
+  int i=0;
+  Uint32 uTemp32 = 0;
+  
+  static Uint32 CIICR_retry_time=0;
+        
+        if(AireConnectState){
+          AT_AIR720_DEBUG_F("关闭UDP或TCP,AT+CIPCLOSE!!!!,%d\r\n",uTemp32++);
+          if(air_send_cmd("AT+CIPCLOSE\r\n", "CLOSE OK", 200))
+          {
+            AT_AIR720_DEBUG_F("AT+CIPCLOSE  ok!!!!\r\n");
+          }
+          else{
+            AT_AIR720_DEBUG_F("AT+CIPCLOSE  failed!!!!\r\n");
+          }
+        }
+        AT_AIR720_DEBUG_F("AT,%d\r\n",uTemp32++);
+        if(air_send_cmd("AT\r\n", "OK", 200))
+        {
+          AT_AIR720_DEBUG_F("AT ok!!!!\r\n\r\n");
+        }
+        else{
+          AT_AIR720_DEBUG_F("AT failed!!!!\r\n\r\n");
+        }
+        
+        AT_AIR720_DEBUG_F("ATTE0,%d\r\n",uTemp32++);
+        if(air_send_cmd("ATTE0\r\n", "OK", 200))
+        {
+          AT_AIR720_DEBUG_F("ATTE0 ok!!!!\r\n\r\n");
+        }
+        else{
+          AT_AIR720_DEBUG_F("ATTE0 failed!!!!\r\n\r\n");
+        }
+        
+        AT_AIR720_DEBUG_F("设置为快发模式,AT+CIPQSEND=1,%d\r\n",uTemp32++);
+        if(air_send_cmd("AT+CIPQSEND=1\r\n", "OK", 200))	      // 设置为快发模式
+        {
+          AT_AIR720_DEBUG_F("AT+CIPQSEND ok!!!!\r\n\r\n");
+        }
+        else{
+          AT_AIR720_DEBUG_F("AT+CIPQSEND failed!!!!\r\n\r\n");
+        }
+        
+        AT_AIR720_DEBUG_F("启动任务，设置APN,AT+CSTT,%d\r\n",uTemp32++);
+        if(air_send_cmd("AT+CSTT\r\n", "OK", 200))	            // 启动任务，设置APN
+        {
+          AT_AIR720_DEBUG_F("AT+CSTT ok!!!!\r\n\r\n");
+        }
+        else{
+          AT_AIR720_DEBUG_F("AT+CSTT failed!!!!\r\n\r\n");
+        }
+        
+        
+        AT_AIR720_DEBUG_F("激活移动场景，获取IP地址,AT+CIICR%d\r\n",uTemp32++);
+        if(air_send_cmd("AT+CIICR\r\n", "OK", 200))	            // 激活移动场景，获取IP地址
+        {
+          AT_AIR720_DEBUG_F("AT+CIICR ok!!!!\r\n\r\n");
+        }
+        else{
+          AT_AIR720_DEBUG_F("AT+CSTT failed!!!!retry=%d\r\n\r\n",CIICR_retry_time);
+          CIICR_retry_time++;
+          if(CIICR_retry_time>5){
+            return res;
+          }
+          
+        }
+        //LED_RUN_Set(LED_FLASH);
+        
+        IWDG_Feed();
+        
+        // 确保模块工作正常
+        AT_AIR720_DEBUG_F("查询分配的IP地址,AT+CIFSR,%d\r\n",uTemp32++);
+        if(air_send_cmd("AT+CIFSR\r\n", ".", 200))					    //查询分配的IP地址
+        {
+          AT_AIR720_DEBUG_F("AT+CIFSR ok!!!!\r\n\r\n");
+        }
+        else{
+          AT_AIR720_DEBUG_F("AT+CIFSR failed!!!!\r\n\r\n");
+          return res;
+        }
+        //LED_RUN_Set(LED_FLASH);
+        IWDG_Feed();
+        res=0;
+        return 0;
+}
+
+/***返回工作模式**/
+int flg = 1;
+void AT_aire720_process(DEV_WORK_MODE_T *pmode){
+  Uint16 retryTimes = 0,sendlen,flg = 1;
+  Uint16 lora_rcv_len = 0;
+	Uint8 lora_rcv_buffer[128];
+  Uint16 at_send_len = 0;
+	Uint8 at_send_buffer[128];
+  Uint16 cmd_len = 0;
+  Uint32 uTemp32 = 0;
+	Uint8 cmd_str[32];
+  Uint8 buffer[256];
+	DEV_WORK_MODE_T WorkMode = *pmode,ret;
+  static Uint32 retry_time=0;
+  
+  static Uint32 CIICR_retry_time=0;
+  int i;
+	char *pchar = "AT+CPIN1111111111111111111111\r\n";
+  //心跳，超过一定时间没有节点的数据，则网关自己上传心跳
+  if((*pmode == GATEWAY_WORK_MODE)&&(TickCounter - time_gw_heartbeat.counter > time_gw_heartbeat.timeOut)){
+    time_gw_heartbeat.counter = TickCounter;
+    UDP_0C_frame();
+    AT_AIR720_DEBUG_F("gw heartbeat time out\r\n");
+  }
+
+  IWDG_Feed();														//喂狗
+  
+  if(!Check_Seqeue_Empty(lora_rx_sq)){
+    IWDG_Feed();														//喂狗
+    lora_rcv_len = 0;
+    memset(lora_rcv_buffer,0,sizeof(lora_rcv_buffer));
+    
+    De_Queue(lora_rx_sq,lora_rcv_buffer,sizeof(lora_rcv_buffer),(uint8_t *)&lora_rcv_len);
+    
+    AT_AIR720_DEBUG_F("lora receive:len=%02d,msg=\r\n",lora_rcv_len);
+    AT_AIR720_DEBUG_H(lora_rcv_buffer,lora_rcv_len);
+    AT_AIR720_DEBUG("\r\n");
+    
+    IWDG_Feed();														//喂狗
+    Air720_analysis(lora_rcv_buffer,lora_rcv_len);
+    IWDG_Feed();														//喂狗
+    
+    //int Air720_analysis(uint8_t *sbuf,uint8_t slen){
+  }
+
+  switch(AT_aire720_State){
+    case AT_AIRE720_STATE_IDLE:
+     // AT_aire720_State = AT_AIRE720_STATE_SEND;
+      break;
+    case AT_AIRE720_STATE_INIT:
+			Air720_Init();
+    #if 0
+      AT_AIR720_DEBUG_F("尝试联网,retry_time=%d\r\n",retry_time++);
+      if(aire720_closeHTTP_openUDP(0)){
+      AT_AIR720_DEBUG_F("尝试联网 failed!!!!retry_time=%d\r\n",retry_time++);
+        if(retry_time>5){
+          AT_aire720_State =AT_AIRE720_STATE_CONNECTING;
+          retry_time=0;
+        }
+        break;
+      }
+      else{
+        AT_AIR720_DEBUG_F("尝试联网 OK\r\n");
+      }
+#endif
+      if(1){
+        
+        for(i=0;i<10;i++){
+          AT_AIR720_DEBUG_F(".\r\n");
+          IWDG_Feed();														//喂狗
+          delay_ms(1000);
+          //LED_RUN_Set(LED_FLASH);
+        }
+        
+          
+        AT_AIR720_DEBUG_F("start AT\r\n");
+        cmd_len = sprintf((char *)cmd_str,"AT\r\n");
+        USART2_SendNByte(cmd_str, cmd_len);
+        IWDG_Feed();														//喂狗
+        delay_ms(1000);
+        IWDG_Feed();														//喂狗
+        //LED_RUN_Set(LED_FLASH);
+      
+        AT_AIR720_DEBUG_F("start ATE0&W\r\n");
+        cmd_len = sprintf((char *)cmd_str,"ATE0&W\r\n");
+        USART2_SendNByte(cmd_str, cmd_len);
+        IWDG_Feed();														//喂狗
+        delay_ms(1000);
+        IWDG_Feed();														//喂狗
+        //LED_RUN_Set(LED_FLASH);
+        
+        AT_AIR720_DEBUG_F("start AT+CIPMUX=0\r\n");
+        cmd_len = sprintf((char *)cmd_str,"AT+CIPMUX=0\r\n");
+        USART2_SendNByte(cmd_str, cmd_len);
+        IWDG_Feed();														//喂狗
+        delay_ms(1000);
+        IWDG_Feed();														//喂狗
+        //LED_RUN_Set(LED_FLASH);
+        
+        
+        AT_AIR720_DEBUG_F("start AT+CIPQSEND=1\r\n");
+        cmd_len = sprintf((char *)cmd_str,"AT+CIPQSEND=1\r\n");	      // 设置为快发模式
+        USART2_SendNByte(cmd_str, cmd_len);
+        IWDG_Feed();														//喂狗
+        delay_ms(1000);
+        IWDG_Feed();														//喂狗
+        //LED_RUN_Set(LED_FLASH);
+        
+        
+        AT_AIR720_DEBUG_F("start AT+CSTT\r\n");
+        cmd_len = sprintf((char *)cmd_str,"AT+CSTT\r\n");             // 启动任务，设置APN
+        USART2_SendNByte(cmd_str, cmd_len);
+        IWDG_Feed();														//喂狗
+        delay_ms(1000);
+        IWDG_Feed();														//喂狗
+        //LED_RUN_Set(LED_FLASH);
+        
+        AT_AIR720_DEBUG_F("start AT+CIICR\r\n");
+        cmd_len = sprintf((char *)cmd_str,"AT+CIICR\r\n");	          // 激活移动场景，获取IP地址
+        USART2_SendNByte(cmd_str, cmd_len);
+        IWDG_Feed();														//喂狗
+        delay_ms(1000);
+        IWDG_Feed();														//喂狗
+        //LED_RUN_Set(LED_FLASH);
+        
+        AT_AIR720_DEBUG_F("start AT+CIFSR\r\n");
+        cmd_len = sprintf((char *)cmd_str,"AT+CIFSR\r\n");					  //查询分配的IP地址
+        USART2_SendNByte(cmd_str, cmd_len);
+        IWDG_Feed();														//喂狗
+        delay_ms(1000);
+        IWDG_Feed();														//喂狗
+        //LED_RUN_Set(LED_FLASH);
+      }
+      else{
+        
+        AT_AIR720_DEBUG_F("AT_AIRE720_STATE_INIT!!!!,%d\r\n",uTemp32++);
+        
+        for(i=0;i<5;i++){
+          AT_AIR720_DEBUG_F(".%d\r\n",uTemp32++);
+          IWDG_Feed();														//喂狗
+          delay_ms(1000);
+          //LED_RUN_Set(LED_FLASH);
+        
+        }
+        
+        
+        
+        AT_AIR720_DEBUG_F("AT,%d\r\n",uTemp32++);
+        if(air_send_cmd("AT\r\n", "OK", 200))
+        {
+          AT_AIR720_DEBUG_F("AT ok!!!!\r\n\r\n");
+        }
+        else{
+          AT_AIR720_DEBUG_F("AT failed!!!!\r\n\r\n");
+        }
+        
+        AT_AIR720_DEBUG_F("ATTE0,%d\r\n",uTemp32++);
+        if(air_send_cmd("ATTE0\r\n", "OK", 200))
+        {
+          AT_AIR720_DEBUG_F("ATTE0 ok!!!!\r\n\r\n");
+        }
+        else{
+          AT_AIR720_DEBUG_F("ATTE0 failed!!!!\r\n\r\n");
+        }
+        
+        //AT_AIR720_DEBUG_F("设置为快发模式,AT+CIPQSEND=1,%d\r\n",uTemp32++);
+        if(air_send_cmd("AT+CIPQSEND=1\r\n", "OK", 200))	      // 设置为快发模式
+        {
+          AT_AIR720_DEBUG_F("AT+CIPQSEND ok!!!!\r\n\r\n");
+        }
+        else{
+          AT_AIR720_DEBUG_F("AT+CIPQSEND failed!!!!\r\n\r\n");
+        }
+        
+        //AT_AIR720_DEBUG_F("启动任务，设置APN,AT+CSTT,%d\r\n",uTemp32++);
+        if(air_send_cmd("AT+CSTT\r\n", "OK", 200))	            // 启动任务，设置APN
+        {
+          AT_AIR720_DEBUG_F("AT+CSTT ok!!!!\r\n\r\n");
+        }
+        else{
+          AT_AIR720_DEBUG_F("AT+CSTT failed!!!!\r\n\r\n");
+        }
+        
+        
+        //AT_AIR720_DEBUG_F("激活移动场景，获取IP地址,AT+CIICR%d\r\n",uTemp32++);
+        if(air_send_cmd("AT+CIICR\r\n", "OK", 1000))	            // 激活移动场景，获取IP地址
+        {
+          AT_AIR720_DEBUG_F("AT+CIICR ok!!!!\r\n\r\n");
+        }
+        else{
+          AT_AIR720_DEBUG_F("AT+CSTT failed!!!!retry=%d\r\n\r\n",CIICR_retry_time);
+          CIICR_retry_time++;
+          if(CIICR_retry_time>5){
+            AT_aire720_State =AT_AIRE720_STATE_CONNECTING;
+            CIICR_retry_time=0;
+          }
+          break;
+        }
+        //LED_RUN_Set(LED_FLASH);
+        
+        IWDG_Feed();
+        
+        // 确保模块工作正常
+        AT_AIR720_DEBUG_F("查询分配的IP地址,AT+CIFSR,%d\r\n",uTemp32++);
+        if(air_send_cmd("AT+CIFSR\r\n", ".", 200))					    //查询分配的IP地址
+        {
+          AT_AIR720_DEBUG_F("AT+CIFSR ok!!!!\r\n\r\n");
+        }
+        else{
+          AT_AIR720_DEBUG_F("AT+CIFSR failed!!!!\r\n\r\n");
+        }
+        //LED_RUN_Set(LED_FLASH);
+        IWDG_Feed();
+      }
+
+
+			AT_aire720_State =AT_AIRE720_STATE_CONNECTING;
+      break;
+    case AT_AIRE720_STATE_CONNECTING:
+						/* 连接服务器 */
+			retryTimes = 0;
+			while(retryTimes++ < UDP_CONNECT_RETRY_TIMES)
+			{
+				 IWDG_Feed();
+#if TEST_TEST_TEST
+          //124.70.207.36 9084
+          //47.104.15.180 9082
+          //
+//          cmd_len = sprintf((char *)cmd_str,"AT+CIPSTART=\"UDP\",\"124.70.207.36\",\"9084\"\r\n");
+          cmd_len = sprintf((char *)cmd_str,"AT+CIPSTART=\"UDP\",\"47.104.15.180\",\"9082\"\r\n");   
+          AT_AIR720_DEBUG_F("%s,%d\r\n",cmd_str,uTemp32++);
+#else
+          cmd_len = sprintf((char *)cmd_str,"AT+CIPSTART=\"UDP\",\"47.104.15.180\",\"9080\"\r\n");      
+          AT_AIR720_DEBUG_F("%s,%d\r\n",cmd_str,uTemp32++);
+#endif
+        
+				if(air_send_cmd((char *)cmd_str, "OK", 100))/*建立UDP链接*/
+				{
+						AT_aire720_State = AT_AIRE720_STATE_CONNECT_OK;
+						AT_AIR720_DEBUG_F("UDP connect ok!!!!,%d\r\n",uTemp32++);
+						//Air720_send(cmd_str,cmd_len);
+           // Air720_send((uint8_t *)pchar,strlen((char *)pchar));
+			
+          break;
+				}
+        //LED_RUN_Set(LED_FLASH);
+        
+				
+			}
+			if(AT_aire720_State != AT_AIRE720_STATE_CONNECT_OK)
+			{
+				AT_AIR720_DEBUG_F("ERROR:UDP connect fail!!!!,%d\r\n",uTemp32++);
+				AT_AIR720_DEBUG_F("ERROR:UDP connect fail!!!!,%d\r\n",uTemp32++);
+				AT_AIR720_DEBUG_F("ERROR:UDP connect fail!!!!,%d\r\n",uTemp32++);
+				NVIC_SystemReset();// 复位
+			}
+			else
+			{
+				
+        IWDG_Feed();														//喂狗
+        delay_ms(200);
+        
+        AT_AIR720_DEBUG_F("%d\r\n",uTemp32++);
+        if(air_send_IMEI_Cmd(10))
+        {
+          AT_AIR720_DEBUG_F("read imei,%d\r\n",uTemp32++);
+        }
+        //LED_RUN_Set(LED_FLASH);
+        
+        
+        AT_AIR720_DEBUG_F("%d\r\n",uTemp32++);
+        if(air_send_ICCID_Cmd(10))
+        {
+          AT_AIR720_DEBUG_F("read iccid,%d\r\n",uTemp32++);
+        }
+        //LED_RUN_Set(LED_FLASH);
+        //联网之后先心跳
+        UDP_0C_frame();
+        //无服务器反馈指令时，设置强制复位时间1小时
+        time_gw_force_rst.timeOut=60*60*1000;
+			}
+//			for(i=0;i<NODE_NUM;i++){
+//        LED_Set(i,LED_OFF);
+//      }
+      LED_OFF_ALL();
+      break;
+    
+    
+    case AT_AIRE720_STATE_CONNECT_OK://指令收发
+			//air_send_cmd("AT+CIPSEND=25", 0, 300);/*建立UDP链接*/
+		
+
+			  if(!Check_Seqeue_Empty(Air720_Send_Sq)){
+					IWDG_Feed();														//喂狗
+          at_send_len = 0;
+          memset(at_send_buffer,0,sizeof(at_send_buffer));
+          
+          De_Queue(Air720_Send_Sq,at_send_buffer,sizeof(at_send_buffer),(uint8_t *)&at_send_len);
+          
+          //AT_AIR720_DEBUG_F("at_send_len=%d\r\n",at_send_len);
+          
+          Air720_send(at_send_buffer,at_send_len);
+					IWDG_Feed();														//喂狗
+          delay_ms(100);
+					IWDG_Feed();														//喂狗
+        }
+  
+      //接收处理
+			#if 0
+			 if(!Check_Seqeue_Empty(Air720_Rev_Sq)){
+					IWDG_Feed();														//喂狗
+				sendlen = 0;
+				memset(buffer,0,sizeof(buffer));
+				De_Queue(Air720_Rev_Sq,buffer,sizeof(buffer),(uint8_t *)&sendlen);
+			
+				Air720_Receive_Handle(buffer,sendlen);
+			}
+			if (USART2_ready_buf_ok == RevOK)
+			{
+				
+				AT_AIR720_DEBUG_F("UDP ready Entery!!!!\r\n");
+				flg = 0;
+				for(i = 0;i<USART2_ready_buf_len; i++)
+				{
+					if(USART2_ready_buf[i] == 0xff)
+						flg = 1;
+					//if(flg)
+					//AT_AIR720_DEBUG_F("0x%02X ",USART2_ready_buf[i]);
+				
+				}
+				//AT_AIR720_DEBUG_F("%p\n",USART2_ready_buf);
+				if((ret = Air720_Receive_Handler2(&USART2_ready_buf[0],USART2_ready_buf_len))!=DEV_MODE_ALL)
+				*pmode = ret;
+				USART2_ready_buf_ok = 0;
+			}
+			else
+				memset(USART2_ready_buf,0,USART2_BUF_SIZE);
+      
+			#endif
+      
+      if (USART2_ready_buf_ok == RevOK){
+        Air720_Receive_Handler2(&USART2_ready_buf[0],USART2_ready_buf_len);
+        USART2_ready_buf_ok = 0;
+        memset(USART2_ready_buf,0,USART2_BUF_SIZE);
+      }
+      if((ret = Air720_Receive_process())!=DEV_MODE_ALL){
+        *pmode=ret;
+        return;
+      }
+      break;
+    case AT_AIRE720_STATE_RE_CONNECT:
+//      
+//      AT_AIR720_DEBUG_F("重新尝试联网,retry_time=%d\r\n",retry_time++);
+//      if(aire720_closeHTTP_openUDP(1)){
+//      AT_AIR720_DEBUG_F("尝试联网 failed!!!!retry_time=%d\r\n",retry_time++);
+//        if(retry_time>5){
+//          AT_aire720_State =AT_AIRE720_STATE_CONNECTING;
+//          retry_time=0;
+//        }
+//        break;
+//      }
+//      else{
+//        AT_AIR720_DEBUG_F("尝试联网 OK\r\n");
+//      }
+    
+      //
+//      AT_AIR720_DEBUG_F("关闭UDP或TCP,AT+CIPCLOSE!!!!,%d\r\n",uTemp32++);
+//          if(air_send_cmd("AT+CIPCLOSE\r\n", "CLOSE OK", 200))
+//          {
+//            AT_AIR720_DEBUG_F("AT+CIPCLOSE  ok!!!!\r\n");
+//          }
+//          else{
+//            AT_AIR720_DEBUG_F("AT+CIPCLOSE  failed!!!!\r\n");
+//          }
+      
+      
+			AT_aire720_State =AT_AIRE720_STATE_CONNECTING;
+      break;
+    default:
+      AT_aire720_State = AT_AIRE720_STATE_IDLE;
+      break;
+  }
+  return;
+}
+
+void set_at_aire720_workState(tAT_AIRE720_StateCodes  mode){
+  AT_aire720_State = mode;
+  return;
+}
+

APP/network_mgr/air72x/atair720.h

@@ -0,0 +1,122 @@
+#ifndef __ATAIR720__
+#define __ATAIR720__
+
+#include <stdint.h>
+#include "type-spec.h"
+#include "queue.h"
+
+#define AT_AIR720_DEBUG_EN 1
+
+#ifdef AT_AIR720_DEBUG_EN
+
+
+#define AT_AIR720_DEBUG(fmt, x...) \
+do \
+{ \
+    printf(fmt,##x); \
+}while(0)
+
+#define AT_AIR720_DEBUG_NB(fmt, x...) \
+do \
+{ \
+    UART4_SendNByte(fmt,##x); \
+}while(0)
+
+#define AT_AIR720_DEBUG_String(fmt, x...) \
+do \
+{ \
+    UART4_SendString(fmt,##x); \
+}while(0)
+
+#define AT_AIR720_DEBUG_1B(fmt, x...) \
+do \
+{ \
+    UART4_SendByte(fmt,##x); \
+}while(0)
+
+
+#define AT_AIR720_DEBUG_H(fmt, x...) \
+do \
+{ \
+    USART_printfHex(fmt,##x); \
+}while(0)
+
+#define AT_AIR720_DEBUG_F(fmt, x...) \
+do \
+{ \
+    printf("%s %s(Line %d): "fmt,__FILE__,__FUNCTION__,__LINE__, ##x); \
+}while(0)
+
+#else
+#define AT_AIR720_DEBUG(fmt, x...)
+#define AT_AIR720_DEBUG_1B(fmt, x...)
+#define AT_AIR720_DEBUG_NB(fmt, x...)
+#define AT_AIR720_DEBUG_String(fmt, x...)
+#define AT_AIR720_DEBUG_H(fmt, x...)
+#define AT_AIR720_DEBUG_F(fmt, x...)
+#endif
+
+void	thread_atair720(void* parameter);
+void Air720_Init(void);
+
+#define buflen  256
+#define loraidbuflen  20
+
+typedef struct USART_BUF{
+	
+	unsigned char rxbufindex;
+	
+	//unsigned char txbufindex;
+	
+  unsigned char rxbuf[buflen];
+	
+	//unsigned char txbuf[buflen];
+	
+} USART_BUF_t;
+
+
+uint16_t UDP_0D_frame_l(uint8_t td);
+
+uint16_t UDP_0D_frame_N(uint8_t td);
+
+uint16_t UDP_0D_frame_NT(uint8_t td);
+
+void AT_aire720_process(DEV_WORK_MODE_T *pmode);
+
+
+
+typedef enum
+{
+    AT_AIRE720_STATE_IDLE=0,
+    AT_AIRE720_STATE_INIT,
+    AT_AIRE720_STATE_CONNECTING,
+		AT_AIRE720_STATE_CONNECT_OK,
+		AT_AIRE720_STATE_RE_CONNECT,
+
+
+
+} tAT_AIRE720_StateCodes;//AT_aire720_State
+typedef struct{
+	uint8_t rsv; 
+	uint8_t firmWareType;                 //固件，类型，0:APP，1:BootLoader,2:SET配置区
+	uint8_t desDeviceType;   							//被升级设备类型(1Byte)
+	uint8_t desDeviceID[4];        					  //被升级设备ID(4Byte)
+	uint8_t  desDeviceChannel;        			//被升级设备通道号(1Byte)
+	uint8_t softWareOldVer[4];        				//前版本(4Byte)
+	uint8_t softWareNewVer[4];        				//后版本(4Byte)
+	uint8_t  srcUrlLen;        			//固件路径URL的长度(1B)
+	uint8_t  ppath[80];										//固件路径URL
+}tUpdare_Paras;
+
+int8_t Air720_Update_Down(void);
+uint8_t  air_send_IMEI_Cmd(uint16_t waittime);
+uint8_t  air_send_ICCID_Cmd(uint16_t waittime);
+
+extern sequeue_t * Air720_Send_Sq;
+
+extern tCounterTimeOut_t time_gw_force_rst;
+void set_at_aire720_workState(tAT_AIRE720_StateCodes  mode);
+
+#endif
+
+

APP/network_mgr/at/at_module.c

@@ -0,0 +1,457 @@
+/********************************************************************************
+ * @file    AT_Module.c
+ * @author  度云未来 DOIOT
+ * @brief   针对公司模块AT指令的处理库
+ ******************************************************************************
+ * @attention
+ * <h2><center>&copy; Copyright (c) 2019 成都度云未来
+ * All rights reserved.</center></h2>
+ * 注意:本程序针对cubemx 生成的hal库程序快速开发
+ * 环境:keil5.0
+ * STM32Cube FW_F1 V1.8.0
+ * 文件版本：1.3		更新时间2020/10/15   降低了文件之间的耦合度
+********************************************************************************/
+ 
+#include "includes.h"
+#include "trace.h"
+#include "at_module.h"
+#include "stdarg.h"
+#include "string.h"
+#include "stdio.h"
+#include "stdlib.h"  
+
+
+uint8_t AT_CMD_SEND(AT_CMD task);
+extern int uart_blocking_read(char *buffer, u8 uartid, u32 timeout);
+char at_rxbuff[1024];
+int Module_Blocking_Read(char *buffer, u32 timeout)
+{
+	return uart_blocking_read(buffer, UART_ME3616, timeout);
+}
+
+uint8_t AT_TASK_START(AT_CMD task[],uint8_t Size)
+{
+	uint32_t i;
+	for(i=0;i<Size;i++)
+	{
+		AT_INFO("Start Task %d",i+1);
+
+		if(AT_CMD_SEND(task[i]))
+		{
+			/*校验成功,开始延时*/
+			HAL_Delay(task[i].delay_time);	
+		}
+		else
+		{
+			/*校验失败,开始处理*/
+			if(task[i].REF_Count!=0)
+			{
+				task[i].REF_Count--;
+				i--;/*下一次迭代会回到这个地方*/
+				AT_INFO("开始重发");
+			}
+			else/*没有重发次数或者次数已尽*/
+			{
+			/*装载跳跃位置*/
+				if(task[i].jump!=0)
+				{
+				i=task[i].jump-2;
+				AT_INFO("开始跳转");
+				}
+			}
+		}
+	}
+	return 1;
+}
+
+uint8_t AT_CMD_SEND(AT_CMD task)
+{
+	uint8_t i=0;
+	rxbuff(buff);
+	
+	/*先执行前调函数*/
+	if(task.BeforeCpltCallback!=NULL)
+	{
+		task.BeforeCpltCallback();
+	}
+		
+	module_printf("%s", task.SEND_CMD);
+	AT_INFO("SEND:%s",task.SEND_CMD);
+	
+	for(i=0;i<task.crc_size;i++)
+	{
+
+		Module_Blocking_Read(buff,task.timeout);
+		AT_INFO("ASK:%s",buff);
+		
+		if(strstr(buff,task.ASK[i]))
+		{	
+		}else
+		{
+			AT_ERROR("%s",buff);
+			/*校验失败，执行失败回掉*/
+			if(task.ErrorCpltCallback!=NULL)
+			{
+				task.ErrorCpltCallback(buff);
+			}
+			return 0;
+		}
+	}
+		/*校验成功，执行完成回调函数*/
+	if(task.AfterCpltCallback!=NULL)
+	{
+		task.AfterCpltCallback(buff);
+	}
+		return 1;
+}
+
+/**
+* @param sned_cmd	: 发送的指令
+* @param cmd_arry	: 要校验的响应数组
+* @param ack_str: 响应的校验的字串
+* @param overtime	: 校验的数量【如果响应组是3，校验是2，则会读取三次，但只校验到第2组】
+*/
+
+uint8_t Module_SEND_CRC(char* send_cmd,char *ack_str,uint32_t overtime)
+{
+	//char rxbuf[cmd_length];
+	module_printf("%s", send_cmd);
+	if(Module_Read_A_CRC(ack_str,overtime)) return 1;//校验成功;	
+	else return 0;/*阻塞的读取一次响应,超时返回失败*/
+}
+
+
+/**
+* @param sned_cmd	: 发送的指令
+* @param cmd_arry	: 要校验的响应数组
+* @param arry_size: 响应的校验组数量
+* @param crc_size	: 校验的数量【如果响应组是3，校验是2，则会读取三次，但只校验到第2组】
+*/
+
+uint8_t Module_SEND_A_CRC(char* send_cmd,char cmd_arry[][cmd_length],uint8_t arry_size,uint8_t crc_size)
+{
+	char rxbuf[cmd_length];
+	uint8_t i;
+	module_printf("%s", send_cmd);
+	for(i=0;i<arry_size;i++)							/*读取完指定次数*/
+	{	
+		if(Module_Blocking_Read(rxbuf,1000));	/*阻塞的读取一次响应,超时返回失败*/
+		else return 0;
+			
+		if(i<crc_size)												/*校验指定的次数*/
+		{
+			if(strstr(rxbuf,cmd_arry[i])) 
+			{
+			}else goto cmd_fail;
+		}
+	}
+	return 1;//校验成功
+	
+	cmd_fail: 
+	{
+		/*自写错误处理*/
+	}
+	return  0;
+}
+
+/**
+* @param 阻塞读取一次数据并校验
+* @param cmd_arry	: 要校验的响应数组
+* @param overtime	: 超时时间
+*/
+
+uint8_t Module_Read_A_CRC(char cmd_arry[],uint32_t overtime)
+{
+	//rxbuff(at_rxbuff);
+
+	memset(at_rxbuff, 0, sizeof(at_rxbuff));	
+
+	if(Module_Blocking_Read(at_rxbuff,overtime)) /*阻塞的读取一次响应,超时返回失败*/
+	{
+//		printf("%s\r\n", at_rxbuff);
+		if(strstr(at_rxbuff,cmd_arry))
+		return 1;	
+		else 
+		{
+			return 0;
+		}
+	}
+	else return 0;
+}
+
+uint8_t Module_Read_A_CRC_DA(char cmd_arry[],char head_arry[], uint32_t len, uint32_t overtime)
+{
+	//rxbuff(at_rxbuff);
+    int i = 0,rcv_size = 0;
+    memset(at_rxbuff, 0, sizeof(at_rxbuff));
+    rcv_size = Module_Blocking_Read(at_rxbuff,overtime);
+    if(rcv_size) /*阻塞的读取一次响应,超时返回失败*/
+    {
+
+//        data_dump("net sendx", (uint8_t *)at_rxbuff, len);
+//        if(strstr(at_rxbuff+len/2,cmd_arry))
+//            return 1;
+//        else
+//        {
+//            return 0;
+//        }
+
+        for(i=len/2; i<rcv_size; i++){
+            if(at_rxbuff[i]==0x0D && at_rxbuff[i+1]==0x0A){
+                if(strstr(at_rxbuff+i,cmd_arry)){
+                    return 1;
+                }
+                else continue;
+            }
+        }
+        return 0;
+    }
+    else return 0;
+}
+
+/**@brief AT_CMD_Polling:按指定的指令轮询直到响应对应的ACK才返回
+* @param  send_cmd			 : 需要轮询的指令
+* @param  Polling_fre	   : 轮询间隔
+* @param  overtime       : 超时时间
+*/
+uint8_t AT_CMD_Polling(char *send_cmd,char*ack,uint32_t Polling_delay,uint32_t overtime)
+{
+	uint32_t time_count=0;
+	while(1)
+	{
+		if(time_count%Polling_delay==0)
+		{
+		module_printf("%s", send_cmd);
+		if(Module_Read_A_CRC(ack,100)) return 1;
+		}
+		time_count++;
+		HAL_Delay(1);
+		if(time_count>overtime) return 0;
+	}
+}
+
+/**@brief AT_GET_data:提取字符串中第Number_of_groups组被特定字符包裹的信息，标志必须是成对闭合的
+* @param  buff			 : 待提取的字符串，可以是数组或静态字符串
+* @param  get_data	 : 提取后装载的数组，必须是数组，不能是静态字符串因为需要写
+* @param  sign       : 包裹符号,是一个字符
+* @param  Number_of_groups : 提取的是第几组
+* 例：字符串 "AT+MIPOPEN=1,"TCP","122.114.122.174",41838,100,0,1,2,11002"
+*			参数Number_of_groups=2提取第二组，装载结果get_data: 122.114.122.174
+*/
+uint8_t AT_GET_Data(char * buff,uint8_t get_data[],char*sign,uint8_t Number_of_groups)
+{
+	uint16_t  i=0,count=0;
+	while(buff[i]!='\0')				/*获取分隔符整数*/
+	{
+	if(buff[i]==sign[0]) count++;
+	i++;
+	}
+	if(count%2==0&&count>=Number_of_groups*2)							/*偶数分隔符数才继续进行*/
+	{
+		char chBuffer[512] ;				/*按需调整*/
+		char *pchDilem =sign;				/*分隔符*/
+		char *pchStrTmpIn = NULL;		/*剩下的缓存*/
+		char *pchTmp = NULL;				/*提取出的字符*/
+		i=0;
+		strcpy(chBuffer,buff);
+		pchTmp = chBuffer;
+		while(NULL != ( pchTmp = strtok_r( pchTmp, pchDilem, &pchStrTmpIn) ))
+		{
+		//	uart1_printf("\n pchTmp[%s] \n",pchTmp);
+			i++;
+			if(i==Number_of_groups*2) strcpy((char*)get_data,pchTmp);
+			pchTmp = NULL;
+		}
+		return 1;
+	}
+	else return 0;							/*非偶数分隔符直接结束*/
+}
+
+/**@brief AT_GET_Data_2Param :提取被头尾字符串包裹的字串
+* @param  buff			 : 待提取的字符串，可以是数组或静态字符串
+* @param  get_data	 : 提取后装载的数组，必须是数组，不能是静态字符串因为需要写
+* @param  head       : 头字符串【任意长度符串】
+* @param  tail			 : 尾字符串【任意长度字符串】
+* 例：字符串 "+QGPSGNMEA: $GPRMC,021229.00,A,3041.560083,N,10405.832869,E,0.0,247.3,040920,1.9,W,A*28"
+*			参数head ",A",tail ",N",装载结果get_data: "3041.560083"
+*/
+uint8_t AT_GET_Data_2Param(char * buff,uint8_t get_data[],char*head,char*tail)
+{
+	if(strstr(buff,head)&&strstr(buff,tail))
+	{
+		uint16_t i;
+		uint16_t len1,len2;
+		char *t = NULL;
+		char *h=strstr(buff,head);
+		len1=strlen(h);				/*剩余长度*/	
+		len2=strlen(head);		/*头子串长度*/	
+		t=strstr(h+len2,tail);
+		if(len1>len2)
+		{
+					for(i=0;h+i+len2!=t;i++)
+					{
+						get_data[i]=h[i+len2];	
+					}
+					get_data[i]='\0';//加上结束符
+		}else 
+		{
+			debug_printf("\r\n字串长度错误\r\n");
+			return 0;
+		}
+	}else
+	{
+		if(!strstr(buff,head))debug_printf("\r\n未能检索到头字串\r\n");
+		if(!strstr(buff,tail))debug_printf("\r\n未能检索到尾字串\r\n");
+		
+		debug_printf("\r\n请检查你的数据原文:\r\n");
+		debug_printf("%s", buff);
+		return 0;
+	}
+	return 1;
+}
+/**@brief AT_Data_Replace :提取被头尾字符包裹的字串
+* @param  buff			 : 待提取的字符串，必须是实体数组，需要写入
+* @param  str1	 		 : 被替换的子串，可以是数组和静态字符串
+* @param  str2       : 替换成的子串，可以是数组和静态字符串
+* 例：字符串 AT+QMTCFG="aliauth",0,"a1XVq3z4DsR"
+*			参数str1 "aliauth",str2 "recv/mode",替换结果buff: AT+QMTCFG="recv/mode",0,"a1XVq3z4DsR"
+*/
+uint8_t AT_Data_Replace(char buff[],char *str1, char *str2) {
+    int i,flag = 0;
+    char *p,*q,*ts;
+    for(i = 0; buff[i]; ++i)
+		{
+						if(buff[i] == str1[0]) 
+						{
+								p = buff + i;
+								q = str1;
+								while(*q && (*p++ == *q++));
+								if(*q == '\0') 
+									{
+										ts = (char *)malloc(strlen(buff) + 1);
+										strcpy(ts,p);
+										buff[i] = '\0';
+										strcat(buff,str2);
+										strcat(buff,ts);
+										free(ts);
+										flag = 1;
+									}
+						}
+    }
+    return flag;
+}
+
+/**@brief AT_GET_Data_Param_number :指定的标志位开始，提取后面的数据，直到遇到\r,\n,
+* @param  buff			 : 待提取的字符串，可以是数组或静态字符串
+* @param  get_data	 : 提取后装载的数组，必须是数组，不能是静态字符串因为需要写
+* @param  head       : 头字符串【任意长度符串】
+* 例：字符串 "  +ESOERR=1,4   "
+*			参数head ",",装载结果get_data: "4"
+*/
+uint8_t AT_GET_Data_Param(char * buff,uint8_t get_data[],char*head)
+{
+	char *h=strstr(buff,head);
+	if(h!=NULL)
+	{
+		uint16_t i;
+		int len=strlen(head);
+		for(i=0;h[i+len]!='\r'&&h[i+len]!='\n'&&h[i+len]!=' ';i++)
+		{
+			get_data[i]=h[i+len];	
+		}
+		get_data[i]='\0';//加上结束符
+	}else
+	{
+		if(!strstr(buff,head))debug_printf("\r\n未能检索到标志位\r\n");	
+		debug_printf("\r\n请检查你的数据原文:\r\n");
+		debug_printf("%s", buff);
+		return 0;
+	}
+	return 1;
+}
+
+
+
+
+/**@brief AT_Extract_numbers :导入的数组进行提纯，去掉非数字的部分
+* @param  buff			 : 待提纯的字符串，必须是实体数组，需要写入
+*/
+uint8_t AT_Extract_numbers(char buff[]) {
+		
+	uint16_t i=0,n=0;
+	int len=strlen(buff);
+	char fifo[32];/*浪费空间，但是效率更高*/
+	memset(fifo,0, sizeof(fifo));
+	for(;buff[i]!='\0';)
+	{
+		if(buff[i]>='0'&&buff[i]<='9')
+		{			
+			fifo[n]=buff[i];
+			n++;
+			i++;
+		}
+		else
+		{
+			i++;
+		}
+	}
+	strcpy(buff,fifo);
+	return 1;
+}
+
+/**@brief AT_Extract_numbers :导入的数组进行提纯，去掉非数字和非字母的部分
+* @param  buff			 : 待提纯的字符串，必须是实体数组，需要写入
+*/
+uint8_t AT_Extract_numbers_letters(char buff[]) {
+		
+	uint16_t i=0,n=0;
+	int len=strlen(buff);
+	char fifo[256];/*浪费空间，但是效率更高*/
+	memset(fifo,0,len+1);
+	for(;buff[i]!='\0';)
+	{
+		if((buff[i]>='0'&&buff[i]<='9')||(buff[i]>='A'&&buff[i]<='Z')||(buff[i]>='a'&&buff[i]<='z'))
+		{			
+			fifo[n]=buff[i];
+			n++;
+			i++;
+		}
+		else
+		{
+			i++;
+		}
+	}
+	//debug_printf("\r\n");
+	//debug_printf(fifo);
+	strcpy(buff,fifo);
+	return 1;
+}
+
+/**@brief AT_Remove_spaces :去掉空字符,\r,\n,space
+* @param  buff			 : 待提纯的字符串，必须是实体数组，需要写入
+*/
+uint8_t AT_Remove_spaces(char buff[]) {
+		
+	uint16_t i=0,n=0;
+	int len=strlen(buff);
+	char fifo[256];/*浪费空间，但是效率更高*/
+	memset(fifo,0,len+1);
+	for(;buff[i]!='\0';)
+	{
+		if((buff[i]!='\r')&&(buff[i]!='\n')&&(buff[i]!=' '))
+		{			
+			fifo[n]=buff[i];
+			n++;
+			i++;
+		}
+		else
+		{
+			i++;
+		}
+	}
+	//debug_printf("\r\n");
+	//debug_printf(fifo);
+	strcpy(buff,fifo);
+	return 1;
+}
+

APP/network_mgr/at/at_module.h

@@ -0,0 +1,100 @@
+/** ******************************************************************************
+ * @file    AT_Module.h
+ * @author  度云未来 DOIOT
+ * @brief   针对公司模块AT指令的处理库
+ ******************************************************************************
+ * @attention
+ * <h2><center>&copy; Copyright (c) 2019 成都度云未来
+ * All rights reserved.</center></h2>
+ * 注意:本程序针对cubemx 生成的hal库程序快速开发
+ * 环境:keil5.0
+ * STM32Cube FW_F1 V1.8.0
+ ********************************************************************************/
+//#define Ask_arry_size     2
+#define Ask_arry_len      20
+//[Ask_arry_size][Ask_arry_len]
+typedef struct{
+	
+		/*发送的指令      */
+		char *SEND_CMD;  		 
+		/*应该响应的指令      */
+    char *ASK[Ask_arry_len];  
+		/*需要校验的指令数      */
+		uint32_t crc_size;	
+		/*指令等待超时时间*/
+	  uint32_t timeout; 		
+		/*重发次数*/
+		uint32_t REF_Count;		
+		/*失败时要跳转的指令位置*/
+		uint32_t jump;			
+		/*支持注册一个发送前奏回调函数*/
+		void (*BeforeCpltCallback)();
+		/*支持注册一个发送且校验完成完成回调函数,参数默认为rx_buff*/
+		void (*AfterCpltCallback)(char *rx_buff);
+		/*支持注册一个错误处理校验函数,参数默认为rx_buff*/
+		void (*ErrorCpltCallback)(char *rx_buff);
+		/*完成后延时*/
+		uint32_t delay_time;
+	
+}AT_CMD;  /*发送指令结构体*/
+
+/*开模组长度char数组的宏*/
+#if 0
+#define MODULE_RDA_MAXlen 128
+#define rxbuff(name)  				 			 char(name)[MODULE_RDA_MAXlen]={0}
+#define clear(name)								 memset(name,0,MODULE_RDA_MAXlen)
+#else
+#define MODULE_RDA_MAXlen 160
+#define rxbuff(name)  				 			 char(name)[MODULE_RDA_MAXlen]={0}
+#define clear(name)								 memset(name,0,MODULE_RDA_MAXlen)
+#endif
+
+/**@brief 开始启动AT任务*/
+uint8_t AT_TASK_START(AT_CMD task[],uint8_t Size);
+
+#define cmd_length			256				/*响应指令最大长度*/
+/**@brief 发送且阻塞读取校验*/
+uint8_t Module_SEND_CRC(char* send_cmd,char *ack_str,uint32_t overtime);
+/**@brief 发送且阻塞读取校验,支持多组参数*/
+uint8_t Module_SEND_A_CRC(char* send_cmd,char cmd_arry[][cmd_length],uint8_t arry_size,uint8_t crc_size);
+/**@brief 阻塞读取并校验*/
+uint8_t Module_Read_A_CRC(char cmd_arry[],uint32_t overtime);
+/**@brief 阻塞轮询,校验成功后返回*/
+uint8_t AT_CMD_Polling(char *send_cmd,char*ack,uint32_t Polling_delay,uint32_t overtime);
+
+/*-字符处理函数------【旧版】---------------------------------------------------------------------------------*/
+
+/**@brief 以字符包裹为标志提取子串*/
+uint8_t AT_GET_Data(char * buff,uint8_t * get_data,char*sign,uint8_t Number_of_groups);
+/**@brief 以子串包裹为标志提取子串*/
+uint8_t AT_GET_Data_2Param(char * buff,uint8_t get_data[],char*head,char*tail);
+/**@brief 把标志位的子串替换为要替换的子串*/
+uint8_t AT_Data_Replace(char buff[],char *str1, char *str2);
+/**@brief AT_GET_Data_Param_number :指定的标志位开始，提取后面的数据，直到遇到\r,\n,*/
+uint8_t AT_GET_Data_Param(char * buff,uint8_t get_data[],char*head);
+
+/**@brief AT_Extract_numbers:把导入的数组提纯为纯数字*/
+uint8_t AT_Extract_numbers(char buff[]);
+/**@brief AT_Extract_numbers :导入的数组提纯为纯字符和数字*/
+uint8_t AT_Extract_numbers_letters(char buff[]);
+/**@brief AT_Remove_spaces :去掉空字符,\r,\n,space */
+uint8_t AT_Remove_spaces(char buff[]);
+
+
+#define HAL_Delay(x)
+
+
+#define AT_INFO(fmt,arg...)           //trace_otp_trace1(uart_msg_send, 4, fmt, ##arg);
+//printf("<<-EEPROM-INFO->> "fmt"\n",##arg)
+#define AT_ERROR(fmt,arg...)          //printf("<<-EEPROM-ERROR->> "fmt"\n",##arg)
+#define AT_DEBUG(fmt,arg...)          /*do{\
+	                                          if(EEPROM_DEBUG_ON)\
+	                                          printf("<<-EEPROM-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
+                                          }while(0)*/
+
+/*调试打印  */
+#define debug_printf(fmt,arg...)		printf("<<-at_debug_printf->> "fmt"\r\n",##arg)
+/*往模组打印*/
+#define module_printf(fmt,arg...)		trace_otp_trace1(uart_msg_send, UART_ME3616, fmt, ##arg);
+
+int Module_Blocking_Read(char *buffer, u32 timeout);

APP/network_mgr/lora/Radio/inc/Sx1276-1278.h

@@ -0,0 +1,16 @@
+#ifndef __SX1276_1278_H
+#define __ SX1276_1278_H
+
+//#include  "common.h"
+//#include  "fifo.h"
+#include  "platform.h"
+#include  "radio.h"
+#include  "sx1276.h"
+#include  "sx1276-Fsk.h"
+#include  "sx1276-FskMisc.h"
+#include  "sx1276-Hal.h"
+#include  "sx1276-LoRa.h"
+#include  "sx1276-LoRaMisc.h"
+
+#endif
+

APP/network_mgr/lora/Radio/inc/crc.h

@@ -0,0 +1,24 @@
+#ifndef _CRC_H_
+#define _CRC_H_
+
+#include <stdint.h>
+
+// CRC types
+#define CRC_TYPE_CCITT 0
+#define CRC_TYPE_IBM 1
+// Polynomial = X^16 + X^12 + X^5 + 1
+#define POLYNOMIAL_CCITT 0x1021
+// Polynomial = X^16 + X^15 + X^2 + 1
+#define POLYNOMIAL_IBM 0x8005
+// Seeds
+#define CRC_IBM_SEED 0xFFFF
+#define CRC_CCITT_SEED 0x1D0F
+
+
+uint16_t RadioComputeCRC( uint8_t *buffer, uint8_t length, uint8_t crcType );
+uint16_t ComputeCrc( uint16_t crc, uint8_t dataByte, uint16_t polynomial );
+
+
+
+#endif
+

APP/network_mgr/lora/Radio/inc/fifo.h

@@ -0,0 +1,37 @@
+#ifndef __FIFO_H__
+#define __FIFO_H__
+
+#include <stdbool.h>
+
+#if defined( STM32F4XX ) || defined( STM32F429_439xx )
+    #include "stm32f4xx.h"
+#elif defined( STM32F2XX )
+    #include "stm32f2xx.h"
+#else
+    #include "stm32f10x.h"
+#endif
+
+/*!
+ * FIFO
+ */
+typedef struct sFifo
+{
+	uint16_t Begin;
+	uint16_t End;
+	uint16_t *Data;
+    uint16_t Size;
+}tFifo;
+
+void FifoInit( tFifo *fifo, uint16_t *buffer, uint16_t size );
+
+void FifoPush( tFifo *fifo, uint16_t data );
+
+uint16_t FifoPop( tFifo *fifo );
+
+void FifoFlush( tFifo *fifo );
+
+bool IsFifoEmpty( tFifo *fifo );
+
+bool IsFifoFull( tFifo *fifo );
+
+#endif // __FIFO_H__

APP/network_mgr/lora/Radio/inc/platform.h

@@ -0,0 +1,88 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       platform.h
+ * \brief        
+ *
+ * \version    1.0
+ * \date       Nov 21 2012
+ * \author     Miguel Luis
+ */
+#ifndef __PLATFORM_H__
+#define __PLATFORM_H__
+
+#ifndef __GNUC__
+#define inline
+#endif
+
+/*!
+ * Platform definition
+ */
+#define Bleeper                                     3
+#define SX1243ska                                   2
+#define SX12xxEiger                                 1
+#define SX12000DVK                                  0
+
+/*!
+ * Platform choice. Please uncoment the PLATFORM define and choose your platform
+ * or add/change the PLATFORM definition on the compiler Defines option
+ */
+
+#define PLATFORM                                    SX12xxEiger
+
+#if( PLATFORM == SX12xxEiger )
+/*!
+ * Radio choice. Please uncomment the wanted radio and comment the others
+ * or add/change wanted radio definition on the compiler Defines option
+ */
+//#define USE_SX1232_RADIO
+//#define USE_SX1272_RADIO
+#define USE_SX1276_RADIO
+//#define USE_SX1243_RADIO
+
+/*!
+ * Module choice. There are three existing module with the SX1276.
+ * Please set the connected module to the value 1 and set the others to 0
+ */
+#ifdef USE_SX1276_RADIO
+#define MODULE_SX1276RF1IAS                         0
+#define MODULE_SX1276RF1JAS                         0  //868
+#define MODULE_SX1276RF1KAS                         1  //434
+#endif
+
+    #include "sx12xxEiger.h"
+    #define USE_UART                                0
+
+#elif( PLATFORM == SX12000DVK )
+/*!
+ * Radio choice. Please uncomment the wanted radio and comment the others
+ * or add/change wanted radio definition on the compiler Defines option
+ */
+//#define USE_SX1232_RADIO
+#define USE_SX1272_RADIO
+//#define USE_SX1276_RADIO
+//#define USE_SX1243_RADIO
+
+    #include "sx1200dvk.h"
+
+#elif( PLATFORM == SX1243ska )
+
+#elif( PLATFORM == Bleeper )
+    #define USE_SX1272_RADIO
+    
+    #include "bleeper/bleeper.h"
+    #define USE_UART                                0
+
+#else
+    #error "Missing define: Platform (ie. SX12xxEiger)"
+#endif
+
+#endif // __PLATFORM_H__

APP/network_mgr/lora/Radio/inc/radio.h

@@ -0,0 +1,68 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       radio.h
+ * \brief      Generic radio driver ( radio abstraction )
+ *
+ * \version    2.0.B2 
+ * \date       Nov 21 2012
+ * \author     Miguel Luis
+ *
+ * Last modified by Gregory Cristian on Apr 25 2013
+ */
+#ifndef __RADIO_H__
+#define __RADIO_H__
+
+/*!
+ * SX1272 and SX1276 General parameters definition
+ */
+#define LORA                                        1       // [0: OFF, 1: ON]
+
+/*!
+ * RF process function return codes
+ */
+typedef enum
+{
+    RF_IDLE,
+    RF_BUSY,
+    RF_RX_DONE,
+    RF_RX_TIMEOUT,
+    RF_TX_DONE,
+    RF_TX_TIMEOUT,
+    RF_LEN_ERROR,
+    RF_CHANNEL_EMPTY,
+    RF_CHANNEL_ACTIVITY_DETECTED,
+}tRFProcessReturnCodes;
+
+/*!
+ * Radio driver structure defining the different function pointers
+ */
+typedef struct sRadioDriver
+{
+    void ( *Init )( void );
+    void ( *Reset )( void );
+    void ( *StartRx )( void );
+    void ( *StartTx )( void );
+    void ( *GetRxPacket )( void *buffer, uint16_t *size );
+    void ( *SetTxPacket )( const void *buffer, uint16_t size );
+    uint32_t ( *Process )( void );
+}tRadioDriver;
+
+extern tRadioDriver *Radio;
+/*!
+ * \brief Initializes the RadioDriver structure with specific radio
+ *        functions.
+ *
+ * \retval radioDriver Pointer to the radio driver variable
+ */
+tRadioDriver* RadioDriverInit( void );
+
+#endif // __RADIO_H__

APP/network_mgr/lora/Radio/inc/sx1276-Fsk.h

@@ -0,0 +1,1461 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276-Fsk.h
+ * \brief      SX1276 RF chip driver mode FSK
+ *
+ * \version    2.0.B2 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#ifndef __SX1276_FSK_H__
+#define __SX1276_FSK_H__
+
+/*!
+ * SX1276 FSK General parameters definition
+ */
+
+typedef struct sFskSettings
+{
+    uint32_t RFFrequency;
+    uint32_t Bitrate;
+    uint32_t Fdev;
+    int8_t Power;
+    uint32_t RxBw;
+    uint32_t RxBwAfc;
+    bool CrcOn;
+    bool AfcOn;
+    uint8_t PayloadLength;
+}tFskSettings;
+
+/*!
+ * RF packet definition
+ */
+#define RF_BUFFER_SIZE_MAX                          100
+#define RF_BUFFER_SIZE                              100
+
+/*!
+ * RF state machine
+ */
+// FSK
+typedef enum
+{
+    RF_STATE_IDLE,
+    RF_STATE_RX_INIT,
+    RF_STATE_RX_SYNC,
+    RF_STATE_RX_RUNNING,
+    RF_STATE_RX_DONE,
+    RF_STATE_RX_TIMEOUT,
+    RF_STATE_RX_LEN_ERROR,
+    RF_STATE_TX_INIT,
+    RF_STATE_TX_READY_WAIT,
+    RF_STATE_TX_RUNNING,
+    RF_STATE_TX_DONE,
+    RF_STATE_TX_TIMEOUT,
+}tRFStates;
+
+/*!
+ * SX1276 definitions
+ */
+#define XTAL_FREQ                                   32000000
+#define FREQ_STEP                                   61.03515625
+
+/*!
+ * SX1276 Internal registers Address
+ */
+#define REG_FIFO                                    0x00
+// Common settings
+#define REG_OPMODE                                  0x01
+#define REG_BITRATEMSB                              0x02
+#define REG_BITRATELSB                              0x03
+#define REG_FDEVMSB                                 0x04 
+#define REG_FDEVLSB                                 0x05
+#define REG_FRFMSB                                  0x06
+#define REG_FRFMID                                  0x07
+#define REG_FRFLSB                                  0x08
+// Tx settings
+#define REG_PACONFIG                                0x09
+#define REG_PARAMP                                  0x0A
+#define REG_OCP                                     0x0B 
+// Rx settings
+#define REG_LNA                                     0x0C
+#define REG_RXCONFIG                                0x0D
+#define REG_RSSICONFIG                              0x0E
+#define REG_RSSICOLLISION                           0x0F
+#define REG_RSSITHRESH                              0x10
+#define REG_RSSIVALUE                               0x11
+#define REG_RXBW                                    0x12 
+#define REG_AFCBW                                   0x13
+#define REG_OOKPEAK                                 0x14
+#define REG_OOKFIX                                  0x15
+#define REG_OOKAVG                                  0x16
+#define REG_RES17                                   0x17
+#define REG_RES18                                   0x18
+#define REG_RES19                                   0x19
+#define REG_AFCFEI                                  0x1A
+#define REG_AFCMSB                                  0x1B
+#define REG_AFCLSB                                  0x1C
+#define REG_FEIMSB                                  0x1D
+#define REG_FEILSB                                  0x1E
+#define REG_PREAMBLEDETECT                          0x1F
+#define REG_RXTIMEOUT1                              0x20
+#define REG_RXTIMEOUT2                              0x21
+#define REG_RXTIMEOUT3                              0x22
+#define REG_RXDELAY                                 0x23
+// Oscillator settings
+#define REG_OSC                                     0x24
+// Packet handler settings
+#define REG_PREAMBLEMSB                             0x25
+#define REG_PREAMBLELSB                             0x26
+#define REG_SYNCCONFIG                              0x27
+#define REG_SYNCVALUE1                              0x28
+#define REG_SYNCVALUE2                              0x29
+#define REG_SYNCVALUE3                              0x2A
+#define REG_SYNCVALUE4                              0x2B
+#define REG_SYNCVALUE5                              0x2C
+#define REG_SYNCVALUE6                              0x2D
+#define REG_SYNCVALUE7                              0x2E
+#define REG_SYNCVALUE8                              0x2F
+#define REG_PACKETCONFIG1                           0x30
+#define REG_PACKETCONFIG2                           0x31
+#define REG_PAYLOADLENGTH                           0x32
+#define REG_NODEADRS                                0x33
+#define REG_BROADCASTADRS                           0x34
+#define REG_FIFOTHRESH                              0x35
+// SM settings
+#define REG_SEQCONFIG1                              0x36
+#define REG_SEQCONFIG2                              0x37
+#define REG_TIMERRESOL                              0x38
+#define REG_TIMER1COEF                              0x39
+#define REG_TIMER2COEF                              0x3A
+// Service settings
+#define REG_IMAGECAL                                0x3B
+#define REG_TEMP                                    0x3C
+#define REG_LOWBAT                                  0x3D
+// Status
+#define REG_IRQFLAGS1                               0x3E
+#define REG_IRQFLAGS2                               0x3F
+// I/O settings
+#define REG_DIOMAPPING1                             0x40
+#define REG_DIOMAPPING2                             0x41
+// Version
+#define REG_VERSION                                 0x42
+// Additional settings
+#define REG_PLLHOP                                  0x44
+#define REG_TCXO                                    0x4B
+#define REG_PADAC                                   0x4D
+#define REG_FORMERTEMP                              0x5B
+#define REG_BITRATEFRAC                             0x5D
+#define REG_AGCREF                                  0x61
+#define REG_AGCTHRESH1                              0x62
+#define REG_AGCTHRESH2                              0x63
+#define REG_AGCTHRESH3                              0x64
+
+
+/*!
+ * SX1276 FSK bit control definition
+ */
+
+/*!
+ * RegFifo
+ */
+
+/*!
+ * RegOpMode
+ */
+#define RF_OPMODE_LONGRANGEMODE_MASK                0x7F
+#define RF_OPMODE_LONGRANGEMODE_OFF                 0x00  // Default
+#define RF_OPMODE_LONGRANGEMODE_ON                  0x80
+
+#define RF_OPMODE_MODULATIONTYPE_MASK               0x9F
+#define RF_OPMODE_MODULATIONTYPE_FSK                0x00  // Default
+#define RF_OPMODE_MODULATIONTYPE_OOK                0x20
+
+#define RF_OPMODE_FREQMODE_ACCESS_MASK              0xF7
+#define RF_OPMODE_FREQMODE_ACCESS_LF                0x08  // Default
+#define RF_OPMODE_FREQMODE_ACCESS_HF                0x00 
+
+#define RF_OPMODE_MASK                              0xF8
+#define RF_OPMODE_SLEEP                             0x00
+#define RF_OPMODE_STANDBY                           0x01  // Default
+#define RF_OPMODE_SYNTHESIZER_TX                    0x02
+#define RF_OPMODE_TRANSMITTER                       0x03
+#define RF_OPMODE_SYNTHESIZER_RX                    0x04
+#define RF_OPMODE_RECEIVER                          0x05
+
+/*!
+ * RegBitRate (bits/sec)
+ */
+#define RF_BITRATEMSB_1200_BPS                      0x68
+#define RF_BITRATELSB_1200_BPS                      0x2B
+#define RF_BITRATEMSB_2400_BPS                      0x34
+#define RF_BITRATELSB_2400_BPS                      0x15
+#define RF_BITRATEMSB_4800_BPS                      0x1A  // Default
+#define RF_BITRATELSB_4800_BPS                      0x0B  // Default
+#define RF_BITRATEMSB_9600_BPS                      0x0D
+#define RF_BITRATELSB_9600_BPS                      0x05
+#define RF_BITRATEMSB_15000_BPS                     0x08
+#define RF_BITRATELSB_15000_BPS                     0x55
+#define RF_BITRATEMSB_19200_BPS                     0x06
+#define RF_BITRATELSB_19200_BPS                     0x83
+#define RF_BITRATEMSB_38400_BPS                     0x03
+#define RF_BITRATELSB_38400_BPS                     0x41
+#define RF_BITRATEMSB_76800_BPS                     0x01
+#define RF_BITRATELSB_76800_BPS                     0xA1
+#define RF_BITRATEMSB_153600_BPS                    0x00
+#define RF_BITRATELSB_153600_BPS                    0xD0
+#define RF_BITRATEMSB_57600_BPS                     0x02
+#define RF_BITRATELSB_57600_BPS                     0x2C
+#define RF_BITRATEMSB_115200_BPS                    0x01
+#define RF_BITRATELSB_115200_BPS                    0x16
+#define RF_BITRATEMSB_12500_BPS                     0x0A
+#define RF_BITRATELSB_12500_BPS                     0x00
+#define RF_BITRATEMSB_25000_BPS                     0x05
+#define RF_BITRATELSB_25000_BPS                     0x00
+#define RF_BITRATEMSB_50000_BPS                     0x02
+#define RF_BITRATELSB_50000_BPS                     0x80
+#define RF_BITRATEMSB_100000_BPS                    0x01
+#define RF_BITRATELSB_100000_BPS                    0x40
+#define RF_BITRATEMSB_150000_BPS                    0x00
+#define RF_BITRATELSB_150000_BPS                    0xD5
+#define RF_BITRATEMSB_200000_BPS                    0x00
+#define RF_BITRATELSB_200000_BPS                    0xA0
+#define RF_BITRATEMSB_250000_BPS                    0x00
+#define RF_BITRATELSB_250000_BPS                    0x80
+#define RF_BITRATEMSB_32768_BPS                     0x03
+#define RF_BITRATELSB_32768_BPS                     0xD1
+
+/*!
+ * RegFdev (Hz)
+ */
+ 
+#define RF_FDEVMSB_BANDREG_MASK                     0x3F 
+#define RF_FDEVMSB_BANDREG_AUTO                     0x00 // Default
+#define RF_FDEVMSB_BANDREG_DIV_BY_1                 0x40
+#define RF_FDEVMSB_BANDREG_DIV_BY_2                 0x80
+#define RF_FDEVMSB_BANDREG_DIV_BY_6                 0xC0
+ 
+#define RF_FDEVMSB_FDEV_MASK                        0xC0
+
+#define RF_FDEVMSB_2000_HZ                          0x00
+#define RF_FDEVLSB_2000_HZ                          0x21
+#define RF_FDEVMSB_5000_HZ                          0x00  // Default
+#define RF_FDEVLSB_5000_HZ                          0x52  // Default
+#define RF_FDEVMSB_10000_HZ                         0x00
+#define RF_FDEVLSB_10000_HZ                         0xA4
+#define RF_FDEVMSB_15000_HZ                         0x00
+#define RF_FDEVLSB_15000_HZ                         0xF6
+#define RF_FDEVMSB_20000_HZ                         0x01
+#define RF_FDEVLSB_20000_HZ                         0x48
+#define RF_FDEVMSB_25000_HZ                         0x01
+#define RF_FDEVLSB_25000_HZ                         0x9A
+#define RF_FDEVMSB_30000_HZ                         0x01
+#define RF_FDEVLSB_30000_HZ                         0xEC
+#define RF_FDEVMSB_35000_HZ                         0x02
+#define RF_FDEVLSB_35000_HZ                         0x3D
+#define RF_FDEVMSB_40000_HZ                         0x02
+#define RF_FDEVLSB_40000_HZ                         0x8F
+#define RF_FDEVMSB_45000_HZ                         0x02
+#define RF_FDEVLSB_45000_HZ                         0xE1
+#define RF_FDEVMSB_50000_HZ                         0x03
+#define RF_FDEVLSB_50000_HZ                         0x33
+#define RF_FDEVMSB_55000_HZ                         0x03
+#define RF_FDEVLSB_55000_HZ                         0x85
+#define RF_FDEVMSB_60000_HZ                         0x03
+#define RF_FDEVLSB_60000_HZ                         0xD7
+#define RF_FDEVMSB_65000_HZ                         0x04
+#define RF_FDEVLSB_65000_HZ                         0x29
+#define RF_FDEVMSB_70000_HZ                         0x04
+#define RF_FDEVLSB_70000_HZ                         0x7B
+#define RF_FDEVMSB_75000_HZ                         0x04
+#define RF_FDEVLSB_75000_HZ                         0xCD
+#define RF_FDEVMSB_80000_HZ                         0x05
+#define RF_FDEVLSB_80000_HZ                         0x1F
+#define RF_FDEVMSB_85000_HZ                         0x05
+#define RF_FDEVLSB_85000_HZ                         0x71
+#define RF_FDEVMSB_90000_HZ                         0x05
+#define RF_FDEVLSB_90000_HZ                         0xC3
+#define RF_FDEVMSB_95000_HZ                         0x06
+#define RF_FDEVLSB_95000_HZ                         0x14
+#define RF_FDEVMSB_100000_HZ                        0x06
+#define RF_FDEVLSB_100000_HZ                        0x66
+#define RF_FDEVMSB_110000_HZ                        0x07
+#define RF_FDEVLSB_110000_HZ                        0x0A
+#define RF_FDEVMSB_120000_HZ                        0x07
+#define RF_FDEVLSB_120000_HZ                        0xAE
+#define RF_FDEVMSB_130000_HZ                        0x08
+#define RF_FDEVLSB_130000_HZ                        0x52
+#define RF_FDEVMSB_140000_HZ                        0x08
+#define RF_FDEVLSB_140000_HZ                        0xF6
+#define RF_FDEVMSB_150000_HZ                        0x09
+#define RF_FDEVLSB_150000_HZ                        0x9A
+#define RF_FDEVMSB_160000_HZ                        0x0A
+#define RF_FDEVLSB_160000_HZ                        0x3D
+#define RF_FDEVMSB_170000_HZ                        0x0A
+#define RF_FDEVLSB_170000_HZ                        0xE1
+#define RF_FDEVMSB_180000_HZ                        0x0B
+#define RF_FDEVLSB_180000_HZ                        0x85
+#define RF_FDEVMSB_190000_HZ                        0x0C
+#define RF_FDEVLSB_190000_HZ                        0x29
+#define RF_FDEVMSB_200000_HZ                        0x0C
+#define RF_FDEVLSB_200000_HZ                        0xCD
+
+/*!
+ * RegFrf (MHz)
+ */
+#define RF_FRFMSB_863_MHZ                           0xD7
+#define RF_FRFMID_863_MHZ                           0xC0
+#define RF_FRFLSB_863_MHZ                           0x00
+#define RF_FRFMSB_864_MHZ                           0xD8
+#define RF_FRFMID_864_MHZ                           0x00
+#define RF_FRFLSB_864_MHZ                           0x00
+#define RF_FRFMSB_865_MHZ                           0xD8
+#define RF_FRFMID_865_MHZ                           0x40
+#define RF_FRFLSB_865_MHZ                           0x00
+#define RF_FRFMSB_866_MHZ                           0xD8
+#define RF_FRFMID_866_MHZ                           0x80
+#define RF_FRFLSB_866_MHZ                           0x00
+#define RF_FRFMSB_867_MHZ                           0xD8
+#define RF_FRFMID_867_MHZ                           0xC0
+#define RF_FRFLSB_867_MHZ                           0x00
+#define RF_FRFMSB_868_MHZ                           0xD9
+#define RF_FRFMID_868_MHZ                           0x00
+#define RF_FRFLSB_868_MHZ                           0x00
+#define RF_FRFMSB_869_MHZ                           0xD9
+#define RF_FRFMID_869_MHZ                           0x40
+#define RF_FRFLSB_869_MHZ                           0x00
+#define RF_FRFMSB_870_MHZ                           0xD9
+#define RF_FRFMID_870_MHZ                           0x80
+#define RF_FRFLSB_870_MHZ                           0x00
+
+#define RF_FRFMSB_902_MHZ                           0xE1
+#define RF_FRFMID_902_MHZ                           0x80
+#define RF_FRFLSB_902_MHZ                           0x00
+#define RF_FRFMSB_903_MHZ                           0xE1
+#define RF_FRFMID_903_MHZ                           0xC0
+#define RF_FRFLSB_903_MHZ                           0x00
+#define RF_FRFMSB_904_MHZ                           0xE2
+#define RF_FRFMID_904_MHZ                           0x00
+#define RF_FRFLSB_904_MHZ                           0x00
+#define RF_FRFMSB_905_MHZ                           0xE2
+#define RF_FRFMID_905_MHZ                           0x40
+#define RF_FRFLSB_905_MHZ                           0x00
+#define RF_FRFMSB_906_MHZ                           0xE2
+#define RF_FRFMID_906_MHZ                           0x80
+#define RF_FRFLSB_906_MHZ                           0x00
+#define RF_FRFMSB_907_MHZ                           0xE2
+#define RF_FRFMID_907_MHZ                           0xC0
+#define RF_FRFLSB_907_MHZ                           0x00
+#define RF_FRFMSB_908_MHZ                           0xE3
+#define RF_FRFMID_908_MHZ                           0x00
+#define RF_FRFLSB_908_MHZ                           0x00
+#define RF_FRFMSB_909_MHZ                           0xE3
+#define RF_FRFMID_909_MHZ                           0x40
+#define RF_FRFLSB_909_MHZ                           0x00
+#define RF_FRFMSB_910_MHZ                           0xE3
+#define RF_FRFMID_910_MHZ                           0x80
+#define RF_FRFLSB_910_MHZ                           0x00
+#define RF_FRFMSB_911_MHZ                           0xE3
+#define RF_FRFMID_911_MHZ                           0xC0
+#define RF_FRFLSB_911_MHZ                           0x00
+#define RF_FRFMSB_912_MHZ                           0xE4
+#define RF_FRFMID_912_MHZ                           0x00
+#define RF_FRFLSB_912_MHZ                           0x00
+#define RF_FRFMSB_913_MHZ                           0xE4
+#define RF_FRFMID_913_MHZ                           0x40
+#define RF_FRFLSB_913_MHZ                           0x00
+#define RF_FRFMSB_914_MHZ                           0xE4
+#define RF_FRFMID_914_MHZ                           0x80
+#define RF_FRFLSB_914_MHZ                           0x00
+#define RF_FRFMSB_915_MHZ                           0xE4  // Default
+#define RF_FRFMID_915_MHZ                           0xC0  // Default
+#define RF_FRFLSB_915_MHZ                           0x00  // Default
+#define RF_FRFMSB_916_MHZ                           0xE5
+#define RF_FRFMID_916_MHZ                           0x00
+#define RF_FRFLSB_916_MHZ                           0x00
+#define RF_FRFMSB_917_MHZ                           0xE5
+#define RF_FRFMID_917_MHZ                           0x40
+#define RF_FRFLSB_917_MHZ                           0x00
+#define RF_FRFMSB_918_MHZ                           0xE5
+#define RF_FRFMID_918_MHZ                           0x80
+#define RF_FRFLSB_918_MHZ                           0x00
+#define RF_FRFMSB_919_MHZ                           0xE5
+#define RF_FRFMID_919_MHZ                           0xC0
+#define RF_FRFLSB_919_MHZ                           0x00
+#define RF_FRFMSB_920_MHZ                           0xE6
+#define RF_FRFMID_920_MHZ                           0x00
+#define RF_FRFLSB_920_MHZ                           0x00
+#define RF_FRFMSB_921_MHZ                           0xE6
+#define RF_FRFMID_921_MHZ                           0x40
+#define RF_FRFLSB_921_MHZ                           0x00
+#define RF_FRFMSB_922_MHZ                           0xE6
+#define RF_FRFMID_922_MHZ                           0x80
+#define RF_FRFLSB_922_MHZ                           0x00
+#define RF_FRFMSB_923_MHZ                           0xE6
+#define RF_FRFMID_923_MHZ                           0xC0
+#define RF_FRFLSB_923_MHZ                           0x00
+#define RF_FRFMSB_924_MHZ                           0xE7
+#define RF_FRFMID_924_MHZ                           0x00
+#define RF_FRFLSB_924_MHZ                           0x00
+#define RF_FRFMSB_925_MHZ                           0xE7
+#define RF_FRFMID_925_MHZ                           0x40
+#define RF_FRFLSB_925_MHZ                           0x00
+#define RF_FRFMSB_926_MHZ                           0xE7
+#define RF_FRFMID_926_MHZ                           0x80
+#define RF_FRFLSB_926_MHZ                           0x00
+#define RF_FRFMSB_927_MHZ                           0xE7
+#define RF_FRFMID_927_MHZ                           0xC0
+#define RF_FRFLSB_927_MHZ                           0x00
+#define RF_FRFMSB_928_MHZ                           0xE8
+#define RF_FRFMID_928_MHZ                           0x00
+#define RF_FRFLSB_928_MHZ                           0x00
+
+/*!
+ * RegPaConfig
+ */
+#define RF_PACONFIG_PASELECT_MASK                   0x7F
+#define RF_PACONFIG_PASELECT_PABOOST                0x80
+#define RF_PACONFIG_PASELECT_RFO                    0x00 // Default
+
+#define RF_PACONFIG_MAX_POWER_MASK                  0x8F
+
+#define RF_PACONFIG_OUTPUTPOWER_MASK                0xF0
+ 
+/*!
+ * RegPaRamp
+ */
+#define RF_PARAMP_MODULATIONSHAPING_MASK            0x9F
+#define RF_PARAMP_MODULATIONSHAPING_00              0x00 // Default
+#define RF_PARAMP_MODULATIONSHAPING_01              0x20
+#define RF_PARAMP_MODULATIONSHAPING_10              0x40
+#define RF_PARAMP_MODULATIONSHAPING_11              0x60
+ 
+#define RF_PARAMP_TXBANDFORCE_MASK                  0xEF 
+#define RF_PARAMP_TXBANDFORCE_BAND_SEL              0x10 
+#define RF_PARAMP_TXBANDFORCE_AUTO                  0x00 // Default
+
+#define RF_PARAMP_MASK                              0xF0
+#define RF_PARAMP_3400_US                           0x00
+#define RF_PARAMP_2000_US                           0x01
+#define RF_PARAMP_1000_US                           0x02
+#define RF_PARAMP_0500_US                           0x03
+#define RF_PARAMP_0250_US                           0x04
+#define RF_PARAMP_0125_US                           0x05
+#define RF_PARAMP_0100_US                           0x06
+#define RF_PARAMP_0062_US                           0x07
+#define RF_PARAMP_0050_US                           0x08
+#define RF_PARAMP_0040_US                           0x09  // Default
+#define RF_PARAMP_0031_US                           0x0A
+#define RF_PARAMP_0025_US                           0x0B
+#define RF_PARAMP_0020_US                           0x0C
+#define RF_PARAMP_0015_US                           0x0D
+#define RF_PARAMP_0012_US                           0x0E
+#define RF_PARAMP_0010_US                           0x0F
+
+/*!
+ * RegOcp
+ */
+#define RF_OCP_MASK                                 0xDF
+#define RF_OCP_ON                                   0x20  // Default
+#define RF_OCP_OFF                                  0x00  
+
+#define RF_OCP_TRIM_MASK                            0xE0
+#define RF_OCP_TRIM_045_MA                          0x00
+#define RF_OCP_TRIM_050_MA                          0x01   
+#define RF_OCP_TRIM_055_MA                          0x02 
+#define RF_OCP_TRIM_060_MA                          0x03 
+#define RF_OCP_TRIM_065_MA                          0x04 
+#define RF_OCP_TRIM_070_MA                          0x05 
+#define RF_OCP_TRIM_075_MA                          0x06 
+#define RF_OCP_TRIM_080_MA                          0x07  
+#define RF_OCP_TRIM_085_MA                          0x08
+#define RF_OCP_TRIM_090_MA                          0x09 
+#define RF_OCP_TRIM_095_MA                          0x0A 
+#define RF_OCP_TRIM_100_MA                          0x0B  // Default
+#define RF_OCP_TRIM_105_MA                          0x0C 
+#define RF_OCP_TRIM_110_MA                          0x0D 
+#define RF_OCP_TRIM_115_MA                          0x0E 
+#define RF_OCP_TRIM_120_MA                          0x0F 
+#define RF_OCP_TRIM_130_MA                          0x10
+#define RF_OCP_TRIM_140_MA                          0x11   
+#define RF_OCP_TRIM_150_MA                          0x12 
+#define RF_OCP_TRIM_160_MA                          0x13 
+#define RF_OCP_TRIM_170_MA                          0x14 
+#define RF_OCP_TRIM_180_MA                          0x15 
+#define RF_OCP_TRIM_190_MA                          0x16 
+#define RF_OCP_TRIM_200_MA                          0x17  
+#define RF_OCP_TRIM_210_MA                          0x18
+#define RF_OCP_TRIM_220_MA                          0x19 
+#define RF_OCP_TRIM_230_MA                          0x1A 
+#define RF_OCP_TRIM_240_MA                          0x1B
+
+/*!
+ * RegLna
+ */
+#define RF_LNA_GAIN_MASK                            0x1F
+#define RF_LNA_GAIN_G1                              0x20  // Default
+#define RF_LNA_GAIN_G2                              0x40
+#define RF_LNA_GAIN_G3                              0x60
+#define RF_LNA_GAIN_G4                              0x80
+#define RF_LNA_GAIN_G5                              0xA0
+#define RF_LNA_GAIN_G6                              0xC0
+
+#define RF_LNA_BOOST_LF_MASK                        0xE7 
+#define RF_LNA_BOOST_LF_DEFAULT                     0x00 // Default
+#define RF_LNA_BOOST_LF_GAIN                        0x08 
+#define RF_LNA_BOOST_LF_IP3                         0x10 
+#define RF_LNA_BOOST_LF_BOOST                       0x18 
+
+#define RF_LNA_RXBANDFORCE_MASK                     0xFB 
+#define RF_LNA_RXBANDFORCE_BAND_SEL                 0x04
+#define RF_LNA_RXBANDFORCE_AUTO                     0x00 // Default
+
+#define RF_LNA_BOOST_HF_MASK                        0xFC 
+#define RF_LNA_BOOST_HF_OFF                         0x00 // Default
+#define RF_LNA_BOOST_HF_ON                          0x03 
+
+/*!
+ * RegRxConfig
+ */
+#define RF_RXCONFIG_RESTARTRXONCOLLISION_MASK       0x7F
+#define RF_RXCONFIG_RESTARTRXONCOLLISION_ON         0x80
+#define RF_RXCONFIG_RESTARTRXONCOLLISION_OFF        0x00 // Default
+
+#define RF_RXCONFIG_RESTARTRXWITHOUTPLLLOCK         0x40 // Write only
+
+#define RF_RXCONFIG_RESTARTRXWITHPLLLOCK            0x20 // Write only
+
+#define RF_RXCONFIG_AFCAUTO_MASK                    0xEF
+#define RF_RXCONFIG_AFCAUTO_ON                      0x10
+#define RF_RXCONFIG_AFCAUTO_OFF                     0x00 // Default 
+
+#define RF_RXCONFIG_AGCAUTO_MASK                    0xF7
+#define RF_RXCONFIG_AGCAUTO_ON                      0x08 // Default
+#define RF_RXCONFIG_AGCAUTO_OFF                     0x00
+
+#define RF_RXCONFIG_RXTRIGER_MASK                   0xF8
+#define RF_RXCONFIG_RXTRIGER_OFF                    0x00
+#define RF_RXCONFIG_RXTRIGER_RSSI                   0x01
+#define RF_RXCONFIG_RXTRIGER_PREAMBLEDETECT         0x06 // Default
+#define RF_RXCONFIG_RXTRIGER_RSSI_PREAMBLEDETECT    0x07
+
+/*!
+ * RegRssiConfig
+ */
+#define RF_RSSICONFIG_OFFSET_MASK                   0x07
+#define RF_RSSICONFIG_OFFSET_P_00_DB                0x00  // Default
+#define RF_RSSICONFIG_OFFSET_P_01_DB                0x08
+#define RF_RSSICONFIG_OFFSET_P_02_DB                0x10
+#define RF_RSSICONFIG_OFFSET_P_03_DB                0x18
+#define RF_RSSICONFIG_OFFSET_P_04_DB                0x20
+#define RF_RSSICONFIG_OFFSET_P_05_DB                0x28
+#define RF_RSSICONFIG_OFFSET_P_06_DB                0x30
+#define RF_RSSICONFIG_OFFSET_P_07_DB                0x38
+#define RF_RSSICONFIG_OFFSET_P_08_DB                0x40
+#define RF_RSSICONFIG_OFFSET_P_09_DB                0x48
+#define RF_RSSICONFIG_OFFSET_P_10_DB                0x50
+#define RF_RSSICONFIG_OFFSET_P_11_DB                0x58
+#define RF_RSSICONFIG_OFFSET_P_12_DB                0x60
+#define RF_RSSICONFIG_OFFSET_P_13_DB                0x68
+#define RF_RSSICONFIG_OFFSET_P_14_DB                0x70
+#define RF_RSSICONFIG_OFFSET_P_15_DB                0x78
+#define RF_RSSICONFIG_OFFSET_M_16_DB                0x80
+#define RF_RSSICONFIG_OFFSET_M_15_DB                0x88
+#define RF_RSSICONFIG_OFFSET_M_14_DB                0x90
+#define RF_RSSICONFIG_OFFSET_M_13_DB                0x98
+#define RF_RSSICONFIG_OFFSET_M_12_DB                0xA0
+#define RF_RSSICONFIG_OFFSET_M_11_DB                0xA8
+#define RF_RSSICONFIG_OFFSET_M_10_DB                0xB0
+#define RF_RSSICONFIG_OFFSET_M_09_DB                0xB8
+#define RF_RSSICONFIG_OFFSET_M_08_DB                0xC0
+#define RF_RSSICONFIG_OFFSET_M_07_DB                0xC8
+#define RF_RSSICONFIG_OFFSET_M_06_DB                0xD0
+#define RF_RSSICONFIG_OFFSET_M_05_DB                0xD8
+#define RF_RSSICONFIG_OFFSET_M_04_DB                0xE0
+#define RF_RSSICONFIG_OFFSET_M_03_DB                0xE8
+#define RF_RSSICONFIG_OFFSET_M_02_DB                0xF0
+#define RF_RSSICONFIG_OFFSET_M_01_DB                0xF8
+
+#define RF_RSSICONFIG_SMOOTHING_MASK                0xF8
+#define RF_RSSICONFIG_SMOOTHING_2                   0x00
+#define RF_RSSICONFIG_SMOOTHING_4                   0x01
+#define RF_RSSICONFIG_SMOOTHING_8                   0x02  // Default
+#define RF_RSSICONFIG_SMOOTHING_16                  0x03
+#define RF_RSSICONFIG_SMOOTHING_32                  0x04
+#define RF_RSSICONFIG_SMOOTHING_64                  0x05
+#define RF_RSSICONFIG_SMOOTHING_128                 0x06
+#define RF_RSSICONFIG_SMOOTHING_256                 0x07
+
+/*!
+ * RegRssiCollision
+ */
+#define RF_RSSICOLISION_THRESHOLD                   0x0A  // Default
+
+/*!
+ * RegRssiThresh
+ */
+#define RF_RSSITHRESH_THRESHOLD                     0xFF  // Default
+
+/*!
+ * RegRssiValue (Read Only)
+ */
+
+/*!
+ * RegRxBw
+ */
+#define RF_RXBW_MANT_MASK                           0xE7
+#define RF_RXBW_MANT_16                             0x00  
+#define RF_RXBW_MANT_20                             0x08  
+#define RF_RXBW_MANT_24                             0x10  // Default 
+
+#define RF_RXBW_EXP_MASK                            0xF8 
+#define RF_RXBW_EXP_0                               0x00 
+#define RF_RXBW_EXP_1                               0x01 
+#define RF_RXBW_EXP_2                               0x02 
+#define RF_RXBW_EXP_3                               0x03 
+#define RF_RXBW_EXP_4                               0x04 
+#define RF_RXBW_EXP_5                               0x05  // Default
+#define RF_RXBW_EXP_6                               0x06  
+#define RF_RXBW_EXP_7                               0x07 
+
+/*!
+ * RegAfcBw
+ */
+#define RF_AFCBW_MANTAFC_MASK                       0xE7
+#define RF_AFCBW_MANTAFC_16                         0x00
+#define RF_AFCBW_MANTAFC_20                         0x08  // Default
+#define RF_AFCBW_MANTAFC_24                         0x10  
+
+#define RF_AFCBW_EXPAFC_MASK                        0xF8
+#define RF_AFCBW_EXPAFC_0                           0x00 
+#define RF_AFCBW_EXPAFC_1                           0x01 
+#define RF_AFCBW_EXPAFC_2                           0x02  
+#define RF_AFCBW_EXPAFC_3                           0x03  // Default
+#define RF_AFCBW_EXPAFC_4                           0x04 
+#define RF_AFCBW_EXPAFC_5                           0x05 
+#define RF_AFCBW_EXPAFC_6                           0x06  
+#define RF_AFCBW_EXPAFC_7                           0x07 
+
+/*!
+ * RegOokPeak
+ */
+#define RF_OOKPEAK_BITSYNC_MASK                     0xDF  // Default
+#define RF_OOKPEAK_BITSYNC_ON                       0x20  // Default
+#define RF_OOKPEAK_BITSYNC_OFF                      0x00
+
+#define RF_OOKPEAK_OOKTHRESHTYPE_MASK               0xE7
+#define RF_OOKPEAK_OOKTHRESHTYPE_FIXED              0x00
+#define RF_OOKPEAK_OOKTHRESHTYPE_PEAK               0x08  // Default
+#define RF_OOKPEAK_OOKTHRESHTYPE_AVERAGE            0x10
+
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_MASK           0xF8
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_0_5_DB         0x00  // Default
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_1_0_DB         0x01
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_1_5_DB         0x02
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_2_0_DB         0x03
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_3_0_DB         0x04
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_4_0_DB         0x05
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_5_0_DB         0x06
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_6_0_DB         0x07
+
+/*!
+ * RegOokFix
+ */
+#define RF_OOKFIX_OOKFIXEDTHRESHOLD                 0x0C  // Default
+
+/*!
+ * RegOokAvg
+ */
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_MASK             0x1F
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_000              0x00  // Default
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_001              0x20
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_010              0x40
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_011              0x60
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_100              0x80
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_101              0xA0
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_110              0xC0
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_111              0xE0
+
+#define RF_OOKAVG_AVERAGEOFFSET_MASK                0xF3
+#define RF_OOKAVG_AVERAGEOFFSET_0_DB                0x00  // Default
+#define RF_OOKAVG_AVERAGEOFFSET_2_DB                0x04
+#define RF_OOKAVG_AVERAGEOFFSET_4_DB                0x08
+#define RF_OOKAVG_AVERAGEOFFSET_6_DB                0x0C
+
+#define RF_OOKAVG_OOKAVERAGETHRESHFILT_MASK         0xFC
+#define RF_OOKAVG_OOKAVERAGETHRESHFILT_00           0x00
+#define RF_OOKAVG_OOKAVERAGETHRESHFILT_01           0x01
+#define RF_OOKAVG_OOKAVERAGETHRESHFILT_10           0x02  // Default
+#define RF_OOKAVG_OOKAVERAGETHRESHFILT_11           0x03
+
+/*!
+ * RegAfcFei
+ */
+#define RF_AFCFEI_AGCSTART                          0x10
+
+#define RF_AFCFEI_AFCCLEAR                          0x02
+
+#define RF_AFCFEI_AFCAUTOCLEAR_MASK                 0xFE
+#define RF_AFCFEI_AFCAUTOCLEAR_ON                   0x01
+#define RF_AFCFEI_AFCAUTOCLEAR_OFF                  0x00  // Default
+
+/*!
+ * RegAfcMsb (Read Only)
+ */
+ 
+/*!
+ * RegAfcLsb (Read Only)
+ */
+
+/*!
+ * RegFeiMsb (Read Only)
+ */
+
+/*!
+ * RegFeiLsb (Read Only)
+ */
+
+/*!
+ * RegPreambleDetect
+ */
+#define RF_PREAMBLEDETECT_DETECTOR_MASK             0x7F
+#define RF_PREAMBLEDETECT_DETECTOR_ON               0x80  // Default
+#define RF_PREAMBLEDETECT_DETECTOR_OFF              0x00
+
+#define RF_PREAMBLEDETECT_DETECTORSIZE_MASK         0x9F
+#define RF_PREAMBLEDETECT_DETECTORSIZE_1            0x00
+#define RF_PREAMBLEDETECT_DETECTORSIZE_2            0x20  // Default
+#define RF_PREAMBLEDETECT_DETECTORSIZE_3            0x40
+#define RF_PREAMBLEDETECT_DETECTORSIZE_4            0x60
+
+#define RF_PREAMBLEDETECT_DETECTORTOL_MASK          0xE0
+#define RF_PREAMBLEDETECT_DETECTORTOL_0             0x00
+#define RF_PREAMBLEDETECT_DETECTORTOL_1             0x01
+#define RF_PREAMBLEDETECT_DETECTORTOL_2             0x02
+#define RF_PREAMBLEDETECT_DETECTORTOL_3             0x03
+#define RF_PREAMBLEDETECT_DETECTORTOL_4             0x04
+#define RF_PREAMBLEDETECT_DETECTORTOL_5             0x05
+#define RF_PREAMBLEDETECT_DETECTORTOL_6             0x06
+#define RF_PREAMBLEDETECT_DETECTORTOL_7             0x07
+#define RF_PREAMBLEDETECT_DETECTORTOL_8             0x08
+#define RF_PREAMBLEDETECT_DETECTORTOL_9             0x09
+#define RF_PREAMBLEDETECT_DETECTORTOL_10            0x0A  // Default
+#define RF_PREAMBLEDETECT_DETECTORTOL_11            0x0B
+#define RF_PREAMBLEDETECT_DETECTORTOL_12            0x0C
+#define RF_PREAMBLEDETECT_DETECTORTOL_13            0x0D
+#define RF_PREAMBLEDETECT_DETECTORTOL_14            0x0E
+#define RF_PREAMBLEDETECT_DETECTORTOL_15            0x0F
+#define RF_PREAMBLEDETECT_DETECTORTOL_16            0x10
+#define RF_PREAMBLEDETECT_DETECTORTOL_17            0x11
+#define RF_PREAMBLEDETECT_DETECTORTOL_18            0x12
+#define RF_PREAMBLEDETECT_DETECTORTOL_19            0x13
+#define RF_PREAMBLEDETECT_DETECTORTOL_20            0x14
+#define RF_PREAMBLEDETECT_DETECTORTOL_21            0x15
+#define RF_PREAMBLEDETECT_DETECTORTOL_22            0x16
+#define RF_PREAMBLEDETECT_DETECTORTOL_23            0x17
+#define RF_PREAMBLEDETECT_DETECTORTOL_24            0x18
+#define RF_PREAMBLEDETECT_DETECTORTOL_25            0x19
+#define RF_PREAMBLEDETECT_DETECTORTOL_26            0x1A
+#define RF_PREAMBLEDETECT_DETECTORTOL_27            0x1B
+#define RF_PREAMBLEDETECT_DETECTORTOL_28            0x1C
+#define RF_PREAMBLEDETECT_DETECTORTOL_29            0x1D
+#define RF_PREAMBLEDETECT_DETECTORTOL_30            0x1E
+#define RF_PREAMBLEDETECT_DETECTORTOL_31            0x1F
+
+/*!
+ * RegRxTimeout1
+ */
+#define RF_RXTIMEOUT1_TIMEOUTRXRSSI                 0x00  // Default
+
+/*!
+ * RegRxTimeout2
+ */
+#define RF_RXTIMEOUT2_TIMEOUTRXPREAMBLE             0x00  // Default
+
+/*!
+ * RegRxTimeout3
+ */
+#define RF_RXTIMEOUT3_TIMEOUTSIGNALSYNC             0x00  // Default
+
+/*!
+ * RegRxDelay
+ */
+#define RF_RXDELAY_INTERPACKETRXDELAY               0x00  // Default
+
+/*!
+ * RegOsc
+ */
+#define RF_OSC_RCCALSTART                           0x08
+
+#define RF_OSC_CLKOUT_MASK                          0xF8
+#define RF_OSC_CLKOUT_32_MHZ                        0x00
+#define RF_OSC_CLKOUT_16_MHZ                        0x01
+#define RF_OSC_CLKOUT_8_MHZ                         0x02
+#define RF_OSC_CLKOUT_4_MHZ                         0x03
+#define RF_OSC_CLKOUT_2_MHZ                         0x04
+#define RF_OSC_CLKOUT_1_MHZ                         0x05  // Default
+#define RF_OSC_CLKOUT_RC                            0x06
+#define RF_OSC_CLKOUT_OFF                           0x07  
+
+/*!
+ * RegPreambleMsb/RegPreambleLsb
+ */
+#define RF_PREAMBLEMSB_SIZE                         0x00  // Default
+#define RF_PREAMBLELSB_SIZE                         0x03  // Default
+
+/*!
+ * RegSyncConfig
+ */
+#define RF_SYNCCONFIG_AUTORESTARTRXMODE_MASK        0x3F
+#define RF_SYNCCONFIG_AUTORESTARTRXMODE_WAITPLL_ON  0x80  // Default
+#define RF_SYNCCONFIG_AUTORESTARTRXMODE_WAITPLL_OFF 0x40
+#define RF_SYNCCONFIG_AUTORESTARTRXMODE_OFF         0x00
+
+
+#define RF_SYNCCONFIG_PREAMBLEPOLARITY_MASK         0xDF
+#define RF_SYNCCONFIG_PREAMBLEPOLARITY_55           0x20
+#define RF_SYNCCONFIG_PREAMBLEPOLARITY_AA           0x00  // Default
+
+#define RF_SYNCCONFIG_SYNC_MASK                     0xEF
+#define RF_SYNCCONFIG_SYNC_ON                       0x10  // Default
+#define RF_SYNCCONFIG_SYNC_OFF                      0x00
+
+
+#define RF_SYNCCONFIG_SYNCSIZE_MASK                 0xF8
+#define RF_SYNCCONFIG_SYNCSIZE_1                    0x00
+#define RF_SYNCCONFIG_SYNCSIZE_2                    0x01
+#define RF_SYNCCONFIG_SYNCSIZE_3                    0x02  
+#define RF_SYNCCONFIG_SYNCSIZE_4                    0x03  // Default
+#define RF_SYNCCONFIG_SYNCSIZE_5                    0x04
+#define RF_SYNCCONFIG_SYNCSIZE_6                    0x05
+#define RF_SYNCCONFIG_SYNCSIZE_7                    0x06
+#define RF_SYNCCONFIG_SYNCSIZE_8                    0x07
+
+/*!
+ * RegSyncValue1-8
+ */
+#define RF_SYNCVALUE1_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE2_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE3_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE4_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE5_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE6_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE7_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE8_SYNCVALUE                     0x01  // Default
+
+/*!
+ * RegPacketConfig1
+ */
+#define RF_PACKETCONFIG1_PACKETFORMAT_MASK          0x7F
+#define RF_PACKETCONFIG1_PACKETFORMAT_FIXED         0x00
+#define RF_PACKETCONFIG1_PACKETFORMAT_VARIABLE      0x80  // Default
+
+#define RF_PACKETCONFIG1_DCFREE_MASK                0x9F
+#define RF_PACKETCONFIG1_DCFREE_OFF                 0x00  // Default
+#define RF_PACKETCONFIG1_DCFREE_MANCHESTER          0x20
+#define RF_PACKETCONFIG1_DCFREE_WHITENING           0x40
+
+#define RF_PACKETCONFIG1_CRC_MASK                   0xEF
+#define RF_PACKETCONFIG1_CRC_ON                     0x10  // Default
+#define RF_PACKETCONFIG1_CRC_OFF                    0x00
+
+#define RF_PACKETCONFIG1_CRCAUTOCLEAR_MASK          0xF7
+#define RF_PACKETCONFIG1_CRCAUTOCLEAR_ON            0x00  // Default
+#define RF_PACKETCONFIG1_CRCAUTOCLEAR_OFF           0x08
+
+#define RF_PACKETCONFIG1_ADDRSFILTERING_MASK         0xF9
+#define RF_PACKETCONFIG1_ADDRSFILTERING_OFF          0x00  // Default
+#define RF_PACKETCONFIG1_ADDRSFILTERING_NODE         0x02
+#define RF_PACKETCONFIG1_ADDRSFILTERING_NODEBROADCAST 0x04
+
+#define RF_PACKETCONFIG1_CRCWHITENINGTYPE_MASK      0xFE
+#define RF_PACKETCONFIG1_CRCWHITENINGTYPE_CCITT     0x00  // Default
+#define RF_PACKETCONFIG1_CRCWHITENINGTYPE_IBM       0x01
+
+/*!
+ * RegPacketConfig2
+ */
+ 
+#define RF_PACKETCONFIG2_WMBUS_CRC_ENABLE_MASK      0x7F 
+#define RF_PACKETCONFIG2_WMBUS_CRC_ENABLE           0x80
+#define RF_PACKETCONFIG2_WMBUS_CRC_DISABLE          0x00  // Default
+
+#define RF_PACKETCONFIG2_DATAMODE_MASK              0xBF
+#define RF_PACKETCONFIG2_DATAMODE_CONTINUOUS        0x00
+#define RF_PACKETCONFIG2_DATAMODE_PACKET            0x40  // Default
+
+#define RF_PACKETCONFIG2_IOHOME_MASK                0xDF
+#define RF_PACKETCONFIG2_IOHOME_ON                  0x20
+#define RF_PACKETCONFIG2_IOHOME_OFF                 0x00  // Default
+
+#define RF_PACKETCONFIG2_BEACON_MASK                0xF7
+#define RF_PACKETCONFIG2_BEACON_ON                  0x08
+#define RF_PACKETCONFIG2_BEACON_OFF                 0x00  // Default
+
+#define RF_PACKETCONFIG2_PAYLOADLENGTH_MSB_MASK     0xF8
+
+/*!
+ * RegPayloadLength
+ */
+#define RF_PAYLOADLENGTH_LENGTH                     0x40  // Default
+
+/*!
+ * RegNodeAdrs
+ */
+#define RF_NODEADDRESS_ADDRESS                      0x00
+
+/*!
+ * RegBroadcastAdrs
+ */
+#define RF_BROADCASTADDRESS_ADDRESS                 0x00
+
+/*!
+ * RegFifoThresh
+ */
+#define RF_FIFOTHRESH_TXSTARTCONDITION_MASK         0x7F
+#define RF_FIFOTHRESH_TXSTARTCONDITION_FIFOTHRESH   0x00  // Default
+#define RF_FIFOTHRESH_TXSTARTCONDITION_FIFONOTEMPTY 0x80  
+
+#define RF_FIFOTHRESH_FIFOTHRESHOLD_MASK            0xC0
+#define RF_FIFOTHRESH_FIFOTHRESHOLD_THRESHOLD       0x0F  // Default
+
+/*!
+ * RegSeqConfig1
+ */
+#define RF_SEQCONFIG1_SEQUENCER_START               0x80
+
+#define RF_SEQCONFIG1_SEQUENCER_STOP                0x40
+
+#define RF_SEQCONFIG1_IDLEMODE_MASK                 0xDF
+#define RF_SEQCONFIG1_IDLEMODE_SLEEP                0x20
+#define RF_SEQCONFIG1_IDLEMODE_STANDBY              0x00  // Default
+
+#define RF_SEQCONFIG1_FROMSTART_MASK                0xE7
+#define RF_SEQCONFIG1_FROMSTART_TOLPS               0x00  // Default
+#define RF_SEQCONFIG1_FROMSTART_TORX                0x08
+#define RF_SEQCONFIG1_FROMSTART_TOTX                0x10
+#define RF_SEQCONFIG1_FROMSTART_TOTX_ONFIFOLEVEL    0x18
+
+#define RF_SEQCONFIG1_LPS_MASK                      0xFB
+#define RF_SEQCONFIG1_LPS_SEQUENCER_OFF             0x00  // Default
+#define RF_SEQCONFIG1_LPS_IDLE                      0x04
+
+#define RF_SEQCONFIG1_FROMIDLE_MASK                 0xFD
+#define RF_SEQCONFIG1_FROMIDLE_TOTX                 0x00  // Default
+#define RF_SEQCONFIG1_FROMIDLE_TORX                 0x02
+
+#define RF_SEQCONFIG1_FROMTX_MASK                   0xFE
+#define RF_SEQCONFIG1_FROMTX_TOLPS                  0x00  // Default
+#define RF_SEQCONFIG1_FROMTX_TORX                   0x01
+
+/*!
+ * RegSeqConfig2
+ */
+#define RF_SEQCONFIG2_FROMRX_MASK                   0x1F
+#define RF_SEQCONFIG2_FROMRX_TOUNUSED_000           0x00  // Default
+#define RF_SEQCONFIG2_FROMRX_TORXPKT_ONPLDRDY       0x20
+#define RF_SEQCONFIG2_FROMRX_TOLPS_ONPLDRDY         0x40
+#define RF_SEQCONFIG2_FROMRX_TORXPKT_ONCRCOK        0x60
+#define RF_SEQCONFIG2_FROMRX_TOSEQUENCEROFF_ONRSSI  0x80
+#define RF_SEQCONFIG2_FROMRX_TOSEQUENCEROFF_ONSYNC  0xA0
+#define RF_SEQCONFIG2_FROMRX_TOSEQUENCEROFF_ONPREAMBLE 0xC0
+#define RF_SEQCONFIG2_FROMRX_TOUNUSED_111           0xE0
+
+#define RF_SEQCONFIG2_FROMRXTIMEOUT_MASK            0xE7
+#define RF_SEQCONFIG2_FROMRXTIMEOUT_TORXRESTART     0x00  // Default
+#define RF_SEQCONFIG2_FROMRXTIMEOUT_TOTX            0x08
+#define RF_SEQCONFIG2_FROMRXTIMEOUT_TOLPS           0x10
+#define RF_SEQCONFIG2_FROMRXTIMEOUT_TOSEQUENCEROFF  0x18
+
+#define RF_SEQCONFIG2_FROMRXPKT_MASK                0xF8
+#define RF_SEQCONFIG2_FROMRXPKT_TOSEQUENCEROFF      0x00  // Default
+#define RF_SEQCONFIG2_FROMRXPKT_TOTX_ONFIFOEMPTY    0x01
+#define RF_SEQCONFIG2_FROMRXPKT_TOLPS               0x02
+#define RF_SEQCONFIG2_FROMRXPKT_TOSYNTHESIZERRX     0x03
+#define RF_SEQCONFIG2_FROMRXPKT_TORX                0x04
+
+/*!
+ * RegTimerResol
+ */
+#define RF_TIMERRESOL_TIMER1RESOL_MASK              0xF3
+#define RF_TIMERRESOL_TIMER1RESOL_OFF               0x00  // Default
+#define RF_TIMERRESOL_TIMER1RESOL_000064_US         0x04
+#define RF_TIMERRESOL_TIMER1RESOL_004100_US         0x08
+#define RF_TIMERRESOL_TIMER1RESOL_262000_US         0x0C
+
+#define RF_TIMERRESOL_TIMER2RESOL_MASK              0xFC
+#define RF_TIMERRESOL_TIMER2RESOL_OFF               0x00  // Default
+#define RF_TIMERRESOL_TIMER2RESOL_000064_US         0x01
+#define RF_TIMERRESOL_TIMER2RESOL_004100_US         0x02
+#define RF_TIMERRESOL_TIMER2RESOL_262000_US         0x03
+
+/*!
+ * RegTimer1Coef
+ */
+#define RF_TIMER1COEF_TIMER1COEFFICIENT             0xF5  // Default
+
+/*!
+ * RegTimer2Coef
+ */
+#define RF_TIMER2COEF_TIMER2COEFFICIENT             0x20  // Default
+
+/*!
+ * RegImageCal
+ */
+#define RF_IMAGECAL_AUTOIMAGECAL_MASK               0x7F
+#define RF_IMAGECAL_AUTOIMAGECAL_ON                 0x80
+#define RF_IMAGECAL_AUTOIMAGECAL_OFF                0x00  // Default
+
+#define RF_IMAGECAL_IMAGECAL_MASK                   0xBF
+#define RF_IMAGECAL_IMAGECAL_START                  0x40
+
+#define RF_IMAGECAL_IMAGECAL_RUNNING                0x20
+#define RF_IMAGECAL_IMAGECAL_DONE                   0x00  // Default
+
+#define RF_IMAGECAL_TEMPCHANGE_HIGHER               0x08
+#define RF_IMAGECAL_TEMPCHANGE_LOWER                0x00
+
+#define RF_IMAGECAL_TEMPTHRESHOLD_MASK              0xF9
+#define RF_IMAGECAL_TEMPTHRESHOLD_05                0x00
+#define RF_IMAGECAL_TEMPTHRESHOLD_10                0x02  // Default
+#define RF_IMAGECAL_TEMPTHRESHOLD_15                0x04
+#define RF_IMAGECAL_TEMPTHRESHOLD_20                0x06
+
+#define RF_IMAGECAL_TEMPMONITOR_MASK                0xFE
+#define RF_IMAGECAL_TEMPMONITOR_ON                  0x00 // Default
+#define RF_IMAGECAL_TEMPMONITOR_OFF                 0x01
+
+/*!
+ * RegTemp (Read Only)
+ */
+
+/*!
+ * RegLowBat
+ */
+#define RF_LOWBAT_MASK                              0xF7
+#define RF_LOWBAT_ON                                0x08
+#define RF_LOWBAT_OFF                               0x00  // Default
+
+#define RF_LOWBAT_TRIM_MASK                         0xF8
+#define RF_LOWBAT_TRIM_1695                         0x00
+#define RF_LOWBAT_TRIM_1764                         0x01
+#define RF_LOWBAT_TRIM_1835                         0x02  // Default
+#define RF_LOWBAT_TRIM_1905                         0x03
+#define RF_LOWBAT_TRIM_1976                         0x04
+#define RF_LOWBAT_TRIM_2045                         0x05
+#define RF_LOWBAT_TRIM_2116                         0x06
+#define RF_LOWBAT_TRIM_2185                         0x07
+
+/*!
+ * RegIrqFlags1
+ */
+#define RF_IRQFLAGS1_MODEREADY                      0x80
+
+#define RF_IRQFLAGS1_RXREADY                        0x40
+
+#define RF_IRQFLAGS1_TXREADY                        0x20
+
+#define RF_IRQFLAGS1_PLLLOCK                        0x10
+
+#define RF_IRQFLAGS1_RSSI                           0x08
+
+#define RF_IRQFLAGS1_TIMEOUT                        0x04
+
+#define RF_IRQFLAGS1_PREAMBLEDETECT                 0x02
+
+#define RF_IRQFLAGS1_SYNCADDRESSMATCH               0x01
+
+/*!
+ * RegIrqFlags2
+ */
+#define RF_IRQFLAGS2_FIFOFULL                       0x80
+
+#define RF_IRQFLAGS2_FIFOEMPTY                      0x40
+
+#define RF_IRQFLAGS2_FIFOLEVEL                      0x20
+
+#define RF_IRQFLAGS2_FIFOOVERRUN                    0x10
+
+#define RF_IRQFLAGS2_PACKETSENT                     0x08
+
+#define RF_IRQFLAGS2_PAYLOADREADY                   0x04
+
+#define RF_IRQFLAGS2_CRCOK                          0x02
+
+#define RF_IRQFLAGS2_LOWBAT                         0x01
+
+/*!
+ * RegDioMapping1
+ */
+#define RF_DIOMAPPING1_DIO0_MASK                    0x3F
+#define RF_DIOMAPPING1_DIO0_00                      0x00  // Default
+#define RF_DIOMAPPING1_DIO0_01                      0x40
+#define RF_DIOMAPPING1_DIO0_10                      0x80
+#define RF_DIOMAPPING1_DIO0_11                      0xC0
+
+#define RF_DIOMAPPING1_DIO1_MASK                    0xCF
+#define RF_DIOMAPPING1_DIO1_00                      0x00  // Default
+#define RF_DIOMAPPING1_DIO1_01                      0x10
+#define RF_DIOMAPPING1_DIO1_10                      0x20
+#define RF_DIOMAPPING1_DIO1_11                      0x30
+
+#define RF_DIOMAPPING1_DIO2_MASK                    0xF3
+#define RF_DIOMAPPING1_DIO2_00                      0x00  // Default
+#define RF_DIOMAPPING1_DIO2_01                      0x04
+#define RF_DIOMAPPING1_DIO2_10                      0x08
+#define RF_DIOMAPPING1_DIO2_11                      0x0C
+
+#define RF_DIOMAPPING1_DIO3_MASK                    0xFC
+#define RF_DIOMAPPING1_DIO3_00                      0x00  // Default
+#define RF_DIOMAPPING1_DIO3_01                      0x01
+#define RF_DIOMAPPING1_DIO3_10                      0x02
+#define RF_DIOMAPPING1_DIO3_11                      0x03
+
+/*!
+ * RegDioMapping2
+ */
+#define RF_DIOMAPPING2_DIO4_MASK                    0x3F
+#define RF_DIOMAPPING2_DIO4_00                      0x00  // Default
+#define RF_DIOMAPPING2_DIO4_01                      0x40
+#define RF_DIOMAPPING2_DIO4_10                      0x80
+#define RF_DIOMAPPING2_DIO4_11                      0xC0
+
+#define RF_DIOMAPPING2_DIO5_MASK                    0xCF
+#define RF_DIOMAPPING2_DIO5_00                      0x00  // Default
+#define RF_DIOMAPPING2_DIO5_01                      0x10
+#define RF_DIOMAPPING2_DIO5_10                      0x20
+#define RF_DIOMAPPING2_DIO5_11                      0x30
+
+#define RF_DIOMAPPING2_MAP_MASK                     0xFE
+#define RF_DIOMAPPING2_MAP_PREAMBLEDETECT           0x01
+#define RF_DIOMAPPING2_MAP_RSSI                     0x00  // Default
+
+/*!
+ * RegVersion (Read Only)
+ */
+
+/*!
+ * RegAgcRef
+ */
+
+/*!
+ * RegAgcThresh1
+ */
+
+/*!
+ * RegAgcThresh2
+ */
+
+/*!
+ * RegAgcThresh3
+ */
+
+/*!
+ * RegPllHop
+ */
+#define RF_PLLHOP_FASTHOP_MASK                      0x7F
+#define RF_PLLHOP_FASTHOP_ON                        0x80
+#define RF_PLLHOP_FASTHOP_OFF                       0x00 // Default
+
+/*!
+ * RegTcxo
+ */
+#define RF_TCXO_TCXOINPUT_MASK                      0xEF
+#define RF_TCXO_TCXOINPUT_ON                        0x10
+#define RF_TCXO_TCXOINPUT_OFF                       0x00  // Default
+
+/*!
+ * RegPaDac
+ */
+#define RF_PADAC_20DBM_MASK                         0xF8
+#define RF_PADAC_20DBM_ON                           0x07
+#define RF_PADAC_20DBM_OFF                          0x04  // Default
+
+/*!
+ * RegPll
+ */
+#define RF_PLL_BANDWIDTH_MASK                       0x3F
+#define RF_PLL_BANDWIDTH_75                         0x00
+#define RF_PLL_BANDWIDTH_150                        0x40
+#define RF_PLL_BANDWIDTH_225                        0x80
+#define RF_PLL_BANDWIDTH_300                        0xC0  // Default
+
+/*!
+ * RegPllLowPn
+ */
+#define RF_PLLLOWPN_BANDWIDTH_MASK                  0x3F
+#define RF_PLLLOWPN_BANDWIDTH_75                    0x00
+#define RF_PLLLOWPN_BANDWIDTH_150                   0x40
+#define RF_PLLLOWPN_BANDWIDTH_225                   0x80
+#define RF_PLLLOWPN_BANDWIDTH_300                   0xC0  // Default
+
+/*!
+ * RegFormerTemp
+ */
+
+/*!
+ * RegBitrateFrac
+ */
+#define RF_BITRATEFRAC_MASK                         0xF0
+
+typedef struct sSX1276
+{
+    uint8_t RegFifo;                                // 0x00
+    // Common settings
+    uint8_t RegOpMode;                              // 0x01
+    uint8_t RegBitrateMsb;                          // 0x02
+    uint8_t RegBitrateLsb;                          // 0x03
+    uint8_t RegFdevMsb;                             // 0x04
+    uint8_t RegFdevLsb;                             // 0x05
+    uint8_t RegFrfMsb;                              // 0x06
+    uint8_t RegFrfMid;                              // 0x07
+    uint8_t RegFrfLsb;                              // 0x08
+    // Tx settings
+    uint8_t RegPaConfig;                            // 0x09
+    uint8_t RegPaRamp;                              // 0x0A
+    uint8_t RegOcp;                                 // 0x0B
+    // Rx settings
+    uint8_t RegLna;                                 // 0x0C
+    uint8_t RegRxConfig;                            // 0x0D
+    uint8_t RegRssiConfig;                          // 0x0E
+    uint8_t RegRssiCollision;                       // 0x0F
+    uint8_t RegRssiThresh;                          // 0x10
+    uint8_t RegRssiValue;                           // 0x11
+    uint8_t RegRxBw;                                // 0x12
+    uint8_t RegAfcBw;                               // 0x13
+    uint8_t RegOokPeak;                             // 0x14
+    uint8_t RegOokFix;                              // 0x15
+    uint8_t RegOokAvg;                              // 0x16
+    uint8_t RegRes17;                               // 0x17
+    uint8_t RegRes18;                               // 0x18
+    uint8_t RegRes19;                               // 0x19
+    uint8_t RegAfcFei;                              // 0x1A
+    uint8_t RegAfcMsb;                              // 0x1B
+    uint8_t RegAfcLsb;                              // 0x1C
+    uint8_t RegFeiMsb;                              // 0x1D
+    uint8_t RegFeiLsb;                              // 0x1E
+    uint8_t RegPreambleDetect;                      // 0x1F
+    uint8_t RegRxTimeout1;                          // 0x20
+    uint8_t RegRxTimeout2;                          // 0x21
+    uint8_t RegRxTimeout3;                          // 0x22
+    uint8_t RegRxDelay;                             // 0x23
+    // Oscillator settings
+    uint8_t RegOsc;                                 // 0x24
+    // Packet handler settings
+    uint8_t RegPreambleMsb;                         // 0x25
+    uint8_t RegPreambleLsb;                         // 0x26
+    uint8_t RegSyncConfig;                          // 0x27
+    uint8_t RegSyncValue1;                          // 0x28
+    uint8_t RegSyncValue2;                          // 0x29
+    uint8_t RegSyncValue3;                          // 0x2A
+    uint8_t RegSyncValue4;                          // 0x2B
+    uint8_t RegSyncValue5;                          // 0x2C
+    uint8_t RegSyncValue6;                          // 0x2D
+    uint8_t RegSyncValue7;                          // 0x2E
+    uint8_t RegSyncValue8;                          // 0x2F
+    uint8_t RegPacketConfig1;                       // 0x30
+    uint8_t RegPacketConfig2;                       // 0x31
+    uint8_t RegPayloadLength;                       // 0x32
+    uint8_t RegNodeAdrs;                            // 0x33
+    uint8_t RegBroadcastAdrs;                       // 0x34
+    uint8_t RegFifoThresh;                          // 0x35
+    // Sequencer settings
+    uint8_t RegSeqConfig1;                          // 0x36
+    uint8_t RegSeqConfig2;                          // 0x37
+    uint8_t RegTimerResol;                          // 0x38
+    uint8_t RegTimer1Coef;                          // 0x39
+    uint8_t RegTimer2Coef;                          // 0x3A
+    // Service settings
+    uint8_t RegImageCal;                            // 0x3B
+    uint8_t RegTemp;                                // 0x3C
+    uint8_t RegLowBat;                              // 0x3D
+    // Status
+    uint8_t RegIrqFlags1;                           // 0x3E
+    uint8_t RegIrqFlags2;                           // 0x3F
+    // I/O settings
+    uint8_t RegDioMapping1;                         // 0x40
+    uint8_t RegDioMapping2;                         // 0x41
+    // Version
+    uint8_t RegVersion;                             // 0x42
+    // Additional settings
+    uint8_t RegAgcRef;                              // 0x43
+    uint8_t RegAgcThresh1;                          // 0x44
+    uint8_t RegAgcThresh2;                          // 0x45
+    uint8_t RegAgcThresh3;                          // 0x46
+    // Test
+    uint8_t RegTestReserved47[0x4B - 0x47];         // 0x47-0x4A
+    // Additional settings
+    uint8_t RegPllHop;                              // 0x4B
+    uint8_t RegTestReserved4C;                      // 0x4C
+    uint8_t RegPaDac;                               // 0x4D
+    // Test
+    uint8_t RegTestReserved4E[0x58-0x4E];           // 0x4E-0x57
+    // Additional settings
+    uint8_t RegTcxo;                                // 0x58
+    // Test
+    uint8_t RegTestReserved59;                      // 0x59
+    // Test
+    uint8_t RegTestReserved5B;                      // 0x5B
+    // Additional settings
+    uint8_t RegPll;                                 // 0x5C
+    // Test
+    uint8_t RegTestReserved5D;                      // 0x5D
+    // Additional settings
+    uint8_t RegPllLowPn;                            // 0x5E
+    // Test
+    uint8_t RegTestReserved5F[0x6C - 0x5F];         // 0x5F-0x6B
+    // Additional settings
+    uint8_t RegFormerTemp;                          // 0x6C
+    // Test
+    uint8_t RegTestReserved6D[0x70 - 0x6D];         // 0x6D-0x6F
+    // Additional settings
+    uint8_t RegBitrateFrac;                         // 0x70
+}tSX1276;
+
+extern tSX1276* SX1276;
+
+/*!
+ * \brief Initializes the SX1276
+ */
+void SX1276FskInit( void );
+
+/*!
+ * \brief Sets the SX1276 to datasheet default values
+ */
+void SX1276FskSetDefaults( void );
+
+/*!
+ * \brief Resets the SX1276
+ */
+void SX1276FskReset( void );
+
+/*!
+ * \brief Enables/Disables the LoRa modem
+ *
+ * \param [IN]: enable [true, false]
+ */
+void SX1276FskSetLoRaOn( bool enable );
+
+/*!
+ * \brief Sets the SX1276 operating mode
+ *
+ * \param [IN] opMode New operating mode
+ */
+void SX1276FskSetOpMode( uint8_t opMode );
+
+/*!
+ * \brief Gets the SX1276 operating mode
+ *
+ * \retval opMode Current operating mode
+ */
+uint8_t SX1276FskGetOpMode( void );
+
+/*!
+ * \brief Trigs and reads the FEI
+ *
+ * \retval feiValue Frequency error value.
+ */
+int32_t SX1276FskReadFei( void );
+
+/*!
+ * \brief Reads the current AFC value
+ *
+ * \retval afcValue Frequency offset value.
+ */
+int32_t SX1276FskReadAfc( void );
+
+/*!
+ * \brief Reads the current Rx gain setting
+ *
+ * \retval rxGain Current gain setting
+ */
+uint8_t SX1276FskReadRxGain( void );
+
+/*!
+ * \brief Trigs and reads the current RSSI value
+ *
+ * \retval rssiValue Current RSSI value in [dBm]
+ */
+double SX1276FskReadRssi( void );
+
+/*!
+ * \brief Gets the Rx gain value measured while receiving the packet
+ *
+ * \retval rxGainValue Current Rx gain value
+ */
+uint8_t SX1276FskGetPacketRxGain( void );
+
+/*!
+ * \brief Gets the RSSI value measured while receiving the packet
+ *
+ * \retval rssiValue Current RSSI value in [dBm]
+ */
+double SX1276FskGetPacketRssi( void );
+
+/*!
+ * \brief Gets the AFC value measured while receiving the packet
+ *
+ * \retval afcValue Current AFC value in [Hz]
+ */
+uint32_t SX1276FskGetPacketAfc( void );
+
+/*!
+ * \brief Sets the radio in Rx mode. Waiting for a packet
+ */
+void SX1276FskStartRx( void );
+
+/*!
+ * \brief Gets a copy of the current received buffer
+ *
+ * \param [IN]: buffer     Buffer pointer
+ * \param [IN]: size       Buffer size
+ */
+void SX1276FskGetRxPacket( void *buffer, uint16_t *size );
+
+/*!
+ * \brief Sets a copy of the buffer to be transmitted and starts the
+ *        transmission
+ *
+ * \param [IN]: buffer     Buffer pointer
+ * \param [IN]: size       Buffer size
+ */
+void SX1276FskSetTxPacket( const void *buffer, uint16_t size );
+
+/*!
+ * \brief Gets the current RFState
+ *
+ * \retval rfState Current RF state [RF_IDLE, RF_BUSY, 
+ *                                   RF_RX_DONE, RF_RX_TIMEOUT,
+ *                                   RF_TX_DONE, RF_TX_TIMEOUT]
+ */
+uint8_t SX1276FskGetRFState( void );
+
+/*!
+ * \brief Sets the new state of the RF state machine
+ *
+ * \param [IN]: state New RF state machine state
+ */
+void SX1276FskSetRFState( uint8_t state );
+
+/*!
+ * \brief Process the FSK modem Rx and Tx state machines depending on the
+ *       SX1276 operating mode.
+ *
+ * \retval rfState Current RF state [RF_IDLE, RF_BUSY, 
+ *                                   RF_RX_DONE, RF_RX_TIMEOUT,
+ *                                   RF_TX_DONE, RF_TX_TIMEOUT]
+ */
+uint32_t SX1276FskProcess( void );
+
+#endif //__SX1276_FSK_H__
+

APP/network_mgr/lora/Radio/inc/sx1276-Fsk.h~RF3cafdf9.TMP

@@ -0,0 +1,1460 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276-Fsk.h
+ * \brief      SX1276 RF chip driver mode FSK
+ *
+ * \version    2.0.B2 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#ifndef __SX1276_FSK_H__
+#define __SX1276_FSK_H__
+
+/*!
+ * SX1276 FSK General parameters definition
+ */
+
+typedef struct sFskSettings
+{
+    uint32_t RFFrequency;
+    uint32_t Bitrate;
+    uint32_t Fdev;
+    int8_t Power;
+    uint32_t RxBw;
+    uint32_t RxBwAfc;
+    bool CrcOn;
+    bool AfcOn;
+    uint8_t PayloadLength;
+}tFskSettings;
+
+/*!
+ * RF packet definition
+ */
+#define RF_BUFFER_SIZE_MAX                          100
+#define RF_BUFFER_SIZE                              100
+
+/*!
+ * RF state machine
+ */
+// FSK
+typedef enum
+{
+    RF_STATE_IDLE,
+    RF_STATE_RX_INIT,
+    RF_STATE_RX_SYNC,
+    RF_STATE_RX_RUNNING,
+    RF_STATE_RX_DONE,
+    RF_STATE_RX_TIMEOUT,
+    RF_STATE_RX_LEN_ERROR,
+    RF_STATE_TX_INIT,
+    RF_STATE_TX_READY_WAIT,
+    RF_STATE_TX_RUNNING,
+    RF_STATE_TX_DONE,
+    RF_STATE_TX_TIMEOUT,
+}tRFStates;
+
+/*!
+ * SX1276 definitions
+ */
+#define XTAL_FREQ                                   32000000
+#define FREQ_STEP                                   61.03515625
+
+/*!
+ * SX1276 Internal registers Address
+ */
+#define REG_FIFO                                    0x00
+// Common settings
+#define REG_OPMODE                                  0x01
+#define REG_BITRATEMSB                              0x02
+#define REG_BITRATELSB                              0x03
+#define REG_FDEVMSB                                 0x04 
+#define REG_FDEVLSB                                 0x05
+#define REG_FRFMSB                                  0x06
+#define REG_FRFMID                                  0x07
+#define REG_FRFLSB                                  0x08
+// Tx settings
+#define REG_PACONFIG                                0x09
+#define REG_PARAMP                                  0x0A
+#define REG_OCP                                     0x0B 
+// Rx settings
+#define REG_LNA                                     0x0C
+#define REG_RXCONFIG                                0x0D
+#define REG_RSSICONFIG                              0x0E
+#define REG_RSSICOLLISION                           0x0F
+#define REG_RSSITHRESH                              0x10
+#define REG_RSSIVALUE                               0x11
+#define REG_RXBW                                    0x12 
+#define REG_AFCBW                                   0x13
+#define REG_OOKPEAK                                 0x14
+#define REG_OOKFIX                                  0x15
+#define REG_OOKAVG                                  0x16
+#define REG_RES17                                   0x17
+#define REG_RES18                                   0x18
+#define REG_RES19                                   0x19
+#define REG_AFCFEI                                  0x1A
+#define REG_AFCMSB                                  0x1B
+#define REG_AFCLSB                                  0x1C
+#define REG_FEIMSB                                  0x1D
+#define REG_FEILSB                                  0x1E
+#define REG_PREAMBLEDETECT                          0x1F
+#define REG_RXTIMEOUT1                              0x20
+#define REG_RXTIMEOUT2                              0x21
+#define REG_RXTIMEOUT3                              0x22
+#define REG_RXDELAY                                 0x23
+// Oscillator settings
+#define REG_OSC                                     0x24
+// Packet handler settings
+#define REG_PREAMBLEMSB                             0x25
+#define REG_PREAMBLELSB                             0x26
+#define REG_SYNCCONFIG                              0x27
+#define REG_SYNCVALUE1                              0x28
+#define REG_SYNCVALUE2                              0x29
+#define REG_SYNCVALUE3                              0x2A
+#define REG_SYNCVALUE4                              0x2B
+#define REG_SYNCVALUE5                              0x2C
+#define REG_SYNCVALUE6                              0x2D
+#define REG_SYNCVALUE7                              0x2E
+#define REG_SYNCVALUE8                              0x2F
+#define REG_PACKETCONFIG1                           0x30
+#define REG_PACKETCONFIG2                           0x31
+#define REG_PAYLOADLENGTH                           0x32
+#define REG_NODEADRS                                0x33
+#define REG_BROADCASTADRS                           0x34
+#define REG_FIFOTHRESH                              0x35
+// SM settings
+#define REG_SEQCONFIG1                              0x36
+#define REG_SEQCONFIG2                              0x37
+#define REG_TIMERRESOL                              0x38
+#define REG_TIMER1COEF                              0x39
+#define REG_TIMER2COEF                              0x3A
+// Service settings
+#define REG_IMAGECAL                                0x3B
+#define REG_TEMP                                    0x3C
+#define REG_LOWBAT                                  0x3D
+// Status
+#define REG_IRQFLAGS1                               0x3E
+#define REG_IRQFLAGS2                               0x3F
+// I/O settings
+#define REG_DIOMAPPING1                             0x40
+#define REG_DIOMAPPING2                             0x41
+// Version
+#define REG_VERSION                                 0x42
+// Additional settings
+#define REG_PLLHOP                                  0x44
+#define REG_TCXO                                    0x4B
+#define REG_PADAC                                   0x4D
+#define REG_FORMERTEMP                              0x5B
+#define REG_BITRATEFRAC                             0x5D
+#define REG_AGCREF                                  0x61
+#define REG_AGCTHRESH1                              0x62
+#define REG_AGCTHRESH2                              0x63
+#define REG_AGCTHRESH3                              0x64
+
+
+/*!
+ * SX1276 FSK bit control definition
+ */
+
+/*!
+ * RegFifo
+ */
+
+/*!
+ * RegOpMode
+ */
+#define RF_OPMODE_LONGRANGEMODE_MASK                0x7F
+#define RF_OPMODE_LONGRANGEMODE_OFF                 0x00  // Default
+#define RF_OPMODE_LONGRANGEMODE_ON                  0x80
+
+#define RF_OPMODE_MODULATIONTYPE_MASK               0x9F
+#define RF_OPMODE_MODULATIONTYPE_FSK                0x00  // Default
+#define RF_OPMODE_MODULATIONTYPE_OOK                0x20
+
+#define RF_OPMODE_FREQMODE_ACCESS_MASK              0xF7
+#define RF_OPMODE_FREQMODE_ACCESS_LF                0x08  // Default
+#define RF_OPMODE_FREQMODE_ACCESS_HF                0x00 
+
+#define RF_OPMODE_MASK                              0xF8
+#define RF_OPMODE_SLEEP                             0x00
+#define RF_OPMODE_STANDBY                           0x01  // Default
+#define RF_OPMODE_SYNTHESIZER_TX                    0x02
+#define RF_OPMODE_TRANSMITTER                       0x03
+#define RF_OPMODE_SYNTHESIZER_RX                    0x04
+#define RF_OPMODE_RECEIVER                          0x05
+
+/*!
+ * RegBitRate (bits/sec)
+ */
+#define RF_BITRATEMSB_1200_BPS                      0x68
+#define RF_BITRATELSB_1200_BPS                      0x2B
+#define RF_BITRATEMSB_2400_BPS                      0x34
+#define RF_BITRATELSB_2400_BPS                      0x15
+#define RF_BITRATEMSB_4800_BPS                      0x1A  // Default
+#define RF_BITRATELSB_4800_BPS                      0x0B  // Default
+#define RF_BITRATEMSB_9600_BPS                      0x0D
+#define RF_BITRATELSB_9600_BPS                      0x05
+#define RF_BITRATEMSB_15000_BPS                     0x08
+#define RF_BITRATELSB_15000_BPS                     0x55
+#define RF_BITRATEMSB_19200_BPS                     0x06
+#define RF_BITRATELSB_19200_BPS                     0x83
+#define RF_BITRATEMSB_38400_BPS                     0x03
+#define RF_BITRATELSB_38400_BPS                     0x41
+#define RF_BITRATEMSB_76800_BPS                     0x01
+#define RF_BITRATELSB_76800_BPS                     0xA1
+#define RF_BITRATEMSB_153600_BPS                    0x00
+#define RF_BITRATELSB_153600_BPS                    0xD0
+#define RF_BITRATEMSB_57600_BPS                     0x02
+#define RF_BITRATELSB_57600_BPS                     0x2C
+#define RF_BITRATEMSB_115200_BPS                    0x01
+#define RF_BITRATELSB_115200_BPS                    0x16
+#define RF_BITRATEMSB_12500_BPS                     0x0A
+#define RF_BITRATELSB_12500_BPS                     0x00
+#define RF_BITRATEMSB_25000_BPS                     0x05
+#define RF_BITRATELSB_25000_BPS                     0x00
+#define RF_BITRATEMSB_50000_BPS                     0x02
+#define RF_BITRATELSB_50000_BPS                     0x80
+#define RF_BITRATEMSB_100000_BPS                    0x01
+#define RF_BITRATELSB_100000_BPS                    0x40
+#define RF_BITRATEMSB_150000_BPS                    0x00
+#define RF_BITRATELSB_150000_BPS                    0xD5
+#define RF_BITRATEMSB_200000_BPS                    0x00
+#define RF_BITRATELSB_200000_BPS                    0xA0
+#define RF_BITRATEMSB_250000_BPS                    0x00
+#define RF_BITRATELSB_250000_BPS                    0x80
+#define RF_BITRATEMSB_32768_BPS                     0x03
+#define RF_BITRATELSB_32768_BPS                     0xD1
+
+/*!
+ * RegFdev (Hz)
+ */
+ 
+#define RF_FDEVMSB_BANDREG_MASK                     0x3F 
+#define RF_FDEVMSB_BANDREG_AUTO                     0x00 // Default
+#define RF_FDEVMSB_BANDREG_DIV_BY_1                 0x40
+#define RF_FDEVMSB_BANDREG_DIV_BY_2                 0x80
+#define RF_FDEVMSB_BANDREG_DIV_BY_6                 0xC0
+ 
+#define RF_FDEVMSB_FDEV_MASK                        0xC0
+
+#define RF_FDEVMSB_2000_HZ                          0x00
+#define RF_FDEVLSB_2000_HZ                          0x21
+#define RF_FDEVMSB_5000_HZ                          0x00  // Default
+#define RF_FDEVLSB_5000_HZ                          0x52  // Default
+#define RF_FDEVMSB_10000_HZ                         0x00
+#define RF_FDEVLSB_10000_HZ                         0xA4
+#define RF_FDEVMSB_15000_HZ                         0x00
+#define RF_FDEVLSB_15000_HZ                         0xF6
+#define RF_FDEVMSB_20000_HZ                         0x01
+#define RF_FDEVLSB_20000_HZ                         0x48
+#define RF_FDEVMSB_25000_HZ                         0x01
+#define RF_FDEVLSB_25000_HZ                         0x9A
+#define RF_FDEVMSB_30000_HZ                         0x01
+#define RF_FDEVLSB_30000_HZ                         0xEC
+#define RF_FDEVMSB_35000_HZ                         0x02
+#define RF_FDEVLSB_35000_HZ                         0x3D
+#define RF_FDEVMSB_40000_HZ                         0x02
+#define RF_FDEVLSB_40000_HZ                         0x8F
+#define RF_FDEVMSB_45000_HZ                         0x02
+#define RF_FDEVLSB_45000_HZ                         0xE1
+#define RF_FDEVMSB_50000_HZ                         0x03
+#define RF_FDEVLSB_50000_HZ                         0x33
+#define RF_FDEVMSB_55000_HZ                         0x03
+#define RF_FDEVLSB_55000_HZ                         0x85
+#define RF_FDEVMSB_60000_HZ                         0x03
+#define RF_FDEVLSB_60000_HZ                         0xD7
+#define RF_FDEVMSB_65000_HZ                         0x04
+#define RF_FDEVLSB_65000_HZ                         0x29
+#define RF_FDEVMSB_70000_HZ                         0x04
+#define RF_FDEVLSB_70000_HZ                         0x7B
+#define RF_FDEVMSB_75000_HZ                         0x04
+#define RF_FDEVLSB_75000_HZ                         0xCD
+#define RF_FDEVMSB_80000_HZ                         0x05
+#define RF_FDEVLSB_80000_HZ                         0x1F
+#define RF_FDEVMSB_85000_HZ                         0x05
+#define RF_FDEVLSB_85000_HZ                         0x71
+#define RF_FDEVMSB_90000_HZ                         0x05
+#define RF_FDEVLSB_90000_HZ                         0xC3
+#define RF_FDEVMSB_95000_HZ                         0x06
+#define RF_FDEVLSB_95000_HZ                         0x14
+#define RF_FDEVMSB_100000_HZ                        0x06
+#define RF_FDEVLSB_100000_HZ                        0x66
+#define RF_FDEVMSB_110000_HZ                        0x07
+#define RF_FDEVLSB_110000_HZ                        0x0A
+#define RF_FDEVMSB_120000_HZ                        0x07
+#define RF_FDEVLSB_120000_HZ                        0xAE
+#define RF_FDEVMSB_130000_HZ                        0x08
+#define RF_FDEVLSB_130000_HZ                        0x52
+#define RF_FDEVMSB_140000_HZ                        0x08
+#define RF_FDEVLSB_140000_HZ                        0xF6
+#define RF_FDEVMSB_150000_HZ                        0x09
+#define RF_FDEVLSB_150000_HZ                        0x9A
+#define RF_FDEVMSB_160000_HZ                        0x0A
+#define RF_FDEVLSB_160000_HZ                        0x3D
+#define RF_FDEVMSB_170000_HZ                        0x0A
+#define RF_FDEVLSB_170000_HZ                        0xE1
+#define RF_FDEVMSB_180000_HZ                        0x0B
+#define RF_FDEVLSB_180000_HZ                        0x85
+#define RF_FDEVMSB_190000_HZ                        0x0C
+#define RF_FDEVLSB_190000_HZ                        0x29
+#define RF_FDEVMSB_200000_HZ                        0x0C
+#define RF_FDEVLSB_200000_HZ                        0xCD
+
+/*!
+ * RegFrf (MHz)
+ */
+#define RF_FRFMSB_863_MHZ                           0xD7
+#define RF_FRFMID_863_MHZ                           0xC0
+#define RF_FRFLSB_863_MHZ                           0x00
+#define RF_FRFMSB_864_MHZ                           0xD8
+#define RF_FRFMID_864_MHZ                           0x00
+#define RF_FRFLSB_864_MHZ                           0x00
+#define RF_FRFMSB_865_MHZ                           0xD8
+#define RF_FRFMID_865_MHZ                           0x40
+#define RF_FRFLSB_865_MHZ                           0x00
+#define RF_FRFMSB_866_MHZ                           0xD8
+#define RF_FRFMID_866_MHZ                           0x80
+#define RF_FRFLSB_866_MHZ                           0x00
+#define RF_FRFMSB_867_MHZ                           0xD8
+#define RF_FRFMID_867_MHZ                           0xC0
+#define RF_FRFLSB_867_MHZ                           0x00
+#define RF_FRFMSB_868_MHZ                           0xD9
+#define RF_FRFMID_868_MHZ                           0x00
+#define RF_FRFLSB_868_MHZ                           0x00
+#define RF_FRFMSB_869_MHZ                           0xD9
+#define RF_FRFMID_869_MHZ                           0x40
+#define RF_FRFLSB_869_MHZ                           0x00
+#define RF_FRFMSB_870_MHZ                           0xD9
+#define RF_FRFMID_870_MHZ                           0x80
+#define RF_FRFLSB_870_MHZ                           0x00
+
+#define RF_FRFMSB_902_MHZ                           0xE1
+#define RF_FRFMID_902_MHZ                           0x80
+#define RF_FRFLSB_902_MHZ                           0x00
+#define RF_FRFMSB_903_MHZ                           0xE1
+#define RF_FRFMID_903_MHZ                           0xC0
+#define RF_FRFLSB_903_MHZ                           0x00
+#define RF_FRFMSB_904_MHZ                           0xE2
+#define RF_FRFMID_904_MHZ                           0x00
+#define RF_FRFLSB_904_MHZ                           0x00
+#define RF_FRFMSB_905_MHZ                           0xE2
+#define RF_FRFMID_905_MHZ                           0x40
+#define RF_FRFLSB_905_MHZ                           0x00
+#define RF_FRFMSB_906_MHZ                           0xE2
+#define RF_FRFMID_906_MHZ                           0x80
+#define RF_FRFLSB_906_MHZ                           0x00
+#define RF_FRFMSB_907_MHZ                           0xE2
+#define RF_FRFMID_907_MHZ                           0xC0
+#define RF_FRFLSB_907_MHZ                           0x00
+#define RF_FRFMSB_908_MHZ                           0xE3
+#define RF_FRFMID_908_MHZ                           0x00
+#define RF_FRFLSB_908_MHZ                           0x00
+#define RF_FRFMSB_909_MHZ                           0xE3
+#define RF_FRFMID_909_MHZ                           0x40
+#define RF_FRFLSB_909_MHZ                           0x00
+#define RF_FRFMSB_910_MHZ                           0xE3
+#define RF_FRFMID_910_MHZ                           0x80
+#define RF_FRFLSB_910_MHZ                           0x00
+#define RF_FRFMSB_911_MHZ                           0xE3
+#define RF_FRFMID_911_MHZ                           0xC0
+#define RF_FRFLSB_911_MHZ                           0x00
+#define RF_FRFMSB_912_MHZ                           0xE4
+#define RF_FRFMID_912_MHZ                           0x00
+#define RF_FRFLSB_912_MHZ                           0x00
+#define RF_FRFMSB_913_MHZ                           0xE4
+#define RF_FRFMID_913_MHZ                           0x40
+#define RF_FRFLSB_913_MHZ                           0x00
+#define RF_FRFMSB_914_MHZ                           0xE4
+#define RF_FRFMID_914_MHZ                           0x80
+#define RF_FRFLSB_914_MHZ                           0x00
+#define RF_FRFMSB_915_MHZ                           0xE4  // Default
+#define RF_FRFMID_915_MHZ                           0xC0  // Default
+#define RF_FRFLSB_915_MHZ                           0x00  // Default
+#define RF_FRFMSB_916_MHZ                           0xE5
+#define RF_FRFMID_916_MHZ                           0x00
+#define RF_FRFLSB_916_MHZ                           0x00
+#define RF_FRFMSB_917_MHZ                           0xE5
+#define RF_FRFMID_917_MHZ                           0x40
+#define RF_FRFLSB_917_MHZ                           0x00
+#define RF_FRFMSB_918_MHZ                           0xE5
+#define RF_FRFMID_918_MHZ                           0x80
+#define RF_FRFLSB_918_MHZ                           0x00
+#define RF_FRFMSB_919_MHZ                           0xE5
+#define RF_FRFMID_919_MHZ                           0xC0
+#define RF_FRFLSB_919_MHZ                           0x00
+#define RF_FRFMSB_920_MHZ                           0xE6
+#define RF_FRFMID_920_MHZ                           0x00
+#define RF_FRFLSB_920_MHZ                           0x00
+#define RF_FRFMSB_921_MHZ                           0xE6
+#define RF_FRFMID_921_MHZ                           0x40
+#define RF_FRFLSB_921_MHZ                           0x00
+#define RF_FRFMSB_922_MHZ                           0xE6
+#define RF_FRFMID_922_MHZ                           0x80
+#define RF_FRFLSB_922_MHZ                           0x00
+#define RF_FRFMSB_923_MHZ                           0xE6
+#define RF_FRFMID_923_MHZ                           0xC0
+#define RF_FRFLSB_923_MHZ                           0x00
+#define RF_FRFMSB_924_MHZ                           0xE7
+#define RF_FRFMID_924_MHZ                           0x00
+#define RF_FRFLSB_924_MHZ                           0x00
+#define RF_FRFMSB_925_MHZ                           0xE7
+#define RF_FRFMID_925_MHZ                           0x40
+#define RF_FRFLSB_925_MHZ                           0x00
+#define RF_FRFMSB_926_MHZ                           0xE7
+#define RF_FRFMID_926_MHZ                           0x80
+#define RF_FRFLSB_926_MHZ                           0x00
+#define RF_FRFMSB_927_MHZ                           0xE7
+#define RF_FRFMID_927_MHZ                           0xC0
+#define RF_FRFLSB_927_MHZ                           0x00
+#define RF_FRFMSB_928_MHZ                           0xE8
+#define RF_FRFMID_928_MHZ                           0x00
+#define RF_FRFLSB_928_MHZ                           0x00
+
+/*!
+ * RegPaConfig
+ */
+#define RF_PACONFIG_PASELECT_MASK                   0x7F
+#define RF_PACONFIG_PASELECT_PABOOST                0x80
+#define RF_PACONFIG_PASELECT_RFO                    0x00 // Default
+
+#define RF_PACONFIG_MAX_POWER_MASK                  0x8F
+
+#define RF_PACONFIG_OUTPUTPOWER_MASK                0xF0
+ 
+/*!
+ * RegPaRamp
+ */
+#define RF_PARAMP_MODULATIONSHAPING_MASK            0x9F
+#define RF_PARAMP_MODULATIONSHAPING_00              0x00 // Default
+#define RF_PARAMP_MODULATIONSHAPING_01              0x20
+#define RF_PARAMP_MODULATIONSHAPING_10              0x40
+#define RF_PARAMP_MODULATIONSHAPING_11              0x60
+ 
+#define RF_PARAMP_TXBANDFORCE_MASK                  0xEF 
+#define RF_PARAMP_TXBANDFORCE_BAND_SEL              0x10 
+#define RF_PARAMP_TXBANDFORCE_AUTO                  0x00 // Default
+
+#define RF_PARAMP_MASK                              0xF0
+#define RF_PARAMP_3400_US                           0x00
+#define RF_PARAMP_2000_US                           0x01
+#define RF_PARAMP_1000_US                           0x02
+#define RF_PARAMP_0500_US                           0x03
+#define RF_PARAMP_0250_US                           0x04
+#define RF_PARAMP_0125_US                           0x05
+#define RF_PARAMP_0100_US                           0x06
+#define RF_PARAMP_0062_US                           0x07
+#define RF_PARAMP_0050_US                           0x08
+#define RF_PARAMP_0040_US                           0x09  // Default
+#define RF_PARAMP_0031_US                           0x0A
+#define RF_PARAMP_0025_US                           0x0B
+#define RF_PARAMP_0020_US                           0x0C
+#define RF_PARAMP_0015_US                           0x0D
+#define RF_PARAMP_0012_US                           0x0E
+#define RF_PARAMP_0010_US                           0x0F
+
+/*!
+ * RegOcp
+ */
+#define RF_OCP_MASK                                 0xDF
+#define RF_OCP_ON                                   0x20  // Default
+#define RF_OCP_OFF                                  0x00  
+
+#define RF_OCP_TRIM_MASK                            0xE0
+#define RF_OCP_TRIM_045_MA                          0x00
+#define RF_OCP_TRIM_050_MA                          0x01   
+#define RF_OCP_TRIM_055_MA                          0x02 
+#define RF_OCP_TRIM_060_MA                          0x03 
+#define RF_OCP_TRIM_065_MA                          0x04 
+#define RF_OCP_TRIM_070_MA                          0x05 
+#define RF_OCP_TRIM_075_MA                          0x06 
+#define RF_OCP_TRIM_080_MA                          0x07  
+#define RF_OCP_TRIM_085_MA                          0x08
+#define RF_OCP_TRIM_090_MA                          0x09 
+#define RF_OCP_TRIM_095_MA                          0x0A 
+#define RF_OCP_TRIM_100_MA                          0x0B  // Default
+#define RF_OCP_TRIM_105_MA                          0x0C 
+#define RF_OCP_TRIM_110_MA                          0x0D 
+#define RF_OCP_TRIM_115_MA                          0x0E 
+#define RF_OCP_TRIM_120_MA                          0x0F 
+#define RF_OCP_TRIM_130_MA                          0x10
+#define RF_OCP_TRIM_140_MA                          0x11   
+#define RF_OCP_TRIM_150_MA                          0x12 
+#define RF_OCP_TRIM_160_MA                          0x13 
+#define RF_OCP_TRIM_170_MA                          0x14 
+#define RF_OCP_TRIM_180_MA                          0x15 
+#define RF_OCP_TRIM_190_MA                          0x16 
+#define RF_OCP_TRIM_200_MA                          0x17  
+#define RF_OCP_TRIM_210_MA                          0x18
+#define RF_OCP_TRIM_220_MA                          0x19 
+#define RF_OCP_TRIM_230_MA                          0x1A 
+#define RF_OCP_TRIM_240_MA                          0x1B
+
+/*!
+ * RegLna
+ */
+#define RF_LNA_GAIN_MASK                            0x1F
+#define RF_LNA_GAIN_G1                              0x20  // Default
+#define RF_LNA_GAIN_G2                              0x40
+#define RF_LNA_GAIN_G3                              0x60
+#define RF_LNA_GAIN_G4                              0x80
+#define RF_LNA_GAIN_G5                              0xA0
+#define RF_LNA_GAIN_G6                              0xC0
+
+#define RF_LNA_BOOST_LF_MASK                        0xE7 
+#define RF_LNA_BOOST_LF_DEFAULT                     0x00 // Default
+#define RF_LNA_BOOST_LF_GAIN                        0x08 
+#define RF_LNA_BOOST_LF_IP3                         0x10 
+#define RF_LNA_BOOST_LF_BOOST                       0x18 
+
+#define RF_LNA_RXBANDFORCE_MASK                     0xFB 
+#define RF_LNA_RXBANDFORCE_BAND_SEL                 0x04
+#define RF_LNA_RXBANDFORCE_AUTO                     0x00 // Default
+
+#define RF_LNA_BOOST_HF_MASK                        0xFC 
+#define RF_LNA_BOOST_HF_OFF                         0x00 // Default
+#define RF_LNA_BOOST_HF_ON                          0x03 
+
+/*!
+ * RegRxConfig
+ */
+#define RF_RXCONFIG_RESTARTRXONCOLLISION_MASK       0x7F
+#define RF_RXCONFIG_RESTARTRXONCOLLISION_ON         0x80
+#define RF_RXCONFIG_RESTARTRXONCOLLISION_OFF        0x00 // Default
+
+#define RF_RXCONFIG_RESTARTRXWITHOUTPLLLOCK         0x40 // Write only
+
+#define RF_RXCONFIG_RESTARTRXWITHPLLLOCK            0x20 // Write only
+
+#define RF_RXCONFIG_AFCAUTO_MASK                    0xEF
+#define RF_RXCONFIG_AFCAUTO_ON                      0x10
+#define RF_RXCONFIG_AFCAUTO_OFF                     0x00 // Default 
+
+#define RF_RXCONFIG_AGCAUTO_MASK                    0xF7
+#define RF_RXCONFIG_AGCAUTO_ON                      0x08 // Default
+#define RF_RXCONFIG_AGCAUTO_OFF                     0x00
+
+#define RF_RXCONFIG_RXTRIGER_MASK                   0xF8
+#define RF_RXCONFIG_RXTRIGER_OFF                    0x00
+#define RF_RXCONFIG_RXTRIGER_RSSI                   0x01
+#define RF_RXCONFIG_RXTRIGER_PREAMBLEDETECT         0x06 // Default
+#define RF_RXCONFIG_RXTRIGER_RSSI_PREAMBLEDETECT    0x07
+
+/*!
+ * RegRssiConfig
+ */
+#define RF_RSSICONFIG_OFFSET_MASK                   0x07
+#define RF_RSSICONFIG_OFFSET_P_00_DB                0x00  // Default
+#define RF_RSSICONFIG_OFFSET_P_01_DB                0x08
+#define RF_RSSICONFIG_OFFSET_P_02_DB                0x10
+#define RF_RSSICONFIG_OFFSET_P_03_DB                0x18
+#define RF_RSSICONFIG_OFFSET_P_04_DB                0x20
+#define RF_RSSICONFIG_OFFSET_P_05_DB                0x28
+#define RF_RSSICONFIG_OFFSET_P_06_DB                0x30
+#define RF_RSSICONFIG_OFFSET_P_07_DB                0x38
+#define RF_RSSICONFIG_OFFSET_P_08_DB                0x40
+#define RF_RSSICONFIG_OFFSET_P_09_DB                0x48
+#define RF_RSSICONFIG_OFFSET_P_10_DB                0x50
+#define RF_RSSICONFIG_OFFSET_P_11_DB                0x58
+#define RF_RSSICONFIG_OFFSET_P_12_DB                0x60
+#define RF_RSSICONFIG_OFFSET_P_13_DB                0x68
+#define RF_RSSICONFIG_OFFSET_P_14_DB                0x70
+#define RF_RSSICONFIG_OFFSET_P_15_DB                0x78
+#define RF_RSSICONFIG_OFFSET_M_16_DB                0x80
+#define RF_RSSICONFIG_OFFSET_M_15_DB                0x88
+#define RF_RSSICONFIG_OFFSET_M_14_DB                0x90
+#define RF_RSSICONFIG_OFFSET_M_13_DB                0x98
+#define RF_RSSICONFIG_OFFSET_M_12_DB                0xA0
+#define RF_RSSICONFIG_OFFSET_M_11_DB                0xA8
+#define RF_RSSICONFIG_OFFSET_M_10_DB                0xB0
+#define RF_RSSICONFIG_OFFSET_M_09_DB                0xB8
+#define RF_RSSICONFIG_OFFSET_M_08_DB                0xC0
+#define RF_RSSICONFIG_OFFSET_M_07_DB                0xC8
+#define RF_RSSICONFIG_OFFSET_M_06_DB                0xD0
+#define RF_RSSICONFIG_OFFSET_M_05_DB                0xD8
+#define RF_RSSICONFIG_OFFSET_M_04_DB                0xE0
+#define RF_RSSICONFIG_OFFSET_M_03_DB                0xE8
+#define RF_RSSICONFIG_OFFSET_M_02_DB                0xF0
+#define RF_RSSICONFIG_OFFSET_M_01_DB                0xF8
+
+#define RF_RSSICONFIG_SMOOTHING_MASK                0xF8
+#define RF_RSSICONFIG_SMOOTHING_2                   0x00
+#define RF_RSSICONFIG_SMOOTHING_4                   0x01
+#define RF_RSSICONFIG_SMOOTHING_8                   0x02  // Default
+#define RF_RSSICONFIG_SMOOTHING_16                  0x03
+#define RF_RSSICONFIG_SMOOTHING_32                  0x04
+#define RF_RSSICONFIG_SMOOTHING_64                  0x05
+#define RF_RSSICONFIG_SMOOTHING_128                 0x06
+#define RF_RSSICONFIG_SMOOTHING_256                 0x07
+
+/*!
+ * RegRssiCollision
+ */
+#define RF_RSSICOLISION_THRESHOLD                   0x0A  // Default
+
+/*!
+ * RegRssiThresh
+ */
+#define RF_RSSITHRESH_THRESHOLD                     0xFF  // Default
+
+/*!
+ * RegRssiValue (Read Only)
+ */
+
+/*!
+ * RegRxBw
+ */
+#define RF_RXBW_MANT_MASK                           0xE7
+#define RF_RXBW_MANT_16                             0x00  
+#define RF_RXBW_MANT_20                             0x08  
+#define RF_RXBW_MANT_24                             0x10  // Default 
+
+#define RF_RXBW_EXP_MASK                            0xF8 
+#define RF_RXBW_EXP_0                               0x00 
+#define RF_RXBW_EXP_1                               0x01 
+#define RF_RXBW_EXP_2                               0x02 
+#define RF_RXBW_EXP_3                               0x03 
+#define RF_RXBW_EXP_4                               0x04 
+#define RF_RXBW_EXP_5                               0x05  // Default
+#define RF_RXBW_EXP_6                               0x06  
+#define RF_RXBW_EXP_7                               0x07 
+
+/*!
+ * RegAfcBw
+ */
+#define RF_AFCBW_MANTAFC_MASK                       0xE7
+#define RF_AFCBW_MANTAFC_16                         0x00
+#define RF_AFCBW_MANTAFC_20                         0x08  // Default
+#define RF_AFCBW_MANTAFC_24                         0x10  
+
+#define RF_AFCBW_EXPAFC_MASK                        0xF8
+#define RF_AFCBW_EXPAFC_0                           0x00 
+#define RF_AFCBW_EXPAFC_1                           0x01 
+#define RF_AFCBW_EXPAFC_2                           0x02  
+#define RF_AFCBW_EXPAFC_3                           0x03  // Default
+#define RF_AFCBW_EXPAFC_4                           0x04 
+#define RF_AFCBW_EXPAFC_5                           0x05 
+#define RF_AFCBW_EXPAFC_6                           0x06  
+#define RF_AFCBW_EXPAFC_7                           0x07 
+
+/*!
+ * RegOokPeak
+ */
+#define RF_OOKPEAK_BITSYNC_MASK                     0xDF  // Default
+#define RF_OOKPEAK_BITSYNC_ON                       0x20  // Default
+#define RF_OOKPEAK_BITSYNC_OFF                      0x00
+
+#define RF_OOKPEAK_OOKTHRESHTYPE_MASK               0xE7
+#define RF_OOKPEAK_OOKTHRESHTYPE_FIXED              0x00
+#define RF_OOKPEAK_OOKTHRESHTYPE_PEAK               0x08  // Default
+#define RF_OOKPEAK_OOKTHRESHTYPE_AVERAGE            0x10
+
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_MASK           0xF8
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_0_5_DB         0x00  // Default
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_1_0_DB         0x01
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_1_5_DB         0x02
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_2_0_DB         0x03
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_3_0_DB         0x04
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_4_0_DB         0x05
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_5_0_DB         0x06
+#define RF_OOKPEAK_OOKPEAKTHRESHSTEP_6_0_DB         0x07
+
+/*!
+ * RegOokFix
+ */
+#define RF_OOKFIX_OOKFIXEDTHRESHOLD                 0x0C  // Default
+
+/*!
+ * RegOokAvg
+ */
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_MASK             0x1F
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_000              0x00  // Default
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_001              0x20
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_010              0x40
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_011              0x60
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_100              0x80
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_101              0xA0
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_110              0xC0
+#define RF_OOKAVG_OOKPEAKTHRESHDEC_111              0xE0
+
+#define RF_OOKAVG_AVERAGEOFFSET_MASK                0xF3
+#define RF_OOKAVG_AVERAGEOFFSET_0_DB                0x00  // Default
+#define RF_OOKAVG_AVERAGEOFFSET_2_DB                0x04
+#define RF_OOKAVG_AVERAGEOFFSET_4_DB                0x08
+#define RF_OOKAVG_AVERAGEOFFSET_6_DB                0x0C
+
+#define RF_OOKAVG_OOKAVERAGETHRESHFILT_MASK         0xFC
+#define RF_OOKAVG_OOKAVERAGETHRESHFILT_00           0x00
+#define RF_OOKAVG_OOKAVERAGETHRESHFILT_01           0x01
+#define RF_OOKAVG_OOKAVERAGETHRESHFILT_10           0x02  // Default
+#define RF_OOKAVG_OOKAVERAGETHRESHFILT_11           0x03
+
+/*!
+ * RegAfcFei
+ */
+#define RF_AFCFEI_AGCSTART                          0x10
+
+#define RF_AFCFEI_AFCCLEAR                          0x02
+
+#define RF_AFCFEI_AFCAUTOCLEAR_MASK                 0xFE
+#define RF_AFCFEI_AFCAUTOCLEAR_ON                   0x01
+#define RF_AFCFEI_AFCAUTOCLEAR_OFF                  0x00  // Default
+
+/*!
+ * RegAfcMsb (Read Only)
+ */
+ 
+/*!
+ * RegAfcLsb (Read Only)
+ */
+
+/*!
+ * RegFeiMsb (Read Only)
+ */
+
+/*!
+ * RegFeiLsb (Read Only)
+ */
+
+/*!
+ * RegPreambleDetect
+ */
+#define RF_PREAMBLEDETECT_DETECTOR_MASK             0x7F
+#define RF_PREAMBLEDETECT_DETECTOR_ON               0x80  // Default
+#define RF_PREAMBLEDETECT_DETECTOR_OFF              0x00
+
+#define RF_PREAMBLEDETECT_DETECTORSIZE_MASK         0x9F
+#define RF_PREAMBLEDETECT_DETECTORSIZE_1            0x00
+#define RF_PREAMBLEDETECT_DETECTORSIZE_2            0x20  // Default
+#define RF_PREAMBLEDETECT_DETECTORSIZE_3            0x40
+#define RF_PREAMBLEDETECT_DETECTORSIZE_4            0x60
+
+#define RF_PREAMBLEDETECT_DETECTORTOL_MASK          0xE0
+#define RF_PREAMBLEDETECT_DETECTORTOL_0             0x00
+#define RF_PREAMBLEDETECT_DETECTORTOL_1             0x01
+#define RF_PREAMBLEDETECT_DETECTORTOL_2             0x02
+#define RF_PREAMBLEDETECT_DETECTORTOL_3             0x03
+#define RF_PREAMBLEDETECT_DETECTORTOL_4             0x04
+#define RF_PREAMBLEDETECT_DETECTORTOL_5             0x05
+#define RF_PREAMBLEDETECT_DETECTORTOL_6             0x06
+#define RF_PREAMBLEDETECT_DETECTORTOL_7             0x07
+#define RF_PREAMBLEDETECT_DETECTORTOL_8             0x08
+#define RF_PREAMBLEDETECT_DETECTORTOL_9             0x09
+#define RF_PREAMBLEDETECT_DETECTORTOL_10            0x0A  // Default
+#define RF_PREAMBLEDETECT_DETECTORTOL_11            0x0B
+#define RF_PREAMBLEDETECT_DETECTORTOL_12            0x0C
+#define RF_PREAMBLEDETECT_DETECTORTOL_13            0x0D
+#define RF_PREAMBLEDETECT_DETECTORTOL_14            0x0E
+#define RF_PREAMBLEDETECT_DETECTORTOL_15            0x0F
+#define RF_PREAMBLEDETECT_DETECTORTOL_16            0x10
+#define RF_PREAMBLEDETECT_DETECTORTOL_17            0x11
+#define RF_PREAMBLEDETECT_DETECTORTOL_18            0x12
+#define RF_PREAMBLEDETECT_DETECTORTOL_19            0x13
+#define RF_PREAMBLEDETECT_DETECTORTOL_20            0x14
+#define RF_PREAMBLEDETECT_DETECTORTOL_21            0x15
+#define RF_PREAMBLEDETECT_DETECTORTOL_22            0x16
+#define RF_PREAMBLEDETECT_DETECTORTOL_23            0x17
+#define RF_PREAMBLEDETECT_DETECTORTOL_24            0x18
+#define RF_PREAMBLEDETECT_DETECTORTOL_25            0x19
+#define RF_PREAMBLEDETECT_DETECTORTOL_26            0x1A
+#define RF_PREAMBLEDETECT_DETECTORTOL_27            0x1B
+#define RF_PREAMBLEDETECT_DETECTORTOL_28            0x1C
+#define RF_PREAMBLEDETECT_DETECTORTOL_29            0x1D
+#define RF_PREAMBLEDETECT_DETECTORTOL_30            0x1E
+#define RF_PREAMBLEDETECT_DETECTORTOL_31            0x1F
+
+/*!
+ * RegRxTimeout1
+ */
+#define RF_RXTIMEOUT1_TIMEOUTRXRSSI                 0x00  // Default
+
+/*!
+ * RegRxTimeout2
+ */
+#define RF_RXTIMEOUT2_TIMEOUTRXPREAMBLE             0x00  // Default
+
+/*!
+ * RegRxTimeout3
+ */
+#define RF_RXTIMEOUT3_TIMEOUTSIGNALSYNC             0x00  // Default
+
+/*!
+ * RegRxDelay
+ */
+#define RF_RXDELAY_INTERPACKETRXDELAY               0x00  // Default
+
+/*!
+ * RegOsc
+ */
+#define RF_OSC_RCCALSTART                           0x08
+
+#define RF_OSC_CLKOUT_MASK                          0xF8
+#define RF_OSC_CLKOUT_32_MHZ                        0x00
+#define RF_OSC_CLKOUT_16_MHZ                        0x01
+#define RF_OSC_CLKOUT_8_MHZ                         0x02
+#define RF_OSC_CLKOUT_4_MHZ                         0x03
+#define RF_OSC_CLKOUT_2_MHZ                         0x04
+#define RF_OSC_CLKOUT_1_MHZ                         0x05  // Default
+#define RF_OSC_CLKOUT_RC                            0x06
+#define RF_OSC_CLKOUT_OFF                           0x07  
+
+/*!
+ * RegPreambleMsb/RegPreambleLsb
+ */
+#define RF_PREAMBLEMSB_SIZE                         0x00  // Default
+#define RF_PREAMBLELSB_SIZE                         0x03  // Default
+
+/*!
+ * RegSyncConfig
+ */
+#define RF_SYNCCONFIG_AUTORESTARTRXMODE_MASK        0x3F
+#define RF_SYNCCONFIG_AUTORESTARTRXMODE_WAITPLL_ON  0x80  // Default
+#define RF_SYNCCONFIG_AUTORESTARTRXMODE_WAITPLL_OFF 0x40
+#define RF_SYNCCONFIG_AUTORESTARTRXMODE_OFF         0x00
+
+
+#define RF_SYNCCONFIG_PREAMBLEPOLARITY_MASK         0xDF
+#define RF_SYNCCONFIG_PREAMBLEPOLARITY_55           0x20
+#define RF_SYNCCONFIG_PREAMBLEPOLARITY_AA           0x00  // Default
+
+#define RF_SYNCCONFIG_SYNC_MASK                     0xEF
+#define RF_SYNCCONFIG_SYNC_ON                       0x10  // Default
+#define RF_SYNCCONFIG_SYNC_OFF                      0x00
+
+
+#define RF_SYNCCONFIG_SYNCSIZE_MASK                 0xF8
+#define RF_SYNCCONFIG_SYNCSIZE_1                    0x00
+#define RF_SYNCCONFIG_SYNCSIZE_2                    0x01
+#define RF_SYNCCONFIG_SYNCSIZE_3                    0x02  
+#define RF_SYNCCONFIG_SYNCSIZE_4                    0x03  // Default
+#define RF_SYNCCONFIG_SYNCSIZE_5                    0x04
+#define RF_SYNCCONFIG_SYNCSIZE_6                    0x05
+#define RF_SYNCCONFIG_SYNCSIZE_7                    0x06
+#define RF_SYNCCONFIG_SYNCSIZE_8                    0x07
+
+/*!
+ * RegSyncValue1-8
+ */
+#define RF_SYNCVALUE1_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE2_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE3_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE4_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE5_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE6_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE7_SYNCVALUE                     0x01  // Default
+#define RF_SYNCVALUE8_SYNCVALUE                     0x01  // Default
+
+/*!
+ * RegPacketConfig1
+ */
+#define RF_PACKETCONFIG1_PACKETFORMAT_MASK          0x7F
+#define RF_PACKETCONFIG1_PACKETFORMAT_FIXED         0x00
+#define RF_PACKETCONFIG1_PACKETFORMAT_VARIABLE      0x80  // Default
+
+#define RF_PACKETCONFIG1_DCFREE_MASK                0x9F
+#define RF_PACKETCONFIG1_DCFREE_OFF                 0x00  // Default
+#define RF_PACKETCONFIG1_DCFREE_MANCHESTER          0x20
+#define RF_PACKETCONFIG1_DCFREE_WHITENING           0x40
+
+#define RF_PACKETCONFIG1_CRC_MASK                   0xEF
+#define RF_PACKETCONFIG1_CRC_ON                     0x10  // Default
+#define RF_PACKETCONFIG1_CRC_OFF                    0x00
+
+#define RF_PACKETCONFIG1_CRCAUTOCLEAR_MASK          0xF7
+#define RF_PACKETCONFIG1_CRCAUTOCLEAR_ON            0x00  // Default
+#define RF_PACKETCONFIG1_CRCAUTOCLEAR_OFF           0x08
+
+#define RF_PACKETCONFIG1_ADDRSFILTERING_MASK         0xF9
+#define RF_PACKETCONFIG1_ADDRSFILTERING_OFF          0x00  // Default
+#define RF_PACKETCONFIG1_ADDRSFILTERING_NODE         0x02
+#define RF_PACKETCONFIG1_ADDRSFILTERING_NODEBROADCAST 0x04
+
+#define RF_PACKETCONFIG1_CRCWHITENINGTYPE_MASK      0xFE
+#define RF_PACKETCONFIG1_CRCWHITENINGTYPE_CCITT     0x00  // Default
+#define RF_PACKETCONFIG1_CRCWHITENINGTYPE_IBM       0x01
+
+/*!
+ * RegPacketConfig2
+ */
+ 
+#define RF_PACKETCONFIG2_WMBUS_CRC_ENABLE_MASK      0x7F 
+#define RF_PACKETCONFIG2_WMBUS_CRC_ENABLE           0x80
+#define RF_PACKETCONFIG2_WMBUS_CRC_DISABLE          0x00  // Default
+
+#define RF_PACKETCONFIG2_DATAMODE_MASK              0xBF
+#define RF_PACKETCONFIG2_DATAMODE_CONTINUOUS        0x00
+#define RF_PACKETCONFIG2_DATAMODE_PACKET            0x40  // Default
+
+#define RF_PACKETCONFIG2_IOHOME_MASK                0xDF
+#define RF_PACKETCONFIG2_IOHOME_ON                  0x20
+#define RF_PACKETCONFIG2_IOHOME_OFF                 0x00  // Default
+
+#define RF_PACKETCONFIG2_BEACON_MASK                0xF7
+#define RF_PACKETCONFIG2_BEACON_ON                  0x08
+#define RF_PACKETCONFIG2_BEACON_OFF                 0x00  // Default
+
+#define RF_PACKETCONFIG2_PAYLOADLENGTH_MSB_MASK     0xF8
+
+/*!
+ * RegPayloadLength
+ */
+#define RF_PAYLOADLENGTH_LENGTH                     0x40  // Default
+
+/*!
+ * RegNodeAdrs
+ */
+#define RF_NODEADDRESS_ADDRESS                      0x00
+
+/*!
+ * RegBroadcastAdrs
+ */
+#define RF_BROADCASTADDRESS_ADDRESS                 0x00
+
+/*!
+ * RegFifoThresh
+ */
+#define RF_FIFOTHRESH_TXSTARTCONDITION_MASK         0x7F
+#define RF_FIFOTHRESH_TXSTARTCONDITION_FIFOTHRESH   0x00  // Default
+#define RF_FIFOTHRESH_TXSTARTCONDITION_FIFONOTEMPTY 0x80  
+
+#define RF_FIFOTHRESH_FIFOTHRESHOLD_MASK            0xC0
+#define RF_FIFOTHRESH_FIFOTHRESHOLD_THRESHOLD       0x0F  // Default
+
+/*!
+ * RegSeqConfig1
+ */
+#define RF_SEQCONFIG1_SEQUENCER_START               0x80
+
+#define RF_SEQCONFIG1_SEQUENCER_STOP                0x40
+
+#define RF_SEQCONFIG1_IDLEMODE_MASK                 0xDF
+#define RF_SEQCONFIG1_IDLEMODE_SLEEP                0x20
+#define RF_SEQCONFIG1_IDLEMODE_STANDBY              0x00  // Default
+
+#define RF_SEQCONFIG1_FROMSTART_MASK                0xE7
+#define RF_SEQCONFIG1_FROMSTART_TOLPS               0x00  // Default
+#define RF_SEQCONFIG1_FROMSTART_TORX                0x08
+#define RF_SEQCONFIG1_FROMSTART_TOTX                0x10
+#define RF_SEQCONFIG1_FROMSTART_TOTX_ONFIFOLEVEL    0x18
+
+#define RF_SEQCONFIG1_LPS_MASK                      0xFB
+#define RF_SEQCONFIG1_LPS_SEQUENCER_OFF             0x00  // Default
+#define RF_SEQCONFIG1_LPS_IDLE                      0x04
+
+#define RF_SEQCONFIG1_FROMIDLE_MASK                 0xFD
+#define RF_SEQCONFIG1_FROMIDLE_TOTX                 0x00  // Default
+#define RF_SEQCONFIG1_FROMIDLE_TORX                 0x02
+
+#define RF_SEQCONFIG1_FROMTX_MASK                   0xFE
+#define RF_SEQCONFIG1_FROMTX_TOLPS                  0x00  // Default
+#define RF_SEQCONFIG1_FROMTX_TORX                   0x01
+
+/*!
+ * RegSeqConfig2
+ */
+#define RF_SEQCONFIG2_FROMRX_MASK                   0x1F
+#define RF_SEQCONFIG2_FROMRX_TOUNUSED_000           0x00  // Default
+#define RF_SEQCONFIG2_FROMRX_TORXPKT_ONPLDRDY       0x20
+#define RF_SEQCONFIG2_FROMRX_TOLPS_ONPLDRDY         0x40
+#define RF_SEQCONFIG2_FROMRX_TORXPKT_ONCRCOK        0x60
+#define RF_SEQCONFIG2_FROMRX_TOSEQUENCEROFF_ONRSSI  0x80
+#define RF_SEQCONFIG2_FROMRX_TOSEQUENCEROFF_ONSYNC  0xA0
+#define RF_SEQCONFIG2_FROMRX_TOSEQUENCEROFF_ONPREAMBLE 0xC0
+#define RF_SEQCONFIG2_FROMRX_TOUNUSED_111           0xE0
+
+#define RF_SEQCONFIG2_FROMRXTIMEOUT_MASK            0xE7
+#define RF_SEQCONFIG2_FROMRXTIMEOUT_TORXRESTART     0x00  // Default
+#define RF_SEQCONFIG2_FROMRXTIMEOUT_TOTX            0x08
+#define RF_SEQCONFIG2_FROMRXTIMEOUT_TOLPS           0x10
+#define RF_SEQCONFIG2_FROMRXTIMEOUT_TOSEQUENCEROFF  0x18
+
+#define RF_SEQCONFIG2_FROMRXPKT_MASK                0xF8
+#define RF_SEQCONFIG2_FROMRXPKT_TOSEQUENCEROFF      0x00  // Default
+#define RF_SEQCONFIG2_FROMRXPKT_TOTX_ONFIFOEMPTY    0x01
+#define RF_SEQCONFIG2_FROMRXPKT_TOLPS               0x02
+#define RF_SEQCONFIG2_FROMRXPKT_TOSYNTHESIZERRX     0x03
+#define RF_SEQCONFIG2_FROMRXPKT_TORX                0x04
+
+/*!
+ * RegTimerResol
+ */
+#define RF_TIMERRESOL_TIMER1RESOL_MASK              0xF3
+#define RF_TIMERRESOL_TIMER1RESOL_OFF               0x00  // Default
+#define RF_TIMERRESOL_TIMER1RESOL_000064_US         0x04
+#define RF_TIMERRESOL_TIMER1RESOL_004100_US         0x08
+#define RF_TIMERRESOL_TIMER1RESOL_262000_US         0x0C
+
+#define RF_TIMERRESOL_TIMER2RESOL_MASK              0xFC
+#define RF_TIMERRESOL_TIMER2RESOL_OFF               0x00  // Default
+#define RF_TIMERRESOL_TIMER2RESOL_000064_US         0x01
+#define RF_TIMERRESOL_TIMER2RESOL_004100_US         0x02
+#define RF_TIMERRESOL_TIMER2RESOL_262000_US         0x03
+
+/*!
+ * RegTimer1Coef
+ */
+#define RF_TIMER1COEF_TIMER1COEFFICIENT             0xF5  // Default
+
+/*!
+ * RegTimer2Coef
+ */
+#define RF_TIMER2COEF_TIMER2COEFFICIENT             0x20  // Default
+
+/*!
+ * RegImageCal
+ */
+#define RF_IMAGECAL_AUTOIMAGECAL_MASK               0x7F
+#define RF_IMAGECAL_AUTOIMAGECAL_ON                 0x80
+#define RF_IMAGECAL_AUTOIMAGECAL_OFF                0x00  // Default
+
+#define RF_IMAGECAL_IMAGECAL_MASK                   0xBF
+#define RF_IMAGECAL_IMAGECAL_START                  0x40
+
+#define RF_IMAGECAL_IMAGECAL_RUNNING                0x20
+#define RF_IMAGECAL_IMAGECAL_DONE                   0x00  // Default
+
+#define RF_IMAGECAL_TEMPCHANGE_HIGHER               0x08
+#define RF_IMAGECAL_TEMPCHANGE_LOWER                0x00
+
+#define RF_IMAGECAL_TEMPTHRESHOLD_MASK              0xF9
+#define RF_IMAGECAL_TEMPTHRESHOLD_05                0x00
+#define RF_IMAGECAL_TEMPTHRESHOLD_10                0x02  // Default
+#define RF_IMAGECAL_TEMPTHRESHOLD_15                0x04
+#define RF_IMAGECAL_TEMPTHRESHOLD_20                0x06
+
+#define RF_IMAGECAL_TEMPMONITOR_MASK                0xFE
+#define RF_IMAGECAL_TEMPMONITOR_ON                  0x00 // Default
+#define RF_IMAGECAL_TEMPMONITOR_OFF                 0x01
+
+/*!
+ * RegTemp (Read Only)
+ */
+
+/*!
+ * RegLowBat
+ */
+#define RF_LOWBAT_MASK                              0xF7
+#define RF_LOWBAT_ON                                0x08
+#define RF_LOWBAT_OFF                               0x00  // Default
+
+#define RF_LOWBAT_TRIM_MASK                         0xF8
+#define RF_LOWBAT_TRIM_1695                         0x00
+#define RF_LOWBAT_TRIM_1764                         0x01
+#define RF_LOWBAT_TRIM_1835                         0x02  // Default
+#define RF_LOWBAT_TRIM_1905                         0x03
+#define RF_LOWBAT_TRIM_1976                         0x04
+#define RF_LOWBAT_TRIM_2045                         0x05
+#define RF_LOWBAT_TRIM_2116                         0x06
+#define RF_LOWBAT_TRIM_2185                         0x07
+
+/*!
+ * RegIrqFlags1
+ */
+#define RF_IRQFLAGS1_MODEREADY                      0x80
+
+#define RF_IRQFLAGS1_RXREADY                        0x40
+
+#define RF_IRQFLAGS1_TXREADY                        0x20
+
+#define RF_IRQFLAGS1_PLLLOCK                        0x10
+
+#define RF_IRQFLAGS1_RSSI                           0x08
+
+#define RF_IRQFLAGS1_TIMEOUT                        0x04
+
+#define RF_IRQFLAGS1_PREAMBLEDETECT                 0x02
+
+#define RF_IRQFLAGS1_SYNCADDRESSMATCH               0x01
+
+/*!
+ * RegIrqFlags2
+ */
+#define RF_IRQFLAGS2_FIFOFULL                       0x80
+
+#define RF_IRQFLAGS2_FIFOEMPTY                      0x40
+
+#define RF_IRQFLAGS2_FIFOLEVEL                      0x20
+
+#define RF_IRQFLAGS2_FIFOOVERRUN                    0x10
+
+#define RF_IRQFLAGS2_PACKETSENT                     0x08
+
+#define RF_IRQFLAGS2_PAYLOADREADY                   0x04
+
+#define RF_IRQFLAGS2_CRCOK                          0x02
+
+#define RF_IRQFLAGS2_LOWBAT                         0x01
+
+/*!
+ * RegDioMapping1
+ */
+#define RF_DIOMAPPING1_DIO0_MASK                    0x3F
+#define RF_DIOMAPPING1_DIO0_00                      0x00  // Default
+#define RF_DIOMAPPING1_DIO0_01                      0x40
+#define RF_DIOMAPPING1_DIO0_10                      0x80
+#define RF_DIOMAPPING1_DIO0_11                      0xC0
+
+#define RF_DIOMAPPING1_DIO1_MASK                    0xCF
+#define RF_DIOMAPPING1_DIO1_00                      0x00  // Default
+#define RF_DIOMAPPING1_DIO1_01                      0x10
+#define RF_DIOMAPPING1_DIO1_10                      0x20
+#define RF_DIOMAPPING1_DIO1_11                      0x30
+
+#define RF_DIOMAPPING1_DIO2_MASK                    0xF3
+#define RF_DIOMAPPING1_DIO2_00                      0x00  // Default
+#define RF_DIOMAPPING1_DIO2_01                      0x04
+#define RF_DIOMAPPING1_DIO2_10                      0x08
+#define RF_DIOMAPPING1_DIO2_11                      0x0C
+
+#define RF_DIOMAPPING1_DIO3_MASK                    0xFC
+#define RF_DIOMAPPING1_DIO3_00                      0x00  // Default
+#define RF_DIOMAPPING1_DIO3_01                      0x01
+#define RF_DIOMAPPING1_DIO3_10                      0x02
+#define RF_DIOMAPPING1_DIO3_11                      0x03
+
+/*!
+ * RegDioMapping2
+ */
+#define RF_DIOMAPPING2_DIO4_MASK                    0x3F
+#define RF_DIOMAPPING2_DIO4_00                      0x00  // Default
+#define RF_DIOMAPPING2_DIO4_01                      0x40
+#define RF_DIOMAPPING2_DIO4_10                      0x80
+#define RF_DIOMAPPING2_DIO4_11                      0xC0
+
+#define RF_DIOMAPPING2_DIO5_MASK                    0xCF
+#define RF_DIOMAPPING2_DIO5_00                      0x00  // Default
+#define RF_DIOMAPPING2_DIO5_01                      0x10
+#define RF_DIOMAPPING2_DIO5_10                      0x20
+#define RF_DIOMAPPING2_DIO5_11                      0x30
+
+#define RF_DIOMAPPING2_MAP_MASK                     0xFE
+#define RF_DIOMAPPING2_MAP_PREAMBLEDETECT           0x01
+#define RF_DIOMAPPING2_MAP_RSSI                     0x00  // Default
+
+/*!
+ * RegVersion (Read Only)
+ */
+
+/*!
+ * RegAgcRef
+ */
+
+/*!
+ * RegAgcThresh1
+ */
+
+/*!
+ * RegAgcThresh2
+ */
+
+/*!
+ * RegAgcThresh3
+ */
+
+/*!
+ * RegPllHop
+ */
+#define RF_PLLHOP_FASTHOP_MASK                      0x7F
+#define RF_PLLHOP_FASTHOP_ON                        0x80
+#define RF_PLLHOP_FASTHOP_OFF                       0x00 // Default
+
+/*!
+ * RegTcxo
+ */
+#define RF_TCXO_TCXOINPUT_MASK                      0xEF
+#define RF_TCXO_TCXOINPUT_ON                        0x10
+#define RF_TCXO_TCXOINPUT_OFF                       0x00  // Default
+
+/*!
+ * RegPaDac
+ */
+#define RF_PADAC_20DBM_MASK                         0xF8
+#define RF_PADAC_20DBM_ON                           0x07
+#define RF_PADAC_20DBM_OFF                          0x04  // Default
+
+/*!
+ * RegPll
+ */
+#define RF_PLL_BANDWIDTH_MASK                       0x3F
+#define RF_PLL_BANDWIDTH_75                         0x00
+#define RF_PLL_BANDWIDTH_150                        0x40
+#define RF_PLL_BANDWIDTH_225                        0x80
+#define RF_PLL_BANDWIDTH_300                        0xC0  // Default
+
+/*!
+ * RegPllLowPn
+ */
+#define RF_PLLLOWPN_BANDWIDTH_MASK                  0x3F
+#define RF_PLLLOWPN_BANDWIDTH_75                    0x00
+#define RF_PLLLOWPN_BANDWIDTH_150                   0x40
+#define RF_PLLLOWPN_BANDWIDTH_225                   0x80
+#define RF_PLLLOWPN_BANDWIDTH_300                   0xC0  // Default
+
+/*!
+ * RegFormerTemp
+ */
+
+/*!
+ * RegBitrateFrac
+ */
+#define RF_BITRATEFRAC_MASK                         0xF0
+
+typedef struct sSX1276
+{
+    uint8_t RegFifo;                                // 0x00
+    // Common settings
+    uint8_t RegOpMode;                              // 0x01
+    uint8_t RegBitrateMsb;                          // 0x02
+    uint8_t RegBitrateLsb;                          // 0x03
+    uint8_t RegFdevMsb;                             // 0x04
+    uint8_t RegFdevLsb;                             // 0x05
+    uint8_t RegFrfMsb;                              // 0x06
+    uint8_t RegFrfMid;                              // 0x07
+    uint8_t RegFrfLsb;                              // 0x08
+    // Tx settings
+    uint8_t RegPaConfig;                            // 0x09
+    uint8_t RegPaRamp;                              // 0x0A
+    uint8_t RegOcp;                                 // 0x0B
+    // Rx settings
+    uint8_t RegLna;                                 // 0x0C
+    uint8_t RegRxConfig;                            // 0x0D
+    uint8_t RegRssiConfig;                          // 0x0E
+    uint8_t RegRssiCollision;                       // 0x0F
+    uint8_t RegRssiThresh;                          // 0x10
+    uint8_t RegRssiValue;                           // 0x11
+    uint8_t RegRxBw;                                // 0x12
+    uint8_t RegAfcBw;                               // 0x13
+    uint8_t RegOokPeak;                             // 0x14
+    uint8_t RegOokFix;                              // 0x15
+    uint8_t RegOokAvg;                              // 0x16
+    uint8_t RegRes17;                               // 0x17
+    uint8_t RegRes18;                               // 0x18
+    uint8_t RegRes19;                               // 0x19
+    uint8_t RegAfcFei;                              // 0x1A
+    uint8_t RegAfcMsb;                              // 0x1B
+    uint8_t RegAfcLsb;                              // 0x1C
+    uint8_t RegFeiMsb;                              // 0x1D
+    uint8_t RegFeiLsb;                              // 0x1E
+    uint8_t RegPreambleDetect;                      // 0x1F
+    uint8_t RegRxTimeout1;                          // 0x20
+    uint8_t RegRxTimeout2;                          // 0x21
+    uint8_t RegRxTimeout3;                          // 0x22
+    uint8_t RegRxDelay;                             // 0x23
+    // Oscillator settings
+    uint8_t RegOsc;                                 // 0x24
+    // Packet handler settings
+    uint8_t RegPreambleMsb;                         // 0x25
+    uint8_t RegPreambleLsb;                         // 0x26
+    uint8_t RegSyncConfig;                          // 0x27
+    uint8_t RegSyncValue1;                          // 0x28
+    uint8_t RegSyncValue2;                          // 0x29
+    uint8_t RegSyncValue3;                          // 0x2A
+    uint8_t RegSyncValue4;                          // 0x2B
+    uint8_t RegSyncValue5;                          // 0x2C
+    uint8_t RegSyncValue6;                          // 0x2D
+    uint8_t RegSyncValue7;                          // 0x2E
+    uint8_t RegSyncValue8;                          // 0x2F
+    uint8_t RegPacketConfig1;                       // 0x30
+    uint8_t RegPacketConfig2;                       // 0x31
+    uint8_t RegPayloadLength;                       // 0x32
+    uint8_t RegNodeAdrs;                            // 0x33
+    uint8_t RegBroadcastAdrs;                       // 0x34
+    uint8_t RegFifoThresh;                          // 0x35
+    // Sequencer settings
+    uint8_t RegSeqConfig1;                          // 0x36
+    uint8_t RegSeqConfig2;                          // 0x37
+    uint8_t RegTimerResol;                          // 0x38
+    uint8_t RegTimer1Coef;                          // 0x39
+    uint8_t RegTimer2Coef;                          // 0x3A
+    // Service settings
+    uint8_t RegImageCal;                            // 0x3B
+    uint8_t RegTemp;                                // 0x3C
+    uint8_t RegLowBat;                              // 0x3D
+    // Status
+    uint8_t RegIrqFlags1;                           // 0x3E
+    uint8_t RegIrqFlags2;                           // 0x3F
+    // I/O settings
+    uint8_t RegDioMapping1;                         // 0x40
+    uint8_t RegDioMapping2;                         // 0x41
+    // Version
+    uint8_t RegVersion;                             // 0x42
+    // Additional settings
+    uint8_t RegAgcRef;                              // 0x43
+    uint8_t RegAgcThresh1;                          // 0x44
+    uint8_t RegAgcThresh2;                          // 0x45
+    uint8_t RegAgcThresh3;                          // 0x46
+    // Test
+    uint8_t RegTestReserved47[0x4B - 0x47];         // 0x47-0x4A
+    // Additional settings
+    uint8_t RegPllHop;                              // 0x4B
+    uint8_t RegTestReserved4C;                      // 0x4C
+    uint8_t RegPaDac;                               // 0x4D
+    // Test
+    uint8_t RegTestReserved4E[0x58-0x4E];           // 0x4E-0x57
+    // Additional settings
+    uint8_t RegTcxo;                                // 0x58
+    // Test
+    uint8_t RegTestReserved59;                      // 0x59
+    // Test
+    uint8_t RegTestReserved5B;                      // 0x5B
+    // Additional settings
+    uint8_t RegPll;                                 // 0x5C
+    // Test
+    uint8_t RegTestReserved5D;                      // 0x5D
+    // Additional settings
+    uint8_t RegPllLowPn;                            // 0x5E
+    // Test
+    uint8_t RegTestReserved5F[0x6C - 0x5F];         // 0x5F-0x6B
+    // Additional settings
+    uint8_t RegFormerTemp;                          // 0x6C
+    // Test
+    uint8_t RegTestReserved6D[0x70 - 0x6D];         // 0x6D-0x6F
+    // Additional settings
+    uint8_t RegBitrateFrac;                         // 0x70
+}tSX1276;
+
+extern tSX1276* SX1276;
+
+/*!
+ * \brief Initializes the SX1276
+ */
+void SX1276FskInit( void );
+
+/*!
+ * \brief Sets the SX1276 to datasheet default values
+ */
+void SX1276FskSetDefaults( void );
+
+/*!
+ * \brief Resets the SX1276
+ */
+void SX1276FskReset( void );
+
+/*!
+ * \brief Enables/Disables the LoRa modem
+ *
+ * \param [IN]: enable [true, false]
+ */
+void SX1276FskSetLoRaOn( bool enable );
+
+/*!
+ * \brief Sets the SX1276 operating mode
+ *
+ * \param [IN] opMode New operating mode
+ */
+void SX1276FskSetOpMode( uint8_t opMode );
+
+/*!
+ * \brief Gets the SX1276 operating mode
+ *
+ * \retval opMode Current operating mode
+ */
+uint8_t SX1276FskGetOpMode( void );
+
+/*!
+ * \brief Trigs and reads the FEI
+ *
+ * \retval feiValue Frequency error value.
+ */
+int32_t SX1276FskReadFei( void );
+
+/*!
+ * \brief Reads the current AFC value
+ *
+ * \retval afcValue Frequency offset value.
+ */
+int32_t SX1276FskReadAfc( void );
+
+/*!
+ * \brief Reads the current Rx gain setting
+ *
+ * \retval rxGain Current gain setting
+ */
+uint8_t SX1276FskReadRxGain( void );
+
+/*!
+ * \brief Trigs and reads the current RSSI value
+ *
+ * \retval rssiValue Current RSSI value in [dBm]
+ */
+double SX1276FskReadRssi( void );
+
+/*!
+ * \brief Gets the Rx gain value measured while receiving the packet
+ *
+ * \retval rxGainValue Current Rx gain value
+ */
+uint8_t SX1276FskGetPacketRxGain( void );
+
+/*!
+ * \brief Gets the RSSI value measured while receiving the packet
+ *
+ * \retval rssiValue Current RSSI value in [dBm]
+ */
+double SX1276FskGetPacketRssi( void );
+
+/*!
+ * \brief Gets the AFC value measured while receiving the packet
+ *
+ * \retval afcValue Current AFC value in [Hz]
+ */
+uint32_t SX1276FskGetPacketAfc( void );
+
+/*!
+ * \brief Sets the radio in Rx mode. Waiting for a packet
+ */
+void SX1276FskStartRx( void );
+
+/*!
+ * \brief Gets a copy of the current received buffer
+ *
+ * \param [IN]: buffer     Buffer pointer
+ * \param [IN]: size       Buffer size
+ */
+void SX1276FskGetRxPacket( void *buffer, uint16_t *size );
+
+/*!
+ * \brief Sets a copy of the buffer to be transmitted and starts the
+ *        transmission
+ *
+ * \param [IN]: buffer     Buffer pointer
+ * \param [IN]: size       Buffer size
+ */
+void SX1276FskSetTxPacket( const void *buffer, uint16_t size );
+
+/*!
+ * \brief Gets the current RFState
+ *
+ * \retval rfState Current RF state [RF_IDLE, RF_BUSY, 
+ *                                   RF_RX_DONE, RF_RX_TIMEOUT,
+ *                                   RF_TX_DONE, RF_TX_TIMEOUT]
+ */
+uint8_t SX1276FskGetRFState( void );
+
+/*!
+ * \brief Sets the new state of the RF state machine
+ *
+ * \param [IN]: state New RF state machine state
+ */
+void SX1276FskSetRFState( uint8_t state );
+
+/*!
+ * \brief Process the FSK modem Rx and Tx state machines depending on the
+ *       SX1276 operating mode.
+ *
+ * \retval rfState Current RF state [RF_IDLE, RF_BUSY, 
+ *                                   RF_RX_DONE, RF_RX_TIMEOUT,
+ *                                   RF_TX_DONE, RF_TX_TIMEOUT]
+ */
+uint32_t SX1276FskProcess( void );
+
+#endif //__SX1276_FSK_H__

APP/network_mgr/lora/Radio/inc/sx1276-FskMisc.h

@@ -0,0 +1,242 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276-FskMisc.h
+ * \brief      SX1276 RF chip high level functions driver
+ *
+ * \remark     Optional support functions.
+ *             These functions are defined only to easy the change of the
+ *             parameters.
+ *             For a final firmware the radio parameters will be known so
+ *             there is no need to support all possible parameters.
+ *             Removing these functions will greatly reduce the final firmware
+ *             size.
+ *
+ * \version    2.0.B2 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#ifndef __SX1276_FSK_MISC_H__
+#define __SX1276_FSK_MISC_H__
+
+/*!
+ * \brief Writes the new RF frequency value
+ *
+ * \param [IN] freq New RF frequency value in [Hz]
+ */
+void SX1276FskSetRFFrequency( uint32_t freq );
+
+/*!
+ * \brief Reads the current RF frequency value
+ *
+ * \retval freq Current RF frequency value in [Hz]
+ */
+uint32_t SX1276FskGetRFFrequency( void );
+
+/*!
+ * \brief Calibrate RSSI and I/Q mismatch for HF 
+ *
+ * \retval none
+ */
+void SX1276FskRxCalibrate( void );
+
+/*!
+ * \brief Writes the new bitrate value
+ *
+ * \param [IN] bitrate New bitrate value in [bps]
+ */
+void SX1276FskSetBitrate( uint32_t bitrate );
+
+/*!
+ * \brief Reads the current bitrate value
+ *
+ * \retval bitrate Current bitrate value in [bps]
+ */
+uint32_t SX1276FskGetBitrate( void );
+
+/*!
+ * \brief Writes the new frequency deviation value
+ *
+ * \param [IN] fdev New frequency deviation value in [Hz]
+ */
+void SX1276FskSetFdev( uint32_t fdev );
+
+/*!
+ * \brief Reads the current frequency deviation value
+ *
+ * \retval fdev Current frequency deviation value in [Hz]
+ */
+uint32_t SX1276FskGetFdev( void );
+
+/*!
+ * \brief Writes the new RF output power value
+ *
+ * \param [IN] power New output power value in [dBm]
+ */
+void SX1276FskSetRFPower( int8_t power );
+
+/*!
+ * \brief Reads the current RF output power value
+ *
+ * \retval power Current output power value in [dBm]
+ */
+int8_t SX1276FskGetRFPower( void );
+
+/*!
+ * \brief Writes the DC offset canceller and Rx bandwidth values
+ *
+ * \remark For SX1276 there is no DCC setting. dccValue should be 0
+ *         ie: SX1276SetDccBw( &SX1276.RegRxBw, 0, 62500 );
+ *
+ * \param [IN] reg Register pointer to either SX1231.RegRxBw or SX1231.RegAfcBw
+ * \param [IN] dccValue New DC offset canceller value in [Hz] ( SX1231 only )
+ * \param [IN] rxBwValue New Rx bandwidth value in [Hz]
+ */
+void SX1276FskSetDccBw( uint8_t* reg, uint32_t dccValue, uint32_t rxBwValue );
+
+/*!
+ * \brief Reads the current bandwidth setting
+ *
+ * \param [IN] reg Register pointer to either SX1231.RegRxBw or SX1231.RegAfcBw
+ *
+ * \retval bandwidth Bandwidth value
+ */
+uint32_t SX1276FskGetBw( uint8_t* reg );
+
+/*!
+ * \brief Enables/Disables CRC
+ *
+ * \param [IN] enable CRC enable/disable
+ */
+void SX1276FskSetPacketCrcOn( bool enable );
+
+/*!
+ * \brief Reads the current CRC Enable/Disbale value
+ *
+ * \retval enable Current CRC Enable/Disbale value
+ */
+bool SX1276FskGetPacketCrcOn( void );
+
+/*!
+ * \brief Enables/Disables AFC
+ *
+ * \param [IN] enable AFC enable/disable
+ */
+void SX1276FskSetAfcOn( bool enable );
+
+/*!
+ * \brief Reads the current AFC Enable/Disbale value
+ *
+ * \retval enable Current AFC Enable/Disbale value
+ */
+bool SX1276FskGetAfcOn( void );
+
+/*!
+ * \brief Writes the new payload length value
+ *
+ * \param [IN] value New payload length value
+ */
+void SX1276FskSetPayloadLength( uint8_t value );
+
+/*!
+ * \brief Reads the current payload length value
+ *
+ * \retval value Current payload length value
+ */
+uint8_t SX1276FskGetPayloadLength( void );
+
+/*!
+ * \brief Enables/Disables the 20 dBm PA
+ *
+ * \param [IN] enable [true, false]
+ */
+void SX1276FskSetPa20dBm( bool enale );
+
+/*!
+ * \brief Gets the current 20 dBm PA status
+ *
+ * \retval enable [true, false]
+ */
+bool SX1276FskGetPa20dBm( void );
+
+/*!
+ * \brief Set the RF Output pin 
+ *
+ * \param [IN] RF_PACONFIG_PASELECT_PABOOST or RF_PACONFIG_PASELECT_RFO
+ */
+void SX1276FskSetPAOutput( uint8_t outputPin );
+
+/*!
+ * \brief Gets the used RF Ouptu pin
+ *
+ * \retval RF_PACONFIG_PASELECT_PABOOST or RF_PACONFIG_PASELECT_RFO
+ */
+uint8_t SX1276FskGetPAOutput( void );
+
+/*!
+ * \brief Writes the new PA rise/fall time of ramp up/down value
+ *
+ * \param [IN] value New PaRamp value
+ */
+void SX1276FskSetPaRamp( uint8_t value );
+
+/*!
+ * \brief Reads the current PA rise/fall time of ramp up/down value
+ *
+ * \retval value Current PaRamp value
+ */
+uint8_t SX1276FskGetPaRamp( void );
+
+/*!
+ * \brief Applies an offset to the RSSI. Compensates board components
+ *
+ * \param [IN] offset Offset to be applied (+/-)
+ */
+void SX1276FskSetRssiOffset( int8_t offset );
+
+/*!
+ * \brief Gets the current RSSI offset.
+ *
+ * \retval offset Current offset (+/-)
+ */
+int8_t SX1276FskGetRssiOffset( void );
+
+/*!
+ * \brief Writes the new value for the preamble size
+ *
+ * \param [IN] size New value of pramble size
+ */
+void SX1276FskSetPreambleSize( uint16_t size );
+
+/*!
+ * Reads the raw temperature
+ * \retval temperature New raw temperature reading in 2's complement format
+ */
+int8_t SX1276FskGetRawTemp( void );
+
+/*!
+ * Computes the temperature compensation factor
+ * \param [IN] actualTemp Actual temperature measured by an external device
+ * \retval compensationFactor Computed compensation factor
+ */
+int8_t SX1276FskCalibreateTemp( int8_t actualTemp );
+
+/*!
+ * Gets the actual compensated temperature
+ * \param [IN] compensationFactor Return value of the calibration function
+ * \retval New compensated temperature value
+ */
+int8_t SX1276FskGetTemp( int8_t compensationFactor );
+
+#endif //__SX1276_FSK_MISC_H__
+

APP/network_mgr/lora/Radio/inc/sx1276-Hal.h

@@ -0,0 +1,162 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276-Hal.h
+ * \brief      SX1276 Hardware Abstraction Layer
+ *
+ * \version    2.0.B2 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#ifndef __SX1276_HAL_H__
+#define __SX1276_HAL_H__
+
+//#include "ioe.h"
+
+/*!
+ * DIO state read functions mapping
+ */
+#define DIO0                                        SX1276ReadDio0( )
+#define DIO1                                        SX1276ReadDio1( )
+#define DIO2                                        SX1276ReadDio2( )
+#define DIO3                                        SX1276ReadDio3( )
+#define DIO4                                        SX1276ReadDio4( )
+#define DIO5                                        SX1276ReadDio5( )
+
+// RXTX pin control see errata note
+#define RXTX( txEnable )                            SX1276WriteRxTx( txEnable );
+
+#define GET_TICK_COUNT( )                           ( TickCounter )
+#define TICK_RATE_MS( ms )                          ( ms )
+
+typedef enum
+{
+    RADIO_RESET_OFF,
+    RADIO_RESET_ON,
+}tRadioResetState;
+
+/*!
+ * \brief Initializes the radio interface I/Os
+ */
+void SX1276InitIo( void );
+
+/*!
+ * \brief Set the radio reset pin state
+ * 
+ * \param state New reset pin state
+ */
+void SX1276SetReset( uint8_t state );
+
+/*!
+ * \brief Writes the radio register at the specified address
+ *
+ * \param [IN]: addr Register address
+ * \param [IN]: data New register value
+ */
+void SX1276Write( uint8_t addr, uint8_t data );
+
+/*!
+ * \brief Reads the radio register at the specified address
+ *
+ * \param [IN]: addr Register address
+ * \param [OUT]: data Register value
+ */
+void SX1276Read( uint8_t addr, uint8_t *data );
+
+/*!
+ * \brief Writes multiple radio registers starting at address
+ *
+ * \param [IN] addr   First Radio register address
+ * \param [IN] buffer Buffer containing the new register's values
+ * \param [IN] size   Number of registers to be written
+ */
+void SX1276WriteBuffer( uint8_t addr, uint8_t *buffer, uint8_t size );
+
+/*!
+ * \brief Reads multiple radio registers starting at address
+ *
+ * \param [IN] addr First Radio register address
+ * \param [OUT] buffer Buffer where to copy the registers data
+ * \param [IN] size Number of registers to be read
+ */
+void SX1276ReadBuffer( uint8_t addr, uint8_t *buffer, uint8_t size );
+
+/*!
+ * \brief Writes the buffer contents to the radio FIFO
+ *
+ * \param [IN] buffer Buffer containing data to be put on the FIFO.
+ * \param [IN] size Number of bytes to be written to the FIFO
+ */
+void SX1276WriteFifo( uint8_t *buffer, uint8_t size );
+
+/*!
+ * \brief Reads the contents of the radio FIFO
+ *
+ * \param [OUT] buffer Buffer where to copy the FIFO read data.
+ * \param [IN] size Number of bytes to be read from the FIFO
+ */
+void SX1276ReadFifo( uint8_t *buffer, uint8_t size );
+
+/*!
+ * \brief Gets the SX1276 DIO0 hardware pin status
+ *
+ * \retval status Current hardware pin status [1, 0]
+ */
+inline uint8_t SX1276ReadDio0( void );
+
+/*!
+ * \brief Gets the SX1276 DIO1 hardware pin status
+ *
+ * \retval status Current hardware pin status [1, 0]
+ */
+inline uint8_t SX1276ReadDio1( void );
+
+/*!
+ * \brief Gets the SX1276 DIO2 hardware pin status
+ *
+ * \retval status Current hardware pin status [1, 0]
+ */
+inline uint8_t SX1276ReadDio2( void );
+
+/*!
+ * \brief Gets the SX1276 DIO3 hardware pin status
+ *
+ * \retval status Current hardware pin status [1, 0]
+ */
+inline uint8_t SX1276ReadDio3( void );
+
+/*!
+ * \brief Gets the SX1276 DIO4 hardware pin status
+ *
+ * \retval status Current hardware pin status [1, 0]
+ */
+inline uint8_t SX1276ReadDio4( void );
+
+/*!
+ * \brief Gets the SX1276 DIO5 hardware pin status
+ *
+ * \retval status Current hardware pin status [1, 0]
+ */
+inline uint8_t SX1276ReadDio5( void );
+
+/*!
+ * \brief Writes the external RxTx pin value
+ *
+ * \remark see errata note
+ *
+ * \param [IN] txEnable [1: Tx, 0: Rx]
+ */
+inline void SX1276WriteRxTx( uint8_t txEnable );
+
+#endif //__SX1276_HAL_H__
+

APP/network_mgr/lora/Radio/inc/sx1276-LoRa.h

@@ -0,0 +1,923 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276-LoRa.h
+ * \brief      SX1276 RF chip driver mode LoRa
+ *
+ * \version    2.0.B2 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#ifndef __SX1276_LORA_H__
+#define __SX1276_LORA_H__
+
+/*!
+ * SX1276 LoRa General parameters definition
+ */
+typedef struct sLoRaSettings
+{
+    uint32_t RFFrequency;
+    int8_t Power;
+    uint8_t SignalBw;                   // LORA [0: 7.8 kHz, 1: 10.4 kHz, 2: 15.6 kHz, 3: 20.8 kHz, 4: 31.2 kHz,
+                                        // 5: 41.6 kHz, 6: 62.5 kHz, 7: 125 kHz, 8: 250 kHz, 9: 500 kHz, other: Reserved]  
+    uint8_t SpreadingFactor;            // LORA [6: 64, 7: 128, 8: 256, 9: 512, 10: 1024, 11: 2048, 12: 4096  chips]
+    uint8_t ErrorCoding;                // LORA [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
+    bool CrcOn;                         // [0: OFF, 1: ON]
+    bool ImplicitHeaderOn;              // [0: OFF, 1: ON]
+    bool RxSingleOn;                    // [0: Continuous, 1 Single]
+    bool FreqHopOn;                     // [0: OFF, 1: ON]
+    uint8_t HopPeriod;                  // Hops every frequency hopping period symbols
+    uint32_t TxPacketTimeout;
+    uint32_t RxPacketTimeout;
+    uint8_t PayloadLength;
+}tLoRaSettings;
+
+/*!
+ * RF packet definition
+ */
+#define RF_BUFFER_SIZE_MAX                          100
+#define RF_BUFFER_SIZE                              100
+
+/*!
+ * RF state machine
+ */
+//LoRa
+typedef enum
+{
+    RFLR_STATE_IDLE,
+    RFLR_STATE_RX_INIT,
+    RFLR_STATE_RX_RUNNING,
+    RFLR_STATE_RX_DONE,
+    RFLR_STATE_RX_TIMEOUT,
+    RFLR_STATE_TX_INIT,
+    RFLR_STATE_TX_RUNNING,
+    RFLR_STATE_TX_DONE,
+    RFLR_STATE_TX_TIMEOUT,
+    RFLR_STATE_CAD_INIT,
+    RFLR_STATE_CAD_RUNNING,
+}tRFLRStates;
+
+/*!
+ * SX1276 definitions
+ */
+#define XTAL_FREQ                                   32000000
+#define FREQ_STEP                                   61.03515625
+
+/*!
+ * SX1276 Internal registers Address
+ */
+#define REG_LR_FIFO                                 0x00 
+// Common settings
+#define REG_LR_OPMODE                               0x01 
+#define REG_LR_BANDSETTING                          0x04
+#define REG_LR_FRFMSB                               0x06 
+#define REG_LR_FRFMID                               0x07
+#define REG_LR_FRFLSB                               0x08 
+// Tx settings
+#define REG_LR_PACONFIG                             0x09 
+#define REG_LR_PARAMP                               0x0A 
+#define REG_LR_OCP                                  0x0B 
+// Rx settings
+#define REG_LR_LNA                                  0x0C 
+// LoRa registers
+#define REG_LR_FIFOADDRPTR                          0x0D 
+#define REG_LR_FIFOTXBASEADDR                       0x0E 
+#define REG_LR_FIFORXBASEADDR                       0x0F 
+#define REG_LR_FIFORXCURRENTADDR                    0x10 
+#define REG_LR_IRQFLAGSMASK                         0x11 
+#define REG_LR_IRQFLAGS                             0x12 
+#define REG_LR_NBRXBYTES                            0x13 
+#define REG_LR_RXHEADERCNTVALUEMSB                  0x14 
+#define REG_LR_RXHEADERCNTVALUELSB                  0x15 
+#define REG_LR_RXPACKETCNTVALUEMSB                  0x16 
+#define REG_LR_RXPACKETCNTVALUELSB                  0x17 
+#define REG_LR_MODEMSTAT                            0x18 
+#define REG_LR_PKTSNRVALUE                          0x19 
+#define REG_LR_PKTRSSIVALUE                         0x1A 
+#define REG_LR_RSSIVALUE                            0x1B 
+#define REG_LR_HOPCHANNEL                           0x1C 
+#define REG_LR_MODEMCONFIG1                         0x1D 
+#define REG_LR_MODEMCONFIG2                         0x1E 
+#define REG_LR_SYMBTIMEOUTLSB                       0x1F 
+#define REG_LR_PREAMBLEMSB                          0x20 
+#define REG_LR_PREAMBLELSB                          0x21 
+#define REG_LR_PAYLOADLENGTH                        0x22 
+#define REG_LR_PAYLOADMAXLENGTH                     0x23 
+#define REG_LR_HOPPERIOD                            0x24 
+#define REG_LR_FIFORXBYTEADDR                       0x25
+#define REG_LR_MODEMCONFIG3                         0x26
+#define REG_LR_FEIMSB                               0x28
+#define REG_LR_FEIMIB                               0x29
+#define REG_LR_FEILSB                               0x2A
+#define REG_LR_LORADETECTOPTIMIZE                   0x31
+#define REG_LR_INVERTIQ                             0x33
+#define REG_LR_DETECTIONTHRESHOLD                   0x37
+// end of documented register in datasheet
+// I/O settings
+#define REG_LR_DIOMAPPING1                          0x40
+#define REG_LR_DIOMAPPING2                          0x41
+// Version
+#define REG_LR_VERSION                              0x42
+// Additional settings
+#define REG_LR_PLLHOP                               0x44
+#define REG_LR_TCXO                                 0x4B
+#define REG_LR_PADAC                                0x4D
+#define REG_LR_FORMERTEMP                           0x5B
+#define REG_LR_BITRATEFRAC                          0x5D
+#define REG_LR_AGCREF                               0x61
+#define REG_LR_AGCTHRESH1                           0x62
+#define REG_LR_AGCTHRESH2                           0x63
+#define REG_LR_AGCTHRESH3                           0x64
+
+
+/*!
+ * SX1276 LoRa bit control definition
+ */
+
+/*!
+ * RegFifo
+ */
+
+/*!
+ * RegOpMode
+ */
+#define RFLR_OPMODE_LONGRANGEMODE_MASK              0x7F 
+#define RFLR_OPMODE_LONGRANGEMODE_OFF               0x00 // Default
+#define RFLR_OPMODE_LONGRANGEMODE_ON                0x80 
+
+#define RFLR_OPMODE_ACCESSSHAREDREG_MASK            0xBF 
+#define RFLR_OPMODE_ACCESSSHAREDREG_ENABLE          0x40 
+#define RFLR_OPMODE_ACCESSSHAREDREG_DISABLE         0x00 // Default
+
+#define RFLR_OPMODE_FREQMODE_ACCESS_MASK            0xF7
+#define RFLR_OPMODE_FREQMODE_ACCESS_LF              0x08 // Default
+#define RFLR_OPMODE_FREQMODE_ACCESS_HF              0x00 
+
+#define RFLR_OPMODE_MASK                            0xF8 
+#define RFLR_OPMODE_SLEEP                           0x00 
+#define RFLR_OPMODE_STANDBY                         0x01 // Default
+#define RFLR_OPMODE_SYNTHESIZER_TX                  0x02 
+#define RFLR_OPMODE_TRANSMITTER                     0x03 
+#define RFLR_OPMODE_SYNTHESIZER_RX                  0x04 
+#define RFLR_OPMODE_RECEIVER                        0x05 
+// LoRa specific modes
+#define RFLR_OPMODE_RECEIVER_SINGLE                 0x06 
+#define RFLR_OPMODE_CAD                             0x07 
+
+/*!
+ * RegBandSetting 
+ */
+#define RFLR_BANDSETTING_MASK                    0x3F 
+#define RFLR_BANDSETTING_AUTO                    0x00 // Default
+#define RFLR_BANDSETTING_DIV_BY_1                0x40
+#define RFLR_BANDSETTING_DIV_BY_2                0x80
+#define RFLR_BANDSETTING_DIV_BY_6                0xC0
+
+/*!
+ * RegFrf (MHz)
+ */
+ 
+#define RFLR_FRFMSB_434_MHZ                         0x6C // Default
+#define RFLR_FRFMID_434_MHZ                         0x80 // Default
+#define RFLR_FRFLSB_434_MHZ                         0x00 // Default
+
+#define RFLR_FRFMSB_863_MHZ                         0xD7
+#define RFLR_FRFMID_863_MHZ                         0xC0
+#define RFLR_FRFLSB_863_MHZ                         0x00
+#define RFLR_FRFMSB_864_MHZ                         0xD8
+#define RFLR_FRFMID_864_MHZ                         0x00
+#define RFLR_FRFLSB_864_MHZ                         0x00
+#define RFLR_FRFMSB_865_MHZ                         0xD8
+#define RFLR_FRFMID_865_MHZ                         0x40
+#define RFLR_FRFLSB_865_MHZ                         0x00
+#define RFLR_FRFMSB_866_MHZ                         0xD8
+#define RFLR_FRFMID_866_MHZ                         0x80
+#define RFLR_FRFLSB_866_MHZ                         0x00
+#define RFLR_FRFMSB_867_MHZ                         0xD8
+#define RFLR_FRFMID_867_MHZ                         0xC0
+#define RFLR_FRFLSB_867_MHZ                         0x00
+#define RFLR_FRFMSB_868_MHZ                         0xD9
+#define RFLR_FRFMID_868_MHZ                         0x00
+#define RFLR_FRFLSB_868_MHZ                         0x00
+#define RFLR_FRFMSB_869_MHZ                         0xD9
+#define RFLR_FRFMID_869_MHZ                         0x40
+#define RFLR_FRFLSB_869_MHZ                         0x00
+#define RFLR_FRFMSB_870_MHZ                         0xD9
+#define RFLR_FRFMID_870_MHZ                         0x80
+#define RFLR_FRFLSB_870_MHZ                         0x00
+
+#define RFLR_FRFMSB_902_MHZ                         0xE1
+#define RFLR_FRFMID_902_MHZ                         0x80
+#define RFLR_FRFLSB_902_MHZ                         0x00
+#define RFLR_FRFMSB_903_MHZ                         0xE1
+#define RFLR_FRFMID_903_MHZ                         0xC0
+#define RFLR_FRFLSB_903_MHZ                         0x00
+#define RFLR_FRFMSB_904_MHZ                         0xE2
+#define RFLR_FRFMID_904_MHZ                         0x00
+#define RFLR_FRFLSB_904_MHZ                         0x00
+#define RFLR_FRFMSB_905_MHZ                         0xE2
+#define RFLR_FRFMID_905_MHZ                         0x40
+#define RFLR_FRFLSB_905_MHZ                         0x00
+#define RFLR_FRFMSB_906_MHZ                         0xE2
+#define RFLR_FRFMID_906_MHZ                         0x80
+#define RFLR_FRFLSB_906_MHZ                         0x00
+#define RFLR_FRFMSB_907_MHZ                         0xE2
+#define RFLR_FRFMID_907_MHZ                         0xC0
+#define RFLR_FRFLSB_907_MHZ                         0x00
+#define RFLR_FRFMSB_908_MHZ                         0xE3
+#define RFLR_FRFMID_908_MHZ                         0x00
+#define RFLR_FRFLSB_908_MHZ                         0x00
+#define RFLR_FRFMSB_909_MHZ                         0xE3
+#define RFLR_FRFMID_909_MHZ                         0x40
+#define RFLR_FRFLSB_909_MHZ                         0x00
+#define RFLR_FRFMSB_910_MHZ                         0xE3
+#define RFLR_FRFMID_910_MHZ                         0x80
+#define RFLR_FRFLSB_910_MHZ                         0x00
+#define RFLR_FRFMSB_911_MHZ                         0xE3
+#define RFLR_FRFMID_911_MHZ                         0xC0
+#define RFLR_FRFLSB_911_MHZ                         0x00
+#define RFLR_FRFMSB_912_MHZ                         0xE4
+#define RFLR_FRFMID_912_MHZ                         0x00
+#define RFLR_FRFLSB_912_MHZ                         0x00
+#define RFLR_FRFMSB_913_MHZ                         0xE4
+#define RFLR_FRFMID_913_MHZ                         0x40
+#define RFLR_FRFLSB_913_MHZ                         0x00
+#define RFLR_FRFMSB_914_MHZ                         0xE4
+#define RFLR_FRFMID_914_MHZ                         0x80
+#define RFLR_FRFLSB_914_MHZ                         0x00
+#define RFLR_FRFMSB_915_MHZ                         0xE4  // Default
+#define RFLR_FRFMID_915_MHZ                         0xC0  // Default
+#define RFLR_FRFLSB_915_MHZ                         0x00  // Default
+#define RFLR_FRFMSB_916_MHZ                         0xE5
+#define RFLR_FRFMID_916_MHZ                         0x00
+#define RFLR_FRFLSB_916_MHZ                         0x00
+#define RFLR_FRFMSB_917_MHZ                         0xE5
+#define RFLR_FRFMID_917_MHZ                         0x40
+#define RFLR_FRFLSB_917_MHZ                         0x00
+#define RFLR_FRFMSB_918_MHZ                         0xE5
+#define RFLR_FRFMID_918_MHZ                         0x80
+#define RFLR_FRFLSB_918_MHZ                         0x00
+#define RFLR_FRFMSB_919_MHZ                         0xE5
+#define RFLR_FRFMID_919_MHZ                         0xC0
+#define RFLR_FRFLSB_919_MHZ                         0x00
+#define RFLR_FRFMSB_920_MHZ                         0xE6
+#define RFLR_FRFMID_920_MHZ                         0x00
+#define RFLR_FRFLSB_920_MHZ                         0x00
+#define RFLR_FRFMSB_921_MHZ                         0xE6
+#define RFLR_FRFMID_921_MHZ                         0x40
+#define RFLR_FRFLSB_921_MHZ                         0x00
+#define RFLR_FRFMSB_922_MHZ                         0xE6
+#define RFLR_FRFMID_922_MHZ                         0x80
+#define RFLR_FRFLSB_922_MHZ                         0x00
+#define RFLR_FRFMSB_923_MHZ                         0xE6
+#define RFLR_FRFMID_923_MHZ                         0xC0
+#define RFLR_FRFLSB_923_MHZ                         0x00
+#define RFLR_FRFMSB_924_MHZ                         0xE7
+#define RFLR_FRFMID_924_MHZ                         0x00
+#define RFLR_FRFLSB_924_MHZ                         0x00
+#define RFLR_FRFMSB_925_MHZ                         0xE7
+#define RFLR_FRFMID_925_MHZ                         0x40
+#define RFLR_FRFLSB_925_MHZ                         0x00
+#define RFLR_FRFMSB_926_MHZ                         0xE7
+#define RFLR_FRFMID_926_MHZ                         0x80
+#define RFLR_FRFLSB_926_MHZ                         0x00
+#define RFLR_FRFMSB_927_MHZ                         0xE7
+#define RFLR_FRFMID_927_MHZ                         0xC0
+#define RFLR_FRFLSB_927_MHZ                         0x00
+#define RFLR_FRFMSB_928_MHZ                         0xE8
+#define RFLR_FRFMID_928_MHZ                         0x00
+#define RFLR_FRFLSB_928_MHZ                         0x00
+
+/*!
+ * RegPaConfig
+ */
+#define RFLR_PACONFIG_PASELECT_MASK                 0x7F 
+#define RFLR_PACONFIG_PASELECT_PABOOST              0x80 
+#define RFLR_PACONFIG_PASELECT_RFO                  0x00 // Default
+
+#define RFLR_PACONFIG_MAX_POWER_MASK                0x8F
+
+#define RFLR_PACONFIG_OUTPUTPOWER_MASK              0xF0 
+ 
+/*!
+ * RegPaRamp
+ */
+#define RFLR_PARAMP_TXBANDFORCE_MASK                0xEF 
+#define RFLR_PARAMP_TXBANDFORCE_BAND_SEL            0x10 
+#define RFLR_PARAMP_TXBANDFORCE_AUTO                0x00 // Default
+
+#define RFLR_PARAMP_MASK                            0xF0 
+#define RFLR_PARAMP_3400_US                         0x00 
+#define RFLR_PARAMP_2000_US                         0x01 
+#define RFLR_PARAMP_1000_US                         0x02
+#define RFLR_PARAMP_0500_US                         0x03 
+#define RFLR_PARAMP_0250_US                         0x04 
+#define RFLR_PARAMP_0125_US                         0x05 
+#define RFLR_PARAMP_0100_US                         0x06 
+#define RFLR_PARAMP_0062_US                         0x07 
+#define RFLR_PARAMP_0050_US                         0x08 
+#define RFLR_PARAMP_0040_US                         0x09 // Default
+#define RFLR_PARAMP_0031_US                         0x0A 
+#define RFLR_PARAMP_0025_US                         0x0B 
+#define RFLR_PARAMP_0020_US                         0x0C 
+#define RFLR_PARAMP_0015_US                         0x0D 
+#define RFLR_PARAMP_0012_US                         0x0E 
+#define RFLR_PARAMP_0010_US                         0x0F 
+
+/*!
+ * RegOcp
+ */
+#define RFLR_OCP_MASK                               0xDF 
+#define RFLR_OCP_ON                                 0x20 // Default
+#define RFLR_OCP_OFF                                0x00   
+
+#define RFLR_OCP_TRIM_MASK                          0xE0
+#define RFLR_OCP_TRIM_045_MA                        0x00
+#define RFLR_OCP_TRIM_050_MA                        0x01   
+#define RFLR_OCP_TRIM_055_MA                        0x02 
+#define RFLR_OCP_TRIM_060_MA                        0x03 
+#define RFLR_OCP_TRIM_065_MA                        0x04 
+#define RFLR_OCP_TRIM_070_MA                        0x05 
+#define RFLR_OCP_TRIM_075_MA                        0x06 
+#define RFLR_OCP_TRIM_080_MA                        0x07  
+#define RFLR_OCP_TRIM_085_MA                        0x08
+#define RFLR_OCP_TRIM_090_MA                        0x09 
+#define RFLR_OCP_TRIM_095_MA                        0x0A 
+#define RFLR_OCP_TRIM_100_MA                        0x0B  // Default
+#define RFLR_OCP_TRIM_105_MA                        0x0C 
+#define RFLR_OCP_TRIM_110_MA                        0x0D 
+#define RFLR_OCP_TRIM_115_MA                        0x0E 
+#define RFLR_OCP_TRIM_120_MA                        0x0F 
+#define RFLR_OCP_TRIM_130_MA                        0x10
+#define RFLR_OCP_TRIM_140_MA                        0x11   
+#define RFLR_OCP_TRIM_150_MA                        0x12 
+#define RFLR_OCP_TRIM_160_MA                        0x13 
+#define RFLR_OCP_TRIM_170_MA                        0x14 
+#define RFLR_OCP_TRIM_180_MA                        0x15 
+#define RFLR_OCP_TRIM_190_MA                        0x16 
+#define RFLR_OCP_TRIM_200_MA                        0x17  
+#define RFLR_OCP_TRIM_210_MA                        0x18
+#define RFLR_OCP_TRIM_220_MA                        0x19 
+#define RFLR_OCP_TRIM_230_MA                        0x1A 
+#define RFLR_OCP_TRIM_240_MA                        0x1B
+
+/*!
+ * RegLna
+ */
+#define RFLR_LNA_GAIN_MASK                          0x1F 
+#define RFLR_LNA_GAIN_G1                            0x20 // Default
+#define RFLR_LNA_GAIN_G2                            0x40 
+#define RFLR_LNA_GAIN_G3                            0x60 
+#define RFLR_LNA_GAIN_G4                            0x80 
+#define RFLR_LNA_GAIN_G5                            0xA0 
+#define RFLR_LNA_GAIN_G6                            0xC0 
+
+#define RFLR_LNA_BOOST_LF_MASK                      0xE7 
+#define RFLR_LNA_BOOST_LF_DEFAULT                   0x00 // Default
+#define RFLR_LNA_BOOST_LF_GAIN                      0x08 
+#define RFLR_LNA_BOOST_LF_IP3                       0x10 
+#define RFLR_LNA_BOOST_LF_BOOST                     0x18 
+
+#define RFLR_LNA_RXBANDFORCE_MASK                   0xFB 
+#define RFLR_LNA_RXBANDFORCE_BAND_SEL               0x04
+#define RFLR_LNA_RXBANDFORCE_AUTO                   0x00 // Default
+
+#define RFLR_LNA_BOOST_HF_MASK                      0xFC 
+#define RFLR_LNA_BOOST_HF_OFF                       0x00 // Default
+#define RFLR_LNA_BOOST_HF_ON                        0x03 
+
+/*!
+ * RegFifoAddrPtr
+ */
+#define RFLR_FIFOADDRPTR                            0x00 // Default
+
+/*!
+ * RegFifoTxBaseAddr
+ */
+#define RFLR_FIFOTXBASEADDR                         0x80 // Default
+
+/*!
+ * RegFifoTxBaseAddr
+ */
+#define RFLR_FIFORXBASEADDR                         0x00 // Default
+
+/*!
+ * RegFifoRxCurrentAddr (Read Only)
+ */
+
+/*!
+ * RegIrqFlagsMask
+ */
+#define RFLR_IRQFLAGS_RXTIMEOUT_MASK                0x80 
+#define RFLR_IRQFLAGS_RXDONE_MASK                   0x40 
+#define RFLR_IRQFLAGS_PAYLOADCRCERROR_MASK          0x20 
+#define RFLR_IRQFLAGS_VALIDHEADER_MASK              0x10 
+#define RFLR_IRQFLAGS_TXDONE_MASK                   0x08 
+#define RFLR_IRQFLAGS_CADDONE_MASK                  0x04 
+#define RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL_MASK       0x02 
+#define RFLR_IRQFLAGS_CADDETECTED_MASK              0x01 
+
+/*!
+ * RegIrqFlags
+ */
+#define RFLR_IRQFLAGS_RXTIMEOUT                     0x80 
+#define RFLR_IRQFLAGS_RXDONE                        0x40 
+#define RFLR_IRQFLAGS_PAYLOADCRCERROR               0x20 
+#define RFLR_IRQFLAGS_VALIDHEADER                   0x10 
+#define RFLR_IRQFLAGS_TXDONE                        0x08 
+#define RFLR_IRQFLAGS_CADDONE                       0x04 
+#define RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL            0x02 
+#define RFLR_IRQFLAGS_CADDETECTED                   0x01 
+
+
+
+/*!
+ * RegFifoRxNbBytes (Read Only)    //
+ */
+
+ 
+ /*!
+ * RegRxHeaderCntValueMsb (Read Only)    //
+ */
+ 
+ 
+  /*!
+ * RegRxHeaderCntValueLsb (Read Only)    //
+ */
+ 
+ 
+/*!
+ * RegRxPacketCntValueMsb (Read Only)    //
+ */
+ 
+ 
+ /*!
+ * RegRxPacketCntValueLsb (Read Only)    //
+ */
+ 
+ 
+ /*!
+ * RegModemStat (Read Only)    //
+ */
+#define RFLR_MODEMSTAT_RX_CR_MASK                   0x1F 
+#define RFLR_MODEMSTAT_MODEM_STATUS_MASK            0xE0 
+ 
+/*!
+ * RegPktSnrValue (Read Only)    //
+ */
+
+ 
+ /*!
+ * RegPktRssiValue (Read Only)    //
+ */
+ 
+ 
+/*!
+ * RegRssiValue (Read Only)    //
+ */
+ 
+/*!
+ * RegHopChannel (Read Only)    //
+ */
+#define RFLR_HOP_CHANNEL_PAYLOAD_CRC_ON_MASK       0xBF
+#define RFLR_HOP_CHANNEL_PAYLOAD_CRC_ON            0x40
+#define RFLR_HOP_CHANNEL_PAYLOAD_CRC_OFF           0x00
+ 
+ /*!
+ * RegModemConfig1
+ */
+#define RFLR_MODEMCONFIG1_BW_MASK                   0x0F 
+
+#define RFLR_MODEMCONFIG1_BW_7_81_KHZ               0x00 
+#define RFLR_MODEMCONFIG1_BW_10_41_KHZ              0x10 
+#define RFLR_MODEMCONFIG1_BW_15_62_KHZ              0x20 
+#define RFLR_MODEMCONFIG1_BW_20_83_KHZ              0x30 
+#define RFLR_MODEMCONFIG1_BW_31_25_KHZ              0x40 
+#define RFLR_MODEMCONFIG1_BW_41_66_KHZ              0x50 
+#define RFLR_MODEMCONFIG1_BW_62_50_KHZ              0x60 
+#define RFLR_MODEMCONFIG1_BW_125_KHZ                0x70 // Default
+#define RFLR_MODEMCONFIG1_BW_250_KHZ                0x80 
+#define RFLR_MODEMCONFIG1_BW_500_KHZ                0x90 
+                                                    
+#define RFLR_MODEMCONFIG1_CODINGRATE_MASK           0xF1 
+#define RFLR_MODEMCONFIG1_CODINGRATE_4_5            0x02
+#define RFLR_MODEMCONFIG1_CODINGRATE_4_6            0x04 // Default
+#define RFLR_MODEMCONFIG1_CODINGRATE_4_7            0x06 
+#define RFLR_MODEMCONFIG1_CODINGRATE_4_8            0x08 
+                                                    
+#define RFLR_MODEMCONFIG1_IMPLICITHEADER_MASK       0xFE 
+#define RFLR_MODEMCONFIG1_IMPLICITHEADER_ON         0x01 
+#define RFLR_MODEMCONFIG1_IMPLICITHEADER_OFF        0x00 // Default
+
+ /*!
+ * RegModemConfig2
+ */
+#define RFLR_MODEMCONFIG2_SF_MASK                   0x0F 
+#define RFLR_MODEMCONFIG2_SF_6                      0x60 
+#define RFLR_MODEMCONFIG2_SF_7                      0x70 // Default
+#define RFLR_MODEMCONFIG2_SF_8                      0x80 
+#define RFLR_MODEMCONFIG2_SF_9                      0x90 
+#define RFLR_MODEMCONFIG2_SF_10                     0xA0 
+#define RFLR_MODEMCONFIG2_SF_11                     0xB0 
+#define RFLR_MODEMCONFIG2_SF_12                     0xC0 
+
+#define RFLR_MODEMCONFIG2_TXCONTINUOUSMODE_MASK     0xF7 
+#define RFLR_MODEMCONFIG2_TXCONTINUOUSMODE_ON       0x08 
+#define RFLR_MODEMCONFIG2_TXCONTINUOUSMODE_OFF      0x00 
+
+#define RFLR_MODEMCONFIG2_RXPAYLOADCRC_MASK         0xFB 
+#define RFLR_MODEMCONFIG2_RXPAYLOADCRC_ON           0x04 
+#define RFLR_MODEMCONFIG2_RXPAYLOADCRC_OFF          0x00 // Default
+ 
+#define RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK       0xFC 
+#define RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB            0x00 // Default
+                                                    
+                                                    
+/*!                                                 
+ * RegHopChannel (Read Only)                        
+ */                                                 
+#define RFLR_HOPCHANNEL_PLL_LOCK_TIMEOUT_MASK       0x7F 
+#define RFLR_HOPCHANNEL_PLL_LOCK_FAIL               0x80 
+#define RFLR_HOPCHANNEL_PLL_LOCK_SUCCEED            0x00 // Default
+                                                    
+#define RFLR_HOPCHANNEL_PAYLOAD_CRC16_MASK          0xBF
+#define RFLR_HOPCHANNEL_PAYLOAD_CRC16_ON            0x40
+#define RFLR_HOPCHANNEL_PAYLOAD_CRC16_OFF           0x00 // Default
+
+#define RFLR_HOPCHANNEL_CHANNEL_MASK                0x3F 
+
+
+/*!
+ * RegSymbTimeoutLsb
+ */
+#define RFLR_SYMBTIMEOUTLSB_SYMBTIMEOUT             0x64 // Default
+
+/*!
+ * RegPreambleLengthMsb
+ */
+#define RFLR_PREAMBLELENGTHMSB                      0x00 // Default
+
+/*!
+ * RegPreambleLengthLsb
+ */
+#define RFLR_PREAMBLELENGTHLSB                      0x08 // Default
+
+/*!
+ * RegPayloadLength
+ */
+#define RFLR_PAYLOADLENGTH                          0x0E // Default
+
+/*!
+ * RegPayloadMaxLength
+ */
+#define RFLR_PAYLOADMAXLENGTH                       0xFF // Default
+
+/*!
+ * RegHopPeriod
+ */
+#define RFLR_HOPPERIOD_FREQFOPPINGPERIOD            0x00 // Default
+
+
+/*!
+ * RegDioMapping1
+ */
+#define RFLR_DIOMAPPING1_DIO0_MASK                  0x3F
+#define RFLR_DIOMAPPING1_DIO0_00                    0x00  // Default
+#define RFLR_DIOMAPPING1_DIO0_01                    0x40
+#define RFLR_DIOMAPPING1_DIO0_10                    0x80
+#define RFLR_DIOMAPPING1_DIO0_11                    0xC0
+
+#define RFLR_DIOMAPPING1_DIO1_MASK                  0xCF
+#define RFLR_DIOMAPPING1_DIO1_00                    0x00  // Default
+#define RFLR_DIOMAPPING1_DIO1_01                    0x10
+#define RFLR_DIOMAPPING1_DIO1_10                    0x20
+#define RFLR_DIOMAPPING1_DIO1_11                    0x30
+
+#define RFLR_DIOMAPPING1_DIO2_MASK                  0xF3
+#define RFLR_DIOMAPPING1_DIO2_00                    0x00  // Default
+#define RFLR_DIOMAPPING1_DIO2_01                    0x04
+#define RFLR_DIOMAPPING1_DIO2_10                    0x08
+#define RFLR_DIOMAPPING1_DIO2_11                    0x0C
+
+#define RFLR_DIOMAPPING1_DIO3_MASK                  0xFC
+#define RFLR_DIOMAPPING1_DIO3_00                    0x00  // Default
+#define RFLR_DIOMAPPING1_DIO3_01                    0x01
+#define RFLR_DIOMAPPING1_DIO3_10                    0x02
+#define RFLR_DIOMAPPING1_DIO3_11                    0x03
+
+/*!
+ * RegDioMapping2
+ */
+#define RFLR_DIOMAPPING2_DIO4_MASK                  0x3F
+#define RFLR_DIOMAPPING2_DIO4_00                    0x00  // Default
+#define RFLR_DIOMAPPING2_DIO4_01                    0x40
+#define RFLR_DIOMAPPING2_DIO4_10                    0x80
+#define RFLR_DIOMAPPING2_DIO4_11                    0xC0
+
+#define RFLR_DIOMAPPING2_DIO5_MASK                  0xCF
+#define RFLR_DIOMAPPING2_DIO5_00                    0x00  // Default
+#define RFLR_DIOMAPPING2_DIO5_01                    0x10
+#define RFLR_DIOMAPPING2_DIO5_10                    0x20
+#define RFLR_DIOMAPPING2_DIO5_11                    0x30
+
+#define RFLR_DIOMAPPING2_MAP_MASK                   0xFE
+#define RFLR_DIOMAPPING2_MAP_PREAMBLEDETECT         0x01
+#define RFLR_DIOMAPPING2_MAP_RSSI                   0x00  // Default
+
+/*!
+ * RegVersion (Read Only)
+ */
+
+/*!
+ * RegAgcRef
+ */
+
+/*!
+ * RegAgcThresh1
+ */
+
+/*!
+ * RegAgcThresh2
+ */
+
+/*!
+ * RegAgcThresh3
+ */
+ 
+/*!
+ * RegFifoRxByteAddr (Read Only)
+ */
+ 
+/*!
+ * RegPllHop
+ */
+#define RFLR_PLLHOP_FASTHOP_MASK                    0x7F
+#define RFLR_PLLHOP_FASTHOP_ON                      0x80
+#define RFLR_PLLHOP_FASTHOP_OFF                     0x00 // Default
+
+/*!
+ * RegTcxo
+ */
+#define RFLR_TCXO_TCXOINPUT_MASK                    0xEF
+#define RFLR_TCXO_TCXOINPUT_ON                      0x10
+#define RFLR_TCXO_TCXOINPUT_OFF                     0x00  // Default
+
+/*!
+ * RegPaDac
+ */
+#define RFLR_PADAC_20DBM_MASK                       0xF8
+#define RFLR_PADAC_20DBM_ON                         0x07
+#define RFLR_PADAC_20DBM_OFF                        0x04  // Default
+
+/*!
+ * RegPll
+ */
+#define RFLR_PLL_BANDWIDTH_MASK                     0x3F
+#define RFLR_PLL_BANDWIDTH_75                       0x00
+#define RFLR_PLL_BANDWIDTH_150                      0x40
+#define RFLR_PLL_BANDWIDTH_225                      0x80
+#define RFLR_PLL_BANDWIDTH_300                      0xC0  // Default
+
+/*!
+ * RegPllLowPn
+ */
+#define RFLR_PLLLOWPN_BANDWIDTH_MASK                0x3F
+#define RFLR_PLLLOWPN_BANDWIDTH_75                  0x00
+#define RFLR_PLLLOWPN_BANDWIDTH_150                 0x40
+#define RFLR_PLLLOWPN_BANDWIDTH_225                 0x80
+#define RFLR_PLLLOWPN_BANDWIDTH_300                 0xC0  // Default
+
+/*!
+ * RegModemConfig3
+ */
+#define RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_MASK  0xF7 
+#define RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_ON    0x08 
+#define RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_OFF   0x00 // Default
+
+#define RFLR_MODEMCONFIG3_AGCAUTO_MASK              0xFB 
+#define RFLR_MODEMCONFIG3_AGCAUTO_ON                0x04 // Default 
+#define RFLR_MODEMCONFIG3_AGCAUTO_OFF               0x00 
+
+/*!
+ * RegFormerTemp
+ */
+
+typedef struct sSX1276LR
+{
+    uint8_t RegFifo;                                // 0x00 
+    // Common settings
+    uint8_t RegOpMode;                              // 0x01 
+    uint8_t RegRes02;                               // 0x02 
+    uint8_t RegRes03;                               // 0x03 
+    uint8_t RegBandSetting;                         // 0x04 
+    uint8_t RegRes05;                               // 0x05 
+    uint8_t RegFrfMsb;                              // 0x06 
+    uint8_t RegFrfMid;                              // 0x07 
+    uint8_t RegFrfLsb;                              // 0x08 
+    // Tx settings
+    uint8_t RegPaConfig;                            // 0x09 
+    uint8_t RegPaRamp;                              // 0x0A 
+    uint8_t RegOcp;                                 // 0x0B 
+    // Rx settings
+    uint8_t RegLna;                                 // 0x0C 
+    // LoRa registers
+    uint8_t RegFifoAddrPtr;                         // 0x0D 
+    uint8_t RegFifoTxBaseAddr;                      // 0x0E 
+    uint8_t RegFifoRxBaseAddr;                      // 0x0F 
+    uint8_t RegFifoRxCurrentAddr;                   // 0x10 
+    uint8_t RegIrqFlagsMask;                        // 0x11 
+    uint8_t RegIrqFlags;                            // 0x12 
+    uint8_t RegNbRxBytes;                           // 0x13 
+    uint8_t RegRxHeaderCntValueMsb;                 // 0x14 
+    uint8_t RegRxHeaderCntValueLsb;                 // 0x15 
+    uint8_t RegRxPacketCntValueMsb;                 // 0x16 
+    uint8_t RegRxPacketCntValueLsb;                 // 0x17 
+    uint8_t RegModemStat;                           // 0x18 
+    uint8_t RegPktSnrValue;                         // 0x19 
+    uint8_t RegPktRssiValue;                        // 0x1A 
+    uint8_t RegRssiValue;                           // 0x1B 
+    uint8_t RegHopChannel;                          // 0x1C 
+    uint8_t RegModemConfig1;                        // 0x1D 
+    uint8_t RegModemConfig2;                        // 0x1E 
+    uint8_t RegSymbTimeoutLsb;                      // 0x1F 
+    uint8_t RegPreambleMsb;                         // 0x20 
+    uint8_t RegPreambleLsb;                         // 0x21 
+    uint8_t RegPayloadLength;                       // 0x22 
+    uint8_t RegMaxPayloadLength;                    // 0x23 
+    uint8_t RegHopPeriod;                           // 0x24 
+    uint8_t RegFifoRxByteAddr;                      // 0x25
+    uint8_t RegModemConfig3;                        // 0x26
+    uint8_t RegTestReserved27;                      // 0x27
+    uint8_t RegFeiMsb;                              // 0x28
+    uint8_t RegFeiMib;                              // 0x29 
+    uint8_t RegFeiLsb;                              // 0x2A
+    uint8_t RegTestReserved2B[0x30 - 0x2B];         // 0x2B-0x30 
+    uint8_t RegDetectOptimize;                      // 0x31    
+    uint8_t RegTestReserved32;                      // 0x32   
+    uint8_t RegInvertIQ;                            // 0x33 
+    uint8_t RegTestReserved34[0x36 - 0x34];         // 0x34-0x36 
+    uint8_t RegDetectionThreshold;                  // 0x37
+    uint8_t RegTestReserved38[0x3F - 0x38];         // 0x38-0x3F
+    // I/O settings                
+    uint8_t RegDioMapping1;                         // 0x40 
+    uint8_t RegDioMapping2;                         // 0x41 
+    // Version
+    uint8_t RegVersion;                             // 0x42
+    // Test   
+    uint8_t RegTestReserved43;                      // 0x43
+    // Additional settings
+    uint8_t RegPllHop;                              // 0x44 
+    // Test
+    uint8_t RegTestReserved45[0x4A - 0x45];         // 0x45-0x4A   
+    // Additional settings    
+    uint8_t RegTcxo;                                // 0x4B
+    // Test    
+    uint8_t RegTestReserved4C;                      // 0x4C  
+    // Additional settings    
+    uint8_t RegPaDac;                               // 0x4D 
+    // Test    
+    uint8_t RegTestReserved4E[0x5A - 0x4E];         // 0x4E-0x5A  
+    // Additional settings
+    uint8_t RegFormerTemp;                          // 0x5B
+    // Test    
+    uint8_t RegTestReserved5C;                      // 0x5C
+    // Additional settings    
+    uint8_t RegBitrateFrac;                         // 0x5D   
+    // Additional settings    
+    uint8_t RegTestReserved5E[0x60 - 0x5E];         // 0x5E-0x60
+    // Additional settings
+    uint8_t RegAgcRef;                              // 0x60
+    uint8_t RegAgcThresh1;                          // 0x61
+    uint8_t RegAgcThresh2;                          // 0x62
+    uint8_t RegAgcThresh3;                          // 0x63
+    // Test
+    uint8_t RegTestReserved64[0x70 - 0x64];         // 0x64-0x70
+}tSX1276LR;
+
+extern tSX1276LR* SX1276LR;
+
+/*!
+ * \brief Initializes the SX1276
+ */
+void SX1276LoRaInit( void );
+
+/*!
+ * \brief Sets the SX1276 to datasheet default values
+ */
+void SX1276LoRaSetDefaults( void );
+
+/*!
+ * \brief Enables/Disables the LoRa modem
+ *
+ * \param [IN]: enable [true, false]
+ */
+void SX1276LoRaSetLoRaOn( bool enable );
+
+/*!
+ * \brief Sets the SX1276 operating mode
+ *
+ * \param [IN] opMode New operating mode
+ */
+void SX1276LoRaSetOpMode( uint8_t opMode );
+
+/*!
+ * \brief Gets the SX1276 operating mode
+ *
+ * \retval opMode Current operating mode
+ */
+uint8_t SX1276LoRaGetOpMode( void );
+
+/*!
+ * \brief Reads the current Rx gain setting
+ *
+ * \retval rxGain Current gain setting
+ */
+uint8_t SX1276LoRaReadRxGain( void );
+
+/*!
+ * \brief Trigs and reads the current RSSI value
+ *
+ * \retval rssiValue Current RSSI value in [dBm]
+ */
+double SX1276LoRaReadRssi( void );
+
+/*!
+ * \brief Gets the Rx gain value measured while receiving the packet
+ *
+ * \retval rxGainValue Current Rx gain value
+ */
+uint8_t SX1276LoRaGetPacketRxGain( void );
+
+/*!
+ * \brief Gets the SNR value measured while receiving the packet
+ *
+ * \retval snrValue Current SNR value in [dB]
+ */
+int8_t SX1276LoRaGetPacketSnr( void );
+
+/*!
+ * \brief Gets the RSSI value measured while receiving the packet
+ *
+ * \retval rssiValue Current RSSI value in [dBm]
+ */
+double SX1276LoRaGetPacketRssi( void );
+
+/*!
+ * \brief Sets the radio in Rx mode. Waiting for a packet
+ */
+void SX1276LoRaStartRx( void );
+
+/*!
+ * \brief Gets a copy of the current received buffer
+ *
+ * \param [IN]: buffer     Buffer pointer
+ * \param [IN]: size       Buffer size
+ */
+void SX1276LoRaGetRxPacket( void *buffer, uint16_t *size );
+
+/*!
+ * \brief Sets a copy of the buffer to be transmitted
+ *
+ * \param [IN]: buffer     Buffer pointer
+ * \param [IN]: size       Buffer size
+ */
+void SX1276LoRaSetTxPacket( const void *buffer, uint16_t size );
+
+/*!
+ * \brief Gets the current RFState
+ *
+ * \retval rfState Current RF state [RF_IDLE, RF_BUSY, 
+ *                                   RF_RX_DONE, RF_RX_TIMEOUT,
+ *                                   RF_TX_DONE, RF_TX_TIMEOUT]
+ */
+uint8_t SX1276LoRaGetRFState( void );
+
+/*!
+ * \brief Sets the new state of the RF state machine
+ *
+ * \param [IN]: state New RF state machine state
+ */
+void SX1276LoRaSetRFState( uint8_t state );
+
+/*!
+ * \brief Process the LoRa modem Rx and Tx state machines depending on the
+ *        SX1276 operating mode.
+ *
+ * \retval rfState Current RF state [RF_IDLE, RF_BUSY, 
+ *                                   RF_RX_DONE, RF_RX_TIMEOUT,
+ *                                   RF_TX_DONE, RF_TX_TIMEOUT]
+ */
+uint32_t SX1276LoRaProcess( void );
+
+#endif //__SX1276_LORA_H__
+

APP/network_mgr/lora/Radio/inc/sx1276-LoRa.h~RF3c521ab.TMP

@@ -0,0 +1,922 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276-LoRa.h
+ * \brief      SX1276 RF chip driver mode LoRa
+ *
+ * \version    2.0.B2 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#ifndef __SX1276_LORA_H__
+#define __SX1276_LORA_H__
+
+/*!
+ * SX1276 LoRa General parameters definition
+ */
+typedef struct sLoRaSettings
+{
+    uint32_t RFFrequency;
+    int8_t Power;
+    uint8_t SignalBw;                   // LORA [0: 7.8 kHz, 1: 10.4 kHz, 2: 15.6 kHz, 3: 20.8 kHz, 4: 31.2 kHz,
+                                        // 5: 41.6 kHz, 6: 62.5 kHz, 7: 125 kHz, 8: 250 kHz, 9: 500 kHz, other: Reserved]  
+    uint8_t SpreadingFactor;            // LORA [6: 64, 7: 128, 8: 256, 9: 512, 10: 1024, 11: 2048, 12: 4096  chips]
+    uint8_t ErrorCoding;                // LORA [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
+    bool CrcOn;                         // [0: OFF, 1: ON]
+    bool ImplicitHeaderOn;              // [0: OFF, 1: ON]
+    bool RxSingleOn;                    // [0: Continuous, 1 Single]
+    bool FreqHopOn;                     // [0: OFF, 1: ON]
+    uint8_t HopPeriod;                  // Hops every frequency hopping period symbols
+    uint32_t TxPacketTimeout;
+    uint32_t RxPacketTimeout;
+    uint8_t PayloadLength;
+}tLoRaSettings;
+
+/*!
+ * RF packet definition
+ */
+#define RF_BUFFER_SIZE_MAX                          100
+#define RF_BUFFER_SIZE                              100
+
+/*!
+ * RF state machine
+ */
+//LoRa
+typedef enum
+{
+    RFLR_STATE_IDLE,
+    RFLR_STATE_RX_INIT,
+    RFLR_STATE_RX_RUNNING,
+    RFLR_STATE_RX_DONE,
+    RFLR_STATE_RX_TIMEOUT,
+    RFLR_STATE_TX_INIT,
+    RFLR_STATE_TX_RUNNING,
+    RFLR_STATE_TX_DONE,
+    RFLR_STATE_TX_TIMEOUT,
+    RFLR_STATE_CAD_INIT,
+    RFLR_STATE_CAD_RUNNING,
+}tRFLRStates;
+
+/*!
+ * SX1276 definitions
+ */
+#define XTAL_FREQ                                   32000000
+#define FREQ_STEP                                   61.03515625
+
+/*!
+ * SX1276 Internal registers Address
+ */
+#define REG_LR_FIFO                                 0x00 
+// Common settings
+#define REG_LR_OPMODE                               0x01 
+#define REG_LR_BANDSETTING                          0x04
+#define REG_LR_FRFMSB                               0x06 
+#define REG_LR_FRFMID                               0x07
+#define REG_LR_FRFLSB                               0x08 
+// Tx settings
+#define REG_LR_PACONFIG                             0x09 
+#define REG_LR_PARAMP                               0x0A 
+#define REG_LR_OCP                                  0x0B 
+// Rx settings
+#define REG_LR_LNA                                  0x0C 
+// LoRa registers
+#define REG_LR_FIFOADDRPTR                          0x0D 
+#define REG_LR_FIFOTXBASEADDR                       0x0E 
+#define REG_LR_FIFORXBASEADDR                       0x0F 
+#define REG_LR_FIFORXCURRENTADDR                    0x10 
+#define REG_LR_IRQFLAGSMASK                         0x11 
+#define REG_LR_IRQFLAGS                             0x12 
+#define REG_LR_NBRXBYTES                            0x13 
+#define REG_LR_RXHEADERCNTVALUEMSB                  0x14 
+#define REG_LR_RXHEADERCNTVALUELSB                  0x15 
+#define REG_LR_RXPACKETCNTVALUEMSB                  0x16 
+#define REG_LR_RXPACKETCNTVALUELSB                  0x17 
+#define REG_LR_MODEMSTAT                            0x18 
+#define REG_LR_PKTSNRVALUE                          0x19 
+#define REG_LR_PKTRSSIVALUE                         0x1A 
+#define REG_LR_RSSIVALUE                            0x1B 
+#define REG_LR_HOPCHANNEL                           0x1C 
+#define REG_LR_MODEMCONFIG1                         0x1D 
+#define REG_LR_MODEMCONFIG2                         0x1E 
+#define REG_LR_SYMBTIMEOUTLSB                       0x1F 
+#define REG_LR_PREAMBLEMSB                          0x20 
+#define REG_LR_PREAMBLELSB                          0x21 
+#define REG_LR_PAYLOADLENGTH                        0x22 
+#define REG_LR_PAYLOADMAXLENGTH                     0x23 
+#define REG_LR_HOPPERIOD                            0x24 
+#define REG_LR_FIFORXBYTEADDR                       0x25
+#define REG_LR_MODEMCONFIG3                         0x26
+#define REG_LR_FEIMSB                               0x28
+#define REG_LR_FEIMIB                               0x29
+#define REG_LR_FEILSB                               0x2A
+#define REG_LR_LORADETECTOPTIMIZE                   0x31
+#define REG_LR_INVERTIQ                             0x33
+#define REG_LR_DETECTIONTHRESHOLD                   0x37
+// end of documented register in datasheet
+// I/O settings
+#define REG_LR_DIOMAPPING1                          0x40
+#define REG_LR_DIOMAPPING2                          0x41
+// Version
+#define REG_LR_VERSION                              0x42
+// Additional settings
+#define REG_LR_PLLHOP                               0x44
+#define REG_LR_TCXO                                 0x4B
+#define REG_LR_PADAC                                0x4D
+#define REG_LR_FORMERTEMP                           0x5B
+#define REG_LR_BITRATEFRAC                          0x5D
+#define REG_LR_AGCREF                               0x61
+#define REG_LR_AGCTHRESH1                           0x62
+#define REG_LR_AGCTHRESH2                           0x63
+#define REG_LR_AGCTHRESH3                           0x64
+
+
+/*!
+ * SX1276 LoRa bit control definition
+ */
+
+/*!
+ * RegFifo
+ */
+
+/*!
+ * RegOpMode
+ */
+#define RFLR_OPMODE_LONGRANGEMODE_MASK              0x7F 
+#define RFLR_OPMODE_LONGRANGEMODE_OFF               0x00 // Default
+#define RFLR_OPMODE_LONGRANGEMODE_ON                0x80 
+
+#define RFLR_OPMODE_ACCESSSHAREDREG_MASK            0xBF 
+#define RFLR_OPMODE_ACCESSSHAREDREG_ENABLE          0x40 
+#define RFLR_OPMODE_ACCESSSHAREDREG_DISABLE         0x00 // Default
+
+#define RFLR_OPMODE_FREQMODE_ACCESS_MASK            0xF7
+#define RFLR_OPMODE_FREQMODE_ACCESS_LF              0x08 // Default
+#define RFLR_OPMODE_FREQMODE_ACCESS_HF              0x00 
+
+#define RFLR_OPMODE_MASK                            0xF8 
+#define RFLR_OPMODE_SLEEP                           0x00 
+#define RFLR_OPMODE_STANDBY                         0x01 // Default
+#define RFLR_OPMODE_SYNTHESIZER_TX                  0x02 
+#define RFLR_OPMODE_TRANSMITTER                     0x03 
+#define RFLR_OPMODE_SYNTHESIZER_RX                  0x04 
+#define RFLR_OPMODE_RECEIVER                        0x05 
+// LoRa specific modes
+#define RFLR_OPMODE_RECEIVER_SINGLE                 0x06 
+#define RFLR_OPMODE_CAD                             0x07 
+
+/*!
+ * RegBandSetting 
+ */
+#define RFLR_BANDSETTING_MASK                    0x3F 
+#define RFLR_BANDSETTING_AUTO                    0x00 // Default
+#define RFLR_BANDSETTING_DIV_BY_1                0x40
+#define RFLR_BANDSETTING_DIV_BY_2                0x80
+#define RFLR_BANDSETTING_DIV_BY_6                0xC0
+
+/*!
+ * RegFrf (MHz)
+ */
+ 
+#define RFLR_FRFMSB_434_MHZ                         0x6C // Default
+#define RFLR_FRFMID_434_MHZ                         0x80 // Default
+#define RFLR_FRFLSB_434_MHZ                         0x00 // Default
+
+#define RFLR_FRFMSB_863_MHZ                         0xD7
+#define RFLR_FRFMID_863_MHZ                         0xC0
+#define RFLR_FRFLSB_863_MHZ                         0x00
+#define RFLR_FRFMSB_864_MHZ                         0xD8
+#define RFLR_FRFMID_864_MHZ                         0x00
+#define RFLR_FRFLSB_864_MHZ                         0x00
+#define RFLR_FRFMSB_865_MHZ                         0xD8
+#define RFLR_FRFMID_865_MHZ                         0x40
+#define RFLR_FRFLSB_865_MHZ                         0x00
+#define RFLR_FRFMSB_866_MHZ                         0xD8
+#define RFLR_FRFMID_866_MHZ                         0x80
+#define RFLR_FRFLSB_866_MHZ                         0x00
+#define RFLR_FRFMSB_867_MHZ                         0xD8
+#define RFLR_FRFMID_867_MHZ                         0xC0
+#define RFLR_FRFLSB_867_MHZ                         0x00
+#define RFLR_FRFMSB_868_MHZ                         0xD9
+#define RFLR_FRFMID_868_MHZ                         0x00
+#define RFLR_FRFLSB_868_MHZ                         0x00
+#define RFLR_FRFMSB_869_MHZ                         0xD9
+#define RFLR_FRFMID_869_MHZ                         0x40
+#define RFLR_FRFLSB_869_MHZ                         0x00
+#define RFLR_FRFMSB_870_MHZ                         0xD9
+#define RFLR_FRFMID_870_MHZ                         0x80
+#define RFLR_FRFLSB_870_MHZ                         0x00
+
+#define RFLR_FRFMSB_902_MHZ                         0xE1
+#define RFLR_FRFMID_902_MHZ                         0x80
+#define RFLR_FRFLSB_902_MHZ                         0x00
+#define RFLR_FRFMSB_903_MHZ                         0xE1
+#define RFLR_FRFMID_903_MHZ                         0xC0
+#define RFLR_FRFLSB_903_MHZ                         0x00
+#define RFLR_FRFMSB_904_MHZ                         0xE2
+#define RFLR_FRFMID_904_MHZ                         0x00
+#define RFLR_FRFLSB_904_MHZ                         0x00
+#define RFLR_FRFMSB_905_MHZ                         0xE2
+#define RFLR_FRFMID_905_MHZ                         0x40
+#define RFLR_FRFLSB_905_MHZ                         0x00
+#define RFLR_FRFMSB_906_MHZ                         0xE2
+#define RFLR_FRFMID_906_MHZ                         0x80
+#define RFLR_FRFLSB_906_MHZ                         0x00
+#define RFLR_FRFMSB_907_MHZ                         0xE2
+#define RFLR_FRFMID_907_MHZ                         0xC0
+#define RFLR_FRFLSB_907_MHZ                         0x00
+#define RFLR_FRFMSB_908_MHZ                         0xE3
+#define RFLR_FRFMID_908_MHZ                         0x00
+#define RFLR_FRFLSB_908_MHZ                         0x00
+#define RFLR_FRFMSB_909_MHZ                         0xE3
+#define RFLR_FRFMID_909_MHZ                         0x40
+#define RFLR_FRFLSB_909_MHZ                         0x00
+#define RFLR_FRFMSB_910_MHZ                         0xE3
+#define RFLR_FRFMID_910_MHZ                         0x80
+#define RFLR_FRFLSB_910_MHZ                         0x00
+#define RFLR_FRFMSB_911_MHZ                         0xE3
+#define RFLR_FRFMID_911_MHZ                         0xC0
+#define RFLR_FRFLSB_911_MHZ                         0x00
+#define RFLR_FRFMSB_912_MHZ                         0xE4
+#define RFLR_FRFMID_912_MHZ                         0x00
+#define RFLR_FRFLSB_912_MHZ                         0x00
+#define RFLR_FRFMSB_913_MHZ                         0xE4
+#define RFLR_FRFMID_913_MHZ                         0x40
+#define RFLR_FRFLSB_913_MHZ                         0x00
+#define RFLR_FRFMSB_914_MHZ                         0xE4
+#define RFLR_FRFMID_914_MHZ                         0x80
+#define RFLR_FRFLSB_914_MHZ                         0x00
+#define RFLR_FRFMSB_915_MHZ                         0xE4  // Default
+#define RFLR_FRFMID_915_MHZ                         0xC0  // Default
+#define RFLR_FRFLSB_915_MHZ                         0x00  // Default
+#define RFLR_FRFMSB_916_MHZ                         0xE5
+#define RFLR_FRFMID_916_MHZ                         0x00
+#define RFLR_FRFLSB_916_MHZ                         0x00
+#define RFLR_FRFMSB_917_MHZ                         0xE5
+#define RFLR_FRFMID_917_MHZ                         0x40
+#define RFLR_FRFLSB_917_MHZ                         0x00
+#define RFLR_FRFMSB_918_MHZ                         0xE5
+#define RFLR_FRFMID_918_MHZ                         0x80
+#define RFLR_FRFLSB_918_MHZ                         0x00
+#define RFLR_FRFMSB_919_MHZ                         0xE5
+#define RFLR_FRFMID_919_MHZ                         0xC0
+#define RFLR_FRFLSB_919_MHZ                         0x00
+#define RFLR_FRFMSB_920_MHZ                         0xE6
+#define RFLR_FRFMID_920_MHZ                         0x00
+#define RFLR_FRFLSB_920_MHZ                         0x00
+#define RFLR_FRFMSB_921_MHZ                         0xE6
+#define RFLR_FRFMID_921_MHZ                         0x40
+#define RFLR_FRFLSB_921_MHZ                         0x00
+#define RFLR_FRFMSB_922_MHZ                         0xE6
+#define RFLR_FRFMID_922_MHZ                         0x80
+#define RFLR_FRFLSB_922_MHZ                         0x00
+#define RFLR_FRFMSB_923_MHZ                         0xE6
+#define RFLR_FRFMID_923_MHZ                         0xC0
+#define RFLR_FRFLSB_923_MHZ                         0x00
+#define RFLR_FRFMSB_924_MHZ                         0xE7
+#define RFLR_FRFMID_924_MHZ                         0x00
+#define RFLR_FRFLSB_924_MHZ                         0x00
+#define RFLR_FRFMSB_925_MHZ                         0xE7
+#define RFLR_FRFMID_925_MHZ                         0x40
+#define RFLR_FRFLSB_925_MHZ                         0x00
+#define RFLR_FRFMSB_926_MHZ                         0xE7
+#define RFLR_FRFMID_926_MHZ                         0x80
+#define RFLR_FRFLSB_926_MHZ                         0x00
+#define RFLR_FRFMSB_927_MHZ                         0xE7
+#define RFLR_FRFMID_927_MHZ                         0xC0
+#define RFLR_FRFLSB_927_MHZ                         0x00
+#define RFLR_FRFMSB_928_MHZ                         0xE8
+#define RFLR_FRFMID_928_MHZ                         0x00
+#define RFLR_FRFLSB_928_MHZ                         0x00
+
+/*!
+ * RegPaConfig
+ */
+#define RFLR_PACONFIG_PASELECT_MASK                 0x7F 
+#define RFLR_PACONFIG_PASELECT_PABOOST              0x80 
+#define RFLR_PACONFIG_PASELECT_RFO                  0x00 // Default
+
+#define RFLR_PACONFIG_MAX_POWER_MASK                0x8F
+
+#define RFLR_PACONFIG_OUTPUTPOWER_MASK              0xF0 
+ 
+/*!
+ * RegPaRamp
+ */
+#define RFLR_PARAMP_TXBANDFORCE_MASK                0xEF 
+#define RFLR_PARAMP_TXBANDFORCE_BAND_SEL            0x10 
+#define RFLR_PARAMP_TXBANDFORCE_AUTO                0x00 // Default
+
+#define RFLR_PARAMP_MASK                            0xF0 
+#define RFLR_PARAMP_3400_US                         0x00 
+#define RFLR_PARAMP_2000_US                         0x01 
+#define RFLR_PARAMP_1000_US                         0x02
+#define RFLR_PARAMP_0500_US                         0x03 
+#define RFLR_PARAMP_0250_US                         0x04 
+#define RFLR_PARAMP_0125_US                         0x05 
+#define RFLR_PARAMP_0100_US                         0x06 
+#define RFLR_PARAMP_0062_US                         0x07 
+#define RFLR_PARAMP_0050_US                         0x08 
+#define RFLR_PARAMP_0040_US                         0x09 // Default
+#define RFLR_PARAMP_0031_US                         0x0A 
+#define RFLR_PARAMP_0025_US                         0x0B 
+#define RFLR_PARAMP_0020_US                         0x0C 
+#define RFLR_PARAMP_0015_US                         0x0D 
+#define RFLR_PARAMP_0012_US                         0x0E 
+#define RFLR_PARAMP_0010_US                         0x0F 
+
+/*!
+ * RegOcp
+ */
+#define RFLR_OCP_MASK                               0xDF 
+#define RFLR_OCP_ON                                 0x20 // Default
+#define RFLR_OCP_OFF                                0x00   
+
+#define RFLR_OCP_TRIM_MASK                          0xE0
+#define RFLR_OCP_TRIM_045_MA                        0x00
+#define RFLR_OCP_TRIM_050_MA                        0x01   
+#define RFLR_OCP_TRIM_055_MA                        0x02 
+#define RFLR_OCP_TRIM_060_MA                        0x03 
+#define RFLR_OCP_TRIM_065_MA                        0x04 
+#define RFLR_OCP_TRIM_070_MA                        0x05 
+#define RFLR_OCP_TRIM_075_MA                        0x06 
+#define RFLR_OCP_TRIM_080_MA                        0x07  
+#define RFLR_OCP_TRIM_085_MA                        0x08
+#define RFLR_OCP_TRIM_090_MA                        0x09 
+#define RFLR_OCP_TRIM_095_MA                        0x0A 
+#define RFLR_OCP_TRIM_100_MA                        0x0B  // Default
+#define RFLR_OCP_TRIM_105_MA                        0x0C 
+#define RFLR_OCP_TRIM_110_MA                        0x0D 
+#define RFLR_OCP_TRIM_115_MA                        0x0E 
+#define RFLR_OCP_TRIM_120_MA                        0x0F 
+#define RFLR_OCP_TRIM_130_MA                        0x10
+#define RFLR_OCP_TRIM_140_MA                        0x11   
+#define RFLR_OCP_TRIM_150_MA                        0x12 
+#define RFLR_OCP_TRIM_160_MA                        0x13 
+#define RFLR_OCP_TRIM_170_MA                        0x14 
+#define RFLR_OCP_TRIM_180_MA                        0x15 
+#define RFLR_OCP_TRIM_190_MA                        0x16 
+#define RFLR_OCP_TRIM_200_MA                        0x17  
+#define RFLR_OCP_TRIM_210_MA                        0x18
+#define RFLR_OCP_TRIM_220_MA                        0x19 
+#define RFLR_OCP_TRIM_230_MA                        0x1A 
+#define RFLR_OCP_TRIM_240_MA                        0x1B
+
+/*!
+ * RegLna
+ */
+#define RFLR_LNA_GAIN_MASK                          0x1F 
+#define RFLR_LNA_GAIN_G1                            0x20 // Default
+#define RFLR_LNA_GAIN_G2                            0x40 
+#define RFLR_LNA_GAIN_G3                            0x60 
+#define RFLR_LNA_GAIN_G4                            0x80 
+#define RFLR_LNA_GAIN_G5                            0xA0 
+#define RFLR_LNA_GAIN_G6                            0xC0 
+
+#define RFLR_LNA_BOOST_LF_MASK                      0xE7 
+#define RFLR_LNA_BOOST_LF_DEFAULT                   0x00 // Default
+#define RFLR_LNA_BOOST_LF_GAIN                      0x08 
+#define RFLR_LNA_BOOST_LF_IP3                       0x10 
+#define RFLR_LNA_BOOST_LF_BOOST                     0x18 
+
+#define RFLR_LNA_RXBANDFORCE_MASK                   0xFB 
+#define RFLR_LNA_RXBANDFORCE_BAND_SEL               0x04
+#define RFLR_LNA_RXBANDFORCE_AUTO                   0x00 // Default
+
+#define RFLR_LNA_BOOST_HF_MASK                      0xFC 
+#define RFLR_LNA_BOOST_HF_OFF                       0x00 // Default
+#define RFLR_LNA_BOOST_HF_ON                        0x03 
+
+/*!
+ * RegFifoAddrPtr
+ */
+#define RFLR_FIFOADDRPTR                            0x00 // Default
+
+/*!
+ * RegFifoTxBaseAddr
+ */
+#define RFLR_FIFOTXBASEADDR                         0x80 // Default
+
+/*!
+ * RegFifoTxBaseAddr
+ */
+#define RFLR_FIFORXBASEADDR                         0x00 // Default
+
+/*!
+ * RegFifoRxCurrentAddr (Read Only)
+ */
+
+/*!
+ * RegIrqFlagsMask
+ */
+#define RFLR_IRQFLAGS_RXTIMEOUT_MASK                0x80 
+#define RFLR_IRQFLAGS_RXDONE_MASK                   0x40 
+#define RFLR_IRQFLAGS_PAYLOADCRCERROR_MASK          0x20 
+#define RFLR_IRQFLAGS_VALIDHEADER_MASK              0x10 
+#define RFLR_IRQFLAGS_TXDONE_MASK                   0x08 
+#define RFLR_IRQFLAGS_CADDONE_MASK                  0x04 
+#define RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL_MASK       0x02 
+#define RFLR_IRQFLAGS_CADDETECTED_MASK              0x01 
+
+/*!
+ * RegIrqFlags
+ */
+#define RFLR_IRQFLAGS_RXTIMEOUT                     0x80 
+#define RFLR_IRQFLAGS_RXDONE                        0x40 
+#define RFLR_IRQFLAGS_PAYLOADCRCERROR               0x20 
+#define RFLR_IRQFLAGS_VALIDHEADER                   0x10 
+#define RFLR_IRQFLAGS_TXDONE                        0x08 
+#define RFLR_IRQFLAGS_CADDONE                       0x04 
+#define RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL            0x02 
+#define RFLR_IRQFLAGS_CADDETECTED                   0x01 
+
+
+
+/*!
+ * RegFifoRxNbBytes (Read Only)    //
+ */
+
+ 
+ /*!
+ * RegRxHeaderCntValueMsb (Read Only)    //
+ */
+ 
+ 
+  /*!
+ * RegRxHeaderCntValueLsb (Read Only)    //
+ */
+ 
+ 
+/*!
+ * RegRxPacketCntValueMsb (Read Only)    //
+ */
+ 
+ 
+ /*!
+ * RegRxPacketCntValueLsb (Read Only)    //
+ */
+ 
+ 
+ /*!
+ * RegModemStat (Read Only)    //
+ */
+#define RFLR_MODEMSTAT_RX_CR_MASK                   0x1F 
+#define RFLR_MODEMSTAT_MODEM_STATUS_MASK            0xE0 
+ 
+/*!
+ * RegPktSnrValue (Read Only)    //
+ */
+
+ 
+ /*!
+ * RegPktRssiValue (Read Only)    //
+ */
+ 
+ 
+/*!
+ * RegRssiValue (Read Only)    //
+ */
+ 
+/*!
+ * RegHopChannel (Read Only)    //
+ */
+#define RFLR_HOP_CHANNEL_PAYLOAD_CRC_ON_MASK       0xBF
+#define RFLR_HOP_CHANNEL_PAYLOAD_CRC_ON            0x40
+#define RFLR_HOP_CHANNEL_PAYLOAD_CRC_OFF           0x00
+ 
+ /*!
+ * RegModemConfig1
+ */
+#define RFLR_MODEMCONFIG1_BW_MASK                   0x0F 
+
+#define RFLR_MODEMCONFIG1_BW_7_81_KHZ               0x00 
+#define RFLR_MODEMCONFIG1_BW_10_41_KHZ              0x10 
+#define RFLR_MODEMCONFIG1_BW_15_62_KHZ              0x20 
+#define RFLR_MODEMCONFIG1_BW_20_83_KHZ              0x30 
+#define RFLR_MODEMCONFIG1_BW_31_25_KHZ              0x40 
+#define RFLR_MODEMCONFIG1_BW_41_66_KHZ              0x50 
+#define RFLR_MODEMCONFIG1_BW_62_50_KHZ              0x60 
+#define RFLR_MODEMCONFIG1_BW_125_KHZ                0x70 // Default
+#define RFLR_MODEMCONFIG1_BW_250_KHZ                0x80 
+#define RFLR_MODEMCONFIG1_BW_500_KHZ                0x90 
+                                                    
+#define RFLR_MODEMCONFIG1_CODINGRATE_MASK           0xF1 
+#define RFLR_MODEMCONFIG1_CODINGRATE_4_5            0x02
+#define RFLR_MODEMCONFIG1_CODINGRATE_4_6            0x04 // Default
+#define RFLR_MODEMCONFIG1_CODINGRATE_4_7            0x06 
+#define RFLR_MODEMCONFIG1_CODINGRATE_4_8            0x08 
+                                                    
+#define RFLR_MODEMCONFIG1_IMPLICITHEADER_MASK       0xFE 
+#define RFLR_MODEMCONFIG1_IMPLICITHEADER_ON         0x01 
+#define RFLR_MODEMCONFIG1_IMPLICITHEADER_OFF        0x00 // Default
+
+ /*!
+ * RegModemConfig2
+ */
+#define RFLR_MODEMCONFIG2_SF_MASK                   0x0F 
+#define RFLR_MODEMCONFIG2_SF_6                      0x60 
+#define RFLR_MODEMCONFIG2_SF_7                      0x70 // Default
+#define RFLR_MODEMCONFIG2_SF_8                      0x80 
+#define RFLR_MODEMCONFIG2_SF_9                      0x90 
+#define RFLR_MODEMCONFIG2_SF_10                     0xA0 
+#define RFLR_MODEMCONFIG2_SF_11                     0xB0 
+#define RFLR_MODEMCONFIG2_SF_12                     0xC0 
+
+#define RFLR_MODEMCONFIG2_TXCONTINUOUSMODE_MASK     0xF7 
+#define RFLR_MODEMCONFIG2_TXCONTINUOUSMODE_ON       0x08 
+#define RFLR_MODEMCONFIG2_TXCONTINUOUSMODE_OFF      0x00 
+
+#define RFLR_MODEMCONFIG2_RXPAYLOADCRC_MASK         0xFB 
+#define RFLR_MODEMCONFIG2_RXPAYLOADCRC_ON           0x04 
+#define RFLR_MODEMCONFIG2_RXPAYLOADCRC_OFF          0x00 // Default
+ 
+#define RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK       0xFC 
+#define RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB            0x00 // Default
+                                                    
+                                                    
+/*!                                                 
+ * RegHopChannel (Read Only)                        
+ */                                                 
+#define RFLR_HOPCHANNEL_PLL_LOCK_TIMEOUT_MASK       0x7F 
+#define RFLR_HOPCHANNEL_PLL_LOCK_FAIL               0x80 
+#define RFLR_HOPCHANNEL_PLL_LOCK_SUCCEED            0x00 // Default
+                                                    
+#define RFLR_HOPCHANNEL_PAYLOAD_CRC16_MASK          0xBF
+#define RFLR_HOPCHANNEL_PAYLOAD_CRC16_ON            0x40
+#define RFLR_HOPCHANNEL_PAYLOAD_CRC16_OFF           0x00 // Default
+
+#define RFLR_HOPCHANNEL_CHANNEL_MASK                0x3F 
+
+
+/*!
+ * RegSymbTimeoutLsb
+ */
+#define RFLR_SYMBTIMEOUTLSB_SYMBTIMEOUT             0x64 // Default
+
+/*!
+ * RegPreambleLengthMsb
+ */
+#define RFLR_PREAMBLELENGTHMSB                      0x00 // Default
+
+/*!
+ * RegPreambleLengthLsb
+ */
+#define RFLR_PREAMBLELENGTHLSB                      0x08 // Default
+
+/*!
+ * RegPayloadLength
+ */
+#define RFLR_PAYLOADLENGTH                          0x0E // Default
+
+/*!
+ * RegPayloadMaxLength
+ */
+#define RFLR_PAYLOADMAXLENGTH                       0xFF // Default
+
+/*!
+ * RegHopPeriod
+ */
+#define RFLR_HOPPERIOD_FREQFOPPINGPERIOD            0x00 // Default
+
+
+/*!
+ * RegDioMapping1
+ */
+#define RFLR_DIOMAPPING1_DIO0_MASK                  0x3F
+#define RFLR_DIOMAPPING1_DIO0_00                    0x00  // Default
+#define RFLR_DIOMAPPING1_DIO0_01                    0x40
+#define RFLR_DIOMAPPING1_DIO0_10                    0x80
+#define RFLR_DIOMAPPING1_DIO0_11                    0xC0
+
+#define RFLR_DIOMAPPING1_DIO1_MASK                  0xCF
+#define RFLR_DIOMAPPING1_DIO1_00                    0x00  // Default
+#define RFLR_DIOMAPPING1_DIO1_01                    0x10
+#define RFLR_DIOMAPPING1_DIO1_10                    0x20
+#define RFLR_DIOMAPPING1_DIO1_11                    0x30
+
+#define RFLR_DIOMAPPING1_DIO2_MASK                  0xF3
+#define RFLR_DIOMAPPING1_DIO2_00                    0x00  // Default
+#define RFLR_DIOMAPPING1_DIO2_01                    0x04
+#define RFLR_DIOMAPPING1_DIO2_10                    0x08
+#define RFLR_DIOMAPPING1_DIO2_11                    0x0C
+
+#define RFLR_DIOMAPPING1_DIO3_MASK                  0xFC
+#define RFLR_DIOMAPPING1_DIO3_00                    0x00  // Default
+#define RFLR_DIOMAPPING1_DIO3_01                    0x01
+#define RFLR_DIOMAPPING1_DIO3_10                    0x02
+#define RFLR_DIOMAPPING1_DIO3_11                    0x03
+
+/*!
+ * RegDioMapping2
+ */
+#define RFLR_DIOMAPPING2_DIO4_MASK                  0x3F
+#define RFLR_DIOMAPPING2_DIO4_00                    0x00  // Default
+#define RFLR_DIOMAPPING2_DIO4_01                    0x40
+#define RFLR_DIOMAPPING2_DIO4_10                    0x80
+#define RFLR_DIOMAPPING2_DIO4_11                    0xC0
+
+#define RFLR_DIOMAPPING2_DIO5_MASK                  0xCF
+#define RFLR_DIOMAPPING2_DIO5_00                    0x00  // Default
+#define RFLR_DIOMAPPING2_DIO5_01                    0x10
+#define RFLR_DIOMAPPING2_DIO5_10                    0x20
+#define RFLR_DIOMAPPING2_DIO5_11                    0x30
+
+#define RFLR_DIOMAPPING2_MAP_MASK                   0xFE
+#define RFLR_DIOMAPPING2_MAP_PREAMBLEDETECT         0x01
+#define RFLR_DIOMAPPING2_MAP_RSSI                   0x00  // Default
+
+/*!
+ * RegVersion (Read Only)
+ */
+
+/*!
+ * RegAgcRef
+ */
+
+/*!
+ * RegAgcThresh1
+ */
+
+/*!
+ * RegAgcThresh2
+ */
+
+/*!
+ * RegAgcThresh3
+ */
+ 
+/*!
+ * RegFifoRxByteAddr (Read Only)
+ */
+ 
+/*!
+ * RegPllHop
+ */
+#define RFLR_PLLHOP_FASTHOP_MASK                    0x7F
+#define RFLR_PLLHOP_FASTHOP_ON                      0x80
+#define RFLR_PLLHOP_FASTHOP_OFF                     0x00 // Default
+
+/*!
+ * RegTcxo
+ */
+#define RFLR_TCXO_TCXOINPUT_MASK                    0xEF
+#define RFLR_TCXO_TCXOINPUT_ON                      0x10
+#define RFLR_TCXO_TCXOINPUT_OFF                     0x00  // Default
+
+/*!
+ * RegPaDac
+ */
+#define RFLR_PADAC_20DBM_MASK                       0xF8
+#define RFLR_PADAC_20DBM_ON                         0x07
+#define RFLR_PADAC_20DBM_OFF                        0x04  // Default
+
+/*!
+ * RegPll
+ */
+#define RFLR_PLL_BANDWIDTH_MASK                     0x3F
+#define RFLR_PLL_BANDWIDTH_75                       0x00
+#define RFLR_PLL_BANDWIDTH_150                      0x40
+#define RFLR_PLL_BANDWIDTH_225                      0x80
+#define RFLR_PLL_BANDWIDTH_300                      0xC0  // Default
+
+/*!
+ * RegPllLowPn
+ */
+#define RFLR_PLLLOWPN_BANDWIDTH_MASK                0x3F
+#define RFLR_PLLLOWPN_BANDWIDTH_75                  0x00
+#define RFLR_PLLLOWPN_BANDWIDTH_150                 0x40
+#define RFLR_PLLLOWPN_BANDWIDTH_225                 0x80
+#define RFLR_PLLLOWPN_BANDWIDTH_300                 0xC0  // Default
+
+/*!
+ * RegModemConfig3
+ */
+#define RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_MASK  0xF7 
+#define RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_ON    0x08 
+#define RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_OFF   0x00 // Default
+
+#define RFLR_MODEMCONFIG3_AGCAUTO_MASK              0xFB 
+#define RFLR_MODEMCONFIG3_AGCAUTO_ON                0x04 // Default 
+#define RFLR_MODEMCONFIG3_AGCAUTO_OFF               0x00 
+
+/*!
+ * RegFormerTemp
+ */
+
+typedef struct sSX1276LR
+{
+    uint8_t RegFifo;                                // 0x00 
+    // Common settings
+    uint8_t RegOpMode;                              // 0x01 
+    uint8_t RegRes02;                               // 0x02 
+    uint8_t RegRes03;                               // 0x03 
+    uint8_t RegBandSetting;                         // 0x04 
+    uint8_t RegRes05;                               // 0x05 
+    uint8_t RegFrfMsb;                              // 0x06 
+    uint8_t RegFrfMid;                              // 0x07 
+    uint8_t RegFrfLsb;                              // 0x08 
+    // Tx settings
+    uint8_t RegPaConfig;                            // 0x09 
+    uint8_t RegPaRamp;                              // 0x0A 
+    uint8_t RegOcp;                                 // 0x0B 
+    // Rx settings
+    uint8_t RegLna;                                 // 0x0C 
+    // LoRa registers
+    uint8_t RegFifoAddrPtr;                         // 0x0D 
+    uint8_t RegFifoTxBaseAddr;                      // 0x0E 
+    uint8_t RegFifoRxBaseAddr;                      // 0x0F 
+    uint8_t RegFifoRxCurrentAddr;                   // 0x10 
+    uint8_t RegIrqFlagsMask;                        // 0x11 
+    uint8_t RegIrqFlags;                            // 0x12 
+    uint8_t RegNbRxBytes;                           // 0x13 
+    uint8_t RegRxHeaderCntValueMsb;                 // 0x14 
+    uint8_t RegRxHeaderCntValueLsb;                 // 0x15 
+    uint8_t RegRxPacketCntValueMsb;                 // 0x16 
+    uint8_t RegRxPacketCntValueLsb;                 // 0x17 
+    uint8_t RegModemStat;                           // 0x18 
+    uint8_t RegPktSnrValue;                         // 0x19 
+    uint8_t RegPktRssiValue;                        // 0x1A 
+    uint8_t RegRssiValue;                           // 0x1B 
+    uint8_t RegHopChannel;                          // 0x1C 
+    uint8_t RegModemConfig1;                        // 0x1D 
+    uint8_t RegModemConfig2;                        // 0x1E 
+    uint8_t RegSymbTimeoutLsb;                      // 0x1F 
+    uint8_t RegPreambleMsb;                         // 0x20 
+    uint8_t RegPreambleLsb;                         // 0x21 
+    uint8_t RegPayloadLength;                       // 0x22 
+    uint8_t RegMaxPayloadLength;                    // 0x23 
+    uint8_t RegHopPeriod;                           // 0x24 
+    uint8_t RegFifoRxByteAddr;                      // 0x25
+    uint8_t RegModemConfig3;                        // 0x26
+    uint8_t RegTestReserved27;                      // 0x27
+    uint8_t RegFeiMsb;                              // 0x28
+    uint8_t RegFeiMib;                              // 0x29 
+    uint8_t RegFeiLsb;                              // 0x2A
+    uint8_t RegTestReserved2B[0x30 - 0x2B];         // 0x2B-0x30 
+    uint8_t RegDetectOptimize;                      // 0x31    
+    uint8_t RegTestReserved32;                      // 0x32   
+    uint8_t RegInvertIQ;                            // 0x33 
+    uint8_t RegTestReserved34[0x36 - 0x34];         // 0x34-0x36 
+    uint8_t RegDetectionThreshold;                  // 0x37
+    uint8_t RegTestReserved38[0x3F - 0x38];         // 0x38-0x3F
+    // I/O settings                
+    uint8_t RegDioMapping1;                         // 0x40 
+    uint8_t RegDioMapping2;                         // 0x41 
+    // Version
+    uint8_t RegVersion;                             // 0x42
+    // Test   
+    uint8_t RegTestReserved43;                      // 0x43
+    // Additional settings
+    uint8_t RegPllHop;                              // 0x44 
+    // Test
+    uint8_t RegTestReserved45[0x4A - 0x45];         // 0x45-0x4A   
+    // Additional settings    
+    uint8_t RegTcxo;                                // 0x4B
+    // Test    
+    uint8_t RegTestReserved4C;                      // 0x4C  
+    // Additional settings    
+    uint8_t RegPaDac;                               // 0x4D 
+    // Test    
+    uint8_t RegTestReserved4E[0x5A - 0x4E];         // 0x4E-0x5A  
+    // Additional settings
+    uint8_t RegFormerTemp;                          // 0x5B
+    // Test    
+    uint8_t RegTestReserved5C;                      // 0x5C
+    // Additional settings    
+    uint8_t RegBitrateFrac;                         // 0x5D   
+    // Additional settings    
+    uint8_t RegTestReserved5E[0x60 - 0x5E];         // 0x5E-0x60
+    // Additional settings
+    uint8_t RegAgcRef;                              // 0x60
+    uint8_t RegAgcThresh1;                          // 0x61
+    uint8_t RegAgcThresh2;                          // 0x62
+    uint8_t RegAgcThresh3;                          // 0x63
+    // Test
+    uint8_t RegTestReserved64[0x70 - 0x64];         // 0x64-0x70
+}tSX1276LR;
+
+extern tSX1276LR* SX1276LR;
+
+/*!
+ * \brief Initializes the SX1276
+ */
+void SX1276LoRaInit( void );
+
+/*!
+ * \brief Sets the SX1276 to datasheet default values
+ */
+void SX1276LoRaSetDefaults( void );
+
+/*!
+ * \brief Enables/Disables the LoRa modem
+ *
+ * \param [IN]: enable [true, false]
+ */
+void SX1276LoRaSetLoRaOn( bool enable );
+
+/*!
+ * \brief Sets the SX1276 operating mode
+ *
+ * \param [IN] opMode New operating mode
+ */
+void SX1276LoRaSetOpMode( uint8_t opMode );
+
+/*!
+ * \brief Gets the SX1276 operating mode
+ *
+ * \retval opMode Current operating mode
+ */
+uint8_t SX1276LoRaGetOpMode( void );
+
+/*!
+ * \brief Reads the current Rx gain setting
+ *
+ * \retval rxGain Current gain setting
+ */
+uint8_t SX1276LoRaReadRxGain( void );
+
+/*!
+ * \brief Trigs and reads the current RSSI value
+ *
+ * \retval rssiValue Current RSSI value in [dBm]
+ */
+double SX1276LoRaReadRssi( void );
+
+/*!
+ * \brief Gets the Rx gain value measured while receiving the packet
+ *
+ * \retval rxGainValue Current Rx gain value
+ */
+uint8_t SX1276LoRaGetPacketRxGain( void );
+
+/*!
+ * \brief Gets the SNR value measured while receiving the packet
+ *
+ * \retval snrValue Current SNR value in [dB]
+ */
+int8_t SX1276LoRaGetPacketSnr( void );
+
+/*!
+ * \brief Gets the RSSI value measured while receiving the packet
+ *
+ * \retval rssiValue Current RSSI value in [dBm]
+ */
+double SX1276LoRaGetPacketRssi( void );
+
+/*!
+ * \brief Sets the radio in Rx mode. Waiting for a packet
+ */
+void SX1276LoRaStartRx( void );
+
+/*!
+ * \brief Gets a copy of the current received buffer
+ *
+ * \param [IN]: buffer     Buffer pointer
+ * \param [IN]: size       Buffer size
+ */
+void SX1276LoRaGetRxPacket( void *buffer, uint16_t *size );
+
+/*!
+ * \brief Sets a copy of the buffer to be transmitted
+ *
+ * \param [IN]: buffer     Buffer pointer
+ * \param [IN]: size       Buffer size
+ */
+void SX1276LoRaSetTxPacket( const void *buffer, uint16_t size );
+
+/*!
+ * \brief Gets the current RFState
+ *
+ * \retval rfState Current RF state [RF_IDLE, RF_BUSY, 
+ *                                   RF_RX_DONE, RF_RX_TIMEOUT,
+ *                                   RF_TX_DONE, RF_TX_TIMEOUT]
+ */
+uint8_t SX1276LoRaGetRFState( void );
+
+/*!
+ * \brief Sets the new state of the RF state machine
+ *
+ * \param [IN]: state New RF state machine state
+ */
+void SX1276LoRaSetRFState( uint8_t state );
+
+/*!
+ * \brief Process the LoRa modem Rx and Tx state machines depending on the
+ *        SX1276 operating mode.
+ *
+ * \retval rfState Current RF state [RF_IDLE, RF_BUSY, 
+ *                                   RF_RX_DONE, RF_RX_TIMEOUT,
+ *                                   RF_TX_DONE, RF_TX_TIMEOUT]
+ */
+uint32_t SX1276LoRaProcess( void );
+
+#endif //__SX1276_LORA_H__

APP/network_mgr/lora/Radio/inc/sx1276-LoRaMisc.h

@@ -0,0 +1,316 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276-LoRaMisc.h
+ * \brief      SX1276 RF chip high level functions driver
+ *
+ * \remark     Optional support functions.
+ *             These functions are defined only to easy the change of the
+ *             parameters.
+ *             For a final firmware the radio parameters will be known so
+ *             there is no need to support all possible parameters.
+ *             Removing these functions will greatly reduce the final firmware
+ *             size.
+ *
+ * \version    2.0.B2 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#ifndef __SX1276_LORA_MISC_H__
+#define __SX1276_LORA_MISC_H__
+
+
+/*!
+ * \brief Writes the new RF frequency value
+ *
+ * \param [IN] freq New RF frequency value in [Hz]
+ */
+void SX1276LoRaSetRFFrequency( uint32_t freq );
+
+/*!
+ * \brief Reads the current RF frequency value
+ *
+ * \retval freq Current RF frequency value in [Hz]
+ */
+uint32_t SX1276LoRaGetRFFrequency( void );
+
+/*!
+ * \brief Writes the new RF output power value
+ *
+ * \param [IN] power New output power value in [dBm]
+ */
+void SX1276LoRaSetRFPower( int8_t power );
+
+/*!
+ * \brief Reads the current RF output power value
+ *
+ * \retval power Current output power value in [dBm]
+ */
+int8_t SX1276LoRaGetRFPower( void );
+
+/*!
+ * \brief Writes the new Signal Bandwidth value
+ *
+ * \remark This function sets the IF frequency according to the datasheet
+ *
+ * \param [IN] factor New Signal Bandwidth value [0: 125 kHz, 1: 250 kHz, 2: 500 kHz]
+ */
+void SX1276LoRaSetSignalBandwidth( uint8_t bw );
+
+/*!
+ * \brief Reads the current Signal Bandwidth value
+ *
+ * \retval factor Current Signal Bandwidth value [0: 125 kHz, 1: 250 kHz, 2: 500 kHz] 
+ */
+uint8_t SX1276LoRaGetSignalBandwidth( void );
+
+/*!
+ * \brief Writes the new Spreading Factor value
+ *
+ * \param [IN] factor New Spreading Factor value [7, 8, 9, 10, 11, 12]
+ */
+void SX1276LoRaSetSpreadingFactor( uint8_t factor );
+
+/*!
+ * \brief Reads the current Spreading Factor value
+ *
+ * \retval factor Current Spreading Factor value [7, 8, 9, 10, 11, 12] 
+ */
+uint8_t SX1276LoRaGetSpreadingFactor( void );
+
+/*!
+ * \brief Writes the new Error Coding value
+ *
+ * \param [IN] value New Error Coding value [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
+ */
+void SX1276LoRaSetErrorCoding( uint8_t value );
+
+/*!
+ * \brief Reads the current Error Coding value
+ *
+ * \retval value Current Error Coding value [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
+ */
+uint8_t SX1276LoRaGetErrorCoding( void );
+
+/*!
+ * \brief Enables/Disables the packet CRC generation
+ *
+ * \param [IN] enaable [true, false]
+ */
+void SX1276LoRaSetPacketCrcOn( bool enable );
+
+/*!
+ * \brief Reads the current packet CRC generation status
+ *
+ * \retval enable [true, false]
+ */
+bool SX1276LoRaGetPacketCrcOn( void );
+
+/*!
+ * \brief Enables/Disables the Implicit Header mode in LoRa
+ *
+ * \param [IN] enable [true, false]
+ */
+void SX1276LoRaSetImplicitHeaderOn( bool enable );
+
+/*!
+ * \brief Check if implicit header mode in LoRa in enabled or disabled
+ *
+ * \retval enable [true, false]
+ */
+bool SX1276LoRaGetImplicitHeaderOn( void );
+
+/*!
+ * \brief Enables/Disables Rx single instead of Rx continuous
+ *
+ * \param [IN] enable [true, false]
+ */
+void SX1276LoRaSetRxSingleOn( bool enable );
+
+/*!
+ * \brief Check if LoRa is in Rx Single mode
+ *
+ * \retval enable [true, false]
+ */
+bool SX1276LoRaGetRxSingleOn( void );
+
+/*!
+ * \brief Enables/Disables the frequency hopping 
+ *
+ * \param [IN] enable [true, false]
+ */
+ 
+void SX1276LoRaSetFreqHopOn( bool enable );
+
+/*!
+ * \brief Get the frequency hopping status 
+ *
+ * \param [IN] enable [true, false]
+ */
+bool SX1276LoRaGetFreqHopOn( void );
+
+/*!
+ * \brief Set symbol period between frequency hops
+ *
+ * \param [IN] value
+ */
+void SX1276LoRaSetHopPeriod( uint8_t value );
+
+/*!
+ * \brief Get symbol period between frequency hops
+ *
+ * \retval value symbol period between frequency hops
+ */
+uint8_t SX1276LoRaGetHopPeriod( void );
+
+/*!
+ * \brief Set timeout Tx packet (based on MCU timer, timeout between Tx Mode entry Tx Done IRQ)
+ *
+ * \param [IN] value timeout (ms)
+ */
+void SX1276LoRaSetTxPacketTimeout( uint32_t value );
+
+/*!
+ * \brief Get timeout between Tx packet (based on MCU timer, timeout between Tx Mode entry Tx Done IRQ)
+ *
+ * \retval value timeout (ms)
+ */
+uint32_t SX1276LoRaGetTxPacketTimeout( void );
+
+/*!
+ * \brief Set timeout Rx packet (based on MCU timer, timeout between Rx Mode entry and Rx Done IRQ)
+ *
+ * \param [IN] value timeout (ms)
+ */
+void SX1276LoRaSetRxPacketTimeout( uint32_t value );
+
+/*!
+ * \brief Get timeout Rx packet (based on MCU timer, timeout between Rx Mode entry and Rx Done IRQ)
+ *
+ * \retval value timeout (ms)
+ */
+uint32_t SX1276LoRaGetRxPacketTimeout( void );
+
+/*!
+ * \brief Set payload length
+ *
+ * \param [IN] value payload length
+ */
+void SX1276LoRaSetPayloadLength( uint8_t value );
+
+/*!
+ * \brief Get payload length
+ *
+ * \retval value payload length
+ */
+uint8_t SX1276LoRaGetPayloadLength( void );
+
+/*!
+ * \brief Enables/Disables the 20 dBm PA
+ *
+ * \param [IN] enable [true, false]
+ */
+void SX1276LoRaSetPa20dBm( bool enale );
+
+/*!
+ * \brief Gets the current 20 dBm PA status
+ *
+ * \retval enable [true, false]
+ */
+bool SX1276LoRaGetPa20dBm( void );
+
+/*!
+ * \brief Set the RF Output pin 
+ *
+ * \param [IN] RF_PACONFIG_PASELECT_PABOOST or RF_PACONFIG_PASELECT_RFO
+ */
+void SX1276LoRaSetPAOutput( uint8_t outputPin );
+
+/*!
+ * \brief Gets the used RF Ouptut pin
+ *
+ * \retval RF_PACONFIG_PASELECT_PABOOST or RF_PACONFIG_PASELECT_RFO
+ */
+uint8_t SX1276LoRaGetPAOutput( void );
+
+/*!
+ * \brief Writes the new PA rise/fall time of ramp up/down value
+ *
+ * \param [IN] value New PaRamp value
+ */
+void SX1276LoRaSetPaRamp( uint8_t value );
+
+/*!
+ * \brief Reads the current PA rise/fall time of ramp up/down value
+ *
+ * \retval freq Current PaRamp value
+ */
+uint8_t SX1276LoRaGetPaRamp( void );
+
+/*!
+ * \brief Set Symbol Timeout based on symbol length
+ *
+ * \param [IN] value number of symbol
+ */
+void SX1276LoRaSetSymbTimeout( uint16_t value );
+
+/*!
+ * \brief  Get Symbol Timeout based on symbol length
+ *
+ * \retval value number of symbol
+ */
+uint16_t SX1276LoRaGetSymbTimeout( void );
+
+/*!
+ * \brief  Configure the device to optimize low datarate transfers
+ *
+ * \param [IN] enable Enables/Disables the low datarate optimization
+ */
+void SX1276LoRaSetLowDatarateOptimize( bool enable );
+
+/*!
+ * \brief  Get the status of optimize low datarate transfers
+ *
+ * \retval LowDatarateOptimize enable or disable
+ */
+bool SX1276LoRaGetLowDatarateOptimize( void );
+
+/*!
+ * \brief Get the preamble length
+ *
+ * \retval value preamble length
+ */
+uint16_t SX1276LoRaGetPreambleLength( void );
+
+/*!
+ * \brief Set the preamble length
+ *
+ * \param [IN] value preamble length
+ */
+void SX1276LoRaSetPreambleLength( uint16_t value );
+
+/*!
+ * \brief Set the number or rolling preamble symbol needed for detection
+ *
+ * \param [IN] value number of preamble symbol
+ */
+void SX1276LoRaSetNbTrigPeaks( uint8_t value );
+
+/*!
+ * \brief Get the number or rolling preamble symbol needed for detection
+ *
+ * \retval value number of preamble symbol
+ */
+uint8_t SX1276LoRaGetNbTrigPeaks( void );
+#endif //__SX1276_LORA_MISC_H__
+

APP/network_mgr/lora/Radio/inc/sx1276.h

@@ -0,0 +1,165 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276.h
+ * \brief      SX1276 RF chip driver
+ *
+ * \version    2.0.B2 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#ifndef __SX1276_H__
+#define __SX1276_H__
+
+/*!
+ * \brief SX1276 registers array
+ */
+extern uint8_t SX1276Regs[0x70];
+
+/*!
+ * \brief Enables LoRa modem or FSK modem
+ *
+ * \param [IN] opMode New operating mode
+ */
+void SX1276SetLoRaOn( bool enable );
+
+/*!
+ * \brief Gets the LoRa modem state
+ *
+ * \retval LoraOn Current LoRa modem mode
+ */
+bool SX1276GetLoRaOn( void );
+
+/*!
+ * \brief Initializes the SX1276
+ */
+void SX1276Init( void );
+
+/*!
+ * \brief Resets the SX1276
+ */
+void SX1276Reset( void );
+
+/*!
+ * \brief Sets the SX1276 operating mode
+ *
+ * \param [IN] opMode New operating mode
+ */
+void SX1276SetOpMode( uint8_t opMode );
+
+/*!
+ * \brief Gets the SX1276 operating mode
+ *
+ * \retval opMode Current operating mode
+ */
+uint8_t SX1276GetOpMode( void );
+
+/*!
+ * \brief Reads the current Rx gain setting
+ *
+ * \retval rxGain Current gain setting
+ */
+uint8_t SX1276ReadRxGain( void );
+
+/*!
+ * \brief Trigs and reads the current RSSI value
+ *
+ * \retval rssiValue Current RSSI value in [dBm]
+ */
+double SX1276ReadRssi( void );
+
+/*!
+ * \brief Gets the Rx gain value measured while receiving the packet
+ *
+ * \retval rxGainValue Current Rx gain value
+ */
+uint8_t SX1276GetPacketRxGain( void );
+
+/*!
+ * \brief Gets the SNR value measured while receiving the packet
+ *
+ * \retval snrValue Current SNR value in [dB]
+ */
+int8_t SX1276GetPacketSnr( void );
+
+/*!
+ * \brief Gets the RSSI value measured while receiving the packet
+ *
+ * \retval rssiValue Current RSSI value in [dBm]
+ */
+double SX1276GetPacketRssi( void );
+
+/*!
+ * \brief Gets the AFC value measured while receiving the packet
+ *
+ * \retval afcValue Current AFC value in [Hz]
+ */
+uint32_t SX1276GetPacketAfc( void );
+
+/*!
+ * \brief Sets the radio in Rx mode. Waiting for a packet
+ */
+void SX1276StartRx( void );
+
+/*!
+ * \brief Sets the radio in Tx mode. Sending a packet
+ */
+void SX1276StartTx( void );
+/*!
+ * \brief Gets a copy of the current received buffer
+ *
+ * \param [IN]: buffer     Buffer pointer
+ * \param [IN]: size       Buffer size
+ */
+void SX1276GetRxPacket( void *buffer, uint16_t *size );
+
+/*!
+ * \brief Sets a copy of the buffer to be transmitted and starts the
+ *        transmission
+ *
+ * \param [IN]: buffer     Buffer pointer
+ * \param [IN]: size       Buffer size
+ */
+void SX1276SetTxPacket( const void *buffer, uint16_t size );
+
+/*!
+ * \brief Gets the current RFState
+ *
+ * \retval rfState Current RF state [RF_IDLE, RF_BUSY, 
+ *                                   RF_RX_DONE, RF_RX_TIMEOUT,
+ *                                   RF_TX_DONE, RF_TX_TIMEOUT]
+ */
+uint8_t SX1276GetRFState( void );
+
+/*!
+ * \brief Sets the new state of the RF state machine
+ *
+ * \param [IN]: state New RF state machine state
+ */
+void SX1276SetRFState( uint8_t state );
+
+/*!
+ * \brief Process the Rx and Tx state machines depending on the
+ *       SX1276 operating mode.
+ *
+ * \retval rfState Current RF state [RF_IDLE, RF_BUSY, 
+ *                                   RF_RX_DONE, RF_RX_TIMEOUT,
+ *                                   RF_TX_DONE, RF_TX_TIMEOUT]
+ */
+uint32_t SX1276Process( void );
+
+void EnterTestMode(void);
+void EnterRxTestMode(void);
+
+#endif //__SX1276_H__
+

APP/network_mgr/lora/Radio/inc/sx12xxEiger.h

@@ -0,0 +1,84 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx12xxEiger.h
+ * \brief        
+ *
+ * \version    1.0
+ * \date       Nov 21 2012
+ * \author     Miguel Luis
+ */
+#ifndef __SX12XXEIGER_H__
+#define __SX12XXEIGER_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#if defined( STM32F4XX ) || defined( STM32F429_439xx )
+    #include "stm32f4xx.h"
+#elif defined( STM32F2XX )
+    #include "stm32f2xx.h"
+#else
+   #include "stm32f10x.h"
+#endif
+
+#define USE_USB                                     1
+
+#if defined( STM32F4XX ) || defined( STM32F2XX ) || defined( STM32F429_439xx )
+#define BACKUP_REG_BOOTLOADER                       RTC_BKP_DR0      /* Booloader enter*/
+#else
+#define BACKUP_REG_BOOTLOADER                       BKP_DR1          /* Booloader enter*/
+#endif
+
+#define FW_VERSION                                  "2.1.0"
+#define SK_NAME                                     "SX12xxEiger"
+
+/*!
+ * Functions return codes definition
+ */
+typedef enum
+{
+    SX_OK,
+    SX_ERROR,
+    SX_BUSY,
+    SX_EMPTY,
+    SX_DONE,
+    SX_TIMEOUT,
+    SX_UNSUPPORTED,
+    SX_WAIT,
+    SX_CLOSE,
+    SX_YES,
+    SX_NO,          
+}tReturnCodes;
+
+extern volatile uint32_t TickCounter;
+
+/**
+  * @brief   Small printf for GCC/RAISONANCE
+  */
+#ifdef __GNUC__
+/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
+   set to 'Yes') calls __io_putchar() */
+#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
+
+#endif /* __GNUC__ */
+
+
+/*!
+ * \brief Computes a random number between min and max
+ *
+ * \param [IN] min range minimum value
+ * \param [IN] max range maximum value
+ * \retval random random value in range min..max
+ */
+uint32_t randr( uint32_t min, uint32_t max );
+
+#endif // __SX12XXEIGER_H__

APP/network_mgr/lora/Radio/src/crc.c

@@ -0,0 +1,47 @@
+#include "crc.h"
+
+
+uint16_t ComputeCrc( uint16_t crc, uint8_t dataByte, uint16_t polynomial )
+{
+  uint8_t i;
+  
+  for( i = 0; i < 8; i++ )
+  {
+   if( ( ( ( crc & 0x8000 ) >> 8 ) ^ ( dataByte & 0x80 ) ) != 0 )
+   {
+     crc <<= 1; // shift left once
+     crc ^= polynomial; // XOR with polynomial
+   }
+   else
+   { 
+     crc <<= 1; // shift left once
+   }
+   dataByte <<= 1; // Next data bit
+  }
+  return crc;
+}
+
+
+uint16_t RadioComputeCRC( uint8_t *buffer, uint8_t length, uint8_t crcType )
+{
+  uint8_t i = 0;
+  uint16_t crc = 0;
+  uint16_t polynomial = 0;
+  
+  polynomial = ( crcType == CRC_TYPE_IBM ) ? POLYNOMIAL_IBM : POLYNOMIAL_CCITT;
+  crc = ( crcType == CRC_TYPE_IBM ) ? CRC_IBM_SEED : CRC_CCITT_SEED;
+  for( i = 0; i < length; i++ )
+  {
+   crc = ComputeCrc( crc, buffer[i], polynomial );
+  }
+  if( crcType == CRC_TYPE_IBM )
+  {
+   return crc;
+  }
+  else
+  {
+   return( ( uint16_t ) ( ~crc ));
+   }
+}
+
+

APP/network_mgr/lora/Radio/src/fifo.c

@@ -0,0 +1,44 @@
+
+#include "fifo.h"
+
+static uint16_t FifoNext( tFifo *fifo, uint16_t index )
+{
+	return ( index + 1 ) % fifo->Size;
+}
+
+void FifoInit( tFifo *fifo, uint16_t *buffer, uint16_t size )
+{	fifo->Begin = 0;
+	fifo->End = 0;
+	fifo->Data = buffer;
+	fifo->Size = size;
+}
+
+void FifoPush( tFifo *fifo, uint16_t data )
+{
+	fifo->End = FifoNext( fifo, fifo->End );
+	fifo->Data[fifo->End] = data;
+}
+
+uint16_t FifoPop( tFifo *fifo )
+{
+	uint16_t data = fifo->Data[FifoNext( fifo, fifo->Begin )];
+
+	fifo->Begin = FifoNext( fifo, fifo->Begin );
+	return data;
+}
+
+void FifoFlush( tFifo *fifo )
+{
+	fifo->Begin = 0;
+	fifo->End = 0;
+}
+
+bool IsFifoEmpty( tFifo *fifo )
+{
+	return ( fifo->Begin == fifo->End );
+}
+
+bool IsFifoFull( tFifo *fifo )
+{
+	return ( FifoNext( fifo, fifo->End ) == fifo->Begin );
+}

APP/network_mgr/lora/Radio/src/radio.c

@@ -0,0 +1,66 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       radio.c
+ * \brief      Generic radio driver ( radio abstraction )
+ *
+ * \version    2.0.0 
+ * \date       Nov 21 2012
+ * \author     Miguel Luis
+ *
+ * Last modified by Gregory Cristian on Apr 25 2013
+ */
+#include "platform.h"
+#include "radio.h"
+
+#if defined( USE_SX1232_RADIO )
+    #include "sx1232.h"
+#elif defined( USE_SX1272_RADIO )
+    #include "sx1272.h"
+#elif defined( USE_SX1276_RADIO )
+    #include "sx1276.h"
+#else
+    #error "Missing define: USE_XXXXXX_RADIO (ie. USE_SX1272_RADIO)"
+#endif    
+
+ #include "sx1276.h"
+tRadioDriver RadioDriver;
+
+tRadioDriver* RadioDriverInit( void )
+{
+#if defined( USE_SX1232_RADIO )
+    RadioDriver.Init = SX1232Init;
+    RadioDriver.Reset = SX1232Reset;
+    RadioDriver.StartRx = SX1232StartRx;
+    RadioDriver.GetRxPacket = SX1232GetRxPacket;
+    RadioDriver.SetTxPacket = SX1232SetTxPacket;
+    RadioDriver.Process = SX1232Process;
+#elif defined( USE_SX1272_RADIO )
+    RadioDriver.Init = SX1272Init;
+    RadioDriver.Reset = SX1272Reset;
+    RadioDriver.StartRx = SX1272StartRx;
+    RadioDriver.GetRxPacket = SX1272GetRxPacket;
+    RadioDriver.SetTxPacket = SX1272SetTxPacket;
+    RadioDriver.Process = SX1272Process;
+#elif defined( USE_SX1276_RADIO )
+    RadioDriver.Init = SX1276Init;
+    RadioDriver.Reset = SX1276Reset;
+    RadioDriver.StartRx = SX1276StartRx;
+    RadioDriver.StartTx = SX1276StartTx;
+    RadioDriver.GetRxPacket = SX1276GetRxPacket;
+    RadioDriver.SetTxPacket = SX1276SetTxPacket;
+    RadioDriver.Process = SX1276Process;
+#else
+    #error "Missing define: USE_XXXXXX_RADIO (ie. USE_SX1272_RADIO)"
+#endif    
+
+    return &RadioDriver;
+}

APP/network_mgr/lora/Radio/src/sx1276-Fsk.c

@@ -0,0 +1,603 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276.c
+ * \brief      SX1276 RF chip driver
+ *
+ * \version    2.0.0 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#include <string.h>
+#include <math.h>
+#include "platform.h"
+
+#if defined( USE_SX1276_RADIO )
+
+#include "radio.h"
+#include "sx1276-Hal.h"
+#include "sx1276.h"
+#include "sx1276-FskMisc.h"
+#include "sx1276-Fsk.h"
+
+// Default settings
+tFskSettings FskSettings = 
+{
+    434000000,      // RFFrequency
+    1200,           // Bitrate
+    50000,          // Fdev  50000
+    20,             // Power
+    10000,         // RxBw
+    150000,         // RxBwAfc
+    true,           // CrcOn
+    false,           // AfcOn    
+    255             // PayloadLength (set payload size to the maximum for variable mode, else set the exact payload length)
+};
+
+/*!
+ * SX1276 FSK registers variable
+ */
+tSX1276* SX1276;
+
+/*!
+ * Local RF buffer for communication support
+ */
+static uint8_t RFBuffer[RF_BUFFER_SIZE];
+
+/*!
+ * Chunk size of data write in buffer 
+ */
+static uint8_t DataChunkSize = 32;
+
+
+/*!
+ * RF state machine variable
+ */
+static uint8_t RFState = RF_STATE_IDLE;
+
+/*!
+ * Rx management support variables
+ */
+
+/*!
+ * PacketTimeout holds the RF packet timeout
+ * SyncSize = [0..8]
+ * VariableSize = [0;1]
+ * AddressSize = [0;1]
+ * PayloadSize = [0..RF_BUFFER_SIZE]
+ * CrcSize = [0;2]
+ * PacketTimeout = ( ( 8 * ( VariableSize + AddressSize + PayloadSize + CrcSize ) / BR ) * 1000.0 ) + 1
+ * Computed timeout is in miliseconds
+ */
+static uint32_t PacketTimeout;
+
+/*!
+ * Preamble2SyncTimeout
+ * Preamble2SyncTimeout = ( ( 8 * ( PremableSize + SyncSize ) / RFBitrate ) * 1000.0 ) + 1
+ * Computed timeout is in miliseconds
+ */
+static uint32_t Preamble2SyncTimeout;
+
+static bool PreambleDetected = false;
+static bool SyncWordDetected = false;
+static bool PacketDetected = false;
+static uint16_t RxPacketSize = 0;
+static uint8_t RxBytesRead = 0;
+static uint8_t TxBytesSent = 0;
+static double RxPacketRssiValue;
+static uint32_t RxPacketAfcValue;
+static uint8_t RxGain = 1;
+static uint32_t RxTimeoutTimer = 0;
+static uint32_t Preamble2SyncTimer = 0;
+
+/*!
+ * Tx management support variables
+ */
+static uint16_t TxPacketSize = 0;
+static uint32_t TxTimeoutTimer = 0;
+
+void SX1276FskInit( void )
+{
+    RFState = RF_STATE_IDLE;
+
+    SX1276FskSetDefaults( );
+    
+    SX1276ReadBuffer( REG_OPMODE, SX1276Regs + 1, 0x70 - 1 );
+
+    // Set the device in FSK mode and Sleep Mode
+    SX1276->RegOpMode = RF_OPMODE_MODULATIONTYPE_FSK | RF_OPMODE_SLEEP;
+    SX1276Write( REG_OPMODE, SX1276->RegOpMode );
+
+    SX1276->RegPaRamp = RF_PARAMP_MODULATIONSHAPING_01;
+    SX1276Write( REG_PARAMP, SX1276->RegPaRamp );
+
+    SX1276->RegLna = RF_LNA_GAIN_G1;
+    SX1276Write( REG_LNA, SX1276->RegLna );
+
+    if( FskSettings.AfcOn == true )
+    {
+        SX1276->RegRxConfig = RF_RXCONFIG_RESTARTRXONCOLLISION_OFF | RF_RXCONFIG_AFCAUTO_ON |
+                              RF_RXCONFIG_AGCAUTO_ON | RF_RXCONFIG_RXTRIGER_PREAMBLEDETECT;
+    }
+    else
+    {
+        SX1276->RegRxConfig = RF_RXCONFIG_RESTARTRXONCOLLISION_OFF | RF_RXCONFIG_AFCAUTO_OFF |
+                              RF_RXCONFIG_AGCAUTO_ON | RF_RXCONFIG_RXTRIGER_PREAMBLEDETECT;
+    }
+
+    SX1276->RegPreambleLsb = 8;
+    
+    SX1276->RegPreambleDetect = RF_PREAMBLEDETECT_DETECTOR_ON | RF_PREAMBLEDETECT_DETECTORSIZE_2 |
+                                RF_PREAMBLEDETECT_DETECTORTOL_10;
+
+    SX1276->RegRssiThresh = 0xFF;
+
+    SX1276->RegSyncConfig = RF_SYNCCONFIG_AUTORESTARTRXMODE_WAITPLL_ON | RF_SYNCCONFIG_PREAMBLEPOLARITY_AA |
+                            RF_SYNCCONFIG_SYNC_ON |
+                            RF_SYNCCONFIG_SYNCSIZE_4;
+
+    SX1276->RegSyncValue1 = 0x69;
+    SX1276->RegSyncValue2 = 0x81;
+    SX1276->RegSyncValue3 = 0x7E;
+    SX1276->RegSyncValue4 = 0x96;
+
+    SX1276->RegPacketConfig1 = RF_PACKETCONFIG1_PACKETFORMAT_VARIABLE | RF_PACKETCONFIG1_DCFREE_OFF |
+                               ( FskSettings.CrcOn << 4 ) | RF_PACKETCONFIG1_CRCAUTOCLEAR_ON |
+                               RF_PACKETCONFIG1_ADDRSFILTERING_OFF | RF_PACKETCONFIG1_CRCWHITENINGTYPE_CCITT;
+    SX1276FskGetPacketCrcOn( ); // Update CrcOn on FskSettings
+
+    SX1276->RegPayloadLength = FskSettings.PayloadLength;
+
+    // we can now update the registers with our configuration
+    SX1276WriteBuffer( REG_OPMODE, SX1276Regs + 1, 0x70 - 1 );
+
+    // then we need to set the RF settings 
+    SX1276FskSetRFFrequency( FskSettings.RFFrequency );
+    SX1276FskSetBitrate( FskSettings.Bitrate );
+    SX1276FskSetFdev( FskSettings.Fdev );
+
+    SX1276FskSetDccBw( &SX1276->RegRxBw, 0, FskSettings.RxBw );
+    SX1276FskSetDccBw( &SX1276->RegAfcBw, 0, FskSettings.RxBwAfc );
+    SX1276FskSetRssiOffset( 0 );
+
+#if( ( MODULE_SX1276RF1IAS == 1 ) || ( MODULE_SX1276RF1KAS == 1 ) )
+    if( FskSettings.RFFrequency > 860000000 )
+    {
+        SX1276FskSetPAOutput( RF_PACONFIG_PASELECT_RFO );
+        SX1276FskSetPa20dBm( false );
+        FskSettings.Power = 14;
+        SX1276FskSetRFPower( FskSettings.Power );
+    }
+    else
+    {
+        SX1276FskSetPAOutput( RF_PACONFIG_PASELECT_PABOOST );
+        SX1276FskSetPa20dBm( true );
+        FskSettings.Power = 20;
+        SX1276FskSetRFPower( FskSettings.Power );
+    } 
+#elif( MODULE_SX1276RF1JAS == 1 )
+    if( FskSettings.RFFrequency > 860000000 )
+    {
+        SX1276FskSetPAOutput( RF_PACONFIG_PASELECT_PABOOST );
+        SX1276FskSetPa20dBm( true );
+        FskSettings.Power = 20;
+        SX1276FskSetRFPower( FskSettings.Power );
+    }
+    else
+    {
+        SX1276FskSetPAOutput( RF_PACONFIG_PASELECT_RFO );
+        SX1276FskSetPa20dBm( false );
+        FskSettings.Power = 14;
+        SX1276FskSetRFPower( FskSettings.Power );
+    } 
+#endif
+
+    SX1276FskSetOpMode( RF_OPMODE_STANDBY );
+
+    // Calibrate the HF
+    SX1276FskRxCalibrate( );
+}
+
+void SX1276FskSetDefaults( void )
+{
+    // REMARK: See SX1276 datasheet for modified default values.
+
+    SX1276Read( REG_VERSION, &SX1276->RegVersion );
+}
+
+void SX1276FskSetOpMode( uint8_t opMode )
+{
+    static uint8_t opModePrev = RF_OPMODE_STANDBY;
+    static bool antennaSwitchTxOnPrev = true;
+    bool antennaSwitchTxOn = false;
+
+    opModePrev = SX1276->RegOpMode & ~RF_OPMODE_MASK;
+
+    if( opMode != opModePrev )
+    {
+        if( opMode == RF_OPMODE_TRANSMITTER )
+        {
+            antennaSwitchTxOn = true;
+        }
+        else
+        {
+            antennaSwitchTxOn = false;
+        }
+        if( antennaSwitchTxOn != antennaSwitchTxOnPrev )
+        {
+            antennaSwitchTxOnPrev = antennaSwitchTxOn;
+            RXTX( antennaSwitchTxOn ); // Antenna switch control
+        }
+        SX1276->RegOpMode = ( SX1276->RegOpMode & RF_OPMODE_MASK ) | opMode;
+
+        SX1276Write( REG_OPMODE, SX1276->RegOpMode );        
+    }
+}
+
+uint8_t SX1276FskGetOpMode( void )
+{
+    SX1276Read( REG_OPMODE, &SX1276->RegOpMode );
+    
+    return SX1276->RegOpMode & ~RF_OPMODE_MASK;
+}
+
+int32_t SX1276FskReadFei( void )
+{
+    SX1276ReadBuffer( REG_FEIMSB, &SX1276->RegFeiMsb, 2 );                          // Reads the FEI value
+
+    return ( int32_t )(( double )( ( ( uint16_t )SX1276->RegFeiMsb << 8 ) | ( uint16_t )SX1276->RegFeiLsb ) * ( double )FREQ_STEP);
+}
+
+int32_t SX1276FskReadAfc( void )
+{
+    SX1276ReadBuffer( REG_AFCMSB, &SX1276->RegAfcMsb, 2 );                            // Reads the AFC value
+    return ( int32_t )(( double )( ( ( uint16_t )SX1276->RegAfcMsb << 8 ) | ( uint16_t )SX1276->RegAfcLsb ) * ( double )FREQ_STEP);
+}
+
+uint8_t SX1276FskReadRxGain( void )
+{
+    SX1276Read( REG_LNA, &SX1276->RegLna );
+    return( SX1276->RegLna >> 5 ) & 0x07;
+}
+
+double SX1276FskReadRssi( void )
+{
+    SX1276Read( REG_RSSIVALUE, &SX1276->RegRssiValue );                               // Reads the RSSI value
+
+    return -( double )( ( double )SX1276->RegRssiValue / 2.0 );
+}
+
+uint8_t SX1276FskGetPacketRxGain( void )
+{
+    return RxGain;
+}
+
+double SX1276FskGetPacketRssi( void )
+{
+    return RxPacketRssiValue;
+}
+
+uint32_t SX1276FskGetPacketAfc( void )
+{
+    return RxPacketAfcValue;
+}
+
+void SX1276FskStartRx( void )
+{
+    SX1276FskSetRFState( RF_STATE_RX_INIT );
+}
+
+void SX1276FskGetRxPacket( void *buffer, uint16_t *size )
+{
+    *size = RxPacketSize;
+    RxPacketSize = 0;
+    memcpy( ( void * )buffer, ( void * )RFBuffer, ( size_t )*size );
+}
+
+void SX1276FskSetTxPacket( const void *buffer, uint16_t size )
+{
+    TxPacketSize = size;
+    memcpy( ( void * )RFBuffer, buffer, ( size_t )TxPacketSize ); 
+
+    RFState = RF_STATE_TX_INIT;
+}
+
+// Remark: SX1276 must be fully initialized before calling this function
+uint16_t SX1276FskGetPacketPayloadSize( void )
+{
+    uint16_t syncSize;
+    uint16_t variableSize;
+    uint16_t addressSize;
+    uint16_t payloadSize;
+    uint16_t crcSize;
+
+    syncSize = ( SX1276->RegSyncConfig & 0x07 ) + 1;
+    variableSize = ( ( SX1276->RegPacketConfig1 & 0x80 ) == 0x80 ) ? 1 : 0;
+    addressSize = ( ( SX1276->RegPacketConfig1 & 0x06 ) != 0x00 ) ? 1 : 0;
+    payloadSize = SX1276->RegPayloadLength;
+    crcSize = ( ( SX1276->RegPacketConfig1 & 0x10 ) == 0x10 ) ? 2 : 0;
+    
+    return syncSize + variableSize + addressSize + payloadSize + crcSize;
+}
+
+// Remark: SX1276 must be fully initialized before calling this function
+uint16_t SX1276FskGetPacketHeaderSize( void )
+{
+    uint16_t preambleSize;
+    uint16_t syncSize;
+
+    preambleSize = ( ( uint16_t )SX1276->RegPreambleMsb << 8 ) | ( uint16_t )SX1276->RegPreambleLsb;
+    syncSize = ( SX1276->RegSyncConfig & 0x07 ) + 1;
+    
+    return preambleSize + syncSize;
+}
+
+uint8_t SX1276FskGetRFState( void )
+{
+    return RFState;
+}
+
+void SX1276FskSetRFState( uint8_t state )
+{
+    RFState = state;
+}
+
+uint32_t SX1276FskProcess( void )
+{
+    uint32_t result = RF_BUSY;
+
+    switch( RFState )
+    {
+    case RF_STATE_IDLE:
+        break;
+    // Rx management
+    case RF_STATE_RX_INIT:
+        // DIO mapping setup
+        if( ( SX1276->RegPacketConfig1 & RF_PACKETCONFIG1_CRC_ON ) == RF_PACKETCONFIG1_CRC_ON )
+        {
+            //                           CrcOk,                   FifoLevel,               SyncAddr,               FifoEmpty
+            SX1276->RegDioMapping1 = RF_DIOMAPPING1_DIO0_01 | RF_DIOMAPPING1_DIO1_00 | RF_DIOMAPPING1_DIO2_11 | RF_DIOMAPPING1_DIO3_00;
+        }
+        else
+        {
+            //                           PayloadReady,            FifoLevel,               SyncAddr,               FifoEmpty
+            SX1276->RegDioMapping1 = RF_DIOMAPPING1_DIO0_00 | RF_DIOMAPPING1_DIO1_00 | RF_DIOMAPPING1_DIO2_11 | RF_DIOMAPPING1_DIO3_00;
+        }
+        //                          Preamble,                   Data
+        SX1276->RegDioMapping2 = RF_DIOMAPPING2_DIO4_11 | RF_DIOMAPPING2_DIO5_10 | RF_DIOMAPPING2_MAP_PREAMBLEDETECT;
+        SX1276WriteBuffer( REG_DIOMAPPING1, &SX1276->RegDioMapping1, 2 );
+
+        SX1276FskSetOpMode( RF_OPMODE_RECEIVER );
+    
+        memset( RFBuffer, 0, ( size_t )RF_BUFFER_SIZE );
+
+        PacketTimeout = ( uint16_t )( round( ( 8.0 * ( ( double )SX1276FskGetPacketPayloadSize( ) ) / ( double )FskSettings.Bitrate ) * 1000.0 ) + 1.0 );
+        PacketTimeout = PacketTimeout + ( PacketTimeout >> 1 ); // Set the Packet timeout as 1.5 times the full payload transmission time
+
+        Preamble2SyncTimeout = PacketTimeout;
+
+        Preamble2SyncTimer = RxTimeoutTimer = GET_TICK_COUNT( );
+
+        SX1276->RegFifoThresh = RF_FIFOTHRESH_TXSTARTCONDITION_FIFONOTEMPTY | 0x20; // 32 bytes of data
+        SX1276Write( REG_FIFOTHRESH, SX1276->RegFifoThresh );
+
+        PreambleDetected = false;
+        SyncWordDetected = false;
+        PacketDetected = false;
+        RxBytesRead = 0;
+        RxPacketSize = 0;
+        RFState = RF_STATE_RX_SYNC;
+        break;
+    case RF_STATE_RX_SYNC:
+        if( ( DIO4 == 1 ) && ( PreambleDetected == false ) )// Preamble
+        {
+            PreambleDetected = true;
+            Preamble2SyncTimer = GET_TICK_COUNT( );
+        }
+        if( ( DIO2 == 1 ) && ( PreambleDetected == true ) && ( SyncWordDetected == false ) ) // SyncAddr
+        {
+            SyncWordDetected = true;
+        
+            RxPacketRssiValue = SX1276FskReadRssi( );
+
+            RxPacketAfcValue = SX1276FskReadAfc( );
+            RxGain = SX1276FskReadRxGain( );
+        
+            Preamble2SyncTimer = RxTimeoutTimer = GET_TICK_COUNT( );
+
+            RFState = RF_STATE_RX_RUNNING;
+        }
+
+        // Preamble 2 SyncAddr timeout
+        if( ( SyncWordDetected == false ) && ( PreambleDetected == true ) && ( ( GET_TICK_COUNT( ) - Preamble2SyncTimer ) > Preamble2SyncTimeout ) )
+        {
+            RFState = RF_STATE_RX_INIT;
+            SX1276Write( REG_RXCONFIG, SX1276->RegRxConfig | RF_RXCONFIG_RESTARTRXWITHPLLLOCK );
+        }
+        if( ( SyncWordDetected == false ) &&
+            ( PreambleDetected == false ) &&
+            ( PacketDetected == false ) &&
+            ( ( GET_TICK_COUNT( ) - RxTimeoutTimer ) > PacketTimeout ) )
+        {
+            RFState = RF_STATE_RX_TIMEOUT;
+        }
+        break;
+    case RF_STATE_RX_RUNNING:
+        if( RxPacketSize > RF_BUFFER_SIZE_MAX )
+        {
+            RFState = RF_STATE_RX_LEN_ERROR;
+            break;
+        }
+#if 1
+        if( DIO1 == 1 ) // FifoLevel
+        {
+            if( ( RxPacketSize == 0 ) && ( RxBytesRead == 0 ) ) // Read received packet size
+            {
+                if( ( SX1276->RegPacketConfig1 & RF_PACKETCONFIG1_PACKETFORMAT_VARIABLE ) == RF_PACKETCONFIG1_PACKETFORMAT_VARIABLE )
+                {
+                    SX1276ReadFifo( ( uint8_t* )&RxPacketSize, 1 );
+                }
+                else
+                {
+                    RxPacketSize = SX1276->RegPayloadLength;
+                }
+            }
+
+            if( ( RxPacketSize - RxBytesRead ) > ( SX1276->RegFifoThresh & 0x3F ) )
+            {
+                SX1276ReadFifo( ( RFBuffer + RxBytesRead ), ( SX1276->RegFifoThresh & 0x3F ) );
+                RxBytesRead += ( SX1276->RegFifoThresh & 0x3F );
+            }
+            else
+            {
+                SX1276ReadFifo( ( RFBuffer + RxBytesRead ), RxPacketSize - RxBytesRead );
+                RxBytesRead += ( RxPacketSize - RxBytesRead );
+            }
+        }
+#endif
+        if( DIO0 == 1 ) // PayloadReady/CrcOk
+        {
+            RxTimeoutTimer = GET_TICK_COUNT( );
+            if( ( RxPacketSize == 0 ) && ( RxBytesRead == 0 ) ) // Read received packet size
+            {
+                if( ( SX1276->RegPacketConfig1 & RF_PACKETCONFIG1_PACKETFORMAT_VARIABLE ) == RF_PACKETCONFIG1_PACKETFORMAT_VARIABLE )
+                {
+                    SX1276ReadFifo( ( uint8_t* )&RxPacketSize, 1 );
+                }
+                else
+                {
+                    RxPacketSize = SX1276->RegPayloadLength;
+                }
+                SX1276ReadFifo( RFBuffer + RxBytesRead, RxPacketSize - RxBytesRead );
+                RxBytesRead += ( RxPacketSize - RxBytesRead );
+                PacketDetected = true;
+                RFState = RF_STATE_RX_DONE;
+            }
+            else
+            {
+                SX1276ReadFifo( RFBuffer + RxBytesRead, RxPacketSize - RxBytesRead );
+                RxBytesRead += ( RxPacketSize - RxBytesRead );
+                PacketDetected = true;
+                RFState = RF_STATE_RX_DONE;
+            }
+        }
+        
+        // Packet timeout
+        if( ( PacketDetected == false ) && ( ( GET_TICK_COUNT( ) - RxTimeoutTimer ) > PacketTimeout ) )
+        {
+            RFState = RF_STATE_RX_TIMEOUT;
+        }
+        break;
+    case RF_STATE_RX_DONE:
+        RxBytesRead = 0;
+        RFState = RF_STATE_RX_INIT;
+        result = RF_RX_DONE;
+        break;
+    case RF_STATE_RX_TIMEOUT:
+        RxBytesRead = 0;
+        RxPacketSize = 0;
+        SX1276Write( REG_RXCONFIG, SX1276->RegRxConfig | RF_RXCONFIG_RESTARTRXWITHPLLLOCK );
+        RFState = RF_STATE_RX_INIT;
+        result = RF_RX_TIMEOUT;
+        break;
+    case RF_STATE_RX_LEN_ERROR:
+        RxBytesRead = 0;
+        RxPacketSize = 0;
+        SX1276Write( REG_RXCONFIG, SX1276->RegRxConfig | RF_RXCONFIG_RESTARTRXWITHPLLLOCK );
+        RFState = RF_STATE_RX_INIT;
+        result = RF_LEN_ERROR;
+        break;
+    // Tx management
+    case RF_STATE_TX_INIT:
+        // Packet DIO mapping setup
+        //                           PacketSent,               FifoLevel,              FifoFull,               TxReady
+        SX1276->RegDioMapping1 = RF_DIOMAPPING1_DIO0_00 | RF_DIOMAPPING1_DIO1_00 | RF_DIOMAPPING1_DIO2_00 | RF_DIOMAPPING1_DIO3_01;
+        //                           LowBat,                   Data
+        SX1276->RegDioMapping2 = RF_DIOMAPPING2_DIO4_00 | RF_DIOMAPPING2_DIO5_10;
+        SX1276WriteBuffer( REG_DIOMAPPING1, &SX1276->RegDioMapping1, 2 );
+
+        SX1276->RegFifoThresh = RF_FIFOTHRESH_TXSTARTCONDITION_FIFONOTEMPTY | 0x18; // 24 bytes of data
+        SX1276Write( REG_FIFOTHRESH, SX1276->RegFifoThresh );
+
+        SX1276FskSetOpMode( RF_OPMODE_TRANSMITTER );
+        RFState = RF_STATE_TX_READY_WAIT;
+        TxBytesSent = 0;
+        break;
+    case RF_STATE_TX_READY_WAIT:
+        if( DIO3 == 1 )    // TxReady
+        {
+            if( ( SX1276->RegPacketConfig1 & RF_PACKETCONFIG1_PACKETFORMAT_VARIABLE ) == RF_PACKETCONFIG1_PACKETFORMAT_VARIABLE )
+            {
+                SX1276WriteFifo( ( uint8_t* )&TxPacketSize, 1 );
+            }
+            
+            if( ( TxPacketSize > 0 ) && ( TxPacketSize <= 64 ) )
+            {
+                DataChunkSize = TxPacketSize;
+            }
+            else
+            {
+                DataChunkSize = 32;
+            }
+            
+            SX1276WriteFifo( RFBuffer, DataChunkSize );
+            TxBytesSent += DataChunkSize;
+            TxTimeoutTimer = GET_TICK_COUNT( );
+            RFState = RF_STATE_TX_RUNNING;
+        }
+        break;
+
+    case RF_STATE_TX_RUNNING:
+        if( DIO1 == 0 )    // FifoLevel below thresold
+        {  
+            if( ( TxPacketSize - TxBytesSent ) > DataChunkSize )
+            {
+                SX1276WriteFifo( ( RFBuffer + TxBytesSent ), DataChunkSize );
+                TxBytesSent += DataChunkSize;
+            }
+            else 
+            {
+                // we write the last chunk of data
+                SX1276WriteFifo( RFBuffer + TxBytesSent, TxPacketSize - TxBytesSent );
+                TxBytesSent += TxPacketSize - TxBytesSent;
+            }
+        }
+
+        if( DIO0 == 1 ) // PacketSent
+        {
+            TxTimeoutTimer = GET_TICK_COUNT( );
+            RFState = RF_STATE_TX_DONE;
+            SX1276FskSetOpMode( RF_OPMODE_STANDBY );
+        }
+         
+        // Packet timeout
+        if( ( GET_TICK_COUNT( ) - TxTimeoutTimer ) > TICK_RATE_MS( 1000 ) )
+        {
+            RFState = RF_STATE_TX_TIMEOUT;
+        }
+        break;
+    case RF_STATE_TX_DONE:
+        RFState = RF_STATE_IDLE;
+        result = RF_TX_DONE;
+        break;
+    case RF_STATE_TX_TIMEOUT:
+        RFState = RF_STATE_IDLE;
+        result = RF_TX_TIMEOUT;
+        break;
+    default:
+        break;
+    }
+    return result;
+}
+
+#endif // USE_SX1276_RADIO

APP/network_mgr/lora/Radio/src/sx1276-FskMisc.c

@@ -0,0 +1,523 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276-FskMisc.c
+ * \brief      SX1276 RF chip high level functions driver
+ *
+ * \remark     Optional support functions.
+ *             These functions are defined only to easy the change of the
+ *             parameters.
+ *             For a final firmware the radio parameters will be known so
+ *             there is no need to support all possible parameters.
+ *             Removing these functions will greatly reduce the final firmware
+ *             size.
+ *
+ * \version    2.0.0 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#include <math.h>
+
+#include "platform.h"
+
+#if defined( USE_SX1276_RADIO )
+
+#include "sx1276-Hal.h"
+#include "sx1276.h"
+
+#include "sx1276-Fsk.h"
+#include "sx1276-FskMisc.h"
+
+extern tFskSettings FskSettings;
+
+void SX1276FskSetRFFrequency( uint32_t freq )
+{
+    FskSettings.RFFrequency = freq;
+    
+    freq = ( uint32_t )( ( double )freq / ( double )FREQ_STEP );
+    SX1276->RegFrfMsb = ( uint8_t )( ( freq >> 16 ) & 0xFF );
+    SX1276->RegFrfMid = ( uint8_t )( ( freq >> 8 ) & 0xFF );
+    SX1276->RegFrfLsb = ( uint8_t )( freq & 0xFF );
+    SX1276WriteBuffer( REG_FRFMSB, &SX1276->RegFrfMsb, 3 );
+}
+
+uint32_t SX1276FskGetRFFrequency( void )
+{
+    SX1276ReadBuffer( REG_FRFMSB, &SX1276->RegFrfMsb, 3 );
+    FskSettings.RFFrequency = ( ( uint32_t )SX1276->RegFrfMsb << 16 ) | ( ( uint32_t )SX1276->RegFrfMid << 8 ) | ( ( uint32_t )SX1276->RegFrfLsb );
+    FskSettings.RFFrequency = ( uint32_t )( ( double )FskSettings.RFFrequency * ( double )FREQ_STEP );
+
+    return FskSettings.RFFrequency;
+}
+
+void SX1276FskRxCalibrate( void )
+{
+    // the function RadioRxCalibrate is called just after the reset so all register are at their default values
+    uint8_t regPaConfigInitVal;
+    uint32_t initialFreq;
+
+    // save register values;
+    SX1276Read( REG_PACONFIG, &regPaConfigInitVal );
+    initialFreq = SX1276FskGetRFFrequency( );
+
+    // Cut the PA just in case
+    SX1276->RegPaConfig = 0x00; // RFO output, power = -1 dBm
+    SX1276Write( REG_PACONFIG, SX1276->RegPaConfig );
+
+    // Set Frequency in HF band
+    SX1276FskSetRFFrequency( 860000000 );
+
+    // Rx chain re-calibration workaround
+    SX1276Read( REG_IMAGECAL, &SX1276->RegImageCal );    
+    SX1276->RegImageCal = ( SX1276->RegImageCal & RF_IMAGECAL_IMAGECAL_MASK ) | RF_IMAGECAL_IMAGECAL_START;
+    SX1276Write( REG_IMAGECAL, SX1276->RegImageCal );
+
+    SX1276Read( REG_IMAGECAL, &SX1276->RegImageCal );
+    // rx_cal_run goes low when calibration in finished
+    while( ( SX1276->RegImageCal & RF_IMAGECAL_IMAGECAL_RUNNING ) == RF_IMAGECAL_IMAGECAL_RUNNING )
+    {
+        SX1276Read( REG_IMAGECAL, &SX1276->RegImageCal );
+    }
+
+    // reload saved values into the registers
+    SX1276->RegPaConfig = regPaConfigInitVal;
+    SX1276Write( REG_PACONFIG, SX1276->RegPaConfig );
+
+    SX1276FskSetRFFrequency( initialFreq );
+
+}
+
+void SX1276FskSetBitrate( uint32_t bitrate )
+{
+    FskSettings.Bitrate = bitrate;
+    
+    bitrate = ( uint16_t )( ( double )XTAL_FREQ / ( double )bitrate );
+    SX1276->RegBitrateMsb    = ( uint8_t )( bitrate >> 8 );
+    SX1276->RegBitrateLsb    = ( uint8_t )( bitrate & 0xFF );
+    SX1276WriteBuffer( REG_BITRATEMSB, &SX1276->RegBitrateMsb, 2 );    
+}
+
+uint32_t SX1276FskGetBitrate( void )
+{
+    SX1276ReadBuffer( REG_BITRATEMSB, &SX1276->RegBitrateMsb, 2 );
+    FskSettings.Bitrate = ( ( ( uint32_t )SX1276->RegBitrateMsb << 8 ) | ( ( uint32_t )SX1276->RegBitrateLsb ) );
+    FskSettings.Bitrate = ( uint16_t )( ( double )XTAL_FREQ / ( double )FskSettings.Bitrate );
+
+    return FskSettings.Bitrate;
+}
+
+void SX1276FskSetFdev( uint32_t fdev )
+{
+    FskSettings.Fdev = fdev;
+    
+    SX1276Read( REG_FDEVMSB, &SX1276->RegFdevMsb ); 
+
+    fdev = ( uint16_t )( ( double )fdev / ( double )FREQ_STEP );
+    SX1276->RegFdevMsb    = ( ( SX1276->RegFdevMsb & RF_FDEVMSB_FDEV_MASK ) | ( ( ( uint8_t )( fdev >> 8 ) ) & ~RF_FDEVMSB_FDEV_MASK ) );
+    SX1276->RegFdevLsb    = ( uint8_t )( fdev & 0xFF );
+    SX1276WriteBuffer( REG_FDEVMSB, &SX1276->RegFdevMsb, 2 );    
+}
+
+uint32_t SX1276FskGetFdev( void )
+{
+    SX1276ReadBuffer( REG_FDEVMSB, &SX1276->RegFdevMsb, 2 );
+    FskSettings.Fdev = ( ( ( uint32_t )( ( SX1276->RegFdevMsb << 8 ) & ~RF_FDEVMSB_FDEV_MASK ) ) | ( ( uint32_t )SX1276->RegFdevLsb ) );
+    FskSettings.Fdev = ( uint16_t )( ( double )FskSettings.Fdev * ( double )FREQ_STEP );
+
+    return FskSettings.Fdev;
+}
+
+void SX1276FskSetRFPower( int8_t power )
+{
+    SX1276Read( REG_PACONFIG, &SX1276->RegPaConfig );
+    SX1276Read( REG_PADAC, &SX1276->RegPaDac );
+    
+    if( ( SX1276->RegPaConfig & RF_PACONFIG_PASELECT_PABOOST ) == RF_PACONFIG_PASELECT_PABOOST )
+    {
+        if( ( SX1276->RegPaDac & 0x87 ) == 0x87 )
+        {
+            if( power < 5 )
+            {
+                power = 5;
+            }
+            if( power > 20 )
+            {
+                power = 20;
+            }
+            SX1276->RegPaConfig = ( SX1276->RegPaConfig & RF_PACONFIG_MAX_POWER_MASK ) | 0x70;
+            SX1276->RegPaConfig = ( SX1276->RegPaConfig & RF_PACONFIG_OUTPUTPOWER_MASK ) | ( uint8_t )( ( uint16_t )( power - 5 ) & 0x0F );
+        }
+        else
+        {
+            if( power < 2 )
+            {
+                power = 2;
+            }
+            if( power > 17 )
+            {
+                power = 17;
+            }
+            SX1276->RegPaConfig = ( SX1276->RegPaConfig & RF_PACONFIG_MAX_POWER_MASK ) | 0x70;
+            SX1276->RegPaConfig = ( SX1276->RegPaConfig & RF_PACONFIG_OUTPUTPOWER_MASK ) | ( uint8_t )( ( uint16_t )( power - 2 ) & 0x0F );
+        }
+    }
+    else
+    {
+        if( power < -1 )
+        {
+            power = -1;
+        }
+        if( power > 14 )
+        {
+            power = 14;
+        }
+        SX1276->RegPaConfig = ( SX1276->RegPaConfig & RF_PACONFIG_MAX_POWER_MASK ) | 0x70;
+        SX1276->RegPaConfig = ( SX1276->RegPaConfig & RF_PACONFIG_OUTPUTPOWER_MASK ) | ( uint8_t )( ( uint16_t )( power + 1 ) & 0x0F );
+    }
+    SX1276Write( REG_PACONFIG, SX1276->RegPaConfig );
+    FskSettings.Power = power;
+}
+
+int8_t SX1276FskGetRFPower( void )
+{
+    SX1276Read( REG_PACONFIG, &SX1276->RegPaConfig );
+    SX1276Read( REG_PADAC, &SX1276->RegPaDac );
+
+    if( ( SX1276->RegPaConfig & RF_PACONFIG_PASELECT_PABOOST ) == RF_PACONFIG_PASELECT_PABOOST )
+    {
+        if( ( SX1276->RegPaDac & 0x07 ) == 0x07 )
+        {
+            FskSettings.Power = 5 + ( SX1276->RegPaConfig & ~RF_PACONFIG_OUTPUTPOWER_MASK );
+        }
+        else
+        {
+            FskSettings.Power = 2 + ( SX1276->RegPaConfig & ~RF_PACONFIG_OUTPUTPOWER_MASK );
+        }
+    }
+    else
+    {
+        FskSettings.Power = -1 + ( SX1276->RegPaConfig & ~RF_PACONFIG_OUTPUTPOWER_MASK );
+    }
+    return FskSettings.Power;
+}
+
+/*!
+ * \brief Computes the Rx bandwidth with the mantisse and exponent
+ *
+ * \param [IN] mantisse Mantisse of the bandwidth value
+ * \param [IN] exponent Exponent of the bandwidth value
+ * \retval bandwidth Computed bandwidth
+ */
+static uint32_t SX1276FskComputeRxBw( uint8_t mantisse, uint8_t exponent )
+{
+    // rxBw
+    if( ( SX1276->RegOpMode & RF_OPMODE_MODULATIONTYPE_FSK ) == RF_OPMODE_MODULATIONTYPE_FSK )
+    {
+        return ( uint32_t )( ( double )XTAL_FREQ / ( mantisse * ( double )pow( 2, exponent + 2 ) ) );
+    }
+    else
+    {
+        return ( uint32_t )( ( double )XTAL_FREQ / ( mantisse * ( double )pow( 2, exponent + 3 ) ) );
+    }
+}
+
+/*!
+ * \brief Computes the mantisse and exponent from the bandwitdh value
+ *
+ * \param [IN] rxBwValue Bandwidth value
+ * \param [OUT] mantisse Mantisse of the bandwidth value
+ * \param [OUT] exponent Exponent of the bandwidth value
+ */
+static void SX1276FskComputeRxBwMantExp( uint32_t rxBwValue, uint8_t* mantisse, uint8_t* exponent )
+{
+    uint8_t tmpExp = 0;
+    uint8_t tmpMant = 0;
+
+    double tmpRxBw = 0;
+    double rxBwMin = 10e6;
+
+    for( tmpExp = 0; tmpExp < 8; tmpExp++ )
+    {
+        for( tmpMant = 16; tmpMant <= 24; tmpMant += 4 )
+        {
+            if( ( SX1276->RegOpMode & RF_OPMODE_MODULATIONTYPE_FSK ) == RF_OPMODE_MODULATIONTYPE_FSK )
+            {
+                tmpRxBw = ( double )XTAL_FREQ / ( tmpMant * ( double )pow( 2, tmpExp + 2 ) );
+            }
+            else
+            {
+                tmpRxBw = ( double )XTAL_FREQ / ( tmpMant * ( double )pow( 2, tmpExp + 3 ) );
+            }
+            if( fabs( tmpRxBw - rxBwValue ) < rxBwMin )
+            {
+                rxBwMin = fabs( tmpRxBw - rxBwValue );
+                *mantisse = tmpMant;
+                *exponent = tmpExp;
+            }
+        }
+    }
+}
+
+void SX1276FskSetDccBw( uint8_t* reg, uint32_t dccValue, uint32_t rxBwValue )
+{
+    uint8_t mantisse = 0;
+    uint8_t exponent = 0;
+    
+    if( reg == &SX1276->RegRxBw )
+    {
+        *reg = ( uint8_t )dccValue & 0x60;
+    }
+    else
+    {
+        *reg = 0;
+    }
+
+    SX1276FskComputeRxBwMantExp( rxBwValue, &mantisse, &exponent );
+
+    switch( mantisse )
+    {
+        case 16:
+            *reg |= ( uint8_t )( 0x00 | ( exponent & 0x07 ) );
+            break;
+        case 20:
+            *reg |= ( uint8_t )( 0x08 | ( exponent & 0x07 ) );
+            break;
+        case 24:
+            *reg |= ( uint8_t )( 0x10 | ( exponent & 0x07 ) );
+            break;
+        default:
+            // Something went terribely wrong
+            break;
+    }
+
+    if( reg == &SX1276->RegRxBw )
+    {
+        SX1276Write( REG_RXBW, *reg );
+        FskSettings.RxBw = rxBwValue;
+    }
+    else
+    {
+        SX1276Write( REG_AFCBW, *reg );
+        FskSettings.RxBwAfc = rxBwValue;
+    }
+}
+
+uint32_t SX1276FskGetBw( uint8_t* reg )
+{
+    uint32_t rxBwValue = 0;
+    uint8_t mantisse = 0;
+    switch( ( *reg & 0x18 ) >> 3 )
+    {
+        case 0:
+            mantisse = 16;
+            break;
+        case 1:
+            mantisse = 20;
+            break;
+        case 2:
+            mantisse = 24;
+            break;
+        default:
+            break;
+    }
+    rxBwValue = SX1276FskComputeRxBw( mantisse, ( uint8_t )*reg & 0x07 );
+    if( reg == &SX1276->RegRxBw )
+    {
+        return FskSettings.RxBw = rxBwValue;
+    }
+    else
+    {
+        return FskSettings.RxBwAfc = rxBwValue;
+    }
+}
+
+void SX1276FskSetPacketCrcOn( bool enable )
+{
+    SX1276Read( REG_PACKETCONFIG1, &SX1276->RegPacketConfig1 );
+    SX1276->RegPacketConfig1 = ( SX1276->RegPacketConfig1 & RF_PACKETCONFIG1_CRC_MASK ) | ( enable << 4 );
+    SX1276Write( REG_PACKETCONFIG1, SX1276->RegPacketConfig1 );
+    FskSettings.CrcOn = enable;
+}
+
+bool SX1276FskGetPacketCrcOn( void )
+{
+    SX1276Read( REG_PACKETCONFIG1, &SX1276->RegPacketConfig1 );
+    FskSettings.CrcOn = ( SX1276->RegPacketConfig1 & RF_PACKETCONFIG1_CRC_ON ) >> 4;
+    return FskSettings.CrcOn;
+}
+
+void SX1276FskSetAfcOn( bool enable )
+{
+    SX1276Read( REG_RXCONFIG, &SX1276->RegRxConfig );
+    SX1276->RegRxConfig = ( SX1276->RegRxConfig & RF_RXCONFIG_AFCAUTO_MASK ) | ( enable << 4 );
+    SX1276Write( REG_RXCONFIG, SX1276->RegRxConfig );
+    FskSettings.AfcOn = enable;
+}
+
+bool SX1276FskGetAfcOn( void )
+{
+    SX1276Read( REG_RXCONFIG, &SX1276->RegRxConfig );
+    FskSettings.AfcOn = ( SX1276->RegRxConfig & RF_RXCONFIG_AFCAUTO_ON ) >> 4;
+    return FskSettings.AfcOn;
+}
+
+void SX1276FskSetPayloadLength( uint8_t value )
+{
+    SX1276->RegPayloadLength = value;
+    SX1276Write( REG_PAYLOADLENGTH, SX1276->RegPayloadLength );
+    FskSettings.PayloadLength = value;
+}
+
+uint8_t SX1276FskGetPayloadLength( void )
+{
+    SX1276Read( REG_PAYLOADLENGTH, &SX1276->RegPayloadLength );
+    FskSettings.PayloadLength = SX1276->RegPayloadLength;
+    return FskSettings.PayloadLength;
+}
+
+void SX1276FskSetPa20dBm( bool enale )
+{
+    SX1276Read( REG_PADAC, &SX1276->RegPaDac );
+    SX1276Read( REG_PACONFIG, &SX1276->RegPaConfig );
+
+    if( ( SX1276->RegPaConfig & RF_PACONFIG_PASELECT_PABOOST ) == RF_PACONFIG_PASELECT_PABOOST )
+    {    
+        if( enale == true )
+        {
+            SX1276->RegPaDac = 0x87;
+        }
+    }
+    else
+    {
+        SX1276->RegPaDac = 0x84;
+    }
+    SX1276Write( REG_PADAC, SX1276->RegPaDac );
+}
+
+bool SX1276FskGetPa20dBm( void )
+{
+    SX1276Read( REG_PADAC, &SX1276->RegPaDac );
+    
+    return ( ( SX1276->RegPaDac & 0x07 ) == 0x07 ) ? true : false;
+}
+
+void SX1276FskSetPAOutput( uint8_t outputPin )
+{
+    SX1276Read( REG_PACONFIG, &SX1276->RegPaConfig );
+    SX1276->RegPaConfig = (SX1276->RegPaConfig & RF_PACONFIG_PASELECT_MASK ) | outputPin;
+    SX1276Write( REG_PACONFIG, SX1276->RegPaConfig );
+}
+
+uint8_t SX1276FskGetPAOutput( void )
+{
+    SX1276Read( REG_PACONFIG, &SX1276->RegPaConfig );
+    return SX1276->RegPaConfig & ~RF_PACONFIG_PASELECT_MASK;
+}
+
+
+void SX1276FskSetPaRamp( uint8_t value )
+{
+    SX1276Read( REG_PARAMP, &SX1276->RegPaRamp );
+    SX1276->RegPaRamp = ( SX1276->RegPaRamp & RF_PARAMP_MASK ) | ( value & ~RF_PARAMP_MASK );
+    SX1276Write( REG_PARAMP, SX1276->RegPaRamp );
+}
+
+uint8_t SX1276FskGetPaRamp( void )
+{
+    SX1276Read( REG_PARAMP, &SX1276->RegPaRamp );
+    return SX1276->RegPaRamp & ~RF_PARAMP_MASK;
+}
+
+void SX1276FskSetRssiOffset( int8_t offset )
+{
+    SX1276Read( REG_RSSICONFIG, &SX1276->RegRssiConfig );
+    if( offset < 0 )
+    {
+        offset = ( ~offset & 0x1F );
+        offset += 1;
+        offset = -offset;
+    }
+    SX1276->RegRssiConfig |= ( uint8_t )( ( offset & 0x1F ) << 3 );
+    SX1276Write( REG_RSSICONFIG, SX1276->RegRssiConfig );
+}
+
+int8_t SX1276FskGetRssiOffset( void )
+{
+	  int8_t offset;
+	  
+    SX1276Read( REG_RSSICONFIG, &SX1276->RegRssiConfig );
+    offset = SX1276->RegRssiConfig >> 3;
+    if( ( offset & 0x10 ) == 0x10 )
+    {
+        offset = ( ~offset & 0x1F );
+        offset += 1;
+        offset = -offset;
+    }
+    return offset;
+}
+
+int8_t SX1276FskGetRawTemp( void )
+{
+    int8_t temp = 0;
+    uint8_t previousOpMode;
+    uint32_t startTick;
+    
+    // Enable Temperature reading
+    SX1276Read( REG_IMAGECAL, &SX1276->RegImageCal );
+    SX1276->RegImageCal = ( SX1276->RegImageCal & RF_IMAGECAL_TEMPMONITOR_MASK ) | RF_IMAGECAL_TEMPMONITOR_ON;
+    SX1276Write( REG_IMAGECAL, SX1276->RegImageCal );
+
+    // save current Op Mode
+    SX1276Read( REG_OPMODE, &SX1276->RegOpMode );
+    previousOpMode = SX1276->RegOpMode;
+
+    // put device in FSK RxSynth
+    SX1276->RegOpMode = RF_OPMODE_SYNTHESIZER_RX;
+    SX1276Write( REG_OPMODE, SX1276->RegOpMode );
+
+    // Wait 1ms
+    startTick = GET_TICK_COUNT( );
+    while( ( GET_TICK_COUNT( ) - startTick ) < TICK_RATE_MS( 1 ) );  
+
+    // Disable Temperature reading
+    SX1276Read( REG_IMAGECAL, &SX1276->RegImageCal );
+    SX1276->RegImageCal = ( SX1276->RegImageCal & RF_IMAGECAL_TEMPMONITOR_MASK ) | RF_IMAGECAL_TEMPMONITOR_OFF;
+    SX1276Write( REG_IMAGECAL, SX1276->RegImageCal );
+
+    // Read temperature
+    SX1276Read( REG_TEMP, &SX1276->RegTemp );
+    
+    temp = SX1276->RegTemp & 0x7F;
+    
+    if( ( SX1276->RegTemp & 0x80 ) == 0x80 )
+    {
+        temp *= -1;
+    }
+
+    // Reload previous Op Mode
+    SX1276Write( REG_OPMODE, previousOpMode );
+
+    return temp;
+}
+
+int8_t SX1276FskCalibreateTemp( int8_t actualTemp )
+{
+    return actualTemp - SX1276FskGetRawTemp( );
+}
+
+int8_t SX1276FskGetTemp( int8_t compensationFactor )
+{
+    return SX1276FskGetRawTemp( ) + compensationFactor;
+}
+
+#endif // USE_SX1276_RADIO

APP/network_mgr/lora/Radio/src/sx1276-Hal.c

@@ -0,0 +1,153 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276-Hal.c
+ * \brief      SX1276 Hardware Abstraction Layer
+ *
+ * \version    2.0.B2 
+ * \date       Nov 21 2012
+ * \author     Miguel Luis
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#include <stdint.h>
+#include <stdbool.h> 
+#include "stm32f10x.h"
+#include "gpio.h"
+#include "platform.h"
+#include "spi.h"
+
+#if defined( USE_SX1276_RADIO )
+#include "sx1276-Hal.h"
+
+
+void SpiWriteData(uint8_t byteCount,uint8_t* pData)
+{
+ uint8_t i;
+ 
+ for(i=0;i<byteCount;i++)
+ {
+   SpiInputOutput_Data(LORA_SPI,pData[i]);
+ }
+}
+
+void SpiReadData(uint8_t byteCount,uint8_t* pData)
+{
+ uint8_t i;
+ 
+ for(i=0;i<byteCount;i++)
+ {
+   *pData=SpiInputOutput_Data(LORA_SPI,0xff);
+   pData++;
+ }
+}
+
+
+void SX1276SetReset( uint8_t state )
+{
+    if( state == RADIO_RESET_ON )
+    {
+      // Set RESET pin to 0
+      GPIO_WriteBit( RF_RST_PORT, RF_RST_IO,Bit_RESET);
+    }
+    else
+    {
+      GPIO_WriteBit( RF_RST_PORT, RF_RST_IO,Bit_SET);
+    }
+}
+
+void SX1276Write( uint8_t addr, uint8_t data )
+{
+    SX1276WriteBuffer( addr, &data, 1 );
+}
+
+void SX1276Read( uint8_t addr, uint8_t *data )
+{
+    SX1276ReadBuffer( addr, data, 1 );
+}
+
+void SX1276WriteBuffer( uint8_t addr, uint8_t *buffer, uint8_t size )
+{
+  addr=addr|0x80;
+  GPIO_WriteBit( RF_NSS_PORT, RF_NSS_IO,Bit_RESET);//NSS = 0;
+  SpiInputOutput_Data(LORA_SPI,addr);
+  SpiWriteData(size,buffer);
+  GPIO_WriteBit( RF_NSS_PORT, RF_NSS_IO,Bit_SET);//NSS = 1;
+}
+
+void SX1276ReadBuffer( uint8_t addr, uint8_t *buffer, uint8_t size )
+{
+   addr=addr&0x7F;
+   GPIO_WriteBit( RF_NSS_PORT, RF_NSS_IO,Bit_RESET);//NSS = 0;
+   SpiInputOutput_Data(LORA_SPI,addr);
+   SpiReadData(size,buffer);
+   GPIO_WriteBit( RF_NSS_PORT, RF_NSS_IO,Bit_SET);//NSS = 1;
+}
+
+void SX1276WriteFifo( uint8_t *buffer, uint8_t size )
+{
+    SX1276WriteBuffer( 0, buffer, size );
+}
+
+void SX1276ReadFifo( uint8_t *buffer, uint8_t size )
+{
+    SX1276ReadBuffer( 0, buffer, size );
+}
+
+inline uint8_t SX1276ReadDio0( void )
+{
+    return GPIO_ReadInputDataBit( RF_DIO0_PORT, RF_DIO0_IO );
+}
+
+inline uint8_t SX1276ReadDio1( void )
+{
+   return GPIO_ReadInputDataBit( RF_DIO1_PORT, RF_DIO1_IO );
+}
+
+inline uint8_t SX1276ReadDio2( void )
+{
+  return GPIO_ReadInputDataBit( RF_DIO2_PORT, RF_DIO2_IO );
+}
+
+inline uint8_t SX1276ReadDio3( void )
+{
+   return GPIO_ReadInputDataBit( RF_DIO3_PORT, RF_DIO3_IO );
+}
+
+inline uint8_t SX1276ReadDio4( void )
+{
+   return GPIO_ReadInputDataBit( RF_DIO4_PORT, RF_DIO4_IO );
+}
+
+inline uint8_t SX1276ReadDio5( void )
+{
+   return GPIO_ReadInputDataBit( RF_DIO5_PORT, RF_DIO5_IO );
+}
+
+inline void SX1276WriteRxTx( uint8_t txEnable )
+{
+    if( txEnable != 0 )
+    {
+			RXE_LOW();
+			TXE_HIGH();    
+       // IoePinOn( FEM_CTX_PIN );
+       // IoePinOff( FEM_CPS_PIN );
+    }
+    else
+    {
+			RXE_HIGH();
+			TXE_LOW();   
+       // IoePinOff( FEM_CTX_PIN );
+       // IoePinOn( FEM_CPS_PIN );
+    }
+}
+
+#endif // USE_SX1276_RADIO

APP/network_mgr/lora/Radio/src/sx1276-LoRa.c

@@ -0,0 +1,764 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276-LoRa.c
+ * \brief      SX1276 RF chip driver mode LoRa
+ *
+ * \version    2.0.0 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#include <string.h>
+
+#include "platform.h"
+
+#if defined( USE_SX1276_RADIO )
+
+#include "radio.h"
+#include "sx1276-Hal.h"
+#include "sx1276.h"
+#include "sx1276-LoRaMisc.h"
+#include "sx1276-LoRa.h"
+#include "Delay.h"
+   
+/*!
+ * Constant values need to compute the RSSI value
+ */
+#define RSSI_OFFSET_LF                              -164.0
+#define RSSI_OFFSET_HF                              -157.0
+
+/*!
+ * Frequency hopping frequencies table
+ */
+const int32_t HoppingFrequencies[] =
+{
+    916500000,
+    923500000,
+    906500000,
+    917500000,
+    917500000,
+    909000000,
+    903000000,
+    916000000,
+    912500000,
+    926000000,
+    925000000,
+    909500000,
+    913000000,
+    918500000,
+    918500000,
+    902500000,
+    911500000,
+    926500000,
+    902500000,
+    922000000,
+    924000000,
+    903500000,
+    913000000,
+    922000000,
+    926000000,
+    910000000,
+    920000000,
+    922500000,
+    911000000,
+    922000000,
+    909500000,
+    926000000,
+    922000000,
+    918000000,
+    925500000,
+    908000000,
+    917500000,
+    926500000,
+    908500000,
+    916000000,
+    905500000,
+    916000000,
+    903000000,
+    905000000,
+    915000000,
+    913000000,
+    907000000,
+    910000000,
+    926500000,
+    925500000,
+    911000000,
+};
+
+// Default settings
+tLoRaSettings LoRaSettings =
+{
+    434000000,        // RFFrequency
+    20,               // Power
+    9,                // SignalBw [0: 7.8kHz, 1: 10.4 kHz, 2: 15.6 kHz, 3: 20.8 kHz, 4: 31.2 kHz,
+                      // 5: 41.6 kHz, 6: 62.5 kHz, 7: 125 kHz, 8: 250 kHz, 9: 500 kHz, other: Reserved]
+    12,                // SpreadingFactor [6: 64, 7: 128, 8: 256, 9: 512, 10: 1024, 11: 2048, 12: 4096  chips]
+    2,                // ErrorCoding [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
+    true,             // CrcOn [0: OFF, 1: ON]
+    false,            // ImplicitHeaderOn [0: OFF, 1: ON]
+    1,                // RxSingleOn [0: Continuous, 1 Single]
+    0,                // FreqHopOn [0: OFF, 1: ON]
+    4,                // HopPeriod Hops every frequency hopping period symbols
+    1000,              // TxPacketTimeout
+    1000,              // RxPacketTimeout
+    128,              // PayloadLength (used for implicit header mode)
+};
+
+/*!
+ * SX1276 LoRa registers variable
+ */
+tSX1276LR* SX1276LR;
+
+/*!
+ * Local RF buffer for communication support
+ */
+static uint8_t RFBuffer[RF_BUFFER_SIZE];
+
+/*!
+ * RF state machine variable
+ */
+ uint8_t RFLRState = RFLR_STATE_IDLE;
+
+/*!
+ * Rx management support variables
+ */
+static uint16_t RxPacketSize = 0;
+static int8_t RxPacketSnrEstimate;
+static double RxPacketRssiValue;
+static uint8_t RxGain = 1;
+static uint32_t RxTimeoutTimer = 0;
+/*!
+ * PacketTimeout Stores the Rx window time value for packet reception
+ */
+static uint32_t PacketTimeout;
+
+/*!
+ * Tx management support variables
+ */
+static uint16_t TxPacketSize = 0;
+
+
+void SX1276LoRaInit( void )
+{   
+    RFLRState = RFLR_STATE_IDLE;
+    
+    SX1276LoRaSetDefaults( );
+    
+    SX1276ReadBuffer( REG_LR_OPMODE, SX1276Regs + 1, 0x70 - 1 );
+    
+    SX1276LR->RegLna = RFLR_LNA_GAIN_G1;
+    
+    SX1276WriteBuffer( REG_LR_OPMODE, SX1276Regs + 1, 0x70 - 1 );
+    
+    // set the RF settings 
+    SX1276LoRaSetRFFrequency( LoRaSettings.RFFrequency );
+    SX1276LoRaSetSpreadingFactor( LoRaSettings.SpreadingFactor ); // SF6 only operates in implicit header mode.
+    SX1276LoRaSetErrorCoding( LoRaSettings.ErrorCoding );
+    SX1276LoRaSetPacketCrcOn( LoRaSettings.CrcOn );
+    SX1276LoRaSetSignalBandwidth( LoRaSettings.SignalBw );
+
+    SX1276LoRaSetImplicitHeaderOn( LoRaSettings.ImplicitHeaderOn );
+    SX1276LoRaSetSymbTimeout( 0x3FF );
+    SX1276LoRaSetPayloadLength( LoRaSettings.PayloadLength );
+    SX1276LoRaSetLowDatarateOptimize( true );
+
+#if( ( MODULE_SX1276RF1IAS == 1 ) || ( MODULE_SX1276RF1KAS == 1 ) )
+    if( LoRaSettings.RFFrequency > 860000000 )
+    {
+        SX1276LoRaSetPAOutput( RFLR_PACONFIG_PASELECT_RFO );
+        SX1276LoRaSetPa20dBm( false );
+        LoRaSettings.Power = 14;
+        SX1276LoRaSetRFPower( LoRaSettings.Power );
+    }
+    else
+    {
+        SX1276LoRaSetPAOutput( RFLR_PACONFIG_PASELECT_PABOOST );
+        SX1276LoRaSetPa20dBm( true );
+        LoRaSettings.Power = 20;
+        SX1276LoRaSetRFPower( LoRaSettings.Power );
+    } 
+#elif( MODULE_SX1276RF1JAS == 1 )
+    if( LoRaSettings.RFFrequency > 860000000 )
+    {
+        SX1276LoRaSetPAOutput( RFLR_PACONFIG_PASELECT_PABOOST );
+        SX1276LoRaSetPa20dBm( true );
+        LoRaSettings.Power = 20;
+        SX1276LoRaSetRFPower( LoRaSettings.Power );
+    }
+    else
+    {
+        SX1276LoRaSetPAOutput( RFLR_PACONFIG_PASELECT_RFO );
+        SX1276LoRaSetPa20dBm( false );
+        LoRaSettings.Power = 14;
+        SX1276LoRaSetRFPower( LoRaSettings.Power );
+    } 
+#endif
+
+    SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
+}
+
+void SX1276LoRaSetDefaults( void )
+{
+    // REMARK: See SX1276 datasheet for modified default values.
+
+    SX1276Read( REG_LR_VERSION, &SX1276LR->RegVersion );
+}
+
+void SX1276LoRaReset( void )
+{
+	  uint32_t startTick;
+	
+    SX1276SetReset( RADIO_RESET_ON );
+    
+    // Wait 1ms
+    startTick = GET_TICK_COUNT( );
+    while( ( GET_TICK_COUNT( ) - startTick ) < TICK_RATE_MS( 1 ) );    
+
+    SX1276SetReset( RADIO_RESET_OFF );
+    
+    // Wait 6ms
+    startTick = GET_TICK_COUNT( );
+    while( ( GET_TICK_COUNT( ) - startTick ) < TICK_RATE_MS( 6 ) );    
+}
+
+void SX1276LoRaSetOpMode( uint8_t opMode )
+{
+    static uint8_t opModePrev = RFLR_OPMODE_STANDBY;
+    static bool antennaSwitchTxOnPrev = true;
+    bool antennaSwitchTxOn = false;
+
+    opModePrev = SX1276LR->RegOpMode & ~RFLR_OPMODE_MASK;
+
+    if( opMode != opModePrev )
+    {
+        if( opMode == RFLR_OPMODE_TRANSMITTER )
+        {
+            antennaSwitchTxOn = true;
+        }
+        else
+        {
+            antennaSwitchTxOn = false;
+        }
+        if( antennaSwitchTxOn != antennaSwitchTxOnPrev )
+        {
+            antennaSwitchTxOnPrev = antennaSwitchTxOn;
+            RXTX( antennaSwitchTxOn ); // Antenna switch control
+        }
+        SX1276LR->RegOpMode = ( SX1276LR->RegOpMode & RFLR_OPMODE_MASK ) | opMode;
+
+        SX1276Write( REG_LR_OPMODE, SX1276LR->RegOpMode );        
+    }
+}
+
+uint8_t SX1276LoRaGetOpMode( void )
+{
+    SX1276Read( REG_LR_OPMODE, &SX1276LR->RegOpMode );
+    
+    return SX1276LR->RegOpMode & ~RFLR_OPMODE_MASK;
+}
+
+uint8_t SX1276LoRaReadRxGain( void )
+{
+    SX1276Read( REG_LR_LNA, &SX1276LR->RegLna );
+    return( SX1276LR->RegLna >> 5 ) & 0x07;
+}
+
+double SX1276LoRaReadRssi( void )
+{
+    // Reads the RSSI value
+    SX1276Read( REG_LR_RSSIVALUE, &SX1276LR->RegRssiValue );
+
+    if( LoRaSettings.RFFrequency < 860000000 )  // LF
+    {
+        return RSSI_OFFSET_LF + ( double )SX1276LR->RegRssiValue;
+    }
+    else
+    {
+        return RSSI_OFFSET_HF + ( double )SX1276LR->RegRssiValue;
+    }
+}
+
+uint8_t SX1276LoRaGetPacketRxGain( void )
+{
+    return RxGain;
+}
+
+int8_t SX1276LoRaGetPacketSnr( void )
+{
+    return RxPacketSnrEstimate;
+}
+
+double SX1276LoRaGetPacketRssi( void )
+{
+    return RxPacketRssiValue;
+}
+
+void SX1276LoRaStartRx( void )
+{
+    SX1276LoRaSetRFState( RFLR_STATE_RX_INIT );
+}
+
+void SX1276LoRaGetRxPacket( void *buffer, uint16_t *size )
+{
+    if(RxPacketSize>RF_BUFFER_SIZE)
+    { 
+     RxPacketSize=0;
+    }
+    *size = RxPacketSize;
+    RxPacketSize = 0;
+    memcpy( ( void * )buffer, ( void * )RFBuffer, ( size_t )*size );
+}
+
+void SX1276LoRaSetTxPacket( const void *buffer, uint16_t size )
+{
+    TxPacketSize = size;
+    memcpy( ( void * )RFBuffer, buffer, ( size_t )TxPacketSize ); 
+
+    RFLRState = RFLR_STATE_TX_INIT;
+}
+
+uint8_t SX1276LoRaGetRFState( void )
+{
+    return RFLRState;
+}
+
+void SX1276LoRaSetRFState( uint8_t state )
+{
+    RFLRState = state;
+}
+
+/*!
+ * \brief Process the LoRa modem Rx and Tx state machines depending on the
+ *        SX1276 operating mode.
+ *
+ * \retval rfState Current RF state [RF_IDLE, RF_BUSY, 
+ *                                   RF_RX_DONE, RF_RX_TIMEOUT,
+ *                                   RF_TX_DONE, RF_TX_TIMEOUT]
+ */
+uint32_t SX1276LoRaProcess( void )
+{
+    uint32_t result = RF_BUSY;
+    
+    switch( RFLRState )
+    {
+    case RFLR_STATE_IDLE:
+      
+       SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
+       
+        break;
+    case RFLR_STATE_RX_INIT:
+        
+        SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
+        
+        SX1276LR->RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT |
+                                    //RFLR_IRQFLAGS_RXDONE |
+                                    //RFLR_IRQFLAGS_PAYLOADCRCERROR |
+                                    RFLR_IRQFLAGS_VALIDHEADER |
+                                    RFLR_IRQFLAGS_TXDONE |
+                                    RFLR_IRQFLAGS_CADDONE |
+                                    //RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL |
+                                     RFLR_IRQFLAGS_CADDETECTED;
+        SX1276Write( REG_LR_IRQFLAGSMASK, SX1276LR->RegIrqFlagsMask );
+        if( LoRaSettings.FreqHopOn == true )
+        {
+            SX1276LR->RegHopPeriod = LoRaSettings.HopPeriod;
+
+            SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
+            SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
+        }
+        else
+        {
+            SX1276LR->RegHopPeriod = 255;
+        }
+        
+        SX1276Write( REG_LR_HOPPERIOD, SX1276LR->RegHopPeriod );
+                
+                                    // RxDone                    RxTimeout                   FhssChangeChannel           CadDone
+        SX1276LR->RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_00 | RFLR_DIOMAPPING1_DIO1_00 | RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_00;
+                                    // PllLock              ModeReady
+        SX1276LR->RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_01 | RFLR_DIOMAPPING2_DIO5_00;
+        SX1276WriteBuffer( REG_LR_DIOMAPPING1, &SX1276LR->RegDioMapping1, 2 );
+        if( LoRaSettings.RxSingleOn == true ) // Rx single mode
+        {
+
+            SX1276LoRaSetOpMode( RFLR_OPMODE_RECEIVER_SINGLE );
+        }
+        else // Rx continuous mode
+        {
+            SX1276LR->RegFifoAddrPtr = SX1276LR->RegFifoRxBaseAddr;
+            SX1276Write( REG_LR_FIFOADDRPTR, SX1276LR->RegFifoAddrPtr );
+            
+            SX1276LoRaSetOpMode( RFLR_OPMODE_RECEIVER );
+        }
+        
+        memset( RFBuffer, 0, ( size_t )RF_BUFFER_SIZE );
+        
+        PacketTimeout = LoRaSettings.RxPacketTimeout;
+        RxTimeoutTimer = GET_TICK_COUNT( );
+        RFLRState = RFLR_STATE_RX_RUNNING;
+        break;
+    case RFLR_STATE_RX_RUNNING:
+
+        if( DIO0 == 1 ) // RxDone
+        {
+            RxTimeoutTimer = GET_TICK_COUNT( );
+            if( LoRaSettings.FreqHopOn == true )
+            {
+                SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
+                SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
+            }
+            // Clear Irq
+            SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_RXDONE  );
+            RFLRState = RFLR_STATE_RX_DONE;
+        }
+        if( DIO2 == 1 ) // FHSS Changed Channel
+        {
+            RxTimeoutTimer = GET_TICK_COUNT( );
+            if( LoRaSettings.FreqHopOn == true )
+            {
+                SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
+                SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
+            }
+            // Clear Irq
+            SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL );
+            // Debug
+            RxGain = SX1276LoRaReadRxGain( );
+        }
+
+        if( LoRaSettings.RxSingleOn == true ) // Rx single mode
+        {
+            if( ( GET_TICK_COUNT( ) - RxTimeoutTimer ) > PacketTimeout )
+            {
+                RFLRState = RFLR_STATE_RX_TIMEOUT;
+            }
+        }
+        break;
+    case RFLR_STATE_RX_DONE:
+        SX1276Read( REG_LR_IRQFLAGS, &SX1276LR->RegIrqFlags );
+        if( ( SX1276LR->RegIrqFlags & RFLR_IRQFLAGS_PAYLOADCRCERROR ) == RFLR_IRQFLAGS_PAYLOADCRCERROR )
+        {
+            // Clear Irq
+            SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_PAYLOADCRCERROR  );
+            
+            if( LoRaSettings.RxSingleOn == true ) // Rx single mode
+            {
+                RFLRState = RFLR_STATE_RX_INIT;
+            }
+            else
+            {
+                RFLRState = RFLR_STATE_RX_RUNNING;
+            }
+            break;
+        }
+        
+        {
+            uint8_t rxSnrEstimate;
+            SX1276Read( REG_LR_PKTSNRVALUE, &rxSnrEstimate );
+            if( rxSnrEstimate & 0x80 ) // The SNR sign bit is 1
+            {
+                // Invert and divide by 4
+                RxPacketSnrEstimate = ( ( ~rxSnrEstimate + 1 ) & 0xFF ) >> 2;
+                RxPacketSnrEstimate = -RxPacketSnrEstimate;
+            }
+            else
+            {
+                // Divide by 4
+                RxPacketSnrEstimate = ( rxSnrEstimate & 0xFF ) >> 2;
+            }
+        }
+        
+        SX1276Read( REG_LR_PKTRSSIVALUE, &SX1276LR->RegPktRssiValue );
+        
+        if( LoRaSettings.RFFrequency < 860000000 )  // LF
+        {    
+            if( RxPacketSnrEstimate < 0 )
+            {
+                RxPacketRssiValue = RSSI_OFFSET_LF + ( ( double )SX1276LR->RegPktRssiValue ) + RxPacketSnrEstimate;
+            }
+            else
+            {
+                RxPacketRssiValue = RSSI_OFFSET_LF + ( 1.0666 * ( ( double )SX1276LR->RegPktRssiValue ) );
+            }
+        }
+        else                                        // HF
+        {    
+            if( RxPacketSnrEstimate < 0 )
+            {
+                RxPacketRssiValue = RSSI_OFFSET_HF + ( ( double )SX1276LR->RegPktRssiValue ) + RxPacketSnrEstimate;
+            }
+            else
+            {    
+                RxPacketRssiValue = RSSI_OFFSET_HF + ( 1.0666 * ( ( double )SX1276LR->RegPktRssiValue ) );
+            }
+        }
+
+        if( LoRaSettings.RxSingleOn == true ) // Rx single mode
+        {
+            SX1276LR->RegFifoAddrPtr = SX1276LR->RegFifoRxBaseAddr;
+            SX1276Write( REG_LR_FIFOADDRPTR, SX1276LR->RegFifoAddrPtr );
+
+            if( LoRaSettings.ImplicitHeaderOn == true )
+            {
+                RxPacketSize = SX1276LR->RegPayloadLength;
+                SX1276ReadFifo( RFBuffer, SX1276LR->RegPayloadLength );
+            }
+            else
+            {
+                SX1276Read( REG_LR_NBRXBYTES, &SX1276LR->RegNbRxBytes );
+                RxPacketSize = SX1276LR->RegNbRxBytes;
+                SX1276ReadFifo( RFBuffer, SX1276LR->RegNbRxBytes );
+            }
+        }
+        else // Rx continuous mode
+        {
+            SX1276Read( REG_LR_FIFORXCURRENTADDR, &SX1276LR->RegFifoRxCurrentAddr );
+
+            if( LoRaSettings.ImplicitHeaderOn == true )
+            {
+                RxPacketSize = SX1276LR->RegPayloadLength;
+                SX1276LR->RegFifoAddrPtr = SX1276LR->RegFifoRxCurrentAddr;
+                SX1276Write( REG_LR_FIFOADDRPTR, SX1276LR->RegFifoAddrPtr );
+                SX1276ReadFifo( RFBuffer, SX1276LR->RegPayloadLength );
+            }
+            else
+            {
+                SX1276Read( REG_LR_NBRXBYTES, &SX1276LR->RegNbRxBytes );
+                RxPacketSize = SX1276LR->RegNbRxBytes;
+                SX1276LR->RegFifoAddrPtr = SX1276LR->RegFifoRxCurrentAddr;
+                SX1276Write( REG_LR_FIFOADDRPTR, SX1276LR->RegFifoAddrPtr );
+                SX1276ReadFifo( RFBuffer, SX1276LR->RegNbRxBytes );
+            }
+        }
+        
+        if( LoRaSettings.RxSingleOn == true ) // Rx single mode
+        {
+            RFLRState = RFLR_STATE_RX_INIT;
+
+        }
+        else // Rx continuous mode
+        {
+            RFLRState = RFLR_STATE_RX_RUNNING;
+        }
+        result = RF_RX_DONE;
+        break;
+    case RFLR_STATE_RX_TIMEOUT:
+        RFLRState = RFLR_STATE_RX_INIT;
+        result = RF_RX_TIMEOUT;
+        break;
+    case RFLR_STATE_TX_INIT:
+        
+        SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
+
+        if( LoRaSettings.FreqHopOn == true )
+        {
+            SX1276LR->RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT |
+                                        RFLR_IRQFLAGS_RXDONE |
+                                        RFLR_IRQFLAGS_PAYLOADCRCERROR |
+                                        RFLR_IRQFLAGS_VALIDHEADER |
+                                        //RFLR_IRQFLAGS_TXDONE |
+                                        RFLR_IRQFLAGS_CADDONE |
+                                        //RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL |
+                                        RFLR_IRQFLAGS_CADDETECTED;
+            SX1276LR->RegHopPeriod = LoRaSettings.HopPeriod;
+
+            SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
+            SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
+        }
+        else
+        {
+            SX1276LR->RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT |
+                                        RFLR_IRQFLAGS_RXDONE |
+                                        RFLR_IRQFLAGS_PAYLOADCRCERROR |
+                                        RFLR_IRQFLAGS_VALIDHEADER |
+                                        //RFLR_IRQFLAGS_TXDONE |
+                                        RFLR_IRQFLAGS_CADDONE |
+                                        RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL |
+                                        RFLR_IRQFLAGS_CADDETECTED;
+            SX1276LR->RegHopPeriod = 0;
+        }
+        SX1276Write( REG_LR_HOPPERIOD, SX1276LR->RegHopPeriod );
+        SX1276Write( REG_LR_IRQFLAGSMASK, SX1276LR->RegIrqFlagsMask );
+        
+        // Initializes the payload size
+        SX1276LR->RegPayloadLength = TxPacketSize;
+        SX1276Write( REG_LR_PAYLOADLENGTH, SX1276LR->RegPayloadLength );
+        
+        SX1276LR->RegFifoTxBaseAddr = 0x00; // Full buffer used for Tx
+        SX1276Write( REG_LR_FIFOTXBASEADDR, SX1276LR->RegFifoTxBaseAddr );
+        
+        SX1276LR->RegFifoAddrPtr = SX1276LR->RegFifoTxBaseAddr;
+        SX1276Write( REG_LR_FIFOADDRPTR, SX1276LR->RegFifoAddrPtr );
+        
+        // Write payload buffer to LORA modem
+        SX1276WriteFifo( RFBuffer, SX1276LR->RegPayloadLength );
+                                        // TxDone               RxTimeout                   FhssChangeChannel          ValidHeader         
+        SX1276LR->RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_01 | RFLR_DIOMAPPING1_DIO1_00 | RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_01;
+                                        // CadDetected            Mode Ready
+        SX1276LR->RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_00 | RFLR_DIOMAPPING2_DIO5_00;
+        SX1276WriteBuffer( REG_LR_DIOMAPPING1, &SX1276LR->RegDioMapping1, 2 );
+
+        SX1276LoRaSetOpMode( RFLR_OPMODE_TRANSMITTER );
+
+        RFLRState = RFLR_STATE_TX_RUNNING;
+        break;
+    case RFLR_STATE_TX_RUNNING:
+        if( DIO0 == 1 ) // TxDone
+        {
+            // Clear Irq
+            SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_TXDONE  );
+            RFLRState = RFLR_STATE_TX_DONE;   
+        }
+        if( DIO2 == 1 ) // FHSS Changed Channel 
+        {
+            if( LoRaSettings.FreqHopOn == true )
+            {
+                SX1276Read( REG_LR_HOPCHANNEL, &SX1276LR->RegHopChannel );
+                SX1276LoRaSetRFFrequency( HoppingFrequencies[SX1276LR->RegHopChannel & RFLR_HOPCHANNEL_CHANNEL_MASK] );
+            }
+            // Clear Irq
+            SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL );
+        }
+        break;
+    case RFLR_STATE_TX_DONE:
+        // optimize the power consumption by switching off the transmitter as soon as the packet has been sent
+        SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
+        
+        RFLRState = RFLR_STATE_IDLE;
+        result = RF_TX_DONE;
+        break;
+        
+    case RFLR_STATE_CAD_INIT:    
+        SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
+        
+        SX1276LR->RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT |
+                                    RFLR_IRQFLAGS_RXDONE |
+                                    RFLR_IRQFLAGS_PAYLOADCRCERROR |
+                                    RFLR_IRQFLAGS_VALIDHEADER |
+                                    RFLR_IRQFLAGS_TXDONE |
+                                    //RFLR_IRQFLAGS_CADDONE |
+                                    RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL; // |
+                                    //RFLR_IRQFLAGS_CADDETECTED;
+        SX1276Write( REG_LR_IRQFLAGSMASK, SX1276LR->RegIrqFlagsMask );
+        
+                                    // RxDone                       CAD Detected               FhssChangeChannel           CadDone
+        SX1276LR->RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_00 | RFLR_DIOMAPPING1_DIO1_10 | RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_00;
+                                   //PllLock               ModeReady
+        SX1276LR->RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_01 | RFLR_DIOMAPPING2_DIO5_00;
+        SX1276WriteBuffer( REG_LR_DIOMAPPING1, &SX1276LR->RegDioMapping1, 2 );
+        
+        SX1276LoRaSetOpMode( RFLR_OPMODE_CAD );
+        RFLRState = RFLR_STATE_CAD_RUNNING;
+        break;
+        
+        
+    case RFLR_STATE_CAD_RUNNING:
+        if( DIO3 == 1 ) //CAD Done interrupt
+        { 
+            // Clear Irq
+            SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_CADDONE  );
+            if( DIO1 == 1 ) // CAD Detected interrupt
+            {
+                // Clear Irq
+                SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_CADDETECTED  );
+                // CAD detected, we have a LoRa preamble
+                RFLRState = RFLR_STATE_RX_INIT;
+                result = RF_CHANNEL_ACTIVITY_DETECTED;
+            } 
+            else
+            {    
+                // The device goes in Standby Mode automatically    
+                RFLRState = RFLR_STATE_IDLE;
+                result = RF_CHANNEL_EMPTY;
+            }
+        }   
+        break;
+    
+    default:
+        break;
+    } 
+    return result;
+}
+
+
+/************************************************
+函数名称 ： SX1276GetLoraTimeOnAir
+功    能 ： 获取空中时间
+参    数 ： pktLen		有效负载长度			
+返 回 值 ： 无
+作    者 ： sun
+*************************************************/
+uint32_t SX1276GetLoraTimeOnAir(uint8_t pktLen )
+{
+    uint32_t airTime = 0;
+		double tPreamble;
+    double rs;
+		double ts;
+		double tmp ;
+		double nPayload ;
+		double tPayload;
+		double tOnAir;
+		double bw = 0.0;
+		// REMARK: When using LoRa modem only bandwidths 125, 250 and 500 kHz are supported
+		switch( LoRaSettings.SignalBw )
+		{
+			//case 0: // 7.8 kHz
+			//    bw = 7800;
+			//    break;
+			//case 1: // 10.4 kHz
+			//    bw = 10400;
+			//    break;
+			//case 2: // 15.6 kHz
+			//    bw = 15600;
+			//    break;
+			//case 3: // 20.8 kHz
+			//    bw = 20800;
+			//    break;
+			//case 4: // 31.2 kHz
+			//    bw = 31200;
+			//    break;
+			//case 5: // 41.4 kHz
+			//    bw = 41400;
+			//    break;
+			//case 6: // 62.5 kHz
+			//    bw = 62500;
+			//    break;
+			case 7: // 125 kHz
+				bw = 125000;
+			break;
+			case 8: // 250 kHz
+				bw = 250000;
+			break;
+			case 9: // 500 kHz
+				bw = 500000;
+			break;
+		}
+
+		// Symbol rate : time for one symbol (secs)
+		 rs = bw / ( 1<< LoRaSettings.SpreadingFactor );
+		//	 rs = bw / (pow(2, LoRaSettings.SpreadingFactor));
+		 ts = 1 / rs;
+		// time of preamble
+		 tPreamble = ( SX1276LoRaGetPreambleLength() + 4.25 ) * ts;
+		// Symbol length of payload and time
+		 tmp = ceil( ( 8 * pktLen - 4 * LoRaSettings.SpreadingFactor +28 + 16 - ( LoRaSettings.ImplicitHeaderOn ? 20 : 0 ) ) /
+		( double )( 4 * ( LoRaSettings.SpreadingFactor -( ( SX1276LoRaGetLowDatarateOptimize() > 0 ) ? 1 : 0 ) ) ) ) *( LoRaSettings.ErrorCoding + 4 );
+		 nPayload = 8 + ( ( tmp > 0 ) ? tmp : 0 );
+		 tPayload = nPayload * ts;
+		// Time on air
+		 tOnAir = tPreamble + tPayload;
+		// return ms secs
+		airTime = floor( tOnAir * 933 + 0.999 );
+		return airTime;
+}
+
+#endif // USE_SX1276_RADIO

APP/network_mgr/lora/Radio/src/sx1276-LoRaMisc.c

@@ -0,0 +1,411 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276-LoRaMisc.c
+ * \brief      SX1276 RF chip high level functions driver
+ *
+ * \remark     Optional support functions.
+ *             These functions are defined only to easy the change of the
+ *             parameters.
+ *             For a final firmware the radio parameters will be known so
+ *             there is no need to support all possible parameters.
+ *             Removing these functions will greatly reduce the final firmware
+ *             size.
+ *
+ * \version    2.0.0 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#include "platform.h"
+
+#if defined( USE_SX1276_RADIO )
+
+#include "sx1276-Hal.h"
+#include "sx1276.h"
+
+#include "sx1276-LoRa.h"
+#include "sx1276-LoRaMisc.h"
+
+/*!
+ * SX1276 definitions
+ */
+#define XTAL_FREQ                                   32000000
+#define FREQ_STEP                                   61.03515625
+
+extern tLoRaSettings LoRaSettings;
+
+void SX1276LoRaSetRFFrequency( uint32_t freq )
+{
+    LoRaSettings.RFFrequency = freq;
+
+    freq = ( uint32_t )( ( double )freq / ( double )FREQ_STEP );
+    SX1276LR->RegFrfMsb = ( uint8_t )( ( freq >> 16 ) & 0xFF );
+    SX1276LR->RegFrfMid = ( uint8_t )( ( freq >> 8 ) & 0xFF );
+    SX1276LR->RegFrfLsb = ( uint8_t )( freq & 0xFF );
+    SX1276WriteBuffer( REG_LR_FRFMSB, &SX1276LR->RegFrfMsb, 3 );
+}
+
+uint32_t SX1276LoRaGetRFFrequency( void )
+{
+    SX1276ReadBuffer( REG_LR_FRFMSB, &SX1276LR->RegFrfMsb, 3 );
+    LoRaSettings.RFFrequency = ( ( uint32_t )SX1276LR->RegFrfMsb << 16 ) | ( ( uint32_t )SX1276LR->RegFrfMid << 8 ) | ( ( uint32_t )SX1276LR->RegFrfLsb );
+    LoRaSettings.RFFrequency = ( uint32_t )( ( double )LoRaSettings.RFFrequency * ( double )FREQ_STEP );
+
+    return LoRaSettings.RFFrequency;
+}
+
+void SX1276LoRaSetRFPower( int8_t power )
+{
+    SX1276Read( REG_LR_PACONFIG, &SX1276LR->RegPaConfig );
+    SX1276Read( REG_LR_PADAC, &SX1276LR->RegPaDac );
+    
+    if( ( SX1276LR->RegPaConfig & RFLR_PACONFIG_PASELECT_PABOOST ) == RFLR_PACONFIG_PASELECT_PABOOST )
+    {
+        if( ( SX1276LR->RegPaDac & 0x87 ) == 0x87 )
+        {
+            if( power < 5 )
+            {
+                power = 5;
+            }
+            if( power > 20 )
+            {
+                power = 20;
+            }
+            SX1276LR->RegPaConfig = ( SX1276LR->RegPaConfig & RFLR_PACONFIG_MAX_POWER_MASK ) | 0x70;
+            SX1276LR->RegPaConfig = ( SX1276LR->RegPaConfig & RFLR_PACONFIG_OUTPUTPOWER_MASK ) | ( uint8_t )( ( uint16_t )( power - 5 ) & 0x0F );
+        }
+        else
+        {
+            if( power < 2 )
+            {
+                power = 2;
+            }
+            if( power > 17 )
+            {
+                power = 17;
+            }
+            SX1276LR->RegPaConfig = ( SX1276LR->RegPaConfig & RFLR_PACONFIG_MAX_POWER_MASK ) | 0x70;
+            SX1276LR->RegPaConfig = ( SX1276LR->RegPaConfig & RFLR_PACONFIG_OUTPUTPOWER_MASK ) | ( uint8_t )( ( uint16_t )( power - 2 ) & 0x0F );
+        }
+    }
+    else
+    {
+        if( power < -1 )
+        {
+            power = -1;
+        }
+        if( power > 14 )
+        {
+            power = 14;
+        }
+        SX1276LR->RegPaConfig = ( SX1276LR->RegPaConfig & RFLR_PACONFIG_MAX_POWER_MASK ) | 0x70;
+        SX1276LR->RegPaConfig = ( SX1276LR->RegPaConfig & RFLR_PACONFIG_OUTPUTPOWER_MASK ) | ( uint8_t )( ( uint16_t )( power + 1 ) & 0x0F );
+    }
+    SX1276Write( REG_LR_PACONFIG, SX1276LR->RegPaConfig );
+    LoRaSettings.Power = power;
+}
+
+int8_t SX1276LoRaGetRFPower( void )
+{
+    SX1276Read( REG_LR_PACONFIG, &SX1276LR->RegPaConfig );
+    SX1276Read( REG_LR_PADAC, &SX1276LR->RegPaDac );
+
+    if( ( SX1276LR->RegPaConfig & RFLR_PACONFIG_PASELECT_PABOOST ) == RFLR_PACONFIG_PASELECT_PABOOST )
+    {
+        if( ( SX1276LR->RegPaDac & 0x07 ) == 0x07 )
+        {
+            LoRaSettings.Power = 5 + ( SX1276LR->RegPaConfig & ~RFLR_PACONFIG_OUTPUTPOWER_MASK );
+        }
+        else
+        {
+            LoRaSettings.Power = 2 + ( SX1276LR->RegPaConfig & ~RFLR_PACONFIG_OUTPUTPOWER_MASK );
+        }
+    }
+    else
+    {
+        LoRaSettings.Power = -1 + ( SX1276LR->RegPaConfig & ~RFLR_PACONFIG_OUTPUTPOWER_MASK );
+    }
+    return LoRaSettings.Power;
+}
+
+void SX1276LoRaSetSignalBandwidth( uint8_t bw )
+{
+    SX1276Read( REG_LR_MODEMCONFIG1, &SX1276LR->RegModemConfig1 );
+    SX1276LR->RegModemConfig1 = ( SX1276LR->RegModemConfig1 & RFLR_MODEMCONFIG1_BW_MASK ) | ( bw << 4 );
+    SX1276Write( REG_LR_MODEMCONFIG1, SX1276LR->RegModemConfig1 );
+    LoRaSettings.SignalBw = bw;
+}
+
+uint8_t SX1276LoRaGetSignalBandwidth( void )
+{
+    SX1276Read( REG_LR_MODEMCONFIG1, &SX1276LR->RegModemConfig1 );
+    LoRaSettings.SignalBw = ( SX1276LR->RegModemConfig1 & ~RFLR_MODEMCONFIG1_BW_MASK ) >> 4;
+    return LoRaSettings.SignalBw;
+}
+
+void SX1276LoRaSetSpreadingFactor( uint8_t factor )
+{
+
+    if( factor > 12 )
+    {
+        factor = 12;
+    }
+    else if( factor < 6 )
+    {
+        factor = 6;
+    }
+
+    if( factor == 6 )
+    {
+        SX1276LoRaSetNbTrigPeaks( 5 );
+    }
+    else
+    {
+        SX1276LoRaSetNbTrigPeaks( 3 );
+    }
+
+    SX1276Read( REG_LR_MODEMCONFIG2, &SX1276LR->RegModemConfig2 );    
+    SX1276LR->RegModemConfig2 = ( SX1276LR->RegModemConfig2 & RFLR_MODEMCONFIG2_SF_MASK ) | ( factor << 4 );
+    SX1276Write( REG_LR_MODEMCONFIG2, SX1276LR->RegModemConfig2 );    
+    LoRaSettings.SpreadingFactor = factor;
+}
+
+uint8_t SX1276LoRaGetSpreadingFactor( void )
+{
+    SX1276Read( REG_LR_MODEMCONFIG2, &SX1276LR->RegModemConfig2 );   
+    LoRaSettings.SpreadingFactor = ( SX1276LR->RegModemConfig2 & ~RFLR_MODEMCONFIG2_SF_MASK ) >> 4;
+    return LoRaSettings.SpreadingFactor;
+}
+
+void SX1276LoRaSetErrorCoding( uint8_t value )
+{
+    SX1276Read( REG_LR_MODEMCONFIG1, &SX1276LR->RegModemConfig1 );
+    SX1276LR->RegModemConfig1 = ( SX1276LR->RegModemConfig1 & RFLR_MODEMCONFIG1_CODINGRATE_MASK ) | ( value << 1 );
+    SX1276Write( REG_LR_MODEMCONFIG1, SX1276LR->RegModemConfig1 );
+    LoRaSettings.ErrorCoding = value;
+}
+
+uint8_t SX1276LoRaGetErrorCoding( void )
+{
+    SX1276Read( REG_LR_MODEMCONFIG1, &SX1276LR->RegModemConfig1 );
+    LoRaSettings.ErrorCoding = ( SX1276LR->RegModemConfig1 & ~RFLR_MODEMCONFIG1_CODINGRATE_MASK ) >> 1;
+    return LoRaSettings.ErrorCoding;
+}
+
+void SX1276LoRaSetPacketCrcOn( bool enable )
+{
+    SX1276Read( REG_LR_MODEMCONFIG2, &SX1276LR->RegModemConfig2 );
+    SX1276LR->RegModemConfig2 = ( SX1276LR->RegModemConfig2 & RFLR_MODEMCONFIG2_RXPAYLOADCRC_MASK ) | ( enable << 2 );
+    SX1276Write( REG_LR_MODEMCONFIG2, SX1276LR->RegModemConfig2 );
+    LoRaSettings.CrcOn = enable;
+}
+
+void SX1276LoRaSetPreambleLength( uint16_t value )
+{
+    SX1276ReadBuffer( REG_LR_PREAMBLEMSB, &SX1276LR->RegPreambleMsb, 2 );
+
+    SX1276LR->RegPreambleMsb = ( value >> 8 ) & 0x00FF;
+    SX1276LR->RegPreambleLsb = value & 0xFF;
+    SX1276WriteBuffer( REG_LR_PREAMBLEMSB, &SX1276LR->RegPreambleMsb, 2 );
+}
+
+uint16_t SX1276LoRaGetPreambleLength( void )
+{
+    SX1276ReadBuffer( REG_LR_PREAMBLEMSB, &SX1276LR->RegPreambleMsb, 2 );
+    return ( ( SX1276LR->RegPreambleMsb & 0x00FF ) << 8 ) | SX1276LR->RegPreambleLsb;
+}
+
+bool SX1276LoRaGetPacketCrcOn( void )
+{
+    SX1276Read( REG_LR_MODEMCONFIG2, &SX1276LR->RegModemConfig2 );
+    LoRaSettings.CrcOn = ( SX1276LR->RegModemConfig2 & RFLR_MODEMCONFIG2_RXPAYLOADCRC_ON ) >> 1;
+    return LoRaSettings.CrcOn;
+}
+
+void SX1276LoRaSetImplicitHeaderOn( bool enable )
+{
+    SX1276Read( REG_LR_MODEMCONFIG1, &SX1276LR->RegModemConfig1 );
+    SX1276LR->RegModemConfig1 = ( SX1276LR->RegModemConfig1 & RFLR_MODEMCONFIG1_IMPLICITHEADER_MASK ) | ( enable );
+    SX1276Write( REG_LR_MODEMCONFIG1, SX1276LR->RegModemConfig1 );
+    LoRaSettings.ImplicitHeaderOn = enable;
+}
+
+bool SX1276LoRaGetImplicitHeaderOn( void )
+{
+    SX1276Read( REG_LR_MODEMCONFIG1, &SX1276LR->RegModemConfig1 );
+    LoRaSettings.ImplicitHeaderOn = ( SX1276LR->RegModemConfig1 & RFLR_MODEMCONFIG1_IMPLICITHEADER_ON );
+    return LoRaSettings.ImplicitHeaderOn;
+}
+
+void SX1276LoRaSetRxSingleOn( bool enable )
+{
+    LoRaSettings.RxSingleOn = enable;
+}
+
+bool SX1276LoRaGetRxSingleOn( void )
+{
+    return LoRaSettings.RxSingleOn;
+}
+
+void SX1276LoRaSetFreqHopOn( bool enable )
+{
+    LoRaSettings.FreqHopOn = enable;
+}
+
+bool SX1276LoRaGetFreqHopOn( void )
+{
+    return LoRaSettings.FreqHopOn;
+}
+
+void SX1276LoRaSetHopPeriod( uint8_t value )
+{
+    SX1276LR->RegHopPeriod = value;
+    SX1276Write( REG_LR_HOPPERIOD, SX1276LR->RegHopPeriod );
+    LoRaSettings.HopPeriod = value;
+}
+
+uint8_t SX1276LoRaGetHopPeriod( void )
+{
+    SX1276Read( REG_LR_HOPPERIOD, &SX1276LR->RegHopPeriod );
+    LoRaSettings.HopPeriod = SX1276LR->RegHopPeriod;
+    return LoRaSettings.HopPeriod;
+}
+
+void SX1276LoRaSetTxPacketTimeout( uint32_t value )
+{
+    LoRaSettings.TxPacketTimeout = value;
+}
+
+uint32_t SX1276LoRaGetTxPacketTimeout( void )
+{
+    return LoRaSettings.TxPacketTimeout;
+}
+
+void SX1276LoRaSetRxPacketTimeout( uint32_t value )
+{
+    LoRaSettings.RxPacketTimeout = value;
+}
+
+uint32_t SX1276LoRaGetRxPacketTimeout( void )
+{
+    return LoRaSettings.RxPacketTimeout;
+}
+
+void SX1276LoRaSetPayloadLength( uint8_t value )
+{
+    SX1276LR->RegPayloadLength = value;
+    SX1276Write( REG_LR_PAYLOADLENGTH, SX1276LR->RegPayloadLength );
+    LoRaSettings.PayloadLength = value;
+}
+
+uint8_t SX1276LoRaGetPayloadLength( void )
+{
+    SX1276Read( REG_LR_PAYLOADLENGTH, &SX1276LR->RegPayloadLength );
+    LoRaSettings.PayloadLength = SX1276LR->RegPayloadLength;
+    return LoRaSettings.PayloadLength;
+}
+
+void SX1276LoRaSetPa20dBm( bool enale )
+{
+    SX1276Read( REG_LR_PADAC, &SX1276LR->RegPaDac );
+    SX1276Read( REG_LR_PACONFIG, &SX1276LR->RegPaConfig );
+
+    if( ( SX1276LR->RegPaConfig & RFLR_PACONFIG_PASELECT_PABOOST ) == RFLR_PACONFIG_PASELECT_PABOOST )
+    {    
+        if( enale == true )
+        {
+            SX1276LR->RegPaDac = 0x87;
+        }
+    }
+    else
+    {
+        SX1276LR->RegPaDac = 0x84;
+    }
+    SX1276Write( REG_LR_PADAC, SX1276LR->RegPaDac );
+}
+
+bool SX1276LoRaGetPa20dBm( void )
+{
+    SX1276Read( REG_LR_PADAC, &SX1276LR->RegPaDac );
+    
+    return ( ( SX1276LR->RegPaDac & 0x07 ) == 0x07 ) ? true : false;
+}
+
+void SX1276LoRaSetPAOutput( uint8_t outputPin )
+{
+    SX1276Read( REG_LR_PACONFIG, &SX1276LR->RegPaConfig );
+    SX1276LR->RegPaConfig = (SX1276LR->RegPaConfig & RFLR_PACONFIG_PASELECT_MASK ) | outputPin;
+    SX1276Write( REG_LR_PACONFIG, SX1276LR->RegPaConfig );
+}
+
+uint8_t SX1276LoRaGetPAOutput( void )
+{
+    SX1276Read( REG_LR_PACONFIG, &SX1276LR->RegPaConfig );
+    return SX1276LR->RegPaConfig & ~RFLR_PACONFIG_PASELECT_MASK;
+}
+
+void SX1276LoRaSetPaRamp( uint8_t value )
+{
+    SX1276Read( REG_LR_PARAMP, &SX1276LR->RegPaRamp );
+    SX1276LR->RegPaRamp = ( SX1276LR->RegPaRamp & RFLR_PARAMP_MASK ) | ( value & ~RFLR_PARAMP_MASK );
+    SX1276Write( REG_LR_PARAMP, SX1276LR->RegPaRamp );
+}
+
+uint8_t SX1276LoRaGetPaRamp( void )
+{
+    SX1276Read( REG_LR_PARAMP, &SX1276LR->RegPaRamp );
+    return SX1276LR->RegPaRamp & ~RFLR_PARAMP_MASK;
+}
+
+void SX1276LoRaSetSymbTimeout( uint16_t value )
+{
+    SX1276ReadBuffer( REG_LR_MODEMCONFIG2, &SX1276LR->RegModemConfig2, 2 );
+
+    SX1276LR->RegModemConfig2 = ( SX1276LR->RegModemConfig2 & RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK ) | ( ( value >> 8 ) & ~RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK );
+    SX1276LR->RegSymbTimeoutLsb = value & 0xFF;
+    SX1276WriteBuffer( REG_LR_MODEMCONFIG2, &SX1276LR->RegModemConfig2, 2 );
+}
+
+uint16_t SX1276LoRaGetSymbTimeout( void )
+{
+    SX1276ReadBuffer( REG_LR_MODEMCONFIG2, &SX1276LR->RegModemConfig2, 2 );
+    return ( ( SX1276LR->RegModemConfig2 & ~RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK ) << 8 ) | SX1276LR->RegSymbTimeoutLsb;
+}
+
+void SX1276LoRaSetLowDatarateOptimize( bool enable )
+{
+    SX1276Read( REG_LR_MODEMCONFIG3, &SX1276LR->RegModemConfig3 );
+    SX1276LR->RegModemConfig3 = ( SX1276LR->RegModemConfig3 & RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_MASK ) | ( enable << 3 );
+    SX1276Write( REG_LR_MODEMCONFIG3, SX1276LR->RegModemConfig3 );
+}
+
+bool SX1276LoRaGetLowDatarateOptimize( void )
+{
+    SX1276Read( REG_LR_MODEMCONFIG3, &SX1276LR->RegModemConfig3 );
+    return ( ( SX1276LR->RegModemConfig3 & RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_ON ) >> 3 );
+}
+
+void SX1276LoRaSetNbTrigPeaks( uint8_t value )
+{
+    SX1276Read( 0x31, &SX1276LR->RegDetectOptimize );
+    SX1276LR->RegDetectOptimize = ( SX1276LR->RegDetectOptimize & 0xF8 ) | value;
+    SX1276Write( 0x31, SX1276LR->RegDetectOptimize );
+}
+
+uint8_t SX1276LoRaGetNbTrigPeaks( void )
+{
+    SX1276Read( 0x31, &SX1276LR->RegDetectOptimize );
+    return ( SX1276LR->RegDetectOptimize & 0x07 );
+}
+
+#endif // USE_SX1276_RADIO

APP/network_mgr/lora/Radio/src/sx1276.c

@@ -0,0 +1,385 @@
+/*
+ * THE FOLLOWING FIRMWARE IS PROVIDED: (1) "AS IS" WITH NO WARRANTY; AND 
+ * (2)TO ENABLE ACCESS TO CODING INFORMATION TO GUIDE AND FACILITATE CUSTOMER.
+ * CONSEQUENTLY, SEMTECH SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT
+ * OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION
+ * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ * 
+ * Copyright (C) SEMTECH S.A.
+ */
+/*! 
+ * \file       sx1276.c
+ * \brief      SX1276 RF chip driver
+ *
+ * \version    2.0.0 
+ * \date       May 6 2013
+ * \author     Gregory Cristian
+ *
+ * Last modified by Miguel Luis on Jun 19 2013
+ */
+#include "platform.h"
+#include "radio.h"
+#include "string.h"
+
+#if defined( USE_SX1276_RADIO )
+
+#include "sx1276.h"
+
+#include "sx1276-Hal.h"
+#include "sx1276-Fsk.h"
+#include "sx1276-LoRa.h"
+#include "sx1276-FskMisc.h"
+#include "sx1276-LoRamisc.h"
+/*!
+ * SX1276 registers variable
+ */
+uint8_t SX1276Regs[0x70];
+
+static bool LoRaOn = false;
+static bool LoRaOnState = false;
+
+extern tFskSettings FskSettings;
+
+void SX1276Init( void )
+{
+  	static uint8_t i, spi_test=0;
+  
+    // Initialize FSK and LoRa registers structure
+    SX1276 = ( tSX1276* )SX1276Regs;
+    SX1276LR = ( tSX1276LR* )SX1276Regs;
+	  
+    memset(SX1276,(int)0,sizeof(tSX1276));
+    memset(SX1276LR,(int)0,sizeof(tSX1276LR));
+    
+    SX1276Reset( );
+    
+    SX1276LoRaSetOpMode(RFLR_OPMODE_STANDBY);
+    
+    // REMARK: After radio reset the default modem is FSK
+	//SPI²âÊÔ
+	for(i = 0;i <= 10;i++) {
+		SX1276Read(i, &spi_test);
+		printf("!!!LORA init, TempReg(%d) = 0x%02X\r\n", i, spi_test);
+	}
+	
+#if ( LORA == 0 ) 
+    
+    LoRaOn = false;
+    SX1276SetLoRaOn( LoRaOn );
+    // Initialize FSK modem
+    SX1276FskInit( );
+
+#else
+
+    LoRaOn = true;
+    LoRaOnState=false;
+    SX1276SetLoRaOn( LoRaOn );
+    // Initialize LoRa modem
+    SX1276LoRaInit( );
+    
+#endif
+
+   // SX1276LoRaSetPreambleLength(100);
+}
+
+
+void EnterRxTestMode()
+{
+  uint8_t PackgeConfigration=0;
+ 
+  SX1276FskSetOpMode( RF_OPMODE_STANDBY );
+  
+  SX1276Read(REG_PACKETCONFIG2,&PackgeConfigration);
+  PackgeConfigration=PackgeConfigration&0xBF;
+  SX1276Write( REG_PACKETCONFIG2, PackgeConfigration );   
+  SX1276Read(REG_PACKETCONFIG2,&PackgeConfigration);  
+                       //       SyncAddress             Dclk                      Data                    Timeout
+  SX1276->RegDioMapping1 = RF_DIOMAPPING1_DIO0_00 | RF_DIOMAPPING1_DIO1_00 | RF_DIOMAPPING1_DIO2_11 | RF_DIOMAPPING1_DIO3_00;
+  SX1276->RegDioMapping2 = RF_DIOMAPPING2_DIO4_11 | RF_DIOMAPPING2_DIO5_10 | RF_DIOMAPPING2_MAP_PREAMBLEDETECT;
+  SX1276WriteBuffer( REG_DIOMAPPING1, &SX1276->RegDioMapping1, 2 );
+  
+  SX1276FskSetOpMode( RF_OPMODE_RECEIVER );
+}
+
+void EnterTestMode()
+{
+
+    SX1276FskSetRFFrequency( FskSettings.RFFrequency );
+    SX1276FskSetFdev( FskSettings.Fdev );
+    
+    SX1276FskSetPAOutput( RF_PACONFIG_PASELECT_PABOOST );
+    SX1276FskSetPa20dBm( true );
+    FskSettings.Power = 20;
+    SX1276FskSetRFPower( FskSettings.Power );
+    
+    SX1276FskSetOpMode( RF_OPMODE_TRANSMITTER );
+}
+
+
+void SX1276Reset( void )
+{
+	  uint32_t startTick;
+    SX1276SetReset( RADIO_RESET_ON );
+    
+    // Wait 1ms
+    startTick = GET_TICK_COUNT( );
+    while( ( GET_TICK_COUNT( ) - startTick ) < TICK_RATE_MS( 1) );    
+
+    SX1276SetReset( RADIO_RESET_OFF );
+    
+    // Wait 6ms
+    startTick = GET_TICK_COUNT( );
+    while( ( GET_TICK_COUNT( ) - startTick ) < TICK_RATE_MS( 6) );   
+    
+}
+
+void SX1276SetLoRaOn( bool enable )
+{
+   // uint8_t ModeTest=0;
+  // static uint8_t test=0;
+  
+    if( LoRaOnState == enable )
+    {
+        return;
+    }
+    LoRaOnState = enable;
+    LoRaOn = enable;
+
+    if( LoRaOn == true )
+    {   
+        SX1276LoRaSetOpMode(RFLR_OPMODE_SLEEP);
+                                               
+        SX1276LR->RegOpMode = ( SX1276LR->RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_ON;
+        SX1276Write( REG_LR_OPMODE, SX1276LR->RegOpMode );
+                                                          
+                                                         
+        
+        SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
+        
+//        SX1276Write( REG_LR_FRFMSB, 0x86 );
+//        SX1276ReadBuffer( REG_LR_FRFMSB, &test, 1);
+        
+                                        // RxDone               RxTimeout                   FhssChangeChannel           CadDone
+        SX1276LR->RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_00 | RFLR_DIOMAPPING1_DIO1_00 | RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_00;
+                                        // CadDetected          ModeReady
+        SX1276LR->RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_00 | RFLR_DIOMAPPING2_DIO5_00;
+        SX1276WriteBuffer( REG_LR_DIOMAPPING1, &SX1276LR->RegDioMapping1, 2 );
+        
+        SX1276ReadBuffer( REG_LR_OPMODE, SX1276Regs + 1, 0x70 - 1 );
+    }
+    else
+    {
+        SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
+        
+        SX1276LR->RegOpMode = ( SX1276LR->RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_OFF;
+        SX1276Write( REG_LR_OPMODE, SX1276LR->RegOpMode );
+        
+        SX1276LoRaSetOpMode( RFLR_OPMODE_STANDBY );
+        
+        SX1276ReadBuffer( REG_OPMODE, SX1276Regs + 1, 0x70 - 1 );
+    }
+}
+
+bool SX1276GetLoRaOn( void )
+{
+    return LoRaOn;
+}
+
+void SX1276SetOpMode( uint8_t opMode )
+{
+    if( LoRaOn == false )
+    {
+        SX1276FskSetOpMode( opMode );
+    }
+    else
+    {
+        SX1276LoRaSetOpMode( opMode );
+    }
+}
+
+uint8_t SX1276GetOpMode( void )
+{
+    if( LoRaOn == false )
+    {
+        return SX1276FskGetOpMode( );
+    }
+    else
+    {
+        return SX1276LoRaGetOpMode( );
+    }
+}
+
+double SX1276ReadRssi( void )
+{
+    if( LoRaOn == false )
+    {
+        return SX1276FskReadRssi( );
+    }
+    else
+    {
+        return SX1276LoRaReadRssi( );
+    }
+}
+
+uint8_t SX1276ReadRxGain( void )
+{
+    if( LoRaOn == false )
+    {
+        return SX1276FskReadRxGain( );
+    }
+    else
+    {
+        return SX1276LoRaReadRxGain( );
+    }
+}
+
+uint8_t SX1276GetPacketRxGain( void )
+{
+    if( LoRaOn == false )
+    {
+        return SX1276FskGetPacketRxGain(  );
+    }
+    else
+    {
+        return SX1276LoRaGetPacketRxGain(  );
+    }
+}
+
+int8_t SX1276GetPacketSnr( void )
+{
+    if( LoRaOn == false )
+    {
+         while( 1 )
+         {
+             // Useless in FSK mode
+             // Block program here
+         }
+    }
+    else
+    {
+        return SX1276LoRaGetPacketSnr(  );
+    }
+}
+
+double SX1276GetPacketRssi( void )
+{
+    if( LoRaOn == false )
+    {
+        return SX1276FskGetPacketRssi(  );
+    }
+    else
+    {
+        return SX1276LoRaGetPacketRssi( );
+    }
+}
+
+uint32_t SX1276GetPacketAfc( void )
+{
+    if( LoRaOn == false )
+    {
+        return SX1276FskGetPacketAfc(  );
+    }
+    else
+    {
+         while( 1 )
+         {
+             // Useless in LoRa mode
+             // Block program here
+         }
+    }
+}
+
+void SX1276StartRx( void )
+{
+    if( LoRaOn == false )
+    {
+        SX1276FskSetRFState( RF_STATE_RX_INIT );
+    }
+    else
+    {
+        SX1276LoRaSetRFState( RF_STATE_RX_INIT );
+    }
+}
+
+void SX1276StartTx( void )//Add by Andrew
+{
+    if( LoRaOn == false )
+    {   
+        SX1276FskSetRFState( RF_STATE_TX_INIT );
+    }
+    else
+    {
+        SX1276LoRaSetRFState( RFLR_STATE_TX_INIT );
+    }
+}
+
+void SX1276StartCad( void )
+{
+	if( LoRaOn == true )
+	{
+		SX1276LoRaSetRFState( RFLR_STATE_CAD_INIT );
+	}
+}
+
+void SX1276GetRxPacket( void *buffer, uint16_t *size )
+{
+    if( LoRaOn == false )
+    {
+        SX1276FskGetRxPacket( buffer, size );
+    }
+    else
+    {
+        SX1276LoRaGetRxPacket( buffer, size );
+    }
+}
+
+void SX1276SetTxPacket( const void *buffer, uint16_t size )
+{
+    if( LoRaOn == false )
+    {
+        SX1276FskSetTxPacket( buffer, size );
+    }
+    else
+    {
+        SX1276LoRaSetTxPacket( buffer, size );
+    }
+}
+
+uint8_t SX1276GetRFState( void )
+{
+    if( LoRaOn == false )
+    {
+        return SX1276FskGetRFState( );
+    }
+    else
+    {
+        return SX1276LoRaGetRFState( );
+    }
+}
+
+void SX1276SetRFState( uint8_t state )
+{
+    if( LoRaOn == false )
+    {
+        SX1276FskSetRFState( state );
+    }
+    else
+    {
+        SX1276LoRaSetRFState( state );
+    }
+}
+
+uint32_t SX1276Process( void )
+{
+    if( LoRaOn == false )
+    {
+        return SX1276FskProcess( );
+    }
+    else
+    {
+        return SX1276LoRaProcess( );
+    }
+}
+
+#endif // USE_SX1276_RADIO

APP/network_mgr/lora/lora.c

@@ -0,0 +1,79 @@
+tRadioDriver *Radio = 0;
+uint8_t cmpBuf[256] ;
+OS_Q  lora_q;
+
+void lora_send(char *tx_data, uint32_t tx_len)
+{
+	char *p_msg = NULL;
+	uint32_t msg_len;
+	OS_ERR      err;	
+
+	/* 接受消息, 发往net_proc模块统一处理 */
+	p_msg = (char *)net_queue_mem_calloc();	
+	if(p_msg) {
+		memcpy(p_msg, tx_data, tx_len);
+		OS_QPost(&lora_q, p_msg, msg_len, OS_OPT_POST_FIFO, 0, &err);
+	}
+}
+
+uint32_t lora_recv(char *tx_data, uint32_t *tx_len)
+{
+	int8_t snr = 0;
+	double rssi=0;
+	
+	*tx_len = SX1276_Read_Data(tx_data ,100, &snr, &rssi);\
+	if(*tx_len > 0) {
+		if(memcmp(cmpBuf, tx_data, *tx_len)){//和上次数据不同，数据有效			
+			memcpy(cmpBuf, tx_data, *tx_len);
+		} else {
+			return 0;
+		}
+	}
+	
+	return *tx_len;
+}
+
+void lora_task(void)
+{
+	inner_msg_format_t *p_msg = NULL;
+	uint32_t msg_len;
+	OS_ERR      err;	
+
+	/* 接受消息, 发往net_proc模块统一处理 */
+	p_msg = (inner_msg_format_t *)net_queue_mem_calloc();
+	if(p_msg) {
+		lora_recv(p_msg, &msg_len);
+		if(msg_len) {
+			net_queue_insert((char *)p_msg, msg_len);
+		} else {
+			net_queue_mem_free(p_msg);
+		}
+	}
+
+	/* 发送消息 */
+	while(p_msg = (inner_msg_format_t *)OSQPend(&lora_q, 0, OS_OPT_PEND_NON_BLOCKING, &msg_len, NULL, &err)) {	/* none blocking. */
+		if(p_msg&&msg_len) {
+			SX1276_Send_Data_Listen_Ch((char *)p_msg, msg_len & 0xFF, 300, 2);
+			//发送完成后重新开启接收
+			Radio->StartRx();
+		}
+	}	
+}
+
+void lora_init(char *device_id)
+{
+	int i = 0, temp ;
+	OS_ERR      err;	
+	temp = 0;
+
+	OSQCreate(&lora_q, "lora_queue", 32, &err);//创建网络消息处理队列	
+	Radio = RadioDriverInit();
+	if(Radio == NULL) {
+		printf("RADIO is not defined!!!! ");
+		return -1;
+	}
+	Radio->Init();               			
+	Radio->StartRx();
+	
+	return temp;
+}

APP/network_mgr/lora/lora_adapt/delay.c

@@ -0,0 +1,32 @@
+#include "delay.h"
+#include <stdint.h>
+
+void Delay_Us (uint32_t delay)
+{
+  uint8_t i=0;
+  uint32_t j=0;
+  for(i=0;i<delay;i++)
+  {
+    for(j=0;j<8;j++);
+  }
+}
+
+
+void Delay_Ms(uint32_t delay )
+{
+  uint32_t i=0;
+  uint32_t j=0;
+  
+  for(i=0;i<delay;i++)
+  {
+    for(j=0;j<4540;j++);
+  }
+}
+
+void HAL_Delay_nMs( uint32_t Delay )
+{
+    uint32_t tickstart = 0;
+    tickstart = HAL_GetTick( );
+    while( ( HAL_GetTick( ) - tickstart ) < Delay );
+}
+

APP/network_mgr/lora/lora_adapt/delay.h

@@ -0,0 +1,16 @@
+#ifndef _DELAY_H_
+#define _DELAY_H_
+
+#include<stdint.h>
+
+extern volatile  uint32_t TickCounter;
+extern volatile  uint32_t ticktimer;
+
+void Delay_Us (uint32_t delay);
+void Delay_Ms(uint32_t delay );
+void HAL_Delay_nMs( uint32_t Delay );
+
+#define HAL_GetTick()  TickCounter
+
+#endif
+

APP/network_mgr/lora/lora_adapt/gpio.c

@@ -0,0 +1,102 @@
+#include "stm32f10x.h"
+#include "gpio.h"
+
+
+void GPIO_int()
+{
+  GPIO_InitTypeDef  GPIO_InitStruct;
+
+  RCC_APB2PeriphClockCmd( RCC_APB2Periph_SPI1, ENABLE );
+  
+  /****************************************
+   RF_NSS
+  ****************************************/
+  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;
+  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_Out_PP;
+  GPIO_InitStruct.GPIO_Pin=RF_NSS_IO;
+  GPIO_Init(RF_NSS_PORT, &GPIO_InitStruct);
+  
+  
+  /****************************************
+   M_CLK
+  ****************************************/
+  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;
+  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_AF_PP;
+  GPIO_InitStruct.GPIO_Pin=RF_CLK_IO;
+  GPIO_Init(RF_CLK_PORT, &GPIO_InitStruct);
+  //GPIO_PinAFConfig(RF_CLK_PORT,RF_CLK_AF,GPIO_AF_0);
+    
+  /****************************************
+   M_MOSI
+  ****************************************/
+  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;
+  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_AF_PP;
+  GPIO_InitStruct.GPIO_Pin=RF_MOSI_IO;
+  GPIO_Init(RF_MOSI_PORT, &GPIO_InitStruct);
+  //GPIO_PinAFConfig(RF_MOSI_PORT,RF_MOSI_AF,GPIO_AF_0);
+
+  /****************************************
+   M_MISO
+  ****************************************/
+  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;
+  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_AF_PP;
+  GPIO_InitStruct.GPIO_Pin=RF_MISO_IO;
+  GPIO_Init(RF_MISO_PORT, &GPIO_InitStruct);
+  //GPIO_PinAFConfig(RF_MISO_PORT,RF_MISO_AF,GPIO_AF_0);
+  
+  
+  /****************************************
+   RF_RST
+  ****************************************/
+  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_10MHz;
+  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_Out_PP;
+  GPIO_InitStruct.GPIO_Pin=RF_RST_IO;
+  GPIO_Init(RF_RST_PORT, &GPIO_InitStruct);
+
+#if 0
+  /****************************************
+   LED1
+  ****************************************/
+  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_10MHz;
+  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_Out_PP;
+  GPIO_InitStruct.GPIO_Pin=LED1_PIN;
+  GPIO_Init(LED1_PORT, &GPIO_InitStruct);
+#endif  
+  
+  /****************************************
+   RF_DIO0
+  ****************************************/
+  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_10MHz;
+  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_IN_FLOATING;
+  GPIO_InitStruct.GPIO_Pin=RF_DIO0_IO;
+  GPIO_Init(RF_DIO0_PORT, &GPIO_InitStruct);
+  
+  
+   /****************************************
+   RF_DIO1
+  ****************************************/
+  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_10MHz;
+  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_IN_FLOATING;
+  GPIO_InitStruct.GPIO_Pin=RF_DIO1_IO;
+  GPIO_Init(RF_DIO1_PORT, &GPIO_InitStruct);
+  
+  /****************************************
+   RF_DIO3
+  ****************************************/
+  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_10MHz;
+  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_IN_FLOATING;
+  GPIO_InitStruct.GPIO_Pin=RF_DIO3_IO;
+  GPIO_Init(RF_DIO3_PORT, &GPIO_InitStruct);	
+	
+	/*sx1278 射频芯片 接收引脚初始化 ---输出*/
+  GPIO_InitStruct.GPIO_Pin =  RXE_PIN;       			 //引脚                                               
+  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;   //频率(50M)																										//输出类型(推挽式输出)
+  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
+  GPIO_Init(RXE_PORT, &GPIO_InitStruct);
+
+	/*sx1278 射频芯片 发射引脚初始化 ---输出*/
+  GPIO_InitStruct.GPIO_Pin =  TXE_PIN;       			 //引脚                                               
+  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;   //频率(50M)																										//输出类型(推挽式输出)
+  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
+  GPIO_Init(TXE_PORT, &GPIO_InitStruct);
+}

APP/network_mgr/lora/lora_adapt/gpio.h

@@ -0,0 +1,63 @@
+#ifndef _GPIO_H_
+#define _GPIO_H_
+
+
+#define  RF_CLK_PORT       GPIOA
+#define  RF_CLK_IO         GPIO_Pin_5
+#define  RF_CLK_AF         GPIO_PinSource5
+
+#define  RF_MISO_PORT      GPIOA
+#define  RF_MISO_IO        GPIO_Pin_6
+#define  RF_MISO_AF        GPIO_PinSource6
+
+#define  RF_MOSI_PORT      GPIOA
+#define  RF_MOSI_IO        GPIO_Pin_7
+#define  RF_MOSI_AF        GPIO_PinSource7
+
+#define  RF_NSS_PORT       GPIOA
+#define  RF_NSS_IO         GPIO_Pin_4
+
+#define  RF_RST_PORT       GPIOB
+#define  RF_RST_IO         GPIO_Pin_0
+
+#define  RF_DIO0_PORT      GPIOB
+#define  RF_DIO0_IO        GPIO_Pin_1
+
+#define  RF_DIO1_PORT      GPIOE
+#define  RF_DIO1_IO        GPIO_Pin_8
+
+#define  RF_DIO2_PORT      GPIOE
+#define  RF_DIO2_IO        GPIO_Pin_9
+
+#define  RF_DIO3_PORT      GPIOE
+#define  RF_DIO3_IO        GPIO_Pin_10
+
+#define  RF_DIO4_PORT      GPIOC
+#define  RF_DIO4_IO        GPIO_Pin_4
+
+#define  RF_DIO5_PORT      GPIOC
+#define  RF_DIO5_IO        GPIO_Pin_5
+
+#define LED1_PORT          GPIOB
+#define LED1_PIN           GPIO_Pin_6
+
+#define RXE_PORT       				GPIOC															//change by scx
+#define RXE_PIN  							GPIO_Pin_5
+
+#define RXE_CLOCK  						RCC_APB2Periph_GPIOC
+#define RXE_HIGH()         		GPIO_SetBits(RXE_PORT,RXE_PIN)
+#define RXE_LOW()          		GPIO_ResetBits(RXE_PORT,RXE_PIN)
+#define RXE_STATE()        		GPIO_ReadOutputDataBit(RXE_PORT,RXE_PIN)
+
+#define TXE_PORT       				GPIOB															//change by scx
+#define TXE_PIN  							GPIO_Pin_1
+#define TXE_CLOCK  						RCC_APB2Periph_GPIOB
+#define TXE_HIGH()         		GPIO_SetBits(TXE_PORT,TXE_PIN)
+#define TXE_LOW()          		GPIO_ResetBits(TXE_PORT,TXE_PIN)
+#define TXE_STATE()        		GPIO_ReadOutputDataBit(TXE_PORT,TXE_PIN)
+
+void GPIO_int(void);
+
+
+#endif
+

APP/network_mgr/lora/lora_adapt/spi.c

@@ -0,0 +1,35 @@
+#include "stm32f10x.h"
+#include "spi.h"
+
+void SPI2_Int()
+{
+    SPI_InitTypeDef  SPI_InitStruct;
+    
+    SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex;//全双工模式
+    SPI_InitStruct.SPI_Mode = SPI_Mode_Master;
+    SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b;
+    SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;//第一个边沿
+    SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;//上升沿捕获
+    SPI_InitStruct.SPI_NSS = SPI_NSS_Soft;
+    SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8; // 6MHz
+    SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;
+    SPI_InitStruct.SPI_CRCPolynomial = 7;
+    SPI_Init(LORA_SPI,&SPI_InitStruct);
+    
+//    SPI_RxFIFOThresholdConfig(SPI2, SPI_RxFIFOThreshold_QF);
+    SPI_Cmd(LORA_SPI, ENABLE );
+	SPI_SSOutputCmd(LORA_SPI, ENABLE);
+}
+
+
+uint8_t SpiInputOutput_Data(SPI_TypeDef* SPIx,uint8_t InputData)
+{
+ 
+    while( SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET);//当发送buffer为空时(说明上一次数据已复制到移位寄存器中)退出,这时可以往buffer里面写数据
+    SPI_I2S_SendData(SPIx, InputData);
+    
+  
+    while( SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_RXNE) == RESET);//当接收buffer为非空时退出
+    return SPI_I2S_ReceiveData(SPIx);
+}
+

APP/network_mgr/lora/lora_adapt/spi.h

@@ -0,0 +1,11 @@
+#ifndef  _SPI_H_
+#define  _SPI_H_
+
+#define LORA_SPI		SPI1
+void SPI2_Int(void);
+uint8_t SpiInputOutput_Data(SPI_TypeDef* SPIx,uint8_t InputData);
+
+
+#endif
+
+

APP/network_mgr/lora/lora_test.c

@@ -0,0 +1,145 @@
+#include "stm32f10x.h"
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include "Sx1276-1278.h"
+
+#include "gpio.h"
+#include "delay.h"
+#include "spi.h"
+
+#include "crc.h"
+
+/**************************************************************************************************************************************
+Demo 程序流程  EnableMaster=true  为主机端，主机端发送一个"PING"数据后切换到接收，等待从机返回的应答"PONG"数据LED闪烁
+
+               EnableMaster=false 为从机端，从机端接收到主机端发过来的"PING"数据后LED闪烁并发送一个"PONG"数据作为应答
+***************************************************************************************************************************************/
+bool  EnableMaster=false;//主从选择 true为主 false 为从
+
+tRadioDriver *Radio = 0;
+const uint8_t PingMsg[] = "PING";
+const uint8_t PongMsg[] = "PONG";
+uint16_t num_rx=0;
+uint8_t   RXBuffer[RF_BUFFER_SIZE];  //RX buffer			
+uint8_t   TXBuffer[RF_BUFFER_SIZE];  //TX buffer
+uint16_t  crc_value;
+
+void HW_Int()//MCU外围资源初始化
+{
+  GPIO_int();
+  SPI2_Int();
+}
+
+
+void LedToggle(void)
+{
+  //GPIO_WriteBit( LED1_PORT, LED1_PIN,Bit_RESET);//LED闪烁
+  HAL_Delay_nMs (1);
+  //GPIO_WriteBit( LED1_PORT, LED1_PIN,Bit_SET);
+}
+
+void lora_data_send(char *tx_data, uint32_t tx_len)
+{
+	memcpy(TXBuffer, tx_data, tx_len);
+	crc_value=RadioComputeCRC(TXBuffer,4,CRC_TYPE_IBM);//计算得出要发送数据包CRC值
+	TXBuffer[tx_len]=crc_value>>8;
+	TXBuffer[tx_len + 1]= crc_value;
+
+	Radio->SetTxPacket( TXBuffer, tx_len + 2);	
+}
+/*
+ * Manages the master operation
+ */
+void OnMaster( void )
+{  
+	switch(Radio->Process())
+	{
+		case RF_TX_DONE:
+			Radio->StartRx( ); 
+			break;
+		case RF_RX_DONE:
+			Radio->GetRxPacket( RXBuffer, ( uint16_t* )&num_rx );
+
+			if(num_rx > 0) {
+				printf("master RF_RX_DONE  %s\r\n", RXBuffer);
+				crc_value=RXBuffer[num_rx-2];
+				crc_value<<=8;
+				crc_value|=RXBuffer[num_rx-1];
+				if(crc_value==RadioComputeCRC(RXBuffer,num_rx-2,CRC_TYPE_IBM)) {
+					if(strncmp(( const char* )RXBuffer, ( const char* )PongMsg,4)==0) {
+						LedToggle();//LED闪烁
+						lora_data_send("PING", 4);
+					}
+				}
+			}            
+			break;
+		case RF_RX_TIMEOUT:
+			printf("RF_RX_TIMEOUT  \r\n");
+			lora_data_send("PING", 4);
+			break;
+		default:
+			break;
+	}
+}
+
+/*
+ * Manages the slave operation
+ */
+void OnSlave( void )
+{
+	switch(Radio->Process())
+	{
+		case RF_RX_DONE:
+			Radio->GetRxPacket(RXBuffer,(uint16_t* )&num_rx );
+			if(num_rx >0) {
+				printf("slave RF_RX_DONE  %s\r\n", RXBuffer);
+				crc_value=RXBuffer[num_rx-2];
+				crc_value<<=8;
+				crc_value|=RXBuffer[num_rx-1];
+				if(crc_value==RadioComputeCRC(RXBuffer,num_rx-2,CRC_TYPE_IBM)) {
+					if( strncmp( ( const char* )RXBuffer, ( const char* )PingMsg, 4 ) == 0 ) {
+						LedToggle();//LED闪烁
+						lora_data_send("PONG", 4);
+					} 
+				}
+			}
+			break;
+		case RF_TX_DONE:
+			Radio->StartRx( ); 
+			break;
+		default:
+			break;
+	}
+}
+
+int lora_test(void)
+{
+	static uint8_t init = 0;
+	
+	if(init == 0) {
+		HW_Int();//MCU初始化
+		Radio = RadioDriverInit();
+		Radio->Init();
+		if(EnableMaster == true) {
+			lora_data_send("PING", 4);
+		} else {
+			Radio->StartRx();
+		}
+		init = 1;
+	}
+
+	if(EnableMaster == true) {		
+		OnMaster();
+	} else {
+		OnSlave();
+	}
+
+	return 0;
+}
+
+void lora_init(void)
+{
+	Radio = RadioDriverInit();
+	Radio->Init();
+}

APP/network_mgr/lora/sx1276_api.c

@@ -0,0 +1,314 @@
+#include <stdio.h>
+#include <string.h>
+#include "sx1276_api.h"
+#include "sx1276-LoRa.h"
+
+
+#include "sys_tick.h"
+#include "sx1276-Hal.h"
+#include "radio.h"
+#include "sx1276.h"
+#include "queue.h"
+
+#include "led.h"
+#include "sx1276-LoRaMisc.h"
+
+/************************************************
+函数名称 ： 应用层函数，SX1276_Send_Data
+功    能 ： Lora发送   阻塞函数,自动计算发送超时时间
+参    数 ： buffer  发送缓存区，
+						bufferLen 发送数据长度，最长不能超过128个字节
+返 回 值 ： 返回1发送成功，其他值发送失败
+作    者 ： sun
+*************************************************/
+uint8_t SX1276_Send_Data(uint8_t * buffer,uint16_t bufferLen)
+{
+	uint32_t result = 0;
+	uint32_t Timeout = 0;
+
+	Timeout = SX1276GetLoraTimeOnAir(bufferLen);
+	Timeout = 2*Timeout;
+	SX1276LoRaSetTxPacketTimeout( Timeout );
+	if(bufferLen > 255)
+	{
+	//SX1276LoRaSetPayloadLength(128);
+	//SX1276SetTxPacket( buffer, 128 );		//开始发送
+		return 0;
+	}
+	else
+	{
+	//start_led(1,bufferLen,99,30*10);//(led,delay*0.1ms,duty,period*0.1ms)
+	//LED1=!LED1;
+		SX1276LoRaSetPayloadLength(bufferLen);
+		SX1276SetTxPacket( buffer, bufferLen );		//开始发送
+
+
+	}
+	while( 1 )
+	{
+	//start_led(1,3*10,90,100*10);//(led,delay*0.1ms,duty,period*0.1ms)
+	//LED3=!LED3;
+		result = SX1276Process( );
+
+
+		if( result == RF_TX_DONE || result == RF_TX_TIMEOUT )
+		{
+			break;
+		}
+	}
+
+	//start_led(1,0,90,100*10);//(led,delay*0.1ms,duty,period*0.1ms)
+	if( result == RF_TX_DONE )
+	{
+		return 1;
+	}
+	return 0;
+}
+
+ /************************************************
+函数名称 ： SX1276_Read_Data  LoRa单次接函数
+功    能 ： 单信道接收,阻塞函数,接收指定敷在长度的数据,用于发送完成后开启短暂接收窗
+参    数 ：	Buffer 接收到的数据
+					  timeout  接收超时时间
+						snr   	 信噪比   输出接收当前包的信噪比
+						rssi     信号强度 输出接收当前包的信噪比
+返 回 值 ： 接收到数据返回数据长度  失败返回-1
+作    者 ： sun
+*************************************************/
+int16_t SX1276_Read_Data( void *Buffer ,uint32_t Timeout, int8_t *snr,double *rssi )
+{
+	uint32_t result;
+	uint16_t bufferLen = 0;
+	SX1276LoRaSetRxSingleOn( 1 );
+	SX1276LoRaSetRxPacketTimeout( Timeout );
+	SX1276StartRx( );
+	while( 1 )
+	{
+		result = SX1276Process( );
+		if( result == RF_RX_DONE || result == RF_RX_TIMEOUT )
+		break;
+	}
+	if( result == RF_RX_DONE )
+	{
+		SX1276GetRxPacket( Buffer, ( uint16_t* )&bufferLen );
+		*snr = SX1276LoRaGetPacketSnr( );
+		//*rssi = ( int16_t )( SX1276LoRaGetPacketRssi( ) + 0.5 );
+		//*rssi = SX1276LoRaReadRssi();
+		*rssi = SX1276LoRaGetPacketRssi();
+		return bufferLen;
+	}
+	
+	return -1;
+}
+
+/************************************************
+函数名称 ： 应用层函数，SX1276_Send_Data_Listen_Ch
+功    能 ： Lora发送   阻塞函数,自动计算发送超时时间,并且在发送时进行CAD监听。
+参    数 ： buffer  发送缓存区，
+						bufferLen 发送数据长度
+						ldelay_ms,两次发送等待时间 单位ms
+						
+返 回 值 ： 返回1发送成功，其他值发送失败
+作    者 ： sun
+*************************************************/
+uint8_t SX1276_Send_Data_Listen_Ch(uint8_t * buffer,uint16_t bufferLen,uint32_t ldelay_ms,uint8_t num)
+{
+	uint32_t result = RF_IDLE;
+	uint8_t send_r = 0;
+	uint8_t temp = num ;
+
+	while(temp--)
+	{
+		//SX1276_API_DEBUG_F("temp=%d\r\n",temp);
+		Delay_Ms(10);
+		SX1276StartCad( );
+		while( 1 )
+		{
+			result = SX1276Process( );
+			Delay_Ms(10);
+			//SX1276_API_DEBUG_F("result=%d\r\n",result);
+			if( result == RF_CHANNEL_ACTIVITY_DETECTED) {
+				printf("RF_CHANNEL_ACTIVITY_DETECTED,temp=%d\r\n",temp);
+				Delay_Ms(ldelay_ms);
+				//delay_ms(10);
+				//延时
+				//goto cad_start;
+				break;
+			} else if( result == RF_CHANNEL_EMPTY) {
+				//goto send_start; //信道时空的开始发送
+				//SX1276_API_DEBUG_F("SX1276_Send_Data\r\n");
+				send_r = SX1276_Send_Data(buffer,bufferLen);
+				//SX1276_API_DEBUG_F("SX1276_Send_Data completed\r\n");
+				if(send_r > 0)
+				{
+					return 1;
+				}
+				else
+				{
+					return 0;
+				}
+ 			} else {
+				if(temp == 0)
+				{
+					return 0;  //信道一直忙,发送失败
+				}
+			}
+			temp--;
+			if(temp>100)
+				temp=0;
+			Delay_Ms(50);
+		}
+
+		if(temp == 0)
+		{
+			return 0;  //信道一直忙,发送失败
+		}
+	}
+	return 0; 
+}
+
+
+/************************************************
+函数名称 ： 应用层函数，SX1276IsLoraChannelFree
+功    能 ： 判断环境RSSI，可用于检测信道是否忙，请自行测试界限值，一般无线都用此方法判断。
+参    数 ： int16_t rssiThresh 信道忙与不忙的界线值
+返 回 值 ： 返回1信道忙，信道不忙，
+作    者 ： sun
+*************************************************/
+bool SX1276IsLoraChannelFree( int16_t rssiThresh )
+{
+	return rssiThresh > SX1276LoRaReadRssi() ? 0:1;
+
+}
+
+/************************************************
+函数名称 ： 应用层函数，SX1276_Sleep
+功    能 ： LoRa休眠函数 LoRa休眠后功耗 < 1uA,可直接调用收发函数唤醒
+参    数 ： 
+返 回 值 ： 
+作    者 ： sun
+*************************************************/
+void SX1276_Sleep(void)
+{
+	SX1276LoRaSetOpMode( RFLR_OPMODE_SLEEP );
+}
+
+/************************************************
+函数名称 ： 应用层函数，SX1276_Cad_Listen
+功    能 ： CAD模式
+参    数 ： 
+返 回 值 ： 1，监测到有效前导码，0无检测
+作    者 ： sun
+*************************************************/
+uint8_t SX1276_Cad_Listen(void)
+{ 
+	uint32_t result =0 ;
+	SX1276StartCad( );
+	while( 1 )
+	{
+		result = SX1276Process( );
+		if( result == RF_CHANNEL_ACTIVITY_DETECTED || result == RF_CHANNEL_EMPTY )
+			break;
+	}
+	if( result == RF_CHANNEL_ACTIVITY_DETECTED )
+	{
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+
+}
+
+
+/************************************************
+函数名称 ： 应用层函数，SX1276_CAD_Task
+功    能 ： MCU唤醒后执行此代码可CAD检测接收数据
+参    数 ： Buffer 数据缓存区，Timeout 超时时间单位ms
+返 回 值 ： 没有接受到数据返回0，接收到数据返回数据长度
+作    者 ： sun
+*************************************************/
+uint16_t  SX1276_CAD_Task( void *Buffer ,uint32_t Timeout,int8_t *snr,int16_t *rssi )
+{
+	uint32_t result = RF_IDLE;
+	uint16_t len =0 ;
+	SX1276LoRaSetRxPacketTimeout( Timeout );
+	SX1276StartCad( );
+	while( 1 )
+	{
+		result = SX1276Process( );
+		if( result == RF_CHANNEL_ACTIVITY_DETECTED || result == RF_CHANNEL_EMPTY )
+			break;
+	}
+	if( result == RF_CHANNEL_ACTIVITY_DETECTED )
+	{
+		while( 1 )
+		{
+			result = SX1276Process( );
+			if( result == RF_RX_DONE || result == RF_RX_TIMEOUT|| result == RF_RX_ID_ERROR )
+				break;
+		}
+
+		if( result == RF_RX_DONE )
+		{
+			SX1276GetRxPacket( Buffer, ( uint16_t* )&len );
+			*rssi = ( int16_t )( SX1276LoRaGetPacketRssi( ) + 0.5 );
+			*snr = SX1276LoRaGetPacketSnr( );
+		}
+	}
+	return len;
+}
+
+
+/************************************************
+函数名称 ： 应用层函数，SX1276_Send_Data_Sp
+功    能 ： Lora发送   非阻塞函数,自动计算发送超时时间，不判断是否发送成功，请在程序里自行判断。
+参    数 ： buffer  发送缓存区，
+						bufferLen 发送数据长度
+返 回 值 ： 空
+作    者 ： sun
+*************************************************/
+void SX1276_Send_Data_Sp(uint8_t * buffer,uint16_t bufferLen )
+{
+		uint32_t Timeout = 0;
+		Timeout = SX1276GetLoraTimeOnAir(bufferLen);
+		Timeout = 2*Timeout;
+		SX1276LoRaSetTxPacketTimeout( Timeout );
+		if(bufferLen > 128)
+		{
+			SX1276SetTxPacket( buffer, 128 );		//开始发送
+		}
+		else
+		{
+			SX1276LoRaSetPayloadLength(bufferLen);
+			SX1276SetTxPacket( buffer, bufferLen );		//开始发送
+		}
+}
+
+ /************************************************
+函数名称 ： SX1276_Read_Data  LoRa单次接函数
+功    能 ： 单信道接收,阻塞函数,接收指定敷在长度的数据,用于发送完成后开启短暂接收窗
+参    数 ：	Buffer 接收到的数据
+					  timeout  接收超时时间
+						snr   	 信噪比   输出接收当前包的信噪比
+						rssi     信号强度 输出接收当前包的信噪比
+返 回 值 ： 接收到数据返回数据长度  失败返回-1
+作    者 ： sun
+*************************************************/
+void SX1276_Read_Data_Sp(uint32_t Timeout)
+{
+	//SX1276LoRaSetRxSingleOn( 1 );
+	SX1276LoRaSetRxPacketTimeout( Timeout );
+	SX1276StartRx( );
+	
+}
+ /************************************************
+函数名称 ： SX1276_CAD_Start
+功    能 ： 启动CAD功能，请在程序中判断CAD结果，防止阻塞
+作    者 ： sun
+*************************************************/
+void SX1276_CAD_Start( void )
+{
+	 SX1276StartCad( );
+}

APP/network_mgr/lora/sx1276_api.h

@@ -0,0 +1,65 @@
+
+#ifndef __SX1276_API_H__
+#define __SX1276_API_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "queue.h"
+
+
+
+
+#define SX1276_API_DEBUG_EN 1
+
+#ifdef SX1276_API_DEBUG_EN
+#include <stdio.h> 
+#define SX1276_API_DEBUG(fmt, x...) \
+do \
+{ \
+    printf(fmt,##x); \
+}while(0)
+
+#define SX1276_API_DEBUG_H(fmt, x...) \
+do \
+{ \
+    USART_printfHex(fmt,##x); \
+}while(0)
+
+#define SX1276_API_DEBUG_F(fmt, x...) \
+do \
+{ \
+    printf("%s %s(Line %d): "fmt,__FILE__,__FUNCTION__,__LINE__, ##x); \
+}while(0)
+
+#else
+#define SX1276_API_DEBUG(fmt, x...)
+#define SX1276_API_DEBUG1(fmt, x...)
+#define SX1276_API_DEBUG_F(fmt, x...)
+#endif
+
+
+#define LoRa_SendTimeOut 60*1000
+extern uint32_t LoRa_SendTimeCouter;
+
+
+uint8_t SX1276_Send_Data(uint8_t * buffer,uint16_t bufferLen );
+int16_t SX1276_Read_Data( void *Buffer ,uint32_t Timeout, int8_t *snr,double *rssi );
+uint8_t SX1276_Send_Data_Listen_Ch(uint8_t * buffer,uint16_t bufferLen,uint32_t ldelay_ms,uint8_t num);
+bool SX1276IsLoraChannelFree( int16_t rssiThresh );
+
+double SX1276_Ambience_Rssi(void);
+void SX1276_Sleep(void);
+uint8_t SX1276_Cad_Listen(void);
+
+uint16_t  SX1276_CAD_Task( void *Buffer ,uint32_t Timeout,int8_t *snr,int16_t *rssi );
+void SX1276_Read_Data_Sp(uint32_t Timeout );
+void SX1276_CAD_Start( void );
+void SX1276_Send_Data_Sp(uint8_t * buffer,uint16_t bufferLen );
+
+
+
+extern sequeue_t				 *lora_tx_sq;
+extern sequeue_t				 *lora_rx_sq;
+
+#endif // __RADIO_H__

APP/network_mgr/me3616/me3616.c

@@ -0,0 +1,1345 @@
+/** ******************************************************************************
+ * @file    ME3616.c
+ * @author  度云未来 DOIOT
+ * @brief   EC20模块AT指令简易串口驱动
+ ******************************************************************************
+ * @attention
+ * <h2><center>&copy; Copyright (c) 2019 成都度云未来
+ * All rights reserved.</center></h2>
+ * 注意:本程序针对cubemx 生成的hal库快速开发
+ * 环境:keil5.0
+ * 描述：
+ * 文件版本：1.3		更新时间2020/10/15   已支持TCP,LWM2M的连接
+ ********************************************************************************/
+/*必备依赖*/
+#include "includes.h"
+#include "trace.h"
+#include "me3616.h"				 	/*文件的头文件*/
+#include "at_module.h"		 	/*AT指令相关的头文件*/
+#include "string_fuc.h"
+
+#include <stdarg.h>		
+#include <string.h>		
+#include <stdlib.h>		
+#include <stdio.h>	
+/********************************************************************************/
+/*
+测试了strstr和kmp的性能，最终用strstr。
+*/
+/* me3616类的句柄,该句柄会默认调用 */
+ME3616  me3616;
+
+/*发送的指令组，需要校验的响应组，校验组数量，校验等级，重发次数，跳转位置，超时时间*/
+
+/**
+* @brief  ME3616句柄的构造函数
+* @param  该函数会对本文件核心全局句柄进行函数构造
+*/		
+ME3616 * ME3616_Init()
+{
+	ME3616 * me=&me3616;
+
+	#if(config_MQTT_Enable)
+
+	MQTT mqtt;
+
+	me->MQTT=mqtt;
+
+	me->MQTT.SetNet=MQTT_Set_Net;
+
+	me->MQTT.Connect=MQTT_Connet;
+
+	me->MQTT.Sub=MQTT_SUB;
+
+	me->MQTT.Pub=MQTT_PUB;
+  #endif
+	me->imei_iccid_get = ME3616_IMEI_ICCID_INFO_GET;
+  
+	#if(config_TCP_Enable)
+	TCP tcp;		/*创建实体*/
+
+	me->TCP=tcp;
+
+	me->TCP.CreateChannel=ME3616_Connect_TCP;
+
+	me->TCP.CloseChannel=Close_TCP_Socket;
+
+	me->TCP.SendStr=ME3616_TCP_SEND_String;
+
+	me->TCP.SendHex=ME3616_TCP_SEND_Hex;
+
+	me->TCP.GetData=ME3616_TCP_DATA_purification;
+	#endif
+
+	me->PowerOn=ME3616_Power_On;
+	#if(Hvertion_data)
+	me->HardRest=ME3616_HARD_Rest;
+	#endif
+	
+	#if(SoftRest_fun)
+	me->SoftRest=ME3616_SOFT_Rest;
+	#endif
+	#if(GetEPS_fun)
+	me->GetEPS=ME3616_READ_EPS;
+	#endif
+	#if(GetCSQ_fun)
+	me->GetCSQ=ME3616_READ_CSQ;
+	#endif
+	me->GetCESQ=ME3616_READ_CESQ;
+	#if(GetCCID_fun)
+	me->GetCCID=ME3616_READ_CCID;
+	#endif
+	me->GetPIN=ME3616_READ_PIN;
+	
+	
+	#if(IMEI_ME3616_INFOrmation)
+	me->GetIMEI=ME3616_READ_IMEI;
+	#endif
+	#if(Svertion_data)
+	me->Version=ME3616_READ_Revision;
+	#endif
+	#if(ICCID_ME3616_INFOrmation)
+	memset(me->State.iccid,0,50);
+	#endif
+	#if(IMEI_ME3616_INFOrmation)
+	memset(me->State.imei,0,50);
+	#endif
+	memset(me->State.imsi,0,50);
+	#if(MAC_ME3616_INFOrmation)
+	memset(me->State.mac,0,50);
+	#endif
+	#if(Hvertion_data)
+	memset(me->State.Hvertion,0,50);
+	#endif
+	#if(Svertion_data)
+	memset(me->State.Svertion,0,50);
+	#endif
+	#if(config_LMW2M_Enable)
+	memset(me->State.msgid,0,20);
+	#endif
+	#if(ICCID_ME3616_INFOrmation)
+	me->flug.iccid=0;
+	#endif
+	#if(IMEI_ME3616_INFOrmation)
+	me->flug.imei=0;
+	#endif
+	me->flug.imsi=0;
+	#if(MAC_ME3616_INFOrmation)
+	me->flug.mac=0;
+	#endif
+	#if(Hvertion_data)
+	me->flug.Hvertion=0;
+	#endif
+	#if(Svertion_data)
+	me->flug.Svertion=0;
+	#endif
+	me->flug.pwr=0;
+	me->flug.rssi=0;
+	me->flug.ber=0;
+	me->flug.eps=0;
+	me->flug.pin=0;
+	me->flug.rest=0;
+	
+	#if defined (config_TCP_Enable_Disconnection_reconnection)
+	me->flug.tcp_recon=0;
+	#endif	
+	
+	#if(config_LMW2M_Enable)
+	me->flug.msgid=0;
+	#endif
+	
+//		UartModuleInit();
+	return me;
+}
+
+
+uint8_t ME3616_Check_State()
+{
+	
+	#if (config_TCP_Enable_heart)	/*心跳*/	
+	
+	if(me3616.State.TCP_State==1)
+	{
+		debug_printf("\r\n开始心跳\r\n");
+		char temp[256]={0};
+		Chaoyou_package("01","",temp);
+		Check_Package(temp);
+		me3616.TCP.send_Str(temp);	
+	}
+	#endif	
+	
+	
+	#if (config_CEREG)	/*网络检查*/	
+	if(me3616.State.TCP_State==1)
+	{
+		
+		
+		
+		
+	}
+	#endif		
+	
+	#if (config_TCP_Enable_Disconnection_reconnection)	/*重连检查*/
+	if(me3616.flug.tcp_recon)
+	{
+		if(me3616.State.TCP_State==0)
+		{
+			/*检查到掉线*/
+			me3616.flug.rest=1;
+		}
+		else
+		{
+			debug_printf("TCP连接正常");
+		}
+		
+	}
+	#endif
+	
+	return 1;
+}
+
+	
+/**
+* @brief  ME3616硬件开机
+* @param	flug = 1,阻塞开机，会直到开机成功，且读取完全部开机信息后才会退出
+* @param	flug = 0,操作完硬件开机后立即返回
+* @param  [Antiphase_flug]额外参数	: 以宏形式的标志，1为反相，0为不反相
+* 【是否反相根据硬件电路决定，如果mcu拉低，模组也被拉低，则不需要反相，否则给反相位置1即可】
+* 	如果在计时器启动前调用了，建议选择直接返回[针对RTOS]
+*/	
+uint8_t ME3616_Power_On(uint8_t flug)
+{
+	OS_ERR err;
+	
+		#if(config_CHINESE_LOG)
+		ME3616_INFO("ME3616 硬件开机");	
+		#else
+		ME3616_INFO("ME3616 Hardware Power On");	
+		#endif
+
+		if(AT_CMD_Polling("AT\r\n","OK",100,300))
+		{
+			me3616.State.pwr=1;
+			#if(config_CHINESE_LOG)
+			ME3616_INFO("ME3616 完成开机");	
+			#else
+			ME3616_INFO("ME3616 Power On");
+			#endif
+			return 1;
+		}
+	#if 0
+		if(config_Antiphase_flug)
+		{
+		PWR_IO_PORT->ODR|=PWR_IO_PIN;/*拉低PWR引脚*/
+		OSTimeDlyHMSM(0, 0, 2, 0, OS_OPT_TIME_DLY, &err);	
+		//HAL_Delay(2000);							/*延时两秒*/
+		PWR_IO_PORT->ODR&=!PWR_IO_PIN; /*拉高PWR引脚*/	
+		}
+		else
+		{
+		PWR_IO_PORT->ODR&=!PWR_IO_PIN;/*拉低PWR引脚*/
+		OSTimeDlyHMSM(0, 0, 2, 0, OS_OPT_TIME_DLY, &err);	
+		//HAL_Delay(2000);							/*延时两秒*/
+		PWR_IO_PORT->ODR|=PWR_IO_PIN; /*拉高PWR引脚*/
+		}
+	#endif
+		if(flug)
+		{
+		
+		char buff[MODULE_RDA_MAXlen]={0};
+		
+				/*这里是为了吃掉三条开机信息，如果直接开始往下运行，开就信息可能会干扰*/
+				if(Module_Blocking_Read(buff,20000))
+				{
+					me3616.State.pwr=1;
+					if(strstr(buff,"*MATREADY:"))
+					{
+						memset(buff,0,MODULE_RDA_MAXlen);
+						if(Module_Blocking_Read(buff,6000))
+						{
+
+							if(strstr(buff,"+CPIN:"))
+							{
+								memset(buff,0,MODULE_RDA_MAXlen);
+									if(Module_Blocking_Read(buff,60000))
+									{
+										if(strstr(buff,"+IP:")) 
+										{
+											/*完整开机需要的时常很长*/
+											AT_CMD_Polling("AT\r\n","OK",200,15000);
+											AT_CMD_Polling("AT\r\n","OK",200,15000);
+											AT_CMD_Polling("AT\r\n","OK",200,15000);
+											
+											ME3616_INFO("ME3616 Hardware Power On OK!");
+											return 1;
+										}
+									}
+							}
+					 }
+					}
+				}
+		}
+		return 0;
+}	
+
+
+/**
+* @brief  ME3616硬件复位
+*	@param  flug:复位标志，1，阻塞复位，会直到开机成功才退出，开机时间较长，2，立即返回*/
+uint8_t ME3616_HARD_Rest(uint8_t flug)
+{		
+	OS_ERR err;
+		#if(config_CHINESE_LOG)
+		ME3616_INFO("ME3616开始硬件复位");
+		#else
+		ME3616_INFO("ME3616 Hardware Reset");
+		#endif
+		if(config_Antiphase_flug)
+		{
+		RST_IO_PORT->ODR|=RST_IO_PIN;/*拉低PWR引脚*/
+		OSTimeDlyHMSM(0, 0, 2, 0, OS_OPT_TIME_DLY, &err);	
+		//HAL_Delay(2000);							/*延时两秒*/
+		RST_IO_PORT->ODR&=!RST_IO_PIN; /*拉高PWR引脚*/	
+		}
+		else
+		{
+		RST_IO_PORT->ODR&=!RST_IO_PIN;/*拉低PWR引脚*/
+		OSTimeDlyHMSM(0, 0, 2, 0, OS_OPT_TIME_DLY, &err);	
+		//HAL_Delay(2000);							/*延时两秒*/
+		RST_IO_PORT->ODR|=RST_IO_PIN; /*拉高PWR引脚*/
+		}
+		if(flug)
+		{
+		/*这里是为了吃掉三条开机信息，如果直接开始往下运行，开就信息可能会干扰*/
+		char buff[MODULE_RDA_MAXlen]={0};
+		if(Module_Blocking_Read(buff,20000))
+		{
+			me3616.State.pwr=1;
+			if(strstr(buff,"*MATREADY:"))
+			{
+				memset(buff,0,MODULE_RDA_MAXlen);
+				if(Module_Blocking_Read(buff,6000))
+				{
+
+					if(strstr(buff,"+CPIN:"))
+					{
+						memset(buff,0,MODULE_RDA_MAXlen);
+							if(Module_Blocking_Read(buff,6000))
+							{
+								if(strstr(buff,"+IP:")) 
+								{
+									/*完整开机需要的时常很长*/
+									AT_CMD_Polling("AT\r\n","OK",200,15000);
+									AT_CMD_Polling("AT\r\n","OK",200,15000);
+									AT_CMD_Polling("AT\r\n","OK",200,15000);
+									ME3616_INFO("ME3616 Hardware Reset OK!");
+									return 1;
+								}
+							}
+					}
+				}
+			}
+		}
+		}
+		return 1;
+}
+
+/**
+* @brief  ME3616软件复位
+*	@param  flug:复位标志，1，阻塞复位，会直到开机成功才退出，软复位很快，2，立即返回*/
+uint8_t ME3616_SOFT_Rest(uint8_t flug)
+{		
+
+		#if(config_CHINESE_LOG)
+		ME3616_INFO("ME3616开始软件复位");
+		#else
+		ME3616_INFO("ME3616 Software Reset");
+		#endif
+		Module_SEND_CRC("AT+ZRST\r\n","OK",500);
+	
+		if(flug)
+		{
+		/*这里是为了吃掉三条开机信息，如果直接开始往下运行，开就信息可能会干扰*/
+		char buff[MODULE_RDA_MAXlen]={0};
+		if(Module_Blocking_Read(buff,20000))
+		{
+			me3616.State.pwr=1;
+			if(strstr(buff,"*MATREADY:"))
+			{
+				memset(buff,0,MODULE_RDA_MAXlen);
+				if(Module_Blocking_Read(buff,6000))
+				{
+
+					if(strstr(buff,"+CPIN:"))
+					{
+						memset(buff,0,MODULE_RDA_MAXlen);
+							if(Module_Blocking_Read(buff,6000))
+							{
+								if(strstr(buff,"+IP:")) 
+								{
+									/*完整开机需要的时常很长*/
+									AT_CMD_Polling("AT\r\n","OK",200,15000);
+									AT_CMD_Polling("AT\r\n","OK",200,15000);
+									AT_CMD_Polling("AT\r\n","OK",200,15000);
+									ME3616_INFO("ME3616 Software Reset OK!");
+									return 1;
+								}
+							}
+					}
+			 }
+		}
+		}
+		}
+		return 1;
+}
+
+/**
+* @brief  ME3616读取网络状态并打印数据
+**/
+uint8_t ME3616_READ_EPS()
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	char get_buff[100];
+	int log;
+	ME3616_INFO("Start to query network registration status");
+	module_printf("AT+CEREG?\r\n");
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"+CEREG:"))
+		{
+			AT_GET_Data_2Param(buff,(uint8_t*)get_buff,",","OK");
+			log=atoi(get_buff);
+			me3616.State.eps=log;	/*装载标数据*/
+			me3616.flug.eps=1;		/*装载成功标志*/
+			switch(log)
+			{			
+				case 0: ME3616_INFO("You are not logged on to the network. You are not searching the network at present"); break;
+				case 1: ME3616_INFO("Local network already logged in"); break;
+				case 2: ME3616_INFO("\r\nYou are not logged on to the network. You are currently searching the network\r\n"); break;
+				case 3: ME3616_INFO("\r\nRegistration denied\r\n"); break;
+				case 4: ME3616_INFO("\r\nUnknown state\r\n"); break;
+				case 5: ME3616_INFO("\r\nYou have logged in to the network and are roaming\r\n"); break;
+				default: 
+				{
+					ME3616_ERROR("Response ME3616_ERROR:%s",buff);
+					return  33;//设定的错误码
+				}
+			}
+		return log+1;
+		}
+		{
+		ME3616_ERROR("%s",buff);
+		return 0;
+		}
+	} 
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+
+
+/**
+* @brief  ME3616读取网络信号强度
+* @param  rssi:用来装载的参数，会装载信号强度原文[弃用]
+* @param  ber:用来装载的参数， 会装载错码率原文[弃用]
+*	*/
+uint8_t ME3616_READ_CSQ()
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	char get_buff[32]={0};
+	int log;
+	
+	#if(config_CHINESE_LOG)
+	ME3616_INFO("开始查询网络信号强度");
+	#else
+	ME3616_INFO("Start querying network signal strength");
+	#endif
+
+	module_printf("AT+CSQ\r\n");
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"+CSQ:"))
+		{
+			AT_GET_Data_2Param(buff,(uint8_t*)get_buff,"+CSQ:",",");
+			log=atoi(get_buff);
+			me3616.State.rssi=log;
+			me3616.flug.rssi=1;		/*装载成功标志*/
+			if(log==99) 							{ME3616_INFO("signal intensity:there is no signal");}
+			else if(log>=31&&log<=99) {ME3616_INFO("signal intensity:-51dBm or higher");}
+			else if(log>=2&&log<31)		{ME3616_INFO("signal intensity:-109dBm ~ -53dBm");}
+			else if(log==1)						{ME3616_INFO("signal intensity:-111dBm");}
+			else 											{ME3616_INFO("signal intensity:-111dBm or less");}
+			
+			AT_GET_Data_2Param(buff,(uint8_t*)get_buff,",","OK");
+			log=atoi(get_buff);
+			me3616.State.ber=log;
+			me3616.flug.ber=1;		/*装载成功标志*/
+			//*ber=log;
+			switch(log)
+			{	
+				case 0: ME3616_INFO("Bit error rate:<0.01%"); break;
+				case 1: ME3616_INFO("Bit error rate:0.01% --- 0.1%"); break;
+				case 2: ME3616_INFO("Bit error rate:0.1% --- 0.5%"); break;
+				case 3: ME3616_INFO("Bit error rate:0.5% --- 1.0%"); break;
+				case 4: ME3616_INFO("Bit error rate:1.0% --- 2.0%"); break;
+				case 5: ME3616_INFO("Bit error rate:2.0% --- 4.0%"); break;
+				case 6: ME3616_INFO("Bit error rate:4.0% --- 8.0%"); break;
+				case 7: ME3616_INFO("Bit error rate:> 8.0%"); break;
+				case 8: ME3616_INFO("Bit error rate:So far or not measurable");break;
+				default: 
+				{
+					ME3616_ERROR("So far or not measurable");
+					return  33;//设定的错误码
+				}
+			}
+		return log+1;
+		}
+		{
+		ME3616_ERROR("%s",buff);
+		return 0;
+		}
+	} 
+	
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+
+/**
+* @brief  ME3616读取精确的网络信号强度
+*	*/
+int ME3616_READ_CESQ()
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	char get_buff[100]={0};
+	int log;
+	ME3616_INFO("Start querying network signal strength");
+	module_printf("AT+CESQ\r\n");
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"+CESQ:"))
+		{
+			AT_GET_Data_2Param(buff,(uint8_t*)get_buff,"+CESQ: ",",");
+			log=atoi(get_buff);
+			//me3616.State.rssi=log;
+			me3616.flug.dBm=1;		/*装载成功标志*/
+			log=atoi(get_buff);
+			
+			log+=-110;/*转化成dBm*/
+			me3616.State.dBm=log;
+			
+			ME3616_INFO("signal intensity:%ddBm");
+		return log+1;
+		}
+		{
+		ME3616_ERROR("%s",buff);
+		return 0;
+		}
+	} 
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+/**
+* @brief  ME3616读取SIM卡的CCID
+* @param  rssi:用来装载的参数，会装载信号强度原文
+* @param  ber:用来装载的参数， 会装载错码率原文
+*	*/
+uint8_t ME3616_READ_CCID()
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	char get_buff[32]={'\0'};
+	
+	ME3616_INFO("Start to query SIM card iccid");
+	module_printf("AT*MICCID\r\n");
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"*MICCID:"))
+		{
+			if(AT_GET_Data_2Param(buff,(uint8_t*)get_buff,"*MICCID: ","\n\r"))//0d0a
+			{
+			#if(IMEI_ME3616_INFOrmation)
+			strcpy(me3616.State.iccid,get_buff);
+			me3616.flug.iccid=1;		/*装载成功标志*/
+			#endif
+			debug_printf("\r\nICCID:");
+			debug_printf("%s\r\n", get_buff);
+			}
+			else 
+			{
+				ME3616_ERROR("%s",buff);
+				ME3616_INFO("%s",buff);
+				return 0;
+			}
+		return 1;
+		}
+		else{
+			if(strstr(buff,"SIM not inserted"))
+			{
+				ME3616_INFO("SIM card not inserted,Please check the SIM card");
+				return 0;
+			}
+			else
+			{
+					ME3616_ERROR("%s",buff);
+					return 0;
+			}
+		}
+	} 
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+
+
+/**
+* @brief  ME3616查询pin状态
+* @param  return 1 为ready，0 其他
+*	*/
+uint8_t ME3616_READ_PIN()
+{
+	char buff[256]={0};
+
+	#if(config_CHINESE_LOG)
+	ME3616_INFO("开始查询PIN状态");
+	#else
+	ME3616_INFO("Start to query pin status");
+	#endif
+	
+	module_printf("AT+CPIN?\r\n");
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"+CPIN:"))
+		{
+			
+			me3616.State.pin=1;
+			me3616.flug.pin=1;		/*装载成功标志*/
+			
+			#if(config_CHINESE_LOG)
+			if(strstr(buff,"READY")) 				{ME3616_INFO("PIN状态: READY,已准备好");return 1;}
+			else if(strstr(buff,"SIM PIN")) {ME3616_INFO("PIN状态: 需要pin码");return 1;}
+			else if(strstr(buff,"SIM PUK")) {ME3616_INFO("PIN状态: PIN 码解锁密码");return 1;}
+			else if(strstr(buff,"PH-SIM PIN")) {ME3616_INFO("PIN状态: SIM 卡绑定密码");return 1;}
+			else if(strstr(buff,"SIM PIN2")) {ME3616_INFO("PIN状态: PIN2 码密码");return 1;}
+			else if(strstr(buff,"SIM PUK2")) {ME3616_INFO("PIN状态: PIN2 码解锁密码");return 1;}
+			else if(strstr(buff,"PH-NET PIN")) {ME3616_INFO("PIN状态: 网络密码");return 1;}
+			#else
+			if(strstr(buff,"READY")) 					 {ME3616_INFO("Pin status: READY");return 1;}
+			else if(strstr(buff,"SIM PIN"))	   {ME3616_INFO("Pin status: need pin");return 1;}
+			else if(strstr(buff,"SIM PUK")) 	 {ME3616_INFO("Pin status: Pin code unlock password");return 1;}
+			else if(strstr(buff,"PH-SIM PIN")) {ME3616_INFO("Pin status: SIM card binding password");return 1;}
+			else if(strstr(buff,"SIM PIN2"))   {ME3616_INFO("Pin status: Pin2 code");return 1;}
+			else if(strstr(buff,"SIM PUK2"))   {ME3616_INFO("Pin status: Pin2 code unlock password");return 1;}
+			else if(strstr(buff,"PH-NET PIN")) {ME3616_INFO("Pin status: Network password");return 1;}
+			#endif
+		}
+		else{
+		ME3616_ERROR("%s",buff);
+		return 0;
+		}
+	} 
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+
+/**
+* @brief  ME3616查询CIMI状态
+*	*/
+uint8_t ME3616_READ_CIMI()
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	#if(config_CHINESE_LOG)
+	ME3616_INFO("开始查询PIN状态");
+	#else
+	ME3616_INFO("Start to query pin status");
+	#endif
+	module_printf("AT+CPIN?\r\n");
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"+CPIN:"))
+		{
+			#if(config_CHINESE_LOG)
+			if(strstr(buff,"READY")) {ME3616_INFO("PIN状态: READY,已准备好");return 1;}
+			else if(strstr(buff,"SIM PIN")) {ME3616_INFO("PIN状态: 需要pin码");return 1;}
+			else if(strstr(buff,"SIM PUK")) {ME3616_INFO("PIN状态: PIN 码解锁密码");return 1;}
+			else if(strstr(buff,"PH-SIM PIN")) {ME3616_INFO("PIN状态: SIM 卡绑定密码");return 1;}
+			else if(strstr(buff,"SIM PIN2")) {ME3616_INFO("PIN状态: PIN2 码密码");return 1;}
+			else if(strstr(buff,"SIM PUK2")) {ME3616_INFO("PIN状态: PIN2 码解锁密码");return 1;}
+			else if(strstr(buff,"PH-NET PIN")) {ME3616_INFO("PIN状态: 网络密码");return 1;}
+			#else
+			if(strstr(buff,"READY")) {ME3616_INFO("Pin status: READY");return 1;}
+			else if(strstr(buff,"SIM PIN")) {ME3616_INFO("Pin status: need pin");return 1;}
+			else if(strstr(buff,"SIM PUK")) {ME3616_INFO("Pin status: Pin code unlock password");return 1;}
+			else if(strstr(buff,"PH-SIM PIN")) {ME3616_INFO("Pin status: SIM card binding password");return 1;}
+			else if(strstr(buff,"SIM PIN2")) {ME3616_INFO("Pin status: Pin2 code");return 1;}
+			else if(strstr(buff,"SIM PUK2")) {ME3616_INFO("Pin status: Pin2 code unlock password");return 1;}
+			else if(strstr(buff,"PH-NET PIN")) {ME3616_INFO("Pin status: Network password");return 1;}
+			#endif
+
+		}
+		else{
+		
+		ME3616_ERROR("%s",buff);
+		return 0;
+		}
+	} 
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+#if(IMEI_ME3616_INFOrmation)
+/**
+* @brief  ME3616查询IMEI并装载至寄存器
+* @param  
+*	*/
+uint8_t ME3616_READ_IMEI()
+{
+	rxbuff(buff);
+
+	clear(buff);	
+	ME3616_INFO("Start query IMEI");
+	module_printf("ATI\r\n");
+	if(Module_Blocking_Read(buff,6000))
+	{
+		if(strstr(buff,"IMEI"))
+		{
+			#if 0
+				char temp[32]={0};
+
+				memset(temp, 0 , sizeof(temp));
+				AT_GET_Data_2Param(buff,(uint8_t*)temp,"IMEI: ","OK");	/*头尾提取方法*/
+				AT_Extract_numbers(temp);							/*提纯数字*/
+				strcat(me3616.State.imei,temp);
+				ME3616_INFO("IMEI:%s\r\n",temp);
+			#else
+				AT_GET_Data_2Param(buff,me3616.State.imei,"IMEI: ","OK");	/*头尾提取方法*/
+			#endif
+				me3616.flug.imei=1;
+				ME3616_INFO("IMEI:%s\r\n",me3616.State.imei);
+				return 1;
+		}
+		else{
+		ME3616_ERROR("%s",buff);
+		return 0;
+		}
+	} 
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+#endif
+#if(Hvertion_data)
+/**
+* @brief  ME3616查询IMEI并装载至寄存器
+* @param  
+*	*/
+uint8_t ME3616_READ_Revision()
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	
+	debug_printf("\r\n开始查询软硬件环境\r\n");
+	module_printf("ATI\r\n");
+	if(Module_Blocking_Read(buff,2000))
+	{
+		if(strstr(buff,"SwRevision: "))
+		{
+				char temp[256]={0};
+				AT_GET_Data_2Param(buff,(uint8_t*)temp,"SwRevision: ","HwR");	/*头尾提取方法*/
+				AT_Extract_numbers_letters(temp);							/*提纯数字*/
+				strcat(me3616.State.Svertion,temp);
+				me3616.flug.Svertion=1;
+				AT_GET_Data_2Param(buff,(uint8_t*)temp,"HwRevision: ","SVN");	/*头尾提取方法*/
+				AT_Extract_numbers_letters(temp);							/*提纯数字*/
+				strcat(me3616.State.Hvertion,temp);
+				me3616.flug.Hvertion=1;
+				debug_printf("\r\nSvertion:%s",me3616.State.Svertion);
+				debug_printf("Hvertion:%s\r\n",me3616.State.Hvertion);
+				return 1;
+		}
+		else{
+		debug_printf("原文：");
+		debug_printf(buff);
+
+		return 0;
+		}
+	} 
+	ME3616_INFO("Response timeout");
+	return 0;
+}
+#endif
+
+void ME3616_IMEI_ICCID_INFO_GET(char *imei, char *iccid)
+{
+	memcpy(imei, me3616.State.imei, strlen(me3616.State.imei));
+	memcpy(iccid, me3616.State.iccid, strlen(me3616.State.iccid));
+}
+
+#if(config_TCP_Enable)
+/**
+* @brief  ME3616关闭一个套接字
+* @param  socket：套接字的句柄编号
+*	*/
+uint8_t ME3616_Close_Socket(uint8_t socket)
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	module_printf("AT+ESOCL=%d\r\n",socket);//printf的重映射有问题，正在修改 
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"OK"))
+		{
+			ME3616_INFO("socket:%d Close OK!",socket);
+			return 1;
+		}
+		else if(strstr(buff,"ERROR")){
+		//debug_printf("\r\n关闭失败\r\n");
+		return 0;
+		}else 
+		{	
+		//	debug_printf("\r\nunknow\r\n");
+		}
+	}else
+	{
+		ME3616_INFO("Response timeout");
+	}
+	return 99;
+}
+/**
+* @brief  ME3616关闭一个套接字[内部调用]
+*	*/
+uint8_t Close_TCP_Socket()
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	module_printf("AT+ESOCL=%d\r\n",me3616.State.TCP_Socket);//printf的重映射有问题，正在修改 
+	if(Module_Blocking_Read(buff,1000))
+	{
+		if(strstr(buff,"OK"))
+		{
+			ME3616_INFO("socket:%d Close OK!",me3616.State.TCP_Socket);
+			return 1;
+		}
+		else if(strstr(buff,"ERROR")){
+		ME3616_INFO("Closing failed");
+		return 0;
+		}else 
+		{	
+			ME3616_ERROR("%s",buff);
+		}
+	} 
+	else
+	{
+		ME3616_INFO("Response timeout");
+	}
+	return 0;
+}
+/**
+* @brief  ME3616创建一个Socket
+* @param  IPvX	 	:	1 - IPv4	,2 - IPv6
+*	@param  TCP_UDP	:	1 - TCP		,2 - UDP		,3 - RAW
+*	@param  protocol:	1 - IP		,2 - ICMP
+*	【创建失败返回99，创建成功返回socket的句柄编号,范围0-4】
+*/
+uint8_t ME3616_Create_Socket(int IPvX,int TCP_UDP,int protocol)
+{
+	char buff[MODULE_RDA_MAXlen]={'\0'};
+	char get_buff[100]={'\0'};
+	uint8_t socket=99;
+	
+	module_printf("AT+ESOC=%d,%d,%d\r\n",IPvX,TCP_UDP,protocol);
+
+	if(Module_Blocking_Read(buff,1000))
+	{	
+		if(strstr(buff,"ERROR"))
+		{
+			if(strstr(buff,"too much socket instance")) 
+			{
+			ME3616_INFO("There is no socket channel left. Please close the socket channel");
+			return  88; 
+			}
+			else 
+			{
+				ME3616_ERROR("%s",buff);
+			}
+		}
+		else if(strstr(buff,"+ESOC="))
+		{
+			char *p;
+//			ME3616_ERROR("\r\n原文:");
+//			ME3616_ERROR((char*)buff);
+			if(strlen(buff)>15) p=buff+13;
+			else p=buff;
+			if(AT_GET_Data_2Param(p,(uint8_t*)get_buff,"OC=","OK"))
+			{
+				socket=atoi(get_buff);
+				me3616.State.TCP_Socket=socket;
+				ME3616_INFO("Socket created successfully, No.:%d",socket);
+				return socket;
+			}
+			else
+			{
+				ME3616_INFO("Socket creation failed :%d",socket);
+				ME3616_ERROR("%s",buff);
+				return 99;
+			}
+		}
+		else{
+		ME3616_ERROR("%s",buff);		
+		return 99;
+		}
+	}else
+	{
+		ME3616_INFO("Response timeout");
+		return 99;
+	}
+	  return 99;	
+}
+/**
+* @brief  ME3616连接到一个Socket
+* @param  socket	 	:	socket创建好的socket通道句柄编号
+*	@param  port  		:	端口
+*	@param  ip  			:	ip地址，或者域名支持域名解析
+*	【创建失败返回99，创建成功返回socket的句柄编号,范围0-5】
+*/
+int ME3616_Connect_Socket(uint8_t socket,char *port,char *ip)
+{
+	char buff[MODULE_RDA_MAXlen]={0};
+	char get_buff[100]={'\0'};
+	char send_data[256]={0};
+	char data_crc[256]={0};
+	/*导入句柄编号*/
+	sprintf(send_data,"AT+ESOCON=%d,",socket);
+	/*导入端口号*/
+	strcat(send_data,port);
+	strcat(send_data,",\"");
+
+	/*导入ip地址或域名*/
+	strcat(send_data,ip);	
+	strcpy(data_crc,send_data);
+	strcat(data_crc,"\"");
+	strcat(send_data,"\"\r\n");
+	
+	//debug_printf("\r\nSEND TO ME3616\r\n");
+	//debug_printf(send_data);
+	//debug_printf("\r\nCRC FIFO\r\n");
+	//debug_printf(data_crc);
+	
+	/*发送指令*/
+	module_printf(send_data);
+	if(Module_Blocking_Read(buff,8000))
+	{
+		if(strstr(buff,"ERROR"))
+		{
+		ME3616_INFO("Socket connection error");	
+		return 0;
+		}
+		else if(strstr(buff,"OK"))
+		{
+			ME3616_INFO("Socket connection successful");
+			return 1;
+		}
+		else if(strstr(buff,data_crc))
+		{		
+				memset(buff,0,MODULE_RDA_MAXlen);
+				if(Module_Blocking_Read(buff,10000))
+				{
+					/*注册成功*/
+					if(strstr(buff,"OK")) 
+					{
+						ME3616_INFO("Socket connection successful");
+						return 1;
+					}
+					else if(strstr(buff,"ERROR"))
+					{
+						ME3616_INFO("Socket connection error");
+						//ME3616_ERROR("%s",buff);
+						return 0;
+					}
+				}
+				else 
+				{
+				ME3616_INFO("Response timeout");
+				}
+		}
+		else if(strstr(buff,"+ESOERR"))
+		{
+			int code=0;
+			/*套接字错误指示器*/
+			if(AT_GET_Data_2Param(buff,(uint8_t*)get_buff,",","\n\r"))
+			{
+				code=atoi(get_buff);
+				ESOERR_PRINT(code);	
+				return code+10;
+			}
+		}
+		else {
+			ME3616_ERROR("%s",buff);
+		}
+	}
+	else 
+	{
+		ME3616_INFO("Response timeout");
+		return 99;	
+	}
+	return 0;
+}
+/**
+* @brief  ME3616创建一个TCP连接
+*	@param  port  		:	端口
+*	@param  ip  			:	ip地址，或者域名支持域名解析
+*	【创建失败返回99，创建成功返回socket的句柄编号,范围0-5】
+*/
+uint8_t  ME3616_Connect_TCP(char *port,char *ip)
+{
+	OS_ERR err;
+	
+		ME3616_Close_Socket(0);
+		ME3616_Close_Socket(1);
+		ME3616_Close_Socket(2);
+		ME3616_Close_Socket(3);
+		ME3616_Close_Socket(4);
+	
+	/*静态的Socket句柄*/
+	static int TCP_Socket;
+	uint8_t 	 Try_count=0;
+	create:
+	Try_count++;/*尝试次数*/
+	
+	/*创建一个套接字,并返回一个句柄*/
+	TCP_Socket=ME3616_Create_Socket(1,1,1);
+	
+	if(TCP_Socket>=0&&TCP_Socket<=4) 
+	{/*创套接字编号满足要求则继续*/
+		ME3616_INFO("Start Connection TCP");
+		//me3616.State.TCP_Socket=TCP_Socket;
+	}
+	else if(TCP_Socket==88)
+	{
+		/*88是套接字通道用尽标志*/
+		ME3616_INFO("Socket Channel has no more left,Start clear");
+		ME3616_Close_Socket(0);
+		ME3616_Close_Socket(1);
+		ME3616_Close_Socket(2);
+		ME3616_Close_Socket(3);
+		ME3616_Close_Socket(4);
+		if(Try_count<3) goto create;
+		else return 0;
+	}
+	else if(TCP_Socket==99)
+	{
+		/*99是其他error，暂未处理*/
+		ME3616_INFO("Socket creation failed");
+		ME3616_INFO("Try again");
+		ME3616_Close_Socket(0);
+		ME3616_Close_Socket(1);
+		ME3616_Close_Socket(2);
+		ME3616_Close_Socket(3);
+		ME3616_Close_Socket(4);
+		
+		if(Try_count<3) goto create;
+		else return 0;
+	}
+	OSTimeDlyHMSM(0, 0, 500, 0, OS_OPT_TIME_DLY, &err);	
+	//HAL_Delay(500);
+	/*创建一个TCP通道*/
+	int code=ME3616_Connect_Socket(TCP_Socket,port,ip);
+	
+	if(code!=1)
+	{
+		ME3616_INFO("TCP creation failed：%d",code);
+		ME3616_INFO("Try again");
+		ME3616_Close_Socket(0);
+		ME3616_Close_Socket(1);
+		ME3616_Close_Socket(2);
+		ME3616_Close_Socket(3);
+		ME3616_Close_Socket(4);
+		if(Try_count<3) goto create;
+		
+		if(code==99)
+		{	
+			return 0;
+		}
+		else if(code>=9&&code<=11)
+		{
+			/*带错误码返回的套接字错误*/
+			return 0;
+		}
+		else return 0;
+		
+	}else if(code==1)
+	{
+		/*装载参数*/
+		me3616.State.TCP_State=1;
+		#if defined (config_TCP_Enable_Disconnection_reconnection)
+		me3616.flug.tcp_recon=1;
+		#endif
+		ME3616_INFO("TCP connection successful (*^▽^*) ");
+		ME3616_INFO("IP Address:%s\r\n>> Port:%s\r\n>> Socket:%d ",ip,port,TCP_Socket);
+		return 1;
+	}	/*code==1是唯一正确的返回*/
+	else
+	{
+		ME3616_INFO("TCP creation failed ");
+		return 0;
+	}
+}
+
+uint8_t  ME3616_TCP_SEND_String(char *str)
+{
+		if(me3616.State.TCP_State==1)
+		{
+			uint16_t len=strlen(str);
+			if(len>0&&len<512)
+			{
+				char str_arry[strlen(str)+1];		
+				memset(str_arry,0,strlen(str)+1);
+				AsciiStr_2_HexStr(str,str_arry);
+				
+				module_printf("AT+ESOSEND=%d,%d,%s\r\n",me3616.State.TCP_Socket,strlen(str),str_arry);
+				//ME3616_INFO("\r\nAT+ESOSEND=%d,%d,%s\r\n",me3616.State.TCP_Socket,strlen(str),str_arry);
+				char rxbuf[MODULE_RDA_MAXlen]={0};
+				if(Module_Blocking_Read(rxbuf,5000))
+				{
+					//debug_printf(rxbuf);
+					if(strstr(rxbuf,"+ESONMI")||strstr(rxbuf,"OK"))
+					{
+						ME3616_INFO("Send:%s",str);
+						ME3616_INFO("Sent successfully");
+					}
+					else if(strstr(rxbuf,"ERROR"))
+					{
+						ME3616_ERROR("%s",rxbuf);
+					}
+				}else 
+				{
+					ME3616_INFO("Response timeout");
+					return 99;
+				}
+			}
+			else 
+			{
+				ME3616_INFO("Data length violation");
+				return 0;
+			}
+		}
+		else{
+			
+			ME3616_INFO("Send failed, TCP channel not open");
+		return 0;
+		}
+		return 0;
+}
+
+uint8_t  ME3616_TCP_SEND_Hex(char *str)
+{
+		if(me3616.State.TCP_State==1)
+		{
+			uint16_t len=strlen(str);
+			if(len%2!=0) 
+			{
+				ME3616_INFO("hex data不符合规范");
+				return 0;
+			}
+			if(len>0&&len<512)
+			{
+				module_printf("AT+ESOSEND=%d,%d,%s\r\n",me3616.State.TCP_Socket,len/2,str);
+				//debug_printf("AT+ESOSEND=%d,%d,%s\r\n",me3616.State.TCP_Socket,len/2,str);
+				char rxbuf[MODULE_RDA_MAXlen];
+				if(Module_Blocking_Read(rxbuf,3000))
+				{
+					//debug_printf(rxbuf);
+					if(strstr(rxbuf,"+ESONMI")||strstr(rxbuf,"OK"))
+					{
+						ME3616_INFO("发送成功");
+					}
+					else if(strstr(rxbuf,"ERROR"))
+					{
+						ME3616_INFO("发送失败");
+						
+					}
+				}else 
+				{
+						ME3616_INFO("响应超时");
+						return 99;
+				}
+			}
+			else 
+			{
+				ME3616_INFO("数据长度违规");
+				return 0;
+			}
+		}
+		else{
+			
+				ME3616_INFO("\r\nTCP通道未打开\r\n");
+		return 0;
+		}
+		return 0;
+}
+
+uint8_t ME3616_TCP_DATA_purification(uint8_t data[])
+{
+	/**/
+	if(me3616.State.TCP_State)
+	{
+		char temp[15]={0};
+		sprintf(temp,"+ESONMI=%d",me3616.State.TCP_Socket);
+		if(strstr((char*)data,temp))/*校验数据是否来自指定的socket*/
+		{
+			/*读取数据长度*/
+			char temp[10]={0};
+			AT_GET_Data((char*)data,(uint8_t*)temp,",",1);
+			int i=atoi(temp);
+			//debug_printf("\r\nlen:%d\r\n",i);
+			int loc=0;
+			for(int n=0;loc<50;loc++)
+			{
+				if(*(data+loc)==',') n++;
+				if(n==2) break;
+			}
+			Shift_left((char*)data,loc+1);
+			//Str.convert.R_CUT((char*)data,i*2+2);/*因为数据还包括odoa，所以额外+2*/
+			return 1;
+		}
+		else return 0;
+	}
+	return 0;
+}
+#endif
+
+/**
+* @brief  ME3616打印套接字错误码
+*/
+void  ESOERR_PRINT(int code)
+{
+	switch(code)
+	{
+		case -1:debug_printf("\r\n错误:通用错误\r\n"); break;
+		case 1:debug_printf("\r\n错误:没有找到路由信息，一般是掉网的情况下会出现\r\n"); break;
+		case 2:debug_printf("\r\n错误:TCP 链接被动断开，一般掉网的情况下会出现\r\n"); break;
+		case 3:debug_printf("\r\n错误:TCP 链接被 server 断连，一般是 device 收到 server 的 reset 数据包\r\n"); break;
+		case 4:debug_printf("\r\n错误:TCP 连接错误\r\n"); break;
+		case 5:debug_printf("\r\n错误:非法值\r\n"); break;
+		case 6:debug_printf("\r\n错误:socket 阻塞\r\n"); break;
+		case 7:debug_printf("\r\n错误:地址已经被使用\r\n"); break;
+		case 8:debug_printf("\r\n错误:正在连接中\r\n"); break;
+		case 9:debug_printf("\r\n错误:已经建立连接\r\n"); break;
+		case 10:debug_printf("\r\n错误:网络接口错误\r\n"); break;
+		default: debug_printf("\r\n错误:通用错误\r\n"); break;
+	}
+}
+
+/*--------------------------------MQTT------------------------------------------------------*/
+#if(config_MQTT_Enable)
+
+
+uint8_t MQTT_Set_Net(char *ip,char *port)
+{
+	if(strcpy(me3616.State.mqtt_ip,ip))
+	if(strcpy(me3616.State.mqtt_port,port))
+	{
+		me3616.flug.mqtt_ip=1;
+		me3616.flug.mqtt_port=1;
+		ME3616_INFO("Net Set OK!");
+		return 1;
+	}
+	return 0;
+}
+
+uint8_t MQTT_Connet(char *_productID,char *_deviceID,char *_secret)
+{
+	int mqttid;
+	/*申请一个接收缓存*/
+	rxbuff(buff);
+	
+	if(!(me3616.flug.mqtt_ip&&me3616.flug.mqtt_port))
+	{
+		ME3616_INFO("The network port has not been configured");
+		return 0;
+	}
+	
+	module_printf("AT+EMQNEW=\"%s\",\"%s\",12000,512\r\n",me3616.State.mqtt_ip,me3616.State.mqtt_port);
+	/*conenet的地址*/
+	//module_printf("AT+EMQNEW=\"183.230.40.39\",\"6002\",12000,100\r\n");
+	clear(buff);
+	if(Module_Blocking_Read(buff,5000))
+	{
+		if(strstr(buff,"+EMQNEW:")&&strstr(buff,"OK"))
+		{
+			uint8_t getid[5]={0};
+			AT_GET_Data_2Param(buff,getid,":","OK");
+			AT_Remove_spaces((char*)getid);
+			mqttid=atoi((char*)getid);
+			ME3616_INFO("NEW mqtt server ok! Start Connect...");
+			
+			module_printf("AT+EMQCON=%d,4,\"%s\",1000,1,0\r\n",mqttid,_deviceID);
+			
+			clear(buff);
+			if(Module_Blocking_Read(buff,5000))
+			{
+				if(strstr(buff,"OK"))
+				{
+					me3616.State.mqtt_id=mqttid;
+					me3616.State.MQTT_State=1;
+					ME3616_INFO("Connect MQTT Successful,MQTT id:%d",mqttid);
+					return 1;
+				}	
+			}
+		}else {
+			ME3616_ERROR("%s",buff);
+		}
+	} else {
+		ME3616_INFO("Response timeout");
+	}
+	
+	return 0;
+}
+
+
+uint8_t MQTT_SUB(char * topic)
+{
+	if(!me3616.State.MQTT_State)
+	{
+		ME3616_INFO("Cannot Connect MQTT");
+		return 0;
+	}
+	/*往模组打印*/
+	module_printf("AT+EMQSUB=%d,\"%s\",1\r\n",me3616.State.mqtt_id,topic);
+	
+	Module_Read_A_CRC("AT+EMQSUB=",5000);
+	
+	if(Module_Read_A_CRC("OK",15000))
+	{
+		ME3616_INFO("Sub \"%s\" Successful",topic);
+		return 1;
+	}else
+	{
+		ME3616_INFO("Sub ERROR");
+		return 0;
+	}
+}
+
+
+uint8_t MQTT_PUB(char * topic,char *data, uint32_t len)
+{
+	if(!me3616.State.MQTT_State)
+	{
+		ME3616_INFO("Cannot Connect MQTT");
+		return 0;
+	}
+	/*往模组打印*/
+	module_printf("AT+EMQPUB=%d,\"%s\",1,0,0,%d,\"%s\"\r\n",me3616.State.mqtt_id,topic,strlen(data)/2,data);
+	
+	//Module_Read_A_CRC("AT+EMQPUB=",5000);
+	
+	if(Module_Read_A_CRC("OK",3000))
+	{
+		/*
+		if(Module_Read_A_CRC("+EMQPUB:",15000))
+		{
+			ME3616_INFO("Pub Successful \r\n[%s]<-[%s]",topic,data);
+			return 1;
+		}	*/
+			ME3616_INFO("Pub Successful \r\n[%s]<-[%s]",topic,data);
+			return 1;
+	}else
+	{
+		ME3616_INFO("Pub ERROR");
+		return 0;
+	}
+
+}
+
+#endif

APP/network_mgr/me3616/me3616.h

@@ -0,0 +1,429 @@
+/** ******************************************************************************
+ * @file    me3616.h
+ * @author  度云未来 DOIOT
+ * @brief   ME3616模块AT指令简易串口驱动
+ ******************************************************************************
+ * @attention
+ * <h2><center>&copy; Copyright (c) 2019 成都度云未来
+ * All rights reserved.</center></h2>
+ * 注意:本程序针对cubemx 生成的hal库快速开发
+ * 环境:keil5.0
+ * STM32Cube FW_F1 V1.8.0
+ * 文件版本：2.30
+ ********************************************************************************/
+
+/*硬件复位和开机的引脚宏定义*/
+#define PWR_IO_PORT       				GPIOA
+#define RST_IO_PORT     				GPIOA
+#define PWR_IO_PIN       				GPIO_Pin_0
+#define RST_IO_PIN     					GPIO_Pin_1
+
+#define config_Antiphase_flug    							0  			  		/*开机硬件电平反相使能*/
+//#define config_TCP_Enable									1					/*使能TCP*/
+#define config_Multi_channel_Tcp							0				  	/*多通道TCP使能*/
+#define config_TCP_Enable_heart               				0					/*开启TCP心跳*/
+#define config_CEREG										0					/*定期TCP网络检查*/
+#define config_EPS											0					/*定期网络检查*/
+#define config_Check_Rest									0					/*检查和复位*/
+#define config_TCP_Enable_Disconn_recon 					0					/*打开TCP断线重连*/
+//#define config_LMW2M_Enable									0					/*使能LMW2M*/
+#define config_ALY_MQTT_Enable								0					/*使能阿里云MQTT[需要对应的固件]*/
+#define config_MQTT_Enable									1					/*使能MQTT*/
+#define config_CHINESE_LOG									0					/*使能中文log*/
+
+/** -------------------------------调整这里以裁剪程序--------------------------------*/
+
+#define process_fifo_max_s										64				/*处理数据函数所使用的小号缓存*/
+#define process_fifo_max_m										64				/*处理数据函数所使用的中号缓存*/
+#define process_fifo_max_L										64				/*处理数据函数所使用的大号缓存*/
+
+#define SoftRest_fun													0					/*使能软件开机函数*/
+#define GetEPS_fun														1					/*使能EPS函数*/
+#define GetCSQ_fun														1					/*使能获取CSQ函数*/
+#define GetCCID_fun														1					/*使能获取CCID函数*/
+
+
+#define Hvertion_data													0					/*使能硬件信息存储栈*/
+#define Svertion_data													0					/*使能软件信息存储栈*/
+#define MAC_information												0					/*使能MAC信息存储栈*/
+#define IMEI_information											1					/*使能IMEI信息存储栈*/
+#define ICCID_information											1					/*使能ICCID信息存储栈*/
+
+#define ICCID_ME3616_INFOrmation					1
+#define IMEI_ME3616_INFOrmation						1
+/** -------------------------------API 注释------------------------------------------------------
+*   @brief		ME3616  用来声明一个句柄，本文件已经默认声明了一个全局句柄为  me3616
+*
+*		调用			ME3616_Init();  完成初始化
+*		TCP
+	
+		me3616.TCP.     							TCP的相关类
+	
+		me3616.TCP.tcp_init();				创建一个TCP连接		
+	
+		me3616.TCP.tcp_close();				关闭一个TCP连接	
+	
+		me3616.TCP.send_Str(char*);		发送ascii字符串
+	
+		me3616.TCP.send_Hex(char*);		发送hex字符串
+		
+		me3616.POWER(uint8_t flug);		硬件开机 flug =1,阻塞等待开机完成再返回，0，立即返回
+		
+		me3616.HRST(uint8_t flug);		硬件复位 flug =1,阻塞等待开机完成再返回，0，立即返回
+		
+		me3616.SRST(uint8_t flug);		软件复位 flug =1,阻塞等待开机完成再返回，0，立即返回
+		
+		me3616.EPS();									打印网络状态，并更新一次标志位寄存器
+		
+		me3616.CSQ();									打印信号强度，并更新一次标志位寄存器
+		
+		me3616.CCID();								打印CCID，并更新一次存储寄存器
+		
+		me3616.PIN();									打印PIN状态，并更新一次标志位寄存器
+*-------------------------------------------------------------------------------------------------*/
+
+
+typedef struct
+{
+	
+	#if(config_TCP_Enable)
+	/*网络状态类*/
+	uint8_t TCP_State; /*TCP连接状态*/
+	
+	#if(config_Multi_channel_Tcp)/*多通道使能*/
+	
+	uint8_t TCP_Socket[5];/*TCP socket 通道*/
+	uint8_t Mult_socket_state;
+	#else
+
+	uint8_t TCP_Socket;/*TCP socket 通道*/
+	
+	#endif
+	
+	uint8_t UDP_State; /*TCP连接状态*/
+	uint8_t UDP_Socket;/*TCP socket 通道*/
+	uint8_t Net_init;	 /*网络连接状态*/
+	#endif
+
+	
+	#if(config_MQTT_Enable)
+	
+	uint8_t mqtt_id;
+	
+	uint8_t MQTT_State;
+	
+	char mqtt_ip[32];
+	
+	char mqtt_port[6];
+	
+	#endif
+	
+	
+	
+	/*硬件类*/
+	uint8_t pwr;	/*开机状态*/
+	uint8_t rssi; /*信号强度等级*/
+	uint8_t ber;	/*误码率*/
+	uint8_t eps;	/*网络状态*/
+	uint8_t pin;	/*pin状态*/
+	int 		dBm;  /*精确的网络信号强度*/
+	#if(ICCID_information)
+	char  	iccid[50];
+	#endif
+	#if(IMEI_information)
+	char  	imei[50];
+	#endif
+	char  	imsi[50];
+	#if(MAC_information)
+	char  	mac[50];
+	#endif
+	#if(Hvertion_data)
+	char  	Hvertion[50];
+	#endif
+	#if(Svertion_data)
+	char  	Svertion[50];
+	#endif
+	#if(config_LMW2M_Enable)
+	/*lwm2m的message id*/
+	char  	msgid[20];
+	#endif
+	
+}ME3616_state;
+
+typedef struct{
+	
+	#if(ICCID_information)
+	_Bool  iccid;
+	#endif
+	#if(IMEI_information)
+	_Bool  imei;
+	#endif
+	_Bool  imsi;
+	#if(MAC_information)
+	_Bool  mac;
+	#endif
+	#if(Hvertion_data)
+	_Bool  Hvertion;
+	#endif
+	#if(Svertion_data)
+	_Bool  Svertion;
+	#endif
+	
+	#if(config_MQTT_Enable)
+	
+	_Bool mqtt_ip;
+	
+	_Bool mqtt_port;
+	
+	#endif
+	
+	
+	
+	_Bool  pwr;	/*开机状态*/
+	_Bool  rssi; /*信号强度*/
+	_Bool  ber;	/*误码率*/
+	_Bool  eps;	/*网络状态*/
+	_Bool  pin;	/*pin状态*/
+	_Bool  dBm;
+	_Bool  rest;
+	
+	#if defined (config_TCP_Enable_Disconnection_reconnection)
+	_Bool  tcp_recon;
+	#endif
+	
+	#if(config_LMW2M_Enable)
+	/*lwm2m的message id*/
+	_Bool  msgid;
+	#endif
+	
+}Flug;
+
+#if(config_TCP_Enable)
+typedef struct{
+	
+	/*发送一个ASCII字符串*/
+	uint8_t (*SendStr)(char *str);
+	/*发送一个hex字符串*/
+	uint8_t (*SendHex)(char *str);
+	/*开始连接TCP*/
+	uint8_t (*CreateChannel)(char *port,char *ip);
+	/*关闭TCP连接*/
+	uint8_t (*CloseChannel)();
+	
+	uint8_t (*GetData)(uint8_t data[]);
+	
+}TCP;
+#endif
+
+typedef struct{
+	
+	uint8_t (*Connect)();
+	
+	uint8_t (*SendStr)(char *data);
+	
+	
+}LWM2M;
+
+
+typedef struct{
+	
+	uint8_t (*Connect)();
+	
+	uint8_t (*SendStr)(char *data,char *topic);
+	
+	
+}ALY_MQTT;
+
+#if(config_MQTT_Enable)
+typedef struct{
+	
+	uint8_t (*SetNet)(char *ip,char *port);
+	
+	uint8_t (*Connect)(char *_productID,char *_deviceID,char *_secret);
+	
+	uint8_t (*Sub)(char * topic);
+	
+	uint8_t (*Pub)(char * topic,char *data, uint32_t len); 
+	
+}MQTT;
+#endif
+
+
+typedef struct
+{
+	#if(config_LMW2M_Enable)
+	/*和LWM2M相关操作的句柄*/
+	LWM2M  LWM2M;
+	#endif
+	
+	#if(config_TCP_Enable)
+	/*和TCP相关操作的句柄*/
+	TCP    TCP;
+	#endif
+	
+	#if(config_MQTT_Enable)
+	MQTT   MQTT;
+	#endif
+
+	void (*imei_iccid_get)(char *imei, char *iccid);
+	
+	#if(config_ALY_MQTT_Enable)
+	ALY_MQTT ALY_MQTT;
+	#endif
+	/*全部标志位的句柄*/
+	ME3616_state State;
+	/*装载位装载记录的标志位*/
+	Flug  flug;
+	/*硬件开机函数指针*/
+	uint8_t (*PowerOn)(uint8_t flug);
+	/*硬件复位函数指针*/
+	uint8_t (*HardRest)(uint8_t flug);
+	#if(SoftRest_fun)
+	/*软件复位函数指针*/
+	uint8_t (*SoftRest)(uint8_t flug);
+	#endif
+	#if(GetEPS_fun)
+	/*获取网络状态并打印的函数指针*/
+	uint8_t (*GetEPS)();
+	#endif
+	#if(GetCSQ_fun)
+	/*获取网络强度并打印的函数指针*/
+	uint8_t (*GetCSQ)();
+	#endif
+	/*获取精确网络强度并打印的函数指针*/
+	int    (*GetCESQ)();
+	#if(GetCCID_fun)
+	/*获取CCID的函数指针*/
+	uint8_t (*GetCCID)();
+	#endif
+	/*获取PIN状态的函数指针*/
+	uint8_t (*GetPIN)();
+	#if(IMEI_information)
+	/*获取IMEI状态的函数指针*/
+	uint8_t (*GetIMEI)();
+	#endif
+	#if(Svertion_data)
+	/*获取软硬件版本*/
+	uint8_t (*Version)();
+	#endif
+	
+}ME3616;
+
+
+extern ME3616  me3616;
+
+/** @brief ME3616句柄的构造函数*/
+ME3616 * ME3616_Init(void);
+
+
+#if defined (config_Check_Rest)
+uint8_t ME3616_Check_State(void);
+#endif
+
+
+/** @brief ME3616硬件开机,flug=1,阻塞等待，flug=0，立即返回*/
+uint8_t ME3616_Power_On(uint8_t flug);
+
+/** @brief ME3616硬件复位,flug=1,阻塞等待，flug=0，立即返回*/
+uint8_t ME3616_HARD_Rest(uint8_t flug);
+
+/** @brief ME3616软件复位,flug=1,阻塞等待，flug=0，立即返回*/
+uint8_t ME3616_SOFT_Rest(uint8_t flug);
+
+/** @brief 读取网络状态并打印相关数据，会返回模组第二位的状态位<state>*/
+uint8_t ME3616_READ_EPS(void);
+
+/** @brief  ME3616读取网络信号强度*/
+uint8_t ME3616_READ_CSQ(void);
+/** @brief  ME3616读取精确的网络信号强度*	*/
+int ME3616_READ_CESQ(void);
+/** @brief  ME3616读取SIM卡的CCID	*/
+uint8_t ME3616_READ_CCID(void);
+/** @brief  ME3616查询pin状态* @param  return 1 为ready，0 其他*	*/
+uint8_t ME3616_READ_PIN(void);
+#if(IMEI_information)
+/** @brief  ME3616查询IMEI状态*/
+uint8_t ME3616_READ_IMEI(void);
+#endif
+/**
+* @brief  ME3616查询软硬件版本*/
+uint8_t ME3616_READ_Revision(void);
+
+void ME3616_IMEI_ICCID_INFO_GET(char *imei, char *iccid);
+
+#if(config_TCP_Enable)
+/**
+* @brief  ME3616关闭一个套接字
+* @param  socket：套接字的句柄编号
+*	*/
+uint8_t ME3616_Close_Socket(uint8_t socket);
+/**
+* @brief  ME3616关闭一个套接字[内部调用]*	*/
+uint8_t Close_TCP_Socket(void);
+
+/** @brief  ME3616创建一个套接字*/
+uint8_t ME3616_Create_Socket(int IPvX,int TCP_UDP,int protocol);
+
+/** @brief  ME3616连接到一个Socket*/
+int ME3616_Connect_Socket(uint8_t socket,char *port,char *ip);
+/**
+* @brief  ME3616创建一个TCP连接*/
+uint8_t ME3616_Connect_TCP(char *port,char *ip);
+/**
+* @brief  ME3616调用TCP通道发送一条ASCII数据*/
+uint8_t  ME3616_TCP_SEND_String(char *str);
+/**
+* @brief  ME3616调用TCP通道发送一条十六进制数据*/
+uint8_t  ME3616_TCP_SEND_Hex(char *str);
+/**
+* @brief  ME3616非透传下的数据进行提纯*/
+uint8_t ME3616_TCP_DATA_purification(uint8_t data[]);
+#endif
+
+/*-----------------------------------------------------------------------------------*/
+/** @brief  ME3616创建一个LWM2M协议的object*/
+uint8_t ME3616_LWM2M_CREATE(void);
+/** @brief  ME3616 LWM2M协议发起observe请求 */
+uint8_t ME3616_LWM2M_LADD(void);
+/**@brief  ME3616 LWM2M协议开始连接服务器【这个函数会阻塞较长时间】*/
+uint8_t ME3616_LWM2M_OPEN(void);
+/**@brief  ME3616 LWM2M  去注册*/
+uint8_t ME3616_LWM2M_CLOSE(void);
+/** @brief  ME3616 [LWM2M协议] 删除OneNET instance	*/
+uint8_t ME3616_LWM2M_MIPLDELETE(void);
+/** @brief  ME3616 [LWM2M协议] 连接ONENET服务器*	*/
+uint8_t ME3616_LWM2M_Connect(void);
+/** @brief  ME3616 [LWM2M协议] 发送一条数据	*/
+uint8_t  ME3616_LWM2M_Send(char *data);
+/** @brief  ME3616打印套接字错误码*/
+void     ESOERR_PRINT(int code);
+/*-----------------------------------------------------------------------------------*/
+#if (config_ALY_MQTT_Enable)
+
+/** @brief  配置阿里云MQTT三元组*/
+uint8_t Configuration_ALY_MQTT(char *ProductKey,char *appdemo,char *DeviceSecret);
+/** @brief  ME3616 连接阿里云MQTT*/
+uint8_t Connect_ALY_MQTT(void);
+
+#endif
+/*-----------------------------------------------------------------------------------*/
+#if(config_MQTT_Enable)
+/** @brief  ME3616设置MQTT的服务器端口和ip地址*/
+uint8_t MQTT_Set_Net(char *ip,char *port);
+/** @brief  ME3616使用三元组连接MQTT服务器*/
+uint8_t MQTT_Connet(char *_productID,char *_deviceID,char *_secret);
+
+uint8_t MQTT_SUB(char * topic);
+
+uint8_t MQTT_PUB(char * topic,char *data, uint32_t len);
+#endif
+/*-----------------------------------------------------------------------------------*/
+
+#define ME3616_INFO(fmt,arg...)           printf("<<-ME3616 INFO->> [%d]"fmt"\r\n",__LINE__, ##arg)//trace_otp_trace1(uart_msg_send, 4, fmt, ##arg);
+//printf("<<-EEPROM-INFO->> "fmt"\n",##arg)
+#define ME3616_ERROR(fmt,arg...)          printf("<<-ME3616-ERROR->> [%d]"fmt"\r\n",__LINE__, ##arg)
+#define ME3616_DEBUG(fmt,arg...)          do{\
+	                                          if(EEPROM_DEBUG_ON)\
+	                                          printf("<<-ME3616-DEBUG->> [%d]"fmt"\r\n",__LINE__, ##arg);\
+                                          }while(0)
+

APP/network_mgr/net_ctrl.c

@@ -0,0 +1,341 @@
+#include "includes.h"
+#include "net_ctrl.h"
+#include "net_proc.h"
+#include "at_module.h"
+#include "me3616.h"
+#include "tax_ctrl.h"
+#include "gateway_collect.h"
+
+sverMsgHeader g_msg;
+extern uint16_t _crc16_get(uint8_t *_buff,uint32_t _len);
+
+extern ME3616  air;
+uint8_t net_send_buf[1024],net_send_len=0;
+uint8_t net_seng_state = 0;
+
+uint8_t net_rcv_data[512];
+uint16_t net_rcv_len = 0;
+uint8_t net_rcv_state = 0;
+
+//collect_para_t collect_para[4];
+//tax_para_t tax_para[4][4];
+
+uint8_t AIR_MQTT_PUB(char * topic, char *data, uint32_t len);
+
+uint16_t crc16_get(uint8_t *data, uint8_t size)
+{
+	uint16_t crc=0;
+	int i;
+	for(i = 0; i < size; i++)
+	{
+		crc += data[i];
+	}
+	return crc;
+}
+
+int tax_net_send(uint8_t *tx_data, uint16_t len, uint8_t typeFirst,uint16_t typeSecd)
+{
+
+    char *msg = NULL;
+    OS_ERR      err;
+    static uint32_t seq_num = 0;
+    uint16_t crc = 0;
+   // sverMsgHeader p_msg;// = (sverMsgHeader *)net_send_buf;
+   // memset(net_send_buf, 0, sizeof(net_send_buf));
+
+   if(sys_net.net_hdl==NULL) return 0;
+
+    memset(g_msg.info,0,sizeof(g_msg.info));
+
+    g_msg.frame_header = 0xfefe;
+    g_msg.proto_ver = 0x01;
+    g_msg.seq_no = seq_num++;
+
+    g_msg.msgtypeFirst = typeFirst;
+    g_msg.msgtypeSecd = typeSecd;
+    g_msg.len = len + 2;
+    //p_msg->fcs = 0;
+
+    memcpy(g_msg.info, tx_data, len);
+    crc = _crc16_get((uint8_t *)&g_msg,len+12);
+    g_msg.info[len] = crc&0xff;
+    g_msg.info[len+1] = (crc>>8)&0xff;
+
+
+    net_send_len = len+FRAME_HEADER_LEN+2;
+
+    msg = (char *)net_queue_mem_calloc_must();
+    if(msg) {
+        memcpy(msg, (char*)&g_msg, len + FRAME_HEADER_LEN+2);
+        net_queue_insert((char *)msg, len + FRAME_HEADER_LEN+2);
+    }
+    else
+    {
+        net_queue_mem_free(msg);
+    }
+    return 0;
+}
+
+//void serino_init(void)
+//{
+//	uint8_t monitor_serino[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+//	uint8_t coder_serino[20] = {0x10,0x20,0x30,0x40,0x50,0x60,0x70,0x80,0x90,0xA0,0xB0,0xC0,0xD0,0xE0,0xF0,0x11,0x22,0x33,0x44,0x55};
+//	uint8_t dispaly_serino[16] = {0x12,0x23,0x34,0x45,0x56,0x67,0x78,0x89,0x9A,0xAB,0xBC,0xCD,0xDE,0xEF,0xF0,0xFF};
+
+//	collect_para[0].device_id = 0x01;;
+//	collect_para[0].device_status = 0x00;
+//	collect_para[0].tax_control_count = 0x02;
+//	
+//	collect_para[1].device_id = 0x02;;
+//	collect_para[1].device_status = 0x00;
+//	collect_para[1].tax_control_count = 0x03;
+//	
+//	memcpy(tax_para[0][0].tax_serino,monitor_serino,16);
+//	memcpy(tax_para[0][0].coder_serino,coder_serino,20);
+//	memcpy(tax_para[0][0].dispaly_serino,dispaly_serino,16);
+//	tax_para[0][0].gun_count = 0x02;
+//}
+
+//int tax_data(uint8_t *data, uint8_t *len)
+//{
+//	uint8_t monitor_serino[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+//	uint8_t coder_serino[20] = {0x10,0x20,0x30,0x40,0x50,0x60,0x70,0x80,0x90,0xA0,0xB0,0xC0,0xD0,0xE0,0xF0,0x11,0x22,0x33,0x44,0x55};
+//	uint8_t dispaly_serino[16] = {0x12,0x23,0x34,0x45,0x56,0x67,0x78,0x89,0x9A,0xAB,0xBC,0xCD,0xDE,0xEF,0xF0,0xFF};
+//	
+//	uint8_t tx_data[128];
+//	
+//	tax_comm_info_t *p_msg = (tax_comm_info_t *)tx_data;
+//	
+//	memset(tx_data,0,sizeof(tx_data));
+//	p_msg->device_type = 0x01;
+//	p_msg->device_id = 0x02;
+//	p_msg->device_status = 0x00;
+//	p_msg->tax_control_count = 0x01;
+//	
+//	memcpy(p_msg->tax_control_info.monitor_serino,monitor_serino,16);
+//	memcpy(p_msg->tax_control_info.coder_serino,coder_serino,20);
+//	memcpy(p_msg->tax_control_info.dispaly_serino,dispaly_serino,16);
+//	p_msg->tax_control_info.gun_count = 0x01;
+//	
+//	p_msg->tax_control_info.guns_info.gun_number = 0x01;
+//	p_msg->tax_control_info.guns_info.gun_status = 0x00;
+//	p_msg->tax_control_info.guns_info.total_price = 0x4358;
+//	p_msg->tax_control_info.guns_info.total_oil_volume = 0x2567;
+//	p_msg->tax_control_info.guns_info.last_unit_price = 0x96;
+//	p_msg->tax_control_info.guns_info.last_oil_volume = 0x84;
+//	p_msg->tax_control_info.guns_info.last_price = 0x200;
+//	
+//	*len = 85;
+//	memcpy(data,tx_data,*len);
+//}
+
+//int tax_net_data_analyze(void *puser,uint8_t collect, uint8_t tax, uint8_t *outdata, uint8_t *len)
+//{
+////	uint8_t tx_data[128];
+//	int ret = 0;
+//	gun_info_t * p_gun = (gun_info_t *)puser;
+//	
+//	tax_comm_info_t *p_msg = (tax_comm_info_t *)outdata;
+
+//	p_msg->device_type = 1;
+//	p_msg->device_id = collect_para[collect].device_id;
+//	p_msg->device_status = collect_para[collect].device_status;
+//	p_msg->tax_control_count = collect_para[collect].tax_control_count;
+//	
+////	printf("device_id : %d\n",p_msg->device_id);
+////	printf("device_status : %d\n",p_msg->device_status);
+////	printf("tax_control_count : %d\n",p_msg->tax_control_count);
+//	
+//	memcpy(p_msg->tax_control_info.monitor_serino,tax_para[collect][tax].tax_serino,16);
+//	memcpy(p_msg->tax_control_info.coder_serino,tax_para[collect][tax].coder_serino,20);
+//	memcpy(p_msg->tax_control_info.dispaly_serino,tax_para[collect][tax].dispaly_serino,16);
+//	p_msg->tax_control_info.gun_count = tax_para[collect][tax].gun_count;
+//	
+//	p_msg->tax_control_info.guns_info.gun_number = p_gun->id;
+//	p_msg->tax_control_info.guns_info.gun_status = p_gun->status;
+//	p_msg->tax_control_info.guns_info.gun_type = p_gun->gun_type;
+//	p_msg->tax_control_info.guns_info.gun_msgid = p_gun->gun_msgid;
+//	if(p_gun->gun_type == SINGLE_DATA)
+//	{
+//		p_msg->tax_control_info.guns_info.last_oil_volume = p_gun->last_oil_volume;
+//		p_msg->tax_control_info.guns_info.last_price = p_gun->last_price;
+//		p_msg->tax_control_info.guns_info.last_unit_price = p_gun->last_unit_price;
+//	}
+//	else if(p_gun->gun_type == CUMULATIVE_DATA)
+//	{
+//		p_msg->tax_control_info.guns_info.total_oil_volume = p_gun->total_oil_volume;
+//		p_msg->tax_control_info.guns_info.total_price = p_gun->total_price;
+//	}
+//	
+//	*len = COLLECT_COM;
+//	return ret;
+//}
+
+//void gw_net_comm(uint8_t *data, uint8_t len)
+//{
+//	uint8_t send_buf[128],send_size;
+//	uint8_t tmp_buf[128];
+//	
+//	
+////	collect_rcv_analyze(data,len,tmp_buf);
+////	tax_net_data_analyze();
+//	tax_net_send(send_buf,send_size,1);
+//}
+
+
+//void gw_net_comm_test(void)
+//{
+//	uint8_t send_buf[128],send_size;
+//	
+//	tax_data(send_buf, &send_size);
+//	
+//	tax_net_send(send_buf,send_size,1);
+//}
+
+int air_mqtt_pub(char *topic, char *data, uint8_t len)
+{
+    int slen,slen1,send_len=0;
+    uint8_t sendbuf[512];
+
+    if(!air.State.MQTT_State) {
+        ME3616_INFO("Cannot Connect MQTT");
+        return 0;
+    }
+
+    slen=sprintf((char *)sendbuf,"AT+MPUB=\"%s\",0,0,\"",topic);
+    send_len = slen;
+    memcpy(sendbuf+send_len,data,len);
+    send_len += len;
+    slen1=sprintf((char *)sendbuf+send_len,"\"\r\n");
+    send_len += slen1;
+    uart_msg_send(UART3_ID, (char *)sendbuf, send_len);
+//	uart_msg_send(UART1_ID, (char *)sendbuf, send_len);
+
+    if(Module_Read_A_CRC("OK", 300)) {
+            //ME3616_INFO("Pub Successful \r\n[%s]<-[%s]",topic,data);
+        return 1;
+    } else {
+        ME3616_INFO("Pub ERROR");
+        return 0;
+    }
+}
+
+
+void gw_net_send(char *data, uint32_t len)
+{
+    int i;
+   // char send_buf[320];
+    int send_len=0;
+    if(air.State.MQTT_State)
+    {
+        memset(net_send_buf,0,sizeof(net_send_buf));
+        for(i = 0;i < len;i++) {
+            send_len += snprintf((char *)net_send_buf + send_len, sizeof(net_send_buf), "%02x", data[i]);
+        }
+        g_data4G.bconnect4G = AIR_MQTT_PUB((char*)g_upLinkTopic,(char*)net_send_buf,send_len);
+//				AIR_MQTT_PUB((char*)g_upLinkTopic,data,len);
+			    
+	//		    AIR_MQTT_PUB((char*)g_upLinkTopic,data,len);
+    }
+}
+
+
+////////////////////////////////
+void net_msg_recv1(void)
+{
+	int len = 0;
+	char *str,*str1,*str2;
+	char *msg = NULL;
+	OS_ERR      err;
+	int slen,data_len;
+	if(!air.State.MQTT_State) {
+		return;
+	}
+	
+        return;
+
+	memset(sys_net.str, 0, sizeof(sys_net.str));	
+	len = Module_Blocking_Read(sys_net.str, 1);
+	if(len) {
+            len = Module_Blocking_Read(sys_net.str+len, 100);
+            str = strstr(sys_net.str, "byte,");
+            str1 = strstr(sys_net.str,"\r\n");
+            if(strstr(sys_net.str,"+MQTTSTATU:")){
+                printf("\r\n aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\r\n");
+            }
+            if(str && str1) {
+
+                    slen = net_data_copy(str+5,(uint8_t *)sys_net.str);
+                    net_rcv_len = net_rcvdata_ch((char *)sys_net.str,net_rcv_data,slen);
+
+                    data_dump("NET RECB", net_rcv_data, net_rcv_len);
+                    msg = (char *)net_queue_mem_calloc_must();
+                    if(msg) {
+                            memcpy(msg, net_rcv_data, net_rcv_len);
+                            net_queue_insert((char *)msg, net_rcv_len); //½«Êý¾Ý·Åµ½ÏûÏ¢¶ÓÁÐÖÐ
+                    }
+                    else
+                    {
+                            net_queue_mem_free(msg);
+                    }
+
+            }
+    }
+}
+
+
+unsigned char HexToChar(unsigned char bChar)
+{
+	if((bChar>=0x30)&&(bChar<=0x39))
+	{
+		bChar -= 0x30;
+	}
+	else if((bChar>=0x41)&&(bChar<=0x46)) // Capital
+	{
+		bChar -= 0x37;
+	}
+	else if((bChar>=0x61)&&(bChar<=0x66)) //littlecase
+	{
+		bChar -= 0x57;
+	}
+	else 
+	{
+		bChar = 0xff;
+	}
+	return bChar;
+}
+
+int net_rcvdata_ch(char *data, uint8_t *out_data, int len)
+{
+	int i,slen=0;
+	uint8_t temp1,temp2;
+	for(i = 0; i < len; i+=2)
+	{
+		temp1 = HexToChar(data[i]);
+		temp2 = HexToChar(data[i+1]);
+		out_data[slen] = (temp1<<4) | temp2;
+		slen++;
+	}
+	return slen;
+}
+
+
+int net_data_copy(char *data, uint8_t *out_data)
+{
+	int len = 0;
+	int i=0;
+	while(1)
+	{
+		if(data[len] == '\r'||data[len] == '\n')
+			break;
+		
+		out_data[len] = data[len];
+		len++;
+		
+//		if(len >= 512)
+//			break;
+	}
+	return len;
+}
+
+

APP/network_mgr/net_ctrl.h

@@ -0,0 +1,85 @@
+#ifndef __NET_CTRL_H__
+#define __NET_CTRL_H__
+
+#include "stm32f10x.h"
+
+#define COLLECT_PARA_NUM 6
+#define TAX_PARA_NUM     53
+
+#define SINGLE_DATA      0
+#define CUMULATIVE_DATA  1
+
+#define COLLECT_COM   94
+
+extern uint8_t net_send_buf[1024],net_send_len;
+extern uint8_t net_seng_state;
+extern uint8_t net_rcv_data[512];
+extern uint16_t net_rcv_len;
+extern uint8_t net_rcv_state;
+
+typedef struct _guns_info
+{
+	uint8_t gun_number;
+	uint8_t gun_status;
+	uint8_t gun_type;
+	uint32_t gun_msgid;
+	uint32_t total_price;
+	uint32_t total_oil_volume;
+	uint32_t last_unit_price;
+	uint32_t last_oil_volume;
+	uint32_t last_price;
+}__attribute__((packed)) guns_info_t;
+
+
+typedef struct _tax_control_info
+{
+	uint8_t monitor_serino[16];
+	uint8_t coder_serino[20];
+	uint8_t dispaly_serino[16];
+	uint8_t gun_count;
+	guns_info_t guns_info;
+}__attribute__((packed)) tax_control_info_t;
+
+typedef struct _tax_comm_info
+{
+	uint32_t device_type;
+	uint32_t device_id;
+	uint8_t device_status;
+	uint8_t tax_control_count;
+	tax_control_info_t tax_control_info;
+	uint32_t collect_time;
+}__attribute__((packed)) tax_comm_info_t;
+
+//²É¼¯Æ÷²ÎÊý
+typedef struct _collect_para
+{
+	uint32_t device_id;
+	uint8_t device_status;
+	uint8_t tax_control_count;
+}__attribute__((packed)) collect_para_t;
+
+
+//Ë°¿Ø¿Ú²ÎÊý
+typedef struct _tax_para
+{
+	uint8_t tax_serino[16];
+	uint8_t coder_serino[20];
+	uint8_t dispaly_serino[16];
+	uint8_t gun_count;
+}__attribute__((packed)) tax_para_t;
+
+extern int tax_net_send(uint8_t *tx_data, uint16_t len, uint8_t typeFirst, uint16_t typeSecd);
+
+void gw_net_comm_test(void);
+int air_mqtt_pub(char *topic, char *data, uint8_t len);
+void gw_net_send(char *data, uint32_t len);
+uint16_t crc16_get(uint8_t *data, uint8_t size);
+
+void net_msg_recv1(void);
+int net_rcvdata_ch(char *data, uint8_t *out_data, int len);
+int net_data_copy(char *data, uint8_t *out_data);
+
+int tax_net_data_analyze(void *puser,uint8_t collect, uint8_t tax, uint8_t *outdata, uint8_t *len);
+void serino_init(void);
+#endif
+

APP/network_mgr/net_proc.c

@@ -0,0 +1,951 @@
+#include "net_proc.h"
+#include "../ota/ota.h"
+#include "me3616.h"
+#include "../storage/AT24C128Opt.h"
+#include "../network/nettimer.h"
+#include "../command/uart_conf.h"
+
+  extern volatile uint32_t TickCounter;
+
+system_network_t	sys_net;
+void collect_msg_frame_fill(gateway_collect_com_t *p_msg,uint8_t msg_type,uint16_t len);
+#define hextoascii(x)	\
+	if((x) < 10) { 	\
+		(x) = (x)|0x30;	\
+	} else {	\
+		(x) = (x)-10 + 'A';\
+	}
+
+void NET_IMEI_ICCID_INFO_GET(char *imei, char *iccid)
+{
+	ME3616	*uplink = sys_net.net_hdl;
+
+	if(uplink) {
+		uplink->imei_iccid_get(imei, iccid);
+	}
+}
+
+extern ME3616  air;
+extern ME3616 * AIR_Init(void);
+void * uplink_net_init(char *device_id) 
+{
+    char sub_topic[64] = {0};
+    ME3616	*uplink;
+
+//	snprintf(sub_topic, sizeof(sub_topic), "RCC/%s", device_id);
+//    snprintf(sub_topic, sizeof(sub_topic), "%s", device_id);
+//uplink = ME3616_Init();
+    uplink = AIR_Init();
+		
+    uplink->PowerOn(1);
+
+		
+    if(uplink->GetCCID) {
+        uplink->GetCCID();	/*获取CCID*/
+    } else {
+        printf("uplink->GetCCID = %p\r\n", uplink->GetCCID);
+    }
+    if(uplink->GetIMEI) {
+        uplink->GetIMEI();
+    } else {
+        printf("uplink->GetIMEI = %p\r\n", uplink->GetIMEI);
+    }
+    uplink->GetCSQ();	/*等待网络*/
+//  NVIC_SystemReset();
+
+    sprintf(sub_topic,"%04x-%010u",GATEWAY_DEVICE_TYPE, g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn);
+
+    if(g_firmwareMsg.mqttidport.flag ==1){
+        if(g_mqttRunDa.bChangeMqtt == 1){
+           // uplink->MQTT.SetNet(MQTT_SERVER_IP1, MQTT_SERVER_PORT);
+           // uplink->MQTT.Connect("cpyypt", (char*)sub_topic, "1SvTlvm1VCawSzS");
+
+            uplink->MQTT.SetNet(g_mqttRunDa.mqttMsg.ip, g_mqttRunDa.mqttMsg.port);
+            uplink->MQTT.Connect(g_mqttRunDa.mqttMsg.admin, (char*)sub_topic, g_mqttRunDa.mqttMsg.password);
+            printf("\r\n change, mqttIP:  mqttPort\r\n");//,g_mqttRunDa.mqttMsg.ip,g_mqttRunDa.mqttMsg.port);
+            printf("\r\n change, admin:  password\r\n");//,g_mqttRunDa.mqttMsg.admin,g_mqttRunDa.mqttMsg.password);
+        }
+        else {
+            uplink->MQTT.SetNet(g_firmwareMsg.mqttidport.ip, g_firmwareMsg.mqttidport.port);
+            uplink->MQTT.Connect(g_firmwareMsg.mqttidport.admin, (char*)sub_topic, g_firmwareMsg.mqttidport.password);
+            printf("\r\n Have Init, mqttIP:  mqttPort \r\n");//,g_firmwareMsg.mqttidport.ip,g_firmwareMsg.mqttidport.port);
+            printf("\r\n Have Init, admin: password \r\n");//,g_firmwareMsg.mqttidport.admin,g_firmwareMsg.mqttidport.password);
+        }
+    }
+    else
+    {
+        uplink->MQTT.SetNet(MQTT_SERVER_IP, MQTT_SERVER_PORT);
+        uplink->MQTT.Connect("admin", (char*)sub_topic, "houjianwei");
+        printf("\r\n NO Init, mqttIP:  mqttPort\r\n");//,MQTT_SERVER_IP,MQTT_SERVER_PORT);
+        printf("\r\n No Init, admin: , password\r\n");//,"admin","houjianwei");
+
+    }
+
+
+
+    memset(sub_topic,0,sizeof(sub_topic));
+    sprintf(sub_topic,"%s%04x/%s",(char*)MQTT_DNLINK_TOPIC_CASE,GATEWAY_DEVICE_TYPE, (char*)"broadcast");
+    uplink->MQTT.Sub((char*)sub_topic);
+
+    memset(sub_topic,0,sizeof(sub_topic));
+    sprintf(sub_topic,"%s%04x/%010u",(char*)MQTT_DNLINK_TOPIC,GATEWAY_DEVICE_TYPE, g_firmwareMsg.gatewayMsg.hardwareMsg.gateway_sn);
+    uplink->MQTT.Sub(sub_topic); // 订阅上行主题
+
+    memcpy(g_firmwareMsg.gatewayMsg.Iccid1,air.State.iccid,20);
+    memcpy(g_firmwareMsg.gatewayMsg.Imei,air.State.imei,15);
+    return uplink;
+}
+extern void AIR_CLOSE_TCP();
+
+void close_tcp_mqtt(void)
+{
+    AIR_CLOSE_TCP();
+}
+
+void uplink_net_send(char *buffer, uint32_t len) 
+{
+	uint32_t i, str_len = 0;//, high, low;
+	inner_msg_format_t *p_net_msg = (inner_msg_format_t *)buffer;
+	ME3616	*uplink = sys_net.net_hdl;
+
+	if(uplink) {
+		memset(sys_net.str, 0, sizeof(sys_net.str));
+		//printf("type = %d, len = %d\r\n", p_net_msg->type, len);
+#if 0	
+		for(i = 0;i < len;i++) {
+			high = (buffer[i]>>4)&0xf;		
+			low = buffer[i]&0xf;
+			hextoascii(high);
+			hextoascii(low);		
+			str_len += snprintf(sys_net.str + str_len, sizeof(sys_net.str)-str_len, "%x", high);
+			str_len += snprintf(sys_net.str + str_len, sizeof(sys_net.str)-str_len, "%x", low);
+		}
+		//printf("%s, %d\r\n", sys_net.str, strlen(sys_net.str));
+		uplink->MQTT.Pub(TOPIC_GET_BY_MSGTYPE(p_net_msg->type), sys_net.str, strlen(sys_net.str)/2);
+#else
+		for(i = 0;i < len;i++) {
+			str_len += snprintf(sys_net.str + str_len, sizeof(sys_net.str)-str_len, "%02x", buffer[i]);
+		}	
+		//printf("%s, %d\r\n", sys_net.str, strlen(sys_net.str));
+                g_data4G.bconnect4G =  uplink->MQTT.Pub(TOPIC_GET_BY_MSGTYPE(p_net_msg->type), sys_net.str, strlen(sys_net.str)/2);
+#endif
+	}
+}
+
+void collect_station_proto_proc(system_network_t *p_sys_net, inner_msg_format_t *p_msg, uint32_t msg_len) 
+{
+	gb_node_bind_info_t *p_bind = NULL;
+	gb_gateway_bind_info_t *p_gw_bind = NULL;
+	gb_node_info_t	*p_node = NULL;
+	u8 i;
+
+	switch(p_msg->type) {
+		case net_msg_type_update:
+			break;
+		case net_msg_type_reboot:
+			p_bind = (gb_node_bind_info_t *)p_msg->info;
+			if(gateway_id_cmp(p_bind->gw_device_id)) {
+				if(device_type_and_id_cmp(p_bind->device_type, p_bind->device_id)) {
+					NVIC_SystemReset();
+				}
+			}
+			break;
+		//绑定请求和心跳上行转发
+		case net_msg_type_bind_req:
+		case net_msg_type_node_echo:
+			p_bind = (gb_node_bind_info_t *)p_msg->info;
+			if(device_type_and_id_cmp(p_bind->device_type, p_bind->device_id)) {
+				if(sys_net.uplink_send) {
+					sys_net.uplink_send((char *)p_msg, FRAME_HEADER_LEN + p_msg->len);
+				}
+			}
+			break;
+		//接收网关回响及心跳
+		case net_msg_type_bind_rsp:
+			p_bind = (gb_node_bind_info_t *)p_msg->info;
+			if(device_type_and_id_cmp(p_bind->device_type, p_bind->device_id)) {
+				gateway_gw_id_flush(p_bind->gw_device_id);
+			}
+			break;
+		case net_msg_type_gw_echo:
+			p_gw_bind = (gb_gateway_bind_info_t *)p_msg->info;
+			if(gateway_id_cmp(p_gw_bind->gw_device_id)) {
+				for(i = 0;i < GB_SUPPORT_MAX_NODE;i++) {
+					p_node = &p_gw_bind->node[i];
+					if(device_type_and_id_cmp(p_node->device_type, p_node->device_id)) {
+						gateway_gw_id_flush(p_gw_bind->gw_device_id);
+						break;
+					}
+				}				
+			}
+			break;
+		default:
+			break;
+	}
+	//printf("collect_station_proto_proc, msg_type = %d, msg_len = %d\r\n", p_msg->type, msg_len);
+	//OSTmrStop(&sys_net.net_tmr, OS_OPT_TMR_NONE, NULL, &err);
+}
+
+void oiltank_station_proto_proc(system_network_t *p_sys_net, inner_msg_format_t *p_msg, uint32_t msg_len) 
+{
+	printf("oiltank_station_proto_proc, msg_type = %d, msg_len = %d\r\n", p_msg->type, msg_len);
+}
+
+//设置升级标志
+uint16_t set_updata_state(uint16_t data)
+{
+	uint16_t temp_data,ret_data = 0;
+	uint16_t temp_h,temp_l;
+	temp_data = data;
+	temp_h = ((~temp_data)<<8)&0xff00;
+	temp_l = temp_data&0x00ff;
+	ret_data = temp_h | temp_l;
+	return ret_data;
+}
+
+//判断升级标志的本体和掩码
+uint8_t updata_state_cmp(uint16_t data)
+{
+	uint8_t ret = 0;
+	uint16_t temp_data;
+	uint8_t temp_h,temp_l;
+	temp_data = data;
+	temp_h = (uint8_t)((temp_data&0xff00)>>8);
+	temp_l = (uint8_t)(temp_data&0x00ff);
+	if((temp_h^temp_l) == 0xff)
+	{
+		ret = 1;
+	}
+	return ret;
+}
+
+/*------------------------------------------------------------------------
+ *  上报服务器的升级状态
+ * -----------------------------------------------------------------------*/
+void up_to_send_server_update_status(uint16_t targetType, uint32_t sn, uint16_t taskNo,uint8_t updateStatus)
+{
+    char buff[128] = {0};
+    uint8_t bufflen = 0;
+
+    memset(buff,0,sizeof(buff));
+    uplink_update_systemcmd_0x2001((uint8_t*)buff,&bufflen,targetType,sn,taskNo,updateStatus);
+    tax_net_send((uint8_t*)buff,bufflen,FIRST_TYPE_SYST,COLL_UP_SYS_CMD2001); //向服务器上传数据的完整数据，并通过mqtt发送
+
+    return;
+}
+
+extern uint8_t * AIR_HTTP_READ(uint32_t start_addr, uint32_t data_len);
+extern void lora_send(char *tx_data, uint32_t tx_len);
+/*--------------------------------------------------------------------
+ *  升级
+ * http://121.89.239.35:8002/chfs/shared/0101/010103001.bin
+ * http://121.89.239.35:8002/chfs/shared/0101/A64010001.bin
+ * https://oil-public.oss-cn-zhangjiakou.aliyuncs.com/upgrade/apk/20211126/A64010001.bin
+ *
+ * https://oil-public.oss-cn-zhangjiakou.aliyuncs.com/upgrade/apk/20211129/01013001.bin
+ * https://oil-public.oss-cn-zhangjiakou.aliyuncs.com/upgrade/apk/20211129/01013002.bin
+ * https://oil-public.oss-cn-zhangjiakou.aliyuncs.com/upgrade/apk/20211211/01013003.bin
+ * -------------------------------------------------------------------*/
+void gateway_update_proc(uint8_t *data,uint8_t msg_len)
+{
+    uint32_t start_addr = 0, total_len = 0, remain_len, read_len, total_crc = 0;
+    uint8_t *p_content = NULL, i,updateStatus = UPDATE_DOWNLOADFILE_SUCCESS;
+	  uint16_t send_data_dr2 = 0;
+    int index = 0,len = 0;
+    OS_ERR  err;
+    char buff[128] = {0};
+    const char ch = '.';
+    char *ret = NULL;
+    uint32_t version = 0;
+    uint16_t dd,nn;
+    uint8_t ff;
+    uint32_t fileVer,addr,filelen,crcVl,fixChar,getcrc;
+    downlinkSysCmd0x1001 *p_msg = NULL;
+    update_msg_format p_update;
+
+    sverMsgHeader *pHeadmsg;
+    OS_MSG_SIZE msg_len_head;
+
+    g_runData.bUpdate = 1;
+    g_updateProg.updateProgFrom = UPDATE_PROG_FROM_NET;
+
+
+
+    p_msg = (downlinkSysCmd0x1001*)data;
+    updateStatus = UPDATE_RECEIVE_UPDATEFLAG; //文件下载 APP3写入成功
+    up_to_send_server_update_status(0x0301,downlink_config.gateway_id,p_msg->taskNo,updateStatus);
+
+    while(sys_net.net_q.MsgQ.NbrEntries!=0){
+        OSSemPend(&sys_net.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+        pHeadmsg = (sverMsgHeader *)OSQPend(&sys_net.net_q, 0, OS_OPT_PEND_NON_BLOCKING, &msg_len_head, NULL, &err);	/* blocking. */
+        OSSemPost(&sys_net.sem, OS_OPT_POST_ALL, &err);
+        gw_net_send((char *)pHeadmsg, msg_len_head);
+        net_queue_mem_free(pHeadmsg);
+    }
+
+     BKP_WriteBackupRegister(BKP_DR4, p_msg->taskNo);
+//    memset(p_msg->url, 0, sizeof(p_msg->url));
+//    snprintf(p_msg->url, sizeof(p_msg->url),
+//            "%s","https://oil-public.oss-cn-zhangjiakou.aliyuncs.com/upgrade/apk/20211213/02013001.bin");
+    ret = strrchr(p_msg->url, ch)-8;
+    sscanf(ret,"%[^.]",buff);
+    sscanf(buff,"%08x",&version);
+    dd = (version>>16)&0xFFFF; //类型
+    ff = (version>>12)&0x0F; //aap类型
+    nn = version&0xFFF; // 版本
+    if(dd != p_msg->targetType){
+        updateStatus = UPDATE_DEVICETYPEERROR;
+        goto UPDATE_END;
+    }
+    if((p_msg->targetType==0x0301)){// 版本对比
+        if(g_firmwareMsg.gatewayMsg.verMsg.gate_appVr== version){
+            updateStatus = UPDATE_SAMEVERSION;
+            goto UPDATE_END;
+        }
+    }
+//    else if(p_msg->targetType==0x0201){
+//        if(p_msg->sn!=0xFFFFFFFF){
+//            index = read_collect_index(p_msg->sn);
+//            if(index== -1){
+//                updateStatus = UPDATE_FAILE_NOCOLLECT;
+//                goto UPDATE_END;
+//            }
+//            if(g_firmwareMsg.collMsg[index].appVr == version){
+//                updateStatus = UPDATE_SAMEVERSION;
+//                goto UPDATE_END;
+//            }
+//        }
+//    }
+    g_runData.updateDeviceTyp = p_msg->targetType;
+    //提取url文件到对应的升级区
+    //len = strlen(p_msg->url);
+
+    g_runData.bUpdate = 1;
+
+    memcpy(buff,p_msg->url,p_msg->urlLen);
+    AIR_HTTP_GET(buff ,p_msg->urlLen, &total_len);
+    printf("total_len %d\r\n", total_len);
+    if(total_len<=2){
+       updateStatus = UPDATE_DOWNLOADFILE_FAILED;// 文件下载失败
+       goto UPDATE_END;
+    }
+    else if(total_len>131072){
+        updateStatus = UPdATE_FILE_LEN_ERROR;
+        goto UPDATE_END;
+    }
+    g_ledStatus.ledM = LED_M_QUICK;
+    Flash_RangeErase(OTA_UPDATE_APP3_FLASH_START_ADDR, OTA_UPDATE_APP3_FLASH_SIZE); // 擦除APP3区
+
+    while(start_addr < total_len) {//每次读取512字节，写入到flash中
+        remain_len = total_len - start_addr;
+        read_len = (remain_len > 512)?512:remain_len;
+        p_content = AIR_HTTP_READ(start_addr, read_len);
+        data_dump("Update Data", p_content, read_len);
+        Flash_BufferWrite(OTA_UPDATE_APP3_FLASH_START_ADDR + start_addr, (uint32_t *)p_content, read_len);
+        start_addr += read_len;
+    }
+
+				
+     OSTimeDlyHMSM(0, 0, 0, 200, OS_OPT_TIME_DLY, &err);
+    crcVl = *(uint32_t*)(OTA_UPDATE_APP3_FLASH_START_ADDR+total_len-4); //CRC校验
+    fixChar = *(uint32_t*)(OTA_UPDATE_APP3_FLASH_START_ADDR+total_len-8); // 固定字符 WBJW
+    fileVer = *(uint32_t*)(OTA_UPDATE_APP3_FLASH_START_ADDR+total_len-12); // 固件信息
+    filelen =  *(uint32_t*)(OTA_UPDATE_APP3_FLASH_START_ADDR+total_len-20); // 文件总长度
+    addr = *(uint32_t*)(OTA_UPDATE_APP3_FLASH_START_ADDR+total_len-16); // 文件写入的地址
+
+    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,ENABLE);
+    CRC_ResetDR();
+    CRC_CalcBlockCRC((uint32_t*)OTA_UPDATE_APP3_FLASH_START_ADDR, (total_len -4)/4);
+    getcrc =  CRC_GetCRC();
+    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC,DISABLE);
+    if(getcrc!=crcVl) {
+        updateStatus = UPDATE_CRCERROR;
+        printf("update file crc error\r\n");// 升级文件crc校验错误
+        goto UPDATE_END;
+    }
+    if(version!=fileVer){
+        updateStatus = UPDATE_URL_FILE_TYPE_ERROR;
+        goto UPDATE_END;
+    }
+
+    printf("^^^^^^^^update file download success\r\n");
+
+    switch(p_msg->targetType){
+    case 0x0101: // 网关
+
+        break;
+    case 0x0201: // 采集器
+       
+        break;
+    case 0x0301: // 液位仪采集器
+        g_firmwareMsg.gatewayMsg.verMsg.gate_appVr3 = version;
+        fram_write_gateway_version(); // 将版本号写入到EEPROM中
+        fram_write_update_flag(); // 写入升级标志
+        send_data_dr2 = set_updata_state(UPDATE_DOWNLOADFILE_SUCCESS);
+        BKP_WriteBackupRegister(BKP_DR3, send_data_dr2); // 写入状态码
+        send_data_dr2 = set_updata_state(0x81);
+        BKP_WriteBackupRegister(BKP_DR2, send_data_dr2); // 写入标志码
+        BKP_WriteBackupRegister(BKP_DR5, UP_PROG_FROM_NET); // 升级的来源 0x22 来源来网络服务下发的
+        OSTimeDlyHMSM(0, 0, 2, 0, OS_OPT_TIME_DLY, &err);
+        printf("\r\n gateway update ======================\r\n");
+        NVIC_SystemReset();//复位//设备重新启动//写升级标志位，然后复位，进入bootloader程序中
+        break;
+    case 0x0401: // 显示器
+
+        break;
+    }
+		
+		return;
+UPDATE_END:
+    up_to_send_server_update_status(0x0301,downlink_config.gateway_id,p_msg->taskNo,updateStatus);
+
+    g_runData.bUpdate = 0;
+    g_updateProg.updateProgFrom = UPDATE_PROG_NULL;
+
+}
+/*--------------------------------------------------------------------------------
+ *  升级重传 或是读取升级状态
+ * --------------------------------------------------------------------------------*/
+void gateway_update_collect_status(void)
+{
+   
+}
+/*---------------------------------------------------------------------------------
+ *  网关自己升级，重新启动后，自动上报服务器升级的状态
+ * ---------------------------------------------------------------------------------*/
+void gateway_reset_send_update_status(void)
+{
+    uint16_t taskNo = 0;
+
+    if((g_runData.bResetUpdate == 1) && (air.State.MQTT_State==1)){
+        taskNo = BKP_ReadBackupRegister(BKP_DR4);
+        up_to_send_server_update_status(0x0301,downlink_config.gateway_id,taskNo,g_runData.bsendUpdateStatus);
+
+         g_runData.bResetUpdate = 0;
+    }
+}
+/*-------------------------------------------------------------
+ *  排序
+ * -------------------------------------------------------------*/
+void sort(void)
+{
+    int i = 0;
+    int j = 0;
+    int tmp = 0;
+    int m = g_updateProg.num;
+
+    for (i = 0; i<m - 1; i++)
+    {
+        for (j = 0; j < m - i - 1; j++)
+        {
+            if (g_updateProg.sn[j]>g_updateProg.sn[j + 1])
+            {
+                tmp = g_updateProg.sn[j + 1];
+                g_updateProg.sn[j + 1] = g_updateProg.sn[j];
+                g_updateProg.sn[j] = tmp;
+
+                tmp = g_updateProg.appVr[j + 1];
+                g_updateProg.appVr[j + 1] = g_updateProg.appVr[j];
+                g_updateProg.appVr[j] = tmp;
+
+                tmp = g_updateProg.status[j + 1];
+                g_updateProg.status[j + 1] = g_updateProg.status[j];
+                g_updateProg.status[j] = tmp;
+            }
+        }
+    }
+}
+
+/*--------------------------------------------------------------------------------
+ *  升级重传 或是读取升级状态 (网关升级网关时用到)
+ * --------------------------------------------------------------------------------*/
+void gateway_update_gateway_status(void)
+{
+    uint8_t flag = 0,i=0;
+    uint8_t num = 0;
+    OS_ERR  err;
+    if(g_runData.bUpdate != 2 ) return;
+    if(g_runData.updateDeviceTyp!= 0x0301) return;
+    if((TickCounter - g_runData.startUpdateTotalTime)< UPDATE_COLLECT_TOTALTIME){
+        if((g_runData.repeatUpdateTime!=0) && ((TickCounter - g_runData.repeatUpdateTime) > UPDATE_REPEAT_TIME)){ // 2s内没有收到重传指令
+            g_runData.readUpdateStatusTime = TickCounter; // 开始延时5s
+            g_runData.repeatUpdateTime = 0;
+        }
+        if((g_runData.readUpdateStatusTime!=0) && ((TickCounter-g_runData.readUpdateStatusTime)>UPDATE_READSTATUS_TIME_GATEWAY)){
+            flag = 1;
+            g_runData.readUpdateStatusTime = 0;
+        }
+    }
+    else { // 升级总时间超时
+        flag = 1;
+    }
+    if(flag == 1){ // 读取采集器的升级状态
+        g_runData.bUpdate = 0;
+        flag = 0;
+        //g_runData.bsendUpdateStatus = 2;
+        g_ledStatus.ledM = LED_M_LOW;
+        g_ledStatus.led16.status = g_ledStatus.collNum;
+        g_runData.bUpdateHost = 0;
+        printf("\r\n update finish read update status\r\n");
+        sort();
+        for(i=0;i<g_updateProg.num;i++){
+            printf("sn = %010u, appVr = 0x%08x, status = %d\r\n",g_updateProg.sn[i],g_updateProg.appVr[i],g_updateProg.status[i]);
+        }
+        g_updateProg.updateProgFrom = UPDATE_PROG_NULL;
+
+    }
+}
+
+/* -------------------------------------------------------------
+ *  网关升级网关
+ * -------------------------------------------------------------*/
+void gateway_update_gateway_proc(void)
+{
+	OS_ERR  err;
+	
+    uint32_t total_len = 0,total_crc = 0;
+    uint8_t i = 0;
+    update_msg_format p_update;
+
+    g_updateProg.updateProgFrom = UPDATE_PROG_FROM_GATEWAY;
+    g_runData.bUpdate = 1;
+    total_len = Flash_DatalenRead(OTA_UPDATE_APP1_FLASH_START_ADDR,OTA_UPDATE_APP3_FLASH_SIZE);
+    printf("-----------------total_len = %d",total_len);
+
+    p_update.rcv_device_type = 0x0301;// 设备类型
+    p_update.rcv_device_id = 0xFFFFFFFF;
+    p_update.des_device_type = 0x0301;// 设备类型
+    p_update.des_device_id = 0xFFFFFFFF;
+    p_update.update_version = g_firmwareMsg.gatewayMsg.verMsg.gate_appVr; // 升级版本号
+    g_runData.updateDeviceTyp = 0x0101;
+    g_runData.bUpdateHost = 1;
+    g_updateProg.num = 0;
+    for(i=0;i<64;i++) {
+        g_updateProg.sn[i] = 0x00000000;
+        g_updateProg.appVr[i] = 0x00000000;
+        g_updateProg.status[i] = 0x00000000;
+    }
+    lora_gw_ota_info_Init(&p_update, total_len, total_crc);
+    for(i = 0;i < 5;i++) {
+        lora_gw_ota_start(&sys_net);
+        OSTimeDlyHMSM(0, 0, 2, 0, OS_OPT_TIME_DLY, &err);
+    }
+    OSTimeDlyHMSM(0, 0, 1, 0, OS_OPT_TIME_DLY, &err);
+    lora_gw_ota_continues(&sys_net,OTA_UPDATE_APP1_FLASH_START_ADDR);
+    g_runData.bUpdate = 2;
+    g_runData.startUpdateTotalTime = TickCounter;
+    g_runData.repeatUpdateTime = TickCounter;
+    g_runData.readUpdateStatusTime = 0;
+    printf("\r\n continue update finish \r\n");
+//    g_runData.bUpdate = 0;
+}
+/*-------------------------------------------------------------------------------
+ *  升级成功后，主设备 接收升级的状态
+ * --------------------------------------------------------------------------------*/
+void gateway_update_status_rcv(gateway_collect_com_t *data, uint32_t len)
+{
+    uint8_t i = 0;
+	OS_ERR      err;
+    ota_updatestatus_up_t *msg = (ota_updatestatus_up_t *)data->taxinfo.info;
+
+    if(msg->des_device_type == 0x0201) {
+        g_runData.repeatUpdateTime = TickCounter;
+        g_runData.readUpdateStatusTime = 0;
+        printf("^^^^^^^rcv type = %04x  sn = %08x app = %08x, status = %d\r\n",msg->des_device_type, msg->des_device_id,msg->des_device_appVr,msg->status);
+        if(g_updateProg.rec0x16 == 0x01){
+            // 上报升级成功指令
+            g_updateProg.rec0x16 = 0x00;
+            g_runData.bUpdate = 0x00;
+            OSTmrStop(&g_updateProg.update_total_time, OS_OPT_TMR_NONE, NULL, &err);
+        }
+        return;
+    }
+    else if(msg->des_device_type == 0x0101) {
+        printf("^^^^^^^rcv sn = %08x app = %08x, status = %d\r\n",msg->des_device_id,msg->des_device_appVr,msg->status);
+
+        for(i=0;i<g_updateProg.num + 1;i++){
+            if(g_updateProg.sn[i] == 0x00000000){
+                g_updateProg.sn[i] = msg->des_device_id;
+                g_updateProg.appVr[i] = msg->des_device_appVr;
+                g_updateProg.status[i] = msg->status;
+                g_updateProg.num++;
+                break;
+            }
+            else {
+                if(g_updateProg.sn[i] == msg->des_device_id) break;
+            }
+        }
+
+        g_runData.repeatUpdateTime = TickCounter;
+        g_runData.readUpdateStatusTime = 0;
+    }
+
+
+}
+/*------------------------------------------------------------------------------------
+ *  升级成功后， 从设备 上报自己的升级状态
+ * -----------------------------------------------------------------------------------*/
+void gateway_update_status_send(system_network_t *p_sys_net)
+{
+    uint16_t data = 0,crc = 0;
+    uint32_t a = 0;
+    OS_ERR  err;
+
+    gateway_collect_com_t msg;
+    ota_updatestatus_up_t *p_ota = (ota_updatestatus_up_t *)msg.taxinfo.info;
+
+    if(g_runData.bUpdateHost == 1 ) return;
+    if(g_runData.bResetUpdate ==0 ) return;
+    if(g_updateProg.num >=3){
+        g_runData.bResetUpdate = 0;
+        return;
+    }
+    if (!(timeout_isOut(&g_updateProg.upStatusOut)))  return;
+
+    p_ota->rcv_device_type = 0x0101;
+    p_ota->rcv_device_id = downlink_config.gateway_id;
+    p_ota->des_device_type = 0x0101;
+    p_ota->des_device_id = downlink_config.gateway_id;
+    p_ota->des_device_bootVr = g_firmwareMsg.gatewayMsg.verMsg.gate_bootloaderVr;
+    p_ota->des_device_appVr = g_firmwareMsg.gatewayMsg.verMsg.gate_appVr ;
+    p_ota->status = g_runData.bsendUpdateStatus;
+    p_ota->reserve = 0x00000000;
+
+    collect_msg_frame_fill(&msg, 0x23, sizeof(ota_updatestatus_up_t)+2);
+
+    crc = _crc16_get((uint8_t *)&msg,msg.len + GATE_COLL_HEAD_LEN -2 );
+
+    msg.taxinfo.info[msg.len -2] = crc&0xff;
+    msg.taxinfo.info[msg.len - 1] = (crc>>8)&0xff;
+
+    if(g_updateProg.num == 0) {
+        srand(TickCounter);
+        a = rand() % 233+200;
+        printf("   a = %d\r\n",a);
+        OSTimeDlyHMSM(0, 0, 0, 300+a, OS_OPT_TIME_DLY, &err);
+    }
+
+    data_dump("send update status ", (uint8_t *)&msg, msg.len + 12);
+    p_sys_net->downlink_send((char *)&msg, GATE_COLL_HEAD_LEN + msg.len);
+    g_updateProg.num++; // 发送的次数
+   // p_sys_net->workstate = DEV_WORK_STATE_UPDATING;
+
+}
+void update_total_timer(void *p_tmr, void *p_arg)
+{
+    OS_ERR  err;
+
+   g_updateProg.rec0x16 = 0x00;
+   g_runData.bUpdate = 0x00;
+   printf("rcv 0x16, update timeout\r\n");
+
+   OSTmrStop(&g_updateProg.update_total_time, OS_OPT_TMR_NONE, NULL, &err);
+
+}
+/*------------------------------------------------------------------------------------
+ *  连接器版本同步
+ * -----------------------------------------------------------------------------------*/
+void gateway_send_update_collect_up_collect(system_network_t *p_sys_net,uint8_t *data,uint16_t len)
+{
+    uint16_t crc = 0;
+    uint32_t a = 0;
+    OS_ERR  err;
+
+    gateway_collect_com_t msg;
+    //ota_lineoffupdate_coll_t *p_ota = (ota_lineoffupdate_coll_t *)msg.taxinfo.info;
+
+    g_updateProg.rec0x16 = 0x01;
+    g_runData.bUpdate = 0x01;
+
+    memcpy(msg.taxinfo.info,data,len);
+
+
+    collect_msg_frame_fill(&msg, 0x16, sizeof(ota_lineoffupdate_coll_t)+2);
+
+    crc = _crc16_get((uint8_t *)&msg,msg.len + GATE_COLL_HEAD_LEN -2 );
+
+    msg.taxinfo.info[msg.len -2] = crc&0xff;
+    msg.taxinfo.info[msg.len - 1] = (crc>>8)&0xff;
+
+
+    data_dump("send update status ", (uint8_t *)&msg, msg.len + 12);
+    p_sys_net->downlink_send((char *)&msg, GATE_COLL_HEAD_LEN + msg.len);
+
+    // p_sys_net->workstate = DEV_WORK_STATE_UPDATING;
+
+    OSTmrCreate(&g_updateProg.update_total_time, "updateTotal_tmr", UPDATE_TOTAL_PERIOD, UPDATE_TOTAL_PERIOD, OS_OPT_TMR_PERIODIC, update_total_timer, NULL, &err);
+    OSTmrStart(&g_updateProg.update_total_time, &err);
+    printf("0x16 update total timer start\r\n");
+}
+
+void net_queue_insert(char *p_msg, uint32_t msg_len)
+{
+	OS_ERR      err;
+	
+	OSSemPend(&sys_net.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+	OS_QPost(&sys_net.net_q, p_msg, msg_len, OS_OPT_POST_FIFO, 0, &err);
+	OSSemPost(&sys_net.sem, OS_OPT_POST_ALL, &err);
+	//printf("net_queue_insert %p %d\r\n", p_msg, msg_len);
+}
+
+void * net_queue_mem_calloc(void)
+{
+	OS_ERR      err;
+	void * p_msg = NULL;
+
+	OSSemPend(&sys_net.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+	if((sys_net.workstate == DEV_WORK_STATE_UPDATING)||
+		(sys_net.workstate == DEV_WORK_STATE_ONLOOKER)) {
+		OSSemPost(&sys_net.sem, OS_OPT_POST_ALL, &err);
+		return p_msg;
+	}
+	p_msg = OSMemGet(&sys_net.net_m, &err);
+	OSSemPost(&sys_net.sem, OS_OPT_POST_ALL, &err);
+	return p_msg;
+}
+
+void * net_queue_mem_calloc_must(void)
+{
+	OS_ERR      err;
+	void * p_msg = NULL;
+
+	OSSemPend(&sys_net.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+	p_msg = OSMemGet(&sys_net.net_m, &err);
+	OSSemPost(&sys_net.sem, OS_OPT_POST_ALL, &err);
+	return p_msg;
+}
+
+int net_queue_mem_free(void * p_msg)
+{
+	OS_ERR      err;
+	
+	OSSemPend(&sys_net.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+	OSMemPut(&sys_net.net_m, p_msg, &err);
+	OSSemPost(&sys_net.sem, OS_OPT_POST_ALL, &err);
+	return err;
+}
+void collect_msg_frame_fill(gateway_collect_com_t *p_msg,uint8_t msg_type,uint16_t len)
+{
+    p_msg->frame_header = 0xfefe;
+    p_msg->type = msg_type;
+    p_msg->proto_ver = 0x01;
+    p_msg->seq_no = sys_net.seq_no++;
+    p_msg->len = len;
+    p_msg->secondType = 0;
+	
+//    CRC_ResetDR();
+//    CRC_CalcBlockCRC((uint32_t*)p_msg, GATE_COLL_HEAD_LEN + len);
+//    p_msg->fcs = CRC_GetCRC()&0xffff;
+
+    return ;
+}
+void net_msg_frame_fill(gateway_collect_com_t *p_msg, uint8_t msg_type, uint16_t len)
+{
+        static uint32_t msg_no = 0;
+        uint16_t crc;
+        p_msg->frame_header = 0xfefe;
+        p_msg->proto_ver = 0x01;
+        p_msg->seq_no = msg_no;
+        p_msg->type = msg_type;
+        p_msg->secondType = 0x00;
+        p_msg->len = len+2;// 后面加两个字节的CRC
+
+        crc = _crc16_get((uint8_t *)p_msg,p_msg->len + GATE_COLL_HEAD_LEN -2 );
+
+        p_msg->taxinfo.info[p_msg->len -2] = crc&0xff;
+        p_msg->taxinfo.info[p_msg->len - 1] = (crc>>8)&0xff;
+
+       // data_dump("send repeat updata", (uint8_t *)p_msg, p_msg->len + 12);
+
+        return ;
+}
+
+extern volatile  uint32_t TickCounter;
+void net_timer_proc(void *p_tmr, void *p_arg)
+{
+//	inner_msg_format_t *p_msg = NULL;
+
+//	p_msg = (inner_msg_format_t *)net_queue_mem_calloc();
+//	p_msg->frame_header = 0xfefe;
+//	p_msg->type = net_msg_type_timer;
+//	net_queue_insert((char *)p_msg, sizeof(inner_msg_format_t));
+//	
+//	printf("net_timer_proc %d!!!\r\n", TickCounter);
+}
+
+extern void lora_send(char *tx_data, uint32_t tx_len);
+void svc_init(u32 dev_type, u32 dev_id)
+{
+	OS_ERR err;
+//	printf("dev_type:%d\n",dev_type);
+	switch(dev_type) {
+		case DEV_TYPE_COLLECT_STATION:// 采集器
+			sys_net.uplink_send = lora_send;
+//			tax_init();
+			break;
+		case DEV_TYPE_OILTANK_STATION: // 油罐车
+			sys_net.uplink_send = lora_send; 
+//			oiltank_init();
+			break;
+		case DEV_TYPE_GATEWAY: // 网关设备
+			sys_net.net_hdl = uplink_net_init((char*)g_upLinkTopic);
+			sys_net.uplink_send = uplink_net_send; //上传数据的函数指针 4G 
+      sys_net.downlink_send = lora_send; // 下发数据的函数指针 lora
+			break;
+		default:
+			printf("dev_type = %d error !!!\r\n", dev_type);
+			break;
+	}
+	device_init(dev_type, dev_id);	
+}
+
+//void net_msg_recv(void)
+//{
+//	int len = 0;
+//	char *str;
+//	char *msg = NULL;
+//	inner_msg_format_t *p_msg = NULL;
+//	OS_ERR      err;	
+//	
+//	memset(sys_net.str, 0, sizeof(sys_net.str));	
+//	len = Module_Blocking_Read(sys_net.str, 0);
+//	if(len) {
+//		str = strstr(sys_net.str, "byte,");
+//		p_msg = (inner_msg_format_t *)(str + 5);
+//		if(str) {
+//			/* 接受消息, 发往net_proc模块统一处理 */
+//			msg = (char *)net_queue_mem_calloc();	
+//			if(msg) {
+//				memcpy(msg, p_msg, p_msg->len + FRAME_HEADER_LEN);		
+//				OS_QPost(&sys_net.net_q, msg, p_msg->len + FRAME_HEADER_LEN, OS_OPT_POST_FIFO, 0, &err);
+//			}
+
+//			data_dump("NET RECB", (uint8_t *)p_msg, p_msg->len + FRAME_HEADER_LEN);
+//		}
+//	}	
+//}
+
+void svc_proc(uint32_t dev_type, uint32_t dev_id)
+{
+    OS_ERR      err;
+
+    if((downlink_config.gateway_id==0x00000000) || (downlink_config.gateway_id == 0xFFFFFFFF)) return;
+    if(g_ptTest.bTestStart == PT_ON ) return;
+    dev_type = DEV_TYPE_GATEWAY;
+    svc_init(dev_type, dev_id);
+
+    timeout_setValue(&g_timeOut,3*60000); // 十分钟读取一次60*1000*10
+    timeout_start(&g_timeOut);
+    timeout_setValue(&g_uart4Time,200);//100ms
+    timeout_setValue(&g_uart5Time,200);//100ms
+    while(1) {
+
+        if(((g_runData.bUpdate!=0) && (g_updateProg.updateProgFrom==UPDATE_PROG_FROM_GATEWAY)) || (g_runData.bResetUpdate==2)) {
+               gateway_update_gateway_status();
+               gateway_update_status_send(&sys_net);
+               goto END_DELAY;
+           }
+
+        oiltank_operation(0);
+END_DELAY:
+        OSTimeDlyHMSM(0, 0, 0, 5, OS_OPT_TIME_DLY, &err);
+    }
+}
+
+/*******************************/
+void net_queue_proc_test(void)
+{
+    OS_ERR      err;
+    sverMsgHeader *p_msg;
+    OS_MSG_SIZE msg_len;
+    uint8_t type,type1 = 0;
+
+   
+    //printf("net_queue_proc 1111\r\n");
+    OSSemPend(&sys_net.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+    p_msg = (sverMsgHeader *)OSQPend(&sys_net.net_q, 0, OS_OPT_PEND_NON_BLOCKING, &msg_len, NULL, &err);	/* blocking. */
+    OSSemPost(&sys_net.sem, OS_OPT_POST_ALL, &err);
+    type = (p_msg->msgtypeSecd>>8)&0xFF;
+    if(p_msg&&msg_len)
+    {
+        if(type == TAX_UPLINK_TYPE)
+        {
+            set_led_status(3,1);
+            gw_net_send((char *)p_msg, msg_len);	 //向服务器端发送消息
+            printf("\r\n mqtt send tax end type = %d, cmd = %x\r\n",p_msg->msgtypeFirst,p_msg->msgtypeSecd);
+            set_led_status(3,0);
+        }
+        else if(type == DOWNLINK_CONFIG_TYPE)
+        {
+            set_led_status(2,1);
+            downlink_gateway_analyze((uint8_t *)p_msg, msg_len); //接收服务器端的消息
+            set_led_status(2,0);
+
+        }
+        net_queue_mem_free(p_msg);
+    }
+}
+/*******************************/
+
+void net_proc(void)
+{
+	OS_ERR      err;
+
+	memset(&sys_net, 0, sizeof(sys_net));
+
+        OSSemCreate(&sys_net.sem, "net_sem", 1, &err);
+        OSQCreate(&sys_net.net_q, "net_queue", 4, &err);//创建网络消息处理队列
+        OSMemCreate(&sys_net.net_m, "net_memory", sys_net.memory, 4, 1024, &err);//创建内存管理池
+
+        printf("net_proc finish !!!\r\n");
+
+	while(sys_net.dev_type == 0) {
+		sys_net.dev_type = device_type_get(); //
+		OSTimeDlyHMSM(0, 0, 1, 0, OS_OPT_TIME_DLY, &err);
+	}
+	sys_net.workstate = 0;
+
+	g_runData.bInitNetProc = 1;
+	while(1) {
+
+        if(g_ptTest.bTestStart == PT_ON) {
+            OSTimeDlyHMSM(0, 0, 0, 5, OS_OPT_TIME_DLY, &err);
+            continue;
+        }
+        if(sys_net.dev_type == DEV_TYPE_GATEWAY)
+        {
+                if(sys_net.net_hdl) {
+                        net_msg_recv1();
+                }
+        }
+
+        net_queue_proc_test();
+        OSTimeDlyHMSM(0, 0, 0, 5, OS_OPT_TIME_DLY, &err);
+	}
+}
+
+//void net_msg_recv_test(void)
+//{
+//	int len = 0;
+//	char *str;
+//	char *msg = NULL;
+//	inner_msg_format_t *p_msg = NULL;
+//	OS_ERR      err;	
+//	
+//	memset(sys_net.str, 0, sizeof(sys_net.str));	
+//	len = Module_Blocking_Read(sys_net.str, 0);
+//	if(len) {
+//		str = strstr(sys_net.str, "byte,");
+//		p_msg = (inner_msg_format_t *)(str + 5);
+//		if(str) {
+//			/* 接受消息, 发往net_proc模块统一处理 */
+//			msg = (char *)net_queue_mem_calloc();	
+//			if(msg) {
+//				memcpy(msg, p_msg, p_msg->len + FRAME_HEADER_LEN);		
+//				OS_QPost(&sys_net.net_q, msg, p_msg->len + FRAME_HEADER_LEN, OS_OPT_POST_FIFO, 0, &err);
+//			}
+
+//			data_dump("NET RECB", (uint8_t *)p_msg, p_msg->len + FRAME_HEADER_LEN);
+//		}
+//	}	
+//}

APP/network_mgr/net_proc.h

@@ -0,0 +1,269 @@
+#ifndef _NET_PROC_H_
+#define _NET_PROC_H_
+#include "stm32f10x.h"
+//#include "os.h"
+#include "includes.h"
+#include "device.h"
+#include "gateway.h"
+//#include "net_proc.h"
+#include "../dev_mgr/taxctrl/tax_ctrl.h"
+//#include "oiltank.h"
+//#include "net_ctrl.h"
+#include "../network/downlink.h"
+#include "../network/uplink.h"
+#include "net_ctrl.h"
+#include "../gateway_collect/gateway_collect.h"
+
+
+#define UPDATE_TOTAL_PERIOD (10*60)//(5*60) //(500*10)//*60) // 1为1S， 5为5S 5*60：5分钟
+
+
+#define UPDATE_EACH_TIME 300
+extern uint8_t RadioRxPayload[255];
+
+enum {
+    UP_PROG_FROM_NET = 0x22, // 来源来网络
+    UP_PROG_FROM_GAT = 0x44, //来源来网关
+};
+enum { // 升级结果类型
+    UPDATE_RECEIVE_UPDATEFLAG = 0x11, // URL的地址与长度不匹配
+    UPDATE_SAMEVERSION, // 和当前版本相同
+    UPDATE_FAILE_NOCOLLECT, // 此采集器不在本网关下
+    UPDATE_DOWNLOADFILE_FAILED, //文件下载失败,即文件大小小于2个字节
+    UPDATE_HTTP_ERROR,  //HTTP返回错误码
+    UPDATE_DOWNLOADFILE_SUCCESS, // 文件下载成功
+    UPDATE_CRCERROR, // 文件包中的CRC与实际不符
+    UPDATE_URL_FILE_TYPE_ERROR, // URL中的文件信息与文件包中的信息不一致
+    UPDATE_DEVICETYPEERROR, // 升级设备类型不匹配
+    UPdATE_FILE_LEN_ERROR,  // 升级文件长度超过128个字节
+    UPDATE_SUCCESS, // 升级成功
+    UPDATE_RETURN_SUCESS, // 回退
+//    UPDATE_SUCESS, // 升级程序成功
+//    UPDATE_TYPEERROR, // 升级类型不匹配 当前升级文件不是网关的，或不是本采集器的
+//    UPDATE_FIXCHARERROR, // 文件包中的固定字符错误
+//    UPDATE_TOTALLENERROR, // 文件包中的长度与实际长度不对应该
+//    UPDATE_FILEVERSION, // 文件包中的版本和当前文件名中的版本不一致
+//    UPDATE_FAILED , // 升级失败
+//    UPDATE_UPDATEING, // 升级中
+//    UPDATE_FINISH, // 升级完成
+};
+
+typedef enum net_msg_type {
+	/* 以下为外部交互信息 */
+	/* uplink, 设备侧 ---> 后端服务器 */
+	net_msg_type_none,
+	net_msg_type_lot = 1,
+	net_msg_type_trans = 2,
+	net_msg_type_oiltank = 3,
+	net_msg_type_gps = 4,
+	net_msg_type_gateway = 5,
+	net_msg_type_log = 6,
+	net_msg_type_debug = 7,
+	
+	/* downlink 后端服务器 ----> 设备侧 */
+	net_msg_type_rsv = 0x80,
+	net_msg_type_config = 0x81,
+	net_msg_type_update = 0x82,
+	net_msg_type_chnbind = 0x83,
+	net_msg_type_commnd = 0x84,
+	net_msg_type_reboot = 0x85,
+
+	/* 以下为内部交互信息，通过内部lora局域网交互升级包 */
+	net_msg_type_timer,
+
+	/* Gateway ----> Node */
+	net_msg_type_update_start = 0x13,
+	net_msg_type_update_continues = 0x14,
+	net_msg_type_update_retransmit_rsp = 0x15,
+	net_msg_type_update_ack_status = 0x16,	
+
+	/* Node ---->  Gateway */	
+	net_msg_type_update_retransmit_req = 0x22,
+	net_msg_type_update_status = 0x21,		
+
+	/* 网关绑定相关 */
+	net_msg_type_bind_req = 0x40,
+	net_msg_type_bind_rsp = 0x41,
+	net_msg_type_node_echo = 0x42,
+	net_msg_type_gw_echo = 0x43,
+} net_msg_type;
+
+typedef struct _update_msg_format {
+        uint16_t rcv_device_type; // 接收设备的类型
+        uint32_t rcv_device_id; //接收设备的SN
+        uint16_t des_device_type;//升级设备的类型
+        uint32_t des_device_id;//升级设备的SN
+        uint32_t update_version; //升级版本
+	char  url[128];
+}__attribute__((packed)) update_msg_format;
+
+// 0x13指令 下行，启动升级指令
+typedef struct _ota_start_info {   
+        uint16_t rcv_device_type;// 接收设备的类型 和SN
+        uint32_t  rcv_device_id;
+        uint16_t  des_device_type;//被升级设备的设备类型和id
+        uint32_t  des_device_id;
+        uint32_t  update_version;//升级包类型和版本；
+        uint32_t  total_bytes;//升级包总长度和校验码
+        uint16_t  time;  // 每包间隔时常
+
+}__attribute__((packed)) ota_start_info_t;
+// 0x14 0x15 指令 连续包 和重传包指令
+typedef struct _ota_continues_info { 
+    uint16_t rcv_device_type;// 接收设备的类型 和SN
+    uint32_t  rcv_device_id;
+    uint16_t  des_device_type;//被升级设备的设备类型和id
+    uint32_t  des_device_id;
+    uint16_t  total_pkgs; // 升级包的总个数
+    uint16_t  sub_pkg_id; //升级包的编号
+    uint8_t   sub_pkg_len; //每包的长度
+//	uint32_t *pkg_content;
+}__attribute__((packed)) ota_continues_info_t;
+// 0x22指令 请求重传包指令
+typedef struct _ota_retransmit_req {//重传请求
+        uint16_t  rcv_devict_type; //接收设备
+        uint32_t  rcv_device_id; //接收设备
+        uint16_t  repeat_sub_pkg_id;
+}__attribute__((packed)) ota_retransmit_req_t;
+
+// 0x16指令  网关通知采集器去升级采集器
+typedef struct _ota_lineoffupdate_collect {
+    uint16_t master_device_type; // 主设备类型
+    uint32_t master_device_sn;   // 主设备SN
+    uint16_t slave_device_type;  // 从设备类型
+    uint32_t slave_device_sn;    // 从设备 SN
+    uint16_t des_device_type;    // 升级目标设备类型
+    uint32_t des_device_sn;      // 升级目标设备SN
+    uint32_t reserve;            // 预留
+}__attribute__((packed)) ota_lineoffupdate_coll_t;
+
+// 0x23 指令，
+typedef struct _ota_updatestatus_up { // 升级状态上报
+    uint16_t rcv_device_type;// 接收设备的类型 和SN
+    uint32_t  rcv_device_id;
+    uint16_t  des_device_type;//被升级设备的设备类型和id
+    uint32_t  des_device_id;
+    uint32_t  des_device_bootVr; //被升级设备的bootloader版本
+    uint32_t  des_device_appVr;  // 被升级设备的APP版本
+    uint8_t   status; // 升级状态码
+    uint32_t  reserve;  // 预留
+}__attribute__((packed)) ota_updatestatus_up_t;
+
+typedef struct _inner_msg_format {
+	uint16_t frame_header;      //帧头
+	uint16_t fcs;               //帧校验
+	uint32_t seq_no;            //消息序列号
+	uint8_t  proto_ver;         //协议版本
+	uint8_t  type;              //消息类型
+	uint16_t len;               //消息长度
+	char 	 info[160];
+} inner_msg_format_t;
+
+
+
+typedef struct _server_msg_header {
+    uint16_t frame_header;      //帧头
+    uint8_t  proto_ver;         //协议版本 0x01
+    uint32_t seq_no;            //消息序列号
+    uint8_t  msgtypeFirst;      //一级消息类型 0x01:系统类  0x02:状态类 0x03:数据类 0x04:产测类
+    uint16_t msgtypeSecd;       // 二级消息类型
+    uint16_t len;               //消息长度
+    char 	 info[1024];
+}__attribute__((packed)) sverMsgHeader;
+
+
+
+
+#define		FRAME_HEADER_LEN		12
+
+#if 1
+//#define		MQTT_SERVER_IP			"8.142.80.166"
+#define		MQTT_SERVER_IP			"test-mqtt.cpyypt.cn"
+#else
+#define		MQTT_SERVER_IP			"39.100.96.218"
+#endif
+//#define		MQTT_SERVER_PORT		"1883"
+#define		MQTT_SERVER_PORT		"9000"
+
+//#define		MQTT_UPLINK_LOT_TOPIC		"LotDeviceInfo"  //LotDeviceInfo
+#define		MQTT_UPLINK_LOT_TOPIC		"cpyypt/up/"//"/mqtt/topic"  //LotDeviceInfo //"/mqtt/downlink"
+#define		MQTT_UPLINK_TRANS_TOPIC		"Transaction"
+#define		MQTT_UPLINK_TANK_TOPIC		"OilTankLevel"
+#define		MQTT_UPLINK_GPS_TOPIC		"GPSLocation"
+#define		MQTT_UPLINK_GATEWAY_TOPIC	"GWDeviceInfo" //
+#define		MQTT_UPLINK_LOG_TOPIC		"LogInfo"
+#define		MQTT_UPLINK_DEBUG_TOPIC		"DebugInfo"
+
+#define         MQTT_UPLINK_TOPIC  "cpyypt/up/"
+#define         MQTT_DNLINK_TOPIC  "cpyypt/down/"
+#define         MQTT_DNLINK_TOPIC_CASE "cpyypt/down/"
+
+#define 	TOPIC_GET_BY_MSGTYPE(msg_type)		((msg_type == net_msg_type_lot)?(MQTT_UPLINK_LOT_TOPIC):\
+				((msg_type == net_msg_type_trans)?(MQTT_UPLINK_TRANS_TOPIC):	\
+				((msg_type == net_msg_type_oiltank)?(MQTT_UPLINK_TANK_TOPIC):	\
+				((msg_type == net_msg_type_gps)?(MQTT_UPLINK_GPS_TOPIC):(MQTT_UPLINK_GATEWAY_TOPIC)))))
+
+typedef void (*net_init)(char *device_id);
+typedef void (*net_send)(char *buffer, uint32_t len);
+typedef uint32_t (*net_recv)(char *buffer, uint32_t *len);
+
+typedef struct _net_drv {
+	net_init init;
+	net_send send;
+	net_recv recv;
+} net_drv_t;
+
+typedef enum DEV_WORK_STATE
+{
+        DEV_WORK_STATE_NORMAL,
+        DEV_WORK_STATE_UPDATING,
+        DEV_WORK_STATE_UPDATE_RETRANSMIT,
+        DEV_WORK_STATE_ONLOOKER,                   //旁观者模式
+        DEV_WORK_STATE_OTA_BEGIN,                  //开始升级模式
+        DEV_WORK_STATE_OTA_CONTINUOUS,             //升级中连续收包模式
+        DEV_WORK_STATE_OTA_RETRANSMIT,             //升级中重传模式
+        DEV_WORK_STATE_OTA_UPGRADE_RCV_END,        //升级中升级包接收完成模式
+        DEV_WORK_STATE_PT,                         //产测模式
+        DEV_WORK_STATE_UNINIT,                     //出厂信息未初始化模式
+
+        DEV_WORK_STATE_MAX
+}DEV_WORK_STATE_T;
+
+typedef struct _system_network {
+        uint8_t memory[4][1024];		//必须4字节对齐
+	uint8_t dev_type;
+	uint8_t workstate;
+	OS_Q  net_q;
+	OS_SEM sem;
+	OS_MEM net_m;
+	OS_TMR net_tmr;
+	void * net_hdl; // mqtt是否初始化
+	net_send uplink_send; //4G 上传数据的函数指针
+	net_send downlink_send; //4G 下载数据的函数指针
+	uint32_t seq_no;
+	char str[1024];
+}system_network_t;
+
+
+extern system_network_t	sys_net;
+
+void NET_IMEI_ICCID_INFO_GET(char *imei, char *iccid);
+void net_queue_insert(char *p_msg, uint32_t msg_len);
+void * net_queue_mem_calloc(void);
+int net_queue_mem_free(void * p_msg);
+//void net_msg_frame_fill(gateway_collect_com_t *p_msg, uint8_t msg_type, uint16_t len);
+
+extern void close_tcp_mqtt(void);
+
+void svc_proc(uint32_t dev_type, uint32_t dev_id);
+void * net_queue_mem_calloc_must(void);
+//extern void collect_msg_frame_fill(gateway_collect_com_t *p_msg,uint8_t msg_type,uint16_t len);
+extern void gateway_update_proc(uint8_t *data,uint8_t msg_len);
+extern void gateway_update_collect_status(void);
+extern void gateway_reset_send_update_status(void);
+
+extern void uplink_net_send(char *buffer, uint32_t len);
+extern void * uplink_net_init(char *device_id) ;
+extern void gateway_update_gateway_proc(void);
+extern void gateway_update_gateway_status(void);
+#endif

APP/network_mgr/sx1268/HAL/HAL_SPI.c

@@ -0,0 +1,69 @@
+#include "HAL_SPI.h"
+#include "project_config.h"
+
+//SPI初始化(sx126x和sx127x使用的SPI配置相同的，可以统一初始化)
+uint8_t Spi1Init(void){
+	GPIO_InitTypeDef  GPIO_InitStructure;
+	SPI_InitTypeDef  SPI_InitStructure;
+
+	//初始化SPI
+	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);//SPI时钟使能
+	//初始化MISO,MOSI,SCK为推挽外设模式
+	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	    //使能指定端口时钟
+	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 //IO口速度为50MHz，这里不用传参，直接写死用最大速度50MHZ
+	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;	//片上外设推挽模式
+	GPIO_InitStructure.GPIO_Pin = RADIO_SCK_PIN|RADIO_MISO_PIN|RADIO_MOSI_PIN;
+	GPIO_Init(RADIO_SCK_PORT, &GPIO_InitStructure);	//初始化GPIO
+
+	//配置SPI
+	SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
+	SPI_InitStructure.SPI_Mode = SPI_Mode_Master;		//设置SPI工作模式:设置为主SPI
+	SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;		//设置SPI的数据大小:SPI发送接收8位帧结构
+	SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;		//设置时钟极性(串行同步时钟的空闲状态为高电平还是低电平)
+	SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;	//设置相位(串行同步时钟的第几个跳变沿（上升或下降）数据被采样)
+	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;		//NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:设置为软件控制(SSI控制)
+	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32;		//定义波特率预分频的值:波特率预分频值为256(256是最低,可以设置完成之后调整速度,如果速度过快导致通信失败再调小)
+	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;	//指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
+	SPI_InitStructure.SPI_CRCPolynomial = 7;	//CRC值计算的多项式(CRC校验相关)
+	SPI_Init(SPI1,&SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
+
+	SPI_Cmd(SPI1,ENABLE); //使能SPI外设
+	
+	//初始化NSS脚为输出高电平 RADIO_NSS_PIN		RADIO_NSS_PORT
+	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	    //使能指定端口时钟
+	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 //IO口速度为50MHz，这里不用传参，直接写死用最大速度50MHZ
+	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;	//推挽输出
+	GPIO_InitStructure.GPIO_Pin = RADIO_NSS_PIN;
+	GPIO_Init(RADIO_NSS_PORT, &GPIO_InitStructure);	//初始化GPIO
+	//GPIO_ResetBits(gpioObj->portIndex,gpioObj->pinIndex);	//输出低电平
+	GPIO_SetBits(RADIO_NSS_PORT,RADIO_NSS_PIN);	//输出高电平
+	
+	return 0;
+}
+
+//spi传输数据(返回值是接收到的数据)
+//参数：
+//     spiName	:需要通过哪个spi传输数据
+//     data		:要发送的数据
+//返回值：
+//       接收到的数据
+//注意：这里没有控制CS信号，需要自己控制（通过一个普通的GPIO控制就可以）
+uint8_t HALSpi1InOut(uint8_t data){
+	uint32_t retry=0;				 	
+	while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET){//检查指定的SPI标志位设置与否:发送缓存空标志位(缓冲区空了就可以拷贝数据了)
+		if((retry++)>2000){
+			//超时了
+			return 0xff;
+		}
+	}
+	SPI_I2S_SendData(SPI1, data); //通过外设SPIx发送一个数据
+	retry=0;
+
+	while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET){ //检查指定的SPI标志位设置与否:接受缓存非空标志位（非空了就表示接收数据完成了）
+		if((retry++)>2000){
+			//超时了
+			return 0xff;
+		}
+	}
+	return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据	
+}

APP/network_mgr/sx1268/HAL/HAL_SPI.h

@@ -0,0 +1,8 @@
+#ifndef __HAL_SPI_H__
+#define __HAL_SPI_H__
+#include "stm32f10x.h"
+
+uint8_t Spi1Init(void);
+uint8_t HALSpi1InOut(uint8_t data);
+
+#endif	//end of __HAL_SPI_H__

APP/network_mgr/sx1268/HAL/SX126xSTM32F103-board.c

@@ -0,0 +1,311 @@
+/*!
+ * \file      sx1262mbxcas-board.c
+ *
+ * \brief     Target board SX1262MBXCAS shield driver implementation
+ *
+ * \copyright Revised BSD License, see section \ref LICENSE.
+ *
+ * \code
+ *                ______                              _
+ *               / _____)             _              | |
+ *              ( (____  _____ ____ _| |_ _____  ____| |__
+ *               \____ \| ___ |    (_   _) ___ |/ ___)  _ \
+ *               _____) ) ____| | | || |_| ____( (___| | | |
+ *              (______/|_____)_|_|_| \__)_____)\____)_| |_|
+ *              (C)2013-2017 Semtech
+ *
+ * \endcode
+ *
+ * \author    Miguel Luis ( Semtech )
+ *
+ * \author    Gregory Cristian ( Semtech )
+ */
+#include <stdlib.h>
+#include "project_config.h"
+#include "delay.h"
+#include "radio.h"
+#include "sx126x-board.h"
+#include "HAL_SPI.h"
+#include "stdio.h"
+
+typedef struct __softTimer_s{
+	uint8_t isRun;		//0停止，1运行
+	uint32_t delayMs;	//定时器需要多长时间后唤醒
+	uint32_t startMs;	//定时器开始时间
+}SoftTimer_t;
+
+static DioIrqHandler *dio1IrqCallback=NULL;	//记录DIO1的回调函数句柄
+static uint32_t timer_count=0;
+static SoftTimer_t txTimerHandle,rxTimerHandle;
+
+/* 初始化sx126x需要用到的GPIO初始化，将 BUSY 引脚设置为输入模式
+ */
+void SX126xIoInit( void )
+{
+	uint8_t u8_ret=255;
+	GPIO_InitTypeDef  GPIO_InitStructure;
+
+	//初始化BUSY为上拉输入模式
+	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOE, ENABLE);	    //使能指定端口时钟
+	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 //IO口速度为50MHz，这里不用传参，直接写死用最大速度50MHZ
+	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;//上拉输入
+	GPIO_InitStructure.GPIO_Pin = RADIO_DIO4_BUSY_PIN;
+	GPIO_Init(RADIO_DIO4_BUSY_PORT, &GPIO_InitStructure);	//初始化GPIO
+	
+	//下面这几个引脚没用用到，设置为浮空输入模式
+	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;//浮空输入
+	
+	GPIO_InitStructure.GPIO_Pin = RADIO_DIO0_TXEN_PIN;
+	GPIO_Init(RADIO_DIO0_TXEN_PORT, &GPIO_InitStructure);	//初始化GPIO
+
+	GPIO_InitStructure.GPIO_Pin = RADIO_DIO2_PIN;
+	GPIO_Init(RADIO_DIO2_PORT, &GPIO_InitStructure);	//初始化GPIO
+	
+	GPIO_InitStructure.GPIO_Pin = RADIO_DIO3_PIN;
+	GPIO_Init(RADIO_DIO3_PORT, &GPIO_InitStructure);	//初始化GPIO
+	
+	GPIO_InitStructure.GPIO_Pin = RADIO_DIO5_RXEN_PIN;
+	GPIO_Init(RADIO_DIO5_RXEN_PORT, &GPIO_InitStructure);	//初始化GPIO
+	
+	u8_ret=Spi1Init();
+	if(u8_ret){
+		printf("spi1 init error\r\n");
+	}else{
+		printf("SX126xIoInit init sucess\r\n");
+	}
+}
+
+/* 初始化 DIO1
+ * 将DIO1设置为外部中断(上升沿触发)，并且回调函数为 dioIrq 函数原型 void RadioOnDioIrq( void* context )
+ */
+void SX126xIoIrqInit( DioIrqHandler dioIrq )
+{
+	GPIO_InitTypeDef  GPIO_InitStructure;
+	EXTI_InitTypeDef EXTI_InitStructure;
+ 	NVIC_InitTypeDef NVIC_InitStructure;
+	
+	dio1IrqCallback=dioIrq;
+	
+	//gpio(DIO1)初始化为下拉输入模式
+	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE|RCC_APB2Periph_GPIOB, ENABLE);	    //使能指定端口时钟
+	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 //IO口速度为50MHz，这里不用传参，直接写死用最大速度50MHZ
+	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPD;//下拉输入
+	GPIO_InitStructure.GPIO_Pin = RADIO_DIO1_PIN;
+	GPIO_Init(RADIO_DIO1_PORT, &GPIO_InitStructure);	//初始化GPIO
+	
+	//中断配置
+  RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);	//使能复用功能时钟
+	//GPIOE.2 中断线以及中断初始化配置   上升沿触发
+  GPIO_EXTILineConfig(GPIO_PortSourceGPIOE, GPIO_PinSource8);
+	EXTI_InitStructure.EXTI_Line=EXTI_Line8;
+	EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;	
+	EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;	//上升沿触发
+	EXTI_InitStructure.EXTI_LineCmd = ENABLE;
+	EXTI_Init(&EXTI_InitStructure);	 	//根据EXTI_InitStruct中指定的参数初始化外设EXTI寄存器
+
+	//设置中断优先级
+	NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;			//使能按键WK_UP所在的外部中断通道
+	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;	//抢占优先级2， 
+	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x03;					//子优先级3
+	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;								//使能外部中断通道
+	NVIC_Init(&NVIC_InitStructure);
+	EXTI_ClearITPendingBit(EXTI_Line8);  //清除LINE11上的中断标志位 
+}
+
+//在中断回调函数中回调 void SX126xIoIrqInit( DioIrqHandler dioIrq ) 中注册的 dioIrq 回调
+void EXTI9_5_IRQHandler(void){
+//	printf("enter irq\r\n");
+	if(GPIO_ReadInputDataBit(RADIO_DIO1_PORT,RADIO_DIO1_PIN)){
+//		printf("DIO1 irq\r\n");
+		if(NULL!=dio1IrqCallback){
+			dio1IrqCallback(NULL);
+		}
+		EXTI_ClearITPendingBit(EXTI_Line8);//清除中断标志位
+	}
+}
+
+void SX126xIoDeInit( void )
+{
+    //GPIO去初始化代码
+}
+
+//复位按键功能
+void SX126xReset( void )
+{
+	GPIO_InitTypeDef  GPIO_InitStructure;
+
+	SX126xDelayMs( 10 );
+	
+	//将RST输出低电平
+	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);	    //使能指定端口时钟
+	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 //IO口速度为50MHz，这里不用传参，直接写死用最大速度50MHZ
+	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;	//推挽输出
+	GPIO_InitStructure.GPIO_Pin = RADIO_nRESET_PIN;
+	GPIO_Init(RADIO_nRESET_PORT, &GPIO_InitStructure);	//初始化GPIO
+	GPIO_WriteBit( RADIO_nRESET_PORT, RADIO_nRESET_PIN,Bit_RESET);	//RST设为低电平输出
+	
+	SX126xDelayMs( 20 );
+	
+	//将RST设置为上拉输入模式
+	GPIO_WriteBit( RADIO_nRESET_PORT, RADIO_nRESET_PIN,Bit_SET);	//RST设为低电平输出
+	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
+	GPIO_Init(RADIO_nRESET_PORT, &GPIO_InitStructure);	//初始化GPIO
+	
+	SX126xDelayMs( 10 );
+}
+
+//读取Busy引脚电平状态
+void SX126xWaitOnBusy( void )
+{
+	uint32_t u32_count=0;
+	
+	while( GPIO_ReadInputDataBit(RADIO_DIO4_BUSY_PORT,RADIO_DIO4_BUSY_PIN) == 1 ){
+		if(u32_count++>1000){
+			printf("wait busy pin timeout\r\n");
+			u32_count=0;
+		}
+		SX126xDelayMs(1);
+	}
+}
+
+//设置SPI的NSS引脚电平，0低电平，非零高电平
+void SX126xSetNss(uint8_t lev ){
+	if(lev){
+		GPIO_SetBits(RADIO_NSS_PORT,RADIO_NSS_PIN);	//输出高电平
+	}else{
+		GPIO_ResetBits(RADIO_NSS_PORT,RADIO_NSS_PIN);	//输出低电平
+	}
+}
+
+//spi传输一个字节的数据
+uint8_t SX126xSpiInOut(uint8_t data){
+	return HALSpi1InOut(data);
+}
+
+//检查频率是否符合要求，如果不需要判断则可以直接返回true
+bool SX126xCheckRfFrequency( uint32_t frequency )
+{
+    // Implement check. Currently all frequencies are supported
+    return true;
+}
+
+//毫秒延时
+void SX126xDelayMs(uint32_t ms){
+	delay_ms(ms);
+}
+
+//tx/rx定时器操作
+
+//定时器3中断服务程序
+//tx定时结束需要回调 RadioOnTxTimeoutIrq
+//rx定时结束需要回调 RadioOnRxTimeoutIrq
+void TIM3_IRQHandler(void)   //TIM3中断
+{
+	uint32_t diffMs=0;
+	
+	if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET){
+		timer_count++;
+		TIM_ClearITPendingBit(TIM3, TIM_IT_Update  );  //清除TIMx更新中断标志
+		//printf("\r\n timer 3 IrqErrorCode_t\r\n");
+		//printf("timer_count=%d\r\n",timer_count);
+		
+		//处理tx定时器
+		if(txTimerHandle.isRun){
+			if(timer_count>=txTimerHandle.startMs){
+				diffMs=timer_count-txTimerHandle.startMs;
+			}else{//溢出了
+				diffMs=0xffffffff - txTimerHandle.startMs + timer_count;
+			}
+			if(diffMs>txTimerHandle.delayMs){
+				//计时结束
+				//printf("----------------- tx timer irq ---------------\r\n");
+				SX126xTxTimerStop();
+				txTimerHandle.startMs=timer_count;
+				RadioOnTxTimeoutIrq(NULL);	//tx定时结束需要回调 RadioOnTxTimeoutIrq
+			}
+		}
+		
+		//处理rx定时器
+		if(rxTimerHandle.isRun){
+			if(timer_count>=rxTimerHandle.startMs){
+				diffMs=timer_count-rxTimerHandle.startMs;
+			}else{//溢出了
+				diffMs=0xffffffff - rxTimerHandle.startMs + timer_count;
+			}
+			if(diffMs>rxTimerHandle.delayMs){
+				//计时结束
+				//printf("----------------- rx timer irq ---------------\r\n");
+				SX126xRxTimerStop();
+				rxTimerHandle.startMs=timer_count;
+				RadioOnRxTimeoutIrq(NULL);	//rx定时结束需要回调 RadioOnRxTimeoutIrq
+			}
+		}
+	}
+}
+
+//初始化定时器(这里用TIM3定时器模拟出了两个ms定时器)
+//tx定时结束需要回调 RadioOnTxTimeoutIrq
+//rx定时结束需要回调 RadioOnRxTimeoutIrq
+void SX126xTimerInit(void){
+	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
+	NVIC_InitTypeDef NVIC_InitStructure;
+
+	//使能TIM3
+	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); //时钟使能
+ 
+	//TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE ); //使能指定的TIM3中断,允许更新中断
+
+	//中断优先级NVIC设置
+	NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;  //TIM3中断
+	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  //先占优先级0级
+	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;  //从优先级3级
+	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
+	NVIC_Init(&NVIC_InitStructure);  //初始化NVIC寄存器
+	
+	//定时器TIM3初始化
+	TIM_TimeBaseStructure.TIM_Period = 10; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值	
+	TIM_TimeBaseStructure.TIM_Prescaler =SystemCoreClock/10000; //设置用来作为TIMx时钟频率除数的预分频值(1s10000次，也就是1次0.1ms)
+	TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
+	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
+	TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //根据指定的参数初始化TIMx的时间基数单位
+	
+	//关闭软件定时器
+	txTimerHandle.isRun=0;
+	rxTimerHandle.isRun=0;
+	
+	TIM_Cmd(TIM3, ENABLE);  //使能TIMx
+	TIM_ClearITPendingBit(TIM3, TIM_IT_Update  );  //清除TIMx更新中断标志
+	TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE ); //使能指定的TIM2中断,允许更新中断
+}
+
+void SX126xSetTxTimerValue(uint32_t nMs){
+	//printf("[%s()-%d]set timer out %d ms\r\n",__func__,__LINE__,nMs);
+	txTimerHandle.delayMs=nMs;
+}
+
+void SX126xTxTimerStart(void){
+	//printf("[%s()-%d]start timer\r\n",__func__,__LINE__);
+	txTimerHandle.startMs=timer_count;
+	txTimerHandle.isRun=1;
+}
+
+void SX126xTxTimerStop(void){
+	//printf("[%s()-%d]stop timer\r\n",__func__,__LINE__);
+	txTimerHandle.isRun=0;
+}
+
+void SX126xSetRxTimerValue(uint32_t nMs){
+	//printf("[%s()-%d]set timer out %d ms\r\n",__func__,__LINE__,nMs);
+	rxTimerHandle.delayMs=nMs;
+}
+
+void SX126xRxTimerStart(void){
+	//printf("[%s()-%d]start timer\r\n",__func__,__LINE__);
+	rxTimerHandle.startMs=timer_count;
+	rxTimerHandle.isRun=1;
+}
+
+void SX126xRxTimerStop(void){
+	//printf("[%s()-%d]stop timer\r\n",__func__,__LINE__);
+	rxTimerHandle.isRun=0;
+}

APP/network_mgr/sx1268/HAL/delay.c

@@ -0,0 +1,58 @@
+#include "delay.h"
+#include "stm32f10x_it.h"
+
+void delay_us(u32 nUs){
+	uint32_t i=0,j=0;
+	for(i=0;i<nUs;i++){
+		for(j=0;j<9;j++){
+			;
+		}
+	}
+}
+
+//¼òµ¥µÄÑÓʱº¯Êý
+void delay_ms(u16 nms)
+{
+	delay_us(nms*1000);
+} 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

APP/network_mgr/sx1268/HAL/delay.h

@@ -0,0 +1,37 @@
+#ifndef __DELAY_H
+#define __DELAY_H
+#include "stm32f10x.h"
+
+void delay_ms(u16 nms);
+void delay_us(u32 nus);
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

APP/network_mgr/sx1268/HAL/project_config.h

@@ -0,0 +1,57 @@
+#ifndef __PROJECT_CONFIG_H__
+#define __PROJECT_CONFIG_H__
+
+//基于semtech官网驱动移植
+//官网驱动网址 https://github.com/Lora-net/LoRaMac-node/tree/master/src/radio  下载日期 2021/2/3
+#define LORA_SOFT_VERSION	"sx126x driver for stm32f103 V0.0.0"
+
+//--------------------------------------------- 测试默认配置 ---------------------------------------------
+#define LORA_FRE																		486300000//470000000	// 收发频率
+#define LORA_TX_OUTPUT_POWER                        17        // 测试默认使用的发射功率，126x发射功率0~22dbm，127x发射功率2~20dbm
+#define LORA_BANDWIDTH                              1         // [0: 125 kHz,	测试默认使用的带宽，sx126x：[0: 125 kHz,1: 250 kHz,2: 500 kHz,3: Reserved]
+#define LORA_SPREADING_FACTOR                       7         // 测试默认使用的扩频因子范围7~12
+#define LORA_CODINGRATE                             2         // 测试默认使用的纠错编码率[1: 4/5,2: 4/6,3: 4/7,4: 4/8]
+#define LORA_PREAMBLE_LENGTH                        8         // 前导码长度
+#define LORA_SX126X_SYMBOL_TIMEOUT                  0         // Symbols(sx126x用到的是0,127x用到的是5)
+#define LORA_FIX_LENGTH_PAYLOAD_ON                  false			// 是否为固定长度包(暂时只是sx126x用到了)
+#define LORA_IQ_INVERSION_ON                        false			// 这个应该是设置是否翻转中断电平的(暂时只是sx126x用到了)
+#define LORA_RX_TIMEOUT_VALUE                       0
+
+/*!
+ * Board MCU pins definitions
+ */
+//SPI
+#define RADIO_NSS_PIN       GPIO_Pin_4
+#define RADIO_NSS_PORT      GPIOA
+#define RADIO_MOSI_PIN      GPIO_Pin_7
+#define RADIO_MOSI_PORT     GPIOA
+#define RADIO_MISO_PIN      GPIO_Pin_6
+#define RADIO_MISO_PORT     GPIOA
+#define RADIO_SCK_PIN       GPIO_Pin_5
+#define RADIO_SCK_PORT      GPIOA
+//RST复位脚
+#define RADIO_nRESET_PIN    GPIO_Pin_0
+#define RADIO_nRESET_PORT   GPIOB
+//DIO1 引脚
+#define RADIO_DIO1_PIN      GPIO_Pin_8
+#define RADIO_DIO1_PORT     GPIOE
+//BUSY 引脚
+#define RADIO_DIO4_BUSY_PIN      GPIO_Pin_4
+#define RADIO_DIO4_BUSY_PORT     GPIOC
+
+
+//下面这几个引脚没用用到，设置为浮空输入模式
+//TXEN
+#define RADIO_DIO0_TXEN_PIN      GPIO_Pin_1
+#define RADIO_DIO0_TXEN_PORT     GPIOB
+//DIO2
+#define RADIO_DIO2_PIN      GPIO_Pin_9
+#define RADIO_DIO2_PORT     GPIOE
+//DIO3
+#define RADIO_DIO3_PIN      GPIO_Pin_10
+#define RADIO_DIO3_PORT     GPIOE
+//RXEN
+#define RADIO_DIO5_RXEN_PIN      GPIO_Pin_5
+#define RADIO_DIO5_RXEN_PORT     GPIOC
+
+#endif // __PROJECT_CONFIG_H__

APP/network_mgr/sx1268/lora.c

@@ -0,0 +1,522 @@
+#include "../../../User/includes.h"
+#include "device.h"
+#include "net_proc.h"
+
+#include "radio.h"
+#include "project_config.h"
+#include "stdio.h"
+#include "stm32f10x_it.h"
+#include "delay.h"
+#include "string.h"
+#include "../../gateway_collect/gateway_collect.h"
+#include "../../globalDef.h"
+#include "lora.h"
+
+extern volatile uint32_t TickCounter;
+loraParam g_loraPa[4];
+#define RADIO_RX_TIMEOUT_VALUE		0
+//uint8_t cmpBuf[256] ;
+uint8_t lora_state = 0;
+OS_Q  lora_q;
+
+
+system_lora_t sys_loraTX;
+system_lora_t sys_loraRx;
+
+uint8_t g_loraCadStatus = 0;
+uint8_t g_loraCadCount = 0;
+uint32_t g_cadTick = 0;
+uint32_t g_cadTickTime = 0;
+/*!
+ * Radio events function pointer
+ * 这个是传参进入其他函数中了，所以用全局变量(局部变量使用完了内存释放可能导致异常)
+ */
+static RadioEvents_t RadioEventsObj;
+static void SX126xOnCadDone( bool channelActivityDetected );
+static void SX126xConfigureCad( RadioLoRaCadSymbols_t cadSymbolNum, uint8_t cadDetPeak, uint8_t cadDetMin , uint32_t cadTimeout);
+
+void * lora_queue_mem_calloc_must(void)
+{
+    OS_ERR      err;
+    void * p_msg = NULL;
+
+    OSSemPend(&sys_loraTX.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+    p_msg = OSMemGet(&sys_loraTX.lora_m, &err);
+  //  printf("\r\n~~~~~~~~~~~~~~~err = %d\r\n",err);
+    OSSemPost(&sys_loraTX.sem, OS_OPT_POST_ALL, &err);
+//	printf("\r\n~~~~~~~~~~~~~~~err = %d  end  \r\n",err);
+    return p_msg;
+}
+
+int lora_queue_mem_free(void * p_msg)
+{
+    OS_ERR      err;
+
+    OSSemPend(&sys_loraTX.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+    OSMemPut(&sys_loraTX.lora_m, p_msg, &err);
+    OSSemPost(&sys_loraTX.sem, OS_OPT_POST_ALL, &err);
+
+    return err;
+}
+
+void lora_queue_insert(char *p_msg, uint32_t msg_len)
+{
+    OS_ERR      err;
+
+    OSSemPend(&sys_loraTX.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+    OS_QPost(&sys_loraTX.lora_q, p_msg, msg_len, OS_OPT_POST_FIFO, 0, &err);
+    OSSemPost(&sys_loraTX.sem, OS_OPT_POST_ALL, &err);
+
+    //printf("net_queue_insert %p %d\r\n", p_msg, msg_len);
+}
+
+void * lora_queue_mem_calloc_mustRx(void)
+{
+    OS_ERR      err;
+    void * p_msg = NULL;
+
+    OSSemPend(&sys_loraRx.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+    p_msg = OSMemGet(&sys_loraRx.lora_m, &err);
+    OSSemPost(&sys_loraRx.sem, OS_OPT_POST_ALL, &err);
+    return p_msg;
+}
+
+int lora_queue_mem_freeRx(void * p_msg)
+{
+    OS_ERR      err;
+
+    OSSemPend(&sys_loraRx.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+    OSMemPut(&sys_loraRx.lora_m, p_msg, &err);
+    OSSemPost(&sys_loraRx.sem, OS_OPT_POST_ALL, &err);
+    return err;
+}
+
+void lora_queue_insertRx(char *p_msg, uint32_t msg_len)
+{
+    OS_ERR      err;
+
+    OSSemPend(&sys_loraRx.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+    OS_QPost(&sys_loraRx.lora_q, p_msg, msg_len, OS_OPT_POST_FIFO, 0, &err);
+    OSSemPost(&sys_loraRx.sem, OS_OPT_POST_ALL, &err);
+    //printf("net_queue_insert %p %d\r\n", p_msg, msg_len);
+}
+static void SX126xOnTxDone( void )
+{
+	//printf("TxDone\r\n");
+	Radio.Standby();
+	lora_state = lora_state_idle;
+  g_loraCadStatus = 0;
+
+	//Radio.Rx( RADIO_RX_TIMEOUT_VALUE );
+}
+/*lora数据接收 2021.11.08*/
+static void SX126xOnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr )
+{
+	OS_ERR      err;
+	
+//	inner_msg_format_t *p_msg = NULL;
+	char *p_msg = NULL;
+        // rssi:信号强度
+//	printf("RxDone size:%d <rssi:%d, snr:%d> \r\n",size, rssi, snr);	
+	Radio.Standby();
+//	p_msg = (gateway_collect_com_t *)payload;
+        g_runData.rssi_lora = rssi+1000;
+        p_msg = lora_queue_mem_calloc_mustRx();
+	if(p_msg) 
+	{
+            if(size) //和上次数据不同，数据有效
+            {
+               // data_dump("LORA Rxtx", (uint8_t *)payload, size);
+                memcpy(p_msg, payload, size);//&&memcmp(cmpBuf, payload, size)
+                lora_queue_insertRx((char *)p_msg, size);
+            } else {
+                lora_queue_mem_freeRx(p_msg);
+            }
+  //              printf("lora rcv\r\n");
+
+	}
+	g_loraCadStatus = 0;
+//	OS_QPost(&lora_q, payload, size, OS_OPT_POST_FIFO, 0, &err);
+//	data_dump("LORA Rx", payload, size);
+#if 0
+	if(((p_msg->type <= net_msg_type_debug)||
+		(p_msg->type == net_msg_type_bind_req)||
+		(p_msg->type == net_msg_type_node_echo))&&
+		(device_type_get() != DEV_TYPE_GATEWAY)) {/* 节点丢弃 */
+		//drop packets;
+	} else if(((p_msg->type == net_msg_type_bind_rsp)||
+		(p_msg->type == net_msg_type_gw_echo))&&
+		(device_type_get() == DEV_TYPE_GATEWAY)) {
+		//drop packets;
+	} else {
+		data_dump("LORA Rx", payload, size);
+		//Radio.Rx( RADIO_RX_TIMEOUT_VALUE );
+		if(((p_msg->type&0x10) == 0x10)||
+			((p_msg->type&0x20) == 0x20)) {
+			p_msg = (inner_msg_format_t *)net_queue_mem_calloc_must();
+		} else {
+			p_msg = (inner_msg_format_t *)net_queue_mem_calloc();
+		}
+		if(p_msg) {
+			if(size) {//和上次数据不同，数据有效
+//				data_dump("LORA Rxtx", (uint8_t *)p_msg, size);
+				memcpy(p_msg, payload, size);//&&memcmp(cmpBuf, payload, size)
+				net_queue_insert((char *)p_msg, size);
+			} else {
+				net_queue_mem_free(p_msg);
+			}
+		}
+	}
+#endif
+	lora_state = lora_state_idle;
+}
+
+static void SX126xOnCadDone( bool channelActivityDetected )
+{
+    inner_msg_format_t *p_msg = NULL;
+    OS_MSG_SIZE msg_len = 0;
+    OS_ERR      err;
+    int a = 0;
+
+  //  __disable_irq();
+    Radio.Standby();
+  //  printf("cadDone %d\r\n", channelActivityDetected);
+    if(channelActivityDetected==true){
+       // lora_state = lora_state_idle;
+        g_loraCadStatus = 0;
+        g_loraCadCount++;
+        srand(TickCounter);
+        a = rand() % 50;
+        if(g_runData.bUpdateHost == 0)g_cadTickTime = 300+a;
+        else {
+            if(g_runData.bUpdate != 0) {
+                g_cadTickTime = 700;
+            }
+            else g_cadTickTime = 300+a;
+        }
+        g_cadTick = TickCounter;
+        lora_state = lora_state_sendRept;
+    }
+    else {
+        lora_queue_proc_testTx();
+        g_loraCadCount = 0;
+        g_cadTick = TickCounter;
+
+    }
+   //  __enable_irq();
+    return ;
+}
+
+static void SX126xOnTxTimeout( void )
+{
+	printf("TxTimeout\r\n");
+	Radio.Standby();
+	lora_state = lora_state_idle;
+}
+
+static void SX126xOnRxTimeout( void )
+{
+	printf("RxTimeout retry recive\r\n");
+	Radio.Standby();
+	//Radio.Rx( LORA_RX_TIMEOUT_VALUE ); 
+	lora_state = lora_state_idle;
+}
+
+static void SX126xOnRxError( void )
+{
+	printf("RxError retry recive\r\n");
+	Radio.Standby();
+	//Radio.Rx(LORA_RX_TIMEOUT_VALUE); 
+	lora_state = lora_state_idle;
+}
+static void SX126xConfigureCad( RadioLoRaCadSymbols_t cadSymbolNum, uint8_t cadDetPeak, uint8_t cadDetMin , uint32_t cadTimeout)
+{
+    SX126xSetDioIrqParams( 	IRQ_CAD_DONE | IRQ_CAD_ACTIVITY_DETECTED, IRQ_CAD_DONE | IRQ_CAD_ACTIVITY_DETECTED,
+                            IRQ_RADIO_NONE, IRQ_RADIO_NONE );
+    SX126xSetCadParams( cadSymbolNum, cadDetPeak, cadDetMin, LORA_CAD_ONLY, ((cadTimeout * 1000) / 15.625 ));
+}
+void lora_send(char *tx_data, uint32_t tx_len)
+{
+	char *p_msg = NULL;
+	OS_ERR      err;		
+	p_msg = (char *)lora_queue_mem_calloc_must();	
+	if(p_msg) {
+		memcpy(p_msg, tx_data, tx_len);
+		lora_queue_insert((char *)p_msg, tx_len);
+	}
+	else
+	{
+		lora_queue_mem_free(p_msg);
+	}
+//	char *p_msg = NULL;
+//	OS_ERR      err;	
+
+//	/* 接受消息, 发往net_proc模块统一处理 */
+//	p_msg = (char *)net_queue_mem_calloc_must();	
+//	if(p_msg) {
+//		memcpy(p_msg, tx_data, tx_len);		
+//		OS_QPost(&lora_q, p_msg, tx_len, OS_OPT_POST_FIFO, 0, &err);
+//	}
+}
+
+void lora_net_send_test(uint8_t *tx_data, uint8_t tx_len)
+{
+	if(tx_data[tx_len-2]==0x0d && tx_data[tx_len-1]==0x0a)
+	{
+		tx_data[tx_len-2]='\0';
+		tx_data[tx_len-1]='\0';
+		tx_len-=2;
+		data_dump("lora tx:", tx_data, tx_len);
+	}
+	AIR_MQTT_PUB((char*)g_upLinkTopic,tx_data,0);
+}
+/*lora 发送消息 */
+void lora_send_test(uint8_t *buf, uint8_t size)
+{
+    gateway_collect_com_t *msg = (gateway_collect_com_t*)msg;
+
+//    if(msg->type==0x56){
+//        downlink_config.collect_conf[msg->taxinfo.comdata.coll_no].coll_send_num++;
+//    }
+//    if(g_runData.bUpdate==0){
+//        if(msg->type==0x57){
+//            set_led_status(msg->taxinfo.data.coll_no,0);
+//        }
+//        else {
+//            set_led_status(msg->taxinfo.info[4],0);
+//        }
+//    }
+    Radio.Send(buf, size);
+}
+
+void lora_queue_proc_test(void)
+{
+    OS_ERR      err;
+    gateway_collect_com_t *p_msg;
+    OS_MSG_SIZE msg_len;
+    uint32_t a = 0;
+    uint16_t crc = 0, fcrc = 0;
+
+    OSSemPend(&sys_loraRx.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+    p_msg = (gateway_collect_com_t *)OSQPend(&sys_loraRx.lora_q, 0, OS_OPT_PEND_NON_BLOCKING, &msg_len, NULL, &err);	/* blocking. */
+    OSSemPost(&sys_loraRx.sem, OS_OPT_POST_ALL, &err);
+
+    if(p_msg&&msg_len)
+    {
+
+        if(p_msg->frame_header != 0xfefe){
+            lora_queue_mem_freeRx(p_msg);
+            return;
+        }
+        crc = _crc16_get((uint8_t*)p_msg,p_msg->len+GATE_COLL_HEAD_LEN-2);// len-2);
+        fcrc = p_msg->taxinfo.info[p_msg->len-1];// data[p_tax_tx->len+GATE_COLL_HEAD_LEN-1];
+        fcrc = (fcrc<<8)| p_msg->taxinfo.info[p_msg->len-2];//data[p_tax_tx->len+GATE_COLL_HEAD_LEN-2];
+        if(fcrc != crc ){//校验位不对则返回
+             printf("lora_queue_proc: crc error\r\n");
+             //data_dump("rcv updata", (uint8_t *)p_msg, p_msg->len + 12);
+             lora_queue_mem_freeRx(p_msg);
+            return;
+        }
+        switch(p_msg->type){
+        case COLL_GATE_TAX_QUERY: //0x67业务数据接收接收消息
+           
+            break;
+        case COLL_GATE_HEART_QUERY:	//0x66网关与采集器的上行心跳包
+            
+            break;
+        case COLL_GATE_FIRMMSG_QUERY://0x68采集器上发固件信息
+            
+            break;
+        case 0x22: // 升级重新传指令， 采集器上发的指令
+            printf("\r\n 收到0x22指令\r\n");
+            g_runData.repeatUpdateTime = TickCounter;
+            g_runData.readUpdateStatusTime = 0;
+            if(g_runData.bUpdateHost == 0) break;
+            lora_gw_ota_proc(&sys_net, p_msg);
+            break;
+       case 0x23: // 升级成功，主设备接收从设备的上报指令
+            printf("rcv 0x23 cmd ,delay = %d\r\n",a);
+            if(g_runData.bResetUpdate == 2) { // 从设备时，
+                srand(TickCounter);
+                a = rand() % 233+200;
+                timeout_setValue(&g_updateProg.upStatusOut,a);
+                timeout_start(&g_updateProg.upStatusOut);
+            }
+            else if(g_runData.bResetUpdate == 0) // 主设备
+                gateway_update_status_rcv(p_msg,msg_len);
+            break;
+        case 0x16: // 通知采集器升级
+
+            break;
+        case net_msg_type_update_start: // 网关升级网关指令开始0x13
+             printf("\r\n 收到0x13指令\r\n");
+             gateway_lora_ota_proc(p_msg);
+             break;
+        case net_msg_type_update_continues: // 0x14指令
+            printf("\r\n 收到0x14指令\r\n");
+            gateway_lora_ota_proc(p_msg);
+            break;
+        case net_msg_type_update_retransmit_rsp: // 0x15指令
+            printf("\r\n 收到0x15指令\r\n");
+            gateway_lora_ota_proc(p_msg);
+            break;
+        default:
+            break;
+        }
+        lora_queue_mem_freeRx(p_msg);
+    }
+}
+
+void lora_queue_proc_testTx(void)
+{
+    OS_ERR      err;
+    gateway_collect_com_t *p_msg;
+    OS_MSG_SIZE msg_len;
+    uint8_t coll = 0;
+
+  //  printf("net_queue_proc 1111\r\n");
+    OSSemPend(&sys_loraTX.sem, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
+    p_msg = (gateway_collect_com_t *)OSQPend(&sys_loraTX.lora_q, 0, OS_OPT_PEND_NON_BLOCKING, &msg_len, NULL, &err);	/* blocking. */
+    OSSemPost(&sys_loraTX.sem, OS_OPT_POST_ALL, &err);
+    if(p_msg&&msg_len)
+    {
+        if(p_msg->type == 0x57) coll = p_msg->taxinfo.data.coll_no;
+        else coll = p_msg->taxinfo.info[4];
+        printf("++++++++++ msg type = 0x%x   coll = %d +++++\r\n",p_msg->type,coll);
+        lora_send_test((uint8_t *)p_msg, msg_len);
+        lora_queue_mem_free(p_msg);
+        if(device_fixed_info.Work_State == DEV_WORK_STATE_OTA_RETRANSMIT)
+        {
+            ota_retransmit_delay.timeout = OTA_CAD_FREE_DELAYTIME;
+            ota_retransmit_delay.counter = TickCounter;
+            ota_continuous_end_flag = OTA_CONTINUOUS_DELAY;
+        }
+
+       // printf("发送loraSend = %d,采集器(%d):发送:%d\r\n",g_loraCollMsg.lora_sendCount,p_msg->taxinfo.info[4],g_loraCollMsg.info[p_msg->taxinfo.info[4]].sendNum);
+    }
+    else {
+        lora_state = lora_state_idle;
+     //   printf("\r\n lora state idel 11111111 \r\n");
+    }
+}
+
+
+void lora_task(void)
+{
+    //inner_msg_format_t *p_msg = NULL;
+    OS_MSG_SIZE msg_len = 0;
+    OS_ERR      err;
+    uint32_t i = 0;
+    /* 发送消息 */
+
+    if(g_runData.bUpdate ==0 ) {
+        if(g_runData.loraConnectTime == 0) return;
+        if(g_runData.loraConnectTime >30) { // 半个小后，lora不再接收数据
+
+            g_runData.loraConnectTime = 0;
+            SX126xReset();
+            printf("lora reset \r\n ");
+        }
+    }
+
+
+    lora_queue_proc_test();
+
+    switch(lora_state) {
+    case lora_state_idle: //idle
+        Radio.Standby();
+        Radio.Rx( LORA_RX_TIMEOUT_VALUE );
+        lora_state = lora_state_send;// lora_state_rcv;
+//        printf("lora rx state\n");
+    case lora_state_rcv:
+      //  lora_queue_proc_test();
+      //  lora_state = lora_state_send;
+        break;
+    case lora_state_send:
+        if(sys_loraTX.lora_q.MsgQ.NbrEntries >0){ //除列不为空
+            Radio.Standby();
+            Radio.StartCad();
+            lora_state = lora_state_max;
+            break;
+        }
+      //  lora_state = lora_state_rcv;
+        break;
+    case lora_state_sendRept:
+        if(g_loraCadCount>0) {
+            if(TickCounter - g_cadTick>=g_cadTickTime){
+                Radio.Standby();
+                Radio.StartCad();
+                g_cadTick = TickCounter;
+                printf("\r\n&&&&&&& timer out \r\n");
+            }
+            if(g_loraCadCount>1){
+                lora_queue_proc_testTx();
+                g_loraCadCount = 0;
+                printf("\r\n ^^^^^^2 count  \r\n");
+
+            }
+        }
+        break;
+    case lora_state_max:
+        break;
+    default:
+
+        break;
+    }
+
+    Radio.IrqProcess( );
+}
+
+
+
+void lora_init(char *device_id)
+{
+	OS_ERR      err;	
+	
+	
+    OSSemCreate(&sys_loraTX.sem, "lora_sem", 1, &err);//创建信号量
+    OSQCreate(&sys_loraTX.lora_q, "lora_queue", 8, &err);//创建网络消息处理队列
+    OSMemCreate(&sys_loraTX.lora_m, "lora_memory", sys_loraTX.memory, 8, 256, &err);//创建内存管理池
+	
+	OSSemCreate(&sys_loraRx.sem, "lora_semRx", 1, &err);//创建信号量
+    OSQCreate(&sys_loraRx.lora_q, "lora_queueRx", 8, &err);//创建网络消息处理队列
+    OSMemCreate(&sys_loraRx.lora_m, "lora_memoryRx", sys_loraRx.memory, 8, 256, &err);//创建内存管理池
+	
+	
+	RadioEventsObj.TxDone = SX126xOnTxDone;
+	RadioEventsObj.RxDone = SX126xOnRxDone;
+	RadioEventsObj.TxTimeout = SX126xOnTxTimeout;
+	RadioEventsObj.RxTimeout = SX126xOnRxTimeout;
+	RadioEventsObj.RxError = SX126xOnRxError;
+	RadioEventsObj.CadDone = SX126xOnCadDone;
+
+    
+	Radio.Init( &RadioEventsObj );
+	Radio.SetChannel(LORA_FRE);
+	Radio.SetTxConfig( MODEM_LORA, LORA_TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
+                     LORA_SPREADING_FACTOR, LORA_CODINGRATE,
+                     LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
+                     true, 0, 0, LORA_IQ_INVERSION_ON, 5000 );//参数：lora模式,发射功率,fsk用的lora设置为0就可以，带宽，纠错编码率，前导码长度，固定长度数据包(一般是不固定的所以选false)，crc校验，0表示关闭跳频，跳频之间的符号数(关闭跳频这个参数没有意义)，这个应该是表示是否要翻转中断电平的，超时时间
+
+	Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
+                     LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
+                     LORA_SX126X_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
+                     0, true, 0, 0, LORA_IQ_INVERSION_ON, false );
+//	Radio.Rx( LORA_RX_TIMEOUT_VALUE );
+
+// Radio.SetTxConfig( MODEM_LORA, LORA_TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
+//                                   LORA_SPREADING_FACTOR, LORA_CODINGRATE,
+//                                   LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
+//                                   true, 0, 0, LORA_IQ_INVERSION_ON, 3000 );
+
+//    Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
+//                                   LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
+//                                   LORA_TX_OUTPUT_POWER, LORA_FIX_LENGTH_PAYLOAD_ON,
+//                                   0, true, 0, 0, LORA_IQ_INVERSION_ON, true );
+//	
+    SX126xConfigureCad( CAD_SYMBOL_NUM, CAD_DET_PEAK,CAD_DET_MIN, CAD_TIMEOUT_MS);
+    Radio.StartCad();
+    lora_state = lora_state_rcv;
+    g_runData.loraConnectTime = 1;
+	return;
+}

APP/network_mgr/sx1268/lora.h

@@ -0,0 +1,46 @@
+#ifndef _LORA_H_
+#define _LORA_H_
+
+
+//CAD parameters
+#define CAD_SYMBOL_NUM          LORA_CAD_02_SYMBOL
+#define CAD_DET_PEAK            22
+#define CAD_DET_MIN             10
+#define CAD_TIMEOUT_MS          2000
+#define NB_TRY                  10
+
+
+typedef struct _lora_param_{
+    uint32_t freq; //发射频率
+    uint8_t power; // 发射功率
+    uint8_t bandwidth; //带宽
+    uint8_t spreadingFactor; //扩频因子
+    uint8_t codingrate; // 纠错编码率
+    uint16_t preambleLen; // 前导码长度
+}loraParam;
+extern loraParam g_loraPa[4];
+typedef enum LORA_STATE_ENUM {
+    lora_state_idle,
+    lora_state_rcv,
+    lora_state_send,
+        lora_state_sendRept,
+    lora_state_max
+} LORA_STATE_ENUM;
+
+typedef struct _system_lora {
+  uint8_t memory[8][256];		//必须4字节对齐
+    OS_Q  lora_q;
+    OS_SEM sem;
+    OS_MEM lora_m;
+    OS_TMR lora_tmr;
+} system_lora_t;
+
+
+static void SX126xOnTxDone( void );
+static void SX126xOnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr );
+static void SX126xOnTxTimeout( void );
+static void SX126xOnRxTimeout( void );
+static void SX126xOnRxError( void );
+extern void lora_queue_proc_testTx(void);
+
+#endif

APP/network_mgr/sx1268/lora_test.c

@@ -0,0 +1,99 @@
+#include "radio.h"
+#include "project_config.h"
+#include "stdio.h"
+#include "stm32f10x_it.h"
+#include "delay.h"
+#include "string.h"
+
+/*!
+ * Radio events function pointer
+ * 这个是传参进入其他函数中了，所以用全局变量(局部变量使用完了内存释放可能导致异常)
+ */
+static RadioEvents_t SX126xRadioEvents;
+
+static void SX126xOnTxDone( void );
+static void SX126xOnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr );
+static void SX126xOnTxTimeout( void );
+static void SX126xOnRxTimeout( void );
+static void SX126xOnRxError( void );
+
+static void SX126xOnTxDone( void )
+{
+	printf("TxDone\r\n");
+	Radio.Standby();
+	Radio.Rx( LORA_RX_TIMEOUT_VALUE );
+}
+
+static void SX126xOnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr )
+{
+	uint32_t reciveNumber=0;
+	
+	Radio.Standby();
+
+	printf("RxDone size:%d <rssi:%d, snr:%d> \r\n",size, rssi, snr);	
+	if(size!=4){
+		printf("recive size != 4 is error\r\n");
+	} else {
+		reciveNumber = *(uint32_t *)payload;
+		printf("recive u32 data = %d\r\n", reciveNumber);
+		reciveNumber += 1;
+		Radio.Send((uint8_t *)&reciveNumber, 4);
+	}
+}
+
+static void SX126xOnTxTimeout( void )
+{
+	printf("TxTimeout\r\n");
+}
+
+static void SX126xOnRxTimeout( void )
+{
+	Radio.Standby();
+	printf("RxTimeout retry recive\r\n");
+	Radio.Rx( LORA_RX_TIMEOUT_VALUE ); 
+}
+
+static void SX126xOnRxError( void )
+{
+	Radio.Standby();
+	printf("RxError retry recive\r\n");
+	Radio.Rx(LORA_RX_TIMEOUT_VALUE); 
+}
+
+bool  EnableMaster=true;//主从选择 true为主 false 为从
+int lora_test(void)
+{
+	static uint8_t init = 0;
+	uint32_t u32_count=0;
+	
+	if(init == 0) {
+		SX126xRadioEvents.TxDone = SX126xOnTxDone;
+		SX126xRadioEvents.RxDone = SX126xOnRxDone;
+		SX126xRadioEvents.TxTimeout = SX126xOnTxTimeout;
+		SX126xRadioEvents.RxTimeout = SX126xOnRxTimeout;
+		SX126xRadioEvents.RxError = SX126xOnRxError;
+
+		Radio.Init( &SX126xRadioEvents );
+		Radio.SetChannel(LORA_FRE);
+		Radio.SetTxConfig( MODEM_LORA, LORA_TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
+	                     LORA_SPREADING_FACTOR, LORA_CODINGRATE,
+	                     LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
+	                     true, 0, 0, LORA_IQ_INVERSION_ON, 3000 );//参数：lora模式,发射功率,fsk用的lora设置为0就可以，带宽，纠错编码率，前导码长度，固定长度数据包(一般是不固定的所以选false)，crc校验，0表示关闭跳频，跳频之间的符号数(关闭跳频这个参数没有意义)，这个应该是表示是否要翻转中断电平的，超时时间
+
+		Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
+	                     LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
+	                     LORA_SX126X_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
+	                     0, true, 0, 0, LORA_IQ_INVERSION_ON, false );
+
+		if(EnableMaster == true) {
+			Radio.Send((uint8_t *)&u32_count, 4);
+		} else {
+			Radio.Rx( LORA_RX_TIMEOUT_VALUE );
+		}
+		init = 1;
+	}
+
+	Radio.IrqProcess( ); // Process Radio IRQ
+
+	return 0;
+}

APP/network_mgr/sx1268/peripherals/radio/radio.h

@@ -0,0 +1,530 @@
+/*!
+ * \file      radio.h
+ *
+ * \brief     Radio driver API definition
+ *
+ * \copyright Revised BSD License, see section \ref LICENSE.
+ *
+ * \code
+ *                ______                              _
+ *               / _____)             _              | |
+ *              ( (____  _____ ____ _| |_ _____  ____| |__
+ *               \____ \| ___ |    (_   _) ___ |/ ___)  _ \
+ *               _____) ) ____| | | || |_| ____( (___| | | |
+ *              (______/|_____)_|_|_| \__)_____)\____)_| |_|
+ *              (C)2013-2017 Semtech
+ *
+ * \endcode
+ *
+ * \author    Miguel Luis ( Semtech )
+ *
+ * \author    Gregory Cristian ( Semtech )
+ */
+#ifndef __RADIO_H__
+#define __RADIO_H__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <sx126x.h>
+
+/*!
+ * Radio driver supported modems
+ */
+typedef enum
+{
+    MODEM_FSK = 0,
+    MODEM_LORA,
+}RadioModems_t;
+
+/*!
+ * Radio driver internal state machine states definition
+ */
+typedef enum
+{
+    RF_IDLE = 0,   //!< The radio is idle
+    RF_RX_RUNNING, //!< The radio is in reception state
+    RF_TX_RUNNING, //!< The radio is in transmission state
+    RF_CAD,        //!< The radio is doing channel activity detection
+}RadioState_t;
+
+/*!
+ * \brief Radio driver callback functions
+ */
+typedef struct
+{
+    /*!
+     * \brief  Tx Done callback prototype.
+     */
+    void    ( *TxDone )( void );
+    /*!
+     * \brief  Tx Timeout callback prototype.
+     */
+    void    ( *TxTimeout )( void );
+    /*!
+     * \brief Rx Done callback prototype.
+     *
+     * \param [IN] payload Received buffer pointer
+     * \param [IN] size    Received buffer size
+     * \param [IN] rssi    RSSI value computed while receiving the frame [dBm]
+     * \param [IN] snr     SNR value computed while receiving the frame [dB]
+     *                     FSK : N/A ( set to 0 )
+     *                     LoRa: SNR value in dB
+     */
+    void    ( *RxDone )( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr );
+    /*!
+     * \brief  Rx Timeout callback prototype.
+     */
+    void    ( *RxTimeout )( void );
+    /*!
+     * \brief Rx Error callback prototype.
+     */
+    void    ( *RxError )( void );
+    /*!
+     * \brief  FHSS Change Channel callback prototype.
+     *
+     * \param [IN] currentChannel   Index number of the current channel
+     */
+    void ( *FhssChangeChannel )( uint8_t currentChannel );
+
+    /*!
+     * \brief CAD Done callback prototype.
+     *
+     * \param [IN] channelDetected    Channel Activity detected during the CAD
+     */
+    void ( *CadDone ) ( bool channelActivityDetected );
+    
+    /*!
+     * \brief  Gnss Done Done callback prototype.
+    */
+    void    ( *GnssDone )( void );
+    
+    /*!
+     * \brief  Gnss Done Done callback prototype.
+    */
+    void    ( *WifiDone )( void );
+}RadioEvents_t;
+
+/*!
+ * \brief Radio driver definition
+ */
+struct Radio_s
+{
+    /*!
+     * \brief Initializes the radio
+     *
+     * \param [IN] events Structure containing the driver callback functions
+     */
+    void    ( *Init )( RadioEvents_t *events );
+    /*!
+     * Return current radio status
+     *
+     * \param status Radio status.[RF_IDLE, RF_RX_RUNNING, RF_TX_RUNNING]
+     */
+    RadioState_t ( *GetStatus )( void );
+    /*!
+     * \brief Configures the radio with the given modem
+     *
+     * \param [IN] modem Modem to be used [0: FSK, 1: LoRa]
+     */
+    void    ( *SetModem )( RadioModems_t modem );
+    /*!
+     * \brief Sets the channel frequency
+     *
+     * \param [IN] freq         Channel RF frequency
+     */
+    void    ( *SetChannel )( uint32_t freq );
+    /*!
+     * \brief Checks if the channel is free for the given time
+     *
+     * \remark The FSK modem is always used for this task as we can select the Rx bandwidth at will.
+     *
+     * \param [IN] freq                Channel RF frequency in Hertz
+     * \param [IN] rxBandwidth         Rx bandwidth in Hertz
+     * \param [IN] rssiThresh          RSSI threshold in dBm
+     * \param [IN] maxCarrierSenseTime Max time in milliseconds while the RSSI is measured
+     *
+     * \retval isFree         [true: Channel is free, false: Channel is not free]
+     */
+    bool    ( *IsChannelFree )( uint32_t freq, uint32_t rxBandwidth, int16_t rssiThresh, uint32_t maxCarrierSenseTime );
+    /*!
+     * \brief Generates a 32 bits random value based on the RSSI readings
+     *
+     * \remark This function sets the radio in LoRa modem mode and disables
+     *         all interrupts.
+     *         After calling this function either Radio.SetRxConfig or
+     *         Radio.SetTxConfig functions must be called.
+     *
+     * \retval randomValue    32 bits random value
+     */
+    uint32_t ( *Random )( void );
+    /*!
+     * \brief Sets the reception parameters
+     *
+     * \param [IN] modem        Radio modem to be used [0: FSK, 1: LoRa]
+     * \param [IN] bandwidth    Sets the bandwidth
+     *                          FSK : >= 2600 and <= 250000 Hz
+     *                          LoRa: [0: 125 kHz, 1: 250 kHz,
+     *                                 2: 500 kHz, 3: Reserved]
+     * \param [IN] datarate     Sets the Datarate
+     *                          FSK : 600..300000 bits/s
+     *                          LoRa: [6: 64, 7: 128, 8: 256, 9: 512,
+     *                                10: 1024, 11: 2048, 12: 4096  chips]
+     * \param [IN] coderate     Sets the coding rate (LoRa only)
+     *                          FSK : N/A ( set to 0 )
+     *                          LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
+     * \param [IN] bandwidthAfc Sets the AFC Bandwidth (FSK only)
+     *                          FSK : >= 2600 and <= 250000 Hz
+     *                          LoRa: N/A ( set to 0 )
+     * \param [IN] preambleLen  Sets the Preamble length
+     *                          FSK : Number of bytes
+     *                          LoRa: Length in symbols (the hardware adds 4 more symbols)
+     * \param [IN] symbTimeout  Sets the RxSingle timeout value
+     *                          FSK : timeout in number of bytes
+     *                          LoRa: timeout in symbols
+     * \param [IN] fixLen       Fixed length packets [0: variable, 1: fixed]
+     * \param [IN] payloadLen   Sets payload length when fixed length is used
+     * \param [IN] crcOn        Enables/Disables the CRC [0: OFF, 1: ON]
+     * \param [IN] freqHopOn    Enables disables the intra-packet frequency hopping
+     *                          FSK : N/A ( set to 0 )
+     *                          LoRa: [0: OFF, 1: ON]
+     * \param [IN] hopPeriod    Number of symbols between each hop
+     *                          FSK : N/A ( set to 0 )
+     *                          LoRa: Number of symbols
+     * \param [IN] iqInverted   Inverts IQ signals (LoRa only)
+     *                          FSK : N/A ( set to 0 )
+     *                          LoRa: [0: not inverted, 1: inverted]
+     * \param [IN] rxContinuous Sets the reception in continuous mode
+     *                          [false: single mode, true: continuous mode]
+     */
+    void    ( *SetRxConfig )( RadioModems_t modem, uint32_t bandwidth,
+                              uint32_t datarate, uint8_t coderate,
+                              uint32_t bandwidthAfc, uint16_t preambleLen,
+                              uint16_t symbTimeout, bool fixLen,
+                              uint8_t payloadLen,
+                              bool crcOn, bool freqHopOn, uint8_t hopPeriod,
+                              bool iqInverted, bool rxContinuous );
+    /*!
+     * \brief Sets the transmission parameters
+     *
+     * \param [IN] modem        Radio modem to be used [0: FSK, 1: LoRa]
+     * \param [IN] power        Sets the output power [dBm]
+     * \param [IN] fdev         Sets the frequency deviation (FSK only)
+     *                          FSK : [Hz]
+     *                          LoRa: 0
+     * \param [IN] bandwidth    Sets the bandwidth (LoRa only)
+     *                          FSK : 0
+     *                          LoRa: [0: 125 kHz, 1: 250 kHz,
+     *                                 2: 500 kHz, 3: Reserved]
+     * \param [IN] datarate     Sets the Datarate
+     *                          FSK : 600..300000 bits/s
+     *                          LoRa: [6: 64, 7: 128, 8: 256, 9: 512,
+     *                                10: 1024, 11: 2048, 12: 4096  chips]
+     * \param [IN] coderate     Sets the coding rate (LoRa only)
+     *                          FSK : N/A ( set to 0 )
+     *                          LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
+     * \param [IN] preambleLen  Sets the preamble length
+     *                          FSK : Number of bytes
+     *                          LoRa: Length in symbols (the hardware adds 4 more symbols)
+     * \param [IN] fixLen       Fixed length packets [0: variable, 1: fixed]
+     * \param [IN] crcOn        Enables disables the CRC [0: OFF, 1: ON]
+     * \param [IN] freqHopOn    Enables disables the intra-packet frequency hopping
+     *                          FSK : N/A ( set to 0 )
+     *                          LoRa: [0: OFF, 1: ON]
+     * \param [IN] hopPeriod    Number of symbols between each hop
+     *                          FSK : N/A ( set to 0 )
+     *                          LoRa: Number of symbols
+     * \param [IN] iqInverted   Inverts IQ signals (LoRa only)
+     *                          FSK : N/A ( set to 0 )
+     *                          LoRa: [0: not inverted, 1: inverted]
+     * \param [IN] timeout      Transmission timeout [ms]
+     */
+    void    ( *SetTxConfig )( RadioModems_t modem, int8_t power, uint32_t fdev,
+                              uint32_t bandwidth, uint32_t datarate,
+                              uint8_t coderate, uint16_t preambleLen,
+                              bool fixLen, bool crcOn, bool freqHopOn,
+                              uint8_t hopPeriod, bool iqInverted, uint32_t timeout );
+    /*!
+     * \brief Checks if the given RF frequency is supported by the hardware
+     *
+     * \param [IN] frequency RF frequency to be checked
+     * \retval isSupported [true: supported, false: unsupported]
+     */
+    bool    ( *CheckRfFrequency )( uint32_t frequency );
+    /*!
+     * \brief Computes the packet time on air in ms for the given payload
+     *
+     * \Remark Can only be called once SetRxConfig or SetTxConfig have been called
+     *
+     * \param [IN] modem      Radio modem to be used [0: FSK, 1: LoRa]
+     * \param [IN] bandwidth    Sets the bandwidth
+     *                          FSK : >= 2600 and <= 250000 Hz
+     *                          LoRa: [0: 125 kHz, 1: 250 kHz,
+     *                                 2: 500 kHz, 3: Reserved]
+     * \param [IN] datarate     Sets the Datarate
+     *                          FSK : 600..300000 bits/s
+     *                          LoRa: [6: 64, 7: 128, 8: 256, 9: 512,
+     *                                10: 1024, 11: 2048, 12: 4096  chips]
+     * \param [IN] coderate     Sets the coding rate (LoRa only)
+     *                          FSK : N/A ( set to 0 )
+     *                          LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
+     * \param [IN] preambleLen  Sets the Preamble length
+     *                          FSK : Number of bytes
+     *                          LoRa: Length in symbols (the hardware adds 4 more symbols)
+     * \param [IN] fixLen       Fixed length packets [0: variable, 1: fixed]
+     * \param [IN] payloadLen   Sets payload length when fixed length is used
+     * \param [IN] crcOn        Enables/Disables the CRC [0: OFF, 1: ON]
+     *
+     * \retval airTime        Computed airTime (ms) for the given packet payload length
+     */
+    uint32_t  ( *TimeOnAir )( RadioModems_t modem, uint32_t bandwidth,
+                              uint32_t datarate, uint8_t coderate,
+                              uint16_t preambleLen, bool fixLen, uint8_t payloadLen,
+                              bool crcOn );
+    /*!
+     * \brief Sends the buffer of size. Prepares the packet to be sent and sets
+     *        the radio in transmission
+     *
+     * \param [IN]: buffer     Buffer pointer
+     * \param [IN]: size       Buffer size
+     */
+    void    ( *Send )( uint8_t *buffer, uint8_t size );
+    /*!
+     * \brief Sets the radio in sleep mode
+     */
+    void    ( *Sleep )( void );
+    /*!
+     * \brief Sets the radio in standby mode
+     */
+    void    ( *Standby )( void );
+    /*!
+     * \brief Sets the radio in reception mode for the given time
+     * \param [IN] timeout Reception timeout [ms]
+     *                     [0: continuous, others timeout]
+     */
+    void    ( *Rx )( uint32_t timeout );
+    /*!
+     * \brief Start a Channel Activity Detection
+     */
+    void    ( *StartCad )( void );
+    /*!
+     * \brief Sets the radio in continuous wave transmission mode
+     *
+     * \param [IN]: freq       Channel RF frequency
+     * \param [IN]: power      Sets the output power [dBm]
+     * \param [IN]: time       Transmission mode timeout [s]
+     */
+    void    ( *SetTxContinuousWave )( uint32_t freq, int8_t power, uint16_t time );
+    /*!
+     * \brief Reads the current RSSI value
+     *
+     * \retval rssiValue Current RSSI value in [dBm]
+     */
+    int16_t ( *Rssi )( RadioModems_t modem );
+    /*!
+     * \brief Writes the radio register at the specified address
+     *
+     * \param [IN]: addr Register address
+     * \param [IN]: data New register value
+     */
+    void    ( *Write )( uint32_t addr, uint8_t data );
+    /*!
+     * \brief Reads the radio register at the specified address
+     *
+     * \param [IN]: addr Register address
+     * \retval data Register value
+     */
+    uint8_t ( *Read )( uint32_t addr );
+    /*!
+     * \brief Writes multiple radio registers starting at address
+     *
+     * \param [IN] addr   First Radio register address
+     * \param [IN] buffer Buffer containing the new register's values
+     * \param [IN] size   Number of registers to be written
+     */
+    void    ( *WriteBuffer )( uint32_t addr, uint8_t *buffer, uint8_t size );
+    /*!
+     * \brief Reads multiple radio registers starting at address
+     *
+     * \param [IN] addr First Radio register address
+     * \param [OUT] buffer Buffer where to copy the registers data
+     * \param [IN] size Number of registers to be read
+     */
+    void    ( *ReadBuffer )( uint32_t addr, uint8_t *buffer, uint8_t size );
+    /*!
+     * \brief Sets the maximum payload length.
+     *
+     * \param [IN] modem      Radio modem to be used [0: FSK, 1: LoRa]
+     * \param [IN] max        Maximum payload length in bytes
+     */
+    void    ( *SetMaxPayloadLength )( RadioModems_t modem, uint8_t max );
+    /*!
+     * \brief Sets the network to public or private. Updates the sync byte.
+     *
+     * \remark Applies to LoRa modem only
+     *
+     * \param [IN] enable if true, it enables a public network
+     */
+    void    ( *SetPublicNetwork )( bool enable );
+    /*!
+     * \brief Gets the time required for the board plus radio to get out of sleep.[ms]
+     *
+     * \retval time Radio plus board wakeup time in ms.
+     */
+    uint32_t  ( *GetWakeupTime )( void );
+    /*!
+     * \brief Process radio irq
+     */
+    void ( *IrqProcess )( void );
+    /*
+     * The next functions are available only on SX126x radios.
+     */
+    /*!
+     * \brief Sets the radio in reception mode with Max LNA gain for the given time
+     *
+     * \remark Available on SX126x radios only.
+     *
+     * \param [IN] timeout Reception timeout [ms]
+     *                     [0: continuous, others timeout]
+     */
+    void    ( *RxBoosted )( uint32_t timeout );
+    /*!
+     * \brief Sets the Rx duty cycle management parameters
+     *
+     * \remark Available on SX126x radios only.
+     *
+     * \param [in]  rxTime        Structure describing reception timeout value
+     * \param [in]  sleepTime     Structure describing sleep timeout value
+     */
+    void ( *SetRxDutyCycle ) ( uint32_t rxTime, uint32_t sleepTime );
+};
+
+/*!
+ * \brief Gets the current Radio OperationMode variable
+ *
+ * \retval      RadioOperatingModes_t last operating mode
+ */
+RadioOperatingModes_t SX126xGetOperatingMode( void );
+
+/*!
+ * \brief Sets/Updates the current Radio OperationMode variable.
+ *
+ * \remark WARNING: This function is only required to reflect the current radio
+ *                  operating mode when processing interrupts.
+ *
+ * \param [in] mode           New operating mode
+ */
+void SX126xSetOperatingMode( RadioOperatingModes_t mode );
+
+/*!
+ * \brief Initializes the TCXO power pin.
+ */
+void SX126xIoTcxoInit( void );
+
+/*!
+ * \brief Gets the Defines the time required for the TCXO to wakeup [ms].
+ *
+ * \retval time Board TCXO wakeup time in ms.
+ */
+uint32_t SX126xGetBoardTcxoWakeupTime( void );
+
+/*!
+ * \brief Initializes RF switch control pins.
+ */
+void SX126xIoRfSwitchInit( void );
+
+/*!
+ * \brief Initializes the RF Switch I/Os pins interface
+ */
+void SX126xAntSwOn( void );
+
+/*!
+ * \brief De-initializes the RF Switch I/Os pins interface
+ *
+ * \remark Needed to decrease the power consumption in MCU low power modes
+ */
+void SX126xAntSwOff( void );
+
+/*!
+ * \brief Gets the device ID
+ *
+ * \retval id Connected device ID
+ */
+uint8_t SX126xGetDeviceId( void );
+
+/*!
+ * \brief Sets the radio output power.
+ *
+ * \param [IN] power Sets the RF output power
+ */
+void SX126xSetRfTxPower( int8_t power );
+
+/*!
+ * \brief Write a single byte of data to the radio memory
+ *
+ * \param [in]  address       The address of the first byte to write in the radio
+ * \param [in]  value         The data to be written in radio's memory
+ */
+void SX126xWriteRegister( uint16_t address, uint8_t value );
+
+/*!
+ * \brief Read a single byte of data from the radio memory
+ *
+ * \param [in]  address       The address of the first byte to write in the radio
+ *
+ * \retval      value         The value of the byte at the given address in radio's memory
+ */
+uint8_t SX126xReadRegister( uint16_t address );
+
+/*!
+ * \brief Wakes up the radio
+ */
+void SX126xWakeup( void );
+
+/*!
+ * \brief Send a command that write data to the radio
+ *
+ * \param [in]  opcode        Opcode of the command
+ * \param [in]  buffer        Buffer to be send to the radio
+ * \param [in]  size          Size of the buffer to send
+ */
+void SX126xWriteCommand( RadioCommands_t opcode, uint8_t *buffer, uint16_t size );
+
+/*!
+ * \brief Send a command that read data from the radio
+ *
+ * \param [in]  opcode        Opcode of the command
+ * \param [out] buffer        Buffer holding data from the radio
+ * \param [in]  size          Size of the buffer
+ *
+ * \retval status Return command radio status
+ */
+uint8_t SX126xReadCommand( RadioCommands_t opcode, uint8_t *buffer, uint16_t size );
+
+/*!
+ * \brief Tx timeout timer callback
+ */
+void RadioOnTxTimeoutIrq( void* context );
+
+/*!
+ * \brief Rx timeout timer callback
+ */
+void RadioOnRxTimeoutIrq( void* context );
+
+/*!
+ * \brief Radio driver
+ *
+ * \remark This variable is defined and initialized in the specific radio
+ *         board implementation
+ */
+extern const struct Radio_s Radio;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __RADIO_H__

APP/network_mgr/sx1268/peripherals/radio/sx126x-board.h

@@ -0,0 +1,111 @@
+/*!
+ * \file      sx126x-board.h
+ *
+ * \brief     Target board SX126x driver implementation
+ *
+ * \copyright Revised BSD License, see section \ref LICENSE.
+ *
+ * \code
+ *                ______                              _
+ *               / _____)             _              | |
+ *              ( (____  _____ ____ _| |_ _____  ____| |__
+ *               \____ \| ___ |    (_   _) ___ |/ ___)  _ \
+ *               _____) ) ____| | | || |_| ____( (___| | | |
+ *              (______/|_____)_|_|_| \__)_____)\____)_| |_|
+ *              (C)2013-2017 Semtech
+ *
+ * \endcode
+ *
+ * \author    Miguel Luis ( Semtech )
+ *
+ * \author    Gregory Cristian ( Semtech )
+ */
+#ifndef __SX126x_BOARD_H__
+#define __SX126x_BOARD_H__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "sx126x/sx126x.h"
+
+//进入和退出临界区保护方法
+#if HAVE_OS
+	#define CRITICAL_SECTION_BEGIN( )	vPortEnterCritical()
+	#define CRITICAL_SECTION_END( )	vPortExitCritical()
+#else
+	#define CRITICAL_SECTION_BEGIN( )
+	#define CRITICAL_SECTION_END( )
+#endif
+
+/*!
+ * \brief Initializes the radio I/Os pins interface
+ */
+void SX126xIoInit( void );
+
+/*!
+ * \brief Initializes DIO IRQ handlers
+ *
+ * \param [IN] irqHandlers Array containing the IRQ callback functions
+ */
+void SX126xIoIrqInit( DioIrqHandler dioIrq );
+
+/*!
+ * \brief De-initializes the radio I/Os pins interface.
+ *
+ * \remark Useful when going in MCU low power modes
+ */
+void SX126xIoDeInit( void );
+
+/*!
+ * \brief Initializes the radio debug pins.
+ */
+void SX126xIoDbgInit( void );
+
+/*!
+ * \brief HW Reset of the radio
+ */
+void SX126xReset( void );
+
+/*!
+ * \brief Blocking loop to wait while the Busy pin in high
+ */
+void SX126xWaitOnBusy( void );
+
+/*!
+ * \brief Checks if the given RF frequency is supported by the hardware
+ *
+ * \param [IN] frequency RF frequency to be checked
+ * \retval isSupported [true: supported, false: unsupported]
+ */
+bool SX126xCheckRfFrequency( uint32_t frequency );
+
+void SX126xDelayMs(uint32_t ms);
+
+/*
+ * 定时器初始化 
+ */
+void SX126xTimerInit(void);
+void SX126xSetTxTimerValue(uint32_t nMs);
+void SX126xTxTimerStart(void);
+void SX126xTxTimerStop(void);
+void SX126xSetRxTimerValue(uint32_t nMs);
+void SX126xRxTimerStart(void);
+void SX126xRxTimerStop(void);
+
+void SX126xSetNss(uint8_t lev );
+uint8_t SX126xSpiInOut(uint8_t data);
+
+/*!
+ * Radio hardware and global parameters
+ */
+extern SX126x_t SX126x;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __SX126x_BOARD_H__

APP/network_mgr/sx1268/peripherals/radio/sx126x/radio.c

@@ -0,0 +1,1606 @@
+/*!
+ * \file      radio.c
+ *
+ * \brief     Radio driver API definition
+ *
+ * \copyright Revised BSD License, see section \ref LICENSE.
+ *
+ * \code
+ *                ______                              _
+ *               / _____)             _              | |
+ *              ( (____  _____ ____ _| |_ _____  ____| |__
+ *               \____ \| ___ |    (_   _) ___ |/ ___)  _ \
+ *               _____) ) ____| | | || |_| ____( (___| | | |
+ *              (______/|_____)_|_|_| \__)_____)\____)_| |_|
+ *              (C)2013-2017 Semtech
+ *
+ * \endcode
+ *
+ * \author    Miguel Luis ( Semtech )
+ *
+ * \author    Gregory Cristian ( Semtech )
+ */
+#include <math.h>
+#include <string.h>
+#include "delay.h"
+#include "../radio.h"
+#include "sx126x.h"
+#include "sx126x-board.h"
+#include "project_config.h"
+#include "BSP.h"
+
+static double RadioLoRaSymbTime[3][6] = {{ 32.768, 16.384, 8.192, 4.096, 2.048, 1.024 },  // 125 KHz
+                                         { 16.384, 8.192,  4.096, 2.048, 1.024, 0.512 },  // 250 KHz
+                                         { 8.192,  4.096,  2.048, 1.024, 0.512, 0.256 }}; // 500 KHz
+
+/*!
+ * Defines the time required for the TCXO to wakeup [ms].
+ */
+#define BOARD_TCXO_WAKEUP_TIME                      0
+
+/*!
+ * \brief Initializes the radio
+ *
+ * \param [IN] events Structure containing the driver callback functions
+ */
+void RadioInit( RadioEvents_t *events );
+
+/*!
+ * Return current radio status
+ *
+ * \param status Radio status.[RF_IDLE, RF_RX_RUNNING, RF_TX_RUNNING]
+ */
+RadioState_t RadioGetStatus( void );
+
+/*!
+ * \brief Configures the radio with the given modem
+ *
+ * \param [IN] modem Modem to be used [0: FSK, 1: LoRa]
+ */
+void RadioSetModem( RadioModems_t modem );
+
+/*!
+ * \brief Sets the channel frequency
+ *
+ * \param [IN] freq         Channel RF frequency
+ */
+void RadioSetChannel( uint32_t freq );
+
+/*!
+ * \brief Checks if the channel is free for the given time
+ *
+ * \remark The FSK modem is always used for this task as we can select the Rx bandwidth at will.
+ *
+ * \param [IN] freq                Channel RF frequency in Hertz
+ * \param [IN] rxBandwidth         Rx bandwidth in Hertz
+ * \param [IN] rssiThresh          RSSI threshold in dBm
+ * \param [IN] maxCarrierSenseTime Max time in milliseconds while the RSSI is measured
+ *
+ * \retval isFree         [true: Channel is free, false: Channel is not free]
+ */
+bool RadioIsChannelFree( uint32_t freq, uint32_t rxBandwidth, int16_t rssiThresh, uint32_t maxCarrierSenseTime );
+
+/*!
+ * \brief Generates a 32 bits random value based on the RSSI readings
+ *
+ * \remark This function sets the radio in LoRa modem mode and disables
+ *         all interrupts.
+ *         After calling this function either Radio.SetRxConfig or
+ *         Radio.SetTxConfig functions must be called.
+ *
+ * \retval randomValue    32 bits random value
+ */
+uint32_t RadioRandom( void );
+
+/*!
+ * \brief Sets the reception parameters
+ *
+ * \param [IN] modem        Radio modem to be used [0: FSK, 1: LoRa]
+ * \param [IN] bandwidth    Sets the bandwidth
+ *                          FSK : >= 2600 and <= 250000 Hz
+ *                          LoRa: [0: 125 kHz, 1: 250 kHz,
+ *                                 2: 500 kHz, 3: Reserved]
+ * \param [IN] datarate     Sets the Datarate
+ *                          FSK : 600..300000 bits/s
+ *                          LoRa: [6: 64, 7: 128, 8: 256, 9: 512,
+ *                                10: 1024, 11: 2048, 12: 4096  chips]
+ * \param [IN] coderate     Sets the coding rate (LoRa only)
+ *                          FSK : N/A ( set to 0 )
+ *                          LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
+ * \param [IN] bandwidthAfc Sets the AFC Bandwidth (FSK only)
+ *                          FSK : >= 2600 and <= 250000 Hz
+ *                          LoRa: N/A ( set to 0 )
+ * \param [IN] preambleLen  Sets the Preamble length
+ *                          FSK : Number of bytes
+ *                          LoRa: Length in symbols (the hardware adds 4 more symbols)
+ * \param [IN] symbTimeout  Sets the RxSingle timeout value
+ *                          FSK : timeout in number of bytes
+ *                          LoRa: timeout in symbols
+ * \param [IN] fixLen       Fixed length packets [0: variable, 1: fixed]
+ * \param [IN] payloadLen   Sets payload length when fixed length is used
+ * \param [IN] crcOn        Enables/Disables the CRC [0: OFF, 1: ON]
+ * \param [IN] FreqHopOn    Enables disables the intra-packet frequency hopping
+ *                          FSK : N/A ( set to 0 )
+ *                          LoRa: [0: OFF, 1: ON]
+ * \param [IN] HopPeriod    Number of symbols between each hop
+ *                          FSK : N/A ( set to 0 )
+ *                          LoRa: Number of symbols
+ * \param [IN] iqInverted   Inverts IQ signals (LoRa only)
+ *                          FSK : N/A ( set to 0 )
+ *                          LoRa: [0: not inverted, 1: inverted]
+ * \param [IN] rxContinuous Sets the reception in continuous mode
+ *                          [false: single mode, true: continuous mode]
+ */
+void RadioSetRxConfig( RadioModems_t modem, uint32_t bandwidth,
+                          uint32_t datarate, uint8_t coderate,
+                          uint32_t bandwidthAfc, uint16_t preambleLen,
+                          uint16_t symbTimeout, bool fixLen,
+                          uint8_t payloadLen,
+                          bool crcOn, bool FreqHopOn, uint8_t HopPeriod,
+                          bool iqInverted, bool rxContinuous );
+
+/*!
+ * \brief Sets the transmission parameters
+ *
+ * \param [IN] modem        Radio modem to be used [0: FSK, 1: LoRa]
+ * \param [IN] power        Sets the output power [dBm]
+ * \param [IN] fdev         Sets the frequency deviation (FSK only)
+ *                          FSK : [Hz]
+ *                          LoRa: 0
+ * \param [IN] bandwidth    Sets the bandwidth (LoRa only)
+ *                          FSK : 0
+ *                          LoRa: [0: 125 kHz, 1: 250 kHz,
+ *                                 2: 500 kHz, 3: Reserved]
+ * \param [IN] datarate     Sets the Datarate
+ *                          FSK : 600..300000 bits/s
+ *                          LoRa: [6: 64, 7: 128, 8: 256, 9: 512,
+ *                                10: 1024, 11: 2048, 12: 4096  chips]
+ * \param [IN] coderate     Sets the coding rate (LoRa only)
+ *                          FSK : N/A ( set to 0 )
+ *                          LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
+ * \param [IN] preambleLen  Sets the preamble length
+ *                          FSK : Number of bytes
+ *                          LoRa: Length in symbols (the hardware adds 4 more symbols)
+ * \param [IN] fixLen       Fixed length packets [0: variable, 1: fixed]
+ * \param [IN] crcOn        Enables disables the CRC [0: OFF, 1: ON]
+ * \param [IN] FreqHopOn    Enables disables the intra-packet frequency hopping
+ *                          FSK : N/A ( set to 0 )
+ *                          LoRa: [0: OFF, 1: ON]
+ * \param [IN] HopPeriod    Number of symbols between each hop
+ *                          FSK : N/A ( set to 0 )
+ *                          LoRa: Number of symbols
+ * \param [IN] iqInverted   Inverts IQ signals (LoRa only)
+ *                          FSK : N/A ( set to 0 )
+ *                          LoRa: [0: not inverted, 1: inverted]
+ * \param [IN] timeout      Transmission timeout [ms]
+ */
+void RadioSetTxConfig( RadioModems_t modem, int8_t power, uint32_t fdev,
+                          uint32_t bandwidth, uint32_t datarate,
+                          uint8_t coderate, uint16_t preambleLen,
+                          bool fixLen, bool crcOn, bool FreqHopOn,
+                          uint8_t HopPeriod, bool iqInverted, uint32_t timeout );
+
+/*!
+ * \brief Checks if the given RF frequency is supported by the hardware
+ *
+ * \param [IN] frequency RF frequency to be checked
+ * \retval isSupported [true: supported, false: unsupported]
+ */
+bool RadioCheckRfFrequency( uint32_t frequency );
+
+/*!
+ * \brief Computes the packet time on air in ms for the given payload
+ *
+ * \Remark Can only be called once SetRxConfig or SetTxConfig have been called
+ *
+ * \param [IN] modem      Radio modem to be used [0: FSK, 1: LoRa]
+ * \param [IN] bandwidth    Sets the bandwidth
+ *                          FSK : >= 2600 and <= 250000 Hz
+ *                          LoRa: [0: 125 kHz, 1: 250 kHz,
+ *                                 2: 500 kHz, 3: Reserved]
+ * \param [IN] datarate     Sets the Datarate
+ *                          FSK : 600..300000 bits/s
+ *                          LoRa: [6: 64, 7: 128, 8: 256, 9: 512,
+ *                                10: 1024, 11: 2048, 12: 4096  chips]
+ * \param [IN] coderate     Sets the coding rate (LoRa only)
+ *                          FSK : N/A ( set to 0 )
+ *                          LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
+ * \param [IN] preambleLen  Sets the Preamble length
+ *                          FSK : Number of bytes
+ *                          LoRa: Length in symbols (the hardware adds 4 more symbols)
+ * \param [IN] fixLen       Fixed length packets [0: variable, 1: fixed]
+ * \param [IN] payloadLen   Sets payload length when fixed length is used
+ * \param [IN] crcOn        Enables/Disables the CRC [0: OFF, 1: ON]
+ *
+ * \retval airTime        Computed airTime (ms) for the given packet payload length
+ */
+uint32_t RadioTimeOnAir( RadioModems_t modem, uint32_t bandwidth,
+                              uint32_t datarate, uint8_t coderate,
+                              uint16_t preambleLen, bool fixLen, uint8_t payloadLen,
+                              bool crcOn );
+
+/*!
+ * \brief Sends the buffer of size. Prepares the packet to be sent and sets
+ *        the radio in transmission
+ *
+ * \param [IN]: buffer     Buffer pointer
+ * \param [IN]: size       Buffer size
+ */
+void RadioSend( uint8_t *buffer, uint8_t size );
+
+/*!
+ * \brief Sets the radio in sleep mode
+ */
+void RadioSleep( void );
+
+/*!
+ * \brief Sets the radio in standby mode
+ */
+void RadioStandby( void );
+
+/*!
+ * \brief Sets the radio in reception mode for the given time
+ * \param [IN] timeout Reception timeout [ms]
+ *                     [0: continuous, others timeout]
+ */
+void RadioRx( uint32_t timeout );
+
+/*!
+ * \brief Start a Channel Activity Detection
+ */
+void RadioStartCad( void );
+
+/*!
+ * \brief Sets the radio in continuous wave transmission mode
+ *
+ * \param [IN]: freq       Channel RF frequency
+ * \param [IN]: power      Sets the output power [dBm]
+ * \param [IN]: time       Transmission mode timeout [s]
+ */
+void RadioSetTxContinuousWave( uint32_t freq, int8_t power, uint16_t time );
+
+/*!
+ * \brief Reads the current RSSI value
+ *
+ * \retval rssiValue Current RSSI value in [dBm]
+ */
+int16_t RadioRssi( RadioModems_t modem );
+
+/*!
+ * \brief Writes the radio register at the specified address
+ *
+ * \param [IN]: addr Register address
+ * \param [IN]: data New register value
+ */
+void RadioWrite( uint32_t addr, uint8_t data );
+
+/*!
+ * \brief Reads the radio register at the specified address
+ *
+ * \param [IN]: addr Register address
+ * \retval data Register value
+ */
+uint8_t RadioRead( uint32_t addr );
+
+/*!
+ * \brief Writes multiple radio registers starting at address
+ *
+ * \param [IN] addr   First Radio register address
+ * \param [IN] buffer Buffer containing the new register's values
+ * \param [IN] size   Number of registers to be written
+ */
+void RadioWriteBuffer( uint32_t addr, uint8_t *buffer, uint8_t size );
+
+/*!
+ * \brief Reads multiple radio registers starting at address
+ *
+ * \param [IN] addr First Radio register address
+ * \param [OUT] buffer Buffer where to copy the registers data
+ * \param [IN] size Number of registers to be read
+ */
+void RadioReadBuffer( uint32_t addr, uint8_t *buffer, uint8_t size );
+
+/*!
+ * \brief Sets the maximum payload length.
+ *
+ * \param [IN] modem      Radio modem to be used [0: FSK, 1: LoRa]
+ * \param [IN] max        Maximum payload length in bytes
+ */
+void RadioSetMaxPayloadLength( RadioModems_t modem, uint8_t max );
+
+/*!
+ * \brief Sets the network to public or private. Updates the sync byte.
+ *
+ * \remark Applies to LoRa modem only
+ *
+ * \param [IN] enable if true, it enables a public network
+ */
+void RadioSetPublicNetwork( bool enable );
+
+/*!
+ * \brief Gets the time required for the board plus radio to get out of sleep.[ms]
+ *
+ * \retval time Radio plus board wakeup time in ms.
+ */
+uint32_t RadioGetWakeupTime( void );
+
+/*!
+ * \brief Process radio irq
+ */
+void RadioIrqProcess( void );
+
+/*!
+ * \brief Sets the radio in reception mode with Max LNA gain for the given time
+ * \param [IN] timeout Reception timeout [ms]
+ *                     [0: continuous, others timeout]
+ */
+void RadioRxBoosted( uint32_t timeout );
+
+/*!
+ * \brief Sets the Rx duty cycle management parameters
+ *
+ * \param [in]  rxTime        Structure describing reception timeout value
+ * \param [in]  sleepTime     Structure describing sleep timeout value
+ */
+void RadioSetRxDutyCycle( uint32_t rxTime, uint32_t sleepTime );
+
+/*!
+ * Radio driver structure initialization
+ */
+const struct Radio_s Radio =
+{
+    RadioInit,
+    RadioGetStatus,
+    RadioSetModem,
+    RadioSetChannel,
+    RadioIsChannelFree,
+    RadioRandom,
+    RadioSetRxConfig,
+    RadioSetTxConfig,
+    RadioCheckRfFrequency,
+    RadioTimeOnAir,
+    RadioSend,
+    RadioSleep,
+    RadioStandby,
+    RadioRx,
+    RadioStartCad,
+    RadioSetTxContinuousWave,
+    RadioRssi,
+    RadioWrite,
+    RadioRead,
+    RadioWriteBuffer,
+    RadioReadBuffer,
+    RadioSetMaxPayloadLength,
+    RadioSetPublicNetwork,
+    RadioGetWakeupTime,
+    RadioIrqProcess,
+    // Available on SX126x only
+    RadioRxBoosted,
+    RadioSetRxDutyCycle
+};
+
+/*
+ * Local types definition
+ */
+
+
+ /*!
+ * FSK bandwidth definition
+ */
+typedef struct
+{
+    uint32_t bandwidth;
+    uint8_t  RegValue;
+}FskBandwidth_t;
+
+/*!
+ * Precomputed FSK bandwidth registers values
+ */
+const FskBandwidth_t FskBandwidths[] =
+{
+    { 4800  , 0x1F },
+    { 5800  , 0x17 },
+    { 7300  , 0x0F },
+    { 9700  , 0x1E },
+    { 11700 , 0x16 },
+    { 14600 , 0x0E },
+    { 19500 , 0x1D },
+    { 23400 , 0x15 },
+    { 29300 , 0x0D },
+    { 39000 , 0x1C },
+    { 46900 , 0x14 },
+    { 58600 , 0x0C },
+    { 78200 , 0x1B },
+    { 93800 , 0x13 },
+    { 117300, 0x0B },
+    { 156200, 0x1A },
+    { 187200, 0x12 },
+    { 234300, 0x0A },
+    { 312000, 0x19 },
+    { 373600, 0x11 },
+    { 467000, 0x09 },
+    { 500000, 0x00 }, // Invalid Bandwidth
+};
+
+const RadioLoRaBandwidths_t Bandwidths[] = { LORA_BW_125, LORA_BW_250, LORA_BW_500 };
+
+uint8_t MaxPayloadLength = 0xFF;
+
+uint32_t TxTimeout = 0;
+uint32_t RxTimeout = 0;
+
+bool RxContinuous = false;
+
+
+PacketStatus_t RadioPktStatus;
+uint8_t RadioRxPayload[255];
+
+volatile bool IrqFired = false;
+
+/*
+ * SX126x DIO IRQ callback functions prototype
+ */
+
+/*!
+ * \brief DIO 0 IRQ callback
+ */
+void RadioOnDioIrq( void* context );
+
+/*
+ * Private global variables
+ */
+
+
+/*!
+ * Holds the current network type for the radio
+ */
+typedef struct
+{
+    bool Previous;
+    bool Current;
+}RadioPublicNetwork_t;
+
+static RadioPublicNetwork_t RadioPublicNetwork = { false };
+
+/*!
+ * Radio callbacks variable
+ */
+static RadioEvents_t* RadioEvents;
+
+/*
+ * Public global variables
+ */
+
+/*!
+ * Radio hardware and global parameters
+ */
+SX126x_t SX126x;
+
+/*!
+ * \brief Holds the internal operating mode of the radio
+ */
+static RadioOperatingModes_t OperatingMode;
+
+//------------------------ board code start 从 board 移动过来的代码 -----------------
+RadioOperatingModes_t SX126xGetOperatingMode( void )
+{
+    return OperatingMode;
+}
+
+void SX126xSetOperatingMode( RadioOperatingModes_t mode )
+{
+    OperatingMode = mode;
+}
+
+void SX126xIoTcxoInit( void )
+{
+    // No TCXO component available on this board design.
+}
+
+uint32_t SX126xGetBoardTcxoWakeupTime( void )
+{
+    return BOARD_TCXO_WAKEUP_TIME;
+}
+
+
+//设置DIO2位RF控制脚
+void SX126xIoRfSwitchInit( void )
+{
+    SX126xSetDio2AsRfSwitchCtrl( true );
+}
+
+//这里天线由内部自动控制，不用专门设置
+void SX126xAntSwOn( void )
+{
+    //GpioInit( &AntPow, RADIO_ANT_SWITCH_POWER, PIN_OUTPUT, PIN_PUSH_PULL, PIN_PULL_UP, 1 );
+}
+//这里天线由内部自动控制，不用专门设置
+void SX126xAntSwOff( void )
+{
+    //GpioInit( &AntPow, RADIO_ANT_SWITCH_POWER, PIN_ANALOGIC, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
+}
+
+uint8_t SX126xGetDeviceId( void )
+{
+    return SX1262;
+}
+
+void SX126xSetRfTxPower( int8_t power )
+{
+    SX126xSetTxParams( power, RADIO_RAMP_40_US );
+}
+
+void SX126xWriteRegister( uint16_t address, uint8_t value )
+{
+    SX126xWriteRegisters( address, &value, 1 );
+}
+
+uint8_t SX126xReadRegister( uint16_t address )
+{
+    uint8_t data;
+    SX126xReadRegisters( address, &data, 1 );
+    return data;
+}
+
+void SX126xWakeup( void )
+{
+	uint8_t status;
+	CRITICAL_SECTION_BEGIN( );
+
+	SX126xSetNss(0);
+
+	status = SX126xSpiInOut(RADIO_GET_STATUS );
+        //printf("status = %d\r\n", status);
+	SX126xSpiInOut(0x00 );
+
+	SX126xSetNss(1);
+
+	// Wait for chip to be ready.
+	SX126xWaitOnBusy( );
+
+	// Update operating mode context variable
+	SX126xSetOperatingMode( MODE_STDBY_RC );
+
+	CRITICAL_SECTION_END( );
+}
+
+void SX126xWriteCommand( RadioCommands_t command, uint8_t *buffer, uint16_t size )
+{
+	uint16_t i = 0;
+	
+	SX126xCheckDeviceReady( );
+
+	SX126xSetNss(0);
+
+	SX126xSpiInOut(( uint8_t )command);
+
+	for( i = 0; i < size; i++ ){
+		SX126xSpiInOut(buffer[i]);
+	}
+
+	SX126xSetNss(1);
+
+	if( command != RADIO_SET_SLEEP ){
+		SX126xWaitOnBusy( );
+	}
+}
+
+uint8_t SX126xReadCommand( RadioCommands_t command, uint8_t *buffer, uint16_t size )
+{
+	uint8_t status = 0;
+	uint16_t i = 0;
+	
+	SX126xCheckDeviceReady( );
+
+	SX126xSetNss(0);
+
+	SX126xSpiInOut(( uint8_t )command);
+	status = SX126xSpiInOut(0x00);
+	for( i = 0; i < size; i++ ){
+		buffer[i] = SX126xSpiInOut(0);
+	}
+
+	SX126xSetNss(1);
+
+	SX126xWaitOnBusy( );
+
+	return status;
+}
+
+void SX126xWriteRegisters( uint16_t address, uint8_t *buffer, uint16_t size )
+{
+	uint16_t i = 0;
+	
+	SX126xCheckDeviceReady( );
+
+	SX126xSetNss(0);
+    
+	SX126xSpiInOut(RADIO_WRITE_REGISTER );
+	SX126xSpiInOut(( address & 0xFF00 ) >> 8 );
+	SX126xSpiInOut( address & 0x00FF );
+    
+	for( i = 0; i < size; i++ ){
+		SX126xSpiInOut(buffer[i] );
+	}
+
+	SX126xSetNss(1);
+
+	SX126xWaitOnBusy( );
+}
+
+void SX126xReadRegisters( uint16_t address, uint8_t *buffer, uint16_t size )
+{
+	uint16_t i = 0;
+	
+	SX126xCheckDeviceReady( );
+	SX126xSetNss(0);
+	
+	SX126xSpiInOut(RADIO_READ_REGISTER);
+	SX126xSpiInOut(( address & 0xFF00 ) >> 8);
+	SX126xSpiInOut(address & 0x00FF);
+	SX126xSpiInOut(0);
+	
+	for( i = 0; i < size; i++ ){
+		buffer[i] = SX126xSpiInOut(0);
+	}
+	SX126xSetNss(1);
+
+	SX126xWaitOnBusy( );
+}
+
+void SX126xWriteBuffer( uint8_t offset, uint8_t *buffer, uint8_t size )
+{
+	uint16_t i = 0;
+	
+	SX126xCheckDeviceReady( );
+
+	SX126xSetNss(0);
+
+	SX126xSpiInOut(RADIO_WRITE_BUFFER );
+	SX126xSpiInOut(offset );
+	for( i = 0; i < size; i++ ){
+		SX126xSpiInOut(buffer[i] );
+	}
+	SX126xSetNss(1);
+
+	SX126xWaitOnBusy( );
+}
+
+void SX126xReadBuffer( uint8_t offset, uint8_t *buffer, uint8_t size )
+{
+	uint16_t i = 0;
+	
+	SX126xCheckDeviceReady( );
+
+	SX126xSetNss(0);
+
+	SX126xSpiInOut(RADIO_READ_BUFFER );
+	SX126xSpiInOut(offset );
+	SX126xSpiInOut(0 );
+	for( i = 0; i < size; i++ ){
+		buffer[i] = SX126xSpiInOut(0);
+	}
+	SX126xSetNss(1);
+
+	SX126xWaitOnBusy( );
+}
+//------------------------ board code end -----------------
+
+/*!
+ * Returns the known FSK bandwidth registers value
+ *
+ * \param [IN] bandwidth Bandwidth value in Hz
+ * \retval regValue Bandwidth register value.
+ */
+static uint8_t RadioGetFskBandwidthRegValue( uint32_t bandwidth )
+{
+    uint8_t i;
+
+    if( bandwidth == 0 )
+    {
+        return( 0x1F );
+    }
+
+    for( i = 0; i < ( sizeof( FskBandwidths ) / sizeof( FskBandwidth_t ) ) - 1; i++ )
+    {
+        if( ( bandwidth >= FskBandwidths[i].bandwidth ) && ( bandwidth < FskBandwidths[i + 1].bandwidth ) )
+        {
+            return FskBandwidths[i+1].RegValue;
+        }
+    }
+    // ERROR: Value not found
+    while( 1 );
+}
+
+void RadioInit( RadioEvents_t *events )
+{
+    RadioEvents = events;
+
+    SX126xIoInit();
+    SX126xInit( RadioOnDioIrq );
+    SX126xSetStandby( STDBY_RC );
+    SX126xSetRegulatorMode( USE_DCDC );
+
+    SX126xSetBufferBaseAddress( 0x00, 0x00 );
+    SX126xSetTxParams( 0, RADIO_RAMP_200_US );
+    SX126xSetDioIrqParams( IRQ_RADIO_ALL, IRQ_RADIO_ALL, IRQ_RADIO_NONE, IRQ_RADIO_NONE );
+
+    SX126xTimerInit();
+
+    IrqFired = false;
+}
+
+RadioState_t RadioGetStatus( void )
+{
+    switch( SX126xGetOperatingMode( ) )
+    {
+        case MODE_TX:
+            return RF_TX_RUNNING;
+        case MODE_RX:
+            return RF_RX_RUNNING;
+        case MODE_CAD:
+            return RF_CAD;
+        default:
+            return RF_IDLE;
+    }
+}
+
+void RadioSetModem( RadioModems_t modem )
+{
+    switch( modem )
+    {
+    default:
+    case MODEM_FSK:
+        SX126xSetPacketType( PACKET_TYPE_GFSK );
+        // When switching to GFSK mode the LoRa SyncWord register value is reset
+        // Thus, we also reset the RadioPublicNetwork variable
+        RadioPublicNetwork.Current = false;
+        break;
+    case MODEM_LORA:
+        SX126xSetPacketType( PACKET_TYPE_LORA );
+        // Public/Private network register is reset when switching modems
+        if( RadioPublicNetwork.Current != RadioPublicNetwork.Previous )
+        {
+            RadioPublicNetwork.Current = RadioPublicNetwork.Previous;
+            RadioSetPublicNetwork( RadioPublicNetwork.Current );
+        }
+        break;
+    }
+}
+
+void RadioSetChannel( uint32_t freq )
+{
+    SX126xSetRfFrequency( freq );
+}
+
+bool RadioIsChannelFree( uint32_t freq, uint32_t rxBandwidth, int16_t rssiThresh, uint32_t maxCarrierSenseTime )
+{
+    bool     status           = true;
+    int16_t  rssi             = 0;
+    uint32_t count = 0;
+
+    RadioSetModem( MODEM_FSK );
+
+    RadioSetChannel( freq );
+
+    // Set Rx bandwidth. Other parameters are not used.
+    RadioSetRxConfig( MODEM_FSK, rxBandwidth, 600, 0, rxBandwidth, 3, 0, false,
+                      0, false, 0, 0, false, true );
+    RadioRx( 0 );
+
+    SX126xDelayMs( 1 );
+
+    // Perform carrier sense for maxCarrierSenseTime
+		count = 0;
+    while( count < maxCarrierSenseTime )
+    {
+        rssi = RadioRssi( MODEM_FSK );
+
+        if( rssi > rssiThresh )
+        {
+            status = false;
+            break;
+        }
+				SX126xDelayMs( 1 );
+				count++;
+    }
+    RadioSleep( );
+    return status;
+}
+
+uint32_t RadioRandom( void )
+{
+    uint32_t rnd = 0;
+
+    /*
+     * Radio setup for random number generation
+     */
+    // Set LoRa modem ON
+    RadioSetModem( MODEM_LORA );
+
+    // Disable LoRa modem interrupts
+    SX126xSetDioIrqParams( IRQ_RADIO_NONE, IRQ_RADIO_NONE, IRQ_RADIO_NONE, IRQ_RADIO_NONE );
+
+    rnd = SX126xGetRandom( );
+
+    return rnd;
+}
+
+void RadioSetRxConfig( RadioModems_t modem, uint32_t bandwidth,
+                         uint32_t datarate, uint8_t coderate,
+                         uint32_t bandwidthAfc, uint16_t preambleLen,
+                         uint16_t symbTimeout, bool fixLen,
+                         uint8_t payloadLen,
+                         bool crcOn, bool freqHopOn, uint8_t hopPeriod,
+                         bool iqInverted, bool rxContinuous )
+{
+    uint8_t syncWordBuf[]={ 0xC1, 0x94, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x00 };
+		
+    RxContinuous = rxContinuous;
+    if( rxContinuous == true )
+    {
+        symbTimeout = 0;
+    }
+    if( fixLen == true )
+    {
+        MaxPayloadLength = payloadLen;
+    }
+    else
+    {
+        MaxPayloadLength = 0xFF;
+    }
+
+    switch( modem )
+    {
+        case MODEM_FSK:
+            SX126xSetStopRxTimerOnPreambleDetect( false );
+            SX126x.ModulationParams.PacketType = PACKET_TYPE_GFSK;
+
+            SX126x.ModulationParams.Params.Gfsk.BitRate = datarate;
+            SX126x.ModulationParams.Params.Gfsk.ModulationShaping = MOD_SHAPING_G_BT_1;
+            SX126x.ModulationParams.Params.Gfsk.Bandwidth = RadioGetFskBandwidthRegValue( bandwidth << 1 ); // SX126x badwidth is double sided
+
+            SX126x.PacketParams.PacketType = PACKET_TYPE_GFSK;
+            SX126x.PacketParams.Params.Gfsk.PreambleLength = ( preambleLen << 3 ); // convert byte into bit
+            SX126x.PacketParams.Params.Gfsk.PreambleMinDetect = RADIO_PREAMBLE_DETECTOR_08_BITS;
+            SX126x.PacketParams.Params.Gfsk.SyncWordLength = 3 << 3; // convert byte into bit
+            SX126x.PacketParams.Params.Gfsk.AddrComp = RADIO_ADDRESSCOMP_FILT_OFF;
+            SX126x.PacketParams.Params.Gfsk.HeaderType = ( fixLen == true ) ? RADIO_PACKET_FIXED_LENGTH : RADIO_PACKET_VARIABLE_LENGTH;
+            SX126x.PacketParams.Params.Gfsk.PayloadLength = MaxPayloadLength;
+            if( crcOn == true )
+            {
+                SX126x.PacketParams.Params.Gfsk.CrcLength = RADIO_CRC_2_BYTES_CCIT;
+            }
+            else
+            {
+                SX126x.PacketParams.Params.Gfsk.CrcLength = RADIO_CRC_OFF;
+            }
+            SX126x.PacketParams.Params.Gfsk.DcFree = RADIO_DC_FREEWHITENING;
+
+            RadioStandby( );
+            RadioSetModem( ( SX126x.ModulationParams.PacketType == PACKET_TYPE_GFSK ) ? MODEM_FSK : MODEM_LORA );
+            SX126xSetModulationParams( &SX126x.ModulationParams );
+            SX126xSetPacketParams( &SX126x.PacketParams );
+            SX126xSetSyncWord( syncWordBuf );
+            SX126xSetWhiteningSeed( 0x01FF );
+
+            RxTimeout = ( uint32_t )symbTimeout * 8000UL / datarate;
+            break;
+
+        case MODEM_LORA:
+            SX126xSetStopRxTimerOnPreambleDetect( false );
+            SX126x.ModulationParams.PacketType = PACKET_TYPE_LORA;
+            SX126x.ModulationParams.Params.LoRa.SpreadingFactor = ( RadioLoRaSpreadingFactors_t )datarate;
+            SX126x.ModulationParams.Params.LoRa.Bandwidth = Bandwidths[bandwidth];
+            SX126x.ModulationParams.Params.LoRa.CodingRate = ( RadioLoRaCodingRates_t )coderate;
+
+            if( ( ( bandwidth == 0 ) && ( ( datarate == 11 ) || ( datarate == 12 ) ) ) ||
+            ( ( bandwidth == 1 ) && ( datarate == 12 ) ) )
+            {
+                SX126x.ModulationParams.Params.LoRa.LowDatarateOptimize = 0x01;
+            }
+            else
+            {
+                SX126x.ModulationParams.Params.LoRa.LowDatarateOptimize = 0x00;
+            }
+
+            SX126x.PacketParams.PacketType = PACKET_TYPE_LORA;
+
+            if( ( SX126x.ModulationParams.Params.LoRa.SpreadingFactor == LORA_SF5 ) ||
+                ( SX126x.ModulationParams.Params.LoRa.SpreadingFactor == LORA_SF6 ) )
+            {
+                if( preambleLen < 12 )
+                {
+                    SX126x.PacketParams.Params.LoRa.PreambleLength = 12;
+                }
+                else
+                {
+                    SX126x.PacketParams.Params.LoRa.PreambleLength = preambleLen;
+                }
+            }
+            else
+            {
+                SX126x.PacketParams.Params.LoRa.PreambleLength = preambleLen;
+            }
+
+            SX126x.PacketParams.Params.LoRa.HeaderType = ( RadioLoRaPacketLengthsMode_t )fixLen;
+
+            SX126x.PacketParams.Params.LoRa.PayloadLength = MaxPayloadLength;
+            SX126x.PacketParams.Params.LoRa.CrcMode = ( RadioLoRaCrcModes_t )crcOn;
+            SX126x.PacketParams.Params.LoRa.InvertIQ = ( RadioLoRaIQModes_t )iqInverted;
+
+            RadioStandby( );
+            RadioSetModem( ( SX126x.ModulationParams.PacketType == PACKET_TYPE_GFSK ) ? MODEM_FSK : MODEM_LORA );
+            SX126xSetModulationParams( &SX126x.ModulationParams );
+            SX126xSetPacketParams( &SX126x.PacketParams );
+            SX126xSetLoRaSymbNumTimeout( symbTimeout );
+
+            // WORKAROUND - Optimizing the Inverted IQ Operation, see DS_SX1261-2_V1.2 datasheet chapter 15.4
+            if( SX126x.PacketParams.Params.LoRa.InvertIQ == LORA_IQ_INVERTED )
+            {
+                // RegIqPolaritySetup = @address 0x0736
+                SX126xWriteRegister( 0x0736, SX126xReadRegister( 0x0736 ) & ~( 1 << 2 ) );
+            }
+            else
+            {
+                // RegIqPolaritySetup @address 0x0736
+                SX126xWriteRegister( 0x0736, SX126xReadRegister( 0x0736 ) | ( 1 << 2 ) );
+            }
+            // WORKAROUND END
+
+            // Timeout Max, Timeout handled directly in SetRx function
+            RxTimeout = 0xFFFF;
+
+            break;
+    }
+}
+
+void RadioSetTxConfig( RadioModems_t modem, int8_t power, uint32_t fdev,
+                        uint32_t bandwidth, uint32_t datarate,
+                        uint8_t coderate, uint16_t preambleLen,
+                        bool fixLen, bool crcOn, bool freqHopOn,
+                        uint8_t hopPeriod, bool iqInverted, uint32_t timeout )
+{
+    uint8_t syncWordBuf[] = { 0xC1, 0x94, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x00 };
+		
+    switch( modem )
+    {
+        case MODEM_FSK:
+            SX126x.ModulationParams.PacketType = PACKET_TYPE_GFSK;
+            SX126x.ModulationParams.Params.Gfsk.BitRate = datarate;
+
+            SX126x.ModulationParams.Params.Gfsk.ModulationShaping = MOD_SHAPING_G_BT_1;
+            SX126x.ModulationParams.Params.Gfsk.Bandwidth = RadioGetFskBandwidthRegValue( bandwidth << 1 ); // SX126x badwidth is double sided
+            SX126x.ModulationParams.Params.Gfsk.Fdev = fdev;
+
+            SX126x.PacketParams.PacketType = PACKET_TYPE_GFSK;
+            SX126x.PacketParams.Params.Gfsk.PreambleLength = ( preambleLen << 3 ); // convert byte into bit
+            SX126x.PacketParams.Params.Gfsk.PreambleMinDetect = RADIO_PREAMBLE_DETECTOR_08_BITS;
+            SX126x.PacketParams.Params.Gfsk.SyncWordLength = 3 << 3 ; // convert byte into bit
+            SX126x.PacketParams.Params.Gfsk.AddrComp = RADIO_ADDRESSCOMP_FILT_OFF;
+            SX126x.PacketParams.Params.Gfsk.HeaderType = ( fixLen == true ) ? RADIO_PACKET_FIXED_LENGTH : RADIO_PACKET_VARIABLE_LENGTH;
+
+            if( crcOn == true )
+            {
+                SX126x.PacketParams.Params.Gfsk.CrcLength = RADIO_CRC_2_BYTES_CCIT;
+            }
+            else
+            {
+                SX126x.PacketParams.Params.Gfsk.CrcLength = RADIO_CRC_OFF;
+            }
+            SX126x.PacketParams.Params.Gfsk.DcFree = RADIO_DC_FREEWHITENING;
+
+            RadioStandby( );
+            RadioSetModem( ( SX126x.ModulationParams.PacketType == PACKET_TYPE_GFSK ) ? MODEM_FSK : MODEM_LORA );
+            SX126xSetModulationParams( &SX126x.ModulationParams );
+            SX126xSetPacketParams( &SX126x.PacketParams );
+            SX126xSetSyncWord( syncWordBuf );
+            SX126xSetWhiteningSeed( 0x01FF );
+            break;
+
+        case MODEM_LORA:
+            SX126x.ModulationParams.PacketType = PACKET_TYPE_LORA;
+            SX126x.ModulationParams.Params.LoRa.SpreadingFactor = ( RadioLoRaSpreadingFactors_t ) datarate;
+            SX126x.ModulationParams.Params.LoRa.Bandwidth =  Bandwidths[bandwidth];
+            SX126x.ModulationParams.Params.LoRa.CodingRate= ( RadioLoRaCodingRates_t )coderate;
+
+            if( ( ( bandwidth == 0 ) && ( ( datarate == 11 ) || ( datarate == 12 ) ) ) ||
+            ( ( bandwidth == 1 ) && ( datarate == 12 ) ) )
+            {
+                SX126x.ModulationParams.Params.LoRa.LowDatarateOptimize = 0x01;
+            }
+            else
+            {
+                SX126x.ModulationParams.Params.LoRa.LowDatarateOptimize = 0x00;
+            }
+
+            SX126x.PacketParams.PacketType = PACKET_TYPE_LORA;
+
+            if( ( SX126x.ModulationParams.Params.LoRa.SpreadingFactor == LORA_SF5 ) ||
+                ( SX126x.ModulationParams.Params.LoRa.SpreadingFactor == LORA_SF6 ) )
+            {
+                if( preambleLen < 12 )
+                {
+                    SX126x.PacketParams.Params.LoRa.PreambleLength = 12;
+                }
+                else
+                {
+                    SX126x.PacketParams.Params.LoRa.PreambleLength = preambleLen;
+                }
+            }
+            else
+            {
+                SX126x.PacketParams.Params.LoRa.PreambleLength = preambleLen;
+            }
+
+            SX126x.PacketParams.Params.LoRa.HeaderType = ( RadioLoRaPacketLengthsMode_t )fixLen;
+            SX126x.PacketParams.Params.LoRa.PayloadLength = MaxPayloadLength;
+            SX126x.PacketParams.Params.LoRa.CrcMode = ( RadioLoRaCrcModes_t )crcOn;
+            SX126x.PacketParams.Params.LoRa.InvertIQ = ( RadioLoRaIQModes_t )iqInverted;
+
+            RadioStandby( );
+            RadioSetModem( ( SX126x.ModulationParams.PacketType == PACKET_TYPE_GFSK ) ? MODEM_FSK : MODEM_LORA );
+            SX126xSetModulationParams( &SX126x.ModulationParams );
+            SX126xSetPacketParams( &SX126x.PacketParams );
+            break;
+    }
+
+    // WORKAROUND - Modulation Quality with 500 kHz LoRa Bandwidth, see DS_SX1261-2_V1.2 datasheet chapter 15.1
+    if( ( modem == MODEM_LORA ) && ( SX126x.ModulationParams.Params.LoRa.Bandwidth == LORA_BW_500 ) )
+    {
+        // RegTxModulation = @address 0x0889
+        SX126xWriteRegister( 0x0889, SX126xReadRegister( 0x0889 ) & ~( 1 << 2 ) );
+    }
+    else
+    {
+        // RegTxModulation = @address 0x0889
+        SX126xWriteRegister( 0x0889, SX126xReadRegister( 0x0889 ) | ( 1 << 2 ) );
+    }
+    // WORKAROUND END
+
+    SX126xSetRfTxPower( power );
+    TxTimeout = timeout;
+}
+
+bool RadioCheckRfFrequency( uint32_t frequency )
+{
+    return true;
+}
+
+static uint32_t RadioGetLoRaBandwidthInHz( RadioLoRaBandwidths_t bw )
+{
+    uint32_t bandwidthInHz = 0;
+
+    switch( bw )
+    {
+    case LORA_BW_007:
+        bandwidthInHz = 7812UL;
+        break;
+    case LORA_BW_010:
+        bandwidthInHz = 10417UL;
+        break;
+    case LORA_BW_015:
+        bandwidthInHz = 15625UL;
+        break;
+    case LORA_BW_020:
+        bandwidthInHz = 20833UL;
+        break;
+    case LORA_BW_031:
+        bandwidthInHz = 31250UL;
+        break;
+    case LORA_BW_041:
+        bandwidthInHz = 41667UL;
+        break;
+    case LORA_BW_062:
+        bandwidthInHz = 62500UL;
+        break;
+    case LORA_BW_125:
+        bandwidthInHz = 125000UL;
+        break;
+    case LORA_BW_250:
+        bandwidthInHz = 250000UL;
+        break;
+    case LORA_BW_500:
+        bandwidthInHz = 500000UL;
+        break;
+    }
+
+    return bandwidthInHz;
+}
+
+static uint32_t RadioGetGfskTimeOnAirNumerator( uint32_t datarate, uint8_t coderate,
+                              uint16_t preambleLen, bool fixLen, uint8_t payloadLen,
+                              bool crcOn )
+{
+    const RadioAddressComp_t addrComp = RADIO_ADDRESSCOMP_FILT_OFF;
+    const uint8_t syncWordLength = 3;
+
+    return ( preambleLen << 3 ) +
+           ( ( fixLen == false ) ? 8 : 0 ) +
+             ( syncWordLength << 3 ) +
+             ( ( payloadLen +
+               ( addrComp == RADIO_ADDRESSCOMP_FILT_OFF ? 0 : 1 ) +
+               ( ( crcOn == true ) ? 2 : 0 ) 
+               ) << 3 
+             );
+}
+
+static uint32_t RadioGetLoRaTimeOnAirNumerator( uint32_t bandwidth,
+                              uint32_t datarate, uint8_t coderate,
+                              uint16_t preambleLen, bool fixLen, uint8_t payloadLen,
+                              bool crcOn )
+{
+    int32_t crDenom           = coderate + 4;
+    bool    lowDatareOptimize = false;
+    int32_t ceilDenominator;
+    int32_t ceilNumerator = 0;
+    int32_t intermediate = 0;
+
+    // Ensure that the preamble length is at least 12 symbols when using SF5 or
+    // SF6
+    if( ( datarate == 5 ) || ( datarate == 6 ) )
+    {
+        if( preambleLen < 12 )
+        {
+            preambleLen = 12;
+        }
+    }
+
+    if( ( ( bandwidth == 0 ) && ( ( datarate == 11 ) || ( datarate == 12 ) ) ) ||
+        ( ( bandwidth == 1 ) && ( datarate == 12 ) ) )
+    {
+        lowDatareOptimize = true;
+    }
+
+    
+    ceilNumerator = ( payloadLen << 3 ) +
+                            ( crcOn ? 16 : 0 ) -
+                            ( 4 * datarate ) +
+                            ( fixLen ? 0 : 20 );
+
+    if( datarate <= 6 )
+    {
+        ceilDenominator = 4 * datarate;
+    }
+    else
+    {
+        ceilNumerator += 8;
+
+        if( lowDatareOptimize == true )
+        {
+            ceilDenominator = 4 * ( datarate - 2 );
+        }
+        else
+        {
+            ceilDenominator = 4 * datarate;
+        }
+    }
+
+    if( ceilNumerator < 0 )
+    {
+        ceilNumerator = 0;
+    }
+
+    // Perform integral ceil()
+    intermediate =
+        ( ( ceilNumerator + ceilDenominator - 1 ) / ceilDenominator ) * crDenom + preambleLen + 12;
+
+    if( datarate <= 6 )
+    {
+        intermediate += 2;
+    }
+
+    return ( uint32_t )( ( 4 * intermediate + 1 ) * ( 1 << ( datarate - 2 ) ) );
+}
+
+uint32_t RadioTimeOnAir( RadioModems_t modem, uint32_t bandwidth,
+                              uint32_t datarate, uint8_t coderate,
+                              uint16_t preambleLen, bool fixLen, uint8_t payloadLen,
+                              bool crcOn )
+{
+    uint32_t numerator = 0;
+    uint32_t denominator = 1;
+
+    switch( modem )
+    {
+    case MODEM_FSK:
+        {
+            numerator   = 1000U * RadioGetGfskTimeOnAirNumerator( datarate, coderate,
+                                                                  preambleLen, fixLen,
+                                                                  payloadLen, crcOn );
+            denominator = datarate;
+        }
+        break;
+    case MODEM_LORA:
+        {
+            numerator   = 1000U * RadioGetLoRaTimeOnAirNumerator( bandwidth, datarate,
+                                                                  coderate, preambleLen,
+                                                                  fixLen, payloadLen, crcOn );
+            denominator = RadioGetLoRaBandwidthInHz( Bandwidths[bandwidth] );
+        }
+        break;
+    }
+    // Perform integral ceil()
+    return ( numerator + denominator - 1 ) / denominator;
+}
+
+uint32_t RadioTimeOnAir2( RadioModems_t modem, uint8_t pktLen )
+{
+    uint32_t airTime = 0;
+
+    switch( modem )
+    {
+    case MODEM_FSK:
+        {
+           airTime = rint( ( 8 * ( SX126x.PacketParams.Params.Gfsk.PreambleLength +
+                                     ( SX126x.PacketParams.Params.Gfsk.SyncWordLength >> 3 ) +
+                                     ( ( SX126x.PacketParams.Params.Gfsk.HeaderType == RADIO_PACKET_FIXED_LENGTH ) ? 0.0 : 1.0 ) +
+                                     pktLen +
+                                     ( ( SX126x.PacketParams.Params.Gfsk.CrcLength == RADIO_CRC_2_BYTES ) ? 2.0 : 0 ) ) /
+                                     SX126x.ModulationParams.Params.Gfsk.BitRate ) * 1e3 );
+        }
+        break;
+    case MODEM_LORA:
+        {
+            double ts = RadioLoRaSymbTime[SX126x.ModulationParams.Params.LoRa.Bandwidth - 4][12 - SX126x.ModulationParams.Params.LoRa.SpreadingFactor];
+            // time of preamble
+            double tPreamble = ( SX126x.PacketParams.Params.LoRa.PreambleLength + 4.25 ) * ts;
+            // Symbol length of payload and time
+            double tmp = ceil( ( 8 * pktLen - 4 * SX126x.ModulationParams.Params.LoRa.SpreadingFactor +
+                                 28 + 16 * SX126x.PacketParams.Params.LoRa.CrcMode -
+                                 ( ( SX126x.PacketParams.Params.LoRa.HeaderType == LORA_PACKET_FIXED_LENGTH ) ? 20 : 0 ) ) /
+                                 ( double )( 4 * ( SX126x.ModulationParams.Params.LoRa.SpreadingFactor -
+                                 ( ( SX126x.ModulationParams.Params.LoRa.LowDatarateOptimize > 0 ) ? 2 : 0 ) ) ) ) *
+                                 ( ( SX126x.ModulationParams.Params.LoRa.CodingRate % 4 ) + 4 );
+            double nPayload = 8 + ( ( tmp > 0 ) ? tmp : 0 );
+            double tPayload = nPayload * ts;
+            // Time on air
+            double tOnAir = tPreamble + tPayload;
+            // return milli seconds
+            airTime = floor( tOnAir + 0.999 );
+        }
+        break;
+    }
+    return airTime;
+}
+void RadioSend( uint8_t *buffer, uint8_t size )
+{
+    SX126xSetDioIrqParams( IRQ_TX_DONE | IRQ_RX_TX_TIMEOUT,
+                           IRQ_TX_DONE | IRQ_RX_TX_TIMEOUT,
+                           IRQ_RADIO_NONE,
+                           IRQ_RADIO_NONE );
+
+    if( SX126xGetPacketType( ) == PACKET_TYPE_LORA )
+    {
+        SX126x.PacketParams.Params.LoRa.PayloadLength = size;
+    }
+    else
+    {
+        SX126x.PacketParams.Params.Gfsk.PayloadLength = size;
+    }
+    SX126xSetPacketParams( &SX126x.PacketParams );
+
+    SX126xSendPayload( buffer, size, 0 );
+    SX126xSetTxTimerValue(TxTimeout);
+    SX126xTxTimerStart();
+}
+
+void RadioSleep( void )
+{
+    SleepParams_t params = { 0 };
+
+    params.Fields.WarmStart = 1;
+    SX126xSetSleep( params );
+
+    SX126xDelayMs( 2 );
+}
+
+void RadioStandby( void )
+{
+//	printf("lora set standby\n");
+    SX126xSetStandby( STDBY_RC );
+}
+
+void RadioRx( uint32_t timeout )
+{
+//	printf("lora set rx\n");
+    SX126xSetDioIrqParams( IRQ_RADIO_ALL, //IRQ_RX_DONE | IRQ_RX_TX_TIMEOUT,
+                           IRQ_RADIO_ALL, //IRQ_RX_DONE | IRQ_RX_TX_TIMEOUT,
+                           IRQ_RADIO_NONE,
+                           IRQ_RADIO_NONE );
+
+    if( timeout != 0 )
+    {
+        SX126xSetRxTimerValue(timeout);
+        SX126xRxTimerStart();
+    }
+
+    if( RxContinuous == true )
+    {
+        SX126xSetRx( 0xFFFFFF ); // Rx Continuous
+    }
+    else
+    {
+        SX126xSetRx( RxTimeout << 6 );
+    }
+}
+
+void RadioRxBoosted( uint32_t timeout )
+{
+    SX126xSetDioIrqParams( IRQ_RADIO_ALL, //IRQ_RX_DONE | IRQ_RX_TX_TIMEOUT,
+                           IRQ_RADIO_ALL, //IRQ_RX_DONE | IRQ_RX_TX_TIMEOUT,
+                           IRQ_RADIO_NONE,
+                           IRQ_RADIO_NONE );
+
+    if( timeout != 0 )
+    {
+        SX126xSetRxTimerValue(timeout);
+        SX126xRxTimerStart();
+    }
+
+    if( RxContinuous == true )
+    {
+        SX126xSetRxBoosted( 0xFFFFFF ); // Rx Continuous
+    }
+    else
+    {
+        SX126xSetRxBoosted( RxTimeout << 6 );
+    }
+}
+
+void RadioSetRxDutyCycle( uint32_t rxTime, uint32_t sleepTime )
+{
+    SX126xSetRxDutyCycle( rxTime, sleepTime );
+}
+
+void RadioStartCad( void )
+{
+    SX126xSetDioIrqParams( IRQ_CAD_DONE | IRQ_CAD_ACTIVITY_DETECTED, IRQ_CAD_DONE | IRQ_CAD_ACTIVITY_DETECTED, IRQ_RADIO_NONE, IRQ_RADIO_NONE );
+    SX126xSetCad( );
+}
+
+void RadioSetTxContinuousWave( uint32_t freq, int8_t power, uint16_t time )
+{
+    uint32_t timeout = ( uint32_t )time * 1000;
+
+    SX126xSetRfFrequency( freq );
+    SX126xSetRfTxPower( power );
+    SX126xSetTxContinuousWave( );
+
+    SX126xSetTxTimerValue(timeout);
+    SX126xTxTimerStart();
+}
+
+int16_t RadioRssi( RadioModems_t modem )
+{
+    return SX126xGetRssiInst( );
+}
+
+void RadioWrite( uint32_t addr, uint8_t data )
+{
+    SX126xWriteRegister( addr, data );
+}
+
+uint8_t RadioRead( uint32_t addr )
+{
+    return SX126xReadRegister( addr );
+}
+
+void RadioWriteBuffer( uint32_t addr, uint8_t *buffer, uint8_t size )
+{
+    SX126xWriteRegisters( addr, buffer, size );
+}
+
+void RadioReadBuffer( uint32_t addr, uint8_t *buffer, uint8_t size )
+{
+    SX126xReadRegisters( addr, buffer, size );
+}
+
+void RadioSetMaxPayloadLength( RadioModems_t modem, uint8_t max )
+{
+    if( modem == MODEM_LORA )
+    {
+        SX126x.PacketParams.Params.LoRa.PayloadLength = MaxPayloadLength = max;
+        SX126xSetPacketParams( &SX126x.PacketParams );
+    }
+    else
+    {
+        if( SX126x.PacketParams.Params.Gfsk.HeaderType == RADIO_PACKET_VARIABLE_LENGTH )
+        {
+            SX126x.PacketParams.Params.Gfsk.PayloadLength = MaxPayloadLength = max;
+            SX126xSetPacketParams( &SX126x.PacketParams );
+        }
+    }
+}
+
+void RadioSetPublicNetwork( bool enable )
+{
+    RadioPublicNetwork.Current = RadioPublicNetwork.Previous = enable;
+
+    RadioSetModem( MODEM_LORA );
+    if( enable == true )
+    {
+        // Change LoRa modem SyncWord
+        SX126xWriteRegister( REG_LR_SYNCWORD, ( LORA_MAC_PUBLIC_SYNCWORD >> 8 ) & 0xFF );
+        SX126xWriteRegister( REG_LR_SYNCWORD + 1, LORA_MAC_PUBLIC_SYNCWORD & 0xFF );
+    }
+    else
+    {
+        // Change LoRa modem SyncWord
+        SX126xWriteRegister( REG_LR_SYNCWORD, ( LORA_MAC_PRIVATE_SYNCWORD >> 8 ) & 0xFF );
+        SX126xWriteRegister( REG_LR_SYNCWORD + 1, LORA_MAC_PRIVATE_SYNCWORD & 0xFF );
+    }
+}
+
+uint32_t RadioGetWakeupTime( void )
+{
+    return SX126xGetBoardTcxoWakeupTime( ) + RADIO_WAKEUP_TIME;
+}
+
+void RadioOnTxTimeoutIrq( void* context )
+{
+    if( ( RadioEvents != NULL ) && ( RadioEvents->TxTimeout != NULL ) )
+    {
+        RadioEvents->TxTimeout( );
+    }
+}
+
+void RadioOnRxTimeoutIrq( void* context )
+{
+    if( ( RadioEvents != NULL ) && ( RadioEvents->RxTimeout != NULL ) )
+    {
+        RadioEvents->RxTimeout( );
+    }
+}
+
+void RadioOnDioIrq( void* context )
+{
+    IrqFired = true;
+}
+
+//int count = 0;
+void RadioIrqProcess( void )
+{
+    uint16_t irqRegs = 0;
+//	count++;
+//	if(count > 100)
+//	{
+//		printf("lora irq begin\n");
+//		count = 0;
+//	}
+    if( IrqFired == true )
+    {
+//			printf("lora irq ture\n");
+        CRITICAL_SECTION_BEGIN( );
+        // Clear IRQ flag
+        IrqFired = false;
+        CRITICAL_SECTION_END( );
+
+        irqRegs = SX126xGetIrqStatus( );
+        SX126xClearIrqStatus( irqRegs );
+//			printf("irqreg: %d\n",irqRegs);
+        if( ( irqRegs & IRQ_TX_DONE ) == IRQ_TX_DONE )
+        {
+            SX126xTxTimerStop();
+            //!< Update operating mode state to a value lower than \ref MODE_STDBY_XOSC
+            SX126xSetOperatingMode( MODE_STDBY_RC );
+            if( ( RadioEvents != NULL ) && ( RadioEvents->TxDone != NULL ) )
+            {
+                RadioEvents->TxDone( );
+            }
+        }
+
+        if( ( irqRegs & IRQ_RX_DONE ) == IRQ_RX_DONE )
+        {
+					
+            if( ( irqRegs & IRQ_CRC_ERROR ) == IRQ_CRC_ERROR )
+            {
+                if( RxContinuous == false )
+                {
+                    //!< Update operating mode state to a value lower than \ref MODE_STDBY_XOSC
+                    SX126xSetOperatingMode( MODE_STDBY_RC );
+                }
+                if( ( RadioEvents != NULL ) && ( RadioEvents->RxError ) )
+                {
+                    RadioEvents->RxError( );
+                }
+								
+            }
+            else
+            {
+                uint8_t size;
+
+                SX126xRxTimerStop();
+                if( RxContinuous == false )
+                {
+                    //!< Update operating mode state to a value lower than \ref MODE_STDBY_XOSC
+                    SX126xSetOperatingMode( MODE_STDBY_RC );
+
+                    // WORKAROUND - Implicit Header Mode Timeout Behavior, see DS_SX1261-2_V1.2 datasheet chapter 15.3
+                    // RegRtcControl = @address 0x0902
+                    SX126xWriteRegister( 0x0902, 0x00 );
+                    // RegEventMask = @address 0x0944
+                    SX126xWriteRegister( 0x0944, SX126xReadRegister( 0x0944 ) | ( 1 << 1 ) );
+                    // WORKAROUND END
+                }
+                SX126xGetPayload( RadioRxPayload, &size , 255 ); //接收的数据放到RadioRxPayload中，size是接收数据的大小
+                SX126xGetPacketStatus( &RadioPktStatus );
+								
+                if( ( RadioEvents != NULL ) && ( RadioEvents->RxDone != NULL ) )
+                {
+                    RadioEvents->RxDone( RadioRxPayload, size, RadioPktStatus.Params.LoRa.RssiPkt, RadioPktStatus.Params.LoRa.SnrPkt );
+
+								}
+//                data_dump("lora rx2:", RadioRxPayload, size);
+//								memcpy(lora_rcv,RadioRxPayload,size);
+//								lora_rcv_len = size;
+//								lora_flag = air_state_send;
+//								air_state = air_state_send;
+								
+            }
+        }
+
+        if( ( irqRegs & IRQ_CAD_DONE ) == IRQ_CAD_DONE )
+        {
+            //!< Update operating mode state to a value lower than \ref MODE_STDBY_XOSC
+            SX126xSetOperatingMode( MODE_STDBY_RC );
+            if( ( RadioEvents != NULL ) && ( RadioEvents->CadDone != NULL ) )
+            {
+                RadioEvents->CadDone( ( ( irqRegs & IRQ_CAD_ACTIVITY_DETECTED ) == IRQ_CAD_ACTIVITY_DETECTED ) );
+            }
+        }
+
+        if( ( irqRegs & IRQ_RX_TX_TIMEOUT ) == IRQ_RX_TX_TIMEOUT )
+        {
+            if( SX126xGetOperatingMode( ) == MODE_TX )
+            {
+                SX126xTxTimerStop();
+                //!< Update operating mode state to a value lower than \ref MODE_STDBY_XOSC
+                SX126xSetOperatingMode( MODE_STDBY_RC );
+                if( ( RadioEvents != NULL ) && ( RadioEvents->TxTimeout != NULL ) )
+                {
+                    RadioEvents->TxTimeout( );
+                }
+            }
+            else if( SX126xGetOperatingMode( ) == MODE_RX )
+            {
+                SX126xRxTimerStop();
+                //!< Update operating mode state to a value lower than \ref MODE_STDBY_XOSC
+                SX126xSetOperatingMode( MODE_STDBY_RC );
+                if( ( RadioEvents != NULL ) && ( RadioEvents->RxTimeout != NULL ) )
+                {
+                    RadioEvents->RxTimeout( );
+                }
+            }
+        }
+
+        if( ( irqRegs & IRQ_PREAMBLE_DETECTED ) == IRQ_PREAMBLE_DETECTED )
+        {
+            //__NOP( );
+        }
+
+        if( ( irqRegs & IRQ_SYNCWORD_VALID ) == IRQ_SYNCWORD_VALID )
+        {
+            //__NOP( );
+        }
+
+        if( ( irqRegs & IRQ_HEADER_VALID ) == IRQ_HEADER_VALID )
+        {
+            //__NOP( );
+        }
+
+        if( ( irqRegs & IRQ_HEADER_ERROR ) == IRQ_HEADER_ERROR )
+        {
+            SX126xRxTimerStop();
+            if( RxContinuous == false )
+            {
+                //!< Update operating mode state to a value lower than \ref MODE_STDBY_XOSC
+                SX126xSetOperatingMode( MODE_STDBY_RC );
+            }
+            if( ( RadioEvents != NULL ) && ( RadioEvents->RxTimeout != NULL ) )
+            {
+                RadioEvents->RxTimeout( );
+            }
+        }
+    }
+}

APP/network_mgr/sx1268/peripherals/radio/sx126x/sx126x.c

@@ -0,0 +1,813 @@
+/*!
+ * \file      sx126x.c
+ *
+ * \brief     SX126x driver implementation
+ *
+ * \copyright Revised BSD License, see section \ref LICENSE.
+ *
+ * \code
+ *                ______                              _
+ *               / _____)             _              | |
+ *              ( (____  _____ ____ _| |_ _____  ____| |__
+ *               \____ \| ___ |    (_   _) ___ |/ ___)  _ \
+ *               _____) ) ____| | | || |_| ____( (___| | | |
+ *              (______/|_____)_|_|_| \__)_____)\____)_| |_|
+ *              (C)2013-2017 Semtech
+ *
+ * \endcode
+ *
+ * \author    Miguel Luis ( Semtech )
+ *
+ * \author    Gregory Cristian ( Semtech )
+ */
+#include <string.h>
+#include "radio.h"
+#include "delay.h"
+#include "sx126x.h"
+#include "sx126x-board.h"
+
+/*!
+ * \brief Internal frequency of the radio
+ */
+#define SX126X_XTAL_FREQ                            32000000UL
+
+/*!
+ * \brief Scaling factor used to perform fixed-point operations
+ */
+#define SX126X_PLL_STEP_SHIFT_AMOUNT                ( 14 )
+
+/*!
+ * \brief PLL step - scaled with SX126X_PLL_STEP_SHIFT_AMOUNT
+ */
+#define SX126X_PLL_STEP_SCALED                      ( SX126X_XTAL_FREQ >> ( 25 - SX126X_PLL_STEP_SHIFT_AMOUNT ) )
+
+/*!
+ * \brief Maximum value for parameter symbNum in \ref SX126xSetLoRaSymbNumTimeout
+ */
+#define SX126X_MAX_LORA_SYMB_NUM_TIMEOUT            248
+
+/*!
+ * \brief Radio registers definition
+ */
+typedef struct
+{
+    uint16_t      Addr;                             //!< The address of the register
+    uint8_t       Value;                            //!< The value of the register
+}RadioRegisters_t;
+
+/*!
+ * \brief Stores the current packet type set in the radio
+ */
+static RadioPacketTypes_t PacketType;
+
+/*!
+ * \brief Stores the current packet header type set in the radio
+ */
+static volatile RadioLoRaPacketLengthsMode_t LoRaHeaderType;
+
+/*!
+ * \brief Stores the last frequency error measured on LoRa received packet
+ */
+volatile uint32_t FrequencyError = 0;
+
+/*!
+ * \brief Hold the status of the Image calibration
+ */
+static bool ImageCalibrated = false;
+
+/*!
+ * \brief Get the number of PLL steps for a given frequency in Hertz
+ *
+ * \param [in] freqInHz Frequency in Hertz
+ *
+ * \returns Number of PLL steps
+ */
+static uint32_t SX126xConvertFreqInHzToPllStep( uint32_t freqInHz );
+
+/*
+ * SX126x DIO IRQ callback functions prototype
+ */
+
+/*!
+ * \brief DIO 0 IRQ callback
+ */
+void SX126xOnDioIrq( void );
+
+/*!
+ * \brief DIO 0 IRQ callback
+ */
+void SX126xSetPollingMode( void );
+
+/*!
+ * \brief DIO 0 IRQ callback
+ */
+void SX126xSetInterruptMode( void );
+
+/*
+ * \brief Process the IRQ if handled by the driver
+ */
+void SX126xProcessIrqs( void );
+
+void SX126xInit( DioIrqHandler dioIrq )
+{
+    SX126xReset( );
+
+    SX126xIoIrqInit( dioIrq );
+
+    SX126xWakeup( );
+    SX126xSetStandby( STDBY_RC );
+
+    // Initialize TCXO control
+    SX126xIoTcxoInit( );
+
+    // Initialize RF switch control
+    SX126xIoRfSwitchInit( );
+
+    SX126xSetOperatingMode( MODE_STDBY_RC );
+}
+
+void SX126xCheckDeviceReady( void )
+{
+    if( ( SX126xGetOperatingMode( ) == MODE_SLEEP ) || ( SX126xGetOperatingMode( ) == MODE_RX_DC ) )
+    {
+        SX126xWakeup( );
+        // Switch is turned off when device is in sleep mode and turned on is all other modes
+        SX126xAntSwOn( );
+    }
+    SX126xWaitOnBusy( );
+}
+
+void SX126xSetPayload( uint8_t *payload, uint8_t size )
+{
+    SX126xWriteBuffer( 0x00, payload, size );
+}
+
+uint8_t SX126xGetPayload( uint8_t *buffer, uint8_t *size,  uint8_t maxSize )
+{
+    uint8_t offset = 0;
+
+    SX126xGetRxBufferStatus( size, &offset );
+    if( *size > maxSize )
+    {
+        return 1;
+    }
+    SX126xReadBuffer( offset, buffer, *size );
+    return 0;
+}
+
+void SX126xSendPayload( uint8_t *payload, uint8_t size, uint32_t timeout )
+{
+    SX126xSetPayload( payload, size );
+    SX126xSetTx( timeout );
+}
+
+uint8_t SX126xSetSyncWord( uint8_t *syncWord )
+{
+    SX126xWriteRegisters( REG_LR_SYNCWORDBASEADDRESS, syncWord, 8 );
+    return 0;
+}
+
+void SX126xSetCrcSeed( uint16_t seed )
+{
+    uint8_t buf[2];
+
+    buf[0] = ( uint8_t )( ( seed >> 8 ) & 0xFF );
+    buf[1] = ( uint8_t )( seed & 0xFF );
+
+    switch( SX126xGetPacketType( ) )
+    {
+        case PACKET_TYPE_GFSK:
+            SX126xWriteRegisters( REG_LR_CRCSEEDBASEADDR, buf, 2 );
+            break;
+
+        default:
+            break;
+    }
+}
+
+void SX126xSetCrcPolynomial( uint16_t polynomial )
+{
+    uint8_t buf[2];
+
+    buf[0] = ( uint8_t )( ( polynomial >> 8 ) & 0xFF );
+    buf[1] = ( uint8_t )( polynomial & 0xFF );
+
+    switch( SX126xGetPacketType( ) )
+    {
+        case PACKET_TYPE_GFSK:
+            SX126xWriteRegisters( REG_LR_CRCPOLYBASEADDR, buf, 2 );
+            break;
+
+        default:
+            break;
+    }
+}
+
+void SX126xSetWhiteningSeed( uint16_t seed )
+{
+    uint8_t regValue = 0;
+    
+    switch( SX126xGetPacketType( ) )
+    {
+        case PACKET_TYPE_GFSK:
+            regValue = SX126xReadRegister( REG_LR_WHITSEEDBASEADDR_MSB ) & 0xFE;
+            regValue = ( ( seed >> 8 ) & 0x01 ) | regValue;
+            SX126xWriteRegister( REG_LR_WHITSEEDBASEADDR_MSB, regValue ); // only 1 bit.
+            SX126xWriteRegister( REG_LR_WHITSEEDBASEADDR_LSB, ( uint8_t )seed );
+            break;
+
+        default:
+            break;
+    }
+}
+
+uint32_t SX126xGetRandom( void )
+{
+    uint32_t number = 0;
+    uint8_t regAnaLna = 0;
+    uint8_t regAnaMixer = 0;
+
+    regAnaLna = SX126xReadRegister( REG_ANA_LNA );
+    SX126xWriteRegister( REG_ANA_LNA, regAnaLna & ~( 1 << 0 ) );
+
+    regAnaMixer = SX126xReadRegister( REG_ANA_MIXER );
+    SX126xWriteRegister( REG_ANA_MIXER, regAnaMixer & ~( 1 << 7 ) );
+
+    // Set radio in continuous reception
+    SX126xSetRx( 0xFFFFFF ); // Rx Continuous
+
+    SX126xReadRegisters( RANDOM_NUMBER_GENERATORBASEADDR, ( uint8_t* )&number, 4 );
+
+    SX126xSetStandby( STDBY_RC );
+
+    SX126xWriteRegister( REG_ANA_LNA, regAnaLna );
+    SX126xWriteRegister( REG_ANA_MIXER, regAnaMixer );
+
+    return number;
+}
+
+void SX126xSetSleep( SleepParams_t sleepConfig )
+{
+    uint8_t value=0;
+
+    SX126xAntSwOff( );
+
+    value = ( ( ( uint8_t )sleepConfig.Fields.WarmStart << 2 ) |
+                      ( ( uint8_t )sleepConfig.Fields.Reset << 1 ) |
+                      ( ( uint8_t )sleepConfig.Fields.WakeUpRTC ) );
+    SX126xWriteCommand( RADIO_SET_SLEEP, &value, 1 );
+    SX126xSetOperatingMode( MODE_SLEEP );
+}
+
+void SX126xSetStandby( RadioStandbyModes_t standbyConfig )
+{
+    SX126xWriteCommand( RADIO_SET_STANDBY, ( uint8_t* )&standbyConfig, 1 );
+    if( standbyConfig == STDBY_RC )
+    {
+        SX126xSetOperatingMode( MODE_STDBY_RC );
+    }
+    else
+    {
+        SX126xSetOperatingMode( MODE_STDBY_XOSC );
+    }
+}
+
+void SX126xSetFs( void )
+{
+    SX126xWriteCommand( RADIO_SET_FS, 0, 0 );
+    SX126xSetOperatingMode( MODE_FS );
+}
+
+void SX126xSetTx( uint32_t timeout )
+{
+    uint8_t buf[3];
+
+    SX126xSetOperatingMode( MODE_TX );
+
+    buf[0] = ( uint8_t )( ( timeout >> 16 ) & 0xFF );
+    buf[1] = ( uint8_t )( ( timeout >> 8 ) & 0xFF );
+    buf[2] = ( uint8_t )( timeout & 0xFF );
+    SX126xWriteCommand( RADIO_SET_TX, buf, 3 );
+}
+
+void SX126xSetRx( uint32_t timeout )
+{
+    uint8_t buf[3];
+
+    SX126xSetOperatingMode( MODE_RX );
+
+    buf[0] = ( uint8_t )( ( timeout >> 16 ) & 0xFF );
+    buf[1] = ( uint8_t )( ( timeout >> 8 ) & 0xFF );
+    buf[2] = ( uint8_t )( timeout & 0xFF );
+    SX126xWriteCommand( RADIO_SET_RX, buf, 3 );
+}
+
+void SX126xSetRxBoosted( uint32_t timeout )
+{
+    uint8_t buf[3];
+
+    SX126xSetOperatingMode( MODE_RX );
+
+    SX126xWriteRegister( REG_RX_GAIN, 0x96 ); // max LNA gain, increase current by ~2mA for around ~3dB in sensivity
+
+    buf[0] = ( uint8_t )( ( timeout >> 16 ) & 0xFF );
+    buf[1] = ( uint8_t )( ( timeout >> 8 ) & 0xFF );
+    buf[2] = ( uint8_t )( timeout & 0xFF );
+    SX126xWriteCommand( RADIO_SET_RX, buf, 3 );
+}
+
+void SX126xSetRxDutyCycle( uint32_t rxTime, uint32_t sleepTime )
+{
+    uint8_t buf[6];
+
+    buf[0] = ( uint8_t )( ( rxTime >> 16 ) & 0xFF );
+    buf[1] = ( uint8_t )( ( rxTime >> 8 ) & 0xFF );
+    buf[2] = ( uint8_t )( rxTime & 0xFF );
+    buf[3] = ( uint8_t )( ( sleepTime >> 16 ) & 0xFF );
+    buf[4] = ( uint8_t )( ( sleepTime >> 8 ) & 0xFF );
+    buf[5] = ( uint8_t )( sleepTime & 0xFF );
+    SX126xWriteCommand( RADIO_SET_RXDUTYCYCLE, buf, 6 );
+    SX126xSetOperatingMode( MODE_RX_DC );
+}
+
+void SX126xSetCad( void )
+{	
+    SX126xWriteCommand( RADIO_SET_CAD, 0, 0 );
+    SX126xSetOperatingMode( MODE_CAD );
+}
+
+void SX126xSetTxContinuousWave( void )
+{
+    SX126xWriteCommand( RADIO_SET_TXCONTINUOUSWAVE, 0, 0 );
+    SX126xSetOperatingMode( MODE_TX );
+}
+
+void SX126xSetTxInfinitePreamble( void )
+{
+    SX126xWriteCommand( RADIO_SET_TXCONTINUOUSPREAMBLE, 0, 0 );
+    SX126xSetOperatingMode( MODE_TX );
+}
+
+void SX126xSetStopRxTimerOnPreambleDetect( bool enable )
+{
+    SX126xWriteCommand( RADIO_SET_STOPRXTIMERONPREAMBLE, ( uint8_t* )&enable, 1 );
+}
+
+void SX126xSetLoRaSymbNumTimeout( uint8_t symbNum )
+{
+    uint8_t mant = ( ( ( symbNum > SX126X_MAX_LORA_SYMB_NUM_TIMEOUT ) ?
+                       SX126X_MAX_LORA_SYMB_NUM_TIMEOUT : 
+                       symbNum ) + 1 ) >> 1;
+    uint8_t exp  = 0;
+    uint8_t reg  = 0;
+
+    while( mant > 31 )
+    {
+        mant = ( mant + 3 ) >> 2;
+        exp++;
+    }
+
+    reg = mant << ( 2 * exp + 1 );
+    SX126xWriteCommand( RADIO_SET_LORASYMBTIMEOUT, &reg, 1 );
+
+    if( symbNum != 0 )
+    {
+        reg = exp + ( mant << 3 );
+        SX126xWriteRegister( REG_LR_SYNCH_TIMEOUT, reg );
+    }
+}
+
+void SX126xSetRegulatorMode( RadioRegulatorMode_t mode )
+{
+    SX126xWriteCommand( RADIO_SET_REGULATORMODE, ( uint8_t* )&mode, 1 );
+}
+
+void SX126xCalibrate( CalibrationParams_t calibParam )
+{
+    uint8_t value = ( ( ( uint8_t )calibParam.Fields.ImgEnable << 6 ) |
+                      ( ( uint8_t )calibParam.Fields.ADCBulkPEnable << 5 ) |
+                      ( ( uint8_t )calibParam.Fields.ADCBulkNEnable << 4 ) |
+                      ( ( uint8_t )calibParam.Fields.ADCPulseEnable << 3 ) |
+                      ( ( uint8_t )calibParam.Fields.PLLEnable << 2 ) |
+                      ( ( uint8_t )calibParam.Fields.RC13MEnable << 1 ) |
+                      ( ( uint8_t )calibParam.Fields.RC64KEnable ) );
+
+    SX126xWriteCommand( RADIO_CALIBRATE, &value, 1 );
+}
+
+void SX126xCalibrateImage( uint32_t freq )
+{
+    uint8_t calFreq[2];
+
+    if( freq > 900000000 )
+    {
+        calFreq[0] = 0xE1;
+        calFreq[1] = 0xE9;
+    }
+    else if( freq > 850000000 )
+    {
+        calFreq[0] = 0xD7;
+        calFreq[1] = 0xDB;
+    }
+    else if( freq > 770000000 )
+    {
+        calFreq[0] = 0xC1;
+        calFreq[1] = 0xC5;
+    }
+    else if( freq > 460000000 )
+    {
+        calFreq[0] = 0x75;
+        calFreq[1] = 0x81;
+    }
+    else if( freq > 425000000 )
+    {
+        calFreq[0] = 0x6B;
+        calFreq[1] = 0x6F;
+    }
+    SX126xWriteCommand( RADIO_CALIBRATEIMAGE, calFreq, 2 );
+}
+
+void SX126xSetPaConfig( uint8_t paDutyCycle, uint8_t hpMax, uint8_t deviceSel, uint8_t paLut )
+{
+    uint8_t buf[4];
+
+    buf[0] = paDutyCycle;
+    buf[1] = hpMax;
+    buf[2] = deviceSel;
+    buf[3] = paLut;
+    SX126xWriteCommand( RADIO_SET_PACONFIG, buf, 4 );
+}
+
+void SX126xSetRxTxFallbackMode( uint8_t fallbackMode )
+{
+    SX126xWriteCommand( RADIO_SET_TXFALLBACKMODE, &fallbackMode, 1 );
+}
+
+void SX126xSetDioIrqParams( uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask, uint16_t dio3Mask )
+{
+    uint8_t buf[8];
+
+    buf[0] = ( uint8_t )( ( irqMask >> 8 ) & 0x00FF );
+    buf[1] = ( uint8_t )( irqMask & 0x00FF );
+    buf[2] = ( uint8_t )( ( dio1Mask >> 8 ) & 0x00FF );
+    buf[3] = ( uint8_t )( dio1Mask & 0x00FF );
+    buf[4] = ( uint8_t )( ( dio2Mask >> 8 ) & 0x00FF );
+    buf[5] = ( uint8_t )( dio2Mask & 0x00FF );
+    buf[6] = ( uint8_t )( ( dio3Mask >> 8 ) & 0x00FF );
+    buf[7] = ( uint8_t )( dio3Mask & 0x00FF );
+    SX126xWriteCommand( RADIO_CFG_DIOIRQ, buf, 8 );
+}
+
+uint16_t SX126xGetIrqStatus( void )
+{
+    uint8_t irqStatus[2];
+
+    SX126xReadCommand( RADIO_GET_IRQSTATUS, irqStatus, 2 );
+    return ( irqStatus[0] << 8 ) | irqStatus[1];
+}
+
+void SX126xSetDio2AsRfSwitchCtrl( uint8_t enable )
+{
+    SX126xWriteCommand( RADIO_SET_RFSWITCHMODE, &enable, 1 );
+}
+
+void SX126xSetDio3AsTcxoCtrl( RadioTcxoCtrlVoltage_t tcxoVoltage, uint32_t timeout )
+{
+    uint8_t buf[4];
+
+    buf[0] = tcxoVoltage & 0x07;
+    buf[1] = ( uint8_t )( ( timeout >> 16 ) & 0xFF );
+    buf[2] = ( uint8_t )( ( timeout >> 8 ) & 0xFF );
+    buf[3] = ( uint8_t )( timeout & 0xFF );
+
+    SX126xWriteCommand( RADIO_SET_TCXOMODE, buf, 4 );
+}
+
+void SX126xSetRfFrequency( uint32_t frequency )
+{
+    uint8_t buf[4];
+	uint32_t freqInPllSteps = 0;
+
+    if( ImageCalibrated == false )
+    {
+        SX126xCalibrateImage( frequency );
+        ImageCalibrated = true;
+    }
+
+    freqInPllSteps = SX126xConvertFreqInHzToPllStep( frequency );
+
+    buf[0] = ( uint8_t )( ( freqInPllSteps >> 24 ) & 0xFF );
+    buf[1] = ( uint8_t )( ( freqInPllSteps >> 16 ) & 0xFF );
+    buf[2] = ( uint8_t )( ( freqInPllSteps >> 8 ) & 0xFF );
+    buf[3] = ( uint8_t )( freqInPllSteps & 0xFF );
+    SX126xWriteCommand( RADIO_SET_RFFREQUENCY, buf, 4 );
+}
+
+void SX126xSetPacketType( RadioPacketTypes_t packetType )
+{
+    // Save packet type internally to avoid questioning the radio
+    PacketType = packetType;
+    SX126xWriteCommand( RADIO_SET_PACKETTYPE, ( uint8_t* )&packetType, 1 );
+}
+
+RadioPacketTypes_t SX126xGetPacketType( void )
+{
+    return PacketType;
+}
+
+void SX126xSetTxParams( int8_t power, RadioRampTimes_t rampTime )
+{
+    uint8_t buf[2];
+
+    if( SX126xGetDeviceId( ) == SX1261 )
+    {
+        if( power == 15 )
+        {
+            SX126xSetPaConfig( 0x06, 0x00, 0x01, 0x01 );
+        }
+        else
+        {
+            SX126xSetPaConfig( 0x04, 0x00, 0x01, 0x01 );
+        }
+        if( power >= 14 )
+        {
+            power = 14;
+        }
+        else if( power < -17 )
+        {
+            power = -17;
+        }
+    }
+    else // sx1262
+    {
+        // WORKAROUND - Better Resistance of the SX1262 Tx to Antenna Mismatch, see DS_SX1261-2_V1.2 datasheet chapter 15.2
+        // RegTxClampConfig = @address 0x08D8
+        SX126xWriteRegister( 0x08D8, SX126xReadRegister( 0x08D8 ) | ( 0x0F << 1 ) );
+        // WORKAROUND END
+
+        SX126xSetPaConfig( 0x04, 0x07, 0x00, 0x01 );
+        if( power > 22 )
+        {
+            power = 22;
+        }
+        else if( power < -9 )
+        {
+            power = -9;
+        }
+    }
+    buf[0] = power;
+    buf[1] = ( uint8_t )rampTime;
+    SX126xWriteCommand( RADIO_SET_TXPARAMS, buf, 2 );
+}
+
+void SX126xSetModulationParams( ModulationParams_t *modulationParams )
+{
+    uint8_t n;
+    uint32_t tempVal = 0;
+    uint8_t buf[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+    // Check if required configuration corresponds to the stored packet type
+    // If not, silently update radio packet type
+    if( PacketType != modulationParams->PacketType )
+    {
+        SX126xSetPacketType( modulationParams->PacketType );
+    }
+
+    switch( modulationParams->PacketType )
+    {
+    case PACKET_TYPE_GFSK:
+        n = 8;
+        tempVal = ( uint32_t )( 32 * SX126X_XTAL_FREQ / modulationParams->Params.Gfsk.BitRate );
+        buf[0] = ( tempVal >> 16 ) & 0xFF;
+        buf[1] = ( tempVal >> 8 ) & 0xFF;
+        buf[2] = tempVal & 0xFF;
+        buf[3] = modulationParams->Params.Gfsk.ModulationShaping;
+        buf[4] = modulationParams->Params.Gfsk.Bandwidth;
+        tempVal = SX126xConvertFreqInHzToPllStep( modulationParams->Params.Gfsk.Fdev );
+        buf[5] = ( tempVal >> 16 ) & 0xFF;
+        buf[6] = ( tempVal >> 8 ) & 0xFF;
+        buf[7] = ( tempVal& 0xFF );
+        SX126xWriteCommand( RADIO_SET_MODULATIONPARAMS, buf, n );
+        break;
+    case PACKET_TYPE_LORA:
+        n = 4;
+        buf[0] = modulationParams->Params.LoRa.SpreadingFactor;
+        buf[1] = modulationParams->Params.LoRa.Bandwidth;
+        buf[2] = modulationParams->Params.LoRa.CodingRate;
+        buf[3] = modulationParams->Params.LoRa.LowDatarateOptimize;
+
+        SX126xWriteCommand( RADIO_SET_MODULATIONPARAMS, buf, n );
+
+        break;
+    default:
+    case PACKET_TYPE_NONE:
+        return;
+    }
+}
+
+void SX126xSetPacketParams( PacketParams_t *packetParams )
+{
+    uint8_t n;
+    uint8_t crcVal = 0;
+    uint8_t buf[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+    // Check if required configuration corresponds to the stored packet type
+    // If not, silently update radio packet type
+    if( PacketType != packetParams->PacketType )
+    {
+        SX126xSetPacketType( packetParams->PacketType );
+    }
+
+    switch( packetParams->PacketType )
+    {
+    case PACKET_TYPE_GFSK:
+        if( packetParams->Params.Gfsk.CrcLength == RADIO_CRC_2_BYTES_IBM )
+        {
+            SX126xSetCrcSeed( CRC_IBM_SEED );
+            SX126xSetCrcPolynomial( CRC_POLYNOMIAL_IBM );
+            crcVal = RADIO_CRC_2_BYTES;
+        }
+        else if( packetParams->Params.Gfsk.CrcLength == RADIO_CRC_2_BYTES_CCIT )
+        {
+            SX126xSetCrcSeed( CRC_CCITT_SEED );
+            SX126xSetCrcPolynomial( CRC_POLYNOMIAL_CCITT );
+            crcVal = RADIO_CRC_2_BYTES_INV;
+        }
+        else
+        {
+            crcVal = packetParams->Params.Gfsk.CrcLength;
+        }
+        n = 9;
+        buf[0] = ( packetParams->Params.Gfsk.PreambleLength >> 8 ) & 0xFF;
+        buf[1] = packetParams->Params.Gfsk.PreambleLength;
+        buf[2] = packetParams->Params.Gfsk.PreambleMinDetect;
+        buf[3] = ( packetParams->Params.Gfsk.SyncWordLength /*<< 3*/ ); // convert from byte to bit
+        buf[4] = packetParams->Params.Gfsk.AddrComp;
+        buf[5] = packetParams->Params.Gfsk.HeaderType;
+        buf[6] = packetParams->Params.Gfsk.PayloadLength;
+        buf[7] = crcVal;
+        buf[8] = packetParams->Params.Gfsk.DcFree;
+        break;
+    case PACKET_TYPE_LORA:
+        n = 6;
+        buf[0] = ( packetParams->Params.LoRa.PreambleLength >> 8 ) & 0xFF;
+        buf[1] = packetParams->Params.LoRa.PreambleLength;
+        buf[2] = LoRaHeaderType = packetParams->Params.LoRa.HeaderType;
+        buf[3] = packetParams->Params.LoRa.PayloadLength;
+        buf[4] = packetParams->Params.LoRa.CrcMode;
+        buf[5] = packetParams->Params.LoRa.InvertIQ;
+        break;
+    default:
+    case PACKET_TYPE_NONE:
+        return;
+    }
+    SX126xWriteCommand( RADIO_SET_PACKETPARAMS, buf, n );
+}
+
+void SX126xSetCadParams( RadioLoRaCadSymbols_t cadSymbolNum, uint8_t cadDetPeak, uint8_t cadDetMin, RadioCadExitModes_t cadExitMode, uint32_t cadTimeout )
+{
+    uint8_t buf[7];
+
+    buf[0] = ( uint8_t )cadSymbolNum;
+    buf[1] = cadDetPeak;
+    buf[2] = cadDetMin;
+    buf[3] = ( uint8_t )cadExitMode;
+    buf[4] = ( uint8_t )( ( cadTimeout >> 16 ) & 0xFF );
+    buf[5] = ( uint8_t )( ( cadTimeout >> 8 ) & 0xFF );
+    buf[6] = ( uint8_t )( cadTimeout & 0xFF );
+    SX126xWriteCommand( RADIO_SET_CADPARAMS, buf, 7 );
+    SX126xSetOperatingMode( MODE_CAD );
+}
+
+void SX126xSetBufferBaseAddress( uint8_t txBaseAddress, uint8_t rxBaseAddress )
+{
+    uint8_t buf[2];
+
+    buf[0] = txBaseAddress;
+    buf[1] = rxBaseAddress;
+    SX126xWriteCommand( RADIO_SET_BUFFERBASEADDRESS, buf, 2 );
+}
+
+RadioStatus_t SX126xGetStatus( void )
+{
+    uint8_t stat = 0;
+    RadioStatus_t status = { 0 };
+		status.Value = 0;
+
+    stat = SX126xReadCommand( RADIO_GET_STATUS, NULL, 0 );
+    status.Fields.CmdStatus = ( stat & ( 0x07 << 1 ) ) >> 1;
+    status.Fields.ChipMode = ( stat & ( 0x07 << 4 ) ) >> 4;
+    return status;
+}
+
+int8_t SX126xGetRssiInst( void )
+{
+    uint8_t buf[1];
+    int8_t rssi = 0;
+
+    SX126xReadCommand( RADIO_GET_RSSIINST, buf, 1 );
+    rssi = -buf[0] >> 1;
+    return rssi;
+}
+
+void SX126xGetRxBufferStatus( uint8_t *payloadLength, uint8_t *rxStartBufferPointer )
+{
+    uint8_t status[2];
+
+    SX126xReadCommand( RADIO_GET_RXBUFFERSTATUS, status, 2 );
+
+    // In case of LORA fixed header, the payloadLength is obtained by reading
+    // the register REG_LR_PAYLOADLENGTH
+    if( ( SX126xGetPacketType( ) == PACKET_TYPE_LORA ) && ( LoRaHeaderType == LORA_PACKET_FIXED_LENGTH ) )
+    {
+        *payloadLength = SX126xReadRegister( REG_LR_PAYLOADLENGTH );
+    }
+    else
+    {
+        *payloadLength = status[0];
+    }
+    *rxStartBufferPointer = status[1];
+}
+
+void SX126xGetPacketStatus( PacketStatus_t *pktStatus )
+{
+    uint8_t status[3];
+
+    SX126xReadCommand( RADIO_GET_PACKETSTATUS, status, 3 );
+
+    pktStatus->packetType = SX126xGetPacketType( );
+    switch( pktStatus->packetType )
+    {
+        case PACKET_TYPE_GFSK:
+            pktStatus->Params.Gfsk.RxStatus = status[0];
+            pktStatus->Params.Gfsk.RssiSync = -status[1] >> 1;
+            pktStatus->Params.Gfsk.RssiAvg = -status[2] >> 1;
+            pktStatus->Params.Gfsk.FreqError = 0;
+            break;
+
+        case PACKET_TYPE_LORA:
+            pktStatus->Params.LoRa.RssiPkt = -status[0] >> 1;
+            // Returns SNR value [dB] rounded to the nearest integer value
+            pktStatus->Params.LoRa.SnrPkt = ( ( ( int8_t )status[1] ) + 2 ) >> 2;
+            pktStatus->Params.LoRa.SignalRssiPkt = -status[2] >> 1;
+            pktStatus->Params.LoRa.FreqError = FrequencyError;
+            break;
+
+        default:
+        case PACKET_TYPE_NONE:
+            // In that specific case, we set everything in the pktStatus to zeros
+            // and reset the packet type accordingly
+            memset( pktStatus, 0, sizeof( PacketStatus_t ) );
+            pktStatus->packetType = PACKET_TYPE_NONE;
+            break;
+    }
+}
+
+RadioError_t SX126xGetDeviceErrors( void )
+{
+    uint8_t err[] = { 0, 0 };
+    RadioError_t error = { 0 };
+		error.Value = 0;
+
+    SX126xReadCommand( RADIO_GET_ERROR, ( uint8_t* )err, 2 );
+    error.Fields.PaRamp     = ( err[0] & ( 1 << 0 ) ) >> 0;
+    error.Fields.PllLock    = ( err[1] & ( 1 << 6 ) ) >> 6;
+    error.Fields.XoscStart  = ( err[1] & ( 1 << 5 ) ) >> 5;
+    error.Fields.ImgCalib   = ( err[1] & ( 1 << 4 ) ) >> 4;
+    error.Fields.AdcCalib   = ( err[1] & ( 1 << 3 ) ) >> 3;
+    error.Fields.PllCalib   = ( err[1] & ( 1 << 2 ) ) >> 2;
+    error.Fields.Rc13mCalib = ( err[1] & ( 1 << 1 ) ) >> 1;
+    error.Fields.Rc64kCalib = ( err[1] & ( 1 << 0 ) ) >> 0;
+    return error;
+}
+
+void SX126xClearDeviceErrors( void )
+{
+    uint8_t buf[2] = { 0x00, 0x00 };
+    SX126xWriteCommand( RADIO_CLR_ERROR, buf, 2 );
+}
+
+void SX126xClearIrqStatus( uint16_t irq )
+{
+    uint8_t buf[2];
+
+    buf[0] = ( uint8_t )( ( ( uint16_t )irq >> 8 ) & 0x00FF );
+    buf[1] = ( uint8_t )( ( uint16_t )irq & 0x00FF );
+    SX126xWriteCommand( RADIO_CLR_IRQSTATUS, buf, 2 );
+}
+
+static uint32_t SX126xConvertFreqInHzToPllStep( uint32_t freqInHz )
+{
+    uint32_t stepsInt;
+    uint32_t stepsFrac;
+
+    // pllSteps = freqInHz / (SX126X_XTAL_FREQ / 2^19 )
+    // Get integer and fractional parts of the frequency computed with a PLL step scaled value
+    stepsInt = freqInHz / SX126X_PLL_STEP_SCALED;
+    stepsFrac = freqInHz - ( stepsInt * SX126X_PLL_STEP_SCALED );
+    
+    // Apply the scaling factor to retrieve a frequency in Hz (+ ceiling)
+    return ( stepsInt << SX126X_PLL_STEP_SHIFT_AMOUNT ) + 
+           ( ( ( stepsFrac << SX126X_PLL_STEP_SHIFT_AMOUNT ) + ( SX126X_PLL_STEP_SCALED >> 1 ) ) /
+             SX126X_PLL_STEP_SCALED );
+}

APP/network_mgr/sx1268/peripherals/radio/sx126x/sx126x.h

@@ -0,0 +1,1115 @@
+/*!
+ * \file      sx126x.h
+ *
+ * \brief     SX126x driver implementation
+ *
+ * \copyright Revised BSD License, see section \ref LICENSE.
+ *
+ * \code
+ *                ______                              _
+ *               / _____)             _              | |
+ *              ( (____  _____ ____ _| |_ _____  ____| |__
+ *               \____ \| ___ |    (_   _) ___ |/ ___)  _ \
+ *               _____) ) ____| | | || |_| ____( (___| | | |
+ *              (______/|_____)_|_|_| \__)_____)\____)_| |_|
+ *              (C)2013-2017 Semtech
+ *
+ * \endcode
+ *
+ * \author    Miguel Luis ( Semtech )
+ *
+ * \author    Gregory Cristian ( Semtech )
+ */
+#ifndef __SX126x_H__
+#define __SX126x_H__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <math.h>
+#include "radio.h"
+
+#define SX1261                                      1
+#define SX1262                                      2
+
+/*!
+ * Radio complete Wake-up Time with margin for temperature compensation
+ */
+#define RADIO_WAKEUP_TIME                           3 // [ms]
+
+/*!
+ * \brief Compensation delay for SetAutoTx/Rx functions in 15.625 microseconds
+ */
+#define AUTO_RX_TX_OFFSET                           2
+
+/*!
+ * \brief LFSR initial value to compute IBM type CRC
+ */
+#define CRC_IBM_SEED                                0xFFFF
+
+/*!
+ * \brief LFSR initial value to compute CCIT type CRC
+ */
+#define CRC_CCITT_SEED                              0x1D0F
+
+/*!
+ * \brief Polynomial used to compute IBM CRC
+ */
+#define CRC_POLYNOMIAL_IBM                          0x8005
+
+/*!
+ * \brief Polynomial used to compute CCIT CRC
+ */
+#define CRC_POLYNOMIAL_CCITT                        0x1021
+
+/*!
+ * \brief The address of the register holding the first byte defining the CRC seed
+ *
+ */
+#define REG_LR_CRCSEEDBASEADDR                      0x06BC
+
+/*!
+ * \brief The address of the register holding the first byte defining the CRC polynomial
+ */
+#define REG_LR_CRCPOLYBASEADDR                      0x06BE
+
+/*!
+ * \brief The address of the register holding the first byte defining the whitening seed
+ */
+#define REG_LR_WHITSEEDBASEADDR_MSB                 0x06B8
+#define REG_LR_WHITSEEDBASEADDR_LSB                 0x06B9
+
+/*!
+ * \brief The address of the register holding the packet configuration
+ */
+#define REG_LR_PACKETPARAMS                         0x0704
+
+/*!
+ * \brief The address of the register holding the payload size
+ */
+#define REG_LR_PAYLOADLENGTH                        0x0702
+
+/*!
+ * \brief The address of the register holding the re-calculated number of symbols
+ */
+#define REG_LR_SYNCH_TIMEOUT                        0x0706
+
+/*!
+ * \brief The addresses of the registers holding SyncWords values
+ */
+#define REG_LR_SYNCWORDBASEADDRESS                  0x06C0
+
+/*!
+ * \brief The addresses of the register holding LoRa Modem SyncWord value
+ */
+#define REG_LR_SYNCWORD                             0x0740
+
+/*!
+ * Syncword for Private LoRa networks
+ */
+#define LORA_MAC_PRIVATE_SYNCWORD                   0x1424
+
+/*!
+ * Syncword for Public LoRa networks
+ */
+#define LORA_MAC_PUBLIC_SYNCWORD                    0x3444
+
+
+/*!
+ * The address of the register giving a 32-bit random number
+ */
+#define RANDOM_NUMBER_GENERATORBASEADDR             0x0819
+
+/*!
+ * The address of the register used to disable the LNA
+ */
+#define REG_ANA_LNA                                 0x08E2
+
+/*!
+ * The address of the register used to disable the mixer
+ */
+#define REG_ANA_MIXER                               0x08E5
+
+/*!
+ * The address of the register holding RX Gain value (0x94: power saving, 0x96: rx boosted)
+ */
+#define REG_RX_GAIN                                 0x08AC
+
+/*!
+ * Change the value on the device internal trimming capacitor
+ */
+#define REG_XTA_TRIM                                0x0911
+
+/*!
+ * Set the current max value in the over current protection
+ */
+#define REG_OCP                                     0x08E7
+
+/*!
+ * \brief Structure describing the radio status
+ */
+typedef union RadioStatus_u
+{
+    uint8_t Value;
+    struct
+    {   //bit order is lsb -> msb
+        uint8_t           : 1;  //!< Reserved
+        uint8_t CmdStatus : 3;  //!< Command status
+        uint8_t ChipMode  : 3;  //!< Chip mode
+        uint8_t           : 1;  //!< Reserved
+    }Fields;
+}RadioStatus_t;
+
+/*!
+ * \brief Structure describing the error codes for callback functions
+ */
+typedef enum
+{
+    IRQ_HEADER_ERROR_CODE                   = 0x01,
+    IRQ_SYNCWORD_ERROR_CODE                 = 0x02,
+    IRQ_CRC_ERROR_CODE                      = 0x04,
+}IrqErrorCode_t;
+
+enum IrqPblSyncHeaderCode_t
+{
+    IRQ_PBL_DETECT_CODE                     = 0x01,
+    IRQ_SYNCWORD_VALID_CODE                 = 0x02,
+    IRQ_HEADER_VALID_CODE                   = 0x04,
+};
+
+/*!
+ * \brief Represents the operating mode the radio is actually running
+ */
+typedef enum
+{
+    MODE_SLEEP                              = 0x00,         //! The radio is in sleep mode
+    MODE_STDBY_RC,                                          //! The radio is in standby mode with RC oscillator
+    MODE_STDBY_XOSC,                                        //! The radio is in standby mode with XOSC oscillator
+    MODE_FS,                                                //! The radio is in frequency synthesis mode
+    MODE_TX,                                                //! The radio is in transmit mode
+    MODE_RX,                                                //! The radio is in receive mode
+    MODE_RX_DC,                                             //! The radio is in receive duty cycle mode
+    MODE_CAD                                                //! The radio is in channel activity detection mode
+}RadioOperatingModes_t;
+
+/*!
+ * \brief Declares the oscillator in use while in standby mode
+ *
+ * Using the STDBY_RC standby mode allow to reduce the energy consumption
+ * STDBY_XOSC should be used for time critical applications
+ */
+typedef enum
+{
+    STDBY_RC                                = 0x00,
+    STDBY_XOSC                              = 0x01,
+}RadioStandbyModes_t;
+
+/*!
+ * \brief Declares the power regulation used to power the device
+ *
+ * This command allows the user to specify if DC-DC or LDO is used for power regulation.
+ * Using only LDO implies that the Rx or Tx current is doubled
+ */
+typedef enum
+{
+    USE_LDO                                 = 0x00, // default
+    USE_DCDC                                = 0x01,
+}RadioRegulatorMode_t;
+
+/*!
+ * \brief Represents the possible packet type (i.e. modem) used
+ */
+typedef enum
+{
+    PACKET_TYPE_GFSK                        = 0x00,
+    PACKET_TYPE_LORA                        = 0x01,
+    PACKET_TYPE_NONE                        = 0x0F,
+}RadioPacketTypes_t;
+
+/*!
+ * \brief Represents the ramping time for power amplifier
+ */
+typedef enum
+{
+    RADIO_RAMP_10_US                        = 0x00,
+    RADIO_RAMP_20_US                        = 0x01,
+    RADIO_RAMP_40_US                        = 0x02,
+    RADIO_RAMP_80_US                        = 0x03,
+    RADIO_RAMP_200_US                       = 0x04,
+    RADIO_RAMP_800_US                       = 0x05,
+    RADIO_RAMP_1700_US                      = 0x06,
+    RADIO_RAMP_3400_US                      = 0x07,
+}RadioRampTimes_t;
+
+/*!
+ * \brief Represents the number of symbols to be used for channel activity detection operation
+ */
+typedef enum
+{
+    LORA_CAD_01_SYMBOL                      = 0x00,
+    LORA_CAD_02_SYMBOL                      = 0x01,
+    LORA_CAD_04_SYMBOL                      = 0x02,
+    LORA_CAD_08_SYMBOL                      = 0x03,
+    LORA_CAD_16_SYMBOL                      = 0x04,
+}RadioLoRaCadSymbols_t;
+
+/*!
+ * \brief Represents the Channel Activity Detection actions after the CAD operation is finished
+ */
+typedef enum
+{
+    LORA_CAD_ONLY                           = 0x00,
+    LORA_CAD_RX                             = 0x01,
+    LORA_CAD_LBT                            = 0x10,
+}RadioCadExitModes_t;
+
+/*!
+ * \brief Represents the modulation shaping parameter
+ */
+typedef enum
+{
+    MOD_SHAPING_OFF                         = 0x00,
+    MOD_SHAPING_G_BT_03                     = 0x08,
+    MOD_SHAPING_G_BT_05                     = 0x09,
+    MOD_SHAPING_G_BT_07                     = 0x0A,
+    MOD_SHAPING_G_BT_1                      = 0x0B,
+}RadioModShapings_t;
+
+/*!
+ * \brief Represents the modulation shaping parameter
+ */
+typedef enum
+{
+    RX_BW_4800                              = 0x1F,
+    RX_BW_5800                              = 0x17,
+    RX_BW_7300                              = 0x0F,
+    RX_BW_9700                              = 0x1E,
+    RX_BW_11700                             = 0x16,
+    RX_BW_14600                             = 0x0E,
+    RX_BW_19500                             = 0x1D,
+    RX_BW_23400                             = 0x15,
+    RX_BW_29300                             = 0x0D,
+    RX_BW_39000                             = 0x1C,
+    RX_BW_46900                             = 0x14,
+    RX_BW_58600                             = 0x0C,
+    RX_BW_78200                             = 0x1B,
+    RX_BW_93800                             = 0x13,
+    RX_BW_117300                            = 0x0B,
+    RX_BW_156200                            = 0x1A,
+    RX_BW_187200                            = 0x12,
+    RX_BW_234300                            = 0x0A,
+    RX_BW_312000                            = 0x19,
+    RX_BW_373600                            = 0x11,
+    RX_BW_467000                            = 0x09,
+}RadioRxBandwidth_t;
+
+/*!
+ * \brief Represents the possible spreading factor values in LoRa packet types
+ */
+typedef enum
+{
+    LORA_SF5                                = 0x05,
+    LORA_SF6                                = 0x06,
+    LORA_SF7                                = 0x07,
+    LORA_SF8                                = 0x08,
+    LORA_SF9                                = 0x09,
+    LORA_SF10                               = 0x0A,
+    LORA_SF11                               = 0x0B,
+    LORA_SF12                               = 0x0C,
+}RadioLoRaSpreadingFactors_t;
+
+/*!
+ * \brief Represents the bandwidth values for LoRa packet type
+ */
+typedef enum
+{
+    LORA_BW_500                             = 6,
+    LORA_BW_250                             = 5,
+    LORA_BW_125                             = 4,
+    LORA_BW_062                             = 3,
+    LORA_BW_041                             = 10,
+    LORA_BW_031                             = 2,
+    LORA_BW_020                             = 9,
+    LORA_BW_015                             = 1,
+    LORA_BW_010                             = 8,
+    LORA_BW_007                             = 0,
+}RadioLoRaBandwidths_t;
+
+/*!
+ * \brief Represents the coding rate values for LoRa packet type
+ */
+typedef enum
+{
+    LORA_CR_4_5                             = 0x01,
+    LORA_CR_4_6                             = 0x02,
+    LORA_CR_4_7                             = 0x03,
+    LORA_CR_4_8                             = 0x04,
+}RadioLoRaCodingRates_t;
+
+/*!
+ * \brief Represents the preamble length used to detect the packet on Rx side
+ */
+typedef enum
+{
+    RADIO_PREAMBLE_DETECTOR_OFF             = 0x00,         //!< Preamble detection length off
+    RADIO_PREAMBLE_DETECTOR_08_BITS         = 0x04,         //!< Preamble detection length 8 bits
+    RADIO_PREAMBLE_DETECTOR_16_BITS         = 0x05,         //!< Preamble detection length 16 bits
+    RADIO_PREAMBLE_DETECTOR_24_BITS         = 0x06,         //!< Preamble detection length 24 bits
+    RADIO_PREAMBLE_DETECTOR_32_BITS         = 0x07,         //!< Preamble detection length 32 bit
+}RadioPreambleDetection_t;
+
+/*!
+ * \brief Represents the possible combinations of SyncWord correlators activated
+ */
+typedef enum
+{
+    RADIO_ADDRESSCOMP_FILT_OFF              = 0x00,         //!< No correlator turned on, i.e. do not search for SyncWord
+    RADIO_ADDRESSCOMP_FILT_NODE             = 0x01,
+    RADIO_ADDRESSCOMP_FILT_NODE_BROAD       = 0x02,
+}RadioAddressComp_t;
+
+/*!
+ *  \brief Radio GFSK packet length mode
+ */
+typedef enum
+{
+    RADIO_PACKET_FIXED_LENGTH               = 0x00,         //!< The packet is known on both sides, no header included in the packet
+    RADIO_PACKET_VARIABLE_LENGTH            = 0x01,         //!< The packet is on variable size, header included
+}RadioPacketLengthModes_t;
+
+/*!
+ * \brief Represents the CRC length
+ */
+typedef enum
+{
+    RADIO_CRC_OFF                           = 0x01,         //!< No CRC in use
+    RADIO_CRC_1_BYTES                       = 0x00,
+    RADIO_CRC_2_BYTES                       = 0x02,
+    RADIO_CRC_1_BYTES_INV                   = 0x04,
+    RADIO_CRC_2_BYTES_INV                   = 0x06,
+    RADIO_CRC_2_BYTES_IBM                   = 0xF1,
+    RADIO_CRC_2_BYTES_CCIT                  = 0xF2,
+}RadioCrcTypes_t;
+
+/*!
+ * \brief Radio whitening mode activated or deactivated
+ */
+typedef enum
+{
+    RADIO_DC_FREE_OFF                       = 0x00,
+    RADIO_DC_FREEWHITENING                  = 0x01,
+}RadioDcFree_t;
+
+/*!
+ * \brief Holds the Radio lengths mode for the LoRa packet type
+ */
+typedef enum
+{
+    LORA_PACKET_VARIABLE_LENGTH             = 0x00,         //!< The packet is on variable size, header included
+    LORA_PACKET_FIXED_LENGTH                = 0x01,         //!< The packet is known on both sides, no header included in the packet
+    LORA_PACKET_EXPLICIT                    = LORA_PACKET_VARIABLE_LENGTH,
+    LORA_PACKET_IMPLICIT                    = LORA_PACKET_FIXED_LENGTH,
+}RadioLoRaPacketLengthsMode_t;
+
+/*!
+ * \brief Represents the CRC mode for LoRa packet type
+ */
+typedef enum
+{
+    LORA_CRC_ON                             = 0x01,         //!< CRC activated
+    LORA_CRC_OFF                            = 0x00,         //!< CRC not used
+}RadioLoRaCrcModes_t;
+
+/*!
+ * \brief Represents the IQ mode for LoRa packet type
+ */
+typedef enum
+{
+    LORA_IQ_NORMAL                          = 0x00,
+    LORA_IQ_INVERTED                        = 0x01,
+}RadioLoRaIQModes_t;
+
+/*!
+ * \brief Represents the voltage used to control the TCXO on/off from DIO3
+ */
+typedef enum
+{
+    TCXO_CTRL_1_6V                          = 0x00,
+    TCXO_CTRL_1_7V                          = 0x01,
+    TCXO_CTRL_1_8V                          = 0x02,
+    TCXO_CTRL_2_2V                          = 0x03,
+    TCXO_CTRL_2_4V                          = 0x04,
+    TCXO_CTRL_2_7V                          = 0x05,
+    TCXO_CTRL_3_0V                          = 0x06,
+    TCXO_CTRL_3_3V                          = 0x07,
+}RadioTcxoCtrlVoltage_t;
+
+/*!
+ * \brief Represents the interruption masks available for the radio
+ *
+ * \remark Note that not all these interruptions are available for all packet types
+ */
+typedef enum
+{
+    IRQ_RADIO_NONE                          = 0x0000,
+    IRQ_TX_DONE                             = 0x0001,
+    IRQ_RX_DONE                             = 0x0002,
+    IRQ_PREAMBLE_DETECTED                   = 0x0004,
+    IRQ_SYNCWORD_VALID                      = 0x0008,
+    IRQ_HEADER_VALID                        = 0x0010,
+    IRQ_HEADER_ERROR                        = 0x0020,
+    IRQ_CRC_ERROR                           = 0x0040,
+    IRQ_CAD_DONE                            = 0x0080,
+    IRQ_CAD_ACTIVITY_DETECTED               = 0x0100,
+    IRQ_RX_TX_TIMEOUT                       = 0x0200,
+    IRQ_RADIO_ALL                           = 0xFFFF,
+}RadioIrqMasks_t;
+
+/*!
+ * \brief Represents all possible opcode understood by the radio
+ */
+typedef enum RadioCommands_e
+{
+    RADIO_GET_STATUS                        = 0xC0,
+    RADIO_WRITE_REGISTER                    = 0x0D,
+    RADIO_READ_REGISTER                     = 0x1D,
+    RADIO_WRITE_BUFFER                      = 0x0E,
+    RADIO_READ_BUFFER                       = 0x1E,
+    RADIO_SET_SLEEP                         = 0x84,
+    RADIO_SET_STANDBY                       = 0x80,
+    RADIO_SET_FS                            = 0xC1,
+    RADIO_SET_TX                            = 0x83,
+    RADIO_SET_RX                            = 0x82,
+    RADIO_SET_RXDUTYCYCLE                   = 0x94,
+    RADIO_SET_CAD                           = 0xC5,
+    RADIO_SET_TXCONTINUOUSWAVE              = 0xD1,
+    RADIO_SET_TXCONTINUOUSPREAMBLE          = 0xD2,
+    RADIO_SET_PACKETTYPE                    = 0x8A,
+    RADIO_GET_PACKETTYPE                    = 0x11,
+    RADIO_SET_RFFREQUENCY                   = 0x86,
+    RADIO_SET_TXPARAMS                      = 0x8E,
+    RADIO_SET_PACONFIG                      = 0x95,
+    RADIO_SET_CADPARAMS                     = 0x88,
+    RADIO_SET_BUFFERBASEADDRESS             = 0x8F,
+    RADIO_SET_MODULATIONPARAMS              = 0x8B,
+    RADIO_SET_PACKETPARAMS                  = 0x8C,
+    RADIO_GET_RXBUFFERSTATUS                = 0x13,
+    RADIO_GET_PACKETSTATUS                  = 0x14,
+    RADIO_GET_RSSIINST                      = 0x15,
+    RADIO_GET_STATS                         = 0x10,
+    RADIO_RESET_STATS                       = 0x00,
+    RADIO_CFG_DIOIRQ                        = 0x08,
+    RADIO_GET_IRQSTATUS                     = 0x12,
+    RADIO_CLR_IRQSTATUS                     = 0x02,
+    RADIO_CALIBRATE                         = 0x89,
+    RADIO_CALIBRATEIMAGE                    = 0x98,
+    RADIO_SET_REGULATORMODE                 = 0x96,
+    RADIO_GET_ERROR                         = 0x17,
+    RADIO_CLR_ERROR                         = 0x07,
+    RADIO_SET_TCXOMODE                      = 0x97,
+    RADIO_SET_TXFALLBACKMODE                = 0x93,
+    RADIO_SET_RFSWITCHMODE                  = 0x9D,
+    RADIO_SET_STOPRXTIMERONPREAMBLE         = 0x9F,
+    RADIO_SET_LORASYMBTIMEOUT               = 0xA0,
+}RadioCommands_t;
+
+/*!
+ * \brief The type describing the modulation parameters for every packet types
+ */
+typedef struct
+{
+    RadioPacketTypes_t                   PacketType;        //!< Packet to which the modulation parameters are referring to.
+    struct
+    {
+        struct
+        {
+            uint32_t                     BitRate;
+            uint32_t                     Fdev;
+            RadioModShapings_t           ModulationShaping;
+            uint8_t                      Bandwidth;
+        }Gfsk;
+        struct
+        {
+            RadioLoRaSpreadingFactors_t  SpreadingFactor;   //!< Spreading Factor for the LoRa modulation
+            RadioLoRaBandwidths_t        Bandwidth;         //!< Bandwidth for the LoRa modulation
+            RadioLoRaCodingRates_t       CodingRate;        //!< Coding rate for the LoRa modulation
+            uint8_t                      LowDatarateOptimize; //!< Indicates if the modem uses the low datarate optimization
+        }LoRa;
+    }Params;                                                //!< Holds the modulation parameters structure
+}ModulationParams_t;
+
+/*!
+ * \brief The type describing the packet parameters for every packet types
+ */
+typedef struct
+{
+    RadioPacketTypes_t                    PacketType;        //!< Packet to which the packet parameters are referring to.
+    struct
+    {
+        /*!
+         * \brief Holds the GFSK packet parameters
+         */
+        struct
+        {
+            uint16_t                     PreambleLength;    //!< The preamble Tx length for GFSK packet type in bit
+            RadioPreambleDetection_t     PreambleMinDetect; //!< The preamble Rx length minimal for GFSK packet type
+            uint8_t                      SyncWordLength;    //!< The synchronization word length for GFSK packet type
+            RadioAddressComp_t           AddrComp;          //!< Activated SyncWord correlators
+            RadioPacketLengthModes_t     HeaderType;        //!< If the header is explicit, it will be transmitted in the GFSK packet. If the header is implicit, it will not be transmitted
+            uint8_t                      PayloadLength;     //!< Size of the payload in the GFSK packet
+            RadioCrcTypes_t              CrcLength;         //!< Size of the CRC block in the GFSK packet
+            RadioDcFree_t                DcFree;
+        }Gfsk;
+        /*!
+         * \brief Holds the LoRa packet parameters
+         */
+        struct
+        {
+            uint16_t                     PreambleLength;    //!< The preamble length is the number of LoRa symbols in the preamble
+            RadioLoRaPacketLengthsMode_t HeaderType;        //!< If the header is explicit, it will be transmitted in the LoRa packet. If the header is implicit, it will not be transmitted
+            uint8_t                      PayloadLength;     //!< Size of the payload in the LoRa packet
+            RadioLoRaCrcModes_t          CrcMode;           //!< Size of CRC block in LoRa packet
+            RadioLoRaIQModes_t           InvertIQ;          //!< Allows to swap IQ for LoRa packet
+        }LoRa;
+    }Params;                                                //!< Holds the packet parameters structure
+}PacketParams_t;
+
+/*!
+ * \brief Represents the packet status for every packet type
+ */
+typedef struct
+{
+    RadioPacketTypes_t                    packetType;      //!< Packet to which the packet status are referring to.
+    struct
+    {
+        struct
+        {
+            uint8_t RxStatus;
+            int8_t RssiAvg;                                //!< The averaged RSSI
+            int8_t RssiSync;                               //!< The RSSI measured on last packet
+            uint32_t FreqError;
+        }Gfsk;
+        struct
+        {
+            int8_t RssiPkt;                                //!< The RSSI of the last packet
+            int8_t SnrPkt;                                 //!< The SNR of the last packet
+            int8_t SignalRssiPkt;
+            uint32_t FreqError;
+        }LoRa;
+    }Params;
+}PacketStatus_t;
+
+/*!
+ * \brief Represents the Rx internal counters values when GFSK or LoRa packet type is used
+ */
+typedef struct
+{
+    RadioPacketTypes_t                    packetType;       //!< Packet to which the packet status are referring to.
+    uint16_t PacketReceived;
+    uint16_t CrcOk;
+    uint16_t LengthError;
+}RxCounter_t;
+
+/*!
+ * \brief Represents a calibration configuration
+ */
+typedef union
+{
+    struct
+    {
+        uint8_t RC64KEnable    : 1;                             //!< Calibrate RC64K clock
+        uint8_t RC13MEnable    : 1;                             //!< Calibrate RC13M clock
+        uint8_t PLLEnable      : 1;                             //!< Calibrate PLL
+        uint8_t ADCPulseEnable : 1;                             //!< Calibrate ADC Pulse
+        uint8_t ADCBulkNEnable : 1;                             //!< Calibrate ADC bulkN
+        uint8_t ADCBulkPEnable : 1;                             //!< Calibrate ADC bulkP
+        uint8_t ImgEnable      : 1;
+        uint8_t                : 1;
+    }Fields;
+    uint8_t Value;
+}CalibrationParams_t;
+
+/*!
+ * \brief Represents a sleep mode configuration
+ */
+typedef union
+{
+    struct
+    {
+        uint8_t WakeUpRTC               : 1;                    //!< Get out of sleep mode if wakeup signal received from RTC
+        uint8_t Reset                   : 1;
+        uint8_t WarmStart               : 1;
+        uint8_t Reserved                : 5;
+    }Fields;
+    uint8_t Value;
+}SleepParams_t;
+
+/*!
+ * \brief Represents the possible radio system error states
+ */
+typedef union
+{
+    struct
+    {
+        uint8_t Rc64kCalib              : 1;                    //!< RC 64kHz oscillator calibration failed
+        uint8_t Rc13mCalib              : 1;                    //!< RC 13MHz oscillator calibration failed
+        uint8_t PllCalib                : 1;                    //!< PLL calibration failed
+        uint8_t AdcCalib                : 1;                    //!< ADC calibration failed
+        uint8_t ImgCalib                : 1;                    //!< Image calibration failed
+        uint8_t XoscStart               : 1;                    //!< XOSC oscillator failed to start
+        uint8_t PllLock                 : 1;                    //!< PLL lock failed
+        uint8_t                         : 1;                    //!< Buck converter failed to start
+        uint8_t PaRamp                  : 1;                    //!< PA ramp failed
+        uint8_t                         : 7;                    //!< Reserved
+    }Fields;
+    uint16_t Value;
+}RadioError_t;
+
+/*!
+ * Radio hardware and global parameters
+ */
+typedef struct SX126x_s
+{
+    PacketParams_t PacketParams;
+    PacketStatus_t PacketStatus;
+    ModulationParams_t ModulationParams;
+}SX126x_t;
+
+/*!
+ * Hardware IO IRQ callback function definition
+ */
+typedef void ( DioIrqHandler )( void* context );
+
+/*
+ * SX126x definitions
+ */
+
+/*!
+ * \brief The radio callbacks structure
+ * Holds function pointers to be called on radio interrupts
+ */
+typedef struct
+{
+    void ( *txDone )( void );                       //!< Pointer to a function run on successful transmission
+    void ( *rxDone )( void );                       //!< Pointer to a function run on successful reception
+    void ( *rxPreambleDetect )( void );             //!< Pointer to a function run on successful Preamble detection
+    void ( *rxSyncWordDone )( void );               //!< Pointer to a function run on successful SyncWord reception
+    void ( *rxHeaderDone )( bool isOk );            //!< Pointer to a function run on successful Header reception
+    void ( *txTimeout )( void );                    //!< Pointer to a function run on transmission timeout
+    void ( *rxTimeout )( void );                    //!< Pointer to a function run on reception timeout
+    void ( *rxError )( IrqErrorCode_t errCode );    //!< Pointer to a function run on reception error
+    void ( *cadDone )( bool cadFlag );              //!< Pointer to a function run on channel activity detected
+}SX126xCallbacks_t;
+
+/*!
+ * ============================================================================
+ * Public functions prototypes
+ * ============================================================================
+ */
+ 
+/*!
+ * \brief Initializes the radio driver
+ */
+void SX126xInit( DioIrqHandler dioIrq );
+
+/*!
+ * \brief Wakeup the radio if it is in Sleep mode and check that Busy is low
+ */
+void SX126xCheckDeviceReady( void );
+
+/*!
+ * \brief Saves the payload to be send in the radio buffer
+ *
+ * \param [in]  payload       A pointer to the payload
+ * \param [in]  size          The size of the payload
+ */
+void SX126xSetPayload( uint8_t *payload, uint8_t size );
+
+/*!
+ * \brief Reads the payload received. If the received payload is longer
+ * than maxSize, then the method returns 1 and do not set size and payload.
+ *
+ * \param [out] payload       A pointer to a buffer into which the payload will be copied
+ * \param [out] size          A pointer to the size of the payload received
+ * \param [in]  maxSize       The maximal size allowed to copy into the buffer
+ */
+uint8_t SX126xGetPayload( uint8_t *payload, uint8_t *size, uint8_t maxSize );
+
+/*!
+ * \brief Sends a payload
+ *
+ * \param [in]  payload       A pointer to the payload to send
+ * \param [in]  size          The size of the payload to send
+ * \param [in]  timeout       The timeout for Tx operation
+ */
+void SX126xSendPayload( uint8_t *payload, uint8_t size, uint32_t timeout );
+
+/*!
+ * \brief Sets the Sync Word given by index used in GFSK
+ *
+ * \param [in]  syncWord      SyncWord bytes ( 8 bytes )
+ *
+ * \retval      status        [0: OK, 1: NOK]
+ */
+uint8_t SX126xSetSyncWord( uint8_t *syncWord );
+
+/*!
+ * \brief Sets the Initial value for the LFSR used for the CRC calculation
+ *
+ * \param [in]  seed          Initial LFSR value ( 2 bytes )
+ *
+ */
+void SX126xSetCrcSeed( uint16_t seed );
+
+/*!
+ * \brief Sets the seed used for the CRC calculation
+ *
+ * \param [in]  seed          The seed value
+ *
+ */
+void SX126xSetCrcPolynomial( uint16_t polynomial );
+
+/*!
+ * \brief Sets the Initial value of the LFSR used for the whitening in GFSK protocols
+ *
+ * \param [in]  seed          Initial LFSR value
+ */
+void SX126xSetWhiteningSeed( uint16_t seed );
+
+/*!
+ * \brief Gets a 32-bit random value generated by the radio
+ *
+ * \remark A valid packet type must have been configured with \ref SX126xSetPacketType
+ *         before using this command.
+ *
+ * \remark The radio must be in reception mode before executing this function
+ *         This code can potentially result in interrupt generation. It is the responsibility of
+ *         the calling code to disable radio interrupts before calling this function,
+ *         and re-enable them afterwards if necessary, or be certain that any interrupts
+ *         generated during this process will not cause undesired side-effects in the software.
+ *
+ *         Please note that the random numbers produced by the generator do not have a uniform or Gaussian distribution. If
+ *         uniformity is needed, perform appropriate software post-processing.
+ *
+ * \retval randomValue    32 bits random value
+ */
+uint32_t SX126xGetRandom( void );
+
+/*!
+ * \brief Sets the radio in sleep mode
+ *
+ * \param [in]  sleepConfig   The sleep configuration describing data
+ *                            retention and RTC wake-up
+ */
+void SX126xSetSleep( SleepParams_t sleepConfig );
+
+/*!
+ * \brief Sets the radio in configuration mode
+ *
+ * \param [in]  mode          The standby mode to put the radio into
+ */
+void SX126xSetStandby( RadioStandbyModes_t mode );
+
+/*!
+ * \brief Sets the radio in FS mode
+ */
+void SX126xSetFs( void );
+
+/*!
+ * \brief Sets the radio in transmission mode
+ *
+ * \param [in]  timeout       Structure describing the transmission timeout value
+ */
+void SX126xSetTx( uint32_t timeout );
+
+/*!
+ * \brief Sets the radio in reception mode
+ *
+ * \param [in]  timeout       Structure describing the reception timeout value
+ */
+void SX126xSetRx( uint32_t timeout );
+
+/*!
+ * \brief Sets the radio in reception mode with Boosted LNA gain
+ *
+ * \param [in]  timeout       Structure describing the reception timeout value
+ */
+void SX126xSetRxBoosted( uint32_t timeout );
+
+/*!
+ * \brief Sets the Rx duty cycle management parameters
+ *
+ * \param [in]  rxTime        Structure describing reception timeout value
+ * \param [in]  sleepTime     Structure describing sleep timeout value
+ */
+void SX126xSetRxDutyCycle( uint32_t rxTime, uint32_t sleepTime );
+
+/*!
+ * \brief Sets the radio in CAD mode
+ */
+void SX126xSetCad( void );
+
+/*!
+ * \brief Sets the radio in continuous wave transmission mode
+ */
+void SX126xSetTxContinuousWave( void );
+
+/*!
+ * \brief Sets the radio in continuous preamble transmission mode
+ */
+void SX126xSetTxInfinitePreamble( void );
+
+/*!
+ * \brief Decide which interrupt will stop the internal radio rx timer.
+ *
+ * \param [in]  enable          [0: Timer stop after header/syncword detection
+ *                               1: Timer stop after preamble detection]
+ */
+void SX126xSetStopRxTimerOnPreambleDetect( bool enable );
+
+/*!
+ * \brief Set the number of symbol the radio will wait to validate a reception
+ *
+ * \param [in]  SymbNum          number of LoRa symbols
+ */
+void SX126xSetLoRaSymbNumTimeout( uint8_t SymbNum );
+
+/*!
+ * \brief Sets the power regulators operating mode
+ *
+ * \param [in]  mode          [0: LDO, 1:DC_DC]
+ */
+void SX126xSetRegulatorMode( RadioRegulatorMode_t mode );
+
+/*!
+ * \brief Calibrates the given radio block
+ *
+ * \param [in]  calibParam    The description of blocks to be calibrated
+ */
+void SX126xCalibrate( CalibrationParams_t calibParam );
+
+/*!
+ * \brief Calibrates the Image rejection depending of the frequency
+ *
+ * \param [in]  freq    The operating frequency
+ */
+void SX126xCalibrateImage( uint32_t freq );
+
+/*!
+ * \brief Activate the extention of the timeout when long preamble is used
+ *
+ * \param [in]  enable      The radio will extend the timeout to cope with long preamble
+ */
+void SX126xSetLongPreamble( uint8_t enable );
+
+/*!
+ * \brief Sets the transmission parameters
+ *
+ * \param [in]  paDutyCycle     Duty Cycle for the PA
+ * \param [in]  hpMax          0 for sx1261, 7 for sx1262
+ * \param [in]  deviceSel       1 for sx1261, 0 for sx1262
+ * \param [in]  paLut           0 for 14dBm LUT, 1 for 22dBm LUT
+ */
+void SX126xSetPaConfig( uint8_t paDutyCycle, uint8_t hpMax, uint8_t deviceSel, uint8_t paLut );
+
+/*!
+ * \brief Defines into which mode the chip goes after a TX / RX done
+ *
+ * \param [in]  fallbackMode    The mode in which the radio goes
+ */
+void SX126xSetRxTxFallbackMode( uint8_t fallbackMode );
+
+/*!
+ * \brief Write data to the radio memory
+ *
+ * \param [in]  address       The address of the first byte to write in the radio
+ * \param [in]  buffer        The data to be written in radio's memory
+ * \param [in]  size          The number of bytes to write in radio's memory
+ */
+void SX126xWriteRegisters( uint16_t address, uint8_t *buffer, uint16_t size );
+
+/*!
+ * \brief Read data from the radio memory
+ *
+ * \param [in]  address       The address of the first byte to read from the radio
+ * \param [out] buffer        The buffer that holds data read from radio
+ * \param [in]  size          The number of bytes to read from radio's memory
+ */
+void SX126xReadRegisters( uint16_t address, uint8_t *buffer, uint16_t size );
+
+/*!
+ * \brief Write data to the buffer holding the payload in the radio
+ *
+ * \param [in]  offset        The offset to start writing the payload
+ * \param [in]  buffer        The data to be written (the payload)
+ * \param [in]  size          The number of byte to be written
+ */
+void SX126xWriteBuffer( uint8_t offset, uint8_t *buffer, uint8_t size );
+
+/*!
+ * \brief Read data from the buffer holding the payload in the radio
+ *
+ * \param [in]  offset        The offset to start reading the payload
+ * \param [out] buffer        A pointer to a buffer holding the data from the radio
+ * \param [in]  size          The number of byte to be read
+ */
+void SX126xReadBuffer( uint8_t offset, uint8_t *buffer, uint8_t size );
+
+/*!
+ * \brief   Sets the IRQ mask and DIO masks
+ *
+ * \param [in]  irqMask       General IRQ mask
+ * \param [in]  dio1Mask      DIO1 mask
+ * \param [in]  dio2Mask      DIO2 mask
+ * \param [in]  dio3Mask      DIO3 mask
+ */
+void SX126xSetDioIrqParams( uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask, uint16_t dio3Mask );
+
+/*!
+ * \brief Returns the current IRQ status
+ *
+ * \retval      irqStatus     IRQ status
+ */
+uint16_t SX126xGetIrqStatus( void );
+
+/*!
+ * \brief Indicates if DIO2 is used to control an RF Switch
+ *
+ * \param [in] enable     true of false
+ */
+void SX126xSetDio2AsRfSwitchCtrl( uint8_t enable );
+
+/*!
+ * \brief Indicates if the Radio main clock is supplied from a tcxo
+ *
+ * \param [in] tcxoVoltage     voltage used to control the TCXO
+ * \param [in] timeout         time given to the TCXO to go to 32MHz
+ */
+void SX126xSetDio3AsTcxoCtrl( RadioTcxoCtrlVoltage_t tcxoVoltage, uint32_t timeout );
+
+/*!
+ * \brief Sets the RF frequency
+ *
+ * \param [in]  frequency     RF frequency [Hz]
+ */
+void SX126xSetRfFrequency( uint32_t frequency );
+
+/*!
+ * \brief Sets the radio for the given protocol
+ *
+ * \param [in]  packetType    [PACKET_TYPE_GFSK, PACKET_TYPE_LORA]
+ *
+ * \remark This method has to be called before SetRfFrequency,
+ *         SetModulationParams and SetPacketParams
+ */
+void SX126xSetPacketType( RadioPacketTypes_t packetType );
+
+/*!
+ * \brief Gets the current radio protocol
+ *
+ * \retval      packetType    [PACKET_TYPE_GFSK, PACKET_TYPE_LORA]
+ */
+RadioPacketTypes_t SX126xGetPacketType( void );
+
+/*!
+ * \brief Sets the transmission parameters
+ *
+ * \param [in]  power         RF output power [-18..13] dBm
+ * \param [in]  rampTime      Transmission ramp up time
+ */
+void SX126xSetTxParams( int8_t power, RadioRampTimes_t rampTime );
+
+/*!
+ * \brief Set the modulation parameters
+ *
+ * \param [in]  modParams     A structure describing the modulation parameters
+ */
+void SX126xSetModulationParams( ModulationParams_t *modParams );
+
+/*!
+ * \brief Sets the packet parameters
+ *
+ * \param [in]  packetParams  A structure describing the packet parameters
+ */
+void SX126xSetPacketParams( PacketParams_t *packetParams );
+
+/*!
+ * \brief Sets the Channel Activity Detection (CAD) parameters
+ *
+ * \param [in]  cadSymbolNum   The number of symbol to use for CAD operations
+ *                             [LORA_CAD_01_SYMBOL, LORA_CAD_02_SYMBOL,
+ *                              LORA_CAD_04_SYMBOL, LORA_CAD_08_SYMBOL,
+ *                              LORA_CAD_16_SYMBOL]
+ * \param [in]  cadDetPeak     Limit for detection of SNR peak used in the CAD
+ * \param [in]  cadDetMin      Set the minimum symbol recognition for CAD
+ * \param [in]  cadExitMode    Operation to be done at the end of CAD action
+ *                             [LORA_CAD_ONLY, LORA_CAD_RX, LORA_CAD_LBT]
+ * \param [in]  cadTimeout     Defines the timeout value to abort the CAD activity
+ */
+void SX126xSetCadParams( RadioLoRaCadSymbols_t cadSymbolNum, uint8_t cadDetPeak, uint8_t cadDetMin, RadioCadExitModes_t cadExitMode, uint32_t cadTimeout );
+
+/*!
+ * \brief Sets the data buffer base address for transmission and reception
+ *
+ * \param [in]  txBaseAddress Transmission base address
+ * \param [in]  rxBaseAddress Reception base address
+ */
+void SX126xSetBufferBaseAddress( uint8_t txBaseAddress, uint8_t rxBaseAddress );
+
+/*!
+ * \brief Gets the current radio status
+ *
+ * \retval      status        Radio status
+ */
+RadioStatus_t SX126xGetStatus( void );
+
+/*!
+ * \brief Returns the instantaneous RSSI value for the last packet received
+ *
+ * \retval      rssiInst      Instantaneous RSSI
+ */
+int8_t SX126xGetRssiInst( void );
+
+/*!
+ * \brief Gets the last received packet buffer status
+ *
+ * \param [out] payloadLength Last received packet payload length
+ * \param [out] rxStartBuffer Last received packet buffer address pointer
+ */
+void SX126xGetRxBufferStatus( uint8_t *payloadLength, uint8_t *rxStartBuffer );
+
+/*!
+ * \brief Gets the last received packet payload length
+ *
+ * \param [out] pktStatus     A structure of packet status
+ */
+void SX126xGetPacketStatus( PacketStatus_t *pktStatus );
+
+/*!
+ * \brief Returns the possible system errors
+ *
+ * \retval sysErrors Value representing the possible sys failures
+ */
+RadioError_t SX126xGetDeviceErrors( void );
+
+/*!
+ * \brief Clear all the errors in the device
+ */
+void SX126xClearDeviceErrors( void );
+
+/*!
+ * \brief Clears the IRQs
+ *
+ * \param [in]  irq           IRQ(s) to be cleared
+ */
+void SX126xClearIrqStatus( uint16_t irq );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __SX126x_H__