代码结构优化

Drivers/Business/PumpBusiness.c

@@ -7,25 +7,21 @@
 #include "Usart1.h"
 
 #include "CONFIG.h"
-#include "INflash.h"
 #include "Initialize.h"
 #include "UDP_Client.h"
 #include "Timer_Module.h"
 #include "Log_Module.h"
 #include "At_Module.h"
 #include "Pump_Dicts_Util.h"
-#include "Regist.h"
-
-// 计时相关的变量
-static struct TIMER_Struct timer;
 
+#include "Tuoreniot.h"
+#include "Regist.h"
+#include "UDP_Client.h"
 
+// 联网成功标识
+uint8_t Network_Success_Flag = 0;
 
-uint8_t send_data_switch = 1; // 发送数据的开关，0表示发送数据
-uint8_t networkTest_Flag=0;//开机判断是否有信号，0是未知默认状态，1是失败状态，2是成功状态。
-uint8_t module_switch = 0;//4G模块开关 0正常，1是关闭标志
-static uint8_t test_switch=0; //0代表正常流程，1代表测试流程
-struct Pump_Params pump_params; // 泵参数
+struct PUMPDICTS_ParamsStruct pump_params; // 泵参数
 
 static uint16_t Data_Number = 0; // 数据编号
 static uint16_t Data_success_Number = 0; // 成功包
@@ -37,13 +33,12 @@ int RSSI3=0;
 int SINR4=0;
 
 // 泵参数初始化
