【Io开发笔记】机智云智能浇花器实战(3)-自动生成代码移植

毛球大大

【Io开发笔记】机智云智能浇花器实战(3)-自动生成代码移植 [复制链接]

第一篇内容：总体设计/系统功能介绍/机智云自助开发平台-开发利器GAgent等等
点击下载：【Io开发笔记】机智云智能浇花器实战(1)-基础Demo实现

第二篇内容：
继电器实现/功能测试/DHT11驱动代码实现/OLED屏幕显示传感器数据/中文字模制作等等
点击下载：机智云智能浇花器实战(2)-基础Demo实现


一，BH1750光照传感器原理图

二，BH1750传感器代码

1. #include "bh1750.h"
2. #include "delay.h"
3.  
4. uint8_t    BUF[8];               //接收数据缓存区  
5. int         mcy;     //进位标志
6.  
7. /**开始信号**/
8. void BH1750_Start()
9. {
10.   BH1750_SDA_H;                                               //拉高数据线
11.   BH1750_SCL_H;                                               //拉高时钟线
12.   Delay_nus(5);                                         //延时
13.   GPIO_ResetBits(BH1750_PORT, BH1750_SDA_PIN);                    //产生下降沿
14.   Delay_nus(5);                                         //延时
15.   GPIO_ResetBits(BH1750_PORT, BH1750_SCL_PIN);                    //拉低时钟线
16. }
17.  
18. /***停止信号***/
19. void BH1750_Stop()
20. {
21.     BH1750_SDA_L;                                             //拉低数据线
22.     BH1750_SCL_H;                                             //拉高时钟线
23.     Delay_nus(5);                                       //延时
24.     GPIO_SetBits(BH1750_PORT, BH1750_SDA_PIN);                    //产生上升沿
25.     Delay_nus(5);                 //延时
26. }
27.  
28. /******************
29. 发送应答信号
30. 入口参数:ack (0:ACK 1:NAK)
31. ******************/
32. void BH1750_SendACK(int ack)
33. {
34.         GPIO_InitTypeDef GPIO_InitStruct;
35.         
36.   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;  
37.   GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
38.   GPIO_InitStruct.GPIO_Pin = BH1750_SDA_PIN;
39.   GPIO_Init(BH1750_PORT, &GPIO_InitStruct);  
40.         
41.         if(ack == 1)   //写应答信号
42.                 BH1750_SDA_H;
43.         else if(ack == 0)
44.                 BH1750_SDA_L;
45.         else
46.                 return;                        
47.   BH1750_SCL_H;     //拉高时钟线
48.   Delay_nus(5);                 //延时
49.   BH1750_SCL_L;      //拉低时钟线
50.   Delay_nus(5);                //延时
51. }
52.  
53. /******************
54. 接收应答信号
55. ******************/
56. int BH1750_RecvACK()
57. {
58.   GPIO_InitTypeDef GPIO_InitStruct;
59.         
60.   GPIO_InitStruct.GPIO_Mode=GPIO_Mode_IPU;  /*这里一定要设成输入上拉，否则不能读出数据*/
61.   GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;
62.   GPIO_InitStruct.GPIO_Pin=BH1750_SDA_PIN;
63.   GPIO_Init(BH1750_PORT,&GPIO_InitStruct);
64.         
65.   BH1750_SCL_H;            //拉高时钟线
66.   Delay_nus(5);                 //延时        
67.         if(GPIO_ReadInputDataBit(BH1750_PORT,BH1750_SDA_PIN)==1)//读应答信号
68.     mcy = 1 ;  
69.   else
70.     mcy = 0 ;                                
71.   BH1750_SCL_L;                    //拉低时钟线
72.   Delay_nus(5);                 //延时
73.   GPIO_InitStruct.GPIO_Mode=GPIO_Mode_Out_PP;
74.   GPIO_Init(BH1750_PORT,&GPIO_InitStruct);
75.         return mcy;
76. }
77.  
78. /******************
79. 向IIC总线发送一个字节数据
80. ******************/
81. void BH1750_SendByte(uint8_t dat)
82. {
83.   uint8_t i;
84.   for (i=0; i<8; i++)         //8位计数器
85.   {
86.                 if( 0X80 & dat )
87.       GPIO_SetBits(BH1750_PORT,BH1750_SDA_PIN);
88.     else
89.       GPIO_ResetBits(BH1750_PORT,BH1750_SDA_PIN);
90.                 dat <<= 1;
91.     BH1750_SCL_H;               //拉高时钟线
92.     Delay_nus(5);             //延时
93.     BH1750_SCL_L;                //拉低时钟线
94.     Delay_nus(5);            //延时
95.   }
96.   BH1750_RecvACK();
97. }
98.  
99. uint8_t BH1750_RecvByte()
100. {
101.   uint8_t i;
102.   uint8_t dat = 0;
103.   uint8_t bit;
104.         
105.   GPIO_InitTypeDef GPIO_InitStruct;
106.         
107.   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_IPU;   /*这里一定要设成输入上拉，否则不能读出数据*/
108.   GPIO_InitStruct.GPIO_Pin   = BH1750_SDA_PIN;
109.   GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
110.   GPIO_Init(BH1750_PORT,&GPIO_InitStruct );
111.         
112.   GPIO_SetBits(BH1750_PORT,BH1750_SDA_PIN);          //使能内部上拉,准备读取数据,
113.   for (i=0; i<8; i++)         //8位计数器
114.   {
115.     dat <<= 1;
116.     BH1750_SCL_H;               //拉高时钟线
117.     Delay_nus(5);             //延时
118.                         
119.                 if( SET == GPIO_ReadInputDataBit(BH1750_PORT,BH1750_SDA_PIN))
120.       bit = 0X01;
121.     else
122.       bit = 0x00;  
123.                 dat |= bit;             //读数据   
124.                 BH1750_SCL_L;                //拉低时钟线
125.     Delay_nus(5);            //延时
126.   }               
127.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
128.   GPIO_Init(BH1750_PORT, &GPIO_InitStruct );
129.   return dat;
130. }
131.  
132. void Single_Write_BH1750(uint8_t REG_Address)
133. {
134.   BH1750_Start();                  //起始信号
135.   BH1750_SendByte(SlaveAddress);   //发送设备地址+写信号
136.   BH1750_SendByte(REG_Address);    //内部寄存器地址，请参考中文pdf22页
137. //  BH1750_SendByte(REG_data);       //内部寄存器数据，请参考中文pdf22页
138.   BH1750_Stop();                   //发送停止信号
139. }
140.  
141. //初始化BH1750，根据需要请参考pdf进行修改**
142. void BH1750_Init()
143. {
144.   GPIO_InitTypeDef GPIO_InitStruct;
145.          /*开启GPIOB的外设时钟*/
146.   RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE);
147.   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;  
148.   GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
149.   GPIO_InitStruct.GPIO_Pin = BH1750_SDA_PIN | BH1750_SCL_PIN ;
150.   GPIO_Init(BH1750_PORT,&GPIO_InitStruct);
151.         
152.   Single_Write_BH1750(0x01);  
153.   Delay_nms(180);            //延时180ms
154. }
155.  
156. //连续读出BH1750内部数据
157. void mread(void)
158. {   
159.   uint8_t i;        
160.   BH1750_Start();                          //起始信号
161.   BH1750_SendByte(SlaveAddress+1);         //发送设备地址+读信号
162.         
163.         for (i=0; i<3; i++)                      //连续读取6个地址数据，存储中BUF
164.   {
165.     BUF = BH1750_RecvByte();          //BUF[0]存储0x32地址中的数据
166.     if (i == 3)
167.     {
168.       BH1750_SendACK(1);                //最后一个数据需要回NOACK
169.     }
170.     else
171.     {               
172.       BH1750_SendACK(0);                //回应ACK
173.     }
174.   }
175.   BH1750_Stop();                          //停止信号
176.   Delay_nms(5);
177. }
178.  
179. float Read_BH1750(void)
180. {
181.   int dis_data;                       //变量        
182.         float temp1;
183.         float temp2;
184.         Single_Write_BH1750(0x01);   // power on
185.         Single_Write_BH1750(0x10);   // H- resolution mode
186.         Delay_nms(180);              //延时180ms
187.         mread();                     //连续读出数据，存储在BUF中
188.         dis_data=BUF[0];
189.         dis_data=(dis_data<<8)+BUF[1]; //合成数据
190.         temp1=dis_data/1.2;
191.         temp2=10*dis_data/1.2;        
192.         temp2=(int)temp2%10;
193.         return temp1;
194. }
195.  

复制代码

 

1. #ifndef __BH1750_H__
2. #define __BH1750_H__
3.  
4. #include "STM32f10x.h"
5.  
6. /*
7.         定义器件在IIC总线中的从地址,根据ALT  ADDRESS地址引脚不同修改
8.         ALT  ADDRESS引脚接地时地址为0x46，   接电源时地址为0xB8
9. */
10. #define        SlaveAddress     0x46                     
11. #define BH1750_PORT      GPIOB
12. #define BH1750_SCL_PIN   GPIO_Pin_1
13. #define BH1750_SDA_PIN   GPIO_Pin_0
14.  
15. #define BH1750_SCL_H     GPIO_SetBits(BH1750_PORT,BH1750_SCL_PIN)
16. #define BH1750_SCL_L     GPIO_ResetBits(BH1750_PORT,BH1750_SCL_PIN)
17.  
18. #define BH1750_SDA_H     GPIO_SetBits(BH1750_PORT,BH1750_SDA_PIN)
19. #define BH1750_SDA_L     GPIO_ResetBits(BH1750_PORT,BH1750_SDA_PIN)  
20.  
21.                                              
22.                                                                                                                         
23. extern uint8_t    BUF[8];                         //接收数据缓存区              
24. extern int        dis_data;                       //变量               
25. extern int        mcy;                            //表示进位标志位
26.  
27. void BH1750_Init(void);
28. void conversion(uint32_t temp_data);
29. void  Single_Write_BH1750(uint8_t REG_Address);    //单个写入数据
30. uint8_t Single_Read_BH1750(uint8_t REG_Address);   //单个读取内部寄存器数据
31. void  mread(void);                                 //连续的读取内部寄存器数据
32. float Read_BH1750(void);
33.  
34.  
35. #endif
36.  
37.  

复制代码

BH1750传感器代码说明

核心板单独测试程序在PB0PB1管脚是完全正常，不知道是不是核心板的PB2上接了什么暂时还未排查出来问题，如果你是用开发板或者是自己设计的项目板的话，那么程序是直接可以使用的程序依然按照PB0PB1保留。


三，机智云自助开发平台数据点创建
机智云官方网站：https://www.gizwits.com/
步骤1，创建产品



创建好后就会有基本信息




步骤2，填写机智云产品ProductKey


这两个信息比较重要最好是保存下来

 

 

1.  
2. Product Key ：9c8a5a8e38344fb4af14b6db0f5b1df7
3.  
4. Product Secret ：45c86d8c6a2a4b1dac7d68df54f6e4f0
5.  

复制代码

 

步骤3，定义自己的数据点

只读：就是只允许赋值数据传感器赋值给平台平台只能读取
可写：就是数据可以被修改继电器的开关状态平台可以修改

四，MCU开发


mcu开发注意事项平台选Common其实就是STM32F103x平台



1，生成代码包


2，下载自动生成的代码包

3，机智云Gizwits协议移植




这两个文件夹要添加到自己的工程

这是添加的文件夹以及文件的目录

4，修改gizwits_product.c

 

 

 

