最新发表 推荐阅读 明星博主 原创博文 年度排行 博文排行 博文评论 FPGA/CPLD MCU/ 嵌入式 模拟 电源/新能源 测试测量 通信 智能手机 处理器与DSP PCB 汽车电子 消费电子 智能硬件 物联网 软件与OS 采购与分销 供应链管理 工程师职场 EDA/ IP/ 设计与制造 无人机 机器人/ AI 医疗电子 工业电子 管理
机智云物联网
文章：244 阅读：416228 评论：28 赞：1623
机智云Gizwits智能硬件自助开发及云服务平台，全栈式物联网平台领导者，为智能硬件提供研发－测试－量产－售后等全生命周期服务。开放Api，支持硬件、应用和业务云二次开发，支持主流无线模块，支持任意IaaS的公有云、私有云、混合云全球部署。
好友 私信 个人主页

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

2022-7-25 16:47 1021 4 4 分类: 物联网 文集: 机智云
第一篇内容：总体设计/系统功能介绍/机智云自助开发平台-开发利器GAgent等等
点击下载：【Io开发笔记】机智云智能浇花器实战(1)-基础Demo实现

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


一，BH1750光照传感器原理图




二，BH1750传感器代码
  1. #include "bh1750.h"
  2. #include "delay.h"

  4. uint8_t    BUF[8];               //接收数据缓存区  
  5. int         mcy;     //进位标志

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

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

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

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

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

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

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

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

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

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

复制代码

  1. #ifndef __BH1750_H__
  2. #define __BH1750_H__

  4. #include "STM32f10x.h"

  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

  15. #define BH1750_SCL_H     GPIO_SetBits(BH1750_PORT,BH1750_SCL_PIN)
  16. #define BH1750_SCL_L     GPIO_ResetBits(BH1750_PORT,BH1750_SCL_PIN)

  18. #define BH1750_SDA_H     GPIO_SetBits(BH1750_PORT,BH1750_SDA_PIN)
  19. #define BH1750_SDA_L     GPIO_ResetBits(BH1750_PORT,BH1750_SDA_PIN)  

  21.                                              
  22.                                                                                                                         
  23. extern uint8_t    BUF[8];                         //接收数据缓存区              
  24. extern int        dis_data;                       //变量               
  25. extern int        mcy;                            //表示进位标志位

  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);


  35. #endif


复制代码

BH1750传感器代码说明


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


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



创建好后就会有基本信息




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


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

  2. Product Key ：9c8a5a8e38344fb4af14b6db0f5b1df7

  4. Product Secret ：45c86d8c6a2a4b1dac7d68df54f6e4f0

复制代码


步骤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"

  6. static uint32_t timerMsCount;
  7. uint8_t aRxBuffer;
  8. dataPoint_t currentDataPoint;
  9. uint8_t wifi_flag;

  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

  25.   if((NULL == info) || (NULL == gizdata))
  26.   {
  27.     return -1;
  28.   }

  30.   for(i=0; inum; 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;

  41.         }
  42.         else
  43.         {
  44.             currentDataPoint.valueRelay_1 = 0;

  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:

  56.         break;
  57.       case WIFI_DISCON_ROUTER:

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

  92.   return 0;
  93. }


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

  113. void gizTimerMs(void)
  114. {
  115.     timerMsCount++;
  116. }

  118. uint32_t gizGetTimerCount(void)
  119. {
  120.     return timerMsCount;
  121. }

  123. void mcuRestart(void)
  124. {
  125.         __set_FAULTMASK(1);
  126.         NVIC_SystemReset();
  127. }

  129. void TIMER_IRQ_FUN(void)
  130. {
  131.   gizTimerMs();
  132. }

  134. void UART_IRQ_FUN(void)
  135. {
  136.   uint8_t value = 0;
  137.   gizPutData(&value, 1);
  138. }

  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);
  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. }