-void Pump_Params_Init(void)
+static void PUMPBUSINESS_ParamsInit(void)
 {
 	pump_params.userId = 0;
 	pump_params.pumpType = 0;
 	pump_params.infusionId = 0;
 	pump_params.appendDose=0;
-	
 	//报警初始化
 	pump_params.alarm_BubbleOrAneroid = 0;
 	pump_params.alarm_Blocked = 0;
@@ -54,7 +49,6 @@ void Pump_Params_Init(void)
 	pump_params.alarm_MotorOutofcontrol = 0;
 	pump_params.alarm_MechanicalBreakdown = 0;
 	pump_params.alarm_UnfilledPillBox = 0;
-	
 	//预报初始化
 	pump_params.forcast_WillFinished = 0;
 	pump_params.forcast_InsufficientAnalgesia = 0;
@@ -71,11 +65,10 @@ void Pump_Params_Init(void)
 
 
 // 刷新泵数据
-void Pump_Params_Refresh(void)
+void PUMPBUSINESS_ParamsRefresh(void)
 {
-	// 初始化参数
-	Pump_Params_Init();
-	
+	// 初始化
+	PUMPBUSINESS_ParamsInit();
 	pump_params.userId = 1000;
 	pump_params.pumpType = 1;
 	pump_params.infusionId = 234;
@@ -99,19 +92,70 @@ void Pump_Params_Refresh(void)
 }
 
 
+// 初始化结果处理
+static void Initialize_ResultHandle()
+{
+	// 初始化过程处理
+	if(INITIALIZE_GetStatus() == INITIALIZE_Status_Being)
+	{
+		// 初始化流程处理
+		INITIALIZE_ProcessHandle();
+	}
+	else if(INITIALIZE_GetStatus() == INITIALIZE_Status_Done)
+	{
+		Log_Printf_Debug("初始化结束\r\n");
+		if(INITIALIZE_GetResult() == INITIALIZE_Result_Success)
+		{
+			Log_Printf_Debug("初始化成功: %d\r\n", INITIALIZE_GetResult());
+			Network_Success_Flag = 1;
+		}
+		else if(INITIALIZE_GetResult() == INITIALIZE_Result_Failure)
+		{
+			Log_Printf_Debug("初始化失败: %d\r\n", INITIALIZE_GetResult());
+			Network_Success_Flag = 0;
+		}
+		// 重置初始化
+		INITIALIZE_Reset();
+	}
+}
 
 
-static uint32_t Business_wait_time = 1200; // 秒
-// 业务处理
-void PumpBusines_Handle(void)
+// 注册结果处理
+static void Regist_ResultHandle()
 {
-	// 没注册，直接返回
-	if(regist_get_result() != Regist_Result_Success)
+	// 注册过程处理
+	if(REGIST_GetStatus() == REGIST_Status_Being)
 	{
-		return;
+		// 注册流程处理
+		REGIST_ProcessHandle();
 	}
-	
-	// 定时发送数据
+	else if(REGIST_GetStatus() == REGIST_Status_Done)
+	{
+		Log_Printf_Debug("注册结束\r\n");
+		if(REGIST_GetResult() == REGIST_Result_Success)
+		{
+			Log_Printf_Debug("注册成功: %d\r\n", REGIST_GetResult());
+			Network_Success_Flag = 1;
+		}
+		else if(REGIST_GetResult() == REGIST_Result_None)
+		{
+			Log_Printf_Debug("注册失败: %d\r\n", REGIST_GetResult());
+			Network_Success_Flag = 0;
+		}
+		// 重置注册
+		REGIST_Reset();
+	}
+}
+
+
+// 定时发送
+// 计时相关的变量
+static struct TIMER_Struct timer;
+static uint32_t Business_wait_time = 1200; // 秒
+uint8_t send_data_switch = 1; // 发送数据的开关，0表示发送数据
+static void UDPClient_SendDataInterval()
+{
+		// 定时发送数据
 	if(time_get_delay(&timer) > 1000 * Business_wait_time) // // 定时时间，20分钟
 	{
 		// 20分钟计时完成，处理业务
@@ -120,68 +164,92 @@ void PumpBusines_Handle(void)
 		Log_Printf_Debug("PumpBusines_Handle\r\n");
 	}
 	
-	// 发送标志位不为1直接返回
-	if(send_data_switch != 1)
-	{
-		return;
-	}
-	// 发送
-	if(UDP_Client_Status() == Client_Status_None)
+	// 判断发送
+	if(send_data_switch == 1)
 	{
-		if(test_switch==1 && Data_Number>=100)//测试模式只发100条数据
+		// 初始化流程处于空闲， 注册流程处于空闲，注册成功时发送
+		if(INITIALIZE_GetStatus() == INITIALIZE_Status_None
+			&& REGIST_GetStatus() == REGIST_Status_None 
+			&& REGIST_GetResult() == REGIST_Result_Success)
 		{
-			send_data_switch=0;
-			return ;
+			Log_Printf_Debug("开始发送\r\n");
+			UDPCLIENT_Start();
+			send_data_switch = 0;
+			// 数据编号加1
+			Data_Number++;
 		}
-		// 数据编号加1
-		Data_Number++;
-		// 发送参数
-		UDP_Client_Send(test_switch);
 	}
-	else if(UDP_Client_Status() == Client_Status_Sending) // 正在发送
+}
+
+// 发送结果处理
+static void UDPClient_ResultHandle()
+{
+	// 发送过程处理
+	if(UDPCLIENT_GetStatus() == UDPCLIENT_Status_Being)
 	{
-		// 客户端
-		UDP_Client_Handle();
+		// 发送流程处理
+		UDPCLIENT_ProcessHandle();
 	}
-	else if(UDP_Client_Status() == Client_Status_Success) // 成功
+	else if(UDPCLIENT_GetStatus() == UDPCLIENT_Status_Done)
 	{
-		Log_Printf("发送成功：%s\r\n", UDP_Client_Get_Info());
-		UDP_Client_Clear(); // 清除
-		
-		send_data_switch = 0; // 关闭发送
-		Data_success_Number++;
-		if(test_switch==1){
-			Query_Signal(&RSRP1,&RSRQ2,&RSSI3,&SINR4);
-			Log_Printf("\r\nRSRP1：%d,RSRQ2:%d,RSSI3:%d,SINR4:%d\r\n", RSRP1,RSRQ2,RSSI3,SINR4);
+		Log_Printf_Debug("发送结束\r\n");
+		if(UDPCLIENT_GetResult() == UDPCLIENT_Result_Success)
+		{
+			Log_Printf_Debug("发送成功: %d\r\n", UDPCLIENT_GetResult());
+			
+			if(UDPCLIENT_TestModeFlag==1){
+				UDPCLIENT_QuerySignal(&RSRP1,&RSRQ2,&RSSI3,&SINR4);
+				Log_Printf("\r\nRSRP1：%d,RSRQ2:%d,RSSI3:%d,SINR4:%d\r\n", RSRP1,RSRQ2,RSSI3,SINR4);
+			}
+			Network_Success_Flag = 1;
+			Data_success_Number++;
 		}
+		else if(UDPCLIENT_GetResult() == UDPCLIENT_Result_Failure)
+		{
+			Log_Printf_Debug("发送失败: %d\r\n", UDPCLIENT_GetResult());
+			Network_Success_Flag = 0;
+			Data_fail_Number++;
+		}
+		// 重置发送
+		UDPCLIENT_Reset();
 	}
-	else if(UDP_Client_Status() == Client_Status_Failure) // 失败
-	{
-		Log_Printf("发送失败：%s\r\n", UDP_Client_Get_Info());
-		UDP_Client_Clear(); // 清除
-		send_data_switch = 0; // 关闭发送
-		Data_fail_Number++;
+}
 
-	}
-	else
-	{
-		// 未知的状态
-		
-	}
+// 业务处理
+static void PUMPBUSINESS_Process(void)
+{
+	// 初始化诱因处理
+	INITIALIZE_TriggerHandle();
+	// 初始化结果处理
+	Initialize_ResultHandle();
+	
+	// 注册结果处理
+	Regist_ResultHandle();
+	
+	// 定时发送数据
+	UDPClient_SendDataInterval();
+	// 发送结果处理
+	UDPClient_ResultHandle();
 	
+	// 一些未处理的数据
+	AT_ResidueHandle();
 }
 
 
 
-// 循环执行
-void pump_business_loop_execution()
-{
-		// 初始化
-	Initialize_Handle();
 
-	// 业务处理
-	PumpBusines_Handle();
-	// 未及时处理的AT指令
-	AT_Handle();
+
+// 初始化，放到while前
+void PUMPBUSINESS_Init(void)
+{
+	TUORENIOT_Init();
+}
+// 流程处理，放到while循环
+void PUMPBUSINESS_ProcessHandle(void)
+{
+	PUMPBUSINESS_Process();
 }
 
+
+
+

Drivers/Business/PumpBusiness.h

@@ -3,9 +3,18 @@
 
 #include <stdint.h>
 
-// 循环执行
-void pump_business_loop_execution(void);
- void Pump_Params_Refresh(void);
- extern uint8_t networkTest_Flag;
-  extern uint8_t module_switch;
+// 联网成功的标识
+extern uint8_t Network_Success_Flag;
+
+// 泵参数
+extern struct PUMPDICTS_ParamsStruct pump_params;
+
+
+
+// 初始化，放到while前
+void PUMPBUSINESS_Init(void);
+// 流程处理，放到while循环
+void PUMPBUSINESS_ProcessHandle(void);
+// 刷新泵参数
+void PUMPBUSINESS_ParamsRefresh(void);
 #endif

Drivers/CONFIG.h

@@ -25,7 +25,7 @@
 #define WAKE_GPIO_Pin GPIO_Pin_6 // ˯ÃßµÄÒý½Å
 //flashÏà¹ØÅäÖÃ
 #define FLASH_SIZE 64
-#define SAVE_ADDR 0X0800FC00
+#define FLASH_SAVE_ADDR 0X0800F800
 
 
 

Drivers/Core/Process_Control.c

@@ -0,0 +1,60 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include "Process_Control.h"
+
+#include "Log_Module.h"
+
+
+
+// 直接跳转到下一步
+// 不带日志
+void PCTRL_GotoStepNoLog(struct PCTRL_Struct * pctrl, uint16_t ns)
+{
+	if(pctrl->goto_step_listener)
+	{
+		pctrl->current_step = pctrl->goto_step_listener(ns);
+	}
+	else
+	{
+		pctrl->current_step = ns;
+	}
+}
+// 带日志
+void PCTRL_GotoStep(struct PCTRL_Struct * pctrl, uint16_t ns, char * msg)
+{
+	PCTRL_GotoStepNoLog(pctrl, ns);
+	// 预存一下
+	memset(pctrl->current_step_msg, 0, sizeof(pctrl->current_step_msg));
+	strcpy(pctrl->current_step_msg, msg);
+	Log_Printf_Debug("\r\n步骤%d：%s\r\n", pctrl->current_step, pctrl->current_step_msg);
+}
+// 先等待再跳转到下一步
+void PCTRL_GotoStepWait(struct PCTRL_Struct * pctrl, uint16_t ns, uint32_t t, char * msg)
+{
+	PCTRL_GotoStepNoLog(pctrl, pctrl->step_wait); // 等待
+	pctrl->wait_time = t;
+	pctrl->next_step = ns; // 等待之后跳转
+	// 预存一下
+	memset(pctrl->next_step_msg, 0, sizeof(pctrl->next_step_msg));
+	strcpy(pctrl->next_step_msg, msg);
+	Log_Printf_Debug("%dms后跳转到步骤%d：%s", t, pctrl->next_step, pctrl->next_step_msg);
+}
+// 只等待，等待之后返回原来的步骤
+void PCTRL_GotoWait(struct PCTRL_Struct * pctrl, uint32_t t)
+{
+	PCTRL_GotoStepWait(pctrl, pctrl->current_step, t, pctrl->current_step_msg);
+}
+// 等待
+void PCTRL_Wait(struct PCTRL_Struct * pctrl)
+{
+	if(time_get_delay(&pctrl->timer) > pctrl->wait_time)
+	{
+		PCTRL_GotoStep(pctrl, pctrl->next_step, pctrl->next_step_msg); // 进入下一步
+		time_clear(&pctrl->timer);
+	}
+}
+
+
+

Drivers/Core/Process_Control.h

@@ -0,0 +1,32 @@
+#ifndef __PROCESS_CONTROL_H
+#define __PROCESS_CONTROL_H
+#include <stdint.h>
+#include "Timer_Module.h"
+
+struct PCTRL_Struct
+{
+	uint16_t current_step;
+	char current_step_msg[40];
+	uint16_t next_step;
+	char next_step_msg[40];
+	struct TIMER_Struct timer;
+	uint32_t wait_time;
+	uint16_t step_wait;
+	uint16_t (* goto_step_listener)(uint16_t ns);
+};
+
+// 直接跳转到下一步
+// 不带日志
+void PCTRL_GotoStepNoLog(struct PCTRL_Struct * pctrl, uint16_t ns);
+// 带日志
+void PCTRL_GotoStep(struct PCTRL_Struct * pctrl, uint16_t ns, char * msg);
+// 先等待再跳转到下一步
+void PCTRL_GotoStepWait(struct PCTRL_Struct * pctrl, uint16_t ns, uint32_t t, char * msg);
+// 只等待，等待之后返回原来的步骤
+void PCTRL_GotoWait(struct PCTRL_Struct * pctrl, uint32_t t);
+// 等待
+void PCTRL_Wait(struct PCTRL_Struct * pctrl);
+
+
+
+#endif

Drivers/Encrypt/Mbedtls_Util.c

@@ -78,48 +78,48 @@ static void cutAESPKCS7Data(char* data)
 void utils_hmac_sha1_str(const char *msg, int msg_len, char *digest, const char *key, int key_len)
 {
 	//对函数参数判空
-    if((NULL == msg) || (NULL == digest) || (NULL == key)) {
-        return;
-    }
-	//限制密钥长度
-    if(key_len > KEY_IOPAD_SIZE) {
-        return;
-    }
-	//hmac sha1加密处理
-    mbedtls_sha1_context context;
-    unsigned char k_ipad[KEY_IOPAD_SIZE];    /* inner padding - key XORd with ipad  */
-    unsigned char k_opad[KEY_IOPAD_SIZE];    /* outer padding - key XORd with opad */
-    unsigned char out[SHA1_DIGEST_SIZE];
-    int i;
-
-    /* start out by storing key in pads */
-    memset(k_ipad, 0, sizeof(k_ipad));
-    memset(k_opad, 0, sizeof(k_opad));
-    memcpy(k_ipad, key, key_len);
-    memcpy(k_opad, key, key_len);
-
-    /* XOR key with ipad and opad values */
-    for (i = 0; i < KEY_IOPAD_SIZE; i++) {
-        k_ipad[i] ^= 0x36;
-        k_opad[i] ^= 0x5c;
-    }
-
-    /* perform inner MD5 */
-    mbedtls_sha1_init(&context);                                      /* init context for 1st pass */
-    mbedtls_sha1_starts(&context);                                    /* setup context for 1st pass */
-    mbedtls_sha1_update(&context, k_ipad, KEY_IOPAD_SIZE);            /* start with inner pad */
-    mbedtls_sha1_update(&context, (unsigned char *) msg, msg_len);    /* then text of datagram */
-    mbedtls_sha1_finish(&context, out);                               /* finish up 1st pass */
-
-    /* perform outer MD5 */
-    mbedtls_sha1_init(&context);                              /* init context for 2nd pass */
-    mbedtls_sha1_starts(&context);                            /* setup context for 2nd pass */
-    mbedtls_sha1_update(&context, k_opad, KEY_IOPAD_SIZE);    /* start with outer pad */
-    mbedtls_sha1_update(&context, out, SHA1_DIGEST_SIZE);      /* then results of 1st hash */
-    mbedtls_sha1_finish(&context, out);                       /* finish up 2nd pass */
-    
-	//加密后的数据16进制输出
-		byteToHexStr(out,digest,SHA1_DIGEST_SIZE);
+	if((NULL == msg) || (NULL == digest) || (NULL == key)) {
+			return;
+	}
+//限制密钥长度
+	if(key_len > KEY_IOPAD_SIZE) {
+			return;
+	}
+//hmac sha1加密处理
+	mbedtls_sha1_context context;
+	unsigned char k_ipad[KEY_IOPAD_SIZE];    /* inner padding - key XORd with ipad  */
+	unsigned char k_opad[KEY_IOPAD_SIZE];    /* outer padding - key XORd with opad */
+	unsigned char out[SHA1_DIGEST_SIZE];
+	int i;
+
+	/* start out by storing key in pads */
+	memset(k_ipad, 0, sizeof(k_ipad));
+	memset(k_opad, 0, sizeof(k_opad));
+	memcpy(k_ipad, key, key_len);
+	memcpy(k_opad, key, key_len);
+
+	/* XOR key with ipad and opad values */
+	for (i = 0; i < KEY_IOPAD_SIZE; i++) {
+			k_ipad[i] ^= 0x36;
+			k_opad[i] ^= 0x5c;
+	}
+
+	/* perform inner MD5 */
+	mbedtls_sha1_init(&context);                                      /* init context for 1st pass */
+	mbedtls_sha1_starts(&context);                                    /* setup context for 1st pass */
+	mbedtls_sha1_update(&context, k_ipad, KEY_IOPAD_SIZE);            /* start with inner pad */
+	mbedtls_sha1_update(&context, (unsigned char *) msg, msg_len);    /* then text of datagram */
+	mbedtls_sha1_finish(&context, out);                               /* finish up 1st pass */
+
+	/* perform outer MD5 */
+	mbedtls_sha1_init(&context);                              /* init context for 2nd pass */
+	mbedtls_sha1_starts(&context);                            /* setup context for 2nd pass */
+	mbedtls_sha1_update(&context, k_opad, KEY_IOPAD_SIZE);    /* start with outer pad */
+	mbedtls_sha1_update(&context, out, SHA1_DIGEST_SIZE);      /* then results of 1st hash */
+	mbedtls_sha1_finish(&context, out);                       /* finish up 2nd pass */
+	
+//加密后的数据16进制输出
+	byteToHexStr(out,digest,SHA1_DIGEST_SIZE);
 	mbedtls_sha1_free(&context);
 		
 }
@@ -127,15 +127,15 @@ void utils_hmac_sha1_str(const char *msg, int msg_len, char *digest, const char
 void utils_sha256(const char *msg, int msg_len, char * digest)
 {
 
-		//hmac sha1加密处理
-    mbedtls_sha256_context context;
+	//hmac sha1加密处理
+	mbedtls_sha256_context context;
 //   memset(testhexdata, 0, sizeof(testhexdata));
-    /* perform inner MD5 */
-    mbedtls_sha256_init(&context);                                      /* init context for 1st pass */
-    mbedtls_sha256_starts(&context,0);                                    /* setup context for 1st pass */
-    mbedtls_sha256_update(&context, (unsigned char *) msg, msg_len);    /* then text of datagram */
-    mbedtls_sha256_finish(&context, (unsigned char *) digest);                               /* finish up 1st pass */
-    mbedtls_sha256_free(&context);
+	/* perform inner MD5 */
+	mbedtls_sha256_init(&context);                                      /* init context for 1st pass */
+	mbedtls_sha256_starts(&context,0);                                    /* setup context for 1st pass */
+	mbedtls_sha256_update(&context, (unsigned char *) msg, msg_len);    /* then text of datagram */
+	mbedtls_sha256_finish(&context, (unsigned char *) digest);                               /* finish up 1st pass */
+	mbedtls_sha256_free(&context);
 //	byteToHexStr((const unsigned char *)digest,testhexdata, strlen((char * )digest));
 //	Log_Printf_Debug("数据报文msg:%s,%d\r\n", msg,msg_len);
 //	Log_Printf_Debug("数据报文digest:%s\r\n", testhexdata);
@@ -169,26 +169,22 @@ int utils_aes128_cbc_enc_with_length(uint8_t *aes_key, char *iv, uint8_t * plain
 int utils_aes128_ECB_base64_enc_with_length(char *aes_key, uint8_t * plaintext)
 {
 	int times=0;
- 		memset(plaintextdata, 0, sizeof(plaintextdata));
-		mbedtls_aes_context aes_ctx;
-		if(strlen((const char *)plaintext) + 16 > AES_LEN_SIZE) return -1;
-		memcpy(plaintextdata, plaintext, strlen((const char *)plaintext));
+ 	memset(plaintextdata, 0, sizeof(plaintextdata));
+	mbedtls_aes_context aes_ctx;
+	if(strlen((const char *)plaintext) + 16 > AES_LEN_SIZE) return -1;
+	memcpy(plaintextdata, plaintext, strlen((const char *)plaintext));
 
-    int len = fillAESPKCS7DataWithLength((uint8_t *)plaintextdata, strlen((const char *)plaintext));
+  int len = fillAESPKCS7DataWithLength((uint8_t *)plaintextdata, strlen((const char *)plaintext));
 	
 	mbedtls_aes_init(&aes_ctx);
-	   //setkey_dec
-    mbedtls_aes_setkey_enc(&aes_ctx, (unsigned char * )aes_key, 128);
+	//setkey_dec
+  mbedtls_aes_setkey_enc(&aes_ctx, (unsigned char * )aes_key, 128);
 	while(times*AES_BLOCK_SIZE<len){
-		
 		mbedtls_aes_crypt_ecb(&aes_ctx, MBEDTLS_AES_ENCRYPT,  (unsigned char * )plaintextdata+times*AES_BLOCK_SIZE, (unsigned char * )plaintext+times*AES_BLOCK_SIZE);
 		++times;
-		
 	}
 	mbedtls_aes_free(&aes_ctx);
-
-		return len;
-		
+	return len;
 }
 
 
@@ -224,16 +220,16 @@ int utils_aes128_ECB_base64_dec(char *aes_key, uint8_t * plaintext, uint16_t rec
 int utils_aes128_cbc_dec(uint8_t *aes_key, char *iv, char *ciphertext, int len, char *plaintext)
 {
 
-		char iv_use[16] = {0};
-		mbedtls_aes_context aes_ctx;
-		if(len%16&&len>AES_LEN_SIZE) return 0;
-		memcpy(iv_use,iv,16);
-    mbedtls_aes_init(&aes_ctx);
-    //setkey_dec
-    mbedtls_aes_setkey_dec(&aes_ctx, aes_key, 128);
-		mbedtls_aes_crypt_cbc(&aes_ctx, MBEDTLS_AES_DECRYPT, len, (unsigned char * )iv_use, (unsigned char * )ciphertext, (unsigned char * )plaintext);
-    cutAESPKCS7Data((char *)plaintext);
-    mbedtls_aes_free(&aes_ctx);
-    return strlen(plaintext); //OK
+	char iv_use[16] = {0};
+	mbedtls_aes_context aes_ctx;
+	if(len%16&&len>AES_LEN_SIZE) return 0;
+	memcpy(iv_use,iv,16);
+	mbedtls_aes_init(&aes_ctx);
+	//setkey_dec
+	mbedtls_aes_setkey_dec(&aes_ctx, aes_key, 128);
+	mbedtls_aes_crypt_cbc(&aes_ctx, MBEDTLS_AES_DECRYPT, len, (unsigned char * )iv_use, (unsigned char * )ciphertext, (unsigned char * )plaintext);
+	cutAESPKCS7Data((char *)plaintext);
+	mbedtls_aes_free(&aes_ctx);
+	return strlen(plaintext); //OK
 
 }

Drivers/INflash.c

@@ -1,111 +0,0 @@
-/**
-  ******************************************************************************
-  * 版   本       ：V1.0.0
-  * 作   者       ：liuyanbin
-  * 版权所有，盗版必究。
-  * Copyright(C) All rights reserved
-  ******************************************************************************
-  *                             历史记录
-  *     序号      版本        变更内容          作者              日期
-  *      1        V0.0.1      实现flash存储      刘艳斌          2024/1/24
-  *
-  ******************************************************************************
-  */
-
-#include "stm32f10x.h"
-#include <stdint.h>
-#include "INflash.h"
-#include "Regist.h"
-#include "string.h"
-#include "Delay.h"
-#include "Log_Module.h"
-
-typedef uint16_t uint16;
-typedef uint32_t uint32;
-
-
-
-uint16 STMFLASH_BUF[STM32_SECTOR_SIZE/2];//最多是2K字节
-void write_to_flash(uint32 WriteAddr,uint16 *pBuffer,uint16 NumToWrite)
-{
-    uint16 i;
-	for(i=0;i<NumToWrite;i++)
-	{
-		FLASH_ProgramHalfWord(WriteAddr,pBuffer[i]);
-	    WriteAddr+=2;//地址增加2.
-	}  
-
-}
-//读取指定地址的半字(16位数据)
-//faddr:读地址(此地址必须为2的倍数!!)
-//返回值:对应数据.
-uint16 STMFLASH_ReadHalfWord(uint32 faddr)
-{
-	return *(vu16*)faddr; 
-}
-//从指定地址开始读出指定长度的数据
-//ReadAddr:起始地址
-//pBuffer:数据指针
-//NumToWrite:半字(16位)数
-void STMFLASH_Read(uint32 ReadAddr,uint16 *pBuffer,uint16 NumToRead)   	
-{
-	uint16 i;
-	for(i=0;i<NumToRead;i++)
-	{
-		pBuffer[i]=STMFLASH_ReadHalfWord(ReadAddr);//读取2个字节.
-		ReadAddr+=2;//偏移2个字节.	
-	}
-}
-void STMFLASH_Write(uint32 WriteAddr,uint16 *pBuffer,uint16 NumToWrite)
-{
-  uint32 secpos;	   //扇区地址
-	uint16 secoff;	   //扇区内偏移地址(16位字计算)
-	uint16 secremain; //扇区内剩余地址(16位字计算)	   
- 	uint16 i;    
-	uint32 offaddr;   //去掉0X08000000后的地址
-	if(WriteAddr<STM32_FLASH_BASE||(WriteAddr>=(STM32_FLASH_BASE+1024*STM32_FLASH_SIZE)))return;//非法地址
-	FLASH_Unlock();	
-	offaddr=WriteAddr-STM32_FLASH_BASE;		//实际偏移地址.
-	secpos=offaddr/STM32_SECTOR_SIZE;	 //扇区地址  0~127 for STM32F103RBT6
-	secoff=(offaddr%STM32_SECTOR_SIZE)/2;		//在扇区内的偏移(2个字节为基本单位.)
-	secremain=STM32_SECTOR_SIZE/2-secoff;		//扇区剩余空间大小  
-	if(NumToWrite<=secremain)secremain=NumToWrite;//不大于该扇区范围
-	while(1) 
-	{	
-		STMFLASH_Read(secpos*STM32_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM32_SECTOR_SIZE/2);//读出整个扇区的内容
-		for(i=0;i<secremain;i++)//校验数据
-		{
-			if(STMFLASH_BUF[secoff+i]!=0XFFFF)break;//需要擦除  	  
-		}
-		if(i<secremain)//需要擦除
-		{
-			FLASH_ErasePage(secpos*STM32_SECTOR_SIZE+STM32_FLASH_BASE);//擦除这个扇区
-			for(i=0;i<secremain;i++)//复制
-			{
-				STMFLASH_BUF[i+secoff]=pBuffer[i];	  
-			}
-			write_to_flash(secpos*STM32_SECTOR_SIZE+STM32_FLASH_BASE,STMFLASH_BUF,STM32_SECTOR_SIZE/2);//写入整个扇区  
-		}else write_to_flash(WriteAddr,pBuffer,secremain);//写已经擦除了的,直接写入扇区剩余区间. 				   
-		if(NumToWrite==secremain)break;//写入结束了
-		else//写入未结束
-		{
-			secpos++;				//扇区地址增1
-			secoff=0;				//偏移位置为0 	 
-		  pBuffer+=secremain;  	//指针偏移
-			WriteAddr+=secremain;	//写地址偏移	   
-		  NumToWrite-=secremain;	//字节(16位)数递减
-			if(NumToWrite>(STM32_SECTOR_SIZE/2))secremain=STM32_SECTOR_SIZE/2;//下一个扇区还是写不完
-			else secremain=NumToWrite;//下一个扇区可以写完了
-		}	 
-	};	
-	FLASH_Lock();//上锁
- 
-}
-
-
-
-
-
-
-
-

Drivers/INflash.h

@@ -1,36 +0,0 @@
-#ifndef __INFLASH_H
-#define __INFLASH_H
-#include "CONFIG.h"
-//FLASH起始地址
-#define STM32_FLASH_BASE 0x08000000 	//STM32 FLASH的起始地址
-
-#define STM32_FLASH_SIZE FLASH_SIZE 	 		//所选STM32的FLASH容量大小(单位为K)
-#define STM32_FLASH_WREN 1              //使能FLASH写入(0，不是能;1，使能)
-/* STM32F103扇区大小 */
-#if STM32_FLASH_SIZE < 256
-#define STM32_SECTOR_SIZE  1024		/* 容量小于256K的F103, 扇区大小为1K字节 */
-#else
-#define STM32_SECTOR_SIZE  2048		/* 容量大于等于256K的F103, 扇区大小为2K字节 */
-#endif
-//(现在是512页的stm32 f103ZE)
-#define FLASH_SAVE_ADDR SAVE_ADDR		//设置FLASH 保存地址(必须为偶数，且其值要大于本代码所占用FLASH的大小+0X08000000)
-
-
-
-void storedata(void);
-void clearflash(void);
-void STMFLASH_Read(uint32_t ReadAddr,uint16_t *pBuffer,uint16_t NumToRead);
-void STMFLASH_Write(uint32_t WriteAddr,uint16_t *pBuffer,uint16_t NumToWrite);
-//结构体存储数组
-#pragma pack(1)
-typedef struct{
-	char deviceSecret[40];
-	char productKey[20];
-	char deviceName[20];
-	uint8_t    read_flag;//判断存flash是否成功，从flash读取值为1代表成功
-}Coefficient_Data;
- 
-#pragma pack()
-#endif
-
-

Drivers/Modules/Aliyuniot.c

@@ -1,324 +0,0 @@
-#include "stm32f10x.h"
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include "Aliyuniot.h"
-#include "CoAP_Util.h"
-#include "mbedtls_util.h"
-#include "cJSON.h"
-#include "Log_Module.h"
-#include "Common_Util.h"
-
-
-
-/** 阿里云连接参数 **/
-static char ProductKey[20] = "k0g9w9xRhhi";
-static char DeviceName[20] = "3738393435363738";
-static char DeviceSecret[40] = "9b59c75bc0044b0de06f3a3355ce94ee";
-
-static char ClientID[60];
-
-static uint16_t Port = 5682;
-static char Host[60];
-
-static uint32_t SeqOffset = 0;
-static char Random[20];
-static char Token[50];
-
-
-static void initClientIdAndHost(void);
-
-// 打印参数
-void aliyuniot_printf_params(void)
-{
-	Log_Printf("------aliyun start------\r\n");
-	Log_Printf("ProductKey=%s\r\n", ProductKey);
-	Log_Printf("DeviceName=%s\r\n", DeviceName);
-	Log_Printf("DeviceSecret=%s\r\n", DeviceSecret);
-	Log_Printf("Token=%s\r\n", Token);
-	Log_Printf("Random=%s\r\n", Random);
-	Log_Printf("SeqOffset=%d\r\n", SeqOffset);
-	Log_Printf("------aliyun end------\r\n");
-}
-
-// 获取host
-char * aliyuniot_get_host(void)
-{
-	initClientIdAndHost();
-	return Host;
-}
-
-
-// 获取port
-uint16_t aliyuniot_get_port(void)
-{
-	return Port;
-}
-
-// 判断是否认证
-uint8_t aliyuniot_is_authentication(void)
-{
-	if(strlen(Token) > 0) // 已认证
-	{
-		return 1;
-	}
-	else
-	{
-		return 0;
-	}
-}
-
-// 设置阿里云连接参数
-void aliyuniot_set_device_params(char * prodect_key, char * device_name, char * device_secret)
-{
-	memset(ProductKey, 0, sizeof(ProductKey));
-	strcpy(ProductKey, prodect_key);
-	memset(DeviceName, 0, sizeof(DeviceName));
-	strcpy(DeviceName, device_name);
-	memset(DeviceSecret, 0, sizeof(DeviceSecret));
-	strcpy(DeviceSecret, device_secret);
-}
-
-// 设置Token
-static void set_token(char * token)
-{
-	memset(Token, 0, sizeof(Token));
-	strcpy(Token, token);
-}
-static void set_random(char * random)
-{
-	memset(Random, 0, sizeof(Random));
-	strcpy(Random, random);
-}
-static void set_seqOffset(uint32_t seqOffset)
-{
-	SeqOffset = seqOffset;
-}
-void aliyuniot_set_device_token(char * token, char * random, uint32_t seqOffset)
-{
-	set_token(token);
-	set_random(random);
-	set_seqOffset(seqOffset);
-}
-
-// 初始化Host和clientID
-static void initClientIdAndHost(void)
-{
-	// 设置host
-	memset(Host, 0, sizeof(Host));
-	strcat(Host, ProductKey);
-	strcat(Host, ".coap.cn-shanghai.link.aliyuncs.com");
-	// 设置clientid
-	memset(ClientID, 0, sizeof(ClientID));
-	strcat(ClientID, ProductKey);
-	strcat(ClientID, "&");
-	strcat(ClientID, DeviceName);
-}
-
-// 拼接认证报文
-static char StrForSignature[100];
-static char sign[50];
-static uint8_t payload[256];
-void aliyuniot_get_auth_message(uint8_t * coap_message, uint16_t * coap_message_length)
-{
-	Log_Printf_Debug("<<STEP: 拼接认证报文\r\n");
-	SeqOffset = 888;
-	aliyuniot_printf_params();
-	// 先初始化clientID和Host
-	initClientIdAndHost();
-	// CoAP协议
-	CoAP_Init(coap_message);
-	CoAP_Set_T(0);
-	CoAP_Set_Code(2);
-	CoAP_Set_MessageID(SeqOffset);
-	// option
-	// host
-	CoAP_Set_Option_Str(3, Host);
-	// port
-	CoAP_Set_Option_Short(7, Port);
-	// path
-	CoAP_Set_Option_Str(11, "auth");
-	// content-format
-	CoAP_Set_Option_Short(12, 50);
-	// accept
-	CoAP_Set_Option_Short(17, 50);
-	
-	// 待签名数据
-	// 签名相关
-	memset(StrForSignature, 0, sizeof(StrForSignature));
-	sprintf(StrForSignature, "clientId%sdeviceName%sproductKey%sseq%d", ClientID, DeviceName, ProductKey, SeqOffset);
-//	Log_Printf_Debug("认证报文StrForSignature:\r\n%s\r\n", StrForSignature);
-	// 签名
-	memset(sign, 0, sizeof(sign));
-	utils_hmac_sha1_str(StrForSignature, strlen((char * )StrForSignature), sign, DeviceSecret, strlen(DeviceSecret));
-
-//	Log_Printf_Debug("签名sign:\r\n%s\r\n", sign);
-
-	// payload
-	memset(payload, 0, sizeof(payload));
-	sprintf((char * )payload, "{\"clientId\":\"%s\",\"signmethod\":\"hmacsha1\",\"sign\":\"%s\",\"productKey\":\"%s\",\"deviceName\":\"%s\",\"seq\":\"%d\"}", ClientID, sign, ProductKey, DeviceName, SeqOffset);
-	// 设置payload
-	CoAP_Set_Payload_Str((char *)payload);
-	
-	
-//	Log_Printf_Debug("payload:\r\n%s\r\n", payload);
-	
-	// 生成报文
-	* coap_message_length = CoAP_Get_Length();
-	Log_Printf_Debug("STEP: 拼接认证报文>>\r\n");
-}
-
-
-// 拼接数据报文
-// aes cbc
-static uint8_t aes_key[16] = {0};
-static char iv[] = "543yhjy97ae7fyfg";
-static char out[80];
-static char sha256_source[100];
-
-static char Rand2089[10] = {'\0'};
-static uint8_t Opt2089[20];
-void aliyuniot_get_data_message(uint8_t * data, uint8_t data_length, uint8_t * coap_message, uint16_t * coap_message_length)
-{
-	Log_Printf_Debug("<<STEP: 拼接数据报文\r\n");
-	aliyuniot_printf_params();
-	// 先初始化clientID和Host
-	initClientIdAndHost();
-
-//	Log_Printf_Debug("SeqOffset：%d\r\n", SeqOffset);
-	
-	// 获取密钥
-	memset(sha256_source, 0, sizeof(sha256_source));
-	snprintf(sha256_source, sizeof(sha256_source), "%s,%s" ,DeviceSecret ,Random);
-//	Log_Printf_Debug("sha256_source:\r\n%s\r\n", sha256_source);
-	memset(out, 0, sizeof(out));
-	utils_sha256(sha256_source, strlen(sha256_source), out);
-	
-//	Log_Printf_Debug("out:\r\n");
-//	Log_SendHex((uint8_t *)out, strlen(out));
-//	Log_Printf_Debug("\r\n");
-	
-	
-	memset(aes_key, 0, sizeof(aes_key));
-	memcpy(aes_key, out+8, 16); //获取key
-//	Log_Printf_Debug("aes_key:\r\n");
-//	Log_SendHex(aes_key, 16);
-//	Log_Printf_Debug("\r\n");
-	
-	// CoAP协议
-	CoAP_Init(coap_message);
-	CoAP_Set_T(0);
-	CoAP_Set_Code(2);
-	CoAP_Set_MessageID(++SeqOffset);
-	// option
-	// host
-	CoAP_Set_Option_Str(3, Host);
-	// port
-	CoAP_Set_Option_Short(7, Port);
-	// path
-	CoAP_Set_Option_Str(11, "topic");
-	CoAP_Set_Option_Str(11, "sys");
-	CoAP_Set_Option_Str(11, ProductKey);
-	CoAP_Set_Option_Str(11, DeviceName);
-	CoAP_Set_Option_Str(11, "thing");
-	CoAP_Set_Option_Str(11, "model");
-	CoAP_Set_Option_Str(11, "up_raw");
-	// content-format
-	CoAP_Set_Option_Short(12, 50);
-	// accept
-	CoAP_Set_Option_Short(17, 50);
-	// 2088
-	CoAP_Set_Option_Str(2088, Token);
-	// 2089
-	memset(Rand2089, 0, sizeof(Rand2089));
-	memset(Opt2089, 0, sizeof(Opt2089));
-	my_itoa(SeqOffset, Rand2089, 10);
-	int Opt2089_Length = utils_aes128_cbc_enc_with_length(aes_key, iv, (uint8_t *)Rand2089, strlen(Rand2089), Opt2089);
-	CoAP_Set_Option(2089,Opt2089_Length, Opt2089);
-	
-//	Log_Printf_Debug("Opt2089:\r\n");
-//	Log_SendHex(Opt2089, Opt2089_Length);
-//	Log_Printf_Debug("\r\n");
-	
-//	Log_Printf_Debug("data:\r\n");
-//	Log_SendHex(data, data_length);
-//	Log_Printf_Debug("\r\n");
-	// payload
-	memset(payload, 0, sizeof(payload));
-	int payload_length = utils_aes128_cbc_enc_with_length(aes_key, iv, data, data_length, payload);
-	
-	CoAP_Set_Payload(payload, payload_length);
-	
-//	Log_Printf_Debug("payload:\r\n");
-//	Log_SendHex(payload, payload_length);
-//	Log_Printf_Debug("\r\n");
-	
-	// 生成报文
-	* coap_message_length = CoAP_Get_Length();
-	Log_Printf_Debug("STEP: 拼接数据报文>>\r\n");
-}
-
-
-
-
-// 接收数据处理
-static uint8_t plaintext[256]; // 明文
-uint8_t aliyuniot_recv_data_handle(uint8_t * coap_message, uint16_t coap_message_length)
-{
-//	Log_Printf_Debug("coap_message(%d):\r\n", coap_message_length);
-//	Log_SendHex(coap_message, coap_message_length);
-//	Log_Printf_Debug("\r\n");
-	
-	memset(payload, 0, sizeof(payload));
-	uint16_t payload_length = CoAP_Get_Payload(coap_message, coap_message_length, payload);
-	
-	Log_Printf_Debug("payload长度: %d\r\n", payload_length);
-	
-	
-	
-	// 判断是认证返回，还是数据发送返回
-	if(payload_length == 0) // 无返回
-	{
-		// 清空Token，重新认证
-		memset(Token, '\0', sizeof(Token));
-		
-		return 0;
-	}
-	else if(payload[0] == '{' && payload[payload_length-1] == '}') // 认证返回
-	{
-		// 解析json
-		cJSON * cjson = cJSON_Parse((char * )payload);
-//		Log_Printf_Debug("plaintext(%d): %s\r\n",payload_length, payload);
-		if(cJSON_HasObjectItem(cjson, "random"))
-		{
-			char * random = cJSON_GetObjectItem(cjson, "random")->valuestring;
-			set_random(random);
-		}
-		if(cJSON_HasObjectItem(cjson, "seqOffset"))
-		{
-			uint16_t seqOffset = cJSON_GetObjectItem(cjson, "seqOffset")->valueint;
-			set_seqOffset(seqOffset);
-		}
-		if(cJSON_HasObjectItem(cjson, "token"))
-		{
-			char * token = cJSON_GetObjectItem(cjson, "token")->valuestring;
-			set_token(token);
-		}
-		cJSON_Delete(cjson);//清除结构体 
-		return 1;
-	}
-	else
-	{
-		// 数据发送成功返回
-		memset(plaintext, 0, sizeof(plaintext));
-		uint16_t plaintext_length = utils_aes128_cbc_dec(aes_key, iv, (char * )payload, payload_length, (char * )plaintext);
-		Log_Printf_Debug("\r\nplaintext(%d): %s\r\n",plaintext_length, (char *)plaintext);
-		return 2;
-	}
-}
-
-
-
-

Drivers/Modules/Aliyuniot.h

@@ -1,30 +0,0 @@
-#ifndef __ALIYUNIOT_H
-#define __ALIYUNIOT_H
-
-#include <stdint.h>
-
-// 打印参数
-void aliyuniot_printf_params(void);
-// 设置阿里云连接参数
-void aliyuniot_set_device_params(char * prodect_key, char * device_name, char * device_secret);
-// 设置Token
-void aliyuniot_set_device_token(char * token, char * random, uint32_t seqOffset);
-// 拼接认证报文
-void aliyuniot_get_auth_message(uint8_t * coap_message, uint16_t * coap_message_length);
-// 拼接数据报文
-void aliyuniot_get_data_message(uint8_t * data, uint8_t data_length, uint8_t * coap_message, uint16_t * coap_message_length);
-
-// 接收数据处理
-uint8_t aliyuniot_recv_data_handle(uint8_t * coap_message, uint16_t coap_message_length);
-
-
-// 判断是否认证
-uint8_t aliyuniot_is_authentication(void);
-
-
-// 获取host
-char * aliyuniot_get_host(void);
-// 获取port
-uint16_t aliyuniot_get_port(void);
-
-#endif

Drivers/Modules/At_Module.c

@@ -134,7 +134,7 @@ uint32_t AT_wait_time(void)
 	return time_get_delay(&timer);
 }
 // AT¼àÌý
-void AT_Handle()
+void AT_ResidueHandle(void)
 {
 	if(AT_Get_Status() == AT_Status_None)
 	{

Drivers/Modules/At_Module.h

@@ -30,7 +30,7 @@ void AT_Set_Status(enum AT_Status status);
 enum AT_Status AT_Get_Status(void);
 
 // AT¼àÌý
-void AT_Handle(void);
+void AT_ResidueHandle(void);
 
 
 

Drivers/Modules/Initialize.h

@@ -1,13 +1,38 @@
 #ifndef __INITIALIZE_H
 #define __INITIALIZE_H
 #include <stdint.h>
+#include "TypeDef.h"
+#include "Process_Control.h"
 
-enum Initialize_Result
+// 状态
+enum INITIALIZE_StatusEnum
 {
-	Initialize_Result_free, // 空闲
-	Initialize_Result_Busy, // 正在初始化
+	INITIALIZE_Status_None, // 空闲
+	INITIALIZE_Status_Being, // 正在进行
+	INITIALIZE_Status_Done, // 结束
 };
+// 结果
+enum INITIALIZE_ResultEnum
+{
+	INITIALIZE_Result_None, // 未知
+	INITIALIZE_Result_Success, // 成功
+	INITIALIZE_Result_Failure, // 失败
+};
+
+// 初始化诱因处理
+void INITIALIZE_TriggerHandle(void);
+
+// 重置
+enum EXECUTE_ResultEnum INITIALIZE_Reset(void);
+// 开始
+enum EXECUTE_ResultEnum INITIALIZE_Start(void);
+// 流程处理，放到循环里
+void INITIALIZE_ProcessHandle(void);
+// 获取状态
+enum INITIALIZE_StatusEnum INITIALIZE_GetStatus(void);
+// 获取结果
+enum INITIALIZE_ResultEnum INITIALIZE_GetResult(void);
+
+
 
-void Initialize_Handle(void);
-enum Initialize_Result get_initialize_status(void);
 #endif

Drivers/Modules/Regist.h

@@ -1,25 +1,35 @@
 #ifndef __REGIST_H
 #define __REGIST_H
 #include <stdint.h>
+#include "TypeDef.h"
+#include "Process_Control.h"
 
-enum Regist_Result
+// 注册状态
+enum REGIST_StatusEnum
 {
-	Regist_Result_None, // 未注册
-	Regist_Result_Success, // 注册成功
+	REGIST_Status_None, // 空闲
+	REGIST_Status_Being, // 正在注册
+	REGIST_Status_Done, // 注册结束
 };
 
-// 注册流程
-uint8_t regist_device_sync(void);
+enum REGIST_ResultEnum
+{
+	REGIST_Result_None, // 未知
+	REGIST_Result_Success, // 成功
+	REGIST_Result_Failure, // 失败
+};
+
+// 重置注册
+enum EXECUTE_ResultEnum REGIST_Reset(void);
+// 开始注册
+enum EXECUTE_ResultEnum REGIST_Start(void);
+// 注册流程处理，放到循环里
+void REGIST_ProcessHandle(void);
+// 获取注册状态
+enum REGIST_StatusEnum REGIST_GetStatus(void);
+// 获取注册结果
+enum REGIST_ResultEnum REGIST_GetResult(void);
 
-// 获取注册的结果。
-enum Regist_Result regist_get_result(void);
 
-// 获取阿里云参数ProductKey
-char * regist_get_aliyun_productKey(void);
-// 获取阿里云参数DeviceName
-char * regist_get_aliyun_deviceName(void);
-// 获取阿里云参数ProductKey
-char * regist_get_aliyun_deviceSecret(void);
-//获取注册状态
 
 #endif

Drivers/Modules/Tuoreniot.c

@@ -11,41 +11,64 @@
 #include "Common_Util.h"
 #include "ec800m.h"
 #include "cJSON.h"
+#include "FlashSetup.h"
+#include "Timer_Module.h"
+#include "CoAP_Util.h"
 
-unsigned char key[17]="tuorenzhinenghua";
+// 注册时用的密钥
+char regist_key[17]="tuorenzhinenghua";
+
+#if  PROD_ENV
+// 生产环境
+char * REGIST_SERVER = "iot.tuoren.com" ; //注册服务器地址
+uint16_t REGIST_PORT = 8888; //端口号
+#endif
+
+#if TEST_ENV
+// 开发环境
+char * REGIST_SERVER = "b21759p174.iok.la" ; //注册服务器地址
+uint16_t REGIST_PORT = 43097; //端口号
+#endif
+
+
+
+// 从flash中读取注册响应
+static void ReadRegistResponseFromFlash(void);
+// 将注册响应写入到flash中
+static void WriteRegistResponseToFlash(void);
 
-/**
-* 
-*注册参数信息打包
-*/
-void packRegistParams(uint8_t * pack_data, uint16_t * pack_data_length, struct Regist_Params_Struct registParams)
-{
-	sprintf((char *)(pack_data + 2), "{\"platform\":\"%s\",\"connectionType\":\"%s\",\"deviceId\":\"%s\"}", 
-	registParams.platform, registParams.networkProtocol, registParams.deviceId); // 拼接AT指令
-	Log_Printf_Debug("%s\r\n", (char *)(pack_data + 2));
-	
-	uint16_t datalen = utils_aes128_ECB_base64_enc_with_length((char *)key, (pack_data + 2));
-	
-	pack_data[0] = datalen>>8;//头2个字节赋值数据长度
-	pack_data[1] = datalen;
 
-	* pack_data_length = datalen + 2;
-}
 
 
 
+// 注册结果
+struct TUORENIOT_RegistResponseStruct regist_response = {
+	.version = 1
+};
+
+// 初始化clientID
+static char ClientID[60];
+static void InitClientId(void)
+{
+	// 设置clientid
+	memset(ClientID, 0, sizeof(ClientID));
+	strcat(ClientID, regist_response.productId);
+	strcat(ClientID, "&");
+	strcat(ClientID, regist_response.deviceId);
+}
+
 /**
 * 
 *注册数据解密
 */
-uint8_t analysisRegistData(uint8_t * regist_data, uint16_t regist_data_length, struct Regist_Result_Struct * registResult)
+uint8_t TUORENIOT_AnalysisRegistData(uint8_t * regist_data, uint16_t regist_data_length)
 {
-	Log_Printf_Debug("regist_data: \r\n");
-	Log_SendHex(regist_data, regist_data_length);
-	Log_Printf_Debug("\r\n");
+//	Log_Printf_Debug("regist_data: \r\n");
+//	Log_SendHex(regist_data, regist_data_length);
+//	Log_Printf_Debug("\r\n");
 
 	uint8_t result;
-	utils_aes128_ECB_base64_dec((char *)key,regist_data,regist_data_length);
+	utils_aes128_ECB_base64_dec(regist_key,regist_data,regist_data_length);
 	Log_Printf_Debug("解密数据(%d):%s\r\n", regist_data_length, (char *)regist_data);
 
 	cJSON *json = cJSON_Parse((char *)regist_data);
@@ -56,17 +79,24 @@ uint8_t analysisRegistData(uint8_t * regist_data, uint16_t regist_data_length, s
 	}
 	else if(cJSON_GetObjectItem(json, "code")->valueint == 200)
 	{
-		registResult->version = 1;
-		registResult->userId = 1000;
-		strcpy(registResult->networkProtocol, "CoAP");
-		strcpy(registResult->platform, "aliyun");
-		registResult->code = cJSON_GetObjectItem(json, "code")->valueint;
-		strcpy(registResult->deviceSecret, cJSON_GetObjectItem(json, "deviceSecret")->valuestring);
-		strcpy(registResult->productId, cJSON_GetObjectItem(json, "productKey")->valuestring);
-		strcpy(registResult->deviceId, cJSON_GetObjectItem(json, "deviceName")->valuestring);
-		strcpy(registResult->remoteAddress, cJSON_GetObjectItem(json, "address")->valuestring);
-		registResult->remotePort = atoi(cJSON_GetObjectItem(json, "port")->valuestring);
+		regist_response.version = 1;
+		regist_response.userId = 1000;
+		strcpy(regist_response.networkProtocol, "CoAP");
+		strcpy(regist_response.platform, "aliyun");
+		regist_response.code = cJSON_GetObjectItem(json, "code")->valueint;
+		strcpy(regist_response.deviceSecret, cJSON_GetObjectItem(json, "deviceSecret")->valuestring);
+		strcpy(regist_response.productId, cJSON_GetObjectItem(json, "productKey")->valuestring);
+		strcpy(regist_response.deviceId, cJSON_GetObjectItem(json, "deviceName")->valuestring);
+		// remoteAddress
+//		strcpy(regist_response.remoteAddress, cJSON_GetObjectItem(json, "address")->valuestring);
+		Log_Printf_Debug("sizeof(regist_response.remoteAddress): %d\r\n", sizeof(regist_response.remoteAddress));
+		memset(regist_response.remoteAddress, 0, sizeof(regist_response.remoteAddress));
+		strcat(regist_response.remoteAddress, regist_response.productId);
+		strcat(regist_response.remoteAddress, ".coap.cn-shanghai.link.aliyuncs.com");
+		regist_response.remotePort = atoi(cJSON_GetObjectItem(json, "port")->valuestring);
+		regist_response.wifiNumber = 3;
 		result = 1;
+		WriteRegistResponseToFlash();
 	}
 	else
 	{
@@ -78,34 +108,314 @@ uint8_t analysisRegistData(uint8_t * regist_data, uint16_t regist_data_length, s
 
 
 
+static uint32_t SeqOffset = 0;
+static char Random[20];
+static char Token[50];
+
+// 判断是否认证
+uint8_t TUORENIOT_IsAuthentication(void)
+{
+	if(strlen(Token) > 0) // 已认证
+	{
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+
+
+// 拼接认证报文
+
+static char StrForSignature[100];
+static char sign[50];
+static uint8_t payload[256];
+void TUORENIOT_PackAuthMessage(uint8_t * coap_message, uint16_t * coap_message_length)
+{
+//	Log_Printf_Debug("<<STEP: 拼接认证报文\r\n");
+//	TUORENIOT_PrintfRegistResponseStruct();
+	SeqOffset = 888;
+	// 初始化clientId
+	InitClientId();
+	// CoAP协议
+	CoAP_Init(coap_message);
+	CoAP_Set_T(0);
+	CoAP_Set_Code(2);
+	CoAP_Set_MessageID(SeqOffset);
+	// option
+	// host
+	CoAP_Set_Option_Str(3, regist_response.remoteAddress);
+	// port
+	CoAP_Set_Option_Short(7, regist_response.remotePort);
+	// path
+	CoAP_Set_Option_Str(11, "auth");
+	// content-format
+	CoAP_Set_Option_Short(12, 50);
+	// accept
+	CoAP_Set_Option_Short(17, 50);
+	
+	// 待签名数据
+	// 签名相关
+	memset(StrForSignature, 0, sizeof(StrForSignature));
+	sprintf(StrForSignature, "clientId%sdeviceName%sproductKey%sseq%d", ClientID, regist_response.deviceId,regist_response.productId, SeqOffset);
+//	Log_Printf_Debug("认证报文StrForSignature:\r\n%s\r\n", StrForSignature);
+	// 签名
+	memset(sign, 0, sizeof(sign));
+	utils_hmac_sha1_str(StrForSignature, strlen((char * )StrForSignature), sign, regist_response.deviceSecret, strlen(regist_response.deviceSecret));
+
+//	Log_Printf_Debug("签名sign:\r\n%s\r\n", sign);
+
+	// payload
+	memset(payload, 0, sizeof(payload));
+	sprintf((char * )payload, "{\"clientId\":\"%s\",\"signmethod\":\"hmacsha1\",\"sign\":\"%s\",\"productKey\":\"%s\",\"deviceName\":\"%s\",\"seq\":\"%d\"}", ClientID, sign, regist_response.productId, regist_response.deviceId, SeqOffset);
+	// 设置payload
+	CoAP_Set_Payload_Str((char *)payload);
+	
+	
+//	Log_Printf_Debug("payload:\r\n%s\r\n", payload);
+	
+	// 生成报文
+	* coap_message_length = CoAP_Get_Length();
+//	Log_Printf_Debug("STEP: 拼接认证报文>>\r\n");
+}
+
+
+// 拼接数据报文
+// aes cbc
+
+static uint8_t aes_key[16] = {0};
+static char iv[] = "543yhjy97ae7fyfg";
+static char out[80];
+static char sha256_source[100];
+
+static char Rand2089[10] = {'\0'};
+static uint8_t Opt2089[20];
+void TUORENIOT_PackDataMessage(uint8_t * data, uint8_t data_length, uint8_t * coap_message, uint16_t * coap_message_length)
+{
+//	Log_Printf_Debug("<<STEP: 拼接数据报文\r\n");
+	// 初始化clientId
+	InitClientId();
+
+//	Log_Printf_Debug("SeqOffset：%d\r\n", SeqOffset);
+	
+	// 获取密钥
+	memset(sha256_source, 0, sizeof(sha256_source));
+	snprintf(sha256_source, sizeof(sha256_source), "%s,%s" ,regist_response.deviceSecret ,Random);
+//	Log_Printf_Debug("sha256_source:\r\n%s\r\n", sha256_source);
+	memset(out, 0, sizeof(out));
+	utils_sha256(sha256_source, strlen(sha256_source), out);
+	
+//	Log_Printf_Debug("out:\r\n");
+//	Log_SendHex((uint8_t *)out, strlen(out));
+//	Log_Printf_Debug("\r\n");
+	
+	
+	memset(aes_key, 0, sizeof(aes_key));
+	memcpy(aes_key, out+8, 16); //获取key
+//	Log_Printf_Debug("aes_key:\r\n");
+//	Log_SendHex(aes_key, 16);
+//	Log_Printf_Debug("\r\n");
+	
+	// CoAP协议
+	CoAP_Init(coap_message);
+	CoAP_Set_T(0);
+	CoAP_Set_Code(2);
+	CoAP_Set_MessageID(++SeqOffset);
+	// option
+	// host
+	CoAP_Set_Option_Str(3, regist_response.remoteAddress);
+	// port
+	CoAP_Set_Option_Short(7, regist_response.remotePort);
+	// path
+	CoAP_Set_Option_Str(11, "topic");
+	CoAP_Set_Option_Str(11, "sys");
+	CoAP_Set_Option_Str(11, regist_response.productId);
+	CoAP_Set_Option_Str(11, regist_response.deviceId);
+	CoAP_Set_Option_Str(11, "thing");
+	CoAP_Set_Option_Str(11, "model");
+	CoAP_Set_Option_Str(11, "up_raw");
+	// content-format
+	CoAP_Set_Option_Short(12, 50);
+	// accept
+	CoAP_Set_Option_Short(17, 50);
+	// 2088
+	CoAP_Set_Option_Str(2088, Token);
+	// 2089
+	memset(Rand2089, 0, sizeof(Rand2089));
+	memset(Opt2089, 0, sizeof(Opt2089));
+	my_itoa(SeqOffset, Rand2089, 10);
+	int Opt2089_Length = utils_aes128_cbc_enc_with_length(aes_key, iv, (uint8_t *)Rand2089, strlen(Rand2089), Opt2089);
+	CoAP_Set_Option(2089,Opt2089_Length, Opt2089);
+	
+//	Log_Printf_Debug("Opt2089:\r\n");
+//	Log_SendHex(Opt2089, Opt2089_Length);
+//	Log_Printf_Debug("\r\n");
+	
+//	Log_Printf_Debug("data:\r\n");
+//	Log_SendHex(data, data_length);
+//	Log_Printf_Debug("\r\n");
+	// payload
+	memset(payload, 0, sizeof(payload));
+	int payload_length = utils_aes128_cbc_enc_with_length(aes_key, iv, data, data_length, payload);
+	
+	CoAP_Set_Payload(payload, payload_length);
+	
+//	Log_Printf_Debug("payload:\r\n");
+//	Log_SendHex(payload, payload_length);
+//	Log_Printf_Debug("\r\n");
+	
+	// 生成报文
+	* coap_message_length = CoAP_Get_Length();
+//	Log_Printf_Debug("STEP: 拼接数据报文>>\r\n");
+}
+
+
+
+// 设置Token
+static void set_token(char * token)
+{
+	memset(Token, 0, sizeof(Token));
+	strcpy(Token, token);
+}
+static void set_random(char * random)
+{
+	memset(Random, 0, sizeof(Random));
+	strcpy(Random, random);
+}
+static void set_seqOffset(uint32_t seqOffset)
+{
+	SeqOffset = seqOffset;
+}
+// 接收数据处理
+static uint8_t plaintext[256]; // 明文
+uint8_t TUORENIOT_AnalysisMessage(uint8_t * coap_message, uint16_t coap_message_length)
+{
+//	Log_Printf_Debug("coap_message(%d):\r\n", coap_message_length);
+//	Log_SendHex(coap_message, coap_message_length);
+//	Log_Printf_Debug("\r\n");
+	
+	memset(payload, 0, sizeof(payload));
+	uint16_t payload_length = CoAP_Get_Payload(coap_message, coap_message_length, payload);
+	
+	Log_Printf_Debug("payload长度: %d\r\n", payload_length);
+	
+	// 判断是认证返回，还是数据发送返回
+	if(payload_length == 0) // 无返回
+	{
+		// 清空Token，重新认证
+		memset(Token, '\0', sizeof(Token));
+		
+		return 0;
+	}
+	else if(payload[0] == '{' && payload[payload_length-1] == '}') // 认证返回
+	{
+		// 解析json
+		cJSON * cjson = cJSON_Parse((char * )payload);
+//		Log_Printf_Debug("plaintext(%d): %s\r\n",payload_length, payload);
+		if(cJSON_HasObjectItem(cjson, "random"))
+		{
+			char * random = cJSON_GetObjectItem(cjson, "random")->valuestring;
+			set_random(random);
+		}
+		if(cJSON_HasObjectItem(cjson, "seqOffset"))
+		{
+			uint16_t seqOffset = cJSON_GetObjectItem(cjson, "seqOffset")->valueint;
+			set_seqOffset(seqOffset);
+		}
+		if(cJSON_HasObjectItem(cjson, "token"))
+		{
+			char * token = cJSON_GetObjectItem(cjson, "token")->valuestring;
+			set_token(token);
+		}
+		cJSON_Delete(cjson);//清除结构体 
+		return 1;
+	}
+	else
+	{
+		// 数据发送成功返回
+		memset(plaintext, 0, sizeof(plaintext));
+		uint16_t plaintext_length = utils_aes128_cbc_dec(aes_key, iv, (char * )payload, payload_length, (char * )plaintext);
+		Log_Printf_Debug("\r\nplaintext(%d): %s\r\n",plaintext_length, (char *)plaintext);
+		return 2;
+	}
+}
+
+
+
 
-void printf_regist_param_struct(struct Regist_Params_Struct regist_params_struct)
+void TUORENIOT_PrintfRegistRequestStruct(struct TUORENIOT_RegistRequestStruct * regist_params_struct)
 {
 	Log_Printf("------print regist params start------\r\n");
-	Log_Printf("version=%d\r\n", regist_params_struct.version);
-	Log_Printf("networkType=%s\r\n", regist_params_struct.networkType);
-	Log_Printf("networkProtocol=%s\r\n", regist_params_struct.networkProtocol);
-	Log_Printf("deviceId=%s\r\n", regist_params_struct.deviceId);
-	Log_Printf("platform=%s\r\n", regist_params_struct.platform);
-	Log_Printf("userId=%d\r\n", regist_params_struct.userId);
+	Log_Printf("version=%d\r\n", regist_params_struct->version);
+	Log_Printf("networkType=%s\r\n", regist_params_struct->networkType);
+	Log_Printf("networkProtocol=%s\r\n", regist_params_struct->networkProtocol);
+	Log_Printf("deviceId=%s\r\n", regist_params_struct->deviceId);
+	Log_Printf("platform=%s\r\n", regist_params_struct->platform);
+	Log_Printf("userId=%d\r\n", regist_params_struct->userId);
 	Log_Printf("------print regist params end------\r\n");
 }
 
 
-void printf_regist_result_struct(struct Regist_Result_Struct regist_result_struct)
+void TUORENIOT_PrintfRegistResponseStruct(void)
 {
 	Log_Printf("------print regist result start------\r\n");
-	Log_Printf("code=%d\r\n", regist_result_struct.code);
-	Log_Printf("version=%d\r\n", regist_result_struct.version);
-	Log_Printf("networkProtocol=%s\r\n", regist_result_struct.networkProtocol);
-	Log_Printf("platform=%s\r\n", regist_result_struct.platform);
-	Log_Printf("deviceId=%s\r\n", regist_result_struct.deviceId);
-	Log_Printf("deviceSecret=%s\r\n", regist_result_struct.deviceSecret);
-	Log_Printf("remoteAddress=%s\r\n", regist_result_struct.remoteAddress);
-	Log_Printf("remotePort=%d\r\n", regist_result_struct.remotePort);
-	Log_Printf("productId=%s\r\n", regist_result_struct.productId);
-	Log_Printf("userId=%d\r\n", regist_result_struct.userId);
+	Log_Printf("code=%d\r\n", regist_response.code);
+	Log_Printf("version=%d\r\n", regist_response.version);
+	Log_Printf("networkProtocol=%s\r\n", regist_response.networkProtocol);
+	Log_Printf("platform=%s\r\n", regist_response.platform);
+	Log_Printf("deviceId=%s\r\n", regist_response.deviceId);
+	Log_Printf("deviceSecret=%s\r\n", regist_response.deviceSecret);
+	Log_Printf("remoteAddress=%s\r\n", regist_response.remoteAddress);
+	Log_Printf("remotePort=%d\r\n", regist_response.remotePort);
+	Log_Printf("productId=%s\r\n", regist_response.productId);
+	Log_Printf("userId=%d\r\n", regist_response.userId);
+	Log_Printf("wifiNumber=%d\r\n", regist_response.wifiNumber);
 	Log_Printf("------print regist result end------\r\n");
 }
 
 
+
+// 初始化
+void TUORENIOT_Init(void)
+{
+	// 从flash中读取注册结果
+	ReadRegistResponseFromFlash();
+}
+
+
+// 从flash中读取注册响应
+static void ReadRegistResponseFromFlash(void)
+{
+	Log_Printf_Debug("sizeof(regist_result): %d\r\n", sizeof(regist_response));
+	//读取flash
+	Log_Printf_Debug("读取前code：%d\r\n", regist_response.code);
+	Log_Printf_Debug("sizeof(regist_result): %d\r\n", sizeof(regist_response));
+	FlashReadOperate((uint8_t*)&regist_response, sizeof(regist_response), FLASH_SAVE_ADDR);
+	Log_Printf_Debug("读取后code：%d\r\n", regist_response.code);
+	if(regist_response.code == 200)
+	{
+		TUORENIOT_PrintfRegistResponseStruct();
+	}
+}
+
+// 将注册响应写入到flash中
+static void WriteRegistResponseToFlash(void)
+{
+	FlashWriteOperate((uint8_t*)&regist_response, sizeof(regist_response), FLASH_SAVE_ADDR);
+	regist_response.code = 0;
+	Log_Printf_Debug("写入数据完成\r\n");
+	FlashReadOperate((uint8_t*)&regist_response, sizeof(regist_response), FLASH_SAVE_ADDR);
+	TUORENIOT_PrintfRegistResponseStruct();
+}
+
+
+// 获取code
+uint8_t TUORENIOT_GetCodeOfRegistResponse(void)
+{
+	return regist_response.code;
+}
+
+
+

Drivers/Modules/Tuoreniot.h

@@ -3,7 +3,13 @@
 
 #include <stdint.h>
 
-struct Regist_Params_Struct
+
+extern char regist_key[17];
+extern char * REGIST_SERVER;
+extern uint16_t REGIST_PORT;
+extern struct TUORENIOT_RegistResponseStruct regist_response;
+
+struct TUORENIOT_RegistRequestStruct
 {
 	uint8_t version;
 	char platform[20];
@@ -14,7 +20,12 @@ struct Regist_Params_Struct
 	uint16_t userId;
 };
 
-struct Regist_Result_Struct
+struct Wifi_Struct
+{
+	char wifiName[50];
+	char wifiPassword[30];
+};
+struct TUORENIOT_RegistResponseStruct
 {
 	uint8_t code;
 	uint8_t version;
@@ -27,15 +38,38 @@ struct Regist_Result_Struct
 	char deviceId[20];
 	uint16_t userId;
 	char deviceSecret[50];
+	uint8_t wifiNumber;
+	struct Wifi_Struct wifi[10];
 };
 
+// 初始化
+void TUORENIOT_Init(void);
+
+// 打包注册请求数据
+void TUORENIOT_PackRegistRequest(uint8_t * pack_data, uint16_t * pack_data_length, struct TUORENIOT_RegistRequestStruct * registParams);
+// 解析注册返回的数据
+uint8_t TUORENIOT_AnalysisRegistData(uint8_t * regist_data, uint16_t regist_data_length);
+
+
+// 判断是否认证
+uint8_t TUORENIOT_IsAuthentication(void);
+// 打包认证报文
+void TUORENIOT_PackAuthMessage(uint8_t * coap_message, uint16_t * coap_message_length);
+// 打包数据报文
+void TUORENIOT_PackDataMessage(uint8_t * data, uint8_t data_length, uint8_t * coap_message, uint16_t * coap_message_length);
+// 接收数据处理
+uint8_t TUORENIOT_AnalysisMessage(uint8_t * coap_message, uint16_t coap_message_length);
 
-void packRegistParams(uint8_t * pack_data, uint16_t * pack_data_length, struct Regist_Params_Struct registParams);
+// 打印注册请求
+void TUORENIOT_PrintfRegistRequestStruct(struct TUORENIOT_RegistRequestStruct * regist_params_struct);
+// 打印返回的结果
+void TUORENIOT_PrintfRegistResponseStruct(void);
 
-uint8_t analysisRegistData(uint8_t * regist_data, uint16_t regist_data_length, struct Regist_Result_Struct * registResult);
 
-void printf_regist_param_struct(struct Regist_Params_Struct regist_params_struct);
+// 从flash中读取注册响应
+void TUORENIOT_ReadRegistResponseFromFlash(void);
+// 获取code
+uint8_t TUORENIOT_GetCodeOfRegistResponse(void);
 
-void printf_regist_result_struct(struct Regist_Result_Struct regist_result_struct);
 
 #endif

Drivers/Modules/UDP_Client.h

@@ -1,30 +1,43 @@
 #ifndef __UDP_CLIENT5_H
 #define __UDP_CLIENT5_H
 #include <stdint.h>
+#include "TypeDef.h"
+#include "Process_Control.h"
 
-enum Client_Status{
-	Client_Status_None, // 空闲
-	Client_Status_Sending, // 正在发送
-	Client_Status_Success, // 发送成功
-	Client_Status_Failure, // 发送失败
+// 测试模式
+extern uint8_t UDPCLIENT_TestModeFlag;
+
+// 状态
+enum UDPCLIENT_StatusEnum
+{
+	UDPCLIENT_Status_None, // 空闲
+	UDPCLIENT_Status_Being, // 进行中
+	UDPCLIENT_Status_Done, // 结束
 };
-struct UDP_Client_Struct{
-	enum Client_Status status; // 状态
-	char info[200]; // 备注信息
+// 结果
+enum UDPCLIENT_ResultEnum
+{
+	UDPCLIENT_Result_None, // 未知
+	UDPCLIENT_Result_Success, // 成功
+	UDPCLIENT_Result_Failure, // 失败
 };
 
+// 重置
+enum EXECUTE_ResultEnum UDPCLIENT_Reset(void);
+// 开始
+enum EXECUTE_ResultEnum UDPCLIENT_Start(void);
+// 流程处理，放到循环里
+void UDPCLIENT_ProcessHandle(void);
 // 获取状态
-enum Client_Status UDP_Client_Status(void);
-// 发送数据
-void UDP_Client_Send(uint8_t test_switch);
-// 清除
-void UDP_Client_Clear(void);
-// 处理流程
-void UDP_Client_Handle(void);
-// 获取备注
-char * UDP_Client_Get_Info(void);
+enum UDPCLIENT_StatusEnum UDPCLIENT_GetStatus(void);
+// 获取结果
+enum UDPCLIENT_ResultEnum UDPCLIENT_GetResult(void);
+
 
 // 查询信号质量
-void Query_Signal(int * RSRP, int * RSRQ, int * RSSI, int * SINR);
+void UDPCLIENT_QuerySignal(int * RSRP, int * RSRQ, int * RSSI, int * SINR);
+
+
+
 
 #endif

Drivers/Modules/bc260y/BC260Y_UDP_Client5.c

@@ -1,20 +1,6 @@
 #include "CONFIG.h"
 #if  BC260Y
-/**
-  ******************************************************************************
-  * 版   本       ：V1.0.0
-  * 作   者       ：liuyanbin,helomgxiang
-  * 版权所有，盗版必究。
-  * Copyright(C) All rights reserved
-  ******************************************************************************
-  *                             历史记录
-  *     序号      版本        变更内容          作者              日期
-  *      1        V0.0.1      实现数据发送功能      何龙翔          2023/12/10
-  *      2        V0.0.2      实现NB数据发送功能      刘艳斌          2024/1/10
-  *      3        V0.0.3      整合4g和nb      刘艳斌          2024/1/24
-  *
-  ******************************************************************************
-  */
+
 
 #include "stm32f10x.h"
 #include <stdio.h>
@@ -33,8 +19,56 @@
 #include "Pump_Dicts_Util.h"
 #include "Regist.h"
 #include "PumpBusiness.h"
-#include "aliyuniot.h"
 #include "Initialize.h"
+#include "Tuoreniot.h"
+
+// 测试模式
+uint8_t UDPCLIENT_TestModeFlag = 0;
+
+// socket ID
+static uint8_t connectID = 1;
+
+// coap报文
+static uint8_t coap_message[512]; 
+static uint16_t coap_message_length = 0;
+
+// 待发送数据的地址和长度
+static uint8_t data[128];
+static uint16_t data_length;
+
+
+// 信号值
+static struct Signal
+{
+	int RSRP;
+	int RSRQ; 
+	int RSSI; 
+	int SINR;
+} signal = {
+	.RSRP = 99,
+	.RSRQ = 99,
+	.RSSI = 99,
+	.SINR = 99,
+};
+// 查询信号质量
+void UDPCLIENT_QuerySignal(int * RSRP, int * RSRQ, int * RSSI, int * SINR)
+{
+	*RSRP = signal.RSRP;
+	*RSRQ = signal.RSRQ;
+	*RSSI = signal.RSSI;
+	*SINR = signal.SINR;
+}
+
+
+// 函数声明
+static void UDPCLIENT_Process(void); // 流程
+static void UDPCLIENT_SetStatus(enum UDPCLIENT_StatusEnum status); // 设置状态
+static void UDPCLIENT_SetResult(enum UDPCLIENT_ResultEnum result); // 设置结果
+
+static void goto_start(void); // 开始
+static void goto_success(void); // 成功
+static void goto_failure(char * _info); // 失败
+static void goto_finish(void); // 结束
 
 // 流程
 enum Step{
@@ -83,167 +117,137 @@ enum Step{
 	STEP_QUERY_CFUN_DNS, // 设置完dns后，查询功能模式
 	STEP_SET_CFUN_0_DNS, // 设置完dns后，设置最小功能模式
 };
-// 当前
-static enum Step step = STEP_NONE;
-// 下一步
-static enum Step next_step = STEP_NONE;
-// 客户端5
-struct UDP_Client_Struct client = {
-	.status = Client_Status_None,
-};
 
 
-// socket ID
-static uint8_t connectID = 1;
 
-
-// coap报文
-static uint8_t coap_message[512]; 
-static uint16_t coap_message_length = 0;
-
-
-// 泵参数
-extern struct Pump_Params pump_params;
-// 待发送数据的地址和长度
-static uint8_t databuff[128];
-static uint16_t data_length;
-
-static uint8_t test_flag=0;
-
-
-// 计时相关的变量
-static struct TIMER_Struct timer;
-uint32_t wait_time = 10;
-// 信号值
-static struct Signal
+// 步骤跳转时的监听
+static uint8_t STEP_JOIN_AUTH_MESSAGE_times = 0; // 认证的次数
+static uint8_t STEP_SET_CFUN_1_times = 0; // 全功能模式的次数
+static void initialize()
 {
-	int RSRP;
-	int RSRQ; 
-	int RSSI; 
-	int SINR;
-} signal = {
-	.RSRP = 99,
-	.RSRQ = 99,
-	.RSSI = 99,
-	.SINR = 99,
-};
-
-void Query_Signal(int * RSRP, int * RSRQ, int * RSSI, int * SINR)
+	STEP_JOIN_AUTH_MESSAGE_times = 0;
+	STEP_SET_CFUN_1_times = 0;
+}	
+static uint16_t goto_step_event(uint16_t ns)
 {
-	*RSRP = signal.RSRP;
-	*RSRQ = signal.RSRQ;
-	*RSSI = signal.RSSI;
-	*SINR = signal.SINR;
+	// 重置bc260y状态
+	bc260y.reset();
+	
+	// 流程控制
+	uint16_t step = ns;
+	if(ns == STEP_JOIN_AUTH_MESSAGE && STEP_JOIN_AUTH_MESSAGE_times++ >= 1)
+	{
+		goto_failure("认证次数过多");
+		step = STEP_FAILURE;
+	}
+	else if(ns == STEP_SET_CFUN_1 && STEP_SET_CFUN_1_times++ >= 2)
+	{
+		goto_failure("重新联网次数过多");
+		step = STEP_FAILURE;
+	}
+	return step;
 }
 
-// 初始化
-void UDP_Client_Init(void)
+// 流程控制
+static struct PCTRL_Struct pctrl = {
+	.current_step = STEP_FINISH,
+	.next_step = STEP_FINISH,
+	.step_wait = STEP_WAIT,
+	.goto_step_listener = goto_step_event,
+};
+
+
+// 备注
+static char info[40];
+// 开始
+static void goto_start(void)
 {
-//   aliyuniot_set_device_params("he1fAihB9M9", "123456", "76ef28342ee0760d781af138095b8fe4");
-   aliyuniot_set_device_params(regist_get_aliyun_productKey(),regist_get_aliyun_deviceName(),regist_get_aliyun_deviceSecret());
-//	aliyuniot_set_device_params(flashdata.productKey,flashdata.deviceName,flashdata.deviceSecret);
-	// 设置host
+	initialize();
+	PCTRL_GotoStep(&pctrl, STEP_START, "开始");
 }
-// 声明函数。步骤跳转
-void goto_step(enum Step ns);
-// 发送流程
-void UDP_Client_Handle(void);
-// 发送数据
-void UDP_Client_Send(uint8_t test_switch)
+// 成功
+static void goto_success(void)
 {
-	test_flag=test_switch;
-	if(step == STEP_NONE)
-	{
-		// 初始化
-		UDP_Client_Init();
-		// 正在发送
-		client.status = Client_Status_Sending;
-		// 流程开始
-		goto_step(STEP_START);
-	}
+	UDPCLIENT_SetResult(UDPCLIENT_Result_Success);
+	PCTRL_GotoStep(&pctrl, STEP_SUCCESS, "成功");
 }
-// 获取状态
-enum Client_Status UDP_Client_Status(void)
+// 失败
+static void goto_failure(char * _info)
 {
-	if(client.status == Client_Status_None)
-	{
-		return client.status;
-	}
-	else if(step == STEP_FINISH)
-	{
-		return client.status;
-	}
-	else
-	{
-		return Client_Status_Sending;
-	}
+	UDPCLIENT_SetResult(UDPCLIENT_Result_Failure);
+	memset(info, 0, sizeof(info));
+	strcpy(info, _info);
+	PCTRL_GotoStep(&pctrl, STEP_FAILURE, "失败");
+	Log_Printf_Debug("info：%s！\r\n", info);
 }
-
-// 获取备注
-char * UDP_Client_Get_Info(void)
+// 结束
+static void goto_finish(void)
 {
-	return client.info;
+	UDPCLIENT_SetStatus(UDPCLIENT_Status_Done);
+	PCTRL_GotoStep(&pctrl, STEP_FINISH, "结束");
 }
 
-// 清除
-void UDP_Client_Clear(void)
+
+
+// 状态
+static enum UDPCLIENT_StatusEnum udpclient_status = UDPCLIENT_Status_None;
+// 结果
+static enum UDPCLIENT_ResultEnum udpclient_result = UDPCLIENT_Result_None;
+// 设置状态
+static void UDPCLIENT_SetStatus(enum UDPCLIENT_StatusEnum status)
 {
-	// 流程置空
-	goto_step(STEP_NONE);
-	// 空闲
-	client.status = Client_Status_None;
+	udpclient_status = status;
 }
-
-// 直接跳转到下一步
-static void goto_step(enum Step ns)
+// 获取状态
+enum UDPCLIENT_StatusEnum UDPCLIENT_GetStatus(void)
 {
-	// 重置bc260y状态
-	bc260y.reset();
-	step = ns; 
+	return udpclient_status;
 }
-
-// 先等待再跳转到下一步
-static void goto_step_wait(enum Step ns, uint32_t t)
+// 设置结果
+static void UDPCLIENT_SetResult(enum UDPCLIENT_ResultEnum result)
 {
-	goto_step(STEP_WAIT); // 等待
-	wait_time = t;
-	next_step = ns; // 等待之后跳转
+	udpclient_result = result;
 }
-
-// 只等待，等待之后返回原来的步骤
-static void goto_wait(uint32_t t)
+// 获取结果
+enum UDPCLIENT_ResultEnum UDPCLIENT_GetResult(void)
 {
-	goto_step_wait(step, t);
+	return udpclient_result;
 }
-
-// 失败
-static void goto_failure(char * info)
+// 重置
+enum EXECUTE_ResultEnum UDPCLIENT_Reset(void)
 {
-	Log_Printf_Debug("STEP: 数据发送失败,%s\r\n", info);
-	client.status = Client_Status_Failure;
-	strcpy(client.info, info);
-	goto_step(STEP_FAILURE);
+	if(UDPCLIENT_GetStatus() == UDPCLIENT_Status_Being)
+	{
+		Log_Printf_Debug("发送流程重置错误！\r\n");
+		return EXECUTE_Result_Failure;
+	}
+	UDPCLIENT_SetStatus(UDPCLIENT_Status_None);
+	UDPCLIENT_SetResult(UDPCLIENT_Result_None);
+	return EXECUTE_Result_Success;
 }
-
-// 成功
-static void goto_success(char * info)
+// 开始
+enum EXECUTE_ResultEnum UDPCLIENT_Start(void)
 {
-	Log_Printf_Debug("STEP: 数据发送成功,%s\r\n", info);
-	client.status = Client_Status_Success;
-	strcpy(client.info, info);
-	goto_step(STEP_SUCCESS);
+	UDPCLIENT_Reset();
+	if(UDPCLIENT_GetStatus() != UDPCLIENT_Status_None)
+	{
+		Log_Printf_Debug("发送流程启动错误！\r\n");
+		return EXECUTE_Result_Failure;
+	}
+	goto_start();
+	UDPCLIENT_SetStatus(UDPCLIENT_Status_Being);
+	return EXECUTE_Result_Success;
 }
-
-// 等待
-static void wait(void)
+// 流程处理，放到大循环里
+void UDPCLIENT_ProcessHandle(void)
 {
-	if(time_get_delay(&timer) > wait_time)
+	if(UDPCLIENT_GetStatus() == UDPCLIENT_Status_Being)
 	{
-		goto_step(next_step); // 进入下一步
-		time_clear(&timer);
+		UDPCLIENT_Process();
 	}
 }
 
+
 //// 发送数据的逻辑
 static enum Result result = Result_None;
 static uint8_t cgreg_n; 
@@ -251,46 +255,30 @@ static uint8_t cgreg_stat;
 static uint16_t cgreg_lac; 
 static uint32_t cgreg_ci;
 //static uint8_t query_cgreg_times = 0; // 查询网络状态的次数
-static uint8_t auth_times = 0; // 认证次数
 static uint16_t socket_err = 0;
-static uint8_t auth_or_data = 0;
-static enum Initialize_Result InitializeResult;
 
 // dns
 static char pridnsaddr[20];
 
-static uint8_t resend_counter = 0;//nb失败重发标志
 static uint8_t cfun_mode = 0;
 static uint8_t connectstate = 0;
 
 // 开启回显的标志
-static uint8_t qisde_flag = 0; // 0：未开启；1：开启。
-void UDP_Client_Handle(void)
+static void UDPCLIENT_Process(void)
 {
-	// 如果模块正在初始化，直接返回发送失败
-	InitializeResult = get_initialize_status();
-	if(InitializeResult==Initialize_Result_Busy)
-	{
-		goto_failure("模块正在初始化");
-		goto_step(STEP_FINISH);
-	}
 	// 流程
-	switch(step)
+	switch(pctrl.current_step)
 	{
 		case STEP_NONE: // 空闲
 			break;
 		case STEP_START: // 开始
-			Log_Printf_Debug("\r\n>>发送流程开始\r\n");
-			auth_times = 0; // 认证次数
-			goto_step(STEP_EXIT_SLEEP);
-			Log_Printf_Debug("\r\n>>退出休眠\r\n");
+			PCTRL_GotoStep(&pctrl, STEP_EXIT_SLEEP, "退出休眠");
 			break;
 		case STEP_EXIT_SLEEP: // 退出休眠
 			result = bc260y.exit_sleep_2();
 		  if(result == Result_Success)
 			{
-				goto_step(STEP_SET_QISDE_1);
-				Log_Printf_Debug("\r\n>>开启回显\r\n");
+				PCTRL_GotoStep(&pctrl, STEP_SET_QISDE_1, "开启回显");
 			}
 			else if(result == Result_Failed)
 			{
@@ -301,8 +289,7 @@ void UDP_Client_Handle(void)
 			result = bc260y.set_qisde(1);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_SET_SLEEP);
-				Log_Printf_Debug("\r\n>>设置休眠模式\r\n");
+				PCTRL_GotoStep(&pctrl, STEP_SET_SLEEP, "设置休眠模式");
 			}
 			else if(result == Result_Failed)
 			{
@@ -313,8 +300,7 @@ void UDP_Client_Handle(void)
 			result = bc260y.set_sleep(2);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_DATAFORMAT);
-				Log_Printf_Debug("\r\n>>配置发送格式\r\n");
+				PCTRL_GotoStep(&pctrl, STEP_DATAFORMAT, "配置发送格式");
 			}
 			else if(result == Result_Failed)
 			{
@@ -325,9 +311,7 @@ void UDP_Client_Handle(void)
 			result = bc260y.dataformat(1);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_QUERY_CFUN);
-				Log_Printf_Debug("\r\n>>查询功能模式\r\n");
-				memset(pridnsaddr, 0, sizeof(pridnsaddr));
+				PCTRL_GotoStep(&pctrl, STEP_QUERY_CFUN, "查询功能模式");
 			}
 			else if(result == Result_Failed)
 			{
@@ -340,13 +324,12 @@ void UDP_Client_Handle(void)
 			{
 				if(cfun_mode == 0)
 				{
-					goto_step(STEP_SET_CFUN_1);
-					Log_Printf_Debug("\r\n>>设置全功能模式\r\n");
+					PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_1, "设置全功能模式");
 				}
 				else
 				{
-					goto_step(STEP_QUERY_DNS);
-					Log_Printf_Debug("\r\n>>查询DNS\r\n");
+					PCTRL_GotoStep(&pctrl, STEP_QUERY_DNS, "查询DNS");
+					memset(pridnsaddr, 0, sizeof(pridnsaddr));
 				}
 			}
 			else if(result == Result_Failed)
@@ -354,17 +337,34 @@ void UDP_Client_Handle(void)
 				goto_failure("查询功能模式失败");
 			}
 		   break;
+		case STEP_SET_CFUN_0:
+			result=bc260y.set_cfun(0);//设置最小功能模式
+			if(result == Result_Success)
+			{
+				if(REGIST_GetResult() != REGIST_Result_None)
+				{
+					goto_finish();
+				}
+				else
+				{
+					PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_1, "设置全功能模式");
+				}
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置最小功能模式失败");
+				goto_finish();
+			}
+			break;
 		case STEP_SET_CFUN_1: // 设置全功能模式
 			result = bc260y.set_cfun(1);
 			if(result == Result_Success)
 			{
-				resend_counter++;
-				goto_step(STEP_QUERY_DNS);
-				Log_Printf_Debug("\r\n>>查询DNS\r\n");
+				PCTRL_GotoStep(&pctrl, STEP_QUERY_DNS, "查询DNS");
+				memset(pridnsaddr, 0, sizeof(pridnsaddr));
 			}
 			else if(result == Result_Failed)
 			{
-				resend_counter++;
 				goto_failure("设置全功能模式失败");
 			}
 			break;
@@ -374,13 +374,11 @@ void UDP_Client_Handle(void)
 			{
 				if(strlen(pridnsaddr) <= 1)
 				{
-					goto_step(STEP_SET_DNS);
-					Log_Printf_Debug("\r\n>>设置DNS\r\n");
+					PCTRL_GotoStep(&pctrl, STEP_SET_DNS, "设置DNS");
 				}
 				else
 				{
-					goto_step(STEP_SET_CGREG_2);
-					Log_Printf_Debug("\r\n>>设置ps域\r\n");
+					PCTRL_GotoStep(&pctrl, STEP_SET_CGREG_2, "设置ps域");
 				}
 			}
 			else if(result == Result_Failed)
@@ -392,33 +390,18 @@ void UDP_Client_Handle(void)
 			result = bc260y.set_dns("114.114.114.114", "8.8.8.8"); // 设置DNS
 			if(result == Result_Success)
 			{
-				goto_step(STEP_SET_CFUN_0_DNS);
-				Log_Printf_Debug("\r\n>>设置完dns，设置最小功能模式\r\n");
+				PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置完DNS，设置最小功能模式");
 			}
 			else if(result == Result_Failed)
 			{
-				goto_failure("查询功能模式失败");
+				goto_failure("设置DNS失败");
 			}
 		   break;
-		case STEP_SET_CFUN_0_DNS: // 设置完dns，设置最小功能模式
-			result = bc260y.set_cfun(0);
-			if(result == Result_Success)
-			{
-				goto_step(STEP_SET_CFUN_1);
-				Log_Printf_Debug("\r\n>>设置全功能模式\r\n");
-			}
-			else if(result == Result_Failed)
-			{
-				goto_failure("设置完dns，设置最小模式失败");
-			}
-			break;
 		case STEP_SET_CGREG_2: // 设置ps域
 			result = bc260y.set_cereg(2);
 			if(result == Result_Success)
 			{
-//				goto_step_wait(STEP_QUERY_CGREG, 400);
-				goto_step(STEP_QUERY_CGREG);
-				Log_Printf_Debug("\r\n>>查询ps域\r\n");
+				PCTRL_GotoStep(&pctrl, STEP_QUERY_CGREG, "查询ps域");
 			}
 			else if(result == Result_Failed)
 			{
@@ -434,17 +417,14 @@ void UDP_Client_Handle(void)
 					// 参数赋值
 					pump_params.lac = cgreg_lac;
 					pump_params.ci = cgreg_ci;
-					// 编码
 						// 下一步
-					if(test_flag == 0)
+					if(UDPCLIENT_TestModeFlag == 0)
 					{
-						goto_step(STEP_QUERY_SOCKET);
-						Log_Printf_Debug("\r\n>>查询连接\r\n");
+						PCTRL_GotoStep(&pctrl, STEP_QUERY_SOCKET, "查询连接");
 					}
 					else
 					{
-						goto_step(STEP_QUERY_QENG_SERVINGCELL);
-						Log_Printf_Debug("\r\n>>查询信号质量\r\n");
+						PCTRL_GotoStep(&pctrl, STEP_QUERY_QENG_SERVINGCELL, "查询信号质量");
 					}
 				}
 				else
@@ -461,8 +441,7 @@ void UDP_Client_Handle(void)
 			result = bc260y.qeng_servingcell(&signal.RSRP, &signal.RSRQ, &signal.RSSI, &signal.SINR);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_QUERY_SOCKET);
-				Log_Printf_Debug("\r\n>>查询连接\r\n");
+				PCTRL_GotoStep(&pctrl, STEP_QUERY_SOCKET, "查询连接");
 			}
 			else if(result == Result_Failed)
 			{
@@ -476,13 +455,11 @@ void UDP_Client_Handle(void)
 			{
 				if(connectstate==2)
 				{
-					goto_step(STEP_JUDGE_AUTH_OR_DATA);
-					Log_Printf_Debug("\r\n>>判断认证还是发送\r\n");
+					PCTRL_GotoStep(&pctrl, STEP_JUDGE_AUTH_OR_DATA, "判断认证或发送");
 				}
 				else
 				{
-					goto_step(STEP_CLOSE);
-					Log_Printf_Debug("\r\n>>关闭连接\r\n");
+					PCTRL_GotoStep(&pctrl, STEP_CLOSE, "关闭连接");
 				}
 			}
 			else if(result == Result_Failed)
@@ -494,8 +471,7 @@ void UDP_Client_Handle(void)
 			result = bc260y.close_socket(connectID);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_OPEN);
-				Log_Printf_Debug("\r\n>>打开客户端\r\n");
+				PCTRL_GotoStep(&pctrl, STEP_OPEN, "打开客户端");
 			}
 			else if(result == Result_Failed)
 			{
@@ -503,17 +479,16 @@ void UDP_Client_Handle(void)
 			}
 			break;
 		case STEP_OPEN: // 打开客户端
-			result = bc260y.open_socket(connectID, "UDP",aliyuniot_get_host(), aliyuniot_get_port(), 1, &socket_err);
+			result = bc260y.open_socket(connectID, "UDP", regist_response.remoteAddress, regist_response.remotePort, 1, &socket_err);
 			if(result == Result_Success)
 			{
 				if(socket_err == 0)
 				{
-					goto_step(STEP_JUDGE_AUTH_OR_DATA);
-					Log_Printf_Debug("\r\n>>判断认证还是发送\r\n");
+					PCTRL_GotoStep(&pctrl, STEP_JUDGE_AUTH_OR_DATA, "判断认证或发送");
 				}
 				else
 				{
-					goto_failure("客户端打开错误");
+					PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "打开客户端失败，设置最小功能模式");
 				}
 			}
 			else if(result == Result_Failed)
@@ -521,50 +496,37 @@ void UDP_Client_Handle(void)
 				goto_failure("打开客户端失败");
 			}
 			break;
-		case STEP_JUDGE_AUTH_OR_DATA: // 判断认证还是发送
-			auth_or_data = aliyuniot_is_authentication();
-			if(auth_or_data == 1) // 已认证
+		case STEP_JUDGE_AUTH_OR_DATA: // 判断认证或发送
+			if(TUORENIOT_IsAuthentication() == 1) // 已认证
 			{
-				goto_step(STEP_JOIN_DATA_MESSAGE);
-				Log_Printf_Debug("\r\n>>拼接数据报文\r\n");
+				PCTRL_GotoStep(&pctrl, STEP_JOIN_DATA_MESSAGE, "拼接数据报文");
 			}
 			else
 			{
-				goto_step(STEP_JOIN_AUTH_MESSAGE);
-				Log_Printf_Debug("\r\n>>拼接认证报文\r\n");
+				PCTRL_GotoStep(&pctrl, STEP_JOIN_AUTH_MESSAGE, "拼接认证报文");
 			}
 			break;
 		case STEP_JOIN_AUTH_MESSAGE: // 拼接认证报文
-			if(auth_times > 0) // 最多重新认证一次
-			{
-				goto_failure("认证次数过多");
-			}
-			else 
-			{
-				memset(coap_message, 0, sizeof(coap_message));
-				aliyuniot_get_auth_message(coap_message, &coap_message_length);
+			memset(coap_message, 0, sizeof(coap_message));
+			TUORENIOT_PackAuthMessage(coap_message, &coap_message_length);
 //				Log_Printf_Debug("认证报文：%d\r\n", coap_message_length);
 //				Log_SendHex(coap_message, coap_message_length);
 //				Log_Printf_Debug("\r\n");
-				goto_step(STEP_SEND);
-				Log_Printf_Debug("\r\n>>发送认证报文\r\n");
-				auth_times++;
-			}
+			PCTRL_GotoStep(&pctrl, STEP_SEND, "发送认证报文");
 			break;
 		case STEP_JOIN_DATA_MESSAGE: // 拼接数据报文
 			pump_params.lac = cgreg_lac;
 			pump_params.ci = cgreg_ci;
-			Pump_Params_Refresh();
+			PUMPBUSINESS_ParamsRefresh();
 					// 编码
-			memset(databuff, 0, sizeof(databuff));
-			business_protocol_encode(pump_params, databuff, &data_length);
+			memset(data, 0, sizeof(data));
+			PUMPDICTS_ProtocolEncode(&pump_params, data, &data_length);
 			memset(coap_message, 0, sizeof(coap_message));
-			aliyuniot_get_data_message(databuff, data_length, coap_message, &coap_message_length);
+			TUORENIOT_PackDataMessage(data, data_length, coap_message, &coap_message_length);
 //			Log_Printf_Debug("数据报文：%d\r\n", coap_message_length);
 //			Log_SendHex(coap_message, coap_message_length);
 //			Log_Printf_Debug("\r\n");
-			goto_step(STEP_SEND);
-			Log_Printf_Debug("\r\n>>发送数据报文\r\n");
+			PCTRL_GotoStep(&pctrl, STEP_SEND, "发送数据报文");
 			break;
  
 		case STEP_SEND: // 发送send
@@ -572,8 +534,7 @@ void UDP_Client_Handle(void)
 			if(result == Result_Success)
 			{
 				memset(coap_message, 0, sizeof(coap_message));
-				goto_step(STEP_RECV);
-				Log_Printf_Debug("\r\n>>等待接收数据\r\n");
+				PCTRL_GotoStep(&pctrl, STEP_RECV, "等待接收数据");
 			}
 			else if(result == Result_Failed)
 			{
@@ -584,73 +545,45 @@ void UDP_Client_Handle(void)
 			result = bc260y.recv_with_time(connectID, coap_message, &coap_message_length, 10000);
 			if(result == Result_Success)
 			{
-				uint8_t res = aliyuniot_recv_data_handle(coap_message, coap_message_length);
+				uint8_t res = TUORENIOT_AnalysisMessage(coap_message, coap_message_length);
 				if(res == 0) // 发送失败
 				{
-					goto_step(STEP_JUDGE_AUTH_OR_DATA); // 重新认证
-					Log_Printf_Debug("\r\n>>重新认证\r\n");
+					PCTRL_GotoStep(&pctrl, STEP_JUDGE_AUTH_OR_DATA, "重新认证"); // 重新认证
 				}
 				else if(res == 1) // 认证成功
 				{
-					goto_step(STEP_JOIN_DATA_MESSAGE);
-					Log_Printf_Debug("\r\n>>拼接数据报文\r\n");
+					PCTRL_GotoStep(&pctrl, STEP_JOIN_DATA_MESSAGE, "拼接数据报文");
 				}
 				else if(res == 2) // 发送成功
 				{
-					goto_success("发送成功");
+					goto_success();
 				}
 			}
 			else if(result == Result_Failed)
 			{
-				goto_failure("等待结果失败");
+				PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "重新发送，设置最小功能模式");
 			}
 			break;
 		case STEP_WAIT: // 等待
-			wait();
+			PCTRL_Wait(&pctrl);
 			break;
 		case STEP_SUCCESS: // 成功
-			goto_step(STEP_ENTER_SLEEP);
-			Log_Printf_Debug("\r\n>>成功，进入睡眠\r\n");
+			goto_finish();
 			break;
 		case STEP_FAILURE: // 失败
-			resend_counter++;
-			goto_step(STEP_SET_CFUN_0);
-			Log_Printf_Debug("\r\n>>失败，设置最小功能模式\r\n");
-			break;
-		case STEP_SET_CFUN_0: // 设置最小功能模式
-			result = bc260y.set_cfun(0);
-			if(result == Result_Success)
-			{
-				if(resend_counter > 1) // 重发次数
-				{
-					goto_step(STEP_ENTER_SLEEP);
-					Log_Printf_Debug("\r\n>>重发次数%d > 1，结束发送，进入睡眠\r\n", resend_counter);
-				}
-				else
-				{
-					goto_step(STEP_START);
-					Log_Printf_Debug("\r\n>>重发次数%d <= 1，重新发送\r\n", resend_counter);
-				}
-			}
-			else if(result == Result_Failed)
-			{
-				goto_step(STEP_ENTER_SLEEP);
-				Log_Printf_Debug("\r\n>>进入睡眠\r\n");
-			}
-			break;
-		case STEP_ENTER_SLEEP: // 进入睡眠
-			resend_counter=0;//失败重发置0
-			goto_step(STEP_FINISH);
-			Log_Printf_Debug("\r\n>>发送流程结束\r\n");
+			PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "失败，设置最小功能模式");
 			break;
 		case STEP_FINISH: // 结束流程
 			break;
 		default:
+			goto_failure("步骤不存在");
 			break;
 	}
 	
 }
 
 
+
+
 #endif
 

Drivers/Modules/bc260y/Bc260y_Initialize.c

@@ -7,12 +7,20 @@
 #include <string.h>
 #include <stdlib.h>
 
-
 #include "bc260y.h"
 #include "PumpBusiness.h"
 #include "Log_Module.h"
 #include "Initialize.h"
 
+// 函数声明
+static void INITIALIZE_Process(void); // 流程
+static void INITIALIZE_SetStatus(enum INITIALIZE_StatusEnum status); // 设置状态
+static void INITIALIZE_SetResult(enum INITIALIZE_ResultEnum result); // 设置结果
+
+static void goto_start(void); // 开始
+static void goto_success(void); // 成功
+static void goto_failure(char * _info); // 失败
+static void goto_finish(void); // 结束
 
 // 流程
 enum Step{
@@ -27,132 +35,162 @@ enum Step{
 	STEP_WAIT, // 等待
 	STEP_SET_QISDE_0,
 	STEP_SET_QISDE_1,
-	STEP_SET_CGREG_2, // 设置ps域允许上报网络注册和位置信息
-	STEP_QUERY_CGREG, // 查询网络注册状态
+	STEP_SET_CEREG_2, // 设置ps域允许上报网络注册和位置信息
+	STEP_QUERY_CEREG, // 查询网络注册状态
 	STEP_SUCCESS, // 成功
 	STEP_FAILURE, // 失败
 	STEP_FINISH,
 };
-// 当前
-static enum Step step = STEP_START;
-// 下一步
-static enum Step next_step = STEP_START;
 
-static enum Initialize_Result InitializeResult;
+// 步骤跳转时的监听
+static uint8_t STEP_SET_CFUN_1_times = 0; // 全功能模式的次数
+static uint16_t goto_step_event(uint16_t ns)
+{
+	// 重置bc260y状态
+	bc260y.reset();
+	
+	// 流程控制
+	uint16_t step = ns;
+	if(ns == STEP_SET_CFUN_1 && STEP_SET_CFUN_1_times++ >= 1)
+	{
+		goto_failure("重新联网次数过多");
+		step = STEP_FAILURE;
+	}
+	return step;
+}
 
-static struct TIMER_Struct timer;
+// 流程控制
+static struct PCTRL_Struct pctrl = {
+	.current_step = STEP_FINISH,
+	.next_step = STEP_FINISH,
+	.step_wait = STEP_WAIT,
+	.goto_step_listener = goto_step_event,
+};
 
+// 备注
+static char info[40];
+// 开始
+static void goto_start(void)
+{
+	PCTRL_GotoStep(&pctrl, STEP_START, "开始");
+}
+// 成功
+static void goto_success(void)
+{
+	INITIALIZE_SetResult(INITIALIZE_Result_Success);
+	PCTRL_GotoStep(&pctrl, STEP_SUCCESS, "成功");
+}
+// 失败
+static void goto_failure(char * _info)
+{
+	INITIALIZE_SetResult(INITIALIZE_Result_Failure);
+	memset(info, 0, sizeof(info));
+	strcpy(info, _info);
+	PCTRL_GotoStep(&pctrl, STEP_FAILURE, "失败");
+	Log_Printf_Debug("info：%s！\r\n", info);
+}
+// 结束
+static void goto_finish(void)
+{
+	INITIALIZE_SetStatus(INITIALIZE_Status_Done);
+	PCTRL_GotoStep(&pctrl, STEP_FINISH, "结束");
+}
 
-// 计时相关的变量
-static uint32_t wait_time = 10;
 
-static uint8_t set_mincfun_flag=1;//0代表正在初始化，1代表空闲
 
-static uint8_t cgreg_n; 
-static uint8_t cgreg_stat; 
-static uint16_t cgreg_lac; 
-static uint32_t cgreg_ci;
-static uint8_t query_cgreg_times = 0; // 查询网络状态的次数
 
-static uint8_t set_func_0_times = 0; // 设置最小功能模式的次数
-//// 声明函数。步骤跳转
-void goto_step(enum Step ns);
-// 发送流程
 
-// 等待
-static void wait(void)
+// 状态
+static enum INITIALIZE_StatusEnum udpclient_status = INITIALIZE_Status_None;
+// 结果
+static enum INITIALIZE_ResultEnum udpclient_result = INITIALIZE_Result_None;
+// 设置状态
+static void INITIALIZE_SetStatus(enum INITIALIZE_StatusEnum status)
 {
-	if(time_get_delay(&timer) > wait_time)
-	{
-	 goto_step(next_step); // 进入下一步
-	 time_clear(&timer);
-	}
+	udpclient_status = status;
 }
-// 失败
-static void goto_failure(char * info)
+// 获取状态
+enum INITIALIZE_StatusEnum INITIALIZE_GetStatus(void)
 {
-	Log_Printf_Debug("STEP: 初始化失败,%s\r\n", info);
-	networkTest_Flag=1;
-	goto_step(STEP_FAILURE);
+	return udpclient_status;
 }
-
-// 成功
-static void goto_success(char * info)
+// 设置结果
+static void INITIALIZE_SetResult(enum INITIALIZE_ResultEnum result)
 {
-	Log_Printf_Debug("STEP: 初始化成功,%s\r\n", info);
-	networkTest_Flag=2;
-	goto_step(STEP_SUCCESS);
+	udpclient_result = result;
 }
-
- //直接跳转到下一步
-static void goto_step(enum Step ns)
+// 获取结果
+enum INITIALIZE_ResultEnum INITIALIZE_GetResult(void)
 {
-	// 重置ec800m状态
-	bc260y.reset();
-	step = ns; 
+	return udpclient_result;
 }
-
-// 先等待再跳转到下一步
-static void goto_step_wait(enum Step ns, uint32_t t)
+// 重置
+enum EXECUTE_ResultEnum INITIALIZE_Reset(void)
 {
-	goto_step(STEP_WAIT); // 等待
-	wait_time = t;
-	next_step = ns; // 等待之后跳转
+	if(INITIALIZE_GetStatus() == INITIALIZE_Status_Being)
+	{
+		Log_Printf_Debug("初始化流程重置错误！\r\n");
+		return EXECUTE_Result_Failure;
+	}
+	INITIALIZE_SetStatus(INITIALIZE_Status_None);
+	INITIALIZE_SetResult(INITIALIZE_Result_None);
+	return EXECUTE_Result_Success;
 }
-
-// 只等待，等待之后返回原来的步骤
-static void goto_wait(uint32_t t)
+// 开始
+enum EXECUTE_ResultEnum INITIALIZE_Start(void)
 {
-	goto_step_wait(step, t);
-}
-
-
-// 发送数据的逻辑
-static enum Result result = Result_None;
-static uint8_t cfun_mode = 0;
-//获取初始化状态
-enum Initialize_Result get_initialize_status(void){
-	
-	if(set_mincfun_flag==0)
+	INITIALIZE_Reset();
+	if(INITIALIZE_GetStatus() != INITIALIZE_Status_None)
 	{
-	  InitializeResult=Initialize_Result_Busy;
+		Log_Printf_Debug("初始化流程启动错误！\r\n");
+		return EXECUTE_Result_Failure;
 	}
-	else
+	goto_start();
+	INITIALIZE_SetStatus(INITIALIZE_Status_Being);
+	return EXECUTE_Result_Success;
+}
+// 流程处理，放到循环里
+void INITIALIZE_ProcessHandle(void)
+{
+	if(INITIALIZE_GetStatus() == INITIALIZE_Status_Being)
 	{
-		InitializeResult=Initialize_Result_free;
+		INITIALIZE_Process();
 	}
-	return InitializeResult;
 }
-void Initialize_Handle(void)
+
+// 初始化诱因处理
+void INITIALIZE_TriggerHandle(void)
 {
-	result =bc260y.ready();
+	enum Result result =bc260y.ready();
 	if(result==Result_Success)
 	{
-		set_mincfun_flag=0;
-		goto_step(STEP_START);
-	}
-	if(set_mincfun_flag==1)
-	{
-		return ;
+		INITIALIZE_Start();
 	}
-	// 流程
-	switch(step)
+}
+
+
+
+
+static enum Result result = Result_None;
+static uint8_t cgreg_n; 
+static uint8_t cgreg_stat; 
+static uint16_t cgreg_lac; 
+static uint32_t cgreg_ci;
+static void INITIALIZE_Process(void)
+{
+	switch(pctrl.current_step)
 	{
 		case STEP_START: // 开始
-		  query_cgreg_times = 0; // 查询网络状态的次数
-			set_func_0_times = 0;
-			goto_step(STEP_EXIT_SLEEP);
+			PCTRL_GotoStep(&pctrl, STEP_EXIT_SLEEP, "退出休眠");
 			break;
 		case STEP_EXIT_SLEEP: // 退出休眠
 			result = bc260y.exit_sleep_2();
 			if(result == Result_Success)
 			{
-				Log_Printf_Debug("退出休眠成功\r\n");
-				goto_step_wait(STEP_SET_QISDE_1, 10);
+				PCTRL_GotoStep(&pctrl, STEP_SET_QISDE_1, "开启回显");
 			}
 			else if(result == Result_Failed)
 			{
-				Log_Printf_Debug("退出休眠失败\r\n");
 				goto_failure("退出休眠失败");
 			}
 			break;
@@ -160,74 +198,61 @@ void Initialize_Handle(void)
 			result = bc260y.set_qisde(1);
 		  if(result == Result_Success)
 			{
-				goto_step(STEP_SET_CFUN_0);
+				PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置最小功能模式");
 			}
 			else if(result == Result_Failed)
 			{
 				goto_failure("开启回显失败");
 			}
 		    break;
-		case STEP_SET_SLEEP: // 设置休眠模式
-			result = bc260y.set_sleep(2);
+		case STEP_SET_CFUN_0:
+			result=bc260y.set_cfun(0);//设置最小功能模式
 			if(result == Result_Success)
 			{
-				Log_Printf_Debug("设置休眠模式成功\r\n");
-				goto_step(STEP_QUERY_CFUN);
-			}
-			else if(result == Result_Failed)
-			{
-				Log_Printf_Debug("设置休眠模式失败\r\n");
-				goto_failure("设置休眠模式失败");
-			}
-			break;
-		case STEP_QUERY_CFUN: // 查询功能模式
-			result = bc260y.query_cfun(&cfun_mode);
-			if(result == Result_Success)
-			{
-				if(cfun_mode == 0)
+				if(INITIALIZE_GetResult() != INITIALIZE_Result_None)
 				{
-					goto_step(STEP_SET_CFUN_1);
+					goto_finish();
 				}
 				else
 				{
-					goto_step(STEP_SET_CGREG_2);
+					PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_1, "设置全功能模式");
 				}
 			}
 			else if(result == Result_Failed)
 			{
-				goto_failure("查询功能模式失败");
+				goto_failure("设置最小功能模式失败");
+				goto_finish();
 			}
-		  break;
+			break;
 		case STEP_SET_CFUN_1:
 			result = bc260y.set_cfun(1);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_SET_CGREG_2);
+				PCTRL_GotoStep(&pctrl, STEP_SET_CEREG_2, "设置网络状态");
 			}
 			else if(result == Result_Failed)
 			{
 				goto_failure("设置全功能模式失败");
 			}
 			break;
-		case STEP_SET_CGREG_2: // 设置ps域
+		case STEP_SET_CEREG_2: // 设置ps域
 			result = bc260y.set_cereg(2);
 			if(result == Result_Success)
 			{
-				goto_step(STEP_QUERY_CGREG);
+				PCTRL_GotoStep(&pctrl, STEP_QUERY_CEREG, "查询网络状态");
 			}
 			else if(result == Result_Failed)
 			{
 				goto_failure("设置ps域失败");
 			}
 			break;
-		case STEP_QUERY_CGREG: // 查询ps域
+		case STEP_QUERY_CEREG: // 查询ps域
 			result = bc260y.query_cereg(&cgreg_n, &cgreg_stat, &cgreg_lac, &cgreg_ci);
 			if(result == Result_Success)
 			{
 				if(cgreg_stat == 1)
 				{
-					// 下一步
-			    goto_success("查询PS域成功");
+			    goto_success();
 				}
 				else
 				{
@@ -240,38 +265,18 @@ void Initialize_Handle(void)
 			}
 			break;
 		case STEP_WAIT: // 等待
-			wait();
+			PCTRL_Wait(&pctrl);
 			break;
 		case STEP_SUCCESS: // 成功
-      Log_Printf_Debug("初始化成功\r\n");
-			goto_step(STEP_FINISH);
+			goto_finish();
 			break;
 		case STEP_FAILURE: // 失败
-			goto_step(STEP_SET_CFUN_0);
-			break;
-		case STEP_SET_CFUN_0: // 设置最小功能模式
-			result = bc260y.set_cfun(0);
-			if(result == Result_Success)
-			{
-				if(set_func_0_times < 1)
-				{
-					set_func_0_times++;
-					goto_step(STEP_SET_SLEEP);
-				}
-				else
-				{
-					goto_step(STEP_FINISH);
-				}
-			}
-			else if(result == Result_Failed)
-			{
-				goto_step(STEP_FINISH);
-			}
+			PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "初始化失败，设置最小功能模式");
 			break;
 		case STEP_FINISH: // 结束流程
-		  set_mincfun_flag=1;
 			break;
 		default:
+			goto_failure("步骤不存在");
 			break;
 	}
 	

Drivers/Modules/bc260y/Bc260y_Regist.c

@@ -20,7 +20,7 @@
 #include "stm32f10x.h"
 #include "Regist.h"
 #include "bc260y.h"
-#include "INflash.h"
+#include "FlashSetup.h"
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
@@ -32,24 +32,13 @@
 #include "Common_Util.h"
 #include "Tuoreniot.h"
 
-//static Coefficient_Data flashdata;
+// 泵号
 extern uint8_t mcu_id[8];
-#if  PROD_ENV
-// 生产环境
-static char * REGIST_SERVER = "iot.tuoren.com" ; //注册服务器地址
-static uint16_t REGIST_PORT = 8888; //端口号
-#endif
-
-#if TEST_ENV
-// 开发环境
-static char * REGIST_SERVER = "b21759p174.iok.la" ; //注册服务器地址
-static uint16_t REGIST_PORT = 43097; //端口号
-#endif
-
-static uint8_t tcpconnectID = 2;
+// socket ID
+static uint8_t connectID = 2;
 
 // 注册参数
-static struct Regist_Params_Struct regist_params = {
+static struct TUORENIOT_RegistRequestStruct regist_request = {
 	.version = 1,
 	.platform = "aliyun",
 	.networkProtocol = "CoAP",
@@ -57,8 +46,6 @@ static struct Regist_Params_Struct regist_params = {
 	.userId = 4562
 };
 
-// 注册结果
-static struct Regist_Result_Struct regist_result;
 static uint8_t regist_data[512];
 static uint16_t regist_data_length;
 
@@ -66,221 +53,430 @@ static uint16_t regist_data_length;
 static char pridnsaddr[20];
 
 
-//清空flash
-void clearflash(void){
-	regist_result.code = 0;
-	my_delay_ms(10);
-	STMFLASH_Write(FLASH_SAVE_ADDR, (uint16_t*)&regist_result, sizeof(regist_result));
-}
-
-void storedata(void)
+/**
+* 
+*注册参数信息打包
+*/
+void TUORENIOT_PackRegistRequest(uint8_t * pack_data, uint16_t * pack_data_length, struct TUORENIOT_RegistRequestStruct * registParams)
 {
-	my_delay_ms(10);
-	STMFLASH_Write(FLASH_SAVE_ADDR, (uint16_t*)&regist_result, sizeof(regist_result));
-	regist_result.code = 0;
-	my_delay_ms(10);
-	Log_Printf_Debug("写入数据完成\r\n");
-	STMFLASH_Read(FLASH_SAVE_ADDR, (uint16_t*)&regist_result, sizeof(regist_result));
-	printf_regist_result_struct(regist_result);
+	sprintf((char *)(pack_data + 2), "{\"platform\":\"%s\",\"connectionType\":\"%s\",\"deviceId\":\"%s\"}", 
+	registParams->platform, registParams->networkProtocol, registParams->deviceId); // 拼接AT指令
+	Log_Printf_Debug("%s\r\n", (char *)(pack_data + 2));
+	
+	uint16_t datalen = utils_aes128_ECB_base64_enc_with_length(regist_key, (pack_data + 2));
+	
+	pack_data[0] = datalen>>8;//头2个字节赋值数据长度
+	pack_data[1] = datalen;
+
+	* pack_data_length = datalen + 2;
 }
 
-uint8_t regist_Handle()
-{
-	uint8_t cfun_mode, mode,stat,regist_flag = 0;
-	uint16_t lac,err = 0;
-	uint32_t ci = 0;
-	enum Result result = Result_None;
-//	GPIO_SetBits(WAKE_GPIO, WAKE_GPIO_Pin);
-	Log_Printf_Debug("\r\n>>退出休眠\r\n");
-	result = bc260y.exit_sleep_2_sync();//退出休眠
-	if(result==Result_Success)
-	{
-		Log_Printf_Debug("\r\n>>开启回显\r\n");
-		result = bc260y.set_qisde_sync(1);//开启回显
-	}
-	if(result==Result_Success)
-	{
-		Log_Printf_Debug("\r\n>>查询功能模式\r\n");
-		result=bc260y.query_cfun_sync(&cfun_mode);//查询功能模式
-	}
-  if(result==Result_Success)
-	{
-		if(cfun_mode == 1)
-		{
-			Log_Printf_Debug("\r\n>>设置最小功能模式\r\n");
-			result=bc260y.set_cfun_sync(0);//设置最小功能模式
-		}
-	}
-  if(result==Result_Success)
-	{
-		Log_Printf_Debug("\r\n>>设置休眠模式\r\n");
-		result=bc260y.set_sleep_sync(2);//设置休眠模式
-	}
-	if(result==Result_Success)
-	{
-		Log_Printf_Debug("\r\n>>设置数据格式\r\n");
-		result = bc260y.dataformat_sync(1); // 设置数据格式, 十六进制
-	}
+
+// 函数声明
+static void REGIST_Process(void); // 注册流程
+static void REGIST_SetStatus(enum REGIST_StatusEnum status); // 设置注册状态
+static void REGIST_SetResult(enum REGIST_ResultEnum result); // 设置注册结果
+
+static void goto_start(void); // 开始
+static void goto_success(void); // 成功
+static void goto_failure(char * _info); // 失败
+static void goto_finish(void); // 结束
+
+
+// 流程
+enum Step{
+	STEP_FINISH, // 结束
+	STEP_START, // 开始
+	STEP_EXIT_SLEEP, // 退出睡眠
+	STEP_WAIT, // 等待
 	
+	STEP_STATE, // 查询状态
+	STEP_OPEN, // 打开
+	STEP_SET_SLEEP, // 设置休眠
 	
-	if(result==Result_Success)
-	{
-		Log_Printf_Debug("\r\n>>设置全功能模式\r\n");
-		result=bc260y.set_cfun_sync(1);//设置全功能模式
-	}
+	STEP_SET_QISDE_0, // 关闭发送回显
+	STEP_SET_QISDE_1, // 打开发送回显
+	STEP_SEND, // 发送
+	STEP_RECV, // 等待发送结果
 	
-	if(result==Result_Success)
-	{
-		Log_Printf_Debug("\r\n>>查询DNS\r\n");
-		memset(pridnsaddr, 0, sizeof(pridnsaddr));
-		result = bc260y.query_dns_sync(pridnsaddr); // 查询DNS
-		Log_Printf_Debug("DNS: %s, %d\r\n", pridnsaddr, strlen(pridnsaddr));
-	}
+	STEP_QUERY_CFUN, // 查询功能模式
+	STEP_SET_CFUN_0, // 设置最小功能模式
+	STEP_SET_CFUN_1, // 设置全功能模式
 	
-	if(result==Result_Success)
-	{
-		if(strlen(pridnsaddr) <= 1)
-		{
-			Log_Printf_Debug("\r\n>>设置DNS\r\n");
-			result = bc260y.set_dns_sync("114.114.114.114", "8.8.8.8"); // 设置DNS
-			if(result==Result_Success)
-			{
-				Log_Printf_Debug("\r\n>>设置最小功能模式\r\n");
-				result=bc260y.set_cfun_sync(0);//设置最小功能模式
-			}
-			if(result==Result_Success)
-			{
-				Log_Printf_Debug("\r\n>>设置全功能模式\r\n");
-				result=bc260y.set_cfun_sync(1);//设置全功能模式
-			}
-		}
-	}
+	STEP_SET_CEREG_2, // 设置ps域允许上报网络注册和位置信息
+	STEP_QUERY_CEREG, // 查询网络注册状态
+	STEP_DATAFORMAT, // 配置发送格式
 	
-  
- 
-  if(result==Result_Success)
-	{
-		Log_Printf_Debug("\r\n>>设置网络状态\r\n");
-		result=bc260y.set_cereg_sync(2);//设置网络状态
-	}
+	STEP_CLOSE, // 关闭
 	
-  if(result==Result_Success)
-	{
-		Log_Printf_Debug("\r\n>>查询网络状态\r\n");
-		result=bc260y.query_cereg_sync(&mode,&stat,&lac,&ci);// 查询网络状态
-	}
+	STEP_SUCCESS, // 成功
+	STEP_FAILURE, // 失败
+	STEP_QUERY_DNS, // 查询DNS
+	STEP_SET_DNS, // 设置DNS
+};
 
-	if(result==Result_Success)
-	{
-		Log_Printf_Debug("\r\n>>断开tcp连接\r\n");
-		result=bc260y.close_socket_sync(tcpconnectID);//防止以前链接没断开，断开tcp链接
-	}
-	
-	if(result==Result_Success)
-	{
-		Log_Printf_Debug("\r\n>>连接tcp\r\n");
-		result=bc260y.open_socket_sync(tcpconnectID,"TCP",REGIST_SERVER,REGIST_PORT,1,&err);//连接tcp
-	}
-	
-	if(result==Result_Success)
-	{
-		Log_Printf_Debug("\r\n>>发送数据\r\n");
-		memset(regist_params.deviceId, 0, sizeof(regist_params.deviceId));
-		Log_Printf_Debug("mcu_id: %s\r\n", mcu_id);
-		byteToHexStr(mcu_id, regist_params.deviceId, sizeof(mcu_id));
-		memset(regist_data, 0, sizeof(regist_data));
-		packRegistParams(regist_data, &regist_data_length, regist_params);
-		printf_regist_param_struct(regist_params);
-		result =bc260y.send_rai_sync(tcpconnectID, regist_data, regist_data_length, 0);//数据发送
-	}
-	
-	if(result==Result_Success)
-	{
-		Log_Printf_Debug("\r\n>>接收数据\r\n");
-		memset(regist_data, 0, sizeof(regist_data));
-		result =bc260y.recv_with_time_sync(tcpconnectID,regist_data,&regist_data_length,10000);
-//		Log_Printf_Debug("解密前：\r\n");
-//		Log_SendHex(regist_data, regist_data_length);
-//		Log_Printf_Debug("\r\n");
-	}
-	
+// 步骤跳转时的监听
+static uint8_t STEP_SET_CFUN_1_times = 0; // 全功能模式的次数
+static uint16_t goto_step_event(uint16_t ns)
+{
+	// 重置bc260y状态
+	bc260y.reset();
 	
-	if(result == Result_Success)
+	// 流程控制
+	uint16_t step = ns;
+	if(ns == STEP_SET_CFUN_1 && STEP_SET_CFUN_1_times++ >= 1)
 	{
-		Log_Printf_Debug("\r\n>>解析数据\r\n");
-		// 解析注册数据
-		regist_flag = analysisRegistData(regist_data, regist_data_length, &regist_result);
-		printf_regist_result_struct(regist_result);
-		
-		Log_Printf_Debug("\r\n>>断开tcp连接\r\n");
-		result=bc260y.close_socket_sync(tcpconnectID);//断开tcp连接
+		goto_failure("重新联网次数过多");
+		step = STEP_FAILURE;
 	}
-	
+	return step;
+}
+
+// 流程控制
+static struct PCTRL_Struct pctrl = {
+	.current_step = STEP_FINISH,
+	.next_step = STEP_FINISH,
+	.step_wait = STEP_WAIT,
+	.goto_step_listener = goto_step_event,
+};
 
-	// 注册失败，进入最小功能模式，防止耗电
-  if(result == Result_Failed)
-	{
-		Log_Printf_Debug("\r\n>>设置最小功能模式\r\n");
-		bc260y.set_cfun_sync(0);//设置最小功能模式
-	}
-	
 
-  return regist_flag;
+// 备注
+static char info[40];
+// 开始
+static void goto_start(void)
+{
+	PCTRL_GotoStep(&pctrl, STEP_START, "开始");
 }
 
-static uint8_t register_status = 0;//注册成功，向flash存储标志
-uint8_t regist_device_sync(void)
+// 成功
+static void goto_success(void)
 {
-	//未注册开始注册流程
-	register_status=regist_Handle();//注册流程
-	if (register_status==0)//注册流程失败不储存flash
-	{
-		clearflash();
-		Log_Printf_Debug("注册失败！\r\n");
-	}
-	else
-	{
-		storedata();//存储到flash
-		Log_Printf_Debug("注册成功！\r\n");
-	}
-	return register_status;
+	REGIST_SetResult(REGIST_Result_Success);
+	PCTRL_GotoStep(&pctrl, STEP_SUCCESS, "成功");
+}
+// 失败
+static void goto_failure(char * _info)
+{
+	REGIST_SetResult(REGIST_Result_Failure);
+	memset(info, 0, sizeof(info));
+	strcpy(info, _info);
+	PCTRL_GotoStep(&pctrl, STEP_FAILURE, "失败");
+	Log_Printf_Debug("info：%s！\r\n", info);
 }
+// 结束
+static void goto_finish(void)
+{
+	REGIST_SetStatus(REGIST_Status_Done);
+	PCTRL_GotoStep(&pctrl, STEP_FINISH, "结束");
+}
+
 
-static uint8_t read_flash_flag = 0; // 读取flash的标志
-enum Regist_Result regist_get_result(void)
+// 注册状态
+static enum REGIST_StatusEnum regist_status = REGIST_Status_None;
+// 注册结果
+static enum REGIST_ResultEnum regist_result = REGIST_Result_None;
+// 设置注册状态
+static void REGIST_SetStatus(enum REGIST_StatusEnum status)
 {
-	if(read_flash_flag == 0)
-	{
-		//读取flash
-		Log_Printf_Debug("读取前：\r\n");
-		printf_regist_result_struct(regist_result);
-		STMFLASH_Read(FLASH_SAVE_ADDR, (u16*)&regist_result, sizeof(regist_result));//读取flash
-		my_delay_ms(10);
-		Log_Printf_Debug("读取后：\r\n");
-		printf_regist_result_struct(regist_result);
-		read_flash_flag = 1;
-	}
-	
-  if(regist_result.code == 200){
-    return Regist_Result_Success;
+	regist_status = status;
+}
+// 获取注册状态
+enum REGIST_StatusEnum REGIST_GetStatus(void)
+{
+	return regist_status;
+}
+// 设置注册结果
+static void REGIST_SetResult(enum REGIST_ResultEnum result)
+{
+	regist_result = result;
+}
+// 获取注册结果
+enum REGIST_ResultEnum REGIST_GetResult(void)
+{
+  if(TUORENIOT_GetCodeOfRegistResponse() == 200){
+    regist_result = REGIST_Result_Success;
   }
   else
   {
-    return Regist_Result_None;
+    regist_result = REGIST_Result_None;
   }
+	return regist_result;
 }
-
-char * regist_get_aliyun_productKey(void)
+// 重置注册
+enum EXECUTE_ResultEnum REGIST_Reset(void)
 {
- return regist_result.productId;
+	if(REGIST_GetStatus() == REGIST_Status_Being)
+	{
+		Log_Printf_Debug("注册流程重置错误！\r\n");
+		return EXECUTE_Result_Failure;
+	}
+	REGIST_SetStatus(REGIST_Status_None);
+	REGIST_SetResult(REGIST_Result_None);
+	return EXECUTE_Result_Success;
 }
-char * regist_get_aliyun_deviceName(void)
+// 开始注册
+enum EXECUTE_ResultEnum REGIST_Start(void)
 {
-  return regist_result.deviceId;
+	REGIST_Reset();
+	if(REGIST_GetStatus() != REGIST_Status_None)
+	{
+		Log_Printf_Debug("注册流程启动错误！\r\n");
+		return EXECUTE_Result_Failure;
+	}
+	goto_start();
+	REGIST_SetStatus(REGIST_Status_Being);
+	return EXECUTE_Result_Success;
 }
-char * regist_get_aliyun_deviceSecret(void)
+// 注册流程处理，放到大循环里
+void REGIST_ProcessHandle(void)
 {
- return regist_result.deviceSecret;
+	if(REGIST_GetStatus() == REGIST_Status_Being)
+	{
+		REGIST_Process();
+	}
 }
+
+
+// 注册流程
+static enum Result result = Result_None;
+static uint8_t cfun_mode, mode, stat = 0;
+static uint16_t lac, err = 0;
+static uint32_t ci = 0;
+static void REGIST_Process()
+{
+	switch(pctrl.current_step)
+	{
+		case STEP_START: // 开始
+			PCTRL_GotoStep(&pctrl, STEP_EXIT_SLEEP, "退出休眠");
+			break;
+		case STEP_EXIT_SLEEP: 
+			result = bc260y.exit_sleep_2();//退出休眠
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_SET_QISDE_1, "开启回显");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("退出休眠失败");
+			}
+			break;
+		case STEP_SET_QISDE_1:
+			result = bc260y.set_qisde(1);//开启回显
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_SET_SLEEP, "设置休眠模式");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("开启回显失败");
+			}
+			break;
+		case STEP_SET_SLEEP:
+			result=bc260y.set_sleep(2);//设置休眠模式
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_DATAFORMAT, "设置数据格式");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置休眠模式失败");
+			}
+			break;
+		case STEP_DATAFORMAT:
+			result = bc260y.dataformat(1); // 设置数据格式, 十六进制
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_QUERY_CFUN, "查询功能模式");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置数据格式失败");
+			}
+			break;
+		case STEP_QUERY_CFUN:
+			result = bc260y.query_cfun(&cfun_mode); // 查询功能模式
+			if(result == Result_Success)
+			{
+				if(cfun_mode == 1)
+				{
+					PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置最小功能模式");
+				}
+				else
+				{
+					PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_1, "设置全功能模式");
+				}
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("查询功能模式失败");
+			}
+			break;
+		case STEP_SET_CFUN_0:
+			result=bc260y.set_cfun(0);//设置最小功能模式
+			if(result == Result_Success)
+			{
+				if(REGIST_GetResult() != REGIST_Result_None)
+				{
+					goto_finish();
+				}
+				else
+				{
+					PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_1, "设置全功能模式");
+				}
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置最小功能模式失败");
+				goto_finish();
+			}
+			break;
+		case STEP_SET_CFUN_1:
+			result=bc260y.set_cfun(1);//设置全功能模式
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_QUERY_DNS, "查询DNS");
+				memset(pridnsaddr, 0, sizeof(pridnsaddr));
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置全功能模式失败");
+			}
+			break;
+		case STEP_QUERY_DNS:
+			result = bc260y.query_dns(pridnsaddr); // 查询DNS
+			if(result == Result_Success)
+			{
+				Log_Printf_Debug("DNS: %s, %d\r\n", pridnsaddr, strlen(pridnsaddr));
+				if(strlen(pridnsaddr) <= 1)
+				{
+					PCTRL_GotoStep(&pctrl, STEP_SET_DNS, "设置DNS");
+				}
+				else
+				{
+					PCTRL_GotoStep(&pctrl, STEP_SET_CEREG_2, "设置网络状态");
+				}
+			}
+			else if(result == Result_Failed) goto_failure("查询DNS失败");
+			break;
+		case STEP_SET_DNS:
+			result = bc260y.set_dns("114.114.114.114", "8.8.8.8"); // 设置DNS
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置最小功能模式");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置DNS失败");
+			}
+			break;
+		case STEP_SET_CEREG_2:
+			result=bc260y.set_cereg(2); // 设置网络状态
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_QUERY_CEREG, "查询网络状态");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("设置网络状态失败");
+			}
+			break;
+		case STEP_QUERY_CEREG:
+			result=bc260y.query_cereg(&mode, &stat, &lac, &ci);// 查询网络状态
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_CLOSE, "断开tcp连接");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("查询网络状态失败");
+			}
+			break;
+		case STEP_CLOSE:
+			result=bc260y.close_socket(connectID);//防止以前链接没断开，断开tcp链接
+			if(result == Result_Success)
+			{
+				if(REGIST_GetResult() != REGIST_Result_None)
+				{
+					goto_finish();
+				}
+				else
+				{
+					PCTRL_GotoStep(&pctrl, STEP_OPEN, "连接tcp");
+				}
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("断开tcp连接失败");
+			}
+			break;
+		case STEP_OPEN:
+			result=bc260y.open_socket(connectID, "TCP", REGIST_SERVER, REGIST_PORT, 1, &err); // 连接tcp
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_SEND, "发送数据");
+				
+				memset(regist_request.deviceId, 0, sizeof(regist_request.deviceId));
+				Log_Printf_Debug("mcu_id: %s\r\n", mcu_id);
+				byteToHexStr(mcu_id, regist_request.deviceId, sizeof(mcu_id));
+				memset(regist_data, 0, sizeof(regist_data));
+				TUORENIOT_PackRegistRequest(regist_data, &regist_data_length, &regist_request);
+				TUORENIOT_PrintfRegistRequestStruct(&regist_request);
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("连接tcp失败");
+			}
+			break;
+		case STEP_SEND: // 发送数据
+			result =bc260y.send_rai(connectID, regist_data, regist_data_length, 0);//数据发送
+			if(result == Result_Success)
+			{
+				PCTRL_GotoStep(&pctrl, STEP_RECV, "等待结果");
+				memset(regist_data, 0, sizeof(regist_data));
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("发送数据失败");
+			}
+			break;
+		case STEP_RECV: // 等待结果
+			result =bc260y.recv_with_time(connectID, regist_data, &regist_data_length, 10000);
+			if(result == Result_Success)
+			{
+				uint8_t res = TUORENIOT_AnalysisRegistData(regist_data, regist_data_length);
+				if(res == 1) // 成功
+				{
+					goto_success();
+				}
+				else // 失败
+				{
+					goto_failure("解析失败");
+				}
+				PCTRL_GotoStep(&pctrl, STEP_CLOSE, "断开tcp连接");
+			}
+			else if(result == Result_Failed)
+			{
+				goto_failure("等待结果失败");
+			}
+			break;
+		case STEP_WAIT: // 等待
+			PCTRL_Wait(&pctrl);
+			break;
+		case STEP_SUCCESS: // 成功
+			goto_finish();
+			break;
+		case STEP_FAILURE: // 失败
+			PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "失败，设置最小功能模式");
+			break;
+		case STEP_FINISH: // 结束
+			break;
+		default: // 默认
+			goto_failure("步骤不存在");
+			break;
+	}
+}
+
+
 #endif
 

