3401 lines
102 KiB
C
3401 lines
102 KiB
C
/************************************************************************************
|
||
* @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_E7025
|
||
|
||
#ifdef __cplusplus
|
||
extern "C"
|
||
{
|
||
#endif
|
||
|
||
#include "nb_uart_driver_e7025.h"
|
||
#include "nb_driver_e7025.h"
|
||
#include "stdio.h"
|
||
#include <time.h>
|
||
#include "UWater_timer1uS_driver.h"
|
||
#include "UWater_uart_driver.h"
|
||
#include "UWater_Rtcc_Driver.h"
|
||
#include "UWater_frame_app.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;
|
||
u8 s_udp_connect_state = S_UDP_CONNECT_START;
|
||
u8 s_coap_send_state = S_SEND_START;
|
||
u8 s_udp_send_state = S_SEND_START;
|
||
u8 s_power_off_state = S_START;
|
||
char c_AT_NMGS[40 + UP_BUF_SIZE*2];//发送数据长度较小
|
||
|
||
//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;
|
||
/*****************************内部功能状态机***********************************/
|
||
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 sys_get_net_state (void);
|
||
void OnenetConnectMachine(void);
|
||
void OneNetSendDataMachine(void);
|
||
void StartOnenetAckRev(void);
|
||
void NbiotRevAckMachine(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 TcpStartConnect(void);
|
||
void TcpConnectMachine(void);
|
||
void TcpSendDataMachine(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:
|
||
{
|
||
if(TRUE == UdpIfNeedReadData())
|
||
{
|
||
ClearUdpReadDataFlag();
|
||
g_s_nbiot_main_state = NBIOT_READ_UDP_DATA;
|
||
}
|
||
if(TRUE == NbiotGetRevAck())//收到ONNET下发的数据,先进入应答流程应答一下
|
||
{
|
||
ClearNbiotGetRevAck();
|
||
StartOnenetAckRev();
|
||
g_s_nbiot_main_state = NBIOT_REV_ACK;
|
||
}
|
||
}
|
||
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
|
||
|
||
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 //任务失败
|
||
{
|
||
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_COAP)
|
||
{
|
||
/*if(Nbiot_Para.Telecom == SIM_CARD_MOBILE)//移动卡
|
||
{
|
||
OnenetConnectMachine();//与ONNET平台建立连接状态机
|
||
}
|
||
else//电信卡
|
||
{
|
||
CoapConnectMachine(); //与主站建立连接状态机
|
||
} */
|
||
TcpConnectMachine(); //与主站建立连接状态机
|
||
}
|
||
else if(nbiot_temp_connect_type == NBIOT_CONNECT_UDP1)
|
||
{
|
||
UdpConnectMachine();
|
||
}
|
||
else if(nbiot_temp_connect_type == NBIOT_CONNECT_UDP2)
|
||
{
|
||
UdpConnectMachine();
|
||
}
|
||
/*else if(nbiot_temp_connect_type == NBIOT_CONNECT_COAP)
|
||
{
|
||
TcpConnectMachine(); //与主站建立连接状态机
|
||
}*/
|
||
else
|
||
{
|
||
g_s_nbiot_task_flag = TASK_INIT;
|
||
g_s_nbiot_main_state = NBIOT_S_IDLE;
|
||
}
|
||
}
|
||
else if (TASK_SUCCESS == g_s_nbiot_task_flag)
|
||
{
|
||
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;
|
||
}
|
||
/*else if (nbiot_temp_connect_type == NBIOT_CONNECT_TCP1)
|
||
{
|
||
Nbiot_Para.tcp1_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(); //数据发送状态机
|
||
}*/
|
||
TcpSendDataMachine(); //数据发送状态机
|
||
}
|
||
else if(g_s_nbiot_send_type == SEND_TYPE_UDP1)
|
||
{
|
||
UdpSendDataMachine(); //数据发送状态机
|
||
}
|
||
else if(g_s_nbiot_send_type == SEND_TYPE_UDP2)
|
||
{
|
||
UdpSendDataMachine(); //数据发送状态机
|
||
}
|
||
/*else if(g_s_nbiot_send_type == SEND_TYPE_TCP1)
|
||
{
|
||
TcpSendDataMachine(); //数据发送状态机
|
||
}*/
|
||
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_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;
|
||
|
||
|
||
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;
|
||
}
|
||
}
|
||
/*else if(connect_type == NBIOT_CONNECT_TCP1)
|
||
{
|
||
if (CONNECT_ON_LINE == Nbiot_Para.tcp1_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)
|
||
{
|
||
//Nbiot_Para.Telecom = SIM_CARD_TELECOM;//debug 强制改为电信平台通信
|
||
|
||
coap_ip = temp_ip;
|
||
coap_port = temp_port;
|
||
/*if(Nbiot_Para.Telecom == SIM_CARD_MOBILE)//移动卡
|
||
{
|
||
OneNetStartConnect();
|
||
}
|
||
else//电信卡
|
||
{
|
||
CoapStartConnect();
|
||
}*/
|
||
TcpStartConnect();
|
||
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);
|
||
}
|
||
/*else if(connect_type == NBIOT_CONNECT_TCP1)
|
||
{
|
||
coap_ip = temp_ip;
|
||
coap_port = temp_port;
|
||
TcpStartConnect();
|
||
}*/
|
||
g_s_nbiot_task_flag = TASK_INIT;
|
||
g_s_nbiot_main_state = NBIOT_NET_OPEN;
|
||
}
|
||
u8 getNB_NetConnectType(void)
|
||
{
|
||
return nbiot_temp_connect_type;
|
||
}
|
||
/***************************************************************************
|
||
* @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 NbiotTcpOpenTask(void)
|
||
{
|
||
if (NBIOT_S_IDLE == g_s_nbiot_main_state)
|
||
{
|
||
if(!TcpIfOnline())
|
||
{
|
||
g_s_nbiot_mode_flag = ONLINE_MODE;
|
||
g_s_nbiot_task_flag = TASK_INIT;
|
||
g_s_nbiot_main_state = NBIOT_TCP_OPEN;
|
||
TcpStartConnect();
|
||
}
|
||
}
|
||
}*/
|
||
void NbiotReadECLSNRTask(u8 *state)
|
||
{
|
||
if (NBIOT_S_IDLE == g_s_nbiot_main_state)
|
||
{
|
||
// g_s_ecl_val = out_ecl;
|
||
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
|
||
***************************************************************************/
|
||
void NbiotPreSleep(void)
|
||
{
|
||
NB_Power_Disable(); //切断电源
|
||
UartPreSleep(NB_UART_COM);
|
||
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;
|
||
//Nbiot_Para.tcp1_state = CONNECT_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);
|
||
}
|
||
|
||
/***************************************************************************
|
||
* @fun_name void NbiotWakeSleep()
|
||
* @brief 休眠后唤醒
|
||
* @param[in] None
|
||
* @param[out] None
|
||
* @retval None
|
||
* @other None
|
||
***************************************************************************/
|
||
void NbiotWakeSleep(void)
|
||
{
|
||
|
||
}
|
||
|
||
/***************************************************************************
|
||
* @fun_name u8 NbiotOfflineReason()
|
||
* @brief 查询NBIOT掉线原因
|
||
* @param[in] None
|
||
* @param[out] None
|
||
* @retval NBIOT参数改变；心跳异常；掉电掉线；主站主动下线；复位下线
|
||
* @other None
|
||
***************************************************************************/
|
||
//u8 NbiotOfflineReason(void)
|
||
//{
|
||
// return Nbiot_Para.offline_reason;
|
||
//}
|
||
|
||
/******************************内部状态机***********************************/
|
||
//
|
||
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
|
||
***************************************************************************/
|
||
#define MODULE_POWER_DELAY_TIME 1000 //mS
|
||
#define MODULE_RESET_DELAY_TIME 1000 //mS
|
||
//AT+QBAND AT+QBAND=1,5 //设置频段为 BAND 5
|
||
//中国移动的为:898600;898602;898604;898607 中国电信898603;898611
|
||
void NbiotInitMachine_E7025(void)
|
||
{
|
||
static u8 s_at_error_count = 0; //记录AT错误或者指令超时次数 超过指定次数后认为任务失败
|
||
|
||
static const char* c_ATE1 = "ATE1\r"; //E7025打开回显
|
||
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+ECICCID\r";//E7025
|
||
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\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_CGATT = "AT+CGATT?\r";
|
||
static const char* c_AT_ECCESQS = "AT+ECCESQS=0\r";//关闭信号更新报告
|
||
static const char* c_AT_ECSTATUS = "AT+ECSTATUS\r";//查询信号等关键参数
|
||
static u8 c_AT_CGDCONT_APN[APN_SIZE+50] = "AT+CGDCONT=1,\"IP\",\""; //指定APN,定义数组大小为固定20字节+APN数组大小，再加预留空间
|
||
static const char* c_AT_CFUN0 = "AT+CFUN=0\r"; //设置最小功能模式
|
||
static const char* c_AT_CFUN1 = "AT+CFUN=1\r"; //设置正常功能模式
|
||
|
||
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_LOW();//模组复位使能
|
||
PWR_NB_HIG();//开机键不使能
|
||
NB_Power_Enable(); //打开电源，延时1S,等待上电稳定
|
||
set_timer_1ms(MODULE_POWER_DELAY_TIME);
|
||
s_init_state = S_INIT_RESET_HIGH;//S_INIT_PWRKEY_LOW;
|
||
}
|
||
break;
|
||
case S_INIT_RESET_HIGH://完成复位NB模块
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
RSTN_NB_HIG(); //高电平
|
||
s_init_state = S_INIT_POWER_ON_WAIT; //到时候查询CSQ和CEREG来确认搜网注册完成 已节约初始化时间 降低功耗
|
||
set_timer_1s(5); //等待NB模块搜网注册5S --5秒时间不够 此时可以继续进行其他任务
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_INIT_POWER_ON_WAIT://等待模块搜网注册延时
|
||
{
|
||
if (!check_timer_1s())
|
||
{
|
||
s_at_error_count = 0; //AT指令错误次数清零
|
||
s_init_state = S_INIT_ATS;
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_INIT_ATS://打开回显, 确认模块正常运行
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
NbiotUartSend((u8*) c_ATE1, strlen(c_ATE1), 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://等待"ATE1"应答
|
||
{
|
||
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(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_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();
|
||
if(0)//if(0 == Sys_data_object.product_test_state)
|
||
{
|
||
//Sys_data_object.product_test_state = 1; //单片机已经获取到三码，等待读取
|
||
s_init_state = S_INIT_POWER_ON;
|
||
g_s_nbiot_task_flag = TASK_INIT;
|
||
StartPowerOffTask(); //调用关机流程
|
||
}
|
||
else
|
||
{
|
||
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);
|
||
}
|
||
}
|
||
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_CFUN0://设置模组最小功能模式
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
NbiotUartSend((u8*) c_AT_CFUN0, strlen((const char*) c_AT_CFUN0), cst_AT_No_AT_CFUN);
|
||
s_init_state = S_INIT_CFUN0_R;
|
||
set_timer_1ms(2 * AT_COMMAND_RECEIVE_WAIT_TIME);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_INIT_CFUN0_R:
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)
|
||
{
|
||
//返回正确的应答
|
||
s_at_error_count = 0;
|
||
set_timer_1ms( AT_COMMAND_SEND_INTERVAL_TIME);
|
||
s_init_state = S_INIT_AT_CGDCONT;
|
||
}
|
||
else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1ms()))
|
||
{
|
||
//返回错误的应答或者定时时间到
|
||
if (++s_at_error_count >= NUM_AT_CFUN_ERROR)
|
||
{
|
||
s_at_error_count = 0;
|
||
s_init_state = S_INIT_AT_CGDCONT;
|
||
}
|
||
else
|
||
{
|
||
s_init_state = S_INIT_CFUN0;
|
||
set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_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_CFUN1://设置模组正常功能模式
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
NbiotUartSend((u8*) c_AT_CFUN1, strlen((const char*) c_AT_CFUN1), cst_AT_No_AT_CFUN);
|
||
s_init_state = S_INIT_CFUN1_R;
|
||
set_timer_1ms(2 * AT_COMMAND_RECEIVE_WAIT_TIME);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_INIT_CFUN1_R:
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)
|
||
{
|
||
//返回正确的应答
|
||
s_at_error_count = 0;
|
||
set_timer_1ms( AT_COMMAND_SEND_INTERVAL_TIME);
|
||
s_init_state = S_INIT_ASK_CSQ;
|
||
}
|
||
else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1ms()))
|
||
{
|
||
//返回错误的应答或者定时时间到
|
||
if (++s_at_error_count >= NUM_AT_CFUN_ERROR)
|
||
{
|
||
s_at_error_count = 0;
|
||
set_timer_1ms( AT_COMMAND_SEND_INTERVAL_TIME);
|
||
s_init_state = S_INIT_ASK_CSQ;
|
||
}
|
||
else
|
||
{
|
||
s_init_state = S_INIT_CFUN1;
|
||
set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME);
|
||
}
|
||
}
|
||
}
|
||
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_AT_ECCESQS;
|
||
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_AT_ECCESQS; //开始查询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_AT_ECCESQS://关闭信号更新报告
|
||
{
|
||
if (!check_timer_1s())
|
||
{
|
||
NbiotUartSend((u8*) c_AT_ECCESQS, strlen(c_AT_ECCESQS), cst_AT_No_AT_ECCESQS);
|
||
set_timer_1s(2);
|
||
s_init_state = S_INIT_AT_ECCESQS_R;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_INIT_AT_ECCESQS_R:
|
||
{
|
||
if (!check_timer_1s())
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)
|
||
{
|
||
//返回正确的应答
|
||
s_at_error_count = 0;
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
s_init_state = S_INIT_AT_ECSTATUS;
|
||
}
|
||
else
|
||
{
|
||
//返回错误的应答或者定时时间到
|
||
s_at_error_count++;
|
||
if (s_at_error_count >= 2)
|
||
{
|
||
s_at_error_count = 0;
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
s_init_state = S_INIT_AT_ECSTATUS;
|
||
}
|
||
else
|
||
{
|
||
s_init_state = S_INIT_AT_ECCESQS;
|
||
set_timer_1s(1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_INIT_AT_ECSTATUS://查询信号等关键参数
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
NbiotUartSend((u8*)c_AT_ECSTATUS, strlen((const char*) c_AT_ECSTATUS), cst_AT_No_AT_ECSTATUS);
|
||
set_timer_1ms(4*AT_COMMAND_SEND_INTERVAL_TIME);//2s
|
||
s_init_state = S_INIT_AT_ECSTATUS_R;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_INIT_AT_ECSTATUS_R:
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)
|
||
{
|
||
s_at_error_count = 0;
|
||
s_init_state = S_INIT_ASK_CEREG;
|
||
}
|
||
else
|
||
{
|
||
//返回错误的应答或者定时时间到
|
||
s_at_error_count++;
|
||
if (s_at_error_count >= 2)
|
||
{
|
||
s_at_error_count = 0;
|
||
s_init_state = S_INIT_ASK_CEREG;
|
||
}
|
||
else
|
||
{
|
||
s_init_state = S_INIT_AT_ECSTATUS;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
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_ASK_CGATT;
|
||
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)
|
||
{
|
||
s_at_error_count = 0;
|
||
s_init_state = S_INIT_ASK_CGATT;
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
}
|
||
else
|
||
{
|
||
s_init_state = S_INIT_ASK_CEREG;
|
||
set_timer_1ms(2 * AT_COMMAND_SEND_INTERVAL_TIME);
|
||
}
|
||
}
|
||
}
|
||
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(AT_COMMAND_RECEIVE_WAIT_TIME*2); //测试报告中AT指令返回的最长时间300ms(不包含发送和接收占用的时间)
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_INIT_ASK_CGATT_R://等待CGATT应答
|
||
{
|
||
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_CGATT_ERROR)
|
||
{
|
||
s_at_error_count = 0;
|
||
*Nbiot_Send_Data.state = NBIOT_ERROR;
|
||
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;
|
||
default:
|
||
{
|
||
s_at_error_count = 0;
|
||
s_init_state = S_INIT_POWER_ON;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
void NbiotInitMachine(void)
|
||
{
|
||
NbiotInitMachine_E7025();
|
||
}
|
||
//
|
||
void CoapStartConnect(void)
|
||
{
|
||
s_coap_connect_state = S_COAP_CONNECT_START;
|
||
}
|
||
/***************************************************************************
|
||
* @fun_name static void CoapConnectMachine()
|
||
* @brief 连接Coap状态机
|
||
***************************************************************************/
|
||
void CoapConnectMachine_E7025(void)
|
||
{
|
||
static u8 s_at_error_count = 0;
|
||
unsigned char *nbiot_ip;
|
||
u16 nbiot_port;
|
||
static char c_AT_CTM2MSETPM[50] = "AT+CTM2MSETPM=\"117.060.157.137\",05683,86400\r"; //配置电信IOT平台连接参数
|
||
static const char* c_AT_CTM2MREG = "AT+CTM2MREG\r"; //注册电信IOT平台
|
||
static const char* c_AT_CCLK = "AT+CCLK?\r"; //查询基站时间
|
||
|
||
switch (s_coap_connect_state)
|
||
{
|
||
case S_COAP_CONNECT_START:
|
||
{
|
||
s_at_error_count=0;
|
||
s_coap_connect_state = S_AT_CTM2MSET;
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
}
|
||
break;
|
||
|
||
case S_AT_CTM2MSET://配置电信IOT平台连接参数
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
u16 len = 15; //整条AT指令的长度，根据发送长度的位数来定
|
||
nbiot_port = coap_port;
|
||
nbiot_ip = coap_ip;
|
||
|
||
//IP 的存储仍然使用水表原来格式，不保存“.”号，使用时加入
|
||
int i;
|
||
for (i = 0; i < 4; i++)
|
||
{
|
||
if (nbiot_ip[i] < 10)
|
||
{
|
||
c_AT_CTM2MSETPM[len++] = nbiot_ip[i] + 0x30;
|
||
}
|
||
else if (nbiot_ip[i] < 100)
|
||
{
|
||
c_AT_CTM2MSETPM[len++] = (nbiot_ip[i] / 10) + 0x30;
|
||
c_AT_CTM2MSETPM[len++] = (nbiot_ip[i] % 10) + 0x30;
|
||
}
|
||
else
|
||
{
|
||
c_AT_CTM2MSETPM[len++] = (nbiot_ip[i] / 100) + 0x30;
|
||
c_AT_CTM2MSETPM[len++] = (nbiot_ip[i] / 10) % 10 + 0x30;
|
||
c_AT_CTM2MSETPM[len++] = (nbiot_ip[i] % 10) + 0x30;
|
||
}
|
||
c_AT_CTM2MSETPM[len++] = '.';
|
||
}
|
||
len--; //消除多余的点号
|
||
|
||
c_AT_CTM2MSETPM[len++] = '\"';
|
||
c_AT_CTM2MSETPM[len++] = ',';
|
||
c_AT_CTM2MSETPM[len++] = ((nbiot_port) / 10000) + 0x30;
|
||
c_AT_CTM2MSETPM[len++] = (((nbiot_port) % 10000) / 1000) + 0x30;
|
||
c_AT_CTM2MSETPM[len++] = (((nbiot_port) % 1000) / 100) + 0x30;
|
||
c_AT_CTM2MSETPM[len++] = (((nbiot_port) % 100) / 10) + 0x30;
|
||
c_AT_CTM2MSETPM[len++] = ((nbiot_port) % 10) + 0x30;
|
||
c_AT_CTM2MSETPM[len++] = ',';
|
||
c_AT_CTM2MSETPM[len++] = '8';
|
||
c_AT_CTM2MSETPM[len++] = '6';
|
||
c_AT_CTM2MSETPM[len++] = '4';
|
||
c_AT_CTM2MSETPM[len++] = '0';
|
||
c_AT_CTM2MSETPM[len++] = '0';
|
||
c_AT_CTM2MSETPM[len++] = '\r';
|
||
NbiotUartSend((u8*)c_AT_CTM2MSETPM, len, cst_AT_No_AT_CTM2MSET);
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
s_coap_connect_state = S_AT_CTM2MSET_R;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_AT_CTM2MSET_R:
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)
|
||
{
|
||
s_at_error_count = 0;
|
||
s_coap_connect_state = S_AT_CTM2MREG;
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
}
|
||
else if (!check_timer_1ms() || NbiotCheckAtAck() == UART_ERROR)
|
||
{
|
||
s_at_error_count++;
|
||
if (s_at_error_count >= NUM_AT_CTM2MSET_ERROR)//
|
||
{
|
||
s_at_error_count = 0;
|
||
s_coap_connect_state = S_AT_CTM2MREG;
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
}
|
||
else
|
||
{
|
||
s_coap_connect_state = S_AT_CTM2MSET;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_AT_CTM2MREG://注册电信IOT平台
|
||
{
|
||
if(!check_timer_1ms())
|
||
{
|
||
NbiotUartSend((u8*) c_AT_CTM2MREG, strlen(c_AT_CTM2MREG), cst_AT_No_AT_CTM2MREG);
|
||
set_timer_1s(8);
|
||
s_coap_connect_state = S_AT_CTM2MREG_R;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_AT_CTM2MREG_R:
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)
|
||
{
|
||
s_at_error_count = 0;
|
||
s_coap_connect_state = S_AT_COAP_CCLK;
|
||
set_timer_1s(1);
|
||
}
|
||
else if (!check_timer_1s() || NbiotCheckAtAck() == UART_ERROR)
|
||
{
|
||
s_at_error_count++;
|
||
if (s_at_error_count >= NUM_AT_CTM2MREG_ERROR)//
|
||
{
|
||
*Nbiot_Send_Data.state = NBIOT_ERROR;
|
||
g_s_nbiot_task_flag = TASK_FAIL; //到此为止任务成功
|
||
s_at_error_count = 0;
|
||
set_timer_1s(1);
|
||
s_coap_connect_state = S_COAP_CONNECT_START; //状态机回归初始状态
|
||
}
|
||
else
|
||
{
|
||
set_timer_1ms(8*AT_COMMAND_SEND_INTERVAL_TIME);
|
||
s_coap_connect_state = S_AT_CTM2MREG;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
|
||
case S_AT_COAP_CCLK://开始查询网络时间
|
||
{
|
||
if (!check_timer_1s())
|
||
{
|
||
NbiotUartSend((u8*) c_AT_CCLK, strlen(c_AT_CCLK), cst_AT_No_AT_CCLK);
|
||
s_coap_connect_state = S_AT_COAP_CCLK_R;
|
||
set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); //测试报告中AT指令返回的最长时间300ms(不包含发送和接收占用的时间)
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_AT_COAP_CCLK_R://等待应答
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)//正确应答
|
||
{
|
||
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_1ms()) || (NbiotCheckAtAck() == UART_ERROR))//应答超时
|
||
{
|
||
if (++s_at_error_count >= NUM_AT_CCLK_ERROR)
|
||
{
|
||
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_CCLK;
|
||
set_timer_1s(1);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
default:
|
||
{
|
||
s_coap_connect_state = S_COAP_CONNECT_START; //状态机回归初始状态
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
void CoapConnectMachine(void)
|
||
{
|
||
CoapConnectMachine_E7025();
|
||
}
|
||
void StartNbiotSendData(void)
|
||
{
|
||
if(g_s_nbiot_send_type == SEND_TYPE_COAP)
|
||
{
|
||
/*if(Nbiot_Para.Telecom == SIM_CARD_MOBILE)//移动卡
|
||
{
|
||
StartOnenetSendData();
|
||
}
|
||
else//电信卡
|
||
{
|
||
StartCoapSendData(); //数据发送状态机
|
||
}*/
|
||
StartTcpSendData();
|
||
}
|
||
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_E7025(void)
|
||
{
|
||
static u8 s_at_error_count = 0; //AT指令累计发送失败次数
|
||
static const u8 temp_AT_Buffer[]= {"AT+CTM2MSEND="};
|
||
switch (s_coap_send_state)
|
||
{
|
||
case S_SEND_START:
|
||
{
|
||
s_coap_send_state = S_SEND_DATA; //收到数据立即进行数据发送，模块会报ERROR，因此延时1S，消除此ERROR
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
}
|
||
break;
|
||
|
||
case S_SEND_DATA:
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
u16 len = 13;//8; //整条AT指令的长度，根据发送长度的位数来定
|
||
int i;
|
||
for(i=0; i<13; i++)
|
||
{
|
||
c_AT_NMGS[i]=temp_AT_Buffer[i];
|
||
}
|
||
//发送内容
|
||
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_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 >= 2)
|
||
{
|
||
s_at_error_count = 0;
|
||
*Nbiot_Send_Data.state = cst_AT_No_AT_NMGS;
|
||
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_E7025();
|
||
}
|
||
//启动连接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状态机
|
||
***************************************************************************/
|
||
void UdpConnectMachine_E7025(void)
|
||
{
|
||
static u8 s_at_error_count = 0;
|
||
|
||
static char c_AT_QIOPEN[100];
|
||
|
||
switch (s_udp_connect_state)
|
||
{
|
||
case S_UDP_CONNECT_START: //任务开始
|
||
{
|
||
s_at_error_count=0;
|
||
s_udp_connect_state = S_UDP_QIOPEN;
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
}
|
||
break;
|
||
|
||
case S_UDP_QIOPEN:
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
u16 len = 21; //整条AT指令的长度，根据发送长度的位数来定
|
||
char strings_temp[50];
|
||
memset(c_AT_QIOPEN,0,sizeof(c_AT_QIOPEN));
|
||
memset(strings_temp,0,sizeof(strings_temp));
|
||
strcpy(c_AT_QIOPEN,"AT+ECSOCR=DGRAM,17,1234,1,AF_INET\r"); //UDP
|
||
len = strlen(c_AT_QIOPEN);
|
||
NbiotUartSend((u8*)c_AT_QIOPEN, len, cst_AT_No_AT_QIOPEN);
|
||
set_timer_1s(2);
|
||
s_udp_connect_state = S_UDP_QIOPEN_R;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_UDP_QIOPEN_R:
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)
|
||
{
|
||
s_at_error_count = 0;
|
||
s_udp_connect_state = S_UDP_Wait;
|
||
set_timer_1s(1);
|
||
}
|
||
else if (!check_timer_1s() || NbiotCheckAtAck() == UART_ERROR)
|
||
{
|
||
s_at_error_count++;
|
||
if (s_at_error_count >= AT_ERROR)//
|
||
{
|
||
s_at_error_count = 0;
|
||
s_udp_connect_state = S_UDP_Wait;
|
||
set_timer_1s(1);
|
||
}
|
||
else
|
||
{
|
||
s_udp_connect_state = S_UDP_QIOPEN;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_UDP_Wait:
|
||
{
|
||
if((!check_timer_1s()))
|
||
{
|
||
s_at_error_count = 0;
|
||
*Nbiot_Send_Data.state = NBIOT_ONLINE;
|
||
s_udp_connect_state = S_UDP_CONNECT_START; //状态机回归初始状态
|
||
g_s_nbiot_task_flag = TASK_SUCCESS; //到此为止任务成功
|
||
}
|
||
}
|
||
break;
|
||
|
||
default:
|
||
{
|
||
s_udp_connect_state = S_UDP_CONNECT_START; //状态机回归初始状态
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
void UdpConnectMachine(void)
|
||
{
|
||
UdpConnectMachine_E7025();
|
||
}
|
||
|
||
//TdpConnectMachine
|
||
|
||
//模组AT指令编号
|
||
typedef enum{
|
||
S_TCP_CONNECT_START=0,
|
||
S_TCP_QIOPEN,
|
||
S_TCP_QIOPEN_R,
|
||
S_TCP_NCDP_CK,
|
||
S_TCP_NCDP_CK_R,
|
||
S_TCP_SUCCESS,
|
||
S_TCP_FAIL
|
||
}TYP_AT_CMDCODE;
|
||
|
||
const char tcp_socket_buf[6]={'0','1','2','3','4','5'};
|
||
u8 tcp_socket_index=0;
|
||
TYP_AT_CMDCODE s_tcp_connect_state=S_TCP_CONNECT_START;
|
||
static char stringbuffer_temp[256];
|
||
|
||
void TcpStartConnect(void)
|
||
{
|
||
s_tcp_connect_state = S_TCP_CONNECT_START;
|
||
}
|
||
void TcpConnectMachine(void)
|
||
{
|
||
unsigned char *nbiot_ip;
|
||
u16 nbiot_port;
|
||
static u8 s_at_error_count = 0;
|
||
//static const u8 temp_AT_Buffer[34]= {"AT+ECSOCR=DGRAM,17,1234,1,AF_INET\r"};
|
||
static const u8 temp_AT_Buffer[34]= {"AT+ECSOCR=STREAM,6,1234,1,AF_INET\r"};//TCP
|
||
static char c_AT_QIOPEN[50];
|
||
|
||
switch (s_tcp_connect_state)
|
||
{
|
||
case S_TCP_CONNECT_START: //任务开始
|
||
{
|
||
s_at_error_count=0;
|
||
s_tcp_connect_state = S_TCP_QIOPEN;
|
||
tcp_socket_index = 0;
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
}
|
||
break;
|
||
|
||
case S_TCP_QIOPEN://创建套接字
|
||
{
|
||
if(TASK_IDLE == UartIfIdle(NB_UART_COM))
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
u16 len = 0; //整条AT指令的长度，根据发送长度的位数来定
|
||
int i;
|
||
for(i=0; i<34; i++)
|
||
{
|
||
c_AT_QIOPEN[i]=temp_AT_Buffer[i];
|
||
}
|
||
if(tcp_socket_index>4)
|
||
{
|
||
tcp_socket_index = 0;
|
||
}
|
||
c_AT_QIOPEN[22] = tcp_socket_buf[tcp_socket_index];//更新socket
|
||
|
||
len = 34;
|
||
NbiotUartSend((u8*)c_AT_QIOPEN, len, cst_AT_No_AT_QIOPEN);
|
||
set_timer_1s(5);
|
||
s_tcp_connect_state = S_TCP_QIOPEN_R;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_TCP_QIOPEN_R:
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)
|
||
{
|
||
s_at_error_count = 0;
|
||
s_tcp_connect_state = S_TCP_NCDP_CK;
|
||
set_timer_1s(1);
|
||
}
|
||
else if (!check_timer_1s() || NbiotCheckAtAck() == UART_ERROR)
|
||
{
|
||
s_at_error_count++;
|
||
if (s_at_error_count >= 3)
|
||
{
|
||
s_at_error_count = 0;
|
||
s_tcp_connect_state = S_TCP_FAIL;
|
||
set_timer_1s(1);
|
||
}
|
||
else
|
||
{
|
||
s_tcp_connect_state = S_TCP_QIOPEN;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case S_TCP_NCDP_CK://连接服务器
|
||
{
|
||
if(TASK_IDLE == UartIfIdle(NB_UART_COM))
|
||
{
|
||
if (!check_timer_1s())
|
||
{
|
||
int ip_len = 0;
|
||
nbiot_port = coap_port;
|
||
nbiot_ip = coap_ip;
|
||
memset(stringbuffer_temp,0,sizeof(stringbuffer_temp));
|
||
//"AT+ECSOCO=1,"183.230.174.137",6065"
|
||
//IP 的存储仍然使用水表原来格式，不保存“.”号，使用时加入
|
||
stringbuffer_temp[ip_len++]='A';
|
||
stringbuffer_temp[ip_len++]='T';
|
||
stringbuffer_temp[ip_len++]='+';
|
||
stringbuffer_temp[ip_len++]='E';
|
||
stringbuffer_temp[ip_len++]='C';
|
||
stringbuffer_temp[ip_len++]='S';
|
||
stringbuffer_temp[ip_len++]='O';
|
||
stringbuffer_temp[ip_len++]='C';
|
||
stringbuffer_temp[ip_len++]='O';
|
||
stringbuffer_temp[ip_len++]='=';
|
||
stringbuffer_temp[ip_len++]=NbiotGetE7025TcpSocket();
|
||
stringbuffer_temp[ip_len++]=',';
|
||
stringbuffer_temp[ip_len++]='"';
|
||
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
if (nbiot_ip[i] < 10)
|
||
{
|
||
stringbuffer_temp[ip_len++] = nbiot_ip[i] + 0x30;
|
||
}
|
||
else if (nbiot_ip[i] < 100)
|
||
{
|
||
stringbuffer_temp[ip_len++] = (nbiot_ip[i] / 10) + 0x30;
|
||
stringbuffer_temp[ip_len++] = (nbiot_ip[i] % 10) + 0x30;
|
||
}
|
||
else
|
||
{
|
||
stringbuffer_temp[ip_len++] = (nbiot_ip[i] / 100) + 0x30;
|
||
stringbuffer_temp[ip_len++] = (nbiot_ip[i] / 10) % 10 + 0x30;
|
||
stringbuffer_temp[ip_len++] = (nbiot_ip[i] % 10) + 0x30;
|
||
}
|
||
stringbuffer_temp[ip_len++] = '.';
|
||
}
|
||
ip_len--; //消除多余的点号
|
||
stringbuffer_temp[ip_len++] = '\"';
|
||
stringbuffer_temp[ip_len++] = ',';
|
||
stringbuffer_temp[ip_len++] = ((nbiot_port) / 10000) + 0x30;
|
||
stringbuffer_temp[ip_len++] = (((nbiot_port) % 10000) / 1000) + 0x30;
|
||
stringbuffer_temp[ip_len++] = (((nbiot_port) % 1000) / 100) + 0x30;
|
||
stringbuffer_temp[ip_len++] = (((nbiot_port) % 100) / 10) + 0x30;
|
||
stringbuffer_temp[ip_len++] = ((nbiot_port) % 10) + 0x30;
|
||
stringbuffer_temp[ip_len++] = '\r';
|
||
|
||
NbiotUartSend((u8*)stringbuffer_temp, ip_len, cst_AT_No_AT);
|
||
set_timer_1s(10);
|
||
s_tcp_connect_state = S_TCP_NCDP_CK_R;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_TCP_NCDP_CK_R:
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)
|
||
{
|
||
s_at_error_count = 0;
|
||
s_tcp_connect_state = S_TCP_SUCCESS;
|
||
set_timer_1s(1);
|
||
}
|
||
else if (!check_timer_1s() || NbiotCheckAtAck() == UART_ERROR)
|
||
{
|
||
s_at_error_count++;
|
||
if (s_at_error_count >= 5)//
|
||
{
|
||
s_at_error_count = 0;
|
||
s_tcp_connect_state = S_TCP_FAIL;
|
||
set_timer_1s(1);
|
||
}
|
||
else
|
||
{
|
||
s_tcp_connect_state = S_TCP_NCDP_CK;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_TCP_SUCCESS:
|
||
{
|
||
if((!check_timer_1s()))
|
||
{
|
||
s_at_error_count = 0;
|
||
s_tcp_connect_state = S_TCP_CONNECT_START; //状态机回归初始状态
|
||
g_s_nbiot_task_flag = TASK_SUCCESS; //到此为止任务成功
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_TCP_FAIL:
|
||
{
|
||
if((!check_timer_1s()))
|
||
{
|
||
s_at_error_count = 0;
|
||
s_tcp_connect_state = S_TCP_CONNECT_START; //状态机回归初始状态
|
||
g_s_nbiot_task_flag = TASK_FAIL; //到此为止任务成功
|
||
}
|
||
}
|
||
break;
|
||
|
||
default:
|
||
{
|
||
s_tcp_connect_state = S_TCP_CONNECT_START; //状态机回归初始状态
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
//
|
||
void StartUdpSendData(void)
|
||
{
|
||
s_udp_send_state = S_SEND_START;
|
||
}
|
||
//AT+ECSOST=1,"183.230.174.137",6065,2,"3334"
|
||
void UdpSendDataMachine_E7025(void)
|
||
{
|
||
unsigned char *nbiot_ip;
|
||
u16 nbiot_port;
|
||
static u8 s_at_error_count = 0; //AT指令累计发送失败次数
|
||
static const u8 temp_AT_Buffer[10]= {"AT+ECSOST="};
|
||
switch (s_udp_send_state)
|
||
{
|
||
case S_SEND_START:
|
||
{
|
||
s_udp_send_state = S_SEND_DATA; //收到数据立即进行数据发送，模块会报ERROR，因此延时1S，消除此ERROR
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
}
|
||
break;
|
||
|
||
case S_SEND_DATA:
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
u16 len = 0; //整条AT指令的长度，根据发送长度的位数来定
|
||
nbiot_port = udp_port1;
|
||
nbiot_ip = udp_ip1;
|
||
int i;
|
||
for(i=0;i<10;i++)
|
||
{
|
||
c_AT_NMGS[len++] = temp_AT_Buffer[i];
|
||
}
|
||
//socekt
|
||
c_AT_NMGS[len++] = NbiotGetE7025UdpSocket();//socket范围为0~6
|
||
c_AT_NMGS[len++] = ',';
|
||
c_AT_NMGS[len++] = '\"';
|
||
//IP: NSOST Udp发送使用
|
||
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++] = ',';
|
||
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_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_udp_send_state = S_SEND_START;
|
||
}
|
||
else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1s()))
|
||
{
|
||
s_at_error_count++;
|
||
if (s_at_error_count >= 2)
|
||
{
|
||
s_at_error_count = 0;
|
||
*Nbiot_Send_Data.state = cst_AT_No_AT_NMGS;
|
||
g_s_nbiot_task_flag = TASK_SUCCESS;
|
||
s_udp_send_state = S_SEND_START;
|
||
}
|
||
else
|
||
{
|
||
set_timer_1s(4);
|
||
s_udp_send_state = S_SEND_DATA;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
default:
|
||
{
|
||
s_udp_send_state = S_SEND_START;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
void UdpSendDataMachine(void)
|
||
{
|
||
UdpSendDataMachine_E7025();
|
||
}
|
||
|
||
u8 s_tcp_send_state=S_SEND_START;
|
||
void StartTcpSendData(void)
|
||
{
|
||
s_tcp_send_state = S_SEND_START;
|
||
}
|
||
//AT+ECSOST=1,"183.230.174.137",6065,2,"3334"
|
||
//AT+ECSOSD=1,2,"3132"
|
||
void TcpSendDataMachine(void)
|
||
{
|
||
static u8 s_at_error_count = 0; //AT指令累计发送失败次数
|
||
static const u8 temp_AT_Buffer[10]= {"AT+ECSOSD="};
|
||
switch (s_tcp_send_state)
|
||
{
|
||
case S_SEND_START:
|
||
{
|
||
s_tcp_send_state = S_SEND_DATA; //收到数据立即进行数据发送，模块会报ERROR，因此延时1S，消除此ERROR
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
}
|
||
break;
|
||
|
||
case S_SEND_DATA:
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
u16 len = 0; //整条AT指令的长度，根据发送长度的位数来定
|
||
for(int i=0;i<10;i++)
|
||
{
|
||
c_AT_NMGS[len++] = temp_AT_Buffer[i];
|
||
}
|
||
//socekt
|
||
c_AT_NMGS[len++] = NbiotGetE7025TcpSocket();//socket范围为0~6
|
||
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++] = ',';
|
||
c_AT_NMGS[len++] = '\"';
|
||
//内容
|
||
for (int 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++] = '\"';
|
||
c_AT_NMGS[len++] = '\r';
|
||
NbiotUartSend((u8*) c_AT_NMGS, len, cst_AT_No_AT_NMGS);
|
||
set_timer_1s(4);
|
||
s_tcp_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_tcp_send_state = S_SEND_START;
|
||
}
|
||
else if (NbiotCheckAtAck() == UART_ERROR || (!check_timer_1s()))
|
||
{
|
||
s_at_error_count++;
|
||
if (s_at_error_count >= 2)
|
||
{
|
||
s_at_error_count = 0;
|
||
*Nbiot_Send_Data.state = cst_AT_No_AT_NMGS;
|
||
g_s_nbiot_task_flag = TASK_SUCCESS;
|
||
s_tcp_send_state = S_SEND_START;
|
||
}
|
||
else
|
||
{
|
||
set_timer_1s(4);
|
||
s_tcp_send_state = S_SEND_DATA;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
default:
|
||
{
|
||
s_tcp_send_state = S_SEND_START;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
void UdpReadDataMachine_E7025(void)
|
||
{
|
||
static u8 s_error_count; //AT指令累计发送失败次数
|
||
static u8 s_read_upd_data_state = S_START;
|
||
static const u8 temp_AT_Buffer[16]= {"AT+ECSORF=2,512\r"};
|
||
switch (s_read_upd_data_state)
|
||
{
|
||
case S_START:
|
||
{
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
s_error_count = 0;
|
||
s_read_upd_data_state = S_AT_QIRD;
|
||
}
|
||
break;
|
||
|
||
case S_AT_QIRD:
|
||
{
|
||
if (!check_timer_1ms())
|
||
{
|
||
u16 len=0;
|
||
int i;
|
||
for(i=0;i<16;i++)
|
||
{
|
||
c_AT_NMGS[len++] = temp_AT_Buffer[i];
|
||
}
|
||
c_AT_NMGS[10] = NbiotGetE7025UdpSocket();//socket范围为0~6
|
||
NbiotUartSend((u8*) c_AT_NMGS, len, cst_AT_No_AT_UPD_READ);
|
||
set_timer_1ms(3*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);
|
||
s_read_upd_data_state = S_AT_QIRD;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
default:
|
||
{
|
||
s_read_upd_data_state = S_START;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
void UdpReadDataMachine(void)
|
||
{
|
||
UdpReadDataMachine_E7025();
|
||
}
|
||
//
|
||
//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_3 = "AT+MIPLCONFIG=3,0\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_CCLK = "AT+CCLK?\r"; //查询基站时间
|
||
static char c_AT_MIPLRSP_BUF[40];// 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 = coap_port;
|
||
nbiot_ip = coap_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(2);
|
||
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;//S_ONENET_MIPLCONFIG3;
|
||
set_timer_1s(2);
|
||
}
|
||
else if (!check_timer_1s() || NbiotCheckAtAck() == UART_ERROR)
|
||
{
|
||
s_at_error_count++;
|
||
if (s_at_error_count >= AT_ERROR)//
|
||
{
|
||
//一般不会发生,肯定能查到返回结果
|
||
s_at_error_count = 0;
|
||
s_onenet_connect_state = S_ONENET_MIPLCONFIG_CK;//S_ONENET_MIPLCONFIG3;
|
||
set_timer_1s(2);
|
||
}
|
||
else
|
||
{
|
||
s_onenet_connect_state = S_ONENET_MIPLCONFIG;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_ONENET_MIPLCONFIG_CK:
|
||
{
|
||
if (!check_timer_1s())
|
||
{
|
||
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_1s(2);
|
||
}
|
||
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_1s(2);
|
||
}
|
||
else
|
||
{
|
||
s_onenet_connect_state = S_ONENET_MIPLCONFIG_CK;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_ONENET_MIPLCREATE:
|
||
{
|
||
if(!check_timer_1s())
|
||
{
|
||
if(TASK_IDLE == UartIfIdle(NB_UART_COM))
|
||
{
|
||
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_1s(2);
|
||
}
|
||
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_1s(2);
|
||
}
|
||
else
|
||
{
|
||
s_onenet_connect_state = S_ONENET_MIPLCREATE;
|
||
set_timer_1s(2);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_ONENET_MIPLADDOBJ:
|
||
{
|
||
if(!check_timer_1s())
|
||
{
|
||
if(TASK_IDLE == UartIfIdle(NB_UART_COM))
|
||
{
|
||
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_1s(2);
|
||
}
|
||
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_1s(2);
|
||
}
|
||
else
|
||
{
|
||
s_onenet_connect_state = S_ONENET_MIPLADDOBJ;
|
||
set_timer_1s(1);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_ONENET_MIPLOPEN:
|
||
{
|
||
if (!check_timer_1s())
|
||
{
|
||
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();
|
||
NbiotSetRevMiplobserve();
|
||
set_timer_1s(10);
|
||
s_onenet_connect_state = S_ONENET_MIPLOBSERVE;
|
||
}
|
||
|
||
else if ((!check_timer_1s()))
|
||
{
|
||
s_at_error_count++;
|
||
|
||
if (s_at_error_count >= NUM_AT_MIPLOPEN_ERROR)
|
||
{
|
||
*Nbiot_Send_Data.state = NBIOT_ERROR;
|
||
g_s_nbiot_task_flag = TASK_FAIL; //到此为止任务成功
|
||
s_at_error_count = 0;
|
||
s_onenet_connect_state = S_ONENET_MIPLOBSERVE;
|
||
}
|
||
else
|
||
{
|
||
s_onenet_connect_state = S_ONENET_MIPLOPEN;
|
||
set_timer_1s(1);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_ONENET_MIPLOBSERVE: //static char c_AT_MIPLDISCOVERRSP[30];// AT+MIPLDISCOVERRSP=0,48839,1,4,"5750"
|
||
{
|
||
if ((NbiotCheckAtAck() == UART_OK)||(!check_timer_1s()))
|
||
{
|
||
u8 len;
|
||
char observe_num[10];
|
||
memset(observe_num, 0, sizeof(observe_num));
|
||
memset(c_AT_MIPLRSP_BUF, 0, sizeof(c_AT_MIPLRSP_BUF));
|
||
strcpy(c_AT_MIPLRSP_BUF, "AT+MIPLOBSERVERSP=0,");
|
||
|
||
NbiotGetObserve_num(observe_num);
|
||
strcat(c_AT_MIPLRSP_BUF, observe_num);
|
||
strcat(c_AT_MIPLRSP_BUF, ",1\r");
|
||
|
||
len = strlen(c_AT_MIPLRSP_BUF);
|
||
NbiotUartSend((u8 *) c_AT_MIPLRSP_BUF, len, cst_AT_No_AT);
|
||
set_timer_1s(2);
|
||
|
||
s_onenet_connect_state = S_ONENET_MIPLOBSERVE_R;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_ONENET_MIPLOBSERVE_R: //应答接收到数据--等待响应
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)
|
||
{
|
||
s_at_error_count = 0;
|
||
NbiotClearAtAck();
|
||
NbiotSetRevMipldiscover();
|
||
set_timer_1s(5);
|
||
s_onenet_connect_state = S_ONENET_MIPLDISCOVER;
|
||
}
|
||
else if ((!check_timer_1s()))
|
||
{
|
||
s_at_error_count++;
|
||
if (s_at_error_count >= NUM_AT_MIPLOBSERVERSP_ERROR)
|
||
{
|
||
*Nbiot_Send_Data.state = NBIOT_ERROR;
|
||
g_s_nbiot_task_flag = TASK_FAIL; //到此为止任务成功
|
||
set_timer_1s(1);
|
||
s_at_error_count = 0;
|
||
s_onenet_connect_state = S_ONENET_CONNECT_IDLE;
|
||
}
|
||
else
|
||
{
|
||
set_timer_1s(5);
|
||
s_onenet_connect_state = S_ONENET_MIPLOBSERVE;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_ONENET_MIPLDISCOVER:
|
||
{
|
||
if ((NbiotCheckAtAck() == UART_OK)||(!check_timer_1s()))
|
||
{
|
||
u8 len;
|
||
char discover_num[10];
|
||
memset(discover_num, 0, sizeof(discover_num));
|
||
memset(c_AT_MIPLRSP_BUF, 0, sizeof(c_AT_MIPLRSP_BUF));
|
||
strcpy(c_AT_MIPLRSP_BUF, "AT+MIPLDISCOVERRSP=0,");
|
||
|
||
NbiotGetDiscover_num(discover_num);
|
||
strcat(c_AT_MIPLRSP_BUF, discover_num);
|
||
strcat(c_AT_MIPLRSP_BUF, ",1,4,\"5750\"\r");
|
||
|
||
len = strlen(c_AT_MIPLRSP_BUF);
|
||
NbiotUartSend((u8 *) c_AT_MIPLRSP_BUF, len, cst_AT_No_AT);
|
||
set_timer_1s(5);
|
||
s_onenet_connect_state = S_ONENET_MIPLDISCOVER_R;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_ONENET_MIPLDISCOVER_R: //应答接收到数据--等待响应
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)
|
||
{
|
||
set_timer_1s(1);
|
||
s_at_error_count = 0;
|
||
s_onenet_connect_state = S_ONENET_CCLK;
|
||
}
|
||
else if ((!check_timer_1s()))
|
||
{
|
||
s_at_error_count++;
|
||
|
||
if (s_at_error_count >= NUM_AT_MIPLDISCOVERRSP_ERROR)
|
||
{
|
||
*Nbiot_Send_Data.state = NBIOT_ERROR;
|
||
g_s_nbiot_task_flag = TASK_FAIL; //到此为止任务成功
|
||
set_timer_1s(1);
|
||
s_at_error_count = 0;
|
||
s_onenet_connect_state = S_ONENET_CONNECT_IDLE;
|
||
}
|
||
else
|
||
{
|
||
NbiotSetRevMipldiscover();
|
||
s_onenet_connect_state = S_ONENET_MIPLDISCOVER;
|
||
set_timer_1s(5);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_ONENET_CCLK://开始查询网络时间
|
||
{
|
||
if (!check_timer_1s())
|
||
{
|
||
NbiotUartSend((u8*) c_AT_CCLK, strlen(c_AT_CCLK), cst_AT_No_AT_CCLK);
|
||
s_onenet_connect_state = S_ONENET_CCLK_R;
|
||
set_timer_1ms(AT_COMMAND_RECEIVE_WAIT_TIME); //测试报告中AT指令返回的最长时间300ms(不包含发送和接收占用的时间)
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_ONENET_CCLK_R://等待应答
|
||
{
|
||
if (NbiotCheckAtAck() == UART_OK)//正确应答
|
||
{
|
||
s_at_error_count = 0;
|
||
s_onenet_connect_state = S_ONENET_Wait; //状态机回归初始状态
|
||
|
||
}
|
||
else if ((!check_timer_1ms()) || (NbiotCheckAtAck() == UART_ERROR))//应答超时
|
||
{
|
||
if (++s_at_error_count >= NUM_AT_CCLK_ERROR)
|
||
{
|
||
s_at_error_count = 0;
|
||
|
||
s_onenet_connect_state = S_ONENET_Wait; //状态机回归初始状态
|
||
|
||
}
|
||
else
|
||
{
|
||
s_onenet_connect_state = S_ONENET_CCLK;
|
||
set_timer_1s(1);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case S_ONENET_Wait:
|
||
{
|
||
if ((!check_timer_1s()))
|
||
{
|
||
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;
|
||
}
|
||
}
|
||
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;
|
||
}
|
||
|
||
void OneNetSendDataMachine(void)
|
||
{
|
||
char observe_num[10];
|
||
static const char temp_AT_MIPLDISCOVERRSP1[] = "AT+MIPLNOTIFY=0,";
|
||
static const char temp_AT_MIPLDISCOVERRSP2[] = ",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_MIPLDISCOVERRSP1);
|
||
memset(observe_num, 0, sizeof(observe_num));
|
||
NbiotGetObserve_num(observe_num);
|
||
//NbiotGetDiscover_num(observe_num);
|
||
|
||
strcat(c_AT_NMGS, observe_num);
|
||
strcat(c_AT_NMGS, temp_AT_MIPLDISCOVERRSP2);
|
||
|
||
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 SEND_ACKID_ENABLE
|
||
char strtemp[8];
|
||
|
||
if(++Send_AckID == 0) Send_AckID = 1; //Send_AckID==0的时候模块会报错ERROR
|
||
|
||
sprintf(strtemp, ",%u", Send_AckID);
|
||
strcat(c_AT_MIPLNOTIFY, strtemp);
|
||
strcat(c_AT_MIPLNOTIFY, "\r");
|
||
NbiotClearMsg();
|
||
NbiotUartSend((u8*) c_AT_MIPLNOTIFY, strlen(c_AT_MIPLNOTIFY), 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);
|
||
#endif
|
||
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 = cst_AT_No_AT_MIPLNOTIFY;
|
||
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_NETCLOSE = "AT+CTM2MDEREG\r";
|
||
//static const char* c_AT_TCPCLOSE = "AT+ECSOCL=1\r";
|
||
//static const char* c_AT_CFUN0 = "AT+CFUN=0\r"; //设置最小功能模式
|
||
//static const char* c_AT_NCSEARFCN = "AT+QCSEARFCN=0\r"; //清除已保存频点
|
||
//static const char* c_AT_CFUN1 = "AT+CFUN=1\r"; //设置正常功能模式
|
||
//static const char* c_AT_QPOWD = "AT+QPOWD=1\r";
|
||
switch (s_power_off_state)
|
||
{
|
||
case S_POWER_OFF_START:
|
||
{
|
||
s_at_error_count = 0;
|
||
|
||
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;
|
||
// Nbiot_Para.tcp1_state = CONNECT_OFF_LINE;
|
||
|
||
set_timer_1ms(AT_COMMAND_SEND_INTERVAL_TIME);
|
||
s_power_off_state = S_AT_NETCLOSE;
|
||
}
|
||
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_MIPLNOTIFY_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_POWER_OFF;
|
||
}
|
||
else
|
||
{
|
||
int len=0; // "AT+ECSOCL=1\r";
|
||
memset(stringbuffer_temp,0,sizeof(stringbuffer_temp));
|
||
//"AT+ECSOCO=1,"183.230.174.137",6065"
|
||
//IP 的存储仍然使用水表原来格式，不保存“.”号，使用时加入
|
||
stringbuffer_temp[len++]='A';
|
||
stringbuffer_temp[len++]='T';
|
||
stringbuffer_temp[len++]='+';
|
||
stringbuffer_temp[len++]='E';
|
||
stringbuffer_temp[len++]='C';
|
||
stringbuffer_temp[len++]='S';
|
||
stringbuffer_temp[len++]='O';
|
||
stringbuffer_temp[len++]='C';
|
||
stringbuffer_temp[len++]='L';
|
||
stringbuffer_temp[len++]='=';
|
||
stringbuffer_temp[len++]=NbiotGetE7025TcpSocket();
|
||
stringbuffer_temp[len++]='\r';
|
||
|
||
NbiotUartSend((u8*) stringbuffer_temp,len, cst_AT_No_AT);
|
||
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_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_NETCLOSE;
|
||
}
|
||
}
|
||
}
|
||
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_POWER_OFF;
|
||
}
|
||
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_POWER_OFF;
|
||
}
|
||
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.udp1_state = CONNECT_OFF_LINE;
|
||
Nbiot_Para.udp2_state = CONNECT_OFF_LINE;
|
||
// Nbiot_Para.tcp1_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;
|
||
static const u8 c_AT_NUESTATS[] = "AT+QENG=0\r";
|
||
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 定时器资源
|
||
* @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.udp1_state = CONNECT_OFF_LINE;
|
||
Nbiot_Para.udp2_state = CONNECT_OFF_LINE;
|
||
// Nbiot_Para.tcp1_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.NB_module_IMEI_0016);
|
||
// NbiotGetIMSI(Sys_data_object.NB_module_IMSI);
|
||
// NbiotGetICCID(Sys_data_object.SIMCard_ICCID_200A);
|
||
}
|
||
u32 sys_get_net_state (void)
|
||
{
|
||
return 0;
|
||
}
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|
||
|
||
#endif
|