1. #include <stdio.h>
2. #include <string.h>
3. #include "gizwits_product.h"
4. #include "usart3.h"
5.  
6. static uint32_t timerMsCount;
7. uint8_t aRxBuffer;
8. dataPoint_t currentDataPoint;
9. uint8_t wifi_flag;
10.  
11. //存放事件处理API接口函数
12. int8_t gizwitsEventProcess(eventInfo_t *info, uint8_t *gizdata, uint32_t len)
13. {
14.   uint8_t i = 0;
15.   dataPoint_t *dataPointPtr = (dataPoint_t *)gizdata;
16.   moduleStatusInfo_t *wifiData = (moduleStatusInfo_t *)gizdata;
17.   protocolTime_t *ptime = (protocolTime_t *)gizdata;
18.   
19. #if MODULE_TYPE
20.   gprsInfo_t *gprsInfoData = (gprsInfo_t *)gizdata;
21. #else
22.   moduleInfo_t *ptModuleInfo = (moduleInfo_t *)gizdata;
23. #endif
24.  
25.   if((NULL == info) || (NULL == gizdata))
26.   {
27.     return -1;
28.   }
29.  
30.   for(i=0; i<info->num; i++)
31.   {
32.     switch(info->event)
33.     {
34.       case EVENT_Relay_1:
35.         currentDataPoint.valueRelay_1 = dataPointPtr->valueRelay_1;
36.         GIZWITS_LOG("Evt: EVENT_Relay_1 %d \n", currentDataPoint.valueRelay_1);
37.         if(0x01 == currentDataPoint.valueRelay_1)
38.         {
39.             currentDataPoint.valueRelay_1 = 1;
40.  
41.         }
42.         else
43.         {
44.             currentDataPoint.valueRelay_1 = 0;
45.  
46.         }
47.         break;
48.       case WIFI_SOFTAP:
49.         break;
50.       case WIFI_AIRLINK:
51.         break;
52.       case WIFI_STATION:
53.         break;
54.       case WIFI_CON_ROUTER:
55.  
56.         break;
57.       case WIFI_DISCON_ROUTER:
58.  
59.         break;
60.       case WIFI_CON_M2M:
61.                wifi_flag = 1; //WiFi连接标志
62.         break;
63.       case WIFI_DISCON_M2M:
64.                wifi_flag = 0; //WiFi断开标志
65.         break;
66.       case WIFI_RSSI:
67.         GIZWITS_LOG("RSSI %d\n", wifiData->rssi);
68.         break;
69.       case TRANSPARENT_DATA:
70.         GIZWITS_LOG("TRANSPARENT_DATA \n");
71.         //user handle , Fetch data from [data] , size is [len]
72.         break;
73.       case WIFI_NTP:
74.         GIZWITS_LOG("WIFI_NTP : [%d-%d-%d %02d:%02d:%02d][%d] \n",ptime->year,ptime->month,ptime->day,ptime->hour,ptime->minute,ptime->second,ptime->ntp);
75.         break;
76.       case MODULE_INFO:
77.             GIZWITS_LOG("MODULE INFO ...\n");
78.       #if MODULE_TYPE
79.             GIZWITS_LOG("GPRS MODULE ...\n");
80.             //Format By gprsInfo_t
81.       #else
82.             GIZWITS_LOG("WIF MODULE ...\n");
83.             //Format By moduleInfo_t
84.             GIZWITS_LOG("moduleType : [%d] \n",ptModuleInfo->moduleType);
85.       #endif
86.     break;
87.       default:
88.         break;
89.     }
90.   }
91.  
92.   return 0;
93. }
94.  
95.  
96. void userHandle(void)
97. {
98. /*
99.     currentDataPoint.valueTemp = ;//Add Sensor Data Collection
100.     currentDataPoint.valueHumi = ;//Add Sensor Data Collection
101.     currentDataPoint.valueLight_Intensity = ;//Add Sensor Data Collection
102. */
103. }
104. void userInit(void)
105. {
106.     memset((uint8_t*)¤tDataPoint, 0, sizeof(dataPoint_t));
107.                 currentDataPoint.valueRelay_1         = 0;
108.                 currentDataPoint.valueTemp            = 0;
109.                 currentDataPoint.valueHumi            = 0;
110.                 currentDataPoint.valueLight_Intensity = 0;
111. }
112.  
113. void gizTimerMs(void)
114. {
115.     timerMsCount++;
116. }
117.  
118. uint32_t gizGetTimerCount(void)
119. {
120.     return timerMsCount;
121. }
122.  
123. void mcuRestart(void)
124. {
125.         __set_FAULTMASK(1);
126.         NVIC_SystemReset();
127. }
128.  
129. void TIMER_IRQ_FUN(void)
130. {
131.   gizTimerMs();
132. }
133.  
134. void UART_IRQ_FUN(void)
135. {
136.   uint8_t value = 0;
137.   gizPutData(&value, 1);
138. }
139.  
140. int32_t uartWrite(uint8_t *buf, uint32_t len)
141. {
142.     uint32_t i = 0;
143.         
144.     if(NULL == buf)
145.     {
146.         return -1;
147.     }
148.    
149.     for(i=0; i<len; i++)
150.     {
151.         USART_SendData(USART3,buf);
152.         while(USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET); //循环发送,直到发送完毕
153.         if(i >=2 && buf == 0xFF)
154.         {
155.             USART_SendData(USART3, 0x55);
156.             while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET); //循环发送,直到发送完毕
157.         }
158.     }
159.     return len;
160. }
161.  

复制代码

5，修改

 

 

 

1. #ifndef _GIZWITS_PRODUCT_H
2. #define _GIZWITS_PRODUCT_H
3.  
4. #ifdef __cplusplus
5. extern "C" {
6. #endif
7.  
8. #include <stdint.h>
9. //#include "stm32f1xx.h"
10. #include "gizwits_protocol.h"
11.  
12. /**
13. * MCU software version
14. */
15. #define SOFTWARE_VERSION "03030000"
16. /**
17. * MCU hardware version
18. */
19. #define HARDWARE_VERSION "03010100"
20.  
21.  
22. /**
23. * Communication module model
24. */
25. #define MODULE_TYPE 0 //0,WIFI ;1,GPRS
26.  
27.  
28. /**@name TIM3 related macro definition
29. * @{
30. */
31. #define TIMER                                             TIM3
32. #define TIMER_IRQ                                   TIM3_IRQn
33. #define TIMER_RCC                                   RCC_APB1Periph_TIM3
34. #define TIMER_IRQ_FUN                         TIM3_IRQHandler
35. /**@} */
36.  
37. /**@name USART related macro definition
38. * @{
39. */
40. #define UART_BAUDRATE                         9600
41. #define UART_PORT                             2
42. #define UART                                  USART2
43. #define UART_IRQ                              USART2_IRQn
44. #define UART_IRQ_FUN                          USART2_IRQHandler
45.  
46. #if (UART_PORT == 1)
47. #define UART_GPIO_Cmd          RCC_APB2PeriphClockCmd
48. #define UART_GPIO_CLK          RCC_APB2Periph_GPIOA
49.  
50. #define UART_AFIO_Cmd          RCC_APB2PeriphClockCmd
51. #define UART_AFIO_CLK          RCC_APB2Periph_AFIO
52.  
53. #define UART_CLK_Cmd           RCC_APB2PeriphClockCmd
54. #define UART_CLK               RCC_APB2Periph_USART1
55.  
56. #define UART_GPIO_PORT         GPIOA
57. #define UART_RxPin             GPIO_Pin_10
58. #define UART_TxPin             GPIO_Pin_9
59. #endif
60.  
61. #if (UART_PORT == 2)
62. #define UART_GPIO_Cmd          RCC_APB2PeriphClockCmd
63. #define UART_GPIO_CLK          RCC_APB2Periph_GPIOA
64.  
65. #define UART_AFIO_Cmd          RCC_APB2PeriphClockCmd
66. #define UART_AFIO_CLK          RCC_APB2Periph_AFIO
67.  
68. #define UART_CLK_Cmd           RCC_APB1PeriphClockCmd
69. #define UART_CLK               RCC_APB1Periph_USART2
70.  
71. #define UART_GPIO_PORT         GPIOA
72. #define UART_RxPin             GPIO_Pin_3
73. #define UART_TxPin             GPIO_Pin_2
74. #endif
75.  
76.  
77. #if (UART_PORT == 3)
78.  
79. #define UART_GPIO_Cmd          RCC_APB2PeriphClockCmd
80. #define UART_GPIO_CLK          RCC_APB2Periph_GPIOC
81.  
82. #define UART_AFIO_Cmd          RCC_APB2PeriphClockCmd
83. #define UART_AFIO_CLK          RCC_APB2Periph_AFIO
84.  
85. #define UART_CLK_Cmd           RCC_APB1PeriphClockCmd
86. #define UART_CLK               RCC_APB1Periph_USART3
87.  
88. #define UART_GPIO_PORT         GPIOC
89. #define UART_RxPin             GPIO_Pin_11
90. #define UART_TxPin             GPIO_Pin_10
91.  
92. #endif
93. /**@} */
94.  
95. /** User area the current device state structure*/
96. extern dataPoint_t currentDataPoint;
97.  
98. void gizTimerMs(void);
99. uint32_t gizGetTimerCount(void);
100. void timerInit(void);
101. void uartInit(void);
102.  
103. void userInit(void);
104. void userHandle(void);
105. void mcuRestart(void);
106.  
107. int32_t uartWrite(uint8_t *buf, uint32_t len);
108. int8_t gizwitsEventProcess(eventInfo_t *info, uint8_t *data, uint32_t len);
109.  
110. #ifdef __cplusplus
111. }
112. #endif
113.  
114. #endif
115.  

复制代码

5，修改gizwits_product.h
Listitem
Listitem
Listitem
Listitem
Listitem

 

 