Drivers/Modules/bc260y/bc260y.c

@@ -376,7 +376,7 @@ static enum Result overtime(void)
 	setStatus(Status_Overtime); // 超时
 	
 	// 发送日志
-	Log_Printf_Debug("activeID: %d, AT指令接收超时: %d\r\n", bc260y.activeID, AT_result_length());
+	Log_Printf_Debug("接收超时: %d\r\n", AT_result_length());
 	Log_SendArray_Debug(AT_result(), AT_result_length());
 	
 	return Result_Failed; // 结果
@@ -393,7 +393,7 @@ static enum Result success_no_log(void)
 static enum Result success(void)
 {
 	// 发送日志
-	Log_Printf_Debug("activeID: %d, AT接收: %d\r\n", bc260y.activeID, AT_result_length());
+	Log_Printf_Debug("接收成功: %d\r\n", AT_result_length());
 	Log_SendArray_Debug(AT_result(), AT_result_length());
 	return success_no_log();
 }
@@ -409,7 +409,7 @@ static enum Result failed(int type)
 	else if(type == 2)
 	{
 		// 发送日志
-		Log_Printf_Debug("activeID: %d, AT接收: %d\r\n", bc260y.activeID, AT_result_length());
+		Log_Printf_Debug("activeID: %d, AT接收失败: %d\r\n", bc260y.activeID, AT_result_length());
 		Log_SendArray_Debug(AT_result(), AT_result_length());
 	}
 	else
