/************************************************************************************ * @Copyright (c) :(C)2017, Qindao ieslab Co., Ltd * @FileName :pic24_nb_driver.c * @Author :QDIES PLATFORM TEAM * @Version :V1.0 * @Date :2017-03-01 * @Description : ************************************************************************************/ #include "sys_config.h" #ifdef NB_MODULE_BC28 #ifdef __cplusplus extern "C" { #endif #include "nb_uart_driver_bc28.h" #include "nb_driver_bc28.h" #include "stdio.h" #include #include "UWater_timer1uS_driver.h" #include "UWater_uart_driver.h" #include "UWater_Rtcc_Driver.h" #include "UWater_frame_app.h" #include "UWater_Adc_driver.h" #include "nb_upload_monitor.h" /********************************变量定义************************************/ NBIOT_PARA Nbiot_Para; NBIOT_MSG Nbiot_Msg; static NBIOT_SEND_DATA Nbiot_Send_Data; //static u8 *g_s_csq_value; //状态变量(各个状态机运行的状态变量) u8 g_s_nbiot_main_state = NBIOT_S_IDLE; //u8 s_send_state; //任务标志位 u8 g_s_nbiot_task_flag = TASK_INIT; u8 g_s_nbiot_mode_flag = NO_NBIOT_TASK; u8 g_s_nbiot_send_type; u8 g_s_nbiot_read_ccid_flag = FALSE; u8 g_s_nbiot_read_ECL_flag = FALSE; u8 flag_clear_ncsearfcn = 0; u8 nb_power_flag = FALSE; u8 s_init_state = S_INIT_POWER_ON; u8 s_coap_connect_state = S_COAP_CONNECT_START; TYP_UDP_CONNECT s_udp_connect_state = S_UDP_CONNECT_IDLE; u8 s_coap_send_state = S_SEND_START; TYP_UDP_SEND s_udp_send_state = S_UDP_SEND_IDLE; u8 s_power_off_state = S_START; char c_AT_NMGS[40 + UP_BUF_SIZE*2];//发送数据长度较小 static const char* c_AT_NUESTATS = "AT+NUESTATS\r";//"AT+QENG=0\r"; static const char* c_AT_CCLK = "AT+CCLK?\r"; //查询基站时间 //ip地址和端口指针 unsigned char *coap_ip; u16 coap_port; unsigned char *udp_ip1; u16 udp_port1; unsigned char *udp_ip2; u16 udp_port2; u8 nbiot_temp_connect_type=NBIOT_CONNECT_COAP; //PSM状态 TYP_PSM_STATE psm_model_state = PSM_STATE_OUT; TYP_PSM_WAKEUP_STATE s_psm_wakeup_state = PSM_WKUPSTA_IDLE; TYP_PSM_SLEEP_STATE s_psm_sleep_state = PSM_SLPSTA_IDLE; //PSM异常检测 static u8 s_psm_adc_done = 0; // AD装换结果完成标志 static u32 s_psm_adc_result = 0; // AD转换后结果存放 /*****************************内部功能状态机***********************************/ void NbiotInitMachine(void); void CoapConnectMachine(void); void UdpConnectMachine(void); void CoapSendDataMachine(void); void UdpSendDataMachine(void); void NbiotPowerOffMachine(void); void UdpReadDataMachine(void); //static void NbiotMsgDeal(void); void NbiotReadECLSNRMachine(void); void StartUdpSendData(void); void sys_get_three_code (void); void OnenetConnectMachine(void); void OneNetSendDataMachine(void); void StartOnenetAckRev(void); void NbiotRevAckMachine(void); static void Psm_Wakup_Machine(void); static void Psm_Sleep_Machine(void); /*****************************内部定时器接口**********************************/ void set_timer_1s(u16 time); u16 check_timer_1s(void); void set_timer_1ms(u16 time); u16 check_timer_1ms(void); void CoapStartConnect(void); void StartCoapSendData(void); void StartNbiotInit(void); void UdpStartConnect(u8 udp_num); void OneNetStartConnect(void); void StartOnenetSendData(void); /*****************************外部接口****************************************/ void NB_Power_Disable(void) { Gpio_WriteOutputIO(BAT_NB_PORT, BAT_NB_PIN, FALSE); nb_power_flag = FALSE; } void NB_Power_Enable(void) { Gpio_WriteOutputIO(BAT_NB_PORT, BAT_NB_PIN, TRUE); nb_power_flag = TRUE; } u8 If_NB_Poweron(void) { return nb_power_flag; } /*************************************************************************** * @fun_name void NbModuleIOInit(void) * @brief 模块供电IO、模块复位、电源、PSM唤醒引脚初始化 ***************************************************************************/ void NbModuleIOInit(void) { stc_gpio_cfg_t stcGpioCfg; DDL_ZERO_STRUCT(stcGpioCfg); stcGpioCfg.enDir = GpioDirOut; ///< 端口方向配置 stcGpioCfg.enDrv = GpioDrvL; ///< 端口驱动能力配置->低驱动能力 stcGpioCfg.enPu = GpioPuDisable; ///< 端口上下拉配置->无 stcGpioCfg.enPd = GpioPdDisable; stcGpioCfg.enOD = GpioOdDisable; ///< 端口开漏输出配置 stcGpioCfg.enCtrlMode = GpioAHB; ///< 端口输入/输出值寄存器总线控制模式配置->AHB Gpio_Init(BAT_NB_PORT, BAT_NB_PIN, &stcGpioCfg); //模块供电IO Gpio_Init(RSTN_NB_PORT, RSTN_NB_PIN, &stcGpioCfg); Gpio_Init(NB_PSM_WAKE_PORT, NB_PSM_WAKE_PIN, &stcGpioCfg); Gpio_Init(PWR_NB_PORT, PWR_NB_PIN, &stcGpioCfg); //电源控制脚 Gpio_WriteOutputIO(BAT_NB_PORT, BAT_NB_PIN, FALSE); Gpio_WriteOutputIO(PWR_NB_PORT, PWR_NB_PIN, FALSE); Gpio_WriteOutputIO(RSTN_NB_PORT, RSTN_NB_PIN, FALSE); Gpio_WriteOutputIO(NB_PSM_WAKE_PORT , NB_PSM_WAKE_PIN, FALSE); } /*************************************************************************** * @fun_name void NbiotMainMachine() * @brief NBIOT主任务机，放在主程序空间的主循环中，进行NBIOT任务处理 ***************************************************************************/ void NbiotMainMachine(void) { switch (g_s_nbiot_main_state) { case NBIOT_S_IDLE: { //沈阳规约修改，udp下发指令和应答帧间隔太短，需要主动查询数据 // if(TRUE == UdpIfNeedReadDataBc25(NBIOT_CONNECT_UDP1)) // { // ClearUdpReadDataFlag(NBIOT_CONNECT_UDP1); // SetRcvDataType(NB_RCV_UDP1_DATA); // g_s_nbiot_main_state = NBIOT_READ_UDP_DATA; // } // else if(TRUE == UdpIfNeedReadDataBc25(NBIOT_CONNECT_UDP2)) // { // ClearUdpReadDataFlag(NBIOT_CONNECT_UDP2); // SetRcvDataType(NB_RCV_UDP2_DATA); // g_s_nbiot_main_state = NBIOT_READ_UDP_DATA; // } // else if(TRUE == Check_Udp_Data_Received()) // { // Clear_Udp_Rec_Data_Flag(); // g_s_nbiot_main_state = NBIOT_READ_UDP_DATA; // } // else if(TRUE == NbiotGetRevAck())//收到ONNET下发的数据,先进入应答流程应答一下 { ClearNbiotGetRevAck(); StartOnenetAckRev(); g_s_nbiot_main_state = NBIOT_REV_ACK; } else if(FrameCheckMsgApp(Msg_PsmPowerCheck)) { FrameClearMsgApp(Msg_PsmPowerCheck); if(psm_model_state == PSM_STATE_SLEEP) { NbiotPsmCheckTask(); } } } break; case NBIOT_POWER_INIT: { if (TASK_INIT == g_s_nbiot_task_flag) //如果是初始状态 { NbiotInitMachine(); //模块初始化状态机 } else if (TASK_SUCCESS == g_s_nbiot_task_flag) //任务成功 { u8 temp_iccid_buf[20]; NbiotGetICCID((char*)temp_iccid_buf); //中国移动的为:898600;898602;898604;898607 中国电信898603;898611 Nbiot_Para.Telecom = SIM_CARD_TELECOM;//电信卡 if(temp_iccid_buf[4]=='0') { if((temp_iccid_buf[5]=='0')||(temp_iccid_buf[5]=='2')||(temp_iccid_buf[5]=='4')||(temp_iccid_buf[5]=='7')) { Nbiot_Para.Telecom = SIM_CARD_MOBILE; } } Nbiot_Para.net_state = NB_ON_LINE; g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } else //任务失败 { *Nbiot_Send_Data.state = NBIOT_ERROR; g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } } break; case NBIOT_NET_OPEN: { if (TASK_INIT == g_s_nbiot_task_flag) { if(nbiot_temp_connect_type == NBIOT_CONNECT_UDP1) { UdpConnectMachine(); } else if(nbiot_temp_connect_type == NBIOT_CONNECT_UDP2) { UdpConnectMachine(); } else { if(Nbiot_Para.Telecom == SIM_CARD_MOBILE)//移动卡 { OnenetConnectMachine();//与ONNET平台建立连接状态机 } else//电信卡 { CoapConnectMachine(); //与主站建立连接状态机 } } } else if (TASK_SUCCESS == g_s_nbiot_task_flag) { if((Sys_data_object.P1.func_cfg_bytes[12]&0x80)&&(Sys_data_object.P1.func_cfg_bytes[12]&0x03)) //PSM模式上报判断 { psm_model_state = PSM_STATE_WAKE; } else { psm_model_state = PSM_STATE_OUT; } if(nbiot_temp_connect_type == NBIOT_CONNECT_COAP) { Nbiot_Para.coap_state = CONNECT_ON_LINE; } else if(nbiot_temp_connect_type == NBIOT_CONNECT_UDP1) { Nbiot_Para.udp1_state = CONNECT_ON_LINE; } else if(nbiot_temp_connect_type == NBIOT_CONNECT_UDP2) { Nbiot_Para.udp2_state = CONNECT_ON_LINE; } g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } else { g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } } break; case NBIOT_DATA_SEND: { if (g_s_nbiot_task_flag == TASK_INIT) { if(g_s_nbiot_send_type == SEND_TYPE_COAP) { if(Nbiot_Para.Telecom == SIM_CARD_MOBILE)//移动卡 { OneNetSendDataMachine(); } else//电信卡 { CoapSendDataMachine(); //数据发送状态机 } } else if(g_s_nbiot_send_type == SEND_TYPE_UDP1) { UdpSendDataMachine(); //数据发送状态机 } else if(g_s_nbiot_send_type == SEND_TYPE_UDP2) { UdpSendDataMachine(); //数据发送状态机 } else { g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } } else//发送完毕回到空闲状态 { g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } } break; case NBIOT_POWER_OFF: { if (TASK_INIT == g_s_nbiot_task_flag) { NbiotPowerOffMachine(); //断电关机 } else { g_s_nbiot_mode_flag = NO_NBIOT_TASK; g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; Nbiot_Para.net_state = NB_OFF_LINE; Nbiot_Para.coap_state = CONNECT_OFF_LINE; Nbiot_Para.udp1_state = CONNECT_OFF_LINE; Nbiot_Para.udp2_state = CONNECT_OFF_LINE; } } break; case NBIOT_READ_ECL_SNR: { if (NB_ON_LINE == Nbiot_Para.net_state) { if (g_s_nbiot_task_flag == TASK_INIT) { NbiotReadECLSNRMachine(); //读CSQ状态机，上行规约需要自检，其中一项就是读信号值，因此做成单独的状态机 } else if (g_s_nbiot_task_flag == TASK_SUCCESS) { *Nbiot_Send_Data.state = RSRP_SUCCESS; g_s_nbiot_mode_flag = NO_NBIOT_TASK; g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } else { g_s_nbiot_mode_flag = NO_NBIOT_TASK; g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } } else //如果不在线 { if (TRUE == g_s_nbiot_read_ECL_flag) { if (g_s_nbiot_task_flag == TASK_INIT) { NbiotReadECLSNRMachine(); //读CSQ状态机，上行规约需要自检，其中一项就是读信号值，因此做成单独的状态机 } else if (g_s_nbiot_task_flag == TASK_SUCCESS) { g_s_nbiot_mode_flag = NO_NBIOT_TASK; g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } else { g_s_nbiot_mode_flag = NO_NBIOT_TASK; g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; //应用层调用关机流程_ } } else { g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_POWER_INIT; //模块初始化 StartNbiotInit(); } } } break; // case NBIOT_READ_UDP_DATA: // { // if (TASK_INIT == g_s_nbiot_task_flag) // { // UdpReadDataMachine(); // } // else // { // g_s_nbiot_task_flag = TASK_INIT; // g_s_nbiot_main_state = NBIOT_S_IDLE; // } // } // break; case NBIOT_REV_ACK: { if (TASK_INIT == g_s_nbiot_task_flag) { NbiotRevAckMachine(); } else { g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } } break; case NBIOT_PSM_WAKEUP: { if (TASK_INIT == g_s_nbiot_task_flag) { Psm_Wakup_Machine(); } else { g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } } break; case NBIOT_PSM_SLEEP: { if (TASK_INIT == g_s_nbiot_task_flag) { Psm_Sleep_Machine(); } else { g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } } break; default: { g_s_nbiot_main_state = NBIOT_S_IDLE; } break; } } /*************************************************************************** * @fun_name u8 NbiotIfIdle() * @brief 查询模块的空闲状态 ***************************************************************************/ u8 NbiotIfIdle(void) { if (NBIOT_S_IDLE == g_s_nbiot_main_state) { return TASK_IDLE; } else { return TASK_BUSY; } } /*************************************************************************** * @fun_name u8 NbiotIfOnline() * @brief 查询NBIOT是否在线 ***************************************************************************/ u8 NbiotIfOnline(void) { if (NB_ON_LINE == Nbiot_Para.net_state) { return TRUE; } else { return FALSE; } } /*************************************************************************** * @fun_name u8 ConncetIfOnline() * @brief 查询连接是否在线 ***************************************************************************/ u8 ConncetIfOnline(u8 connect_type) { if(connect_type == NBIOT_CONNECT_COAP) { if (CONNECT_ON_LINE == Nbiot_Para.coap_state) { return TRUE; } else { return FALSE; } } else if(connect_type == NBIOT_CONNECT_UDP1) { if (CONNECT_ON_LINE == Nbiot_Para.udp1_state) { return TRUE; } else { return FALSE; } } else if(connect_type == NBIOT_CONNECT_UDP2) { if (CONNECT_ON_LINE == Nbiot_Para.udp2_state) { return TRUE; } else { return FALSE; } } return FALSE; } /*************************************************************************** * @fun_name void NbiotOnlineTask(u8 *state) * @brief NBIOT上线任务 * @param[in] state:状态信息 ***************************************************************************/ void NbiotOnlineTask(u8 *state) { if (NBIOT_S_IDLE == g_s_nbiot_main_state) { if (!NbiotIfOnline()) { if (NBIOT_S_IDLE == g_s_nbiot_main_state) { Nbiot_Send_Data.state = state; //地址拷贝 *state = NBIOT_ING; g_s_nbiot_mode_flag = ONLINE_MODE; g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_POWER_INIT; StartNbiotInit(); } } else { *state = NBIOT_ONLINE; } } else { *state = NBIOT_ERROR; } } /*************************************************************************** * @fun_name void NB_NetConnectStart * @brief 根据连接类型建立连接 * @param[in] state:状态信息 ***************************************************************************/ void NB_NetConnectStart(unsigned char* temp_ip, u16 temp_port, u8 connect_type) { if(connect_type == NBIOT_CONNECT_COAP) { coap_ip = temp_ip; coap_port = temp_port; if(Nbiot_Para.Telecom == SIM_CARD_MOBILE)//移动卡 { OneNetStartConnect(); } else//电信卡 { CoapStartConnect(); } nbiot_temp_connect_type = NBIOT_CONNECT_COAP; } else if(connect_type == NBIOT_CONNECT_UDP1) { udp_ip1 = temp_ip; udp_port1 = temp_port; UdpStartConnect(NBIOT_CONNECT_UDP1); } else if(connect_type == NBIOT_CONNECT_UDP2) { udp_ip2 = temp_ip; udp_port2 = temp_port; UdpStartConnect(NBIOT_CONNECT_UDP2); } g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_NET_OPEN; } void NbiotPsmWakeupTask(void) { if (NBIOT_S_IDLE == g_s_nbiot_main_state) { g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_PSM_WAKEUP; s_psm_wakeup_state = PSM_WKUPSTA_START; } } void NbiotPsmSleepTask(void) { if (NBIOT_S_IDLE == g_s_nbiot_main_state) { g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_PSM_SLEEP; s_psm_sleep_state = PSM_SLPSTA_START; } } void NbiotPsmCheckTask(void) { if (NBIOT_S_IDLE == g_s_nbiot_main_state) { g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_PSM_SLEEP; s_psm_sleep_state = PSM_CHECK_START; } } /*************************************************************************** * @fun_name void NbiotSendTask(u8 *addr, u16 len, u8 send_type,u8 *state) * @brief NBIOT数据发送任务 * @param[in] addr：内容的首地址 len：长度 * @param[out] state:状态信息 * @retval None * @other state(NBIOT_ING：查询中, NBIOT_SUCCES：成功 其他：异常) ***************************************************************************/ void NbiotSendTask(u8 *addr, u16 len, u8 send_type,u8 *state) { if ((NBIOT_S_IDLE == g_s_nbiot_main_state) && (len > 0) && (len <= UP_BUF_SIZE)) { Nbiot_Send_Data.buf = addr; //地址拷贝 Nbiot_Send_Data.len = len; //值拷贝 Nbiot_Send_Data.state = state; //地址拷贝 *state = NBIOT_ING; g_s_nbiot_mode_flag = SEND_MODE; g_s_nbiot_send_type = send_type; g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_DATA_SEND; StartNbiotSendData(); } else { *state = NBIOT_ERROR; } } //获取发送类型 u8 GetNbiotSendType(void) { return g_s_nbiot_send_type; } /*************************************************************************** * @fun_name void NbiotReadCsqTask(u8 *out_csq,u8 *state) * @brief NBIOT查询信号值任务 * @param[in] out_csq：存放数据地址 * @param[out] state:状态信息 * @retval None * @other state(CSQ_ING：查询中, CSQ_SUCCES：成功 其他：异常) ***************************************************************************/ /*void NbiotUdpOpenTask(void) { if (NBIOT_S_IDLE == g_s_nbiot_main_state) { if(!UdpIfOnline()) { g_s_nbiot_mode_flag = ONLINE_MODE; g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_UDP_OPEN; UdpStartConnect(); } } }*/ void NbiotReadECLSNRTask(u8 *state) { if (NBIOT_S_IDLE == g_s_nbiot_main_state) { Nbiot_Send_Data.state = state; *state = ECL_SNR_ING; g_s_nbiot_mode_flag = READ_ECL_SNR; g_s_nbiot_read_ECL_flag = FALSE; g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_READ_ECL_SNR; } else { *state = ECL_SNR_ERROR; } } /*************************************************************************** * @fun_name u8 NbiotIfSleep() * @brief 是否允许休眠 * @param[in] None * @param[out] None * @retval TRUE: 允许 FALSE:不允许 * @other None ***************************************************************************/ u8 NbiotIfSleep(void) { if (NBIOT_S_IDLE == g_s_nbiot_main_state) { return TRUE; } else { return FALSE; } } /*************************************************************************** * @fun_name void NbiotPreSleep() * @brief 休眠前操作 * @param[in] None * @param[out] None * @retval None * @other None ***************************************************************************/ static void NbiotPreSleepNormal(void) { NB_Power_Disable(); //切断电源 UartPreSleep(NB_UART_COM); g_s_nbiot_main_state = NBIOT_S_IDLE; Nbiot_Para.coap_state = CONNECT_OFF_LINE; Nbiot_Para.udp1_state = CONNECT_OFF_LINE; Nbiot_Para.udp2_state = CONNECT_OFF_LINE; Nbiot_Para.net_state = NB_OFF_LINE; //配置NB相关引脚 stc_gpio_cfg_t stcGpioCfg; DDL_ZERO_STRUCT(stcGpioCfg); stcGpioCfg.enDir = GpioDirOut; ///< 端口方向配置 stcGpioCfg.enDrv = GpioDrvL; ///< 端口驱动能力配置->低驱动能力 stcGpioCfg.enPu = GpioPuDisable; ///< 端口上下拉配置->无 stcGpioCfg.enPd = GpioPdDisable; stcGpioCfg.enOD = GpioOdDisable; ///< 端口开漏输出配置 stcGpioCfg.enCtrlMode = GpioAHB; ///< 端口输入/输出值寄存器总线控制模式配置->AHB Gpio_Init(BAT_NB_PORT, BAT_NB_PIN, &stcGpioCfg); //模块供电IO Gpio_Init(RSTN_NB_PORT, RSTN_NB_PIN, &stcGpioCfg); Gpio_Init(NB_PSM_WAKE_PORT, NB_PSM_WAKE_PIN, &stcGpioCfg); Gpio_Init(PWR_NB_PORT, PWR_NB_PIN, &stcGpioCfg); //电源控制脚 Gpio_WriteOutputIO(BAT_NB_PORT, BAT_NB_PIN, FALSE); Gpio_WriteOutputIO(PWR_NB_PORT, PWR_NB_PIN, FALSE); Gpio_WriteOutputIO(RSTN_NB_PORT, RSTN_NB_PIN, FALSE); Gpio_WriteOutputIO(NB_PSM_WAKE_PORT , NB_PSM_WAKE_PIN, FALSE); Gpio_Init(LPUART1_TX_PORT, LPUART1_TX_PIN, &stcGpioCfg); Gpio_WriteOutputIO(LPUART1_TX_PORT, LPUART1_TX_PIN, FALSE); //TX也配置为输出低 stcGpioCfg.enDir = GpioDirIn; //RX输入 Gpio_Init(LPUART1_RX_PORT, LPUART1_RX_PIN, &stcGpioCfg); } static void NbiotPreSleepPsm(void) { UartPreSleep(NB_UART_COM); g_s_nbiot_main_state = NBIOT_S_IDLE; } void NbiotPreSleep(void) { if(Sys_data_object.P3.NBSleepMode == 1)//PSM模式休眠 { NbiotPreSleepPsm(); } else { NbiotPreSleepNormal(); } } /*************************************************************************** * @fun_name void NbiotWakeSleep() * @brief 休眠后唤醒 * @param[in] None * @param[out] None * @retval None * @other None ***************************************************************************/ void NbiotWakeSleep(void) { } /******************************内部状态机***********************************/ void StartNbiotInit(void) { s_init_state = S_INIT_POWER_ON; } /*************************************************************************** * @fun_name void NbiotInitMachine() * @brief NBIOT初始化状态机 * @param[in] None * @param[out] None * @retval None * @other None ***************************************************************************/ /*模组端串口调试配置*/ void NB_UartInitForGPIO(void)//debug { stc_gpio_cfg_t stcGpioCfg; DDL_ZERO_STRUCT(stcGpioCfg); //PA0,PA1:配置为数字输入 stcGpioCfg.enDir = GpioDirIn; ///< 端口方向配置->输入 stcGpioCfg.enDrv = GpioDrvL; ///< 端口驱动能力配置->低驱动能力 stcGpioCfg.enPu = GpioPuDisable; ///< 端口上下拉配置->无 stcGpioCfg.enPd = GpioPdDisable; stcGpioCfg.enOD = GpioOdDisable; ///< 端口开漏输出配置->开漏输出关闭 stcGpioCfg.enCtrlMode = GpioAHB; ///< 端口输入/输出值寄存器总线控制模式配置->AHB Gpio_Init(GpioPortA, GpioPin0, &stcGpioCfg); Gpio_Init(GpioPortA, GpioPin1, &stcGpioCfg); } #define MODULE_POWER_DELAY_TIME 2000 //mS #define MODULE_RESET_DELAY_TIME 1000 //mS //AT+QBAND AT+QBAND=1,5 //设置频段为 BAND 5 //中国移动的为:898600;898602;898604;898607 中国电信898603;898611 void NbiotInitMachine_BC28(void) { static u8 s_at_error_count = 0; //记录AT错误或者指令超时次数 超过指定次数后认为任务失败 static const char* c_AT = "ATE1\r";//"ATE1\r"; //AT+NSMI=1 不保存 static const char* c_AT_IMEI = "AT+CGSN=1\r"; static const char* c_AT_CIMI = "AT+CIMI\r"; static const char* c_AT_ICCID = "AT+NCCID\r"; static const char* c_AT_CMEE = "AT+CMEE=1\r"; //打开ERROR错误码显示 static const char* c_AT_CPSMS = "AT+CPSMS=0\r"; //关闭PSM模式 static const char* c_AT_NPTWEDRXS = "AT+CEDRXS=0,5\r"; //关闭eDRX模式 static const char* c_AT_CSQ = "AT+CSQ\r"; //查询信号值 static const char* c_AT_CEREG = "AT+CEREG?\r"; //static const char* c_AT_NCFG = "AT+NCFG=0,172800\r";//设置lifetime 平台端的生存周期 超过指定时间设备显示离线，48小时 static const char* c_AT_NCFG = "AT+QCFG=\"LWM2M/lifetime\",172800\r";//设置lifetime static const char* c_AT_CGATT = "AT+CGATT?\r"; static u8 c_AT_CGDCONT_APN[APN_SIZE+50] = "AT+CGDCONT=0,\"IP\",\""; //指定APN,定义数组大小为固定20字节+APN数组大小，再加预留空间 /** BC28:模块VBAT上电后,保持RESET_N输入不被拉低,即可实现模块自动开机.booting时间500ms BC28:pin7为boot引脚,BC25为开机键 */ switch (s_init_state) { case S_INIT_POWER_ON://NB模块送电 { NbModuleIOInit(); //初始化默认模块断电 UartInit(NB_UART_COM, BAUD9600, DATA_BIT_8, STOPBIT_1, UART_NONE_PARITY,UART_LPUART_Disable); RSTN_NB_HIG(); //PWR_NB_HIG(); BC28:pin7为boot引脚 NB_Power_Enable(); set_timer_1ms(MODULE_POWER_DELAY_TIME); s_init_state = S_INIT_POWER_ON_WAIT; clearRegindState(); } break; /* case S_INIT_PWRKEY_LOW://NB模块送电 { if (!check_timer_1ms()) { PWR_NB_LOW(); s_init_state = S_INIT_PWRKEY_HIGH; set_timer_1ms(MODULE_RESET_DELAY_TIME*4); } } break; case S_INIT_PWRKEY_HIGH://NB模块送电 { if (!check_timer_1ms()) { PWR_NB_HIG(); //高电平 set_timer_1s(1); s_init_state = S_INIT_POWER_ON_WAIT; } } break; */ case S_INIT_POWER_ON_WAIT://等待模块搜网注册延时 { if (!check_timer_1ms())//if (!check_timer_1s()) { s_at_error_count = 0; //AT指令错误次数清零 set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); if(getUploadControlPara(UP_AT_SIMPLE)!=AT_SIMPLE_NULL) { s_init_state = S_INIT_ASK_CEREG; } else { s_init_state = S_INIT_ATS; } } } break; case S_INIT_ATS://发送"AT" 确认模块正常运行 { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT, strlen(c_AT), cst_AT_No_AT); s_init_state = S_INIT_ATS_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); } } break; case S_INIT_ATS_R://等待"AT"应答 { if (NbiotCheckAtAck() == UART_OK)//返回正确的应答 { s_at_error_count = 0; s_init_state = S_INIT_ASK_IMEI; //下一步开始查询IMEI set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR)) //应答超时或者错误 { if (++s_at_error_count >= NUM_AT_ERROR) { s_at_error_count = 0; s_init_state = S_INIT_ASK_IMEI; //下一步开始查询IMEI set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_init_state = S_INIT_ATS; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_INIT_ASK_IMEI: //开始查询IMEI号 { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_IMEI, strlen(c_AT_IMEI), cst_AT_No_AT_IMEI); s_init_state = S_INIT_ASK_IMEI_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); //测试报告中AT指令返回的最长时间300ms(不包含发送和接收占用的时间) } } break; case S_INIT_ASK_IMEI_R://等待IMEI应答 { if (NbiotCheckAtAck() == UART_OK)//返回正确的应答 { s_at_error_count = 0; s_init_state = S_INIT_ASK_CIMI; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR)) { if (++s_at_error_count >= NUM_AT_CIMI_ERROR) { s_at_error_count = 0; s_init_state = S_INIT_ASK_CIMI; set_timer_1ms(2 * AT_COMMAND_SEND_INTERVAL_TIME); } else { s_init_state = S_INIT_ASK_IMEI; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_INIT_ASK_CIMI://开始查询CIMI { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_CIMI, strlen(c_AT_CIMI), cst_AT_No_AT_CIMI); s_init_state = S_INIT_ASK_CIMI_R; set_timer_1ms(3*AT_COMMAND_RECEIVE_WAIT_TIME); //测试报告中AT指令返回的最长时间300ms(不包含发送和接收占用的时间) } } break; case S_INIT_ASK_CIMI_R://等待CIMI应答 { if (NbiotCheckAtAck() == UART_OK)//返回正确的应答 { s_at_error_count = 0; s_init_state = S_INIT_ASK_ICCID; //开始查询ICCID set_timer_1ms(2*AT_COMMAND_SEND_INTERVAL_TIME); } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR)) { if (++s_at_error_count >= NUM_AT_CIMI_ERROR) { s_at_error_count = 0; s_init_state = S_INIT_ASK_ICCID; //开始查询ICCID set_timer_1ms(2*AT_COMMAND_SEND_INTERVAL_TIME); } else { s_init_state = S_INIT_ASK_CIMI; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_INIT_ASK_ICCID://开始查询ICCID { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_ICCID, strlen(c_AT_ICCID), cst_AT_No_AT_ICCID); s_init_state = S_INIT_ASK_ICCID_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); //测试报告中AT指令返回的最长时间300ms(不包含发送和接收占用的时间) } } break; case S_INIT_ASK_ICCID_R://等待ICCID应答 { if (NbiotCheckAtAck() == UART_OK)//返回正确的应答 { s_at_error_count = 0; //将IMEI IMSI ICCID 转换并拷贝到全局RAM sys_get_three_code(); s_init_state = S_INIT_CMEE; //下一步打开ERROR错误代码显示 set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR)) { if (++s_at_error_count >= NUM_AT_ICCID_ERROR) { s_at_error_count = 0; s_init_state = S_INIT_CMEE; //下一步打开ERROR错误代码显示 set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_init_state = S_INIT_ASK_ICCID; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_INIT_CMEE: // { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_CMEE, strlen(c_AT_CMEE), cst_AT_No_AT_CMEE); s_init_state = S_INIT_CMEE_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); //测试报告中AT指令返回的最长时间300ms(不包含发送和接收占用的时间) } } break; case S_INIT_CMEE_R://等待CMEE应答 { if (NbiotCheckAtAck() == UART_OK)//返回正确的应答 { s_at_error_count = 0; s_init_state = S_TCP_CPSMS; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR)) { if (++s_at_error_count >= NUM_AT_CMEE_ERROR) { s_at_error_count = 0; s_init_state = S_TCP_CPSMS; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_init_state = S_INIT_CMEE; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_TCP_CPSMS://设置关闭PSM模式 { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_CPSMS, strlen(c_AT_CPSMS), cst_AT_No_AT_CPSMS); s_init_state = S_TCP_CPSMS_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); } } break; case S_TCP_CPSMS_R: { if (NbiotCheckAtAck() == UART_OK)//应答正确-下一步 { s_at_error_count = 0; s_init_state = S_TCP_NPTWEDRXS; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR)) { if (++s_at_error_count >= NUM_AT_CPSMS_ERROR) { s_at_error_count = 0; s_init_state = S_TCP_NPTWEDRXS; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_init_state = S_TCP_CPSMS; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_TCP_NPTWEDRXS://关闭eDRX模式 { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_NPTWEDRXS, strlen(c_AT_NPTWEDRXS), cst_AT_No_AT_NPTWEDRXS); s_init_state = S_TCP_NPTWEDRXS_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); } } break; case S_TCP_NPTWEDRXS_R://关闭eDRX模式 --等待应答 { if (NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; s_init_state = S_INIT_AT_CGDCONT; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR)) { if (++s_at_error_count >= NUM_AT_NPTWEDRXS_ERROR) { s_at_error_count = 0; s_init_state = S_INIT_AT_CGDCONT; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_init_state = S_TCP_NPTWEDRXS; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_INIT_AT_CGDCONT: { if(!check_timer_1ms()) { u8 ip_apn = 19; int i; for(i = 0; i < Sys_data_object.P1.apn[1]; i++) { c_AT_CGDCONT_APN[ip_apn++] = Sys_data_object.P1.apn[2 + i]; } c_AT_CGDCONT_APN[ip_apn++] = '"'; c_AT_CGDCONT_APN[ip_apn++] = '\r'; NbiotUartSend((u8*) c_AT_CGDCONT_APN, ip_apn, cst_AT_No_AT_CGDCONT); set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); s_init_state = S_INIT_AT_CGDCONT_R; } } break; case S_INIT_AT_CGDCONT_R: { if (NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); s_init_state = S_INIT_ASK_CSQ; } else if ((NbiotCheckAtAck() == UART_ERROR) || (!check_timer_1ms())) { s_at_error_count++; if (s_at_error_count >= AT_ERROR) { s_at_error_count = 0; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); s_init_state = S_INIT_ASK_CSQ; } else { s_init_state = S_INIT_AT_CGDCONT; } } } break; case S_INIT_ASK_CSQ://查询CSQ { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_CSQ, strlen(c_AT_CSQ), cst_AT_No_AT_CSQ); s_init_state = S_INIT_ASK_CSQ_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); //测试报告中AT指令返回的最长时间300ms(不包含发送和接收占用的时间) } } break; case S_INIT_ASK_CSQ_R://等待CSQ应答 { if (NbiotCheckAtAck() == UART_OK)//返回正确的应答 { s_at_error_count = 0; s_init_state = S_INIT_ASK_CEREG; //开始查询CEREG set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR)) { if (++s_at_error_count >= NUM_AT_CSQ_ERROR) { s_at_error_count = 0; s_init_state = S_INIT_ASK_CEREG; //开始查询CEREG set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_init_state = S_INIT_ASK_CSQ; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_INIT_ASK_CEREG://开始查询CEREG { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_CEREG, strlen((const char*) c_AT_CEREG), cst_AT_No_AT_CEREG); s_init_state = S_INIT_ASK_CEREG_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME * 2); } } break; case S_INIT_ASK_CEREG_R://等待CEREG应答 { if (NbiotCheckAtAck() == UART_OK)//正确应答 { s_at_error_count = 0; s_init_state = S_INIT_SET_NCFG; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR))//应答超时 { /*u8 NB_login_ask_times = FrameCheckParaApp(FramePara_NbParaLoginAckTimes); if (NB_login_ask_times < 30) { NB_login_ask_times = 30; } if (NB_login_ask_times > 150) { NB_login_ask_times = 150; } if (++s_at_error_count >= NB_login_ask_times)*/ if (++s_at_error_count >= NUM_AT_CEREG_ERROR) { s_at_error_count = 0; s_init_state = S_INIT_SET_NCFG; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_init_state = S_INIT_ASK_CEREG; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_INIT_SET_NCFG: { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_NCFG, strlen((const char*) c_AT_NCFG), cst_AT_No_AT); s_init_state = S_INIT_SET_NCFG_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME * 2); //测试报告中AT指令返回的最长时间300ms(不包含发送和接收占用的时间) } } break; case S_INIT_SET_NCFG_R: { if (NbiotCheckAtAck() == UART_OK)//正确应答 { s_init_state = S_INIT_ASK_CGATT; } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR))//应答超时 { s_init_state = S_INIT_ASK_CGATT; } } break; case S_INIT_ASK_CGATT://开始查询CGATT { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_CGATT, strlen(c_AT_CGATT), cst_AT_No_AT_CGATT_how); s_init_state = S_INIT_ASK_CGATT_R; set_timer_1ms(2*AT_COMMAND_RECEIVE_WAIT_TIME); //测试报告中AT指令返回的最长时间300ms(不包含发送和接收占用的时间) } } break; case S_INIT_ASK_CGATT_R://等待CGATT应答 { if (NbiotCheckAtAck() == UART_OK)//正确应答 { s_at_error_count = 0; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); s_init_state = S_INIT_ASK_NUESTATS; } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR))//应答超时 { u8 NB_login_ask_times = FrameCheckParaApp(FramePara_NbParaLoginAckTimes); if (NB_login_ask_times < 30) { NB_login_ask_times = 30; } if (NB_login_ask_times > 150) { NB_login_ask_times = 150; } if (++s_at_error_count >= NB_login_ask_times) { s_at_error_count = 0; g_s_nbiot_task_flag = TASK_FAIL; //初始化失败 s_init_state = S_INIT_POWER_ON; } else { s_init_state = S_INIT_ASK_CGATT; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_INIT_ASK_NUESTATS: { if(!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_NUESTATS, strlen(c_AT_NUESTATS), cst_AT_No_AT_NUESTATS); set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); s_init_state = S_INIT_ASK_NUESTATS_R; } } break; case S_INIT_ASK_NUESTATS_R: { if (NbiotCheckAtAck() == UART_OK) { //返回正确的应答 s_at_error_count = 0; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); s_init_state = S_INIT_ASK_CCLK; } else if(!check_timer_1ms()) { //返回错误的应答或者定时时间到 s_at_error_count++; if (s_at_error_count >= NUM_AT_ECL_ERROR) { s_at_error_count = 0; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); s_init_state = S_INIT_ASK_CCLK; } else { s_init_state = S_INIT_ASK_NUESTATS; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_INIT_ASK_CCLK://开始查询网络时间 { if(!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_CCLK, strlen(c_AT_CCLK), cst_AT_No_AT_CCLK); s_init_state = S_INIT_ASK_CCLK_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); } } break; case S_INIT_ASK_CCLK_R://等待应答 { if (NbiotCheckAtAck() == UART_OK)//正确应答 { s_at_error_count = 0; g_s_nbiot_task_flag = TASK_SUCCESS; //初始化成功 s_init_state = S_INIT_POWER_ON; // 任务指针返回 } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR))//应答超时 { if (++s_at_error_count >= NUM_AT_CCLK_ERROR) { s_at_error_count = 0; g_s_nbiot_task_flag = TASK_SUCCESS; //初始化成功 s_init_state = S_INIT_POWER_ON; // 任务指针返回 } else { s_init_state = S_INIT_ASK_CCLK; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; default: { s_at_error_count = 0; s_init_state = S_INIT_POWER_ON; } break; } } void NbiotInitMachine(void) { NbiotInitMachine_BC28(); } // void CoapStartConnect(void) { s_coap_connect_state = S_COAP_CONNECT_START; } /*************************************************************************** * @fun_name static void CoapConnectMachine() * @brief 连接Coap状态机 ***************************************************************************/ void CoapConnectMachine_BC25(void) { static u8 s_at_error_count = 0; unsigned char *nbiot_ip; u16 nbiot_port; //static char c_AT_NCDP[50] = "AT+NCDPOPEN=\"117.060.157.137\",05683\r"; // static char c_AT_NCDP[50] = "AT+NCDP=117.060.157.137,05683\r"; // //static const char* c_AT_NCDP_CK = "AT+NMSTATUS?\r"; // static const char* c_AT_QLWSREGIND = "AT+QLWSREGIND=0\r"; // switch (s_coap_connect_state) { case S_COAP_CONNECT_START: //任务开始 { s_at_error_count=0; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); if(getRegindState()==TRUE)//已经连接,则跳过连接服务器 { s_at_error_count = 0; *Nbiot_Send_Data.state = NBIOT_ONLINE; s_coap_connect_state = S_COAP_CONNECT_START; g_s_nbiot_task_flag = TASK_SUCCESS; } else { s_coap_connect_state = S_COAP_NCDP; } } break; case S_COAP_NCDP: { if (!check_timer_1ms()) { u16 len = 8; nbiot_port = coap_port; nbiot_ip = coap_ip; //IP 的存储仍然使用水表原来格式，不保存“.”号，使用时加入 for (int i = 0; i < 4; i++) { if (nbiot_ip[i] < 10) { c_AT_NCDP[len++] = nbiot_ip[i] + 0x30; } else if (nbiot_ip[i] < 100) { c_AT_NCDP[len++] = (nbiot_ip[i] / 10) + 0x30; c_AT_NCDP[len++] = (nbiot_ip[i] % 10) + 0x30; } else { c_AT_NCDP[len++] = (nbiot_ip[i] / 100) + 0x30; c_AT_NCDP[len++] = (nbiot_ip[i] / 10) % 10 + 0x30; c_AT_NCDP[len++] = (nbiot_ip[i] % 10) + 0x30; } c_AT_NCDP[len++] = '.'; } len--; //消除多余的点号 c_AT_NCDP[len++] = ','; c_AT_NCDP[len++] = ((nbiot_port) / 10000) + 0x30; c_AT_NCDP[len++] = (((nbiot_port) % 10000) / 1000) + 0x30; c_AT_NCDP[len++] = (((nbiot_port) % 1000) / 100) + 0x30; c_AT_NCDP[len++] = (((nbiot_port) % 100) / 10) + 0x30; c_AT_NCDP[len++] = ((nbiot_port) % 10) + 0x30; c_AT_NCDP[len++] = '\r'; NbiotUartSend((u8*)c_AT_NCDP, len, cst_AT_No_AT_NCDP); set_timer_1s(2); s_coap_connect_state = S_COAP_NCDP_R; } } break; case S_COAP_NCDP_R: { if(getRegindState()==TRUE)//跳过连接服务器 { s_at_error_count = 0; *Nbiot_Send_Data.state = NBIOT_ONLINE; s_coap_connect_state = S_COAP_CONNECT_START; g_s_nbiot_task_flag = TASK_SUCCESS; } else { if (NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; s_coap_connect_state = S_COAP_NCDP_CK; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if (!check_timer_1s() || NbiotCheckAtAck() == UART_ERROR) { s_at_error_count++; if (s_at_error_count >= NUM_AT_NCDP_ERROR)// { //一般不会发生,肯定能查到返回结果 s_at_error_count = 0; s_coap_connect_state = S_COAP_NCDP_CK; set_timer_1s(2); } else { s_coap_connect_state = S_COAP_NCDP; } } } } break; case S_COAP_NCDP_CK: { if(!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_QLWSREGIND, strlen(c_AT_QLWSREGIND), cst_AT_No_AT_NCDP_CK); set_timer_1s(35); s_coap_connect_state = S_COAP_NCDP_CK_R; } } break; case S_COAP_NCDP_CK_R: { if(getRegindState()==TRUE)//跳过连接服务器 { s_at_error_count = 0; *Nbiot_Send_Data.state = NBIOT_ONLINE; s_coap_connect_state = S_COAP_CONNECT_START; g_s_nbiot_task_flag = TASK_SUCCESS; } else if((!check_timer_1s())) { s_at_error_count++; if (s_at_error_count >= NUM_AT_NCDP_CK_ERROR) { s_at_error_count = 0; *Nbiot_Send_Data.state = NBIOT_ERROR; s_coap_connect_state = S_COAP_CONNECT_START; g_s_nbiot_task_flag = TASK_FAIL; } else { s_coap_connect_state = S_COAP_NCDP_CK; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; default: { s_coap_connect_state = S_COAP_CONNECT_START; //状态机回归初始状态 } break; } } void CoapConnectMachine() { CoapConnectMachine_BC25(); } void StartNbiotSendData(void) { if(g_s_nbiot_send_type == SEND_TYPE_COAP) { if(Nbiot_Para.Telecom == SIM_CARD_MOBILE)//移动卡 { StartOnenetSendData(); } else//电信卡 { StartCoapSendData(); //数据发送状态机 } } else if(g_s_nbiot_send_type == SEND_TYPE_UDP1) { StartUdpSendData(); //数据发送状态机 // UdpStartCheckData();//查询UDP数据 } else if(g_s_nbiot_send_type == SEND_TYPE_UDP2) { StartUdpSendData(); //数据发送状态机 // UdpStartCheckData();//查询UDP数据 } } #if SEND_ACKID_ENABLE u16 Send_AckID = 0; #endif // void StartCoapSendData(void) { s_coap_send_state = S_SEND_START; } void CoapSendDataMachine_BC25(void) { static u8 s_at_error_count = 0; //AT指令累计发送失败次数 static const u8 temp_AT_Buffer[]= {"AT+NMGS="}; static const char* c_AT_ACK = "AT+NSMI=1\r";//不保存 switch (s_coap_send_state) { case S_SEND_START: { s_coap_send_state = S_SEND_DATA; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); if((Sys_data_object.P1.func_cfg_bytes[10] == 0x55)||(Sys_data_object.P3.ProductUploadFlag == 0x55))//ACK判上报成功 { s_coap_send_state = S_SEND_ACK; } else { s_coap_send_state = S_SEND_DATA; } } break; case S_SEND_ACK://ACK { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_ACK, strlen(c_AT_ACK), cst_AT_No_AT); s_coap_send_state = S_SEND_ACK_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); } } break; case S_SEND_ACK_R: { if (NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; s_coap_send_state = S_SEND_DATA; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR)) //应答超时或者错误 { s_coap_send_state = S_SEND_DATA; } } break; case S_SEND_DATA: { if (!check_timer_1ms()) { u16 len = 8; //整条AT指令的长度，根据发送长度的位数来定 int i; for(i=0; i<8; i++) { c_AT_NMGS[i]=temp_AT_Buffer[i]; } c_AT_NMGS[len++] = (Nbiot_Send_Data.len / 10000) + 0x30; c_AT_NMGS[len++] = (Nbiot_Send_Data.len % 10000) / 1000 + 0x30; c_AT_NMGS[len++] = (Nbiot_Send_Data.len % 1000) / 100 + 0x30; c_AT_NMGS[len++] = (Nbiot_Send_Data.len % 100) / 10 + 0x30; c_AT_NMGS[len++] = (Nbiot_Send_Data.len % 10) + 0x30; c_AT_NMGS[len++] = ','; //内容 for (i = 0; i < Nbiot_Send_Data.len; i++)//获取发送数据内容 { if ((*(Nbiot_Send_Data.buf + i) >> 4) >= 0x0A) { c_AT_NMGS[len++] = (*(Nbiot_Send_Data.buf + i) >> 4) + 0x37; } else { c_AT_NMGS[len++] = (*(Nbiot_Send_Data.buf + i) >> 4) + 0x30; } if ((*(Nbiot_Send_Data.buf + i) & 0x0F) >= 0x0A) { c_AT_NMGS[len++] = (*(Nbiot_Send_Data.buf + i) & 0x0F) + 0x37; } else { c_AT_NMGS[len++] = (*(Nbiot_Send_Data.buf + i) & 0x0F) + 0x30; } } if((Sys_data_object.P1.func_cfg_bytes[12]&0x80)&&(Sys_data_object.P1.func_cfg_bytes[12]&0x03)) //PSM模式上报判断 { c_AT_NMGS[len++] = ','; c_AT_NMGS[len++] = '1'; c_AT_NMGS[len++] = '0'; c_AT_NMGS[len++] = '1';//c_AT_NMGS[len++] = '2'; c_AT_NMGS[len++] = '\r'; NbiotUartSend((u8*) c_AT_NMGS, len, cst_AT_No_AT_NMGS_ACKID); } else { if((Sys_data_object.P1.func_cfg_bytes[10] == 0x55)||(Sys_data_object.P3.ProductUploadFlag == 0x55))//ACK判上报成功 { c_AT_NMGS[len++] = ','; c_AT_NMGS[len++] = '1'; c_AT_NMGS[len++] = '0'; c_AT_NMGS[len++] = '0'; c_AT_NMGS[len++] = '\r'; NbiotUartSend((u8*) c_AT_NMGS, len, cst_AT_No_AT_NMGS_ACKID); } else { c_AT_NMGS[len++] = '\r'; NbiotUartSend((u8*) c_AT_NMGS, len, cst_AT_No_AT_NMGS); } } set_timer_1s(4); s_coap_send_state = S_SEND_DATA_R; } } break; case S_SEND_DATA_R: { if (NbiotCheckAtAck() == UART_OK) //返回正确的应答 { s_at_error_count = 0; g_s_nbiot_task_flag = TASK_SUCCESS; *Nbiot_Send_Data.state = NBIOT_SUCCESS; s_coap_send_state = S_SEND_START; } else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1s())) { s_at_error_count++; if (s_at_error_count >= 1) { s_at_error_count = 0; *Nbiot_Send_Data.state = NBIOT_ERROR; g_s_nbiot_task_flag = TASK_FAIL; s_coap_send_state = S_SEND_START; } else { s_coap_send_state = S_SEND_DATA_R; } } } break; default: { s_coap_send_state = S_SEND_START; } break; } } void CoapSendDataMachine(void) { CoapSendDataMachine_BC25(); } //启动连接UDP void UdpStartConnect(u8 udp_num) { nbiot_temp_connect_type = udp_num; s_udp_connect_state = S_UDP_CONNECT_START; } /*************************************************************************** * @fun_name void UdpConnectMachine(void) * @brief 连接UDP状态机 ***************************************************************************/ u8 temp_udp_socket1 = '0'; u8 temp_udp_socket2 = '1'; static void UdpConnectMachine_BC28(void) { static u8 s_at_error_count = 0; static u8 c_AT_NSOCR[]="AT+NSOCR=DGRAM,17,12345"; const char* c_AT_NSONMI="AT+NSONMI=3\r"; switch (s_udp_connect_state) { case S_UDP_CONNECT_IDLE: { break; } case S_UDP_CONNECT_START: { s_at_error_count = 0; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); s_udp_connect_state = S_UDP_CONNECT_NSONMI; } break; case S_UDP_CONNECT_NSONMI: { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_NSONMI, strlen(c_AT_NSONMI), cst_AT_No_AT_NSONMI);//设置是否显示可选长度参数 s_udp_connect_state = S_UDP_CONNECT_NSONMI_R; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } break; case S_UDP_CONNECT_NSONMI_R: { if (NbiotCheckAtAck() == UART_OK)//应答正确-下一步 { s_at_error_count = 0; s_udp_connect_state = S_UDP_CONNECT_NSOCR; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR)) { if (++s_at_error_count >= NUM_AT_NSONMI_ERROR) { s_at_error_count = 0; s_udp_connect_state = S_UDP_CONNECT_NSOCR; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_udp_connect_state = S_UDP_CONNECT_NSONMI; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_UDP_CONNECT_NSOCR: { u16 len = 18; //整条AT指令的长度，根据发送长度的位数来定 if (!check_timer_1ms()) { //local端口号 c_AT_NSOCR[len++] = '1'; c_AT_NSOCR[len++] = '2'; c_AT_NSOCR[len++] = '3'; c_AT_NSOCR[len++] = '4'; if(nbiot_temp_connect_type == NBIOT_CONNECT_UDP1) { c_AT_NSOCR[len++] = '1'; } else if(nbiot_temp_connect_type == NBIOT_CONNECT_UDP2) { c_AT_NSOCR[len++] = '2'; } c_AT_NSOCR[len++] = '\r'; NbiotUartSend((u8*) c_AT_NSOCR, len, cst_AT_No_AT_NSOCR); set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); s_udp_connect_state = S_UDP_CONNECT_NSOCR_R; } } break; case S_UDP_CONNECT_NSOCR_R: { if (NbiotCheckAtAck() == UART_OK) { if(nbiot_temp_connect_type == NBIOT_CONNECT_UDP1) { temp_udp_socket1 = getTempUdpCode(); } else if(nbiot_temp_connect_type == NBIOT_CONNECT_UDP2) { temp_udp_socket2 = getTempUdpCode(); } s_udp_connect_state = S_UDP_CONNECT_IDLE; g_s_nbiot_task_flag = TASK_SUCCESS; } else if (!check_timer_1ms() || NbiotCheckAtAck() == UART_ERROR) { s_udp_connect_state = S_UDP_CONNECT_IDLE; g_s_nbiot_task_flag = TASK_FAIL; } } break; default: { g_s_nbiot_task_flag = TASK_FAIL; s_udp_connect_state = S_UDP_CONNECT_IDLE; break; } } } void UdpConnectMachine(void) { UdpConnectMachine_BC28(); } // void StartUdpSendData(void) { s_udp_send_state = S_UDP_SEND_START; } // //AT+NSOST=1,118.123.19.67,40001,13,30313233343536373839415344 static void UdpSendDataMachine_BC28(void) { unsigned char *nbiot_ip; u16 nbiot_port; u16 len = 0;//9; //整条AT指令的长度，根据发送长度的位数来定 int i; switch (s_udp_send_state) { case S_UDP_SEND_IDLE: { } break; case S_UDP_SEND_START: { set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); s_udp_send_state = S_UDP_SEND_NSOFT; } break; case S_UDP_SEND_NSOFT: { if (!check_timer_1ms()) { //内容 if(nbiot_temp_connect_type == NBIOT_CONNECT_UDP1) { nbiot_port = udp_port1; nbiot_ip = udp_ip1; } else if(nbiot_temp_connect_type == NBIOT_CONNECT_UDP2) { nbiot_port = udp_port2; nbiot_ip = udp_ip2; } len = 0; c_AT_NMGS[len++] = 'A'; c_AT_NMGS[len++] = 'T'; c_AT_NMGS[len++] = '+'; c_AT_NMGS[len++] = 'N'; c_AT_NMGS[len++] = 'S'; c_AT_NMGS[len++] = 'O'; c_AT_NMGS[len++] = 'S'; c_AT_NMGS[len++] = 'T'; c_AT_NMGS[len++] = '='; if(g_s_nbiot_send_type == SEND_TYPE_UDP1) { c_AT_NMGS[len++] = temp_udp_socket1;//socket范围为0~6 } else if(g_s_nbiot_send_type == SEND_TYPE_UDP2) { c_AT_NMGS[len++] = temp_udp_socket2;//socket范围为0~6 } c_AT_NMGS[len++] = ','; //IP for (i = 0; i < 4; i++) { if (nbiot_ip[i] < 10) { c_AT_NMGS[len++] = nbiot_ip[i] + 0x30; } else if (nbiot_ip[i] < 100) { c_AT_NMGS[len++] = (nbiot_ip[i] / 10) + 0x30; c_AT_NMGS[len++] = (nbiot_ip[i] % 10) + 0x30; } else { c_AT_NMGS[len++] = (nbiot_ip[i] / 100) + 0x30; c_AT_NMGS[len++] = (nbiot_ip[i] / 10) % 10 + 0x30; c_AT_NMGS[len++] = (nbiot_ip[i] % 10) + 0x30; } c_AT_NMGS[len++] = '.'; } //端口号 len--; //消除多余的点号 c_AT_NMGS[len++] = ','; c_AT_NMGS[len++] = (nbiot_port / 10000) + 0x30; c_AT_NMGS[len++] = (nbiot_port % 10000) / 1000 + 0x30; c_AT_NMGS[len++] = (nbiot_port % 1000) / 100 + 0x30; c_AT_NMGS[len++] = (nbiot_port % 100) / 10 + 0x30; c_AT_NMGS[len++] = (nbiot_port % 10) + 0x30; c_AT_NMGS[len++] = ','; //长度 c_AT_NMGS[len++] = (Nbiot_Send_Data.len / 10000) + 0x30; c_AT_NMGS[len++] = (Nbiot_Send_Data.len % 10000) / 1000 + 0x30; c_AT_NMGS[len++] = (Nbiot_Send_Data.len % 1000) / 100 + 0x30; c_AT_NMGS[len++] = (Nbiot_Send_Data.len % 100) / 10 + 0x30; c_AT_NMGS[len++] = (Nbiot_Send_Data.len % 10) + 0x30; c_AT_NMGS[len++] = ','; //内容 for (i = 0; i < Nbiot_Send_Data.len; i++) { if ((*(Nbiot_Send_Data.buf + i) >> 4) >= 0x0A) { c_AT_NMGS[len++] = (*(Nbiot_Send_Data.buf + i) >> 4) + 0x37; } else { c_AT_NMGS[len++] = (*(Nbiot_Send_Data.buf + i) >> 4) + 0x30; } if ((*(Nbiot_Send_Data.buf + i) & 0x0F) >= 0x0A) { c_AT_NMGS[len++] = (*(Nbiot_Send_Data.buf + i) & 0x0F) + 0x37; } else { c_AT_NMGS[len++] = (*(Nbiot_Send_Data.buf + i) & 0x0F) + 0x30; } } c_AT_NMGS[len++] = '\r'; NbiotUartSend((u8*) c_AT_NMGS, len, cst_AT_No_AT_NMGS); set_timer_1s(4); s_udp_send_state = S_UDP_SEND_NSOFT_R; } } break; case S_UDP_SEND_NSOFT_R: { if(NbiotCheckAtAck() == UART_OK) { *Nbiot_Send_Data.state = NBIOT_SUCCESS; g_s_nbiot_task_flag = TASK_SUCCESS; s_udp_send_state = S_UDP_SEND_IDLE; } else if(!check_timer_1s() || NbiotCheckAtAck() == UART_ERROR) { *Nbiot_Send_Data.state = NBIOT_ERROR; g_s_nbiot_task_flag = TASK_FAIL; s_udp_send_state = S_UDP_SEND_IDLE; } } break; default: break; } } void UdpSendDataMachine(void) { UdpSendDataMachine_BC28(); } void UdpReadDataMachine_BC25(void) { static u8 s_error_count; //AT指令累计发送失败次数 static u8 s_read_upd_data_state = S_START; static const char* c_AT_QIRD1 = "AT+NSORF=0,512\r"; static const char* c_AT_QIRD2 = "AT+NSORF=1,512\r"; switch (s_read_upd_data_state) { case S_START: { set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME*2); s_error_count = 0; s_read_upd_data_state = S_AT_QIRD; } break; case S_AT_QIRD: { if (!check_timer_1ms()) { if(GetRcvDataType() == NB_RCV_UDP1_DATA) { NbiotUartSend((u8*) c_AT_QIRD1, strlen((const char*) c_AT_QIRD1), cst_AT_No_AT_UPD_READ); } else if(GetRcvDataType() == NB_RCV_UDP2_DATA) { NbiotUartSend((u8*) c_AT_QIRD2, strlen((const char*) c_AT_QIRD2), cst_AT_No_AT_UPD_READ); } set_timer_1ms(5*AT_COMMAND_RECEIVE_WAIT_TIME); s_read_upd_data_state = S_AT_QIRD_R; } } break; case S_AT_QIRD_R: { if (NbiotCheckAtAck() == UART_OK) { //返回正确的应答 *Nbiot_Send_Data.state = QIRD_SUCCESS; g_s_nbiot_task_flag = TASK_SUCCESS; s_read_upd_data_state = S_START; } else if (!check_timer_1ms()) { //返回错误的应答或者定时时间到 s_error_count++; if (s_error_count >= 3) { s_error_count = 0; *Nbiot_Send_Data.state = QIRD_ERROR; g_s_nbiot_task_flag = TASK_FAIL; s_read_upd_data_state = S_START; } else { set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME*5); s_read_upd_data_state = S_AT_QIRD; } } } break; default: { s_read_upd_data_state = S_START; } break; } } void UdpReadDataMachine(void) { UdpReadDataMachine_BC25(); } // //OnenetConnectMachine u8 s_onenet_connect_state=0; void OneNetStartConnect(void) { s_onenet_connect_state = S_ONENET_CONNECT_START; } /*************************************************************************** * @fun_name static void CoapConnectMachine() * @brief 连接Coap状态机 ***************************************************************************/ void OnenetConnectMachine(void) { static u8 s_at_error_count = 0; unsigned char *nbiot_ip; u16 nbiot_port; static char c_AT_MIPLCONFIG[40]="AT+MIPLCONFIG=0,183.230.040.040,05683\r"; static const char* c_AT_MIPLCONFIG_CK="AT+MIPLCONFIG?\r";//+MIPLCONFIG: 0,183.230.40.40,5683 +MIPLCONFIG: 2,2 +MIPLCONFIG: 3,1 +MIPLCONFIG: 4,0,1 static const char* c_AT_MIPLCREATE="AT+MIPLCREATE\r"; static const char* c_AT_MIPLADDOBJ = "AT+MIPLADDOBJ=0,3200,1,\"1\",4,2\r"; static const char* c_AT_MIPLOPEN ="AT+MIPLOPEN=0,600,60\r"; static const char* c_AT_MIPLOPENPSM ="AT+MIPLOPEN=0,172800,60\r"; static char c_AT_MIPLDISCOVERRSP[30];// AT+MIPLDISCOVERRSP=0,48839,1,4,"5750" switch (s_onenet_connect_state) { case S_ONENET_CONNECT_IDLE: { break; } case S_ONENET_CONNECT_START: //任务开始 { s_at_error_count=0; s_onenet_connect_state = S_ONENET_MIPLCONFIG; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } break; case S_ONENET_MIPLCONFIG: { if (!check_timer_1ms()) { u16 len = 16; //整条AT指令的长度，根据发送长度的位数来定 nbiot_port = Sys_data_object.P1.server_port.datas; nbiot_ip = Sys_data_object.P1.server_ip; //IP 的存储仍然使用水表原来格式，不保存“.”号，使用时加入 int i; for (i = 0; i < 4; i++) { if (nbiot_ip[i] < 10) { c_AT_MIPLCONFIG[len++] = nbiot_ip[i] + 0x30; } else if (nbiot_ip[i] < 100) { c_AT_MIPLCONFIG[len++] = (nbiot_ip[i] / 10) + 0x30; c_AT_MIPLCONFIG[len++] = (nbiot_ip[i] % 10) + 0x30; } else { c_AT_MIPLCONFIG[len++] = (nbiot_ip[i] / 100) + 0x30; c_AT_MIPLCONFIG[len++] = (nbiot_ip[i] / 10) % 10 + 0x30; c_AT_MIPLCONFIG[len++] = (nbiot_ip[i] % 10) + 0x30; } c_AT_MIPLCONFIG[len++] = '.'; } len--; //消除多余的点号 c_AT_MIPLCONFIG[len++] = ','; //c_AT_MIPLCONFIG[len++] = ((nbiot_port) / 10000) + 0x30; c_AT_MIPLCONFIG[len++] = (((nbiot_port) % 10000) / 1000) + 0x30; c_AT_MIPLCONFIG[len++] = (((nbiot_port) % 1000) / 100) + 0x30; c_AT_MIPLCONFIG[len++] = (((nbiot_port) % 100) / 10) + 0x30; c_AT_MIPLCONFIG[len++] = ((nbiot_port) % 10) + 0x30; c_AT_MIPLCONFIG[len++] = '\r'; NbiotUartSend((u8*)c_AT_MIPLCONFIG, len, cst_AT_No_AT_MIPLCONFIG); set_timer_1s(5); s_onenet_connect_state = S_ONENET_MIPLCONFIG_R; } } break; case S_ONENET_MIPLCONFIG_R: { if (NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; s_onenet_connect_state = S_ONENET_MIPLCONFIG_CK; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if (!check_timer_1s() || NbiotCheckAtAck() == UART_ERROR) { s_at_error_count++; if (s_at_error_count >= NUM_AT_MIPLCONF_ERROR)// { //一般不会发生,肯定能查到返回结果 s_at_error_count = 0; s_onenet_connect_state = S_ONENET_MIPLCONFIG_CK; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_onenet_connect_state = S_ONENET_MIPLCONFIG; } } } break; case S_ONENET_MIPLCONFIG_CK: { if (!check_timer_1ms()) { if(TASK_IDLE == UartIfIdle(NB_UART_COM)) { NbiotUartSend((u8*)c_AT_MIPLCONFIG_CK, strlen(c_AT_MIPLCONFIG_CK), cst_AT_No_AT_MIPLCONFIG_CK); s_onenet_connect_state = S_ONENET_MIPLCONFIG_CK_R; set_timer_1s(2); } } } break; case S_ONENET_MIPLCONFIG_CK_R: { if (NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; s_onenet_connect_state = S_ONENET_MIPLCREATE; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if (!check_timer_1s()) { s_at_error_count++; if (s_at_error_count >= NUM_AT_MIPLCONF_ERROR)// { //一般不会发生,肯定能查到返回结果 s_at_error_count = 0; s_onenet_connect_state = S_ONENET_MIPLCREATE; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_onenet_connect_state = S_ONENET_MIPLCONFIG_CK; } } } break; case S_ONENET_MIPLCREATE: { if(!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_MIPLCREATE, strlen(c_AT_MIPLCREATE), cst_AT_No_AT_MIPLCREATE); set_timer_1s(2); s_onenet_connect_state = S_ONENET_MIPLCREATE_R; } } break; case S_ONENET_MIPLCREATE_R: { if(NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; s_onenet_connect_state = S_ONENET_MIPLADDOBJ; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if(!check_timer_1s()) { s_at_error_count++; if (s_at_error_count >= NUM_AT_MIPLCREATE_ERROR) { s_at_error_count = 0; s_onenet_connect_state = S_ONENET_MIPLADDOBJ; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_onenet_connect_state = S_ONENET_MIPLCREATE; set_timer_1s(2); } } } break; case S_ONENET_MIPLADDOBJ: { if(!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_MIPLADDOBJ, strlen(c_AT_MIPLADDOBJ), cst_AT_No_AT_MIPLADDOBJ); set_timer_1s(2); s_onenet_connect_state = S_ONENET_MIPLADDOBJ_R; } } break; case S_ONENET_MIPLADDOBJ_R: { if(NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; s_onenet_connect_state = S_ONENET_MIPLOPEN; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if((!check_timer_1s())) { s_at_error_count++; if (s_at_error_count >= NUM_AT_MIPLADDOBJ_ERROR) { s_at_error_count = 0; s_onenet_connect_state = S_ONENET_MIPLOPEN; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_onenet_connect_state = S_ONENET_MIPLADDOBJ; } } } break; case S_ONENET_MIPLOPEN: { if(!check_timer_1ms()) { if((Sys_data_object.P1.func_cfg_bytes[12]&0x80)&&(Sys_data_object.P1.func_cfg_bytes[12]&0x03)) //PSM模式上报判断 { NbiotUartSend((u8*) c_AT_MIPLOPENPSM, strlen(c_AT_MIPLOPENPSM), cst_AT_No_AT_MIPLOPEN); } else { NbiotUartSend((u8*) c_AT_MIPLOPEN, strlen(c_AT_MIPLOPEN), cst_AT_No_AT_MIPLOPEN); } set_timer_1s(10); s_onenet_connect_state = S_ONENET_MIPLOPEN_R; } } break; case S_ONENET_MIPLOPEN_R: { if(NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; NbiotClearAtAck(); NbiotSetRevMipldiscover(); set_timer_1s(20); s_onenet_connect_state = S_ONENET_MIPLDISCOVER; } else if((!check_timer_1s())) { s_at_error_count++; if (s_at_error_count >= NUM_AT_MIPLOPEN_ERROR) { set_timer_1s(5); s_at_error_count = 0; s_onenet_connect_state = S_ONENET_MIPLDISCOVER; } else { s_onenet_connect_state = S_ONENET_MIPLOPEN; set_timer_1s(1); } } } break; case S_ONENET_MIPLDISCOVER: //static char c_AT_MIPLDISCOVERRSP[30];// AT+MIPLDISCOVERRSP=0,48839,1,4,"5750" { if (NbiotCheckAtAck() == UART_OK) { u8 len; char discover_num[10]; memset(discover_num,0,sizeof(discover_num)); memset(c_AT_MIPLDISCOVERRSP,0,sizeof(c_AT_MIPLDISCOVERRSP)); strcpy(c_AT_MIPLDISCOVERRSP,"AT+MIPLDISCOVERRSP=0,"); NbiotGetDiscover_num(discover_num); strcat(c_AT_MIPLDISCOVERRSP,discover_num); strcat(c_AT_MIPLDISCOVERRSP,",1,4,\"5750\"\r"); len = strlen(c_AT_MIPLDISCOVERRSP); NbiotUartSend((u8*)c_AT_MIPLDISCOVERRSP, len, cst_AT_No_AT); set_timer_1s(5); s_onenet_connect_state = S_ONENET_MIPLDISCOVER_R; } else if(!check_timer_1s()) { s_at_error_count = 0; *Nbiot_Send_Data.state = NBIOT_ERROR; g_s_nbiot_task_flag = TASK_FAIL; //到此为止任务成功 s_onenet_connect_state = S_ONENET_CONNECT_IDLE; } } break; case S_ONENET_MIPLDISCOVER_R://应答接收到数据--等待响应 { if(NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; *Nbiot_Send_Data.state = NBIOT_ONLINE; g_s_nbiot_task_flag = TASK_SUCCESS; //到此为止任务成功 s_onenet_connect_state = S_ONENET_CONNECT_IDLE; } else if((!check_timer_1s())) { s_at_error_count++; if (s_at_error_count >= NUM_AT_MIPLDISCOVERRSP_ERROR) { s_at_error_count = 0; *Nbiot_Send_Data.state = NBIOT_ONLINE; g_s_nbiot_task_flag = TASK_SUCCESS; //到此为止任务成功 s_onenet_connect_state = S_ONENET_CONNECT_IDLE; } else { NbiotClearAtAck(); NbiotSetRevMipldiscover(); s_onenet_connect_state = S_ONENET_MIPLDISCOVER; set_timer_1s(5); } } } break; default: { s_onenet_connect_state = S_ONENET_CONNECT_IDLE; //状态机回归初始状态 } break; } } #if SEND_ACKID_ENABLE u16 Send_AckID=0; #endif //Onnet发送数据状态机 #define S_ONENET_SEND_START 0 #define S_ONENET_SEND_DATA 1 #define S_ONENET_SEND_DATA_R 2 u8 s_onenet_send_state = S_ONENET_SEND_START; void StartOnenetSendData(void) { s_onenet_send_state = S_ONENET_SEND_START; } u8 Send_AckID=0; void OneNetSendDataMachine(void) { // static u8 s_at_error_count=0; //AT指令累计发送失败次数 static const char temp_AT_MIPLDISCOVERRSP[] = "AT+MIPLNOTIFY=0,0,3200,0,5750,1,"; //static char c_AT_MIPLNOTIFY[50+SEND_DATA_LENGTH];//内存不足，使用公用发送缓存 c_AT_NMGS switch (s_onenet_send_state) { case S_ONENET_SEND_START: { s_onenet_send_state = S_ONENET_SEND_DATA; //收到数据立即进行数据发送，模块会报ERROR，因此延时1S，消除此ERROR set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } break; case S_ONENET_SEND_DATA://发送数据 { if (!check_timer_1ms()) { if(TASK_IDLE == UartIfIdle(NB_UART_COM)) { //u16 len = 31; //整条AT指令的长度，根据发送长度的位数来定 u16 len,i,len_Gprs_Send_Data; char len_buffer[6]={0}; c_AT_NMGS[0]=0;//强制归零 strcat(c_AT_NMGS,temp_AT_MIPLDISCOVERRSP); len_Gprs_Send_Data=2*Nbiot_Send_Data.len; sprintf(len_buffer,"%u",len_Gprs_Send_Data); strcat(c_AT_NMGS,len_buffer); strcat(c_AT_NMGS,",\""); len=strlen(c_AT_NMGS); for (i = 0; i < Nbiot_Send_Data.len; i++)//获取发送数据内容 { if ((*(Nbiot_Send_Data.buf + i) >> 4) >= 0x0A) { c_AT_NMGS[len++] = (*(Nbiot_Send_Data.buf + i) >> 4) + 0x37;//字符转换 } else { c_AT_NMGS[len++] = (*(Nbiot_Send_Data.buf + i) >> 4) + 0x30;//数字转换 } if ((*(Nbiot_Send_Data.buf + i) & 0x0F) >= 0x0A) { c_AT_NMGS[len++] = (*(Nbiot_Send_Data.buf + i) & 0x0F) + 0x37; } else { c_AT_NMGS[len++] = (*(Nbiot_Send_Data.buf + i) & 0x0F) + 0x30; } } c_AT_NMGS[len++] = 0;//手动加字符串结束符防止意外溢出 strcat(c_AT_NMGS,"\",0,0"); if((Sys_data_object.P1.func_cfg_bytes[10] == 0x55)||(Sys_data_object.P3.ProductUploadFlag == 0x55))//ACK判上报成功 { char strtemp[8]; if(++Send_AckID==0) { Send_AckID=1; } sprintf(strtemp,",%u",Send_AckID); strcat(c_AT_NMGS,strtemp); strcat(c_AT_NMGS,"\r"); NbiotClearMsg(); NbiotUartSend((u8*) c_AT_NMGS,strlen(c_AT_NMGS), cst_AT_No_AT_MIPLNOTIFY_ACKID); } else { strcat(c_AT_NMGS,"\r"); NbiotClearMsg(); NbiotUartSend((u8*) c_AT_NMGS,strlen(c_AT_NMGS), cst_AT_No_AT_MIPLNOTIFY); } s_onenet_send_state = S_ONENET_SEND_DATA_R; set_timer_1ms(5*AT_COMMAND_RECEIVE_WAIT_TIME); //发送数据延时较长5倍时间等待 } } } break; case S_ONENET_SEND_DATA_R: { if (NbiotCheckAtAck() == UART_OK) //返回正确的应答 { g_s_nbiot_task_flag = TASK_SUCCESS; *Nbiot_Send_Data.state = NBIOT_SUCCESS; s_onenet_send_state = S_ONENET_SEND_START; } else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1ms()))//返回错误的应答或者定时时间到 { *Nbiot_Send_Data.state = NBIOT_ERROR; g_s_nbiot_task_flag = TASK_FAIL; s_onenet_send_state = S_ONENET_SEND_START; } } break; default: break; } } /*************************************************************************** * @fun_name static void NbiotPowerOffMachine() * @brief 关机状态机 ***************************************************************************/ void NbiotPowerOffMachine(void) //先注销网络然后断电关机 { //关机流程 static u8 s_at_error_count = 0; static const char* c_AT_MIPLCLOSE = "AT+MIPLCLOSE=0\r"; //登录注销流程 static const char* c_AT_MIPLDELOBJ = "AT+MIPLDELOBJ=0,3200\r"; //模组侧订阅资源列表释放 static const char* c_AT_MIPLDEL = "AT+MIPLDELETE=0\r"; //模组侧通信实例删除 static const char* c_AT_CFUN0 = "AT+CFUN=0\r"; //设置最小功能模式 static const char* c_AT_NCSEARFCN = "AT+NCSEARFCN\r"; //清除已保存频点 static const char* c_AT_CFUN1 = "AT+CFUN=1\r"; //设置正常功能模式 //static const char* c_AT_NETCLOSE = "AT+NCDPCLOSE\r"; static const char* c_AT_COPS = "AT+COPS=2\r"; //从注册网络注销 static const u8 c_AT_QPOWD[] = "AT+QPOWD=1\r";//模组正常关机 switch (s_power_off_state) { case S_POWER_OFF_START: { s_at_error_count = 0; if (Nbiot_Para.net_state == NB_ON_LINE) { Nbiot_Para.net_state = NB_OFF_LINE; Nbiot_Para.coap_state = CONNECT_OFF_LINE; Nbiot_Para.udp1_state = CONNECT_OFF_LINE; Nbiot_Para.udp2_state = CONNECT_OFF_LINE; if(Nbiot_Para.Telecom == SIM_CARD_MOBILE) { s_power_off_state = S_AT_QPOWD; } else { s_power_off_state = S_AT_NETCLOSE; } set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_power_off_state = S_AT_CFUN0; } } break; case S_AT_MIPLCLOSE://登录注销流程 //注销指令改为5s,重试2次 { if(!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_MIPLCLOSE, strlen(c_AT_MIPLCLOSE), cst_AT_No_AT_MIPLCLOSE); s_power_off_state = S_AT_MIPLCLOSE_R; set_timer_1ms(5*AT_COMMAND_RECEIVE_WAIT_TIME); } } break; case S_AT_MIPLCLOSE_R: { if (NbiotCheckAtAck() == UART_OK) { //返回正确的应答 s_at_error_count = 0; s_power_off_state = S_AT_MIPLDELOBJ; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); } else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1ms())) { //返回错误的应答或者定时时间到 if (++s_at_error_count >= NUM_AT_MIPLCLOSE_ERROR) { s_at_error_count = 0; *Nbiot_Send_Data.state = cst_AT_No_AT_MIPLCLOSE; s_power_off_state = S_AT_MIPLDELOBJ; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_power_off_state = S_AT_MIPLCLOSE; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_AT_MIPLDELOBJ://模组侧订阅资源列表释放 { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_MIPLDELOBJ, strlen(c_AT_MIPLDELOBJ), cst_AT_No_AT_MIPLDELOBJ); s_power_off_state = S_AT_MIPLDELOBJ_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); } } break; case S_AT_MIPLDELOBJ_R: { if (NbiotCheckAtAck() == UART_OK) { //返回正确的应答 s_at_error_count = 0; s_power_off_state = S_AT_MIPLDEL; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1ms())) { //返回错误的应答或者定时时间到 if (++s_at_error_count >= NUM_AT_MIPLDEL_ERROR) { s_at_error_count = 0; *Nbiot_Send_Data.state = cst_AT_No_AT_MIPLDELOBJ; s_power_off_state = S_AT_MIPLDEL; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } else { s_power_off_state = S_AT_MIPLDELOBJ; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_AT_MIPLDEL://模组侧订阅资源列表释放 { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_MIPLDEL, strlen(c_AT_MIPLDEL), cst_AT_No_AT_MIPLDEL); s_power_off_state = S_AT_MIPLDEL_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); } } break; case S_AT_MIPLDEL_R: { if (NbiotCheckAtAck() == UART_OK) { //返回正确的应答 s_at_error_count = 0; s_power_off_state = S_AT_NETCLOSE; } else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1ms())) { //返回错误的应答或者定时时间到 if (++s_at_error_count >= NUM_AT_MIPLDEL_ERROR) { s_at_error_count = 0; *Nbiot_Send_Data.state = cst_AT_No_AT_MIPLDEL; s_power_off_state = S_AT_NETCLOSE; } else { s_power_off_state = S_AT_MIPLDEL; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; case S_AT_NETCLOSE: { if(Nbiot_Para.Telecom == SIM_CARD_MOBILE) { s_power_off_state = S_AT_QPOWD; } else { NbiotUartSend((u8*) c_AT_COPS, strlen(c_AT_COPS), cst_AT_No_AT_COPS); set_timer_1s(3); s_power_off_state = S_AT_NETCLOSE_R; } } break; case S_AT_NETCLOSE_R: { if (NbiotCheckAtAck() == UART_OK) { //返回正确的应答 s_at_error_count = 0; set_timer_1s(1); s_power_off_state = S_AT_QPOWD; } else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1s())) { //返回错误的应答或者定时时间到 s_at_error_count++; if (s_at_error_count >= 2) //两次不成功直接关机 { s_at_error_count = 0; s_power_off_state = S_AT_QPOWD; //关机命令 } else { s_power_off_state = S_AT_NETCLOSE; } } } break; case S_AT_QPOWD: { if (!check_timer_1s()) { NbiotUartSend((u8*) c_AT_QPOWD, strlen((const char*) c_AT_QPOWD), cst_AT_No_AT_QPOWD); set_timer_1s(3); s_power_off_state = S_AT_QPOWD_R; } } break; case S_AT_QPOWD_R: { if (NbiotCheckAtAck() == UART_OK) { //返回正确的应答 s_at_error_count = 0; set_timer_1s(1); s_power_off_state = S_POWER_OFF; } else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1s())) { //返回错误的应答或者定时时间到 s_at_error_count++; if (s_at_error_count >= 2) //两次不成功直接关机 { s_at_error_count = 0; s_power_off_state = S_POWER_OFF; //直接去关机 } else { s_power_off_state = S_AT_QPOWD; } } } break; case S_AT_CFUN0://设置模组最小功能模式 { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_CFUN0, strlen((const char*) c_AT_CFUN0), cst_AT_No_AT_CFUN); s_power_off_state = S_AT_CFUN0_R; set_timer_1ms(2 * AT_COMMAND_RECEIVE_WAIT_TIME); } } break; case S_AT_CFUN0_R: { if (NbiotCheckAtAck() == UART_OK) { //返回正确的应答 s_at_error_count = 0; set_timer_1ms( AT_COMMAND_SEND_INTERVAL_TIME); s_power_off_state = S_AT_NCSEARFCN; } else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1ms())) { //返回错误的应答或者定时时间到 if (++s_at_error_count >= NUM_AT_CFUN_ERROR) { s_at_error_count = 0; s_power_off_state = S_AT_NCSEARFCN; } else { s_power_off_state = S_AT_CFUN0; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); } } } break; case S_AT_NCSEARFCN://清除频点 { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_NCSEARFCN, strlen((const char*) c_AT_NCSEARFCN), cst_AT_No_AT_NCSEARFCN); s_power_off_state = S_AT_NCSEARFCN_R; set_timer_1ms(2 * AT_COMMAND_RECEIVE_WAIT_TIME); } } break; case S_AT_NCSEARFCN_R: { if (NbiotCheckAtAck() == UART_OK) { //返回正确的应答 s_at_error_count = 0; set_timer_1ms( AT_COMMAND_SEND_INTERVAL_TIME*6);//清频后延时3秒 s_power_off_state = S_AT_CFUN1; } else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1ms())) { //返回错误的应答或者定时时间到 if (++s_at_error_count >= NUM_AT_NCSEARFCN_ERROR) { s_at_error_count = 0; s_power_off_state = S_AT_CFUN1; } else { s_power_off_state = S_AT_NCSEARFCN; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); } } } break; case S_AT_CFUN1://设置模组正常功能模式 { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_CFUN1, strlen((const char*) c_AT_CFUN1), cst_AT_No_AT_CFUN); s_power_off_state = S_AT_CFUN1_R; set_timer_1ms(2 * AT_COMMAND_RECEIVE_WAIT_TIME); } } break; case S_AT_CFUN1_R: { if (NbiotCheckAtAck() == UART_OK) { //返回正确的应答 s_at_error_count = 0; set_timer_1s(1); s_power_off_state = S_AT_QPOWD; } else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1ms())) { //返回错误的应答或者定时时间到 if (++s_at_error_count >= NUM_AT_CFUN_ERROR) { s_at_error_count = 0; set_timer_1s(1); s_power_off_state = S_AT_QPOWD; } else { s_power_off_state = S_AT_CFUN1; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); } } } break; case S_POWER_OFF: { if (!check_timer_1s()) { NB_Power_Disable(); //切断电源 set_timer_1s(1); s_power_off_state = S_POWER_OFF_WAIT; Nbiot_Para.net_state = NB_OFF_LINE; Nbiot_Para.coap_state = CONNECT_OFF_LINE; Nbiot_Para.udp1_state = CONNECT_OFF_LINE; Nbiot_Para.udp2_state = CONNECT_OFF_LINE; } } break; case S_POWER_OFF_WAIT: { if (!check_timer_1s()) { NbiotPreSleep(); g_s_nbiot_task_flag = TASK_SUCCESS; s_power_off_state = S_START; } } break; default: { s_power_off_state = S_START; } break; } } void NbiotReadECLSNRMachine(void) { static u8 s_error_count; //AT指令累计发送失败次数 static u8 s_ecl_state = S_START; switch (s_ecl_state) { case S_START: { set_timer_1ms(1000); s_error_count = 0; s_ecl_state = S_AT_ECL; } break; case S_AT_ECL: { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_NUESTATS, strlen((const char*) c_AT_NUESTATS), cst_AT_No_AT_NUESTATS); set_timer_1ms(500); s_ecl_state = S_AT_ECL_R; } } break; case S_AT_ECL_R: { if (!check_timer_1ms()) { if (NbiotCheckAtAck() == UART_OK) { //返回正确的应答 *Nbiot_Send_Data.state = ECL_SNR_SUCCESS; g_s_nbiot_task_flag = TASK_SUCCESS; s_ecl_state = S_START; } else { //返回错误的应答或者定时时间到 s_error_count++; if (s_error_count >= 1) { s_error_count = 0; *Nbiot_Send_Data.state = ECL_SNR_ERROR; g_s_nbiot_task_flag = TASK_FAIL; s_ecl_state = S_START; } else { s_ecl_state = S_AT_ECL; } } } } break; default: { s_ecl_state = S_START; } break; } } /*****************************ONENET应答下发指令*********************/ static u8 s_onenet_ack_rev_state = S_ONENET_ACKREV_START; static void StartOnenetAckRev(void) { s_onenet_ack_rev_state = S_ONENET_ACKREV_START; } /******************************************************* NbiotRevAckMachine 对接收到的指令先应答 *******************************************************/ void NbiotRevAckMachine(void) { static u8 s_error_count; //AT指令累计发送失败次数 static char c_AT_MIPLWRITE_EXECUTE[30];// = "AT+MIPLWRITERSP=0,12345,2\r"; //static char c_AT_MIPLEXECUTE[30];// = "AT+MIPLEXECUTERSP=0,12345,2\r"; switch (s_onenet_ack_rev_state) { case S_ONENET_ACKREV_IDLE: { } break; case S_ONENET_ACKREV_START: { set_timer_1ms(1000); s_onenet_ack_rev_state = S_ONENET_REPLY_REV_ACKID; s_error_count = 0; } break; case S_ONENET_REPLY_REV_ACKID://应答接收到数据 { u8 len; char ack_num[10]; if (!check_timer_1ms()) { memset(ack_num,0,sizeof(ack_num)); memset(c_AT_MIPLWRITE_EXECUTE,0,sizeof(c_AT_MIPLWRITE_EXECUTE)); if(ORDER_EXECUTE == NbiotGetOnenetTypeDownOrder()) { strcpy(c_AT_MIPLWRITE_EXECUTE,"AT+MIPLEXECUTERSP=0,"); } else { strcpy(c_AT_MIPLWRITE_EXECUTE,"AT+MIPLWRITERSP=0,"); } NbiotGetWriteAck_num(ack_num); strcat(c_AT_MIPLWRITE_EXECUTE,ack_num); strcat(c_AT_MIPLWRITE_EXECUTE,",2\r"); len = strlen(c_AT_MIPLWRITE_EXECUTE); NbiotUartSend((u8*)c_AT_MIPLWRITE_EXECUTE, len, cst_AT_No_AT_MIPLWRITE); set_timer_1ms(5*AT_COMMAND_RECEIVE_WAIT_TIME); s_onenet_ack_rev_state = S_ONENET_REPLY_REV_ACKID_R; } } break; case S_ONENET_REPLY_REV_ACKID_R://应答接收到数据--等待响应 { if (NbiotCheckAtAck() == UART_OK) { g_s_nbiot_task_flag = TASK_SUCCESS; s_onenet_ack_rev_state = S_ONENET_ACKREV_IDLE; SetUartCommRevFlag(); //应答写命名完成--进行数据处理 } else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1ms()))//返回错误的应答或者定时时间到 { if (++s_error_count >= NUM_AT_MIPLWRITE_ERROR) { *Nbiot_Send_Data.state = cst_AT_No_AT_MIPLWRITE; g_s_nbiot_task_flag = TASK_FAIL; s_onenet_ack_rev_state = S_ONENET_ACKREV_IDLE; } else { s_onenet_ack_rev_state = S_ONENET_REPLY_REV_ACKID; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; default: break; } } /*************************************************************************** * @fun_name void PsmWakupMachine(void) * @brief 唤醒PSM ***************************************************************************/ static void Psm_Wakup_Machine(void) { static const char *c_AT_QSCLK = "AT+QSCLK=0\r"; //临时关闭深度休眠功能，进行NB通信 static const char *c_AT_QPING = "AT+CSCON=1\r";//"AT+NPING=8.8.8.8,1,1\r";//+CSCON: 1 触发模组与基站交互后查询信号值 static const char* c_AT_NCDP_CK = "AT+NMSTATUS?\r"; //查询信号值 static const char* c_AT_UPDATE_LIFETIME = "AT+MIPLUPDATE?\r"; //ONNET更新lifetime static u8 s_at_error_count = 0; switch(s_psm_wakeup_state) { //硬件唤醒:当模块处于PSM模式时,拉低PSM_EINT(下降沿>100ms)可将模块从 PSM 唤醒 case PSM_WKUPSTA_IDLE: { } break; case PSM_WKUPSTA_START: { UartInit(NB_UART_COM, BAUD9600, DATA_BIT_8, STOPBIT_1, UART_NONE_PARITY,UART_LPUART_Disable); NB_PSM_WAKE_HIG(); set_timer_1ms(500); s_psm_wakeup_state= PSM_WKUPSTA_EINT_LOW; } break; case PSM_WKUPSTA_EINT_LOW: { if (!check_timer_1ms()) { NB_PSM_WAKE_LOW(); set_timer_1ms(500); s_psm_wakeup_state= PSM_WKUPSTA_EINT_HIGH; } } break; case PSM_WKUPSTA_EINT_HIGH: { if (!check_timer_1ms()) { NB_PSM_WAKE_HIG(); NbiotUartSend(0, 0, cst_AT_No_AT_NCDP);//查询+QLWEVTIND状态 set_timer_1ms(5000);//5s,超时等待5s,信号差的时候+QLWEVTIND: 6响应也很快,但PING和上报都失败 s_psm_wakeup_state= PSM_WKUPSTA_QLWEVTIND6; } } break; case PSM_WKUPSTA_QLWEVTIND6://检查深度睡眠唤醒连接恢复成功 +QLWEVTIND: 6, { if (NbiotCheckAtAck() == UART_OK) { set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); s_psm_wakeup_state = PSM_WKUPSTA_QSCLK0; } else if (!check_timer_1ms()) { s_psm_wakeup_state = PSM_WKUPSTA_WAKE_FAIL; } } break; //模块进入工作模式 case PSM_WKUPSTA_QSCLK0: { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_QSCLK, strlen(c_AT_QSCLK), cst_AT_QSCLK_CLOSE); s_at_error_count = 0; set_timer_1ms(2000); s_psm_wakeup_state = PSM_WKUPSTA_QSCLK0_R; } } break; case PSM_WKUPSTA_QSCLK0_R: { if (NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; s_psm_wakeup_state = PSM_WKUPSTA_NUESTATS;//PSM_WKUPSTA_NCDP_CK; } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR)) { if (++s_at_error_count >= 3) { s_at_error_count = 0; s_psm_wakeup_state = PSM_WKUPSTA_WAKE_FAIL; } else { s_psm_wakeup_state = PSM_WKUPSTA_QSCLK0; set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME); } } } break; //检查连接服务器是否成功 case PSM_WKUPSTA_NCDP_CK: { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_NCDP_CK, strlen((const char*) c_AT_NCDP_CK), cst_AT_No_AT_NCDP_CK); set_timer_1s(3); s_psm_wakeup_state = PSM_WKUPSTA_NCDP_CK_R; } } break; case PSM_WKUPSTA_NCDP_CK_R://应答的应该是模组保存的状态,跟本次唤醒是否真正成功连到服务无关.+NMSTATUS: REGISTERED_AND_OBSERVED { if (NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; s_psm_wakeup_state = PSM_WKUPSTA_NPING; } else if((!check_timer_1s())) { s_at_error_count++; if (s_at_error_count >=3) { s_at_error_count = 0; s_psm_wakeup_state = PSM_WKUPSTA_WAKE_FAIL; } else { s_psm_wakeup_state = PSM_WKUPSTA_NCDP_CK; } } } break; //PING /*当返回+CSCON:1---标准模组与基站建立链接 后执行AT+QENG=0查询---此时在模组与基站建立链接的状态下查询信号*/ case PSM_WKUPSTA_NPING: { if (!check_timer_1ms()) { NbiotUartSend((u8*) c_AT_QPING, strlen((const char*) c_AT_QPING), cst_AT_No_CSCON1); set_timer_1s(5); s_psm_wakeup_state = PSM_WKUPSTA_NPING_R; } } break; case PSM_WKUPSTA_NPING_R: { if (NbiotCheckAtAck() == UART_OK) { s_at_error_count = 0; s_psm_wakeup_state = PSM_WKUPSTA_NUESTATS; } else if((!check_timer_1s())) { s_psm_wakeup_state = PSM_WKUPSTA_NUESTATS; } } break; //更新信号值 case PSM_WKUPSTA_NUESTATS: { if (!check_timer_1s()) { NbiotUartSend((u8*) c_AT_NUESTATS, strlen(c_AT_NUESTATS), cst_AT_No_AT_NUESTATS); set_timer_1s(2); s_psm_wakeup_state = PSM_WKUPSTA_NUESTATS_R; } } break; case PSM_WKUPSTA_NUESTATS_R: { if (NbiotCheckAtAck() == UART_OK) { s_psm_wakeup_state = PSM_WKUPSTA_UPDATE;//PSM_WKUPSTA_WAKE_SUCCESS; } else if((!check_timer_1s())) { s_psm_wakeup_state = PSM_WKUPSTA_UPDATE;//PSM_WKUPSTA_WAKE_SUCCESS; } } break; //移动更新lifetime case PSM_WKUPSTA_UPDATE://更新lifetime { if (!check_timer_1s()) { NbiotUartSend((u8*) c_AT_UPDATE_LIFETIME, strlen(c_AT_UPDATE_LIFETIME), cst_AT_No_AT); set_timer_1s(10); s_psm_wakeup_state = PSM_WKUPSTA_UPDATE_R; } } break; case PSM_WKUPSTA_UPDATE_R://定制对象--等待应答 { if (NbiotCheckAtAck() == UART_OK) { s_psm_wakeup_state = PSM_WKUPSTA_WAKE_SUCCESS; } else if((!check_timer_1s())) { s_psm_wakeup_state = PSM_WKUPSTA_WAKE_FAIL; } } break; case PSM_WKUPSTA_WAKE_SUCCESS: { psm_model_state = PSM_STATE_WAKE; g_s_nbiot_task_flag = TASK_SUCCESS; //初始化成功 s_psm_wakeup_state = PSM_WKUPSTA_IDLE; } break; case PSM_WKUPSTA_WAKE_FAIL: { NbForcePowerOff(); psm_model_state = PSM_STATE_OUT; g_s_nbiot_task_flag = TASK_FAIL; s_psm_wakeup_state = PSM_WKUPSTA_IDLE; } break; default: { s_psm_wakeup_state = PSM_WKUPSTA_IDLE; } break; } } /*************************************************************************** * @fun_name void Psm_Sleep_Machine(void) * @brief 进入低功耗模式 ***************************************************************************/ static void Psm_Sleep_Machine(void) { static const char* c_AT_CPSMS1 = "AT+CPSMS=1\r"; //开启PSM模式 static const char c_AT_QSCLK1[] = "AT+QSCLK=1\r"; //开启深度休眠功能，进行NB通信 switch(s_psm_sleep_state) { case PSM_SLPSTA_IDLE: { } break; case PSM_SLPSTA_START://设置关闭或打开PSM模式 { NbiotUartSend((u8*) c_AT_CPSMS1, strlen(c_AT_CPSMS1), cst_AT_No_AT_CPSMS);//使用PSM s_init_state = S_TCP_CPSMS_R; set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); s_psm_sleep_state = PSM_SLPSTA_CPSMS1_R; } break; case PSM_SLPSTA_CPSMS1_R: { if (NbiotCheckAtAck() == UART_OK)//应答正确-下一步 { NbiotUartSend((u8*) c_AT_QSCLK1, strlen(c_AT_QSCLK1), cst_AT_No_AT);//cst_AT_QSCLK_OPEN); s_psm_sleep_state = PSM_SLPSTA_WAIT; set_timer_1s(30); //进入休眠模式30s超时等待 } else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR)) { NbForcePowerOff(); psm_model_state = PSM_STATE_OUT; g_s_nbiot_task_flag = TASK_FAIL; s_psm_sleep_state = PSM_SLPSTA_IDLE; } } break; case PSM_SLPSTA_WAIT://等待应答 +QATSLEEP { if (NbiotCheckAtAck() == UART_OK)//应答正确-下一步 { psm_model_state = PSM_STATE_SLEEP; g_s_nbiot_task_flag = TASK_SUCCESS; s_psm_sleep_state = PSM_SLPSTA_IDLE; } else if ((!check_timer_1s()) || (NbiotCheckAtAck() == UART_ERROR)) { NbForcePowerOff(); psm_model_state = PSM_STATE_OUT; g_s_nbiot_task_flag = TASK_FAIL; s_psm_sleep_state = PSM_SLPSTA_IDLE; } } break; case PSM_CHECK_START: { if(TASK_IDLE == AdcIfIdle()) { AdcStartConvert(PSM_CHECK_CHANNEL, PSM_CHECK_NUM, PSM_CHECK_INTERVAL, &s_psm_adc_result, &s_psm_adc_done); s_psm_sleep_state =PSM_CHECK_WAIT; } } break; case PSM_CHECK_WAIT: { if (TRUE == s_psm_adc_done) { if (ADC_OK == AdcGetStatus()) { if(s_psm_adc_result>1500)//大于1V左右 { NbForcePowerOff(); psm_model_state = PSM_STATE_OUT; } g_s_nbiot_task_flag = TASK_SUCCESS; s_psm_sleep_state = PSM_SLPSTA_IDLE; } } } break; default: { NbForcePowerOff(); psm_model_state = PSM_STATE_OUT; g_s_nbiot_task_flag = TASK_SUCCESS; s_psm_sleep_state = PSM_SLPSTA_IDLE; } break; } } /*************************************************************************** * @fun_name 定时器资源 * @brief 该内部接口主要为了方便记忆及使用 ***************************************************************************/ void set_timer_1s(u16 time) { Set100msTimer(TIMER_100MS_NBIOT, time * 10); } u16 check_timer_1s(void) { return Check100msTimer(TIMER_100MS_NBIOT); } void set_timer_1ms(u16 time) { Set5msTimer(TIMER_5MS_NBIOT, time / 5); } u16 check_timer_1ms(void) { return Check5msTimer(TIMER_5MS_NBIOT); } /*************************************************************************** * @fun_name void StartPowerOffTask() * @brief 关机接口 ***************************************************************************/ void StartPowerOffTask(void) { g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_POWER_OFF; s_power_off_state = S_POWER_OFF_START; } //NB强制关机 void NbForcePowerOff(void) { NB_Power_Disable(); Nbiot_Para.net_state = NB_OFF_LINE; Nbiot_Para.coap_state = CONNECT_OFF_LINE; Nbiot_Para.udp1_state = CONNECT_OFF_LINE; Nbiot_Para.udp2_state = CONNECT_OFF_LINE; g_s_nbiot_task_flag = TASK_INIT; g_s_nbiot_main_state = NBIOT_S_IDLE; } void set_clear_ncsearfcn (void) { flag_clear_ncsearfcn =1; } void sys_get_three_code (void) { // NbiotGetIMEI(Sys_data_object.P1.NB_module_IMEI_0016); // NbiotGetIMSI(Sys_data_object.P1.NB_module_IMSI); // NbiotGetICCID(Sys_data_object.P1.SIMCard_ICCID_200A); } UNION_4U8TOU32 net_state_data; u32 sys_get_net_state(void) { s16 s_temp_data=0; if(g_s_nbiot_main_state == NBIOT_POWER_INIT) { net_state_data.data_buf[0] = 1; net_state_data.data_buf[1] = s_init_state; //net_state_buf[2]CEREG //net_state_buf[3]cgatt } else if(g_s_nbiot_main_state == NBIOT_NET_OPEN) { net_state_data.data_buf[0] = 2; if(Nbiot_Para.Telecom == SIM_CARD_TELECOM) { net_state_data.data_buf[1] = s_coap_connect_state; } else { net_state_data.data_buf[1] = s_onenet_connect_state; } } else if(If_NB_Poweron()==FALSE) { net_state_data.data_buf[0] = 3; //rsrp NbiotGetRSRP(&s_temp_data); net_state_data.data_buf[1] = -(s_temp_data/10); //SNR NbiotGetSNR(&s_temp_data); if(s_temp_data<0) { net_state_data.data_buf[2] = (-s_temp_data/10)|0x80; } else { net_state_data.data_buf[2] = s_temp_data/10; } //CSQ NbiotGetCSQ(&net_state_data.data_buf[3]); } return net_state_data.datas; } void sys_set_net_state(u8 state, u8 data) { net_state_data.data_buf[state] = data; } TYP_PSM_STATE getPsmState(void) { return psm_model_state; } u16 get_Send_AckID(void) { return Send_AckID; } #ifdef __cplusplus } #endif #endif