1. /**
2. ***************************
3. * @File          gizwits_protocol.c
4. * @brief         Corresponding gizwits_product.c header file (including product hardware and software version definition)
5. * @author        Gizwits
6. * @date          2017-07-19
7. * @version       V03030000
8. * @copyright    Gizwits
9. *
10. * @note         机智云.只为智能硬件而生
11. *               Gizwits Smart Cloud  for Smart Products
12. *               链接|增值ֵ|开放|中立|安全|自有|自由|生态
13. *               www.gizwits.com
14. *
15. ***************************/
16. //#include "ringBuffer.h"
17. //#include "gizwits_product.h"
18. //#include "dataPointTools.h"
19. #include "delay.h"
20. /** Protocol global variables **/
21. //gizwitsProtocol_t gizwitsProtocol;
22. //extern dataPoint_t currentDataPoint;
23. //extern uint8_t wifi_flag;
24.  
25. /**@name The serial port receives the ring buffer implementation
26. * @{
27. */
28. rb_t pRb;                                               ///< Ring buffer structure variable
29. static uint8_t rbBuf[RB_MAX_LEN];                       ///< Ring buffer data cache buffer
30.  
31.  
32. /**@} */
33.  
34. /**
35. * @brief Write data to the ring buffer
36. * @param [in] buf        : buf adress
37. * @param [in] len        : byte length
38. * @return   correct : Returns the length of the written data
39.             failure : -1
40. */
41. int32_t gizPutData(uint8_t *buf, uint32_t len)
42. {
43.     int32_t count = 0;
44.  
45.     if(NULL == buf)
46.     {
47.         GIZWITS_LOG("ERR: gizPutData buf is empty \n");
48.         return -1;
49.     }
50.  
51.     count = rbWrite(&pRb, buf, len);
52.     if(count != len)
53.     {
54.         GIZWITS_LOG("ERR: Failed to rbWrite \n");
55.         return -1;
56.     }
57.  
58.     return count;
59. }
60.  
61.  
62.  
63. /**
64. * @brief Protocol header initialization
65. *
66. * @param [out] head         : Protocol header pointer
67. *
68. * @return 0， success; other， failure   
69. */
70. static int8_t gizProtocolHeadInit(protocolHead_t *head)
71. {
72.     if(NULL == head)
73.     {
74.         GIZWITS_LOG("ERR: gizProtocolHeadInit head is empty \n");
75.         return -1;
76.     }
77.  
78.     memset((uint8_t *)head, 0, sizeof(protocolHead_t));
79.     head->head[0] = 0xFF;
80.     head->head[1] = 0xFF;
81.  
82.     return 0;
83. }
84.  
85. /**
86. * @brief Protocol ACK check processing function
87. *
88. * @param [in] data            : data adress
89. * @param [in] len             : data length
90. *
91. * @return 0， suceess; other， failure
92. */
93. static int8_t gizProtocolWaitAck(uint8_t *gizdata, uint32_t len)
94. {
95.     if(NULL == gizdata)
96.     {
97.         GIZWITS_LOG("ERR: data is empty \n");
98.         return -1;
99.     }
100.  
101.     memset((uint8_t *)&gizwitsProtocol.waitAck, 0, sizeof(protocolWaitAck_t));
102.     memcpy((uint8_t *)gizwitsProtocol.waitAck.buf, gizdata, len);
103.     gizwitsProtocol.waitAck.dataLen = (uint16_t)len;
104.    
105.     gizwitsProtocol.waitAck.flag = 1;
106.     gizwitsProtocol.waitAck.sendTime = gizGetTimerCount();
107.  
108.     return 0;
109. }
110. /**
111. * @brief generates "controlled events" according to protocol
112.  
113. * @param [in] issuedData: Controlled data
114. * @param [out] info: event queue
115. * @param [out] dataPoints: data point data
116. * @return 0, the implementation of success, non-0, failed
117. */
118. static int8_t ICACHE_FLASH_ATTR gizDataPoint2Event(gizwitsIssued_t *issuedData, eventInfo_t *info, dataPoint_t *dataPoints)
119. {
120.     if((NULL == issuedData) || (NULL == info) ||(NULL == dataPoints))
121.     {
122.         GIZWITS_LOG("gizDataPoint2Event Error , Illegal Param\n");
123.         return -1;
124.     }
125.    
126.     /** Greater than 1 byte to do bit conversion **/
127.     if(sizeof(issuedData->attrFlags) > 1)
128.     {
129.         if(-1 == gizByteOrderExchange((uint8_t *)&issuedData->attrFlags,sizeof(attrFlags_t)))
130.         {
131.             GIZWITS_LOG("gizByteOrderExchange Error\n");
132.             return -1;
133.         }
134.     }
135.    
136.     if(0x01 == issuedData->attrFlags.flagRelay_1)
137.     {
138.         info->event[info->num] = EVENT_Relay_1;
139.         info->num++;
140.         dataPoints->valueRelay_1 = gizStandardDecompressionValue(Relay_1_BYTEOFFSET,Relay_1_BITOFFSET,Relay_1_LEN,(uint8_t *)&issuedData->attrVals.wBitBuf,sizeof(issuedData->attrVals.wBitBuf));
141.     }
142.         
143.    
144.     return 0;
145. }
146.  
147. /**
148. * @brief contrasts the current data with the last data
149. *
150. * @param [in] cur: current data point data
151. * @param [in] last: last data point data
152. *
153. * @return: 0, no change in data; 1, data changes
154. */
155. static int8_t ICACHE_FLASH_ATTR gizCheckReport(dataPoint_t *cur, dataPoint_t *last)
156. {
157.     int8_t ret = 0;
158.     static uint32_t lastReportTime = 0;
159.     uint32_t currentTime = 0;
160.  
161.     if((NULL == cur) || (NULL == last))
162.     {
163.         GIZWITS_LOG("gizCheckReport Error , Illegal Param\n");
164.         return -1;
165.     }
166.     currentTime = gizGetTimerCount();
167.     if(last->valueRelay_1 != cur->valueRelay_1)
168.     {
169.         GIZWITS_LOG("valueRelay_1 Changed\n");
170.         ret = 1;
171.     }
172.  
173.     if(last->valueTemp != cur->valueTemp)
174.     {
175.         if(currentTime - lastReportTime >= REPORT_TIME_MAX)
176.         {
177.             GIZWITS_LOG("valueTemp Changed\n");
178.             ret = 1;
179.         }
180.     }
181.     if(last->valueHumi != cur->valueHumi)
182.     {
183.         if(currentTime - lastReportTime >= REPORT_TIME_MAX)
184.         {
185.             GIZWITS_LOG("valueHumi Changed\n");
186.             ret = 1;
187.         }
188.     }
189.     if(last->valueLight_Intensity != cur->valueLight_Intensity)
190.     {
191.         if(currentTime - lastReportTime >= REPORT_TIME_MAX)
192.         {
193.             GIZWITS_LOG("valueLight_Intensity Changed\n");
194.             ret = 1;
195.         }
196.     }
197.  
198.     if(1 == ret)
199.     {
200.         lastReportTime = gizGetTimerCount();
201.     }
202.     return ret;
203. }
204.  
205. /**
206. * @brief User data point data is converted to wit the cloud to report data point data
207. *
208. * @param [in] dataPoints: user data point data address
209. * @param [out] devStatusPtr: wit the cloud data point data address
210. *
211. * @return 0, the correct return; -1, the error returned
212. */
213. static int8_t ICACHE_FLASH_ATTR gizDataPoints2ReportData(dataPoint_t *dataPoints , devStatus_t *devStatusPtr)
214. {
215.     if((NULL == dataPoints) || (NULL == devStatusPtr))
216.     {
217.         GIZWITS_LOG("gizDataPoints2ReportData Error , Illegal Param\n");
218.         return -1;
219.     }
220.  
221.     gizMemset((uint8_t *)devStatusPtr->wBitBuf,0,sizeof(devStatusPtr->wBitBuf));
222.  
223.     gizStandardCompressValue(Relay_1_BYTEOFFSET,Relay_1_BITOFFSET,Relay_1_LEN,(uint8_t *)devStatusPtr,dataPoints->valueRelay_1);
224.     gizByteOrderExchange((uint8_t *)devStatusPtr->wBitBuf,sizeof(devStatusPtr->wBitBuf));
225.  
226.     devStatusPtr->valueTemp = gizY2X(Temp_RATIO,  Temp_ADDITION, dataPoints->valueTemp);
227.     devStatusPtr->valueHumi = gizY2X(Humi_RATIO,  Humi_ADDITION, dataPoints->valueHumi);
228.     devStatusPtr->valueLight_Intensity = gizY2X(Light_Intensity_RATIO,  Light_Intensity_ADDITION, dataPoints->valueLight_Intensity);
229.  
230.  
231.  
232.  
233.     return 0;
234. }
235.  
236.  
237. /**
238. * @brief This function is called by the GAgent module to receive the relevant protocol data from the cloud or APP
239. * @param [in] inData The protocol data entered
240. * @param [in] inLen Enter the length of the data
241. * @param [out] outData The output of the protocol data
242. * @param [out] outLen The length of the output data
243. * @return 0, the implementation of success, non-0, failed
244. */
245. static int8_t gizProtocolIssuedProcess(char *did, uint8_t *inData, uint32_t inLen, uint8_t *outData, uint32_t *outLen)
246. {
247.     uint8_t issuedAction = inData[0];
248.  
249.     if((NULL == inData)||(NULL == outData)||(NULL == outLen))
250.     {
251.         GIZWITS_LOG("gizProtocolIssuedProcess Error , Illegal Param\n");
252.         return -1;
253.     }
254.    
255.     if(NULL == did)
256.     {
257.         memset((uint8_t *)&gizwitsProtocol.issuedProcessEvent, 0, sizeof(eventInfo_t));
258.         switch(issuedAction)
259.         {
260.             case ACTION_CONTROL_DEVICE:
261.                 gizDataPoint2Event((gizwitsIssued_t *)&inData[1], &gizwitsProtocol.issuedProcessEvent,&gizwitsProtocol.gizCurrentDataPoint);
262.                 gizwitsProtocol.issuedFlag = ACTION_CONTROL_TYPE;
263.                 outData = NULL;
264.                 *outLen = 0;
265.                 break;
266.             
267.             case ACTION_READ_DEV_STATUS:
268.                 if(0 == gizDataPoints2ReportData(&gizwitsProtocol.gizLastDataPoint,&gizwitsProtocol.reportData.devStatus))
269.                 {
270.                     memcpy(outData+1, (uint8_t *)&gizwitsProtocol.reportData.devStatus, sizeof(gizwitsReport_t));
271.                     outData[0] = ACTION_READ_DEV_STATUS_ACK;
272.                     *outLen = sizeof(gizwitsReport_t)+1;
273.                 }
274.                 else
275.                 {
276.                     return -1;
277.                 }
278.                 break;
279.             case ACTION_W2D_TRANSPARENT_DATA:
280.                 memcpy(gizwitsProtocol.transparentBuff, &inData[1], inLen-1);
281.                 gizwitsProtocol.transparentLen = inLen - 1;
282.                
283.                 gizwitsProtocol.issuedProcessEvent.event[gizwitsProtocol.issuedProcessEvent.num] = TRANSPARENT_DATA;
284.                 gizwitsProtocol.issuedProcessEvent.num++;
285.                 gizwitsProtocol.issuedFlag = ACTION_W2D_TRANSPARENT_TYPE;
286.                 outData = NULL;
287.                 *outLen = 0;
288.                 break;
289.             
290.                 default:
291.                     break;
292.         }
293.     }
294.  
295.     return 0;
296. }
297. /**
298. * @brief The protocol sends data back , P0 ACK
299. *
300. * @param [in] head                  : Protocol head pointer
301. * @param [in] data                  : Payload data
302. * @param [in] len                   : Payload data length
303. * @param [in] proFlag               : DID flag ,1 for Virtual sub device did ,0 for single product or gateway
304. *
305. * @return : 0,Ack success;
306. *           -1，Input Param Illegal
307. *           -2，Serial send faild
308. */
309. static int32_t gizProtocolIssuedDataAck(protocolHead_t *head, uint8_t *gizdata, uint32_t len, uint8_t proFlag)
310. {
311.     int32_t ret = 0;
312.     uint8_t tx_buf[RB_MAX_LEN];
313.     uint32_t offset = 0;
314.     uint8_t sDidLen = 0;
315.     uint16_t data_len = 0;
316.         uint8_t *pTxBuf = tx_buf;
317.     if(NULL == gizdata)
318.     {
319.         GIZWITS_LOG("[ERR]  data Is Null \n");
320.         return -1;
321.     }
322.    
323.  
324.     if(0x1 == proFlag)
325.     {
326.         sDidLen = *((uint8_t *)head + sizeof(protocolHead_t));
327.         data_len = 5 + 1 + sDidLen + len;   
328.     }
329.     else
330.     {
331.         data_len = 5 + len;
332.     }
333.     GIZWITS_LOG("len = %d , sDidLen = %d ,data_len = %d\n", len,sDidLen,data_len);
334.     *pTxBuf ++= 0xFF;
335.     *pTxBuf ++= 0xFF;
336.     *pTxBuf ++= (uint8_t)(data_len>>8);
337.     *pTxBuf ++= (uint8_t)(data_len);
338.     *pTxBuf ++= head->cmd + 1;
339.     *pTxBuf ++= head->sn;
340.     *pTxBuf ++= 0x00;
341.     *pTxBuf ++= proFlag;
342.     offset = 8;
343.     if(0x1 == proFlag)
344.     {
345.         *pTxBuf ++= sDidLen;
346.         offset += 1;
347.         memcpy(&tx_buf[offset],(uint8_t *)head+sizeof(protocolHead_t)+1,sDidLen);
348.         offset += sDidLen;
349.         pTxBuf += sDidLen;
350.  
351.     }
352.     if(0 != len)
353.     {
354.         memcpy(&tx_buf[offset],gizdata,len);
355.     }
356.     tx_buf[data_len + 4 - 1 ] = gizProtocolSum( tx_buf , (data_len+4));
357.  
358.     ret = uartWrite(tx_buf, data_len+4);
359.     if(ret < 0)
360.     {
361.         GIZWITS_LOG("uart write error %d \n", ret);
362.         return -2;
363.     }
364.  
365.     return 0;
366. }
367.  
368. /**
369. * @brief Report data interface
370. *
371. * @param [in] action            : PO action
372. * @param [in] data              : Payload data
373. * @param [in] len               : Payload data length
374. *
375. * @return : 0,Ack success;
376. *           -1，Input Param Illegal
377. *           -2，Serial send faild
378. */
379. static int32_t gizReportData(uint8_t action, uint8_t *gizdata, uint32_t len)
380. {
381.     int32_t ret = 0;
382.     protocolReport_t protocolReport;
383.  
384.     if(NULL == gizdata)
385.     {
386.         GIZWITS_LOG("gizReportData Error , Illegal Param\n");
387.         return -1;
388.     }
389.     gizProtocolHeadInit((protocolHead_t *)&protocolReport);
390.     protocolReport.head.cmd = CMD_REPORT_P0;
391.     protocolReport.head.sn = gizwitsProtocol.sn++;
392.     protocolReport.action = action;
393.     protocolReport.head.len = exchangeBytes(sizeof(protocolReport_t)-4);
394.     memcpy((gizwitsReport_t *)&protocolReport.reportData, (gizwitsReport_t *)gizdata,len);
395.     protocolReport.sum = gizProtocolSum((uint8_t *)&protocolReport, sizeof(protocolReport_t));
396.    
397.     ret = uartWrite((uint8_t *)&protocolReport, sizeof(protocolReport_t));
398.     if(ret < 0)
399.     {
400.         GIZWITS_LOG("ERR: uart write error %d \n", ret);
401.         return -2;
402.     }
403.  
404.     gizProtocolWaitAck((uint8_t *)&protocolReport, sizeof(protocolReport_t));
405.  
406.     return ret;
407. }/**
408. * @brief Datapoints reporting mechanism
409. *
410. * 1. Changes are reported immediately
411.  
412. * 2. Data timing report , 600000 Millisecond
413. *
414. *@param [in] currentData       : Current datapoints value
415. * @return : NULL
416. */
417. static void gizDevReportPolicy(dataPoint_t *currentData)
418. {
419.     static uint32_t lastRepTime = 0;
420.     uint32_t timeNow = gizGetTimerCount();
421.  
422.     if((1 == gizCheckReport(currentData, (dataPoint_t *)&gizwitsProtocol.gizLastDataPoint)))
423.     {
424.         GIZWITS_LOG("changed, report data\n");
425.         if(0 == gizDataPoints2ReportData(currentData,&gizwitsProtocol.reportData.devStatus))
426.         {
427.             gizReportData(ACTION_REPORT_DEV_STATUS, (uint8_t *)&gizwitsProtocol.reportData.devStatus, sizeof(devStatus_t));        }      
428.         memcpy((uint8_t *)&gizwitsProtocol.gizLastDataPoint, (uint8_t *)currentData, sizeof(dataPoint_t));
429.     }
430.  
431.     if((0 == (timeNow % (600000))) && (lastRepTime != timeNow))
432.     {
433.         GIZWITS_LOG("Info: 600S report data\n");
434.         if(0 == gizDataPoints2ReportData(currentData,&gizwitsProtocol.reportData.devStatus))
435.         {
436.             gizReportData(ACTION_REPORT_DEV_STATUS, (uint8_t *)&gizwitsProtocol.reportData.devStatus, sizeof(devStatus_t));
437.         }      
438.         memcpy((uint8_t *)&gizwitsProtocol.gizLastDataPoint, (uint8_t *)currentData, sizeof(dataPoint_t));
439.  
440.         lastRepTime = timeNow;
441.     }
442. }
443.  
444. /**
445. * @brief Get a packet of data from the ring buffer
446. *
447. * @param [in]  rb                  : Input data address
448. * @param [out] data                : Output data address
449. * @param [out] len                 : Output data length
450. *
451. * @return : 0,Return correct ;-1，Return failure;-2，Data check failure
452. */
453. static int8_t gizProtocolGetOnePacket(rb_t *rb, uint8_t *gizdata, uint16_t *len)
454. {
455.     int32_t ret = 0;
456.     uint8_t sum = 0;
457.     int32_t i = 0;
458.     uint8_t tmpData;
459.     uint8_t tmpLen = 0;
460.     uint16_t tmpCount = 0;
461.     static uint8_t protocolFlag = 0;
462.     static uint16_t protocolCount = 0;
463.     static uint8_t lastData = 0;
464.     static uint8_t debugCount = 0;
465.     uint8_t *protocolBuff = gizdata;
466.     protocolHead_t *head = NULL;
467.  
468.     if((NULL == rb) || (NULL == gizdata) ||(NULL == len))
469.     {
470.         GIZWITS_LOG("gizProtocolGetOnePacket Error , Illegal Param\n");
471.         return -1;
472.     }
473.  
474.     tmpLen = rbCanRead(rb);
475.     if(0 == tmpLen)
476.     {
477.         return -1;
478.     }
479.  
480.     for(i=0; i<tmpLen; i++)
481.     {
482.         ret = rbRead(rb, &tmpData, 1);
483.         if(0 != ret)
484.         {
485.             if((0xFF == lastData) && (0xFF == tmpData))
486.             {
487.                 if(0 == protocolFlag)
488.                 {
489.                     protocolBuff[0] = 0xFF;
490.                     protocolBuff[1] = 0xFF;
491.                     protocolCount = 2;
492.                     protocolFlag = 1;
493.                 }
494.                 else
495.                 {
496.                     if((protocolCount > 4) && (protocolCount != tmpCount))
497.                     {
498.                         protocolBuff[0] = 0xFF;
499.                         protocolBuff[1] = 0xFF;
500.                         protocolCount = 2;
501.                     }
502.                 }
503.             }
504.             else if((0xFF == lastData) && (0x55 == tmpData))
505.             {
506.             }
507.             else
508.             {
509.                 if(1 == protocolFlag)
510.                 {
511.                     protocolBuff[protocolCount] = tmpData;
512.                     protocolCount++;
513.  
514.                     if(protocolCount > 4)
515.                     {
516.                         head = (protocolHead_t *)protocolBuff;
517.                         tmpCount = exchangeBytes(head->len)+4;
518.                         if(protocolCount == tmpCount)
519.                         {
520.                             break;
521.                         }
522.                     }
523.                 }
524.             }
525.  
526.             lastData = tmpData;
527.             debugCount++;
528.         }
529.     }
530.  
531.     if((protocolCount > 4) && (protocolCount == tmpCount))
532.     {
533.         sum = gizProtocolSum(protocolBuff, protocolCount);
534.  
535.         if(protocolBuff[protocolCount-1] == sum)
536.         {
537.             memcpy(gizdata, protocolBuff, tmpCount);
538.             *len = tmpCount;
539.             protocolFlag = 0;
540.  
541.             protocolCount = 0;
542.             debugCount = 0;
543.             lastData = 0;
544.  
545.             return 0;
546.         }
547.         else
548.         {
549.             return -2;
550.         }
551.     }
552.  
553.     return 1;
554. }
555.  
556.  
557.  
558. /**
559. * @brief Protocol data resend
560.  
561. * The protocol data resend when check timeout and meet the resend limiting
562.  
563. * @param none   
564. *
565. * @return none
566. */
567. static void gizProtocolResendData(void)
568. {
569.     int32_t ret = 0;
570.  
571.     if(0 == gizwitsProtocol.waitAck.flag)
572.     {
573.         return;
574.     }
575.  
576.     GIZWITS_LOG("Warning: timeout, resend data \n");
577.    
578.     ret = uartWrite(gizwitsProtocol.waitAck.buf, gizwitsProtocol.waitAck.dataLen);
579.     if(ret != gizwitsProtocol.waitAck.dataLen)
580.     {
581.         GIZWITS_LOG("ERR: resend data error\n");
582.     }
583.  
584.     gizwitsProtocol.waitAck.sendTime = gizGetTimerCount();
585. }
586.  
587. /**
588. * @brief Clear the ACK protocol message
589. *
590. * @param [in] head : Protocol header address
591. *
592. * @return 0， success; other， failure
593. */
594. static int8_t gizProtocolWaitAckCheck(protocolHead_t *head)
595. {
596.     protocolHead_t *waitAckHead = (protocolHead_t *)gizwitsProtocol.waitAck.buf;
597.  
598.     if(NULL == head)
599.     {
600.         GIZWITS_LOG("ERR: data is empty \n");
601.         return -1;
602.     }
603.  
604.     if(waitAckHead->cmd+1 == head->cmd)
605.     {
606.         memset((uint8_t *)&gizwitsProtocol.waitAck, 0, sizeof(protocolWaitAck_t));
607.     }
608.  
609.     return 0;
610. }
611.  
612. /**
613. * @brief Send general protocol message data
614. *
615. * @param [in] head              : Protocol header address
616. *
617. * @return : Return effective data length;-1，return failure
618. */
619. static int32_t gizProtocolCommonAck(protocolHead_t *head)
620. {
621.     int32_t ret = 0;
622.     protocolCommon_t ack;
623.  
624.     if(NULL == head)
625.     {
626.         GIZWITS_LOG("ERR: gizProtocolCommonAck data is empty \n");
627.         return -1;
628.     }
629.     memcpy((uint8_t *)&ack, (uint8_t *)head, sizeof(protocolHead_t));
630.     ack.head.cmd = ack.head.cmd+1;
631.     ack.head.len = exchangeBytes(sizeof(protocolCommon_t)-4);
632.     ack.sum = gizProtocolSum((uint8_t *)&ack, sizeof(protocolCommon_t));
633.  
634.     ret = uartWrite((uint8_t *)&ack, sizeof(protocolCommon_t));
635.     if(ret < 0)
636.     {
637.         GIZWITS_LOG("ERR: uart write error %d \n", ret);
638.     }
639.  
640.     return ret;
641. }
642.  
643. /**
644. * @brief ACK processing function
645.  
646. * Time-out 200ms no ACK resend，resend two times at most
647.  
648. * @param none
649. *
650. * @return none
651. */
652. static void gizProtocolAckHandle(void)
653. {
654.     if(1 == gizwitsProtocol.waitAck.flag)
655.     {
656.         if(SEND_MAX_NUM > gizwitsProtocol.waitAck.num)
657.         {
658.             // Time-out no ACK resend
659.             if(SEND_MAX_TIME < (gizGetTimerCount() - gizwitsProtocol.waitAck.sendTime))
660.             {
661.                 GIZWITS_LOG("Warning:gizProtocolResendData %d %d %d\n", gizGetTimerCount(), gizwitsProtocol.waitAck.sendTime, gizwitsProtocol.waitAck.num);
662.                 gizProtocolResendData();
663.                 gizwitsProtocol.waitAck.num++;
664.             }
665.         }
666.         else
667.         {
668.             memset((uint8_t *)&gizwitsProtocol.waitAck, 0, sizeof(protocolWaitAck_t));
669.         }
670.     }
671. }
672.  
673. /**
674. * @brief Protocol 4.1 WiFi module requests device information
675. *
676. * @param[in] head : Protocol header address
677. *
678. * @return Return effective data length;-1，return failure
679. */
680. static int32_t gizProtocolGetDeviceInfo(protocolHead_t * head)
681. {
682.     int32_t ret = 0;
683.     protocolDeviceInfo_t deviceInfo;
684.  
685.     if(NULL == head)
686.     {
687.         GIZWITS_LOG("gizProtocolGetDeviceInfo Error , Illegal Param\n");
688.         return -1;
689.     }
690.  
691.     gizProtocolHeadInit((protocolHead_t *)&deviceInfo);
692.     deviceInfo.head.cmd = ACK_GET_DEVICE_INFO;
693.     deviceInfo.head.sn = head->sn;
694.     memcpy((uint8_t *)deviceInfo.protocolVer, protocol_VERSION, 8);
695.     memcpy((uint8_t *)deviceInfo.p0Ver, P0_VERSION, 8);
696.     memcpy((uint8_t *)deviceInfo.softVer, SOFTWARE_VERSION, 8);
697.     memcpy((uint8_t *)deviceInfo.hardVer, HARDWARE_VERSION, 8);
698.     memcpy((uint8_t *)deviceInfo.productKey, PRODUCT_KEY, strlen(PRODUCT_KEY));
699.     memcpy((uint8_t *)deviceInfo.productSecret, PRODUCT_SECRET, strlen(PRODUCT_SECRET));
700.     memset((uint8_t *)deviceInfo.devAttr, 0, 8);
701.     deviceInfo.devAttr[7] |= DEV_IS_GATEWAY<<0;
702.     deviceInfo.devAttr[7] |= (0x01<<1);
703.     deviceInfo.ninableTime = exchangeBytes(NINABLETIME);
704.     deviceInfo.head.len = exchangeBytes(sizeof(protocolDeviceInfo_t)-4);
705.     deviceInfo.sum = gizProtocolSum((uint8_t *)&deviceInfo, sizeof(protocolDeviceInfo_t));
706.  
707.     ret = uartWrite((uint8_t *)&deviceInfo, sizeof(protocolDeviceInfo_t));
708.     if(ret < 0)
709.     {
710.         GIZWITS_LOG("ERR: uart write error %d \n", ret);
711.     }
712.    
713.     return ret;
714. }
715.  
716. /**
717. * @brief Protocol 4.7 Handling of illegal message notification
718.  
719. * @param[in] head  : Protocol header address
720. * @param[in] errno : Illegal message notification type
721. * @return 0， success; other， failure
722. */
723. static int32_t gizProtocolErrorCmd(protocolHead_t *head,errorPacketsType_t errno)
724. {
725.     int32_t ret = 0;
726.     protocolErrorType_t errorType;
727.  
728.     if(NULL == head)
729.     {
730.         GIZWITS_LOG("gizProtocolErrorCmd Error , Illegal Param\n");
731.         return -1;
732.     }
733.     gizProtocolHeadInit((protocolHead_t *)&errorType);
734.     errorType.head.cmd = ACK_ERROR_PACKAGE;
735.     errorType.head.sn = head->sn;
736.    
737.     errorType.head.len = exchangeBytes(sizeof(protocolErrorType_t)-4);
738.     errorType.error = errno;
739.     errorType.sum = gizProtocolSum((uint8_t *)&errorType, sizeof(protocolErrorType_t));
740.    
741.     ret = uartWrite((uint8_t *)&errorType, sizeof(protocolErrorType_t));
742.     if(ret < 0)
743.     {
744.         GIZWITS_LOG("ERR: uart write error %d \n", ret);
745.     }
746.  
747.     return ret;
748. }
749.  
750. /**
751. * @brief Protocol 4.13 Get and process network time
752. *
753. * @param [in] head : Protocol header address
754. *
755. * @return 0， success; other， failure
756. */
757. static int8_t gizProtocolNTP(protocolHead_t *head)
758. {  
759.     protocolUTT_t *UTTInfo = (protocolUTT_t *)head;
760.    
761.     if(NULL == head)
762.     {
763.         GIZWITS_LOG("ERR: NTP is empty \n");
764.         return -1;
765.     }
766.    
767.     memcpy((uint8_t *)&gizwitsProtocol.TimeNTP,(uint8_t *)UTTInfo->time, (7 + 4));
768.     gizwitsProtocol.TimeNTP.year = exchangeBytes(gizwitsProtocol.TimeNTP.year);
769.     gizwitsProtocol.TimeNTP.ntp =exchangeWord(gizwitsProtocol.TimeNTP.ntp);
770.  
771.     gizwitsProtocol.NTPEvent.event[gizwitsProtocol.NTPEvent.num] = WIFI_NTP;
772.     gizwitsProtocol.NTPEvent.num++;
773.    
774.     gizwitsProtocol.issuedFlag = GET_NTP_TYPE;
775.    
776.    
777.     return 0;
778. }
779.  
780. /**
781. * @brief Protocol 4.4 Device MCU restarts function
782.  
783. * @param none
784. * @return none
785. */
786. static void gizProtocolReboot(void)
787. {
788.     uint32_t timeDelay = gizGetTimerCount();
789.    
790.     /*Wait 600ms*/
791.     while((gizGetTimerCount() - timeDelay) <= 600);
792.     mcuRestart();
793. }
794.  
795. /**
796. * @brief Protocol 4.5 :The WiFi module informs the device MCU of working status about the WiFi module
797.  
798. * @param[in] status WiFi module working status
799. * @return none
800. */
801. static int8_t gizProtocolModuleStatus(protocolWifiStatus_t *status)
802. {
803.     static wifiStatus_t lastStatus;
804.  
805.     if(NULL == status)
806.     {
807.         GIZWITS_LOG("gizProtocolModuleStatus Error , Illegal Param\n");
808.         return -1;
809.     }
810.  
811.     status->ststus.value = exchangeBytes(status->ststus.value);
812.    
813.     //OnBoarding mode status
814.     if(lastStatus.types.onboarding != status->ststus.types.onboarding)
815.     {
816.         if(1 == status->ststus.types.onboarding)
817.         {
818.             if(1 == status->ststus.types.softap)
819.             {
820.                 gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_SOFTAP;
821.                 gizwitsProtocol.wifiStatusEvent.num++;
822.                 GIZWITS_LOG("OnBoarding: SoftAP or Web mode\n");
823.             }
824.  
825.             if(1 == status->ststus.types.station)
826.             {
827.                 gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_AIRLINK;
828.                 gizwitsProtocol.wifiStatusEvent.num++;
829.                 GIZWITS_LOG("OnBoarding: AirLink mode\n");
830.             }
831.         }
832.         else
833.         {
834.             if(1 == status->ststus.types.softap)
835.             {
836.                 gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_SOFTAP;
837.                 gizwitsProtocol.wifiStatusEvent.num++;
838.                 GIZWITS_LOG("OnBoarding: SoftAP or Web mode\n");
839.             }
840.  
841.             if(1 == status->ststus.types.station)
842.             {
843.                 gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_STATION;
844.                 gizwitsProtocol.wifiStatusEvent.num++;
845.                 GIZWITS_LOG("OnBoarding: Station mode\n");
846.             }
847.         }
848.     }
849.  
850.     //binding mode status
851.     if(lastStatus.types.binding != status->ststus.types.binding)
852.     {
853.         lastStatus.types.binding = status->ststus.types.binding;
854.         if(1 == status->ststus.types.binding)
855.         {
856.             gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_OPEN_BINDING;
857.             gizwitsProtocol.wifiStatusEvent.num++;
858.             GIZWITS_LOG("WiFi status: in binding mode\n");
859.         }
860.         else
861.         {
862.             gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_CLOSE_BINDING;
863.             gizwitsProtocol.wifiStatusEvent.num++;
864.             GIZWITS_LOG("WiFi status: out binding mode\n");
865.         }
866.     }
867.  
868.     //router status
869.     if(lastStatus.types.con_route != status->ststus.types.con_route)
870.     {
871.         lastStatus.types.con_route = status->ststus.types.con_route;
872.         if(1 == status->ststus.types.con_route)
873.         {
874.             gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_CON_ROUTER;
875.             gizwitsProtocol.wifiStatusEvent.num++;
876.             GIZWITS_LOG("WiFi status: connected router\n");
877.         }
878.         else
879.         {
880.             gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_DISCON_ROUTER;
881.             gizwitsProtocol.wifiStatusEvent.num++;
882.             GIZWITS_LOG("WiFi status: disconnected router\n");
883.         }
884.     }
885.  
886.     //M2M server status
887.     if(lastStatus.types.con_m2m != status->ststus.types.con_m2m)
888.     {
889.         lastStatus.types.con_m2m = status->ststus.types.con_m2m;
890.         if(1 == status->ststus.types.con_m2m)
891.         {
892.             gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_CON_M2M;
893.             gizwitsProtocol.wifiStatusEvent.num++;
894.             GIZWITS_LOG("WiFi status: connected m2m\n");
895.         }
896.         else
897.         {
898.             gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_DISCON_M2M;
899.             gizwitsProtocol.wifiStatusEvent.num++;
900.             GIZWITS_LOG("WiFi status: disconnected m2m\n");
901.         }
902.     }
903.  
904.     //APP status
905.     if(lastStatus.types.app != status->ststus.types.app)
906.     {
907.         lastStatus.types.app = status->ststus.types.app;
908.         if(1 == status->ststus.types.app)
909.         {
910.             gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_CON_APP;
911.             gizwitsProtocol.wifiStatusEvent.num++;
912.             GIZWITS_LOG("WiFi status: app connect\n");
913.         }
914.         else
915.         {
916.             gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_DISCON_APP;
917.             gizwitsProtocol.wifiStatusEvent.num++;
918.             GIZWITS_LOG("WiFi status: no app connect\n");
919.         }
920.     }
921.  
922.     //test mode status
923.     if(lastStatus.types.test != status->ststus.types.test)
924.     {
925.         lastStatus.types.test = status->ststus.types.test;
926.         if(1 == status->ststus.types.test)
927.         {
928.             gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_OPEN_TESTMODE;
929.             gizwitsProtocol.wifiStatusEvent.num++;
930.             GIZWITS_LOG("WiFi status: in test mode\n");
931.         }
932.         else
933.         {
934.             gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_CLOSE_TESTMODE;
935.             gizwitsProtocol.wifiStatusEvent.num++;
936.             GIZWITS_LOG("WiFi status: out test mode\n");
937.         }
938.     }
939.  
940.     gizwitsProtocol.wifiStatusEvent.event[gizwitsProtocol.wifiStatusEvent.num] = WIFI_RSSI;
941.     gizwitsProtocol.wifiStatusEvent.num++;
942.     gizwitsProtocol.wifiStatusData.rssi = status->ststus.types.rssi;
943.     GIZWITS_LOG("RSSI is %d \n", gizwitsProtocol.wifiStatusData.rssi);
944.  
945.     gizwitsProtocol.issuedFlag = WIFI_STATUS_TYPE;
946.  
947.     return 0;
948. }
949.  
950.  
951. /**@name Gizwits User API interface
952. * @{
953. */
954.  
955. /**
956. * @brief gizwits Protocol initialization interface
957.  
958. * Protocol-related timer, serial port initialization
959.  
960. * Datapoint initialization
961.  
962. * @param none
963. * @return none
964. */
965. void gizwitsInit(void)
966. {   
967.     pRb.rbCapacity = RB_MAX_LEN;
968.     pRb.rbBuff = rbBuf;
969.     if(0 == rbCreate(&pRb))
970.         {
971.                 GIZWITS_LOG("rbCreate Success \n");
972.         }
973.         else
974.         {
975.                 GIZWITS_LOG("rbCreate Faild \n");
976.         }
977.    
978.     memset((uint8_t *)&gizwitsProtocol, 0, sizeof(gizwitsProtocol_t));
979. }
980.  
981. /**
982. * @brief WiFi configure interface
983.  
984. * Set the WiFi module into the corresponding configuration mode or reset the module
985.  
986. * @param[in] mode ：0x0， reset the module ;0x01， SoftAp mode ;0x02， AirLink mode ;0x03， Production test mode; 0x04:allow users to bind devices
987.  
988. * @return Error command code
989. */
990. int32_t gizwitsSetMode(uint8_t mode)
991. {
992.     int32_t ret = 0;
993.     protocolCfgMode_t cfgMode;
994.     protocolCommon_t setDefault;
995.  
996.     switch(mode)
997.     {
998.         case WIFI_RESET_MODE:
999.             gizProtocolHeadInit((protocolHead_t *)&setDefault);
1000.             setDefault.head.cmd = CMD_SET_DEFAULT;
1001.             setDefault.head.sn = gizwitsProtocol.sn++;
1002.             setDefault.head.len = exchangeBytes(sizeof(protocolCommon_t)-4);
1003.             setDefault.sum = gizProtocolSum((uint8_t *)&setDefault, sizeof(protocolCommon_t));
1004.             ret = uartWrite((uint8_t *)&setDefault, sizeof(protocolCommon_t));
1005.             if(ret < 0)
1006.             {
1007.                 GIZWITS_LOG("ERR: uart write error %d \n", ret);
1008.             }
1009.  
1010.             gizProtocolWaitAck((uint8_t *)&setDefault, sizeof(protocolCommon_t));   
1011.             break;
1012.         case WIFI_SOFTAP_MODE:
1013.             gizProtocolHeadInit((protocolHead_t *)&cfgMode);
1014.             cfgMode.head.cmd = CMD_WIFI_CONFIG;
1015.             cfgMode.head.sn = gizwitsProtocol.sn++;
1016.             cfgMode.cfgMode = mode;
1017.             cfgMode.head.len = exchangeBytes(sizeof(protocolCfgMode_t)-4);
1018.             cfgMode.sum = gizProtocolSum((uint8_t *)&cfgMode, sizeof(protocolCfgMode_t));
1019.             ret = uartWrite((uint8_t *)&cfgMode, sizeof(protocolCfgMode_t));
1020.             if(ret < 0)
1021.             {
1022.                 GIZWITS_LOG("ERR: uart write error %d \n", ret);
1023.             }
1024.             gizProtocolWaitAck((uint8_t *)&cfgMode, sizeof(protocolCfgMode_t));
1025.             break;
1026.         case WIFI_AIRLINK_MODE:
1027.             gizProtocolHeadInit((protocolHead_t *)&cfgMode);
1028.             cfgMode.head.cmd = CMD_WIFI_CONFIG;
1029.             cfgMode.head.sn = gizwitsProtocol.sn++;
1030.             cfgMode.cfgMode = mode;
1031.             cfgMode.head.len = exchangeBytes(sizeof(protocolCfgMode_t)-4);
1032.             cfgMode.sum = gizProtocolSum((uint8_t *)&cfgMode, sizeof(protocolCfgMode_t));
1033.             ret = uartWrite((uint8_t *)&cfgMode, sizeof(protocolCfgMode_t));
1034.             if(ret < 0)
1035.             {
1036.                 GIZWITS_LOG("ERR: uart write error %d \n", ret);
1037.             }
1038.             gizProtocolWaitAck((uint8_t *)&cfgMode, sizeof(protocolCfgMode_t));
1039.             break;
1040.         case WIFI_PRODUCTION_TEST:
1041.             gizProtocolHeadInit((protocolHead_t *)&setDefault);
1042.             setDefault.head.cmd = CMD_PRODUCTION_TEST;
1043.             setDefault.head.sn = gizwitsProtocol.sn++;
1044.             setDefault.head.len = exchangeBytes(sizeof(protocolCommon_t)-4);
1045.             setDefault.sum = gizProtocolSum((uint8_t *)&setDefault, sizeof(protocolCommon_t));
1046.             ret = uartWrite((uint8_t *)&setDefault, sizeof(protocolCommon_t));
1047.             if(ret < 0)
1048.             {
1049.                 GIZWITS_LOG("ERR: uart write error %d \n", ret);
1050.             }
1051.  
1052.             gizProtocolWaitAck((uint8_t *)&setDefault, sizeof(protocolCommon_t));
1053.             break;
1054.         case WIFI_NINABLE_MODE:
1055.             gizProtocolHeadInit((protocolHead_t *)&setDefault);
1056.             setDefault.head.cmd = CMD_NINABLE_MODE;
1057.             setDefault.head.sn = gizwitsProtocol.sn++;
1058.             setDefault.head.len = exchangeBytes(sizeof(protocolCommon_t)-4);
1059.             setDefault.sum = gizProtocolSum((uint8_t *)&setDefault, sizeof(protocolCommon_t));
1060.             ret = uartWrite((uint8_t *)&setDefault, sizeof(protocolCommon_t));
1061.             if(ret < 0)
1062.             {
1063.                 GIZWITS_LOG("ERR: uart write error %d \n", ret);
1064.             }
1065.  
1066.             gizProtocolWaitAck((uint8_t *)&setDefault, sizeof(protocolCommon_t));
1067.             break;
1068.         case WIFI_REBOOT_MODE:
1069.             gizProtocolHeadInit((protocolHead_t *)&setDefault);
1070.             setDefault.head.cmd = CMD_REBOOT_MODULE;
1071.             setDefault.head.sn = gizwitsProtocol.sn++;
1072.             setDefault.head.len = exchangeBytes(sizeof(protocolCommon_t)-4);
1073.             setDefault.sum = gizProtocolSum((uint8_t *)&setDefault, sizeof(protocolCommon_t));
1074.             ret = uartWrite((uint8_t *)&setDefault, sizeof(protocolCommon_t));
1075.             if(ret < 0)
1076.             {
1077.                 GIZWITS_LOG("ERR: uart write error %d \n", ret);
1078.             }
1079.  
1080.             gizProtocolWaitAck((uint8_t *)&setDefault, sizeof(protocolCommon_t));
1081.             break;
1082.         default:
1083.             GIZWITS_LOG("ERR: CfgMode error!\n");
1084.             break;
1085.     }
1086.  
1087.     return ret;
1088. }
1089.  
1090. /**
1091. * @brief Get the the network time
1092.  
1093. * Protocol 4.13:"Device MCU send" of "the MCU requests access to the network time"
1094.  
1095. * @param[in] none
1096. * @return none
1097. */
1098. void gizwitsGetNTP(void)
1099. {
1100.     int32_t ret = 0;
1101.     protocolCommon_t getNTP;
1102.  
1103.     gizProtocolHeadInit((protocolHead_t *)&getNTP);
1104.     getNTP.head.cmd = CMD_GET_NTP;
1105.     getNTP.head.sn = gizwitsProtocol.sn++;
1106.     getNTP.head.len = exchangeBytes(sizeof(protocolCommon_t)-4);
1107.     getNTP.sum = gizProtocolSum((uint8_t *)&getNTP, sizeof(protocolCommon_t));
1108.     ret = uartWrite((uint8_t *)&getNTP, sizeof(protocolCommon_t));
1109.     if(ret < 0)
1110.     {
1111.         GIZWITS_LOG("ERR[NTP]: uart write error %d \n", ret);
1112.     }
1113.  
1114.     gizProtocolWaitAck((uint8_t *)&getNTP, sizeof(protocolCommon_t));
1115. }
1116.  
1117.  
1118. /**
1119. * @brief Get Module Info
1120.  
1121. *
1122.  
1123. * @param[in] none
1124. * @return none
1125. */
1126. void gizwitsGetModuleInfo(void)
1127. {
1128.     int32_t ret = 0;
1129.     protocolGetModuleInfo_t getModuleInfo;
1130.  
1131.     gizProtocolHeadInit((protocolHead_t *)&getModuleInfo);
1132.     getModuleInfo.head.cmd = CMD_ASK_MODULE_INFO;
1133.     getModuleInfo.head.sn = gizwitsProtocol.sn++;
1134.     getModuleInfo.type = 0x0;
1135.     getModuleInfo.head.len = exchangeBytes(sizeof(protocolGetModuleInfo_t)-4);
1136.     getModuleInfo.sum = gizProtocolSum((uint8_t *)&getModuleInfo, sizeof(protocolGetModuleInfo_t));
1137.     ret = uartWrite((uint8_t *)&getModuleInfo, sizeof(protocolGetModuleInfo_t));
1138.     if(ret < 0)
1139.     {
1140.         GIZWITS_LOG("ERR[NTP]: uart write error %d \n", ret);
1141.     }
1142.  
1143.     gizProtocolWaitAck((uint8_t *)&getModuleInfo, sizeof(protocolGetModuleInfo_t));
1144. }
1145.  
1146.  
1147. /**
1148. * @brief Module Info Analyse
1149. *
1150. * @param [in] head :
1151. *
1152. * @return 0, Success， , other,Faild
1153. */
1154. static int8_t gizProtocolModuleInfoHandle(protocolHead_t *head)
1155. {
1156.     protocolModuleInfo_t *moduleInfo = (protocolModuleInfo_t *)head;
1157.  
1158.     if(NULL == head)
1159.     {
1160.         GIZWITS_LOG("NTP is empty \n");
1161.         return -1;
1162.     }
1163.  
1164.     memcpy((uint8_t *)&gizwitsProtocol.wifiModuleNews,(uint8_t *)&moduleInfo->wifiModuleInfo, sizeof(moduleInfo_t));
1165.  
1166.     gizwitsProtocol.moduleInfoEvent.event[gizwitsProtocol.moduleInfoEvent.num] = MODULE_INFO;
1167.     gizwitsProtocol.moduleInfoEvent.num++;
1168.  
1169.     gizwitsProtocol.issuedFlag = GET_MODULEINFO_TYPE;
1170.  
1171.  
1172.     return 0;
1173. }
1174.  
1175. /**
1176. * @brief Protocol handling function
1177.  
1178. *
1179.  
1180. * @param [in] currentData :The protocol data pointer
1181. * @return none
1182. */
1183. int32_t gizwitsHandle(dataPoint_t *currentData)
1184. {
1185.     int8_t ret = 0;
1186. #ifdef PROTOCOL_DEBUG
1187.     uint16_t i = 0;
1188. #endif
1189.     uint8_t ackData[RB_MAX_LEN];
1190.     uint16_t protocolLen = 0;
1191.     uint32_t ackLen = 0;
1192.     protocolHead_t *recvHead = NULL;
1193.     char *didPtr = NULL;
1194.     uint16_t offset = 0;
1195.  
1196.  
1197.     if(NULL == currentData)
1198.     {
1199.         GIZWITS_LOG("GizwitsHandle Error , Illegal Param\n");
1200.         return -1;
1201.     }
1202.  
1203.     /*resend strategy*/
1204.     gizProtocolAckHandle();
1205.     ret = gizProtocolGetOnePacket(&pRb, gizwitsProtocol.protocolBuf, &protocolLen);
1206.  
1207.     if(0 == ret)
1208.     {
1209.         GIZWITS_LOG("Get One Packet!\n");
1210.         
1211. #ifdef PROTOCOL_DEBUG
1212.         GIZWITS_LOG("WiFi2MCU[%4d:%4d]: ", gizGetTimerCount(), protocolLen);
1213.         for(i=0; i<protocolLen;i++)
1214.         {
1215.             GIZWITS_LOG("%02x ", gizwitsProtocol.protocolBuf);
1216.         }
1217.         GIZWITS_LOG("\n");
1218. #endif
1219.  
1220.         recvHead = (protocolHead_t *)gizwitsProtocol.protocolBuf;
1221.         switch (recvHead->cmd)
1222.         {
1223.             case CMD_GET_DEVICE_INTO:
1224.                 gizProtocolGetDeviceInfo(recvHead);
1225.                 break;
1226.             case CMD_ISSUED_P0:
1227.                 GIZWITS_LOG("flag %x %x \n", recvHead->flags[0], recvHead->flags[1]);
1228.                 //offset = 1;
1229.                
1230.                 if(0 == gizProtocolIssuedProcess(didPtr, gizwitsProtocol.protocolBuf+sizeof(protocolHead_t)+offset, protocolLen-(sizeof(protocolHead_t)+offset+1), ackData, &ackLen))
1231.                 {
1232.                     gizProtocolIssuedDataAck(recvHead, ackData, ackLen,recvHead->flags[1]);
1233.                     GIZWITS_LOG("AckData : \n");
1234.                 }
1235.                 break;
1236.             case CMD_HEARTBEAT:
1237.                 gizProtocolCommonAck(recvHead);
1238.                 break;
1239.             case CMD_WIFISTATUS:
1240.                 gizProtocolCommonAck(recvHead);
1241.                 gizProtocolModuleStatus((protocolWifiStatus_t *)recvHead);
1242.                 break;
1243.             case ACK_REPORT_P0:
1244.             case ACK_WIFI_CONFIG:
1245.             case ACK_SET_DEFAULT:
1246.             case ACK_NINABLE_MODE:
1247.             case ACK_REBOOT_MODULE:
1248.                 gizProtocolWaitAckCheck(recvHead);
1249.                 break;
1250.             case CMD_MCU_REBOOT:
1251.                 gizProtocolCommonAck(recvHead);
1252.                 GIZWITS_LOG("report:MCU reboot!\n");
1253.                
1254.                 gizProtocolReboot();
1255.                 break;
1256.             case CMD_ERROR_PACKAGE:
1257.                 break;
1258.             case ACK_PRODUCTION_TEST:
1259.                 gizProtocolWaitAckCheck(recvHead);
1260.                 GIZWITS_LOG("Ack PRODUCTION_MODE success \n");
1261.                 break;           
1262.             case ACK_GET_NTP:
1263.                 gizProtocolWaitAckCheck(recvHead);
1264.                 gizProtocolNTP(recvHead);
1265.                 GIZWITS_LOG("Ack GET_UTT success \n");
1266.                 break;
1267.             case ACK_ASK_MODULE_INFO:
1268.                 gizProtocolWaitAckCheck(recvHead);
1269.                 gizProtocolModuleInfoHandle(recvHead);
1270.                 GIZWITS_LOG("Ack GET_Module success \n");
1271.             break;
1272.  
1273.             default:
1274.                 gizProtocolErrorCmd(recvHead,ERROR_CMD);
1275.                 GIZWITS_LOG("ERR: cmd code error!\n");
1276.                 break;
1277.         }
1278.     }
1279.     else if(-2 == ret)
1280.     {
1281.         //Check failed, report exception
1282.         recvHead = (protocolHead_t *)gizwitsProtocol.protocolBuf;
1283.         gizProtocolErrorCmd(recvHead,ERROR_ACK_SUM);
1284.         GIZWITS_LOG("ERR: check sum error!\n");
1285.         return -2;
1286.     }
1287.    
1288.     switch(gizwitsProtocol.issuedFlag)
1289.     {
1290.         case ACTION_CONTROL_TYPE:
1291.             gizwitsProtocol.issuedFlag = STATELESS_TYPE;
1292.             gizwitsEventProcess(&gizwitsProtocol.issuedProcessEvent, (uint8_t *)&gizwitsProtocol.gizCurrentDataPoint, sizeof(dataPoint_t));
1293.             memset((uint8_t *)&gizwitsProtocol.issuedProcessEvent,0x0,sizeof(gizwitsProtocol.issuedProcessEvent));  
1294.             break;
1295.         case WIFI_STATUS_TYPE:
1296.             gizwitsProtocol.issuedFlag = STATELESS_TYPE;
1297.             gizwitsEventProcess(&gizwitsProtocol.wifiStatusEvent, (uint8_t *)&gizwitsProtocol.wifiStatusData, sizeof(moduleStatusInfo_t));
1298.             memset((uint8_t *)&gizwitsProtocol.wifiStatusEvent,0x0,sizeof(gizwitsProtocol.wifiStatusEvent));
1299.             break;
1300.         case ACTION_W2D_TRANSPARENT_TYPE:
1301.             gizwitsProtocol.issuedFlag = STATELESS_TYPE;
1302.             gizwitsEventProcess(&gizwitsProtocol.issuedProcessEvent, (uint8_t *)gizwitsProtocol.transparentBuff, gizwitsProtocol.transparentLen);
1303.             break;
1304.         case GET_NTP_TYPE:
1305.             gizwitsProtocol.issuedFlag = STATELESS_TYPE;
1306.             gizwitsEventProcess(&gizwitsProtocol.NTPEvent, (uint8_t *)&gizwitsProtocol.TimeNTP, sizeof(protocolTime_t));
1307.             memset((uint8_t *)&gizwitsProtocol.NTPEvent,0x0,sizeof(gizwitsProtocol.NTPEvent));
1308.             break;
1309.         case GET_MODULEINFO_TYPE:
1310.             gizwitsProtocol.issuedFlag = STATELESS_TYPE;
1311.             gizwitsEventProcess(&gizwitsProtocol.moduleInfoEvent, (uint8_t *)&gizwitsProtocol.wifiModuleNews, sizeof(moduleInfo_t));
1312.             memset((uint8_t *)&gizwitsProtocol.moduleInfoEvent,0x0,sizeof(moduleInfo_t));
1313.             break;
1314.         default:
1315.             break;      
1316.     }
1317.  
1318.     gizDevReportPolicy(currentData);
1319.  
1320.     return 0;
1321. }
1322.  
1323. /**
1324. * @brief gizwits report transparent data interface
1325.  
1326. * The user can call the interface to complete the reporting of private protocol data
1327.  
1328. * @param [in] data :Private protocol data
1329. * @param [in] len  :Private protocol data length
1330. * @return 0，success ;other，failure
1331. */
1332. int32_t gizwitsPassthroughData(uint8_t * gizdata, uint32_t len)
1333. {
1334.         int32_t ret = 0;
1335.         uint8_t tx_buf[MAX_PACKAGE_LEN];
1336.         uint8_t *pTxBuf = tx_buf;
1337.         uint16_t data_len = 6+len;
1338.     if(NULL == gizdata)
1339.     {
1340.         GIZWITS_LOG("[ERR] gizwitsPassthroughData Error \n");
1341.         return (-1);
1342.     }
1343.  
1344.         *pTxBuf ++= 0xFF;
1345.         *pTxBuf ++= 0xFF;
1346.         *pTxBuf ++= (uint8_t)(data_len>>8);//len
1347.         *pTxBuf ++= (uint8_t)(data_len);
1348.         *pTxBuf ++= CMD_REPORT_P0;//0x1b cmd
1349.         *pTxBuf ++= gizwitsProtocol.sn++;//sn
1350.         *pTxBuf ++= 0x00;//flag
1351.         *pTxBuf ++= 0x00;//flag
1352.         *pTxBuf ++= ACTION_D2W_TRANSPARENT_DATA;//P0_Cmd
1353.  
1354.     memcpy(&tx_buf[9],gizdata,len);
1355.     tx_buf[data_len + 4 - 1 ] = gizProtocolSum( tx_buf , (data_len+4));
1356.    
1357.         ret = uartWrite(tx_buf, data_len+4);
1358.     if(ret < 0)
1359.     {
1360.         GIZWITS_LOG("ERR: uart write error %d \n", ret);
1361.     }
1362.  
1363.     gizProtocolWaitAck(tx_buf, data_len+4);
1364.  
1365.     return 0;
1366. }
1367.  
1368.  
1369. void gziwits_Task(dataPoint_t * currentDataPoint)
1370. {
1371.         static uint32_t Timer=0;
1372.         if(SoftTimer(Timer,5000))
1373.         {
1374.                 gizwitsHandle(currentDataPoint);
1375.                 Timer=GetSoftTimer();
1376.         }
1377. }
1378.  
1379.  
1380. /**@} */
1381.  