@@ -431,12 +431,12 @@ void bc260y_reset(void)
 	AT_Clear(); // 清除AT指令
 }
 // 发送指令并改变状态
-enum Result send_at(char * cmd, uint8_t activeID)
+enum Result send_at_nolog(char * cmd, uint8_t activeID)
 {
-	Log_Printf_Debug("activeID: %d, AT发送: %d\r\n", activeID, strlen(cmd)); // 打印日志
-	Log_Printf_Debug(cmd); // 打印AT指令
 	if(send_at_string(cmd)) // 发送AT指令
 	{
+		Log_Printf_Debug("发送成功: %d\r\n", strlen(cmd)); // 打印日志
+		
 		setActiveID(activeID); // 活动ID
 		setStatus(Status_Sending); // 设置已发送
 		clearTimer(); // 重置计时
@@ -445,10 +445,21 @@ enum Result send_at(char * cmd, uint8_t activeID)
 	else
 	{
 		Log_Printf_Debug("activeID: %d, error: AT指令发送失败\r\n", bc260y.activeID); // 打印日志
+		
 		return Result_Failed; // 失败结果
 	}
 }
 
+enum Result send_at(char * cmd, uint8_t activeID)
+{
+	enum Result result = send_at_nolog(cmd, activeID);
+	if(result == Result_None) // 发送成功
+	{
+		Log_Printf_Debug(cmd); // 打印AT指令
+	}
+	return result;
+}
+
 
 // 退出休眠
 enum Result bc260y_exit_sleep(void)
@@ -1340,7 +1351,7 @@ enum Result bc260y_send(uint8_t connectID, uint8_t * data, uint16_t data_length)
 	if(getStatus() == Status_None) // 空闲状态
 	{
 		sprintf(AT_CMD, "AT+QISEND=%d,%d\r\n", connectID, data_length); // 拼接AT指令
-		result = send_at(AT_CMD, activeID);
+		result = send_at_nolog(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
@@ -1432,7 +1443,7 @@ enum Result bc260y_send_rai(uint8_t connectID, uint8_t * data, uint16_t data_len
 			sprintf(AT_CMD + strlen(AT_CMD), "%02X", data[i]);
 		}
 		sprintf(AT_CMD + strlen(AT_CMD), ",%d\r\n", rai); // 拼接AT指令
-		result = send_at(AT_CMD, activeID);
+		result = send_at_nolog(AT_CMD, activeID);
 	}
 	else if(getStatus() != Status_Sending) // 上一次的结果没有清除，返回错误，为了保证时效性，需要重置状态。重新调用
 	{
@@ -1445,7 +1456,7 @@ enum Result bc260y_send_rai(uint8_t connectID, uint8_t * data, uint16_t data_len
 	}
 	else if(strstr((char * )AT_result(), "SEND OK\r\n") != NULL) // 查询是否返回
 	{
-		result = success(); // 成功
+		result = success_no_log(); // 成功
 	}
 	else if(strstr((char * )AT_result(), "SEND FALL\r\n") != NULL) // 查询是否返回
 	{

Drivers/TypeDef.h

@@ -0,0 +1,12 @@
+#ifndef __TYPE_DEF_H
+#define __TYPE_DEF_H
+
+// 执行结果
+enum EXECUTE_ResultEnum
+{
+	EXECUTE_Result_Failure, // 执行失败
+	EXECUTE_Result_Success, // 执行成功
+};
+
+
+#endif

Drivers/Utils/Pump_Dicts_Util.c

@@ -110,7 +110,7 @@ void setPumpOption(uint16_t IDNumber,uint16_t Length,uint8_t * pump_data, uint16
 * pump_data_length 编码后的二进制数据的长度。
 **/
 
-void business_protocol_encode(struct Pump_Params pump_params, uint8_t * pump_data, uint16_t * pump_data_length)
+void PUMPDICTS_ProtocolEncode(struct PUMPDICTS_ParamsStruct * pump_params, uint8_t * pump_data, uint16_t * pump_data_length)
 {
 	uint16_t length = 0;
 	LastIDNumber = 0;
@@ -121,163 +121,163 @@ void business_protocol_encode(struct Pump_Params pump_params, uint8_t * pump_dat
 	
 	//用户编号
 	setPumpOption(1,2,pump_data,&length);
-	pump_data[length++] = (uint8_t)( ( pump_params.userId & 0xff00 ) >> 8 );
-  pump_data[length++] = (uint8_t)( ( pump_params.userId & 0x00ff ) ); 
+	pump_data[length++] = (uint8_t)( ( pump_params->userId & 0xff00 ) >> 8 );
+  pump_data[length++] = (uint8_t)( ( pump_params->userId & 0x00ff ) ); 
 	
 	// 网络类型
   setPumpOption(2,1,pump_data,&length);
-  pump_data[length++] = pump_params.networkType;
+  pump_data[length++] = pump_params->networkType;
 	
 	// 基站位置区号
 	setPumpOption(5,2,pump_data,&length);
-	pump_data[length++] = (uint8_t)( ( pump_params.lac & 0xff00 ) >> 8 );
-	pump_data[length++] = (uint8_t)( pump_params.lac & 0x00ff );
+	pump_data[length++] = (uint8_t)( ( pump_params->lac & 0xff00 ) >> 8 );
+	pump_data[length++] = (uint8_t)( pump_params->lac & 0x00ff );
 		
 	// 基站小区ID
   setPumpOption(6,4,pump_data,&length);
-  pump_data[length++] = (uint8_t)( ( pump_params.ci & 0xff000000 ) >> 24 );
-  pump_data[length++] = (uint8_t)( ( pump_params.ci & 0x00ff0000 ) >> 16 );
-  pump_data[length++] = (uint8_t)( ( pump_params.ci & 0x0000ff00 ) >> 8 );
-  pump_data[length++] = (uint8_t)( ( pump_params.ci & 0x000000ff ) ); 
+  pump_data[length++] = (uint8_t)( ( pump_params->ci & 0xff000000 ) >> 24 );
+  pump_data[length++] = (uint8_t)( ( pump_params->ci & 0x00ff0000 ) >> 16 );
+  pump_data[length++] = (uint8_t)( ( pump_params->ci & 0x0000ff00 ) >> 8 );
+  pump_data[length++] = (uint8_t)( ( pump_params->ci & 0x000000ff ) ); 
   
   // 泵类型
   setPumpOption(101,1,pump_data,&length);
-  pump_data[length++] = pump_params.pumpType;
+  pump_data[length++] = pump_params->pumpType;
 
   // 输注编号
   setPumpOption(103,4,pump_data,&length);
-  pump_data[length++] = (uint8_t)( ( pump_params.infusionId & 0xff000000 ) >> 24 );
-  pump_data[length++] = (uint8_t)( ( pump_params.infusionId & 0x00ff0000 ) >> 16 );
-  pump_data[length++] = (uint8_t)( ( pump_params.infusionId & 0x0000ff00 ) >> 8 );
-  pump_data[length++] = (uint8_t)( pump_params.infusionId & 0x000000ff );
+  pump_data[length++] = (uint8_t)( ( pump_params->infusionId & 0xff000000 ) >> 24 );
+  pump_data[length++] = (uint8_t)( ( pump_params->infusionId & 0x00ff0000 ) >> 16 );
+  pump_data[length++] = (uint8_t)( ( pump_params->infusionId & 0x0000ff00 ) >> 8 );
+  pump_data[length++] = (uint8_t)( pump_params->infusionId & 0x000000ff );
 	
   // 数据编号
   setPumpOption(104,4,pump_data,&length);
-  pump_data[length++] = (uint8_t)( ( pump_params.dataNumber & 0xff000000 ) >> 24 );
-  pump_data[length++] = (uint8_t)( ( pump_params.dataNumber & 0x00ff0000 ) >> 16 );
-  pump_data[length++] = (uint8_t)( ( pump_params.dataNumber & 0x0000ff00) >> 8 );
-  pump_data[length++] = (uint8_t)( pump_params.dataNumber & 0x000000ff );
+  pump_data[length++] = (uint8_t)( ( pump_params->dataNumber & 0xff000000 ) >> 24 );
+  pump_data[length++] = (uint8_t)( ( pump_params->dataNumber & 0x00ff0000 ) >> 16 );
+  pump_data[length++] = (uint8_t)( ( pump_params->dataNumber & 0x0000ff00) >> 8 );
+  pump_data[length++] = (uint8_t)( pump_params->dataNumber & 0x000000ff );
 	
   // 住院号
   setPumpOption(105,8,pump_data,&length);
-	pump_data[length++] = (uint8_t)( ( pump_params.patientCode & 0xff00000000000000 ) >> 56 );
-  pump_data[length++] = (uint8_t)( ( pump_params.patientCode & 0x00ff000000000000 ) >> 48 );
-  pump_data[length++] = (uint8_t)( ( pump_params.patientCode & 0x0000ff0000000000 ) >> 40 );
-  pump_data[length++] = (uint8_t)( ( pump_params.patientCode & 0x000000ff00000000 ) >> 32 ); 
-  pump_data[length++] = (uint8_t)( ( pump_params.patientCode & 0x00000000ff000000 ) >> 24 );
-  pump_data[length++] = (uint8_t)( ( pump_params.patientCode & 0x0000000000ff0000 ) >> 16 );
-  pump_data[length++] = (uint8_t)( ( pump_params.patientCode & 0x000000000000ff00 ) >> 8 );
-  pump_data[length++] = (uint8_t)( ( pump_params.patientCode & 0x00000000000000ff ) ); 
+	pump_data[length++] = (uint8_t)( ( pump_params->patientCode & 0xff00000000000000 ) >> 56 );
+  pump_data[length++] = (uint8_t)( ( pump_params->patientCode & 0x00ff000000000000 ) >> 48 );
+  pump_data[length++] = (uint8_t)( ( pump_params->patientCode & 0x0000ff0000000000 ) >> 40 );
+  pump_data[length++] = (uint8_t)( ( pump_params->patientCode & 0x000000ff00000000 ) >> 32 ); 
+  pump_data[length++] = (uint8_t)( ( pump_params->patientCode & 0x00000000ff000000 ) >> 24 );
+  pump_data[length++] = (uint8_t)( ( pump_params->patientCode & 0x0000000000ff0000 ) >> 16 );
+  pump_data[length++] = (uint8_t)( ( pump_params->patientCode & 0x000000000000ff00 ) >> 8 );
+  pump_data[length++] = (uint8_t)( ( pump_params->patientCode & 0x00000000000000ff ) ); 
   
   // 持续量
   setPumpOption(106,2,pump_data,&length);
-  pump_data[length++] = (uint8_t)( ( pump_params.continueDose & 0xff00 ) >> 8 );
-  pump_data[length++] = (uint8_t)( ( pump_params.continueDose & 0x00ff ) ); 
+  pump_data[length++] = (uint8_t)( ( pump_params->continueDose & 0xff00 ) >> 8 );
+  pump_data[length++] = (uint8_t)( ( pump_params->continueDose & 0x00ff ) ); 
 	
   // 锁定时间
   setPumpOption(107,1,pump_data,&length);
-  pump_data[length++] = pump_params.lockTime; 
+  pump_data[length++] = pump_params->lockTime; 
 	 
   // 极限量
 	setPumpOption(108,1,pump_data,&length);
-	pump_data[length++] = pump_params.ultimateDose; 
+	pump_data[length++] = pump_params->ultimateDose; 
 	
 	// 首次量 
 	setPumpOption(109,1,pump_data,&length);
-	pump_data[length++] = pump_params.firstDose; 
+	pump_data[length++] = pump_params->firstDose; 
 	
 	// 追加量	
 	setPumpOption(110,1,pump_data,&length);
-	pump_data[length++] = pump_params.appendDose; 
+	pump_data[length++] = pump_params->appendDose; 
 	
 	// 总量
 	setPumpOption(111,2,pump_data,&length);
-	pump_data[length++] = (uint8_t)( ( pump_params.totalDose & 0xff00 ) >> 8 );
-	pump_data[length++] = (uint8_t)( pump_params.totalDose & 0x00ff );
+	pump_data[length++] = (uint8_t)( ( pump_params->totalDose & 0xff00 ) >> 8 );
+	pump_data[length++] = (uint8_t)( pump_params->totalDose & 0x00ff );
     
 	// 已输注量
 	setPumpOption(112,2,pump_data,&length);
-	pump_data[length++] = (uint8_t)( ( pump_params.finishDose & 0xff00 ) >> 8 );
-	pump_data[length++] = (uint8_t)( pump_params.finishDose & 0x00ff );
+	pump_data[length++] = (uint8_t)( ( pump_params->finishDose & 0xff00 ) >> 8 );
+	pump_data[length++] = (uint8_t)( pump_params->finishDose & 0x00ff );
 	
 	
 	// 有效追加次数
 	setPumpOption(113,1,pump_data,&length);
-	pump_data[length++] = pump_params.validTimes;
+	pump_data[length++] = pump_params->validTimes;
 	
 	// 无效追加次数
 	setPumpOption(114,1,pump_data,&length);
-	pump_data[length++] = pump_params.invalidTimes;
+	pump_data[length++] = pump_params->invalidTimes;
 	
 	// 报警
-	if(pump_params.alarm_BubbleOrAneroid == 1)
+	if(pump_params->alarm_BubbleOrAneroid == 1)
 	{
 		setPumpOption(115,1,pump_data,&length);
 		pump_data[length++] = 1; // 气泡或无液报警
 	}
 	
-	if(pump_params.alarm_Blocked == 1)
+	if(pump_params->alarm_Blocked == 1)
 	{
 		setPumpOption(115,1,pump_data,&length);
 		pump_data[length++] = 2; // 堵塞报警
 	}
 	
-	if(pump_params.alarm_Total == 1)
+	if(pump_params->alarm_Total == 1)
 	{
 		setPumpOption(115,1,pump_data,&length);
 		pump_data[length++] = 3; // 输入总量报警 
 	}
 	
-	if(pump_params.alarm_Ultimate == 1)
+	if(pump_params->alarm_Ultimate == 1)
 	{
 		setPumpOption(115,1,pump_data,&length);
 		pump_data[length++] = 4; // 极限量报警 
 	}
 	
-	if(pump_params.alarm_LowPower == 1)
+	if(pump_params->alarm_LowPower == 1)
 	{
 		setPumpOption(115,1,pump_data,&length);
 		pump_data[length++] = 5; // 电量耗尽报警
 	}
 	
-	if(pump_params.alarm_Finished == 1)
+	if(pump_params->alarm_Finished == 1)
 	{
 		setPumpOption(115,1,pump_data,&length);
 		pump_data[length++] = 6; // 输液结束报警
 	}
 	
-	if(pump_params.alarm_MotorOutofcontrol ==1)
+	if(pump_params->alarm_MotorOutofcontrol ==1)
 	{
 		setPumpOption(115,1,pump_data,&length);
 		pump_data[length++] = 7; // 电机失控报警
 	}
 	
-	if(pump_params.alarm_MechanicalBreakdown ==1)
+	if(pump_params->alarm_MechanicalBreakdown ==1)
 	{
 		setPumpOption(115,1,pump_data,&length);
 		pump_data[length++] = 8; // 机械故障报警
 	}
 	
-	if(pump_params.alarm_UnfilledPillBox ==1)
+	if(pump_params->alarm_UnfilledPillBox ==1)
 	{
 		setPumpOption(115,1,pump_data,&length);
 		pump_data[length++] = 9; // 未装药盒报警
 	}
 	
 	// 预报
-	if(pump_params.forcast_WillFinished ==1)
+	if(pump_params->forcast_WillFinished ==1)
 	{
 		setPumpOption(116,1,pump_data,&length);
 		pump_data[length++] = 1; // 输液将结束
 	}
 	
-	if(pump_params.forcast_InsufficientAnalgesia ==1)
+	if(pump_params->forcast_InsufficientAnalgesia ==1)
 	{
 		setPumpOption(116,1,pump_data,&length);
 		pump_data[length++] = 2; // 镇痛不足
 	}
 	
-	if(pump_params.forcast_LowPowerForecast ==1)
+	if(pump_params->forcast_LowPowerForecast ==1)
 	{
 		setPumpOption(116,1,pump_data,&length);
 		pump_data[length++] = 3; // 电量偏低
@@ -285,41 +285,41 @@ void business_protocol_encode(struct Pump_Params pump_params, uint8_t * pump_dat
 	// 运行状态
 	setPumpOption(117,1,pump_data,&length);
 	
-	if( pump_params.runStatus == 0 )pump_data[length++] = 0; // 关机
+	if( pump_params->runStatus == 0 )pump_data[length++] = 0; // 关机
 	
-	if( pump_params.runStatus == 1 )pump_data[length++] = 1; // 开机
+	if( pump_params->runStatus == 1 )pump_data[length++] = 1; // 开机
 	
-	if( pump_params.runStatus == 2 )pump_data[length++] = 2; // 运行
+	if( pump_params->runStatus == 2 )pump_data[length++] = 2; // 运行
 	
-	if( pump_params.runStatus == 3 )pump_data[length++] = 3; // 暂停
+	if( pump_params->runStatus == 3 )pump_data[length++] = 3; // 暂停
 
-	if( pump_params.runStatus == 4 )pump_data[length++] = 4; // 待机
+	if( pump_params->runStatus == 4 )pump_data[length++] = 4; // 待机
 	
 	// 电量
 	setPumpOption(118,1,pump_data,&length);
-	pump_data[length++] = pump_params.electricity;
+	pump_data[length++] = pump_params->electricity;
 	
   // 脉冲量锁时
 	setPumpOption(121,1,pump_data,&length);
-	pump_data[length++] = pump_params.pulseLockTime; 
+	pump_data[length++] = pump_params->pulseLockTime; 
 	
 	// 脉冲首次锁时
 	setPumpOption(122,1,pump_data,&length);
-	pump_data[length++] = pump_params.firstLockTime; 
+	pump_data[length++] = pump_params->firstLockTime; 
 	
 	// 脉冲量
 	setPumpOption(123,1,pump_data,&length);
-	pump_data[length++] = pump_params.pulseDose; 
+	pump_data[length++] = pump_params->pulseDose; 
 	
 	//病区
 	setPumpOption(124,2,pump_data,&length);
-	pump_data[length++] = (uint8_t)( ( pump_params.ward & 0xff00 ) >> 8 );
-	pump_data[length++] = (uint8_t)( pump_params.ward & 0x00ff );
+	pump_data[length++] = (uint8_t)( ( pump_params->ward & 0xff00 ) >> 8 );
+	pump_data[length++] = (uint8_t)( pump_params->ward & 0x00ff );
 	
 	//床号
 	setPumpOption(125,2,pump_data,&length);
-	pump_data[length++] = (uint8_t)( ( pump_params.bedNo & 0xff00 ) >> 8 );
-	pump_data[length++] = (uint8_t)( pump_params.bedNo & 0x00ff );
+	pump_data[length++] = (uint8_t)( ( pump_params->bedNo & 0xff00 ) >> 8 );
+	pump_data[length++] = (uint8_t)( pump_params->bedNo & 0x00ff );
 	
 	*pump_data_length = length;
 }
@@ -332,9 +332,8 @@ void business_protocol_encode(struct Pump_Params pump_params, uint8_t * pump_dat
 * 输出>>
 * pump_params 泵参数。
 **/
-struct Pump_Params business_protocol_decode(uint8_t * pump_data, uint16_t * pump_data_length)
+void PUMPDICTS_ProtocolDecode(struct PUMPDICTS_ParamsStruct * pump_params, uint8_t * pump_data, uint16_t * pump_data_length)
 {
-	struct Pump_Params pump_params;
-	return pump_params;
+	
 }
 

Drivers/Utils/Pump_Dicts_Util.h

@@ -10,7 +10,7 @@
 #define __PUMP_DICTS_UTIL_H
 #include <stdint.h>
 
-struct Pump_Params{
+struct PUMPDICTS_ParamsStruct{
 	uint16_t userId; // 编号1，用户编号；医院编号。
 	uint8_t networkType; // 编号2，网络类型。
 	uint16_t lac; // 编号5，基站ID。
@@ -49,7 +49,6 @@ struct Pump_Params{
 	uint16_t bedNo; // 编号125，床号。
 };
 
-void setPumpheader(void);
 
 /** 
 * 协议编码
@@ -59,7 +58,7 @@ void setPumpheader(void);
 * pump_data 编码后的二进制数据。
 * pump_data_length 编码后的二进制数据的长度。
 **/
-void business_protocol_encode(struct Pump_Params pump_params, uint8_t * pump_data, uint16_t * pump_data_length);
+void PUMPDICTS_ProtocolEncode(struct PUMPDICTS_ParamsStruct * pump_params, uint8_t * pump_data, uint16_t * pump_data_length);
 
 /** 
 * 协议解码
@@ -69,7 +68,7 @@ void business_protocol_encode(struct Pump_Params pump_params, uint8_t * pump_dat
 * 输出>>
 * pump_params 泵参数。
 **/
-struct Pump_Params business_protocol_decode(uint8_t * pump_data, uint16_t * pump_data_length);
+void PUMPDICTS_ProtocolDecode(struct PUMPDICTS_ParamsStruct * pump_params, uint8_t * pump_data, uint16_t * pump_data_length);
 
 
 #endif

Hardware/FlashSetup.c

@@ -0,0 +1,57 @@
+/*--------------------------------------------------------------------------------------
+*  @file     FlashSetup.c
+*  @author   ZhangJing
+*  @version  base on stm32f0x   
+*  @date     2015.09.11
+*  @brief    芯片内部flash驱动
+---------------------------------------------------------------------------------------*/
+
+#include "stm32f10x_flash.h"
+#include "FlashSetup.h"
+
+/*********************************************************************************
+*  Function:	FlashWriteOperate						                                                           
+*  Object:		flash写操作
+*  输入:			uint8_t *writeDataBuf,uint16_t writeLen,uint32_t writeAddress
+*  输出:			无	                                     
+*  备注:			内部flash一次写两个字节，先根据相应地址进行擦除，再写入              
+**********************************************************************************/
+void FlashWriteOperate( uint8_t *writeDataBuf,uint16_t writeLen,uint32_t writeAddress )
+{
+	uint16_t 	i;
+	uint16_t	tempWriteData;
+	FLASH_Unlock();
+	FLASH_ClearFlag( FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR );
+	//if(( writeAddress == HISTORY_RECORDQTY_ADDR) || (writeAddress == PARAMSET_DATA_START_ADDR ) || (writeAddress == HISTORY_DATA_START_ADDR ))
+	{
+		FLASH_ErasePage(writeAddress);
+	}
+	for( i = 0;i < writeLen / 2;i++ )
+	{
+		tempWriteData = writeDataBuf[i*2];
+		tempWriteData <<= 8;
+		tempWriteData += writeDataBuf[i*2+1];
+		FLASH_ProgramHalfWord((writeAddress + i*2),tempWriteData);
+	}
+	FLASH_Lock();
+}
+
+/*********************************************************************************
+*  Function:	FlashReadOperate						                                                           
+*  Object:		flash读操作
+*  输入:			uint8_t *readDataBuf,uint16_t readLen,uint32_t readAddress
+*  输出:			无	                                     
+*  备注:			内部flash可以按单个字节读取              
+**********************************************************************************/
+void FlashReadOperate( uint8_t *readDataBuf,uint16_t readLen,uint32_t readAddress)
+{
+	uint16_t i;
+	uint16_t	tempData = 0;//临时变量
+	for( i = 0;i < readLen / 2;i++ )
+	{
+		tempData = *(uint16_t *)( readAddress + i * 2 );
+		readDataBuf[i * 2] = tempData / 256;
+		readDataBuf[i * 2 + 1] = tempData % 256;
+	}
+}
+

Hardware/FlashSetup.h

@@ -0,0 +1,34 @@
+#ifndef __FLASHSETUP_H__
+#define __FLASHSETUP_H__
+/*--------------------------------------------------------------------------------------
+*  @file     FlashSetup.h
+*  @author   ZhangJing
+*  @version  base on stm32f0x   
+*  @date     2015.09.11
+*  @brief    芯片内部flash驱动
+---------------------------------------------------------------------------------------*/
+#include "stdint.h"
+
+/*给应用程序分配400Kflash空间 0x08000000~0x08063FFF*/ //0~199页用于存储数据
+/*给设置参数数据分配2Kflash空间 0x08064000~0x080647FF*/
+#define FLASH_PAGE_SIZE    				((uint16_t)0x800)//定义页的大小，对于大容量器件页的大小为0X800字节
+#define PARAMSET_DATA_START_ADDR	((uint32_t)0x08064000)//0x08064000  200页
+#define PARAMSET_DATA_END_ADDR		((uint32_t)0x080647FF)//0x080647FF
+
+#define HISTORY_DATA_START_ADDR		((uint32_t)0x08064800)//0x08064800  201页
+#define HISTORY_DATA_END_ADDR			((uint32_t)0x08064FFF)//0x08064FFF
+#define HISTORY_DATA_SIZE					((uint16_t)0x1000)	//给历史数据分配4096字节大小	
+
+#define HISTORY_RECORDQTY_ADDR		((uint32_t)0x08069800)//历史数据存储数量 211页
+#define HISTORY_RECORDQTY_SIZE		6											//历史数据存储数量占2个字节,历史数据存储指针占2个字节
+
+#define HISTORY31256_DATA_InputTotalDose		((uint32_t)0x0806A000)//历史数据存储数量 212页
+
+#define PROGRAM_INFO_ADDR	          ((uint32_t)0x0806A800)//0x0806A800 程序参数信息213页 add by wulianwei
+#define PROGRAM_INFO_SIZE   600
+
+
+
+void FlashWriteOperate( uint8_t *writeDataBuf,uint16_t writeLen,uint32_t writeAddress);
+void FlashReadOperate( uint8_t *readDataBuf,uint16_t readLen,uint32_t readAddress);
+#endif

User/main.c

@@ -33,6 +33,8 @@ static struct TIMER_Struct timer;
 //static char AT_CMD[512];
 //static char pridnsaddr[20];
 
+static uint8_t regist_flag = 0;
+
 int main(void)
 {
 //	uint8_t memmem_flag = 0;
@@ -46,74 +48,62 @@ int main(void)
 	OLED_ShowString(1, 1, "MS:");
 	
 	Log_Printf_Debug("1234\r\n");
+	
+	// 通讯流程初始化
+	PUMPBUSINESS_Init();
 //	my_delay_ms(5000);
 	
 	//注册设备
-	if(regist_get_result() == Regist_Result_None)
-	{
-		uint8_t state = regist_device_sync();
-		if(state == 1)
-		{
-			// 注册成功
-		}
-		else
-		{
-			// 注册失败
-		}
-	}
-	
-	Log_Printf_Debug("注册结束\r\n");
+//	if(regist_get_result() == Regist_Result_None)
+//	{
+//		uint8_t state = regist_device_sync();
+//		if(state == 1)
+//		{
+//			// 注册成功
+//		}
+//		else
+//		{
+//			// 注册失败
+//		}
+//	}
+//	
+//	Log_Printf_Debug("注册结束\r\n");
+//	
+//	Log_Printf_Debug("code: %d", regist_get_result());
 	
 	while(1)
 	{
 		// 循环执行udp客户端OLED_ShowNum
 		OLED_ShowNum(1, 4, time_get_delay(&timer), 6);
-		
 		if(time_get_delay(&timer) > 60 * 1000)
 		{
-			
-			
 			time_clear(&timer);
 		}
 		
 		
-//		if(send_flag == 1)
-//		{
-//			enum Result result = bc260y.exit_sleep_2_sync();
-//			if(result==Result_Success)
-//			{
-//				Log_Printf_Debug("退出休眠成功\r\n");
-//				result = bc260y.set_qisde_sync(1);//开启回显
-//			}
-//			if(result==Result_Success)
-//			{
-//				Log_Printf_Debug("开启回显成功\r\n");
-//				memset(pridnsaddr, 0, sizeof(pridnsaddr));
-//				result = bc260y.query_dns_sync(pridnsaddr); // 查询DNS
-//				Log_Printf_Debug("DNS: %s, %d\r\n", pridnsaddr, strlen(pridnsaddr));
-//			}
-//			if(result==Result_Success)
-//			{
-//				Log_Printf_Debug("查询DNS成功\r\n");
-//				if(strlen(pridnsaddr) <= 1)
-//				{
-//					result = bc260y.set_dns_sync("114.114.114.114", "8.8.8.8"); // 设置DNS
-//					if(result==Result_Success)
-//					{
-//						Log_Printf_Debug("设置DNS成功\r\n");
-//						memset(pridnsaddr, 0, sizeof(pridnsaddr));
-//						result = bc260y.query_dns_sync(pridnsaddr); // 查询DNS
-//						Log_Printf_Debug("DNS: %s, %d\r\n", pridnsaddr, strlen(pridnsaddr));
-//					}
-//				}
-//				
-//			}
-//			
-//			send_flag = 0;
-//		}
-//		AT_Handle();
+		// 注册接口使用方法
+		if(regist_flag == 0)
+		{
+			if(REGIST_GetResult() != REGIST_Result_Success)
+			{
+				Log_Printf_Debug("开始注册\r\n");
+				// 开始注册
+				REGIST_Start();
+				regist_flag = 1;
+			}
+			else
+			{
+				Log_Printf_Debug("已注册\r\n");
+			}
+		}
+		
+		
+			
+		
+		
 		
-		pump_business_loop_execution();
+		// 通讯流程处理
+		PUMPBUSINESS_ProcessHandle();