复制代码
5，修改
  1. #ifndef _GIZWITS_PRODUCT_H
  2. #define _GIZWITS_PRODUCT_H

  4. #ifdef __cplusplus
  5. extern "C" {
  6. #endif

  8. #include
  9. //#include "stm32f1xx.h"
  10. #include "gizwits_protocol.h"

  12. /**
  13. * MCU software version
  14. */
  15. #define SOFTWARE_VERSION "03030000"
  16. /**
  17. * MCU hardware version
  18. */
  19. #define HARDWARE_VERSION "03010100"


  22. /**
  23. * Communication module model
  24. */
  25. #define MODULE_TYPE 0 //0,WIFI ;1,GPRS


  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. /**@} */

  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

  46. #if (UART_PORT == 1)
  47. #define UART_GPIO_Cmd          RCC_APB2PeriphClockCmd
  48. #define UART_GPIO_CLK          RCC_APB2Periph_GPIOA

  50. #define UART_AFIO_Cmd          RCC_APB2PeriphClockCmd
  51. #define UART_AFIO_CLK          RCC_APB2Periph_AFIO

  53. #define UART_CLK_Cmd           RCC_APB2PeriphClockCmd
  54. #define UART_CLK               RCC_APB2Periph_USART1

  56. #define UART_GPIO_PORT         GPIOA
  57. #define UART_RxPin             GPIO_Pin_10
  58. #define UART_TxPin             GPIO_Pin_9
  59. #endif

  61. #if (UART_PORT == 2)
  62. #define UART_GPIO_Cmd          RCC_APB2PeriphClockCmd
  63. #define UART_GPIO_CLK          RCC_APB2Periph_GPIOA

  65. #define UART_AFIO_Cmd          RCC_APB2PeriphClockCmd
  66. #define UART_AFIO_CLK          RCC_APB2Periph_AFIO

  68. #define UART_CLK_Cmd           RCC_APB1PeriphClockCmd
  69. #define UART_CLK               RCC_APB1Periph_USART2

  71. #define UART_GPIO_PORT         GPIOA
  72. #define UART_RxPin             GPIO_Pin_3
  73. #define UART_TxPin             GPIO_Pin_2
  74. #endif


  77. #if (UART_PORT == 3)

  79. #define UART_GPIO_Cmd          RCC_APB2PeriphClockCmd
  80. #define UART_GPIO_CLK          RCC_APB2Periph_GPIOC

  82. #define UART_AFIO_Cmd          RCC_APB2PeriphClockCmd
  83. #define UART_AFIO_CLK          RCC_APB2Periph_AFIO

  85. #define UART_CLK_Cmd           RCC_APB1PeriphClockCmd
  86. #define UART_CLK               RCC_APB1Periph_USART3

  88. #define UART_GPIO_PORT         GPIOC
  89. #define UART_RxPin             GPIO_Pin_11
  90. #define UART_TxPin             GPIO_Pin_10

  92. #endif
  93. /**@} */

  95. /** User area the current device state structure*/
  96. extern dataPoint_t currentDataPoint;

  98. void gizTimerMs(void);
  99. uint32_t gizGetTimerCount(void);
  100. void timerInit(void);
  101. void uartInit(void);

  103. void userInit(void);
  104. void userHandle(void);
  105. void mcuRestart(void);

  107. int32_t uartWrite(uint8_t *buf, uint32_t len);
  108. int8_t gizwitsEventProcess(eventInfo_t *info, uint8_t *data, uint32_t len);

  110. #ifdef __cplusplus
  111. }
  112. #endif

  114. #endif