复制代码

 

 

修改gizwits_protocol.h

 

 

 

 

1. #ifndef _GIZWITS_PROTOCOL_H
2. #define _GIZWITS_PROTOCOL_H
3.  
4. #ifdef __cplusplus
5. extern "C" {
6. #endif
7.  
8. #include <stdint.h>
9. #include <stdbool.h>
10. #include <stdio.h>
11. #include <stdlib.h>
12. #include <string.h>
13. #include "common.h"
14.  
15.                                                                                                                   
16. #define SEND_MAX_TIME       200                     ///< 200ms resend
17. #define SEND_MAX_NUM        2                       ///< resend times
18.                                                    
19. #define protocol_VERSION    "00000004"              ///< protocol version
20. #define P0_VERSION          "00000002"              ///< P0 protocol version
21.  
22. /**@name Product Key  
23. * @{
24. */
25. #define PRODUCT_KEY "9c8a5a8e38344fb4af14b6db0f5b1df7"
26. /**@} */
27. /**@name Product Secret  
28. * @{
29. */
30. #define PRODUCT_SECRET "45c86d8c6a2a4b1dac7d68df54f6e4f0"
31.                
32. /**@name Device status data reporting interval
33. * @{
34. */
35. #define REPORT_TIME_MAX 6000 //6S
36. /**@} */   
37.  
38. #define CELLNUMMAX 7   
39.  
40.  
41. /**@name Whether the device is in the control class, 0 means no, 1 means yes
42. * @{
43. */
44. #define DEV_IS_GATEWAY   0                    
45. /**@} */
46.  
47. /**@name Binding time
48. * @{
49. */
50. #define NINABLETIME  0
51. /**@} */
52.  
53.  
54.  
55. #define MAX_PACKAGE_LEN    (sizeof(devStatus_t)+sizeof(attrFlags_t)+20)                 ///< Data buffer maximum length
56. #define RB_MAX_LEN          (MAX_PACKAGE_LEN*2)     ///< Maximum length of ring buffer
57.  
58. /**@name Data point related definition
59. * @{
60. */
61. #define Relay_1_BYTEOFFSET                    0
62. #define Relay_1_BITOFFSET                     0
63. #define Relay_1_LEN                           1
64.  
65. #define Temp_RATIO                         1
66. #define Temp_ADDITION                      0
67. #define Temp_MIN                           0
68. #define Temp_MAX                           100
69. #define Humi_RATIO                         1
70. #define Humi_ADDITION                      0
71. #define Humi_MIN                           0
72. #define Humi_MAX                           100
73. #define Light_Intensity_RATIO                         1
74. #define Light_Intensity_ADDITION                      0
75. #define Light_Intensity_MIN                           0
76. #define Light_Intensity_MAX                           100
77. /**@} */
78.  
79. /** Writable data points Boolean and enumerated variables occupy byte size */
80. #define COUNT_W_BIT 1
81.  
82.  
83.  
84.  
85.  
86.  
87.  
88. /** Event enumeration */
89. typedef enum
90. {
91.   WIFI_SOFTAP = 0x00,                               ///< WiFi SOFTAP configuration event
92.   WIFI_AIRLINK,                                     ///< WiFi module AIRLINK configuration event
93.   WIFI_STATION,                                     ///< WiFi module STATION configuration event
94.   WIFI_OPEN_BINDING,                                ///< The WiFi module opens the binding event
95.   WIFI_CLOSE_BINDING,                               ///< The WiFi module closes the binding event
96.   WIFI_CON_ROUTER,                                  ///< The WiFi module is connected to a routing event
97.   WIFI_DISCON_ROUTER,                               ///< The WiFi module has been disconnected from the routing event
98.   WIFI_CON_M2M,                                     ///< The WiFi module has a server M2M event
99.   WIFI_DISCON_M2M,                                  ///< The WiFi module has been disconnected from the server M2M event
100.   WIFI_OPEN_TESTMODE,                               ///< The WiFi module turns on the test mode event
101.   WIFI_CLOSE_TESTMODE,                              ///< The WiFi module turns off the test mode event
102.   WIFI_CON_APP,                                     ///< The WiFi module connects to the APP event
103.   WIFI_DISCON_APP,                                  ///< The WiFi module disconnects the APP event
104.   WIFI_RSSI,                                        ///< WiFi module RSSI event
105.   WIFI_NTP,                                         ///< Network time event
106.   MODULE_INFO,                                      ///< Module information event
107.   TRANSPARENT_DATA,                                 ///< Transparency events
108.   EVENT_Relay_1,
109.   EVENT_TYPE_MAX                                    ///< Enumerate the number of members to calculate (user accidentally deleted)
110. } EVENT_TYPE_T;
111.  
112. /** P0 Command code */
113. typedef enum
114. {
115.     ACTION_CONTROL_DEVICE       = 0x01,             ///< Protocol 4.10 WiFi Module Control Device WiFi Module Send
116.     ACTION_READ_DEV_STATUS      = 0x02,             ///< Protocol 4.8 WiFi Module Reads the current status of the device WiFi module sent
117.     ACTION_READ_DEV_STATUS_ACK  = 0x03,             ///< Protocol 4.8 WiFi Module Read Device Current Status Device MCU Reply
118.     ACTION_REPORT_DEV_STATUS    = 0x04,             ///< Protocol 4.9 device MCU to the WiFi module to actively report the current status of the device to send the MCU
119.     ACTION_W2D_TRANSPARENT_DATA = 0x05,             ///< WiFi to device MCU transparent
120.     ACTION_D2W_TRANSPARENT_DATA = 0x06,             ///< Device MCU to WiFi
121. } actionType_t;   
122.  
123. /** Protocol network time structure */
124. typedef struct
125. {
126.     uint16_t year;
127.     uint8_t month;
128.     uint8_t day;
129.     uint8_t hour;
130.     uint8_t minute;
131.     uint8_t second;
132.     uint32_t ntp;
133. }protocolTime_t;
134.            
135.  
136. /** WiFi Module configuration parameters*/
137. typedef enum
138. {
139.   WIFI_RESET_MODE = 0x00,                           ///< WIFI module reset
140.   WIFI_SOFTAP_MODE,                                 ///< WIFI module softAP modeF
141.   WIFI_AIRLINK_MODE,                                ///< WIFI module AirLink mode
142.   WIFI_PRODUCTION_TEST,                             ///< MCU request WiFi module into production test mode
143.   WIFI_NINABLE_MODE,                                ///< MCU request module to enter binding mode
144.   WIFI_REBOOT_MODE,                                 ///< MCU request module reboot  
145. }WIFI_MODE_TYPE_T;                                
146.  
147. /** The protocol event type*/
148. typedef enum
149. {
150.   STATELESS_TYPE = 0x00,                            ///< Stateless type
151.   ACTION_CONTROL_TYPE,                              ///< Protocol 4.10 :WiFi module control device event
152.   WIFI_STATUS_TYPE,                                 ///< Protocol 4.5 :WiFi module inform the device MCU of the change event of the WiFi module status
153.   ACTION_W2D_TRANSPARENT_TYPE,                      ///< Protocol WiFi to device MCU transparent event
154.   GET_NTP_TYPE,                                     ///< Protocol 4.13 :The MCU requests access to the network time event
155.   GET_MODULEINFO_TYPE,                              ///< Protocol 4.9 :The MCU get module information event
156.   PROTOCOL_EVENT_TYPE_MAX                           ///< Count enumerated member (User donot delete)
157. } PROTOCOL_EVENT_TYPE_T;
158.      
159. /** Protocol command code */                                   
160. typedef enum                              
161. {                                                   
162.     CMD_GET_DEVICE_INTO             = 0x01,         ///< Protocol：3.1
163.     ACK_GET_DEVICE_INFO             = 0x02,         ///< Protocol：3.1
164.             
165.     CMD_ISSUED_P0                   = 0x03,         ///< Protocol：3.2 3.3
166.     ACK_ISSUED_P0                   = 0x04,         ///< Protocol：3.2 3.3
167.             
168.     CMD_REPORT_P0                   = 0x05,         ///< Protocol：3.4
169.     ACK_REPORT_P0                   = 0x06,         ///< Protocol：3.4
170.             
171.     CMD_HEARTBEAT                   = 0x07,         ///< Protocol：3.5
172.     ACK_HEARTBEAT                   = 0x08,         ///< Protocol：3.5
173.             
174.     CMD_WIFI_CONFIG                 = 0x09,         ///< Protocol：3.6
175.     ACK_WIFI_CONFIG                 = 0x0A,         ///< Protocol：3.6
176.             
177.     CMD_SET_DEFAULT                 = 0x0B,         ///< Protocol：3.7
178.     ACK_SET_DEFAULT                 = 0x0C,         ///< Protocol：3.7
179.             
180.     CMD_WIFISTATUS                  = 0x0D,         ///< Protocol：3.8
181.     ACK_WIFISTATUS                  = 0x0E,         ///< Protocol：3.8
182.         
183.     CMD_MCU_REBOOT                  = 0x0F,         ///< Protocol：4.1
184.     ACK_MCU_REBOOT                  = 0x10,         ///< Protocol：4.1
185.             
186.     CMD_ERROR_PACKAGE               = 0x11,         ///< Protocol：3.9
187.     ACK_ERROR_PACKAGE               = 0x12,         ///< Protocol：3.9
188.  
189.     CMD_PRODUCTION_TEST             = 0x13,         ///< Protocol：
190.     ACK_PRODUCTION_TEST             = 0x14,         ///< Protocol：
191.  
192.     CMD_NINABLE_MODE                = 0x15,         ///< Protocol：3.10
193.     ACK_NINABLE_MODE                = 0x16,         ///< Protocol：3.10
194.  
195.     CMD_GET_NTP                     = 0x17,         ///< Protocol：4.3
196.     ACK_GET_NTP                     = 0x18,         ///< Protocol：4.3
197.  
198.  
199.     CMD_ASK_BIGDATA                 = 0x19,         ///< Protocol：4.4
200.     ACK_ASK_BIGDATA                 = 0x1A,         ///< Protocol：4.4
201.  
202.     CMD_BIGDATA_READY               = 0x1B,         ///< Protocol：4.5
203.     ACK_BIGDATA_READY               = 0x1C,         ///< Protocol：4.5
204.  
205.     CMD_BIGDATA_SEND                = 0x1D,         ///< Protocol：4.6
206.     ACK_BIGDATA_SEND                = 0x1E,         ///< Protocol：4.6
207.  
208.     CMD_S_STOP_BIGDATA_SEND         = 0x1F,         ///< Protocol：4.7
209.     ACK_S_STOP_BIGDATA_SEND         = 0x20,         ///< Protocol：4.7
210.  
211.     CMD_D_STOP_BIGDATA_SEND         = 0x27,         ///< Protocol：4.8
212.     ACK_D_STOP_BIGDATA_SEND         = 0x28,         ///< Protocol：4.8
213.  
214.     CMD_ASK_MODULE_INFO             = 0x21,         ///< Protocol：4.9
215.     ACK_ASK_MODULE_INFO             = 0x22,         ///< Protocol：4.9
216.  
217.     CMD_ASK_AFFAIR_HANDLE           = 0x23,         ///< Protocol：4.10
218.     ACK_ASK_AFFAIR_HANDLE           = 0x24,         ///< Protocol：4.10
219.  
220.     CMD_AFFAIR_RESULT               = 0x25,         ///< Protocol：4.10
221.     ACK_AFFAIR_RESULT               = 0x26,         ///< Protocol：4.10
222.  
223.     CMD_REBOOT_MODULE               = 0x29,         ///< Protocol：3.11
224.     ACK_REBOOT_MODULE               = 0x2A,         ///< Protocol：3.11
225.  
226.     CMD_CONNECT_M2M                 = 0x2D,         ///< Protocol：for Virtualization
227.     ACK_CONNECT_M2M                 = 0x2E,         ///< Protocol：for Virtualization
228.  
229.     CMD_CONNECT_M2M_BACK            = 0x2F,         ///< Protocol：for Virtualization
230.     ACK_CONNECT_M2M_BACK            = 0x30,         ///< Protocol：for Virtualization
231.  
232.     CMD_UPLOAD_DATA                 = 0x31,         ///< Protocol：for Virtualization
233.     ACK_UPLOAD_DATA                 = 0x32,         ///< Protocol：for Virtualization
234.  
235.     CMD_UPLOAD_DATA_BACK            = 0x33,         ///< Protocol：for Virtualization
236.     ACK_UPLOAD_DATA_BACK            = 0x34,         ///< Protocol：for Virtualization
237.  
238.     CMD_DISCONNECT_M2M              = 0x35,         ///< Protocol：for Virtualization
239.     ACK_DISCONNECT_M2M              = 0x36,         ///< Protocol：for Virtualization
240.  
241.     CMD_DISCONNECT_M2M_BACK         = 0x37,         ///< Protocol：for Virtualization
242.     ACK_DISCONNECT_M2M_BACK         = 0x38,         ///< Protocol：for Virtualization
243.  
244.     CMD_RESET_SIMULATOR             = 0x39,         ///< Protocol：for Virtualization
245.     ACK_RESET_SIMULATOR             = 0x3A,         ///< Protocol：for Virtualization
246.  
247.     CMD_RESET_SIMULATOR_BACK        = 0x3B,         ///< Protocol：for Virtualization
248.     ACK_RESET_SIMULATOR_BACK        = 0x3C,         ///< Protocol：for Virtualization
249. } PROTOCOL_CMDTYPE;                                                                                 
250.                         
251. /** Illegal message type*/  
252. typedef enum
253. {
254.     ERROR_ACK_SUM = 0x01,                           ///< check error
255.     ERROR_CMD     = 0x02,                           ///< Command code error
256.     ERROR_OTHER   = 0x03,                           ///< other
257. } errorPacketsType_t;
258.  
259. typedef enum
260. {
261.     EXE_SUCESS                      = 0x00,
262.     EXE_FAILE                       = 0x01,
263. } execute_result;  
264.  
265. #pragma pack(1)
266.  
267. /** User Area Device State Structure */
268. typedef struct {
269.   bool valueRelay_1;
270.   uint32_t valueTemp;
271.   uint32_t valueHumi;
272.   uint32_t valueLight_Intensity;
273. } dataPoint_t;
274.  
275.  
276. /** Corresponding to the protocol "4.10 WiFi module control device" in the flag " attr_flags" */
277. typedef struct {
278.   uint8_t flagRelay_1:1;
279. } attrFlags_t;
280.  
281.  
282. /** Corresponding protocol "4.10 WiFi module control device" in the data value "attr_vals" */
283.  
284. typedef struct {
285.   uint8_t wBitBuf[COUNT_W_BIT];
286. } attrVals_t;
287.  
288. /** The flag "attr_flags (1B)" + data value "P0 protocol area" in the corresponding protocol "4.10 WiFi module control device"attr_vals(6B)" */
289. typedef struct {
290.     attrFlags_t attrFlags;
291.     attrVals_t  attrVals;
292. }gizwitsIssued_t;
293.  
294. /** Corresponding protocol "4.9 Device MCU to the WiFi module to actively report the current state" in the device status "dev_status(11B)" */
295.  
296. typedef struct {
297.   uint8_t wBitBuf[COUNT_W_BIT];
298.   uint8_t valueTemp;
299.   uint8_t valueHumi;
300.   uint8_t valueLight_Intensity;
301. } devStatus_t;
302.  
303.  
304.                
305. /** Event queue structure */                              
306. typedef struct {                           
307.     uint8_t num;                                    ///< Number of queue member
308.     uint8_t event[EVENT_TYPE_MAX];                  ///< Queue member event content
309. }eventInfo_t;
310.  
311.  
312.                            
313. /** wifiSignal strength structure */                       
314. typedef struct {                           
315.     uint8_t rssi;                                   ///< WIFI signal strength
316. }moduleStatusInfo_t;                                
317.  
318. /** Protocol standard header structure */
319. typedef struct
320. {
321.     uint8_t                 head[2];                ///< The head is 0xFFFF
322.     uint16_t                len;                    ///< From cmd to the end of the entire packet occupied by the number of bytes
323.     uint8_t                 cmd;                    ///< command
324.     uint8_t                 sn;                     ///<
325.     uint8_t                 flags[2];               ///< flag,default is 0
326. } protocolHead_t;
327.  
328. /** 4.1 WiFi module requests the device information protocol structure */
329. typedef struct
330. {
331.     protocolHead_t          head;                   ///< Protocol standard header structure
332.     uint8_t                 protocolVer[8];         ///< Protocol version
333.     uint8_t                 p0Ver[8];               ///< p0 Protocol version
334.     uint8_t                 hardVer[8];             ///< Hardware version
335.     uint8_t                 softVer[8];             ///< Software version
336.     uint8_t                 productKey[32];         ///< Product key
337.     uint16_t                ninableTime;            ///< Binding time(second)
338.     uint8_t                 devAttr[8];             ///< Device attribute
339.     uint8_t                 productSecret[32];      ///< Product secret
340.     uint8_t                 sum;                    ///< checksum
341. } protocolDeviceInfo_t;
342.  
343. /** Protocol common data frame(4.2、4.4、4.6、4.9、4.10) protocol structure */
344. typedef struct
345. {
346.     protocolHead_t          head;                   ///< Protocol standard header structure
347.     uint8_t                 sum;                    ///< checksum
348. } protocolCommon_t;
349.  
350. /** 4.3 The device MCU informs the WiFi module of the configuration mode  protocol structure */
351. typedef struct
352. {
353.     protocolHead_t          head;                   ///< Protocol standard header structure
354.     uint8_t                 cfgMode;                ///< Configuration parameters
355.     uint8_t                 sum;                    ///< checksum
356. } protocolCfgMode_t;
357.  
358. /** 4.13 The MCU requests the network time  protocol structure */
359. typedef struct
360. {
361.     protocolHead_t          head;                   ///< Protocol standard header structure
362.     uint8_t                 time[7];                ///< Hardware version
363.     uint8_t                 ntp_time[4];            ///< Software version
364.     uint8_t                 sum;                    ///< checksum
365. } protocolUTT_t;
366.  
367. /** WiFi module working status*/
368. typedef union
369. {
370.     uint16_t                value;
371.     struct
372.     {
373.         uint16_t            softap:1;     
374.         uint16_t            station:1;   
375.         uint16_t            onboarding:1;
376.         uint16_t            binding:1;   
377.         uint16_t            con_route:1;  
378.         uint16_t            con_m2m:1;   
379.         uint16_t            reserve1:2;   
380.         uint16_t            rssi:3;      
381.         uint16_t            app:1;        
382.         uint16_t            test:1;      
383.         uint16_t            reserve2:3;   
384.     }types;
385.    
386. } wifiStatus_t;
387.  
388. /** WiFi status type :protocol structure */
389. typedef struct
390. {
391.     protocolHead_t          head;                   ///< Protocol standard header structure
392.     wifiStatus_t            ststus;                 ///< WIFI status
393.     uint8_t                 sum;                    ///< checksum
394. } protocolWifiStatus_t;
395.  
396. /** Protocol common data frame(4.9) :protocol structure */
397. typedef struct
398. {
399.     protocolHead_t          head;                   ///< Protocol standard header structure
400.     uint8_t                 type;                   ///< Information Type
401.     uint8_t                 sum;                    ///< checksum
402. } protocolGetModuleInfo_t;
403.  
404. typedef struct
405. {
406.     uint8_t                 moduleType;             ///< Information Type
407.     uint8_t                 serialVer[8];           ///< Serial port protocol version
408.     uint8_t                 hardVer[8];             ///< Hardware version
409.     uint8_t                 softVer[8];             ///< Software version
410.     uint8_t                 mac[16];                ///< mac
411.     uint8_t                 ip[16];                 ///< ip
412.     uint8_t                 devAttr[8];             ///< Device attribute
413. } moduleInfo_t;
414.  
415. /** Protocol common data frame(4.9) :protocol structure */
416. typedef struct
417. {
418.     protocolHead_t          head;                   ///< Protocol standard header structure
419.     moduleInfo_t            wifiModuleInfo;         ///< WIFI module information
420.     uint8_t                 sum;                    ///< checksum
421. } protocolModuleInfo_t;
422.  
423.  
424. /** GPRS information of base station */
425. typedef struct
426. {
427.     uint16_t                    LAC_ID;             ///<LAC area ID
428.     uint16_t                    CellID;             ///<Base station ID
429.     uint8_t                     RSSI;               ///<Signal strength of base station
430. } gprsCellInfo_t;
431.  
432.  
433. /** 3.19 The basic information of the GPRS communication module  */
434. typedef struct
435. {
436.     uint8_t                 Type;//2G/3g/4g
437.     uint8_t                 Pro_ver[8];//Universal serial port protocol version
438.     uint8_t                 Hard_ver[8];//Hardware version
439.     uint8_t                 Soft_ver[8];//Software version
440.     uint8_t                 Device_attribute[8];//Device attribute
441.     uint8_t                 IMEI[16];//string
442.     uint8_t                 IMSI[16];//string
443.     uint8_t                 MCC[8];//Mobile country code
444.     uint8_t                 MNC[8];//Mobile network code
445.     uint8_t                 CellNum;//Number of base station
446.     uint8_t                 CellInfoLen;//Information length of base station
447.     gprsCellInfo_t          GPRS_CellINFO[CELLNUMMAX];
448. }gprsInfo_t;
449.  
450. /** 4.7 Illegal message notification :protocol structure*/
451. typedef struct
452. {
453.     protocolHead_t          head;                   ///< Protocol standard header structure
454.     uint8_t                 error;                  ///< error value
455.     uint8_t                 sum;                    ///< checksum
456. } protocolErrorType_t;
457.  
458.  
459. /** P0 message header */
460. typedef struct
461. {
462.     protocolHead_t          head;                   ///< Protocol standard header structure
463.     uint8_t                 action;                 ///< p0 command
464. } protocolP0Head_t;
465.  
466.  
467. /** protocol “4.9 The device MCU reports the current status to the WiFi module” device status "dev_status(11B)"  */
468. typedef struct {
469.                      
470.     devStatus_t devStatus;                          ///< Stores the device status data
471. }gizwitsReport_t;
472.  
473. /** resend strategy structure */
474. typedef struct {
475.     uint8_t                 num;                    ///< resend times
476.     uint8_t                 flag;                   ///< 1,Indicates that there is a need to wait for the ACK;0,Indicates that there is no need to wait for the ACK
477.     uint8_t                 buf[MAX_PACKAGE_LEN];   ///< resend data buffer
478.     uint16_t                dataLen;                ///< resend data length
479.     uint32_t                sendTime;               ///< resend time
480. } protocolWaitAck_t;
481.                                                                                 
482. /** 4.8 WiFi read device datapoint value , device ack use this struct */
483. typedef struct
484. {
485.     protocolHead_t          head;                   ///< Protocol head
486.     uint8_t                 action;                 ///< p0 action
487.     gizwitsReport_t         reportData;             ///< p0 data
488.     uint8_t                 sum;                    ///< Checksum
489. } protocolReport_t;
490.  
491.  
492. /** Protocol main and very important struct */
493. typedef struct
494. {
495.     uint8_t issuedFlag;                             ///< P0 action type
496.     uint8_t protocolBuf[MAX_PACKAGE_LEN];           ///< Protocol data handle buffer
497.     uint8_t transparentBuff[MAX_PACKAGE_LEN];       ///< Transparent data storage area
498.     uint32_t transparentLen;                        ///< Transmission data length
499.    
500.     uint32_t sn;                                    ///< Message SN
501.     uint32_t timerMsCount;                          ///< Timer Count
502.     protocolWaitAck_t waitAck;                      ///< Protocol wait ACK data structure
503.    
504.     eventInfo_t issuedProcessEvent;                 ///< Control events
505.     eventInfo_t wifiStatusEvent;                    ///< WIFI Status events
506.     eventInfo_t NTPEvent;                           ///< NTP events
507.     eventInfo_t moduleInfoEvent;                    ///< Module Info events
508.  
509.         gizwitsReport_t reportData;                     ///< The protocol reports data for standard product
510.     dataPoint_t gizCurrentDataPoint;                ///< Current device datapoints status
511.     dataPoint_t gizLastDataPoint;                   ///< Last device datapoints status
512.     moduleStatusInfo_t wifiStatusData;              ///< WIFI signal intensity
513.     protocolTime_t TimeNTP;                         ///< Network time information
514. #if MODULE_TYPE
515.     gprsInfo_t   gprsInfoNews;
516. #else  
517.     moduleInfo_t  wifiModuleNews;                   ///< WIFI module Info
518. #endif
519.         
520.         
521. }gizwitsProtocol_t;
522.  
523. #pragma pack()
524.  
525. /**@name Gizwits user API interface
526. * @{
527. */
528.  
529. extern uint32_t gizGetTimerCount(void);
530.  
531. void gizwitsInit(void);
532. int32_t gizwitsSetMode(uint8_t mode);
533. void gizwitsGetNTP(void);
534. int32_t gizwitsHandle(dataPoint_t *currentData);
535. int32_t gizwitsPassthroughData(uint8_t * gizdata, uint32_t len);
536. void gizwitsGetModuleInfo(void);
537. int32_t gizPutData(uint8_t *buf, uint32_t len);
538.  
539.  
540. /*添加用户自定义的函数**/
541. void gziwits_Task(dataPoint_t * currentDataPoint);
542.  
543. /**@} */
544. #ifdef __cplusplus
545. }
546. #endif
547.  
548. #endif
549.  

