第一篇内容：总体设计/系统功能介绍/机智云自助开发平台-开发利器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[i] = 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. 
     
196. 
     

复制代码

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. 
    
38. 
    

复制代码

BH1750传感器代码说明

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

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

创建好后就会有基本信息

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

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

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

复制代码

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

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

四，MCU开发

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

1，生成代码包

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

3，机智云Gizwits协议移植

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

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

4，修改gizwits_product.c

1. #include
2. #include
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; inum; i++)
31. {
32. switch(info->event[i])
33. {
34. case EVENT_Relay_1:
35. currentDataPoint.valueRelay_1 = dataPointPtr->valueRelay_1;
36. GIZWITS_LOG("Evt: EVENT_Relay_1 %d ", 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 ", wifiData->rssi);
68. break;
69. case TRANSPARENT_DATA:
70. GIZWITS_LOG("TRANSPARENT_DATA ");
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] ",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 ... ");
78. #if MODULE_TYPE
79. GIZWITS_LOG("GPRS MODULE ... ");
80. //Format By gprsInfo_t
81. #else
82. GIZWITS_LOG("WIF MODULE ... ");
83. //Format By moduleInfo_t
84. GIZWITS_LOG("moduleType : [%d] ",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
150. {
151. USART_SendData(USART3,buf[i]);
152. while(USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET); //循环发送,直到发送完毕
153. if(i >=2 && buf[i] == 0xFF)
154. {
155. USART_SendData(USART3, 0x55);
156. while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET); //循环发送,直到发送完毕
157. }
158. }
159. return len;
160. }
161. 
     
162. 
     

复制代码

5，修改

1. #ifndef _GIZWITS_PRODUCT_H
2. #define _GIZWITS_PRODUCT_H
3. 
   
4. #ifdef __cplusplus
5. extern "C" {
6. #endif
7. 
   
8. #include
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. 
     
116. 
     

复制代码

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 ");
48. return -1;
49. }
50. 
    
51. count = rbWrite(&pRb, buf, len);
52. if(count != len)
53. {
54. GIZWITS_LOG("ERR: Failed to rbWrite ");
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 ");
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 ");
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 ");
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 ");
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 ");
164. return -1;
165. }
166. currentTime = gizGetTimerCount();
167. if(last->valueRelay_1 != cur->valueRelay_1)
168. {
169. GIZWITS_LOG("valueRelay_1 Changed ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ", 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 ", 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 ");
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 ", 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 ");
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 ");
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 ");
471. return -1;
472. }
473. 
     
474. tmpLen = rbCanRead(rb);
475. if(0 == tmpLen)
476. {
477. return -1;
478. }
479. 
     
480. for(i=0; 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 ");
577. 
     
578. ret = uartWrite(gizwitsProtocol.waitAck.buf, gizwitsProtocol.waitAck.dataLen);
579. if(ret != gizwitsProtocol.waitAck.dataLen)
580. {
581. GIZWITS_LOG("ERR: resend data error ");
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 ");
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 ");
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 ", 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 ", 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 ");
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 ", 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 ");
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 ", 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 ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ");
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 ", 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 ");
972. }
973. else
974. {
975. GIZWITS_LOG("rbCreate Faild ");
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 ", 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 ", 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 ", 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 ", 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 ", 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 ", ret);
1078. }
1079. 
      
1080. gizProtocolWaitAck((uint8_t *)&setDefault, sizeof(protocolCommon_t));
1081. break;
1082. default:
1083. GIZWITS_LOG("ERR: CfgMode error! ");
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 ", 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 ", 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 ");
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 ");
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! ");
1210. 
      
1211. #ifdef PROTOCOL_DEBUG
1212. GIZWITS_LOG("WiFi2MCU[%4d:%4d]: ", gizGetTimerCount(), protocolLen);
1213. for(i=0; i
1214. {
1215. GIZWITS_LOG("%02x ", gizwitsProtocol.protocolBuf[i]);
1216. }
1217. GIZWITS_LOG(" ");
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 ", 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 : ");
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! ");
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 ");
1261. break;
1262. case ACK_GET_NTP:
1263. gizProtocolWaitAckCheck(recvHead);
1264. gizProtocolNTP(recvHead);
1265. GIZWITS_LOG("Ack GET_UTT success ");
1266. break;
1267. case ACK_ASK_MODULE_INFO:
1268. gizProtocolWaitAckCheck(recvHead);
1269. gizProtocolModuleInfoHandle(recvHead);
1270. GIZWITS_LOG("Ack GET_Module success ");
1271. break;
1272. 
      
1273. default:
1274. gizProtocolErrorCmd(recvHead,ERROR_CMD);
1275. GIZWITS_LOG("ERR: cmd code error! ");
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! ");
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 ");
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 ", 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. 
      
1382. 
      

复制代码

修改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
9. #include
10. #include
11. #include
12. #include
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; ///
428. uint16_t CellID; ///
429. uint8_t RSSI; ///
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. 
     
550. 
     

复制代码

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. /*********************/
108. 
     

复制代码

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


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

设备上线显示

效果展示