复制代码

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;

  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


  32. /**@} */

  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;

  45.     if(NULL == buf)
  46.     {
  47.         GIZWITS_LOG("ERR: gizPutData buf is empty \n");
  48.         return -1;
  49.     }

  51.     count = rbWrite(&pRb, buf, len);
  52.     if(count != len)
  53.     {
  54.         GIZWITS_LOG("ERR: Failed to rbWrite \n");
  55.         return -1;
  56.     }

  58.     return count;
  59. }



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

  78.     memset((uint8_t *)head, 0, sizeof(protocolHead_t));
  79.     head->head[0] = 0xFF;
  80.     head->head[1] = 0xFF;

  82.     return 0;
  83. }

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

  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();

  108.     return 0;
  109. }
  110. /**
  111. * @brief generates "controlled events" according to protocol

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

  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;

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

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

  198.     if(1 == ret)
  199.     {
  200.         lastReportTime = gizGetTimerCount();
  201.     }
  202.     return ret;
  203. }

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

  221.     gizMemset((uint8_t *)devStatusPtr->wBitBuf,0,sizeof(devStatusPtr->wBitBuf));

  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));

  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);




  233.     return 0;
  234. }


  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];

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

  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.    

  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;

  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));

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

  365.     return 0;
  366. }

  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;

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

  404.     gizProtocolWaitAck((uint8_t *)&protocolReport, sizeof(protocolReport_t));

  406.     return ret;
  407. }/**
  408. * @brief Datapoints reporting mechanism
  409. *
  410. * 1. Changes are reported immediately

  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();

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

  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));

  440.         lastRepTime = timeNow;
  441.     }
  442. }

  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;

  468.     if((NULL == rb) || (NULL == gizdata) ||(NULL == len))
  469.     {
  470.         GIZWITS_LOG("gizProtocolGetOnePacket Error , Illegal Param\n");
  471.         return -1;
  472.     }

  474.     tmpLen = rbCanRead(rb);
  475.     if(0 == tmpLen)
  476.     {
  477.         return -1;
  478.     }

  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++;

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

  526.             lastData = tmpData;
  527.             debugCount++;
  528.         }
  529.     }

  531.     if((protocolCount > 4) && (protocolCount == tmpCount))
  532.     {
  533.         sum = gizProtocolSum(protocolBuff, protocolCount);

  535.         if(protocolBuff[protocolCount-1] == sum)
  536.         {
  537.             memcpy(gizdata, protocolBuff, tmpCount);
  538.             *len = tmpCount;
  539.             protocolFlag = 0;

  541.             protocolCount = 0;
  542.             debugCount = 0;
  543.             lastData = 0;

  545.             return 0;
  546.         }
  547.         else
  548.         {
  549.             return -2;
  550.         }
  551.     }

  553.     return 1;
  554. }



  558. /**
  559. * @brief Protocol data resend

  561. * The protocol data resend when check timeout and meet the resend limiting

  563. * @param none   
  564. *
  565. * @return none
  566. */
  567. static void gizProtocolResendData(void)
  568. {
  569.     int32_t ret = 0;

  571.     if(0 == gizwitsProtocol.waitAck.flag)
  572.     {
  573.         return;
  574.     }

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

  584.     gizwitsProtocol.waitAck.sendTime = gizGetTimerCount();
  585. }

  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;

  598.     if(NULL == head)
  599.     {
  600.         GIZWITS_LOG("ERR: data is empty \n");
  601.         return -1;
  602.     }

  604.     if(waitAckHead->cmd+1 == head->cmd)
  605.     {
  606.         memset((uint8_t *)&gizwitsProtocol.waitAck, 0, sizeof(protocolWaitAck_t));
  607.     }

  609.     return 0;
  610. }

  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;

  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));

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

  640.     return ret;
  641. }

  643. /**
  644. * @brief ACK processing function

  646. * Time-out 200ms no ACK resend，resend two times at most

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

  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;

  685.     if(NULL == head)
  686.     {
  687.         GIZWITS_LOG("gizProtocolGetDeviceInfo Error , Illegal Param\n");
  688.         return -1;
  689.     }

  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));

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

  716. /**
  717. * @brief Protocol 4.7 Handling of illegal message notification

  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;

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

  747.     return ret;
  748. }

  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);

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

  780. /**
  781. * @brief Protocol 4.4 Device MCU restarts function

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

  795. /**
  796. * @brief Protocol 4.5 :The WiFi module informs the device MCU of working status about the WiFi module

  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;

  805.     if(NULL == status)
  806.     {
  807.         GIZWITS_LOG("gizProtocolModuleStatus Error , Illegal Param\n");
  808.         return -1;
  809.     }

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

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

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

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

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

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

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

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

  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);

  945.     gizwitsProtocol.issuedFlag = WIFI_STATUS_TYPE;

  947.     return 0;
  948. }


  951. /**@name Gizwits User API interface
  952. * @{
  953. */

  955. /**
  956. * @brief gizwits Protocol initialization interface

  958. * Protocol-related timer, serial port initialization

  960. * Datapoint initialization

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

  981. /**
  982. * @brief WiFi configure interface

  984. * Set the WiFi module into the corresponding configuration mode or reset the module

  986. * @param[in] mode ：0x0， reset the module ;0x01， SoftAp mode ;0x02， AirLink mode ;0x03， Production test mode; 0x04:allow users to bind devices

  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;

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

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

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

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

  1080.             gizProtocolWaitAck((uint8_t *)&setDefault, sizeof(protocolCommon_t));
  1081.             break;
  1082.         default:
  1083.             GIZWITS_LOG("ERR: CfgMode error!\n");
  1084.             break;
  1085.     }

  1087.     return ret;
  1088. }

  1090. /**
  1091. * @brief Get the the network time

  1093. * Protocol 4.13:"Device MCU send" of "the MCU requests access to the network time"

  1095. * @param[in] none
  1096. * @return none
  1097. */
  1098. void gizwitsGetNTP(void)
  1099. {
  1100.     int32_t ret = 0;
  1101.     protocolCommon_t getNTP;

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

  1114.     gizProtocolWaitAck((uint8_t *)&getNTP, sizeof(protocolCommon_t));
  1115. }


  1118. /**
  1119. * @brief Get Module Info

  1121. *

  1123. * @param[in] none
  1124. * @return none
  1125. */
  1126. void gizwitsGetModuleInfo(void)
  1127. {
  1128.     int32_t ret = 0;
  1129.     protocolGetModuleInfo_t getModuleInfo;

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

  1143.     gizProtocolWaitAck((uint8_t *)&getModuleInfo, sizeof(protocolGetModuleInfo_t));
  1144. }


  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;

  1158.     if(NULL == head)
  1159.     {
  1160.         GIZWITS_LOG("NTP is empty \n");
  1161.         return -1;
  1162.     }

  1164.     memcpy((uint8_t *)&gizwitsProtocol.wifiModuleNews,(uint8_t *)&moduleInfo->wifiModuleInfo, sizeof(moduleInfo_t));

  1166.     gizwitsProtocol.moduleInfoEvent.event[gizwitsProtocol.moduleInfoEvent.num] = MODULE_INFO;
  1167.     gizwitsProtocol.moduleInfoEvent.num++;

  1169.     gizwitsProtocol.issuedFlag = GET_MODULEINFO_TYPE;


  1172.     return 0;
  1173. }

  1175. /**
  1176. * @brief Protocol handling function

  1178. *

  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;


  1197.     if(NULL == currentData)
  1198.     {
  1199.         GIZWITS_LOG("GizwitsHandle Error , Illegal Param\n");
  1200.         return -1;
  1201.     }

  1203.     /*resend strategy*/
  1204.     gizProtocolAckHandle();
  1205.     ret = gizProtocolGetOnePacket(&pRb, gizwitsProtocol.protocolBuf, &protocolLen);

  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
  1214.         {
  1215.             GIZWITS_LOG("%02x ", gizwitsProtocol.protocolBuf);
  1216.         }
  1217.         GIZWITS_LOG("\n");
  1218. #endif

  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;

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

  1318.     gizDevReportPolicy(currentData);

  1320.     return 0;
  1321. }

  1323. /**
  1324. * @brief gizwits report transparent data interface

  1326. * The user can call the interface to complete the reporting of private protocol data

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

  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

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

  1363.     gizProtocolWaitAck(tx_buf, data_len+4);

  1365.     return 0;
  1366. }


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


  1380. /**@} */