复制代码

 

 

6，Utils直接移植无需修改

7，添加TIM3定时器代码驱动

 

 

 

 

1. #include "tim3.h"
2. #include "gizwits_product.h"
3.  
4. void TIM3_Config(uint16_t psc,uint16_t arr)
5. {
6.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
7.         
8.         TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
9.         TIM_TimeBaseStructure.TIM_Period                     = arr;
10.         TIM_TimeBaseStructure.TIM_Prescaler                  = psc;
11.         TIM_TimeBaseStructure.TIM_ClockDivision              = TIM_CKD_DIV1;
12.         TIM_TimeBaseStructure.TIM_CounterMode                = TIM_CounterMode_Up;
13.         TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
14.         
15.         TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE );
16.         
17.   NVIC_InitTypeDef NVIC_InitStructure;
18.         NVIC_InitStructure.NVIC_IRQChannel                   = TIM3_IRQn;
19.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  
20.         NVIC_InitStructure.NVIC_IRQChannelSubPriority        = 3;  
21.         NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
22.         NVIC_Init(&NVIC_InitStructure);                             
23.         TIM_Cmd(TIM3, ENABLE);                  
24. }
25. /*用户实现的定时器接口*/
26. void TIM3_IRQHandler(void)  
27. {
28.         if(TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)  
29.         {
30.                 TIM_ClearITPendingBit(TIM3, TIM_IT_Update  );  
31.                 gizTimerMs();
32.         }
33. }
34. /*******************/
35. //void TIMER_IRQ_FUN(void)
36. //{
37. //  gizTimerMs();
38. //}
39. /*******************/
40.  
41.  
42. ## 添加UART3串口通信代码驱动
43.  
44. ```c
45. #include "usart3.h"
46. #include "gizwits_product.h"
47.  
48. void USART3_Init(uint32_t BaudRate)
49. {  
50.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);                               //GPIOB时钟
51.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);                          //串口3时钟使能
52.  
53.          USART_DeInit(USART3);  //复位串口3
54.         GPIO_InitTypeDef GPIO_InitStructure;
55.         
56.         
57.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                                     //PB10
58.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                              //USART3_TX   PB10
59.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                                       //复用推挽输出
60.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                         //初始化PB10
61.  
62.  
63.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;                                              //USART3_RX          PB11
64.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                          //浮空输入
65.         GPIO_Init(GPIOB, &GPIO_InitStructure);  
66.  
67.         USART_InitTypeDef                  USART_InitStructure;
68.         USART_InitStructure.USART_BaudRate            = BaudRate;                                    //波特率一般设置为9600;
69.         USART_InitStructure.USART_WordLength          = USART_WordLength_8b;                    //字长为8位数据格式
70.         USART_InitStructure.USART_StopBits            = USART_StopBits_1;                         //一个停止位
71.         USART_InitStructure.USART_Parity              = USART_Parity_No;                            //无奇偶校验位
72.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
73.         USART_InitStructure.USART_Mode                = USART_Mode_Rx | USART_Mode_Tx;                       //收发模式
74.   
75.         USART_Init(USART3, &USART_InitStructure);       //初始化串口3
76.   
77.  
78.         USART_Cmd(USART3, ENABLE);                      //使能串口
79.         
80.   
81.   USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);       //开启中断
82.  
83.   NVIC_InitTypeDef NVIC_InitStructure;
84.         NVIC_InitStructure.NVIC_IRQChannel                   = USART3_IRQn;
85.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
86.         NVIC_InitStructure.NVIC_IRQChannelSubPriority        = 3;
87.         NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;                        
88.         NVIC_Init(&NVIC_InitStructure);        
89.         
90. }
91. /*用户实现的中断服务函数接口*/
92. void USART3_IRQHandler(void)
93. {
94.         uint8_t Recv_Data;              
95.         if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)//接收到数据
96.         {         
97.                   Recv_Data = USART_ReceiveData(USART3);                 
98.                   gizPutData(&Recv_Data, 1);
99.         }                                                                                                                           
100. }   
101. /*********************/
102. //void UART_IRQ_FUN(void)
103. //{
104. //  uint8_t value = 0;
105. //  gizPutData(&value, 1);
106. //}
107. /*********************/

复制代码

 

8，修改关键函数的函数体，封装各模块的初始化


五，机智云初始化函数封装
成功联网

设备上线显示


效果展示