复制代码



修改gizwits_protocol.h


  1. #ifndef _GIZWITS_PROTOCOL_H
  2. #define _GIZWITS_PROTOCOL_H

  4. #ifdef __cplusplus
  5. extern "C" {
  6. #endif

  8. #include
  9. #include
  10. #include
  11. #include
  12. #include
  13. #include "common.h"

  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

  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. /**@} */   

  38. #define CELLNUMMAX 7   


  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. /**@} */

  47. /**@name Binding time
  48. * @{
  49. */
  50. #define NINABLETIME  0
  51. /**@} */



  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

  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

  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. /**@} */

  79. /** Writable data points Boolean and enumerated variables occupy byte size */
  80. #define COUNT_W_BIT 1







  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;

  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;   

  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.            

  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;                                

  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

  189.     CMD_PRODUCTION_TEST             = 0x13,         ///< Protocol：
  190.     ACK_PRODUCTION_TEST             = 0x14,         ///< Protocol：

  192.     CMD_NINABLE_MODE                = 0x15,         ///< Protocol：3.10
  193.     ACK_NINABLE_MODE                = 0x16,         ///< Protocol：3.10

  195.     CMD_GET_NTP                     = 0x17,         ///< Protocol：4.3
  196.     ACK_GET_NTP                     = 0x18,         ///< Protocol：4.3


  199.     CMD_ASK_BIGDATA                 = 0x19,         ///< Protocol：4.4
  200.     ACK_ASK_BIGDATA                 = 0x1A,         ///< Protocol：4.4

  202.     CMD_BIGDATA_READY               = 0x1B,         ///< Protocol：4.5
  203.     ACK_BIGDATA_READY               = 0x1C,         ///< Protocol：4.5

  205.     CMD_BIGDATA_SEND                = 0x1D,         ///< Protocol：4.6
  206.     ACK_BIGDATA_SEND                = 0x1E,         ///< Protocol：4.6

  208.     CMD_S_STOP_BIGDATA_SEND         = 0x1F,         ///< Protocol：4.7
  209.     ACK_S_STOP_BIGDATA_SEND         = 0x20,         ///< Protocol：4.7

  211.     CMD_D_STOP_BIGDATA_SEND         = 0x27,         ///< Protocol：4.8
  212.     ACK_D_STOP_BIGDATA_SEND         = 0x28,         ///< Protocol：4.8

  214.     CMD_ASK_MODULE_INFO             = 0x21,         ///< Protocol：4.9
  215.     ACK_ASK_MODULE_INFO             = 0x22,         ///< Protocol：4.9

  217.     CMD_ASK_AFFAIR_HANDLE           = 0x23,         ///< Protocol：4.10
  218.     ACK_ASK_AFFAIR_HANDLE           = 0x24,         ///< Protocol：4.10

  220.     CMD_AFFAIR_RESULT               = 0x25,         ///< Protocol：4.10
  221.     ACK_AFFAIR_RESULT               = 0x26,         ///< Protocol：4.10

  223.     CMD_REBOOT_MODULE               = 0x29,         ///< Protocol：3.11
  224.     ACK_REBOOT_MODULE               = 0x2A,         ///< Protocol：3.11

  226.     CMD_CONNECT_M2M                 = 0x2D,         ///< Protocol：for Virtualization
  227.     ACK_CONNECT_M2M                 = 0x2E,         ///< Protocol：for Virtualization

  229.     CMD_CONNECT_M2M_BACK            = 0x2F,         ///< Protocol：for Virtualization
  230.     ACK_CONNECT_M2M_BACK            = 0x30,         ///< Protocol：for Virtualization

  232.     CMD_UPLOAD_DATA                 = 0x31,         ///< Protocol：for Virtualization
  233.     ACK_UPLOAD_DATA                 = 0x32,         ///< Protocol：for Virtualization

  235.     CMD_UPLOAD_DATA_BACK            = 0x33,         ///< Protocol：for Virtualization
  236.     ACK_UPLOAD_DATA_BACK            = 0x34,         ///< Protocol：for Virtualization

  238.     CMD_DISCONNECT_M2M              = 0x35,         ///< Protocol：for Virtualization
  239.     ACK_DISCONNECT_M2M              = 0x36,         ///< Protocol：for Virtualization

  241.     CMD_DISCONNECT_M2M_BACK         = 0x37,         ///< Protocol：for Virtualization
  242.     ACK_DISCONNECT_M2M_BACK         = 0x38,         ///< Protocol：for Virtualization

  244.     CMD_RESET_SIMULATOR             = 0x39,         ///< Protocol：for Virtualization
  245.     ACK_RESET_SIMULATOR             = 0x3A,         ///< Protocol：for Virtualization

  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;

  259. typedef enum
  260. {
  261.     EXE_SUCESS                      = 0x00,
  262.     EXE_FAILE                       = 0x01,
  263. } execute_result;  

  265. #pragma pack(1)

  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;


  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;


  282. /** Corresponding protocol "4.10 WiFi module control device" in the data value "attr_vals" */

  284. typedef struct {
  285.   uint8_t wBitBuf[COUNT_W_BIT];
  286. } attrVals_t;

  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;

  294. /** Corresponding protocol "4.9 Device MCU to the WiFi module to actively report the current state" in the device status "dev_status(11B)" */

  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;


  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;


  312.                            
  313. /** wifiSignal strength structure */                       
  314. typedef struct {                           
  315.     uint8_t rssi;                                   ///< WIFI signal strength
  316. }moduleStatusInfo_t;                                

  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;

  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;

  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;

  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;

  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;

  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;

  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;

  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;

  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;

  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;


  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;


  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;

  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;


  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;


  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;

  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;


  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

  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;

  523. #pragma pack()

  525. /**@name Gizwits user API interface
  526. * @{
  527. */

  529. extern uint32_t gizGetTimerCount(void);

  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);


  540. /*添加用户自定义的函数**/
  541. void gziwits_Task(dataPoint_t * currentDataPoint);

  543. /**@} */
  544. #ifdef __cplusplus
  545. }
  546. #endif

  548. #endif

复制代码



6，Utils直接移植无需修改


7，添加TIM3定时器代码驱动
  1. #include "tim3.h"
  2. #include "gizwits_product.h"

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


  42. ## 添加UART3串口通信代码驱动

  44. ```c
  45. #include "usart3.h"
  46. #include "gizwits_product.h"

  48. void USART3_Init(uint32_t BaudRate)
  49. {  
  50.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);                               //GPIOB时钟
  51.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);                          //串口3时钟使能

  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


  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);  

  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.   

  78.         USART_Cmd(USART3, ENABLE);                      //使能串口
  79.         
  80.   
  81.   USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);       //开启中断

  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，修改关键函数的函数体，封装各模块的初始化


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


设备上线显示


效果展示
写原创有奖励！2024面包板原创奖励正在进行中

文章评论（0条评论）

登录后参与讨论
机智云物联网
文章：244 阅读：416228 评论：28 赞：1623
机智云Gizwits智能硬件自助开发及云服务平台，全栈式物联网平台领导者，为智能硬件提供研发－测试－量产－售后等全生命周期服务。开放Api，支持硬件、应用和业务云二次开发，支持主流无线模块，支持任意IaaS的公有云、私有云、混合云全球部署。
好友 私信 个人主页
EE直播间
更多
在线研讨会
更多
我要评论
0
4
关闭 站长推荐上一条 /2 下一条
  • 帖子
  • 博文
  • 返回顶部