Arduino 物联网篇 | Arduno + ESP8266模组运用中移OneNet物联网平台实现远程监控

一、初识OneNet

OneNET定位为PaaS服务，即在物联网应用和真实设备之间搭建高效、稳定、安全的应用平台：面向设备，适配多种网络环境和常见传输协议，提供各类硬件终端的快速接入方案和设备管理服务；面向应用层，提供丰富的API和数据分发能力以满足各类行业应用系统的开发需求，使物联网企业可以更加专注于自身应用的开发，而不用将工作重心放在设备接入层的环境搭建上，从而缩短物联网系统的形成周期，降低企业研发、运营和运维成本。

1. 物联网与OneNet

物联网是把生活中各种物品通过各种元器件，传感器等连接在一起的网络。这个网络具备观察性和可控性，我们可以通过这个网络知道其中各个物品的状态，同时可以控制他们。

物联网可以分为三层，感知层、网络层、应用层。其中感知层可以通过传感器，执行器等元器件与环境进行互动。网络层指起到数据存储于管理功能的那一部分，其可以把各种数据按照特定标准进行存储，便于应用层调取。应用层是用户与网络层的接口，一方面把数据以特定形式展现给用户，一方面存储用户的指令，以备感知层调用。

OneNET平台具备网络层和应用层的功能，它可以把Arduino传感器采集的数据存储在自己的服务器上，同时可以在设计应用的时候调用这些数据。

OneNET平台是中国移动开发的物联网平台，稳定性非常好，上手容易。
使用方法：

1）进入OneNET官网（“https://open.iot.10086.cn/”）注册账号

2）注册完成后在首页右上角点击「开发者中心」进入产品开发界面

小提示：零基础入，建议先别去网络上找找乱七八糟的文章学习，直接参考官方文档一步一步走就没那么多问题了。遇到实际问题后首先根据官方文档以及网上资料去解决。官方文档：【首页】-【服务与支持】- 【开发文档】- 【快速入门】

2. OneNet快速入门

2.1 创建产品

进入产品开发界面后，选择左侧菜单栏中【全部产品】-【基础服务】。基础服务中有：

• NB-IoT物联网套件
• MQTT物联网套件(新版)
• 多协议接入
• 协议适配

【多协议接入】-【HTTP】-【添加产品】

添加产品时，填写产品相关信息

2.2 创建设备

创建产品后，点击左上角 【OneNet】 回到首页，单击进入产品 【HTTP】

OneNet上在项目下还有设备的概念，一个设备就相当于一块Arduino板。单击【设备列表】-【添加备】，在弹出的设备信息里可以随便填，对后面没有影响，唯一需要注意的是数据保密性这里，建议选择私有，如果选择公开，那后面你把这个项目发布的时候别人就能看的你的数据了。填完后单击添加即可完成创建。

选择【设备列表】-【添加设备】

【添加新设备】 - 设置设备名称、设备编号后，点击确认即可。

2.3 新建数据流

Arduino发送给OneNET平台的数据可能有很多种，比如温度，湿度，光照强度等等。我们需要在OneNET上建立「变量」来存储这些数据，在OneNET上我们把这种变量叫做“ 数据流 ”。单击【数据流模板】-【添加数据流模板】，填入数据流名称即可得到一个存储数据的数据流。

2.4 创建应用

有了数据之后，我们需要把数据以一种特定形式呈现出来，比如用一个温度计显示实时温度，以一个折线图显示一段时间的温度趋势。肩负展示数据功能的是“应用”，就像我们平时在手机的“应用商店”里下载的那种应用一样，上面会有图标，图片等等。我们依次单击选择【应用管理】-【添加应用】

设置应用相关信息：名称、logo等。

添加应用后，进入编辑应用界面如下：

设置应用界面组件以及组件的属性：

查看应用有两种方法：

• 第一种单击【应用管理】-【应用名称】，即可在底部看到应用页面
• 第二种是下载OneNET的移动端（下载地址：https://open.iot.10086.cn/doc/art656.html ），通过手机或平板查看。

---

参考资料

• [1] 【电子发烧友】Arduino接入OneNET云服务
• [2] 【CSDN】Arduino物联网三步曲—（1）OneNET初识
• [3] Arduino+ESP8266上传至oneNet云(文章粗劣)
• [4] 【CSDN】超详细Arduino uno接入onenet云平台教程（TCP透传）
• [5] 【B站】Arduino 利用ESP8266模块通过ONENET平台来实现远程控制

---

二、Arduino + ESP8266 接入 OneNet

1.准备工作

1.1 硬件

• ESP8266-01S * 1
• Arduno Uno * 1
• DHT11 * 1

ESP8266-01S	Arduno Uno
VCC&EN	3.3V
GND	GND
RX	TX (D1)
TX	RX(D0)

DHT11	Arduno Uno
VCC	3.3V /5V
GND	GND
OUT	D3

1.2 软件

Arduino 通过 ESP8266-01S 发送数据给 OneNet 平台的数据。ESP8266-01S 属于 安信可公司的产品，我们需要下载官网的安信可串口调试助手 查看返回的数据。

• 安信可串口调试助手
• Arduino IDE

1.3 平台

OneNet服务器里有很多项目很多设备，具体把数据发到拿呢？
实际上OneNet平台对于发送过来的Json数据是有一定格式要求的，其中除了要传输的数据，还包含了设备ID、密匙，这样就可以保证数据发送到正确的设备。

在正式开始前，我们需要记录设备的ID和密匙。设备ID可通过单击【设备列表】可在设备前面看到设备ID、密匙，在APIKey这一列的就是密匙。

• 设备ID 597420765
• 密匙 APIKey vutzlt=cl9B99vnsozQcKSRSkNs= (进入【设备列表】- 【设备详情】路径添加APIKey)

另外，还需要自家的WiFi账号与密码接入网络。

• WiFi名称
• WiFi密码

补充：按照前文的方法对 OneNet平台设置：创建产品（多协议接入 - edp）、创建设备、新建数据流（数据流的名称要与程序中的一致）、添加应用（注意开关控件的属性设置"switch:{V}"）

2.程序设计

2.1 ESP8266-01S AT指令手动联网

/***************************************************
 * 
 * 名称：ESP8266 01S AT指令手动联网
 * 作者：Naiva
 * 日期：2020/05/17
 * 接线：
 * Arduino nano       ESP8266 01S
 * D2(RX)   ———   TX
 * D3(TX)   ———   RX
 * VCC(3.3) ———   VCC(&EN)
 * GND      ———   GND
 * 
 ****************************************************/


#include<SoftwareSerial.h>
SoftwareSerial mySerial(2,3);//RX ,TX   wifiSerial


void setup() {
    
    
  // put your setup code here, to run once:
  Serial.begin(115200);
  while (!Serial)
  {
    
    
    ;
    }
   Serial.println("ok");
   
   mySerial.begin(115200);
   mySerial.println("ready");
  

}

void loop() {
    
    
  // put your main code here, to run repeatedly:
  if(mySerial.available())
  Serial.write(mySerial.read());
  
  if(Serial.available())
  mySerial.write(Serial.read());

  


  

}

2.2 自动联网及接入设备

把AT指令写进程序让程序自动帮我们发送，并且链接到云平台，还要再实现设备和脚本的关联。

 while (!doCmdOk("AT+CWMODE=3", "OK"));            //工作模式
      
      
 while (!doCmdOk("AT+CWJAP=\"CMCC-R6Qs\",\"qmt2fx3q\"", "OK"));//WiFi账号与WiFi密码
        
while (!doCmdOk("AT+CIPSTART=\"TCP\",\"jjfaedp.hedevice.com\",876", "OK"));//链接到云平台，三个参数分别是接入协议，服务器地址和端口号
while (!doCmdOk("AT+CIPMODE=1", "OK"));           //透传模式
while (!doCmdOk("AT+CIPSEND", ">"));              //开始发送

程序讲解参考一下视频连接，代码见文末附录。
https://www.bilibili.com/video/BV1CE411h7hP?p=4

3.效果展示

安信可串口调试助手

实验过程中，一开始用的Arduino Nano 开发板，但后来可能因为开发板质量或接线的把板子烧坏了，电脑识别不了设备，于是我换了一块官网的Arduino Uno 正版开发板！

OneNet 移动终端「设备云」效果界面展示，实现温湿度显示、开关控件控制pin13 板载 LED 的亮灭。

---

参考资料

• [1] Arduino_OneNET物联网三部曲（2）远程数据监控
• [2] 【B站】Arduino ESP8266模块通过ONENET平台来实现远程控制（系列视频如下）
  

---

附代码

ESP8266_EDP.ino

/***********************************************************
File name:  ESP8266_EDP.ino
Description:  ESP8266 realizes remote control via ONENet
Author: Naiva
Date: 2020/05/17 
***********************************************************/

#include "edp.c"
#include "DHT11.h"


DHT11 dht11;
#define DHT11PIN 3 //pin3

#define KEY  "24eV33JUKr8dj=XGpckVygdFyJQ="    //APIkey 
#define ID   "598229651"                       //设备ID

//#define PUSH_ID "680788"
#define PUSH_ID NULL
 String comdata = "";
// 串口
#define _baudrate   115200

#define WIFI_UART   Serial
int DHT11 = 0;
 
const int stbPin = 7;  //the segment display module STB pin connected to digital pin 7
const int clkPin = 9;  //the segment display module CLK pin connected to digital pin 9
const int dioPin = 8;  //the segment display module DIO pin connected to digital pin 8

 uint8_t digits[] = {
    
     0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f };

     
edp_pkt *pkt;
 
/*
* doCmdOk
* 发送命令至模块，从回复中获取期待的关键字
* keyword: 所期待的关键字
* 成功找到关键字返回true，否则返回false
*/
bool doCmdOk(String data, char *keyword)
{
    
    
    bool result = false;
    
    if (data != "")   //对于tcp连接命令，直接等待第二次回复
    {
    
    
    WIFI_UART.println(data);  //发送AT指令
    
    }
    if (data == "AT")   //检查模块存在
      delay(2000);
      else
      while (!WIFI_UART.available());  // 等待模块回复
       
      delay(200);
    if (WIFI_UART.find(keyword))   //返回值判断
    {
    
    
    
         result = true;
    }
    else
    {
    
    
          result = false;
    }
    while (WIFI_UART.available()) WIFI_UART.read();   //清空串口接收缓存
    delay(500); //指令时间间隔
    return result;
}
 
 void sendCommand(uint8_t value) 
{
    
     
   digitalWrite(stbPin, LOW);                   //pin low.  To begin receiving data
   shiftOut(dioPin, clkPin, LSBFIRST, value);   //send data(value) to the segment display module
   digitalWrite(stbPin, HIGH);                  //pin high.  Stop receiving data
}  
void setup()
{
    
    
      char buf[100] = {
    
    0};
      int tmp;
       
      pinMode(13, OUTPUT);   //WIFI模块指示灯
      pinMode(8, OUTPUT);    //用于连接EDP控制的发光二极管
       
      WIFI_UART.begin( _baudrate );
       pinMode(stbPin, OUTPUT); //initialize the stbPin as an output   数码管
         pinMode(clkPin, OUTPUT); //initialize the clkPin as an output
         pinMode(dioPin, OUTPUT); //initialize the dioPin as an output
         sendCommand(0x8f);       //activate 
      WIFI_UART.setTimeout(3000);    //设置find超时时间
      delay(3000);
      Serial.setTimeout(100);
       
      delay(2000);
      while (!doCmdOk("AT", "OK"));
      digitalWrite(13, HIGH);   // 使Led亮
      while (!doCmdOk("AT+CWMODE=3", "OK"));            //工作模式
      
      
      while (!doCmdOk("AT+CWJAP=\"CMCC-R6Qs\",\"qmt2fx3q\"", "OK"));//WiFi账号与WiFi密码
        
      while (!doCmdOk("AT+CIPSTART=\"TCP\",\"jjfaedp.hedevice.com\",876", "OK"));
      while (!doCmdOk("AT+CIPMODE=1", "OK"));           //透传模式
      while (!doCmdOk("AT+CIPSEND", ">"));              //开始发送
}
     int dht_flag = 1;
void loop()
{
    
    
    static int edp_connect = 0;
    bool trigger = false;
    edp_pkt rcv_pkt;
    unsigned char pkt_type;
    int i = 0, tmp;
    char num[10];
    
    int wd,sd;
    char wd1[20],sd1[20];
    
/* EDP 连接 */
    if (!edp_connect)
    {
    
    
        while (WIFI_UART.available()) WIFI_UART.read(); //清空串口接收缓存
        packetSend(packetConnect(ID, KEY));             //发送EPD连接包
        while (!WIFI_UART.available());                 //等待EDP连接应答
    if ((tmp = WIFI_UART.readBytes(rcv_pkt.data, sizeof(rcv_pkt.data))) > 0 )
    {
    
    
        rcvDebug(rcv_pkt.data, tmp);
     
    if (rcv_pkt.data[0] == 0x20 && rcv_pkt.data[2] == 0x00 && rcv_pkt.data[3] == 0x00)
    {
    
    
        edp_connect = 1;
    
        digitalWrite(13, LOW);   // 使Led灭
    }
    else
         ;
    }
         packetClear(&rcv_pkt);
    }
    
    
   if(dht_flag == 1)
   {
    
    
      dht_flag = 0;
      dht11.read(DHT11PIN);//温湿度
      wd = dht11.temperature;
      sd = dht11.humidity;
      sprintf(wd1,"%d",wd); //int型转换char型
      sprintf(sd1,"%d",sd); //int型转换char型
      DHT11 = 0;
      delay(500);
      
      packetSend(packetDataSaveTrans(NULL, "WD", wd1)); //将新数据值上传至数据流 WD是上传的地方 wd1是上传的数据
      delay(500);
      packetSend(packetDataSaveTrans(NULL, "SD", sd1)); //将新数据值上传至数据流
      delay(500);
    }
    
  DHT11++;



 if(DHT11 > 150&&edp_connect)
 {
    
    
   
     dht11.read(DHT11PIN);
    wd = dht11.temperature;
    sd = dht11.humidity;
    sprintf(wd1,"%d",wd); //int型转换char型
    sprintf(sd1,"%d",sd); //int型转换char型
    DHT11 = 0;
    delay(500);
    packetSend(packetDataSaveTrans(NULL, "WD", wd1)); //将新数据值上传至数据流
    delay(500);
    packetSend(packetDataSaveTrans(NULL, "SD", sd1)); //将新数据值上传至数据流
    delay(500);
  }

  
while (WIFI_UART.available())
{
    
    

    readEdpPkt(&rcv_pkt);
  if (isEdpPkt(&rcv_pkt))
  {
    
    
    pkt_type = rcv_pkt.data[0];
  switch (pkt_type)
    {
    
    
      case CMDREQ:
      char edp_command[50];
      char edp_cmd_id[40];
      long id_len, cmd_len, rm_len;
      char datastr[20];
      char val[10];
      memset(edp_command, 0, sizeof(edp_command));
      memset(edp_cmd_id, 0, sizeof(edp_cmd_id));
      edpCommandReqParse(&rcv_pkt, edp_cmd_id, edp_command, &rm_len, &id_len, &cmd_len);  

//数据处理与应用中EDP命令内容对应
//本例中格式为  datastream:[1/0] 
    sscanf(edp_command, "%[^:]:%s", datastr, val);
    
    if (atoi(val) == 1)
       // 使Led亮
       digitalWrite(13, HIGH);
       //digitalWrite(8, HIGH);
    else
       digitalWrite(13, LOW);   // 使Led灭
      //digitalWrite(8, HIGH);

if(atoi(val) > 1)
{
    
    
   sendCommand(0x40);                                       //setting the Write Data Command,using automatic address genuine.
   digitalWrite(stbPin, LOW);                               //pin low.  To begin receiving data
   shiftOut(dioPin, clkPin, LSBFIRST, 0xc0);                //Set the start address 0C0H
  if(atoi(val) >= 100 && atoi(val) <=1000)
   {
    
       
      shiftOut(dioPin, clkPin, LSBFIRST, digits[0]);//thousand data
     shiftOut(dioPin, clkPin, LSBFIRST, 0x00);                //filling high 8-bit data  
     shiftOut(dioPin, clkPin, LSBFIRST, digits[atoi(val)/100%10]); //hundred data
     shiftOut(dioPin, clkPin, LSBFIRST, 0x00);                //filling high 8-bit data 
     shiftOut(dioPin, clkPin, LSBFIRST, digits[atoi(val)/10%10]);  //ten data
     shiftOut(dioPin, clkPin, LSBFIRST, 0x00);                //filling high 8-bit data
     shiftOut(dioPin, clkPin, LSBFIRST, digits[atoi(val)%10]);     //bit data
     shiftOut(dioPin, clkPin, LSBFIRST, 0x00);                //filling high 8-bit data 
   }
 
   else  if(atoi(val) >= 10 && atoi(val) <=100)
   {
    
      
      shiftOut(dioPin, clkPin, LSBFIRST, digits[0]);//thousand data
     shiftOut(dioPin, clkPin, LSBFIRST, 0x00);                //filling high 8-bit data  
     shiftOut(dioPin, clkPin, LSBFIRST, digits[0]); //hundred data
     shiftOut(dioPin, clkPin, LSBFIRST, 0x00);                //filling high 8-bit data 
     shiftOut(dioPin, clkPin, LSBFIRST, digits[atoi(val)/10%10]);  //ten data
     shiftOut(dioPin, clkPin, LSBFIRST, 0x00);                //filling high 8-bit data
     shiftOut(dioPin, clkPin, LSBFIRST, digits[atoi(val)%10]);     //bit data
     shiftOut(dioPin, clkPin, LSBFIRST, 0x00);                //filling high 8-bit data 
   }
  
  else  if(atoi(val) > 0 && atoi(val) <=10)
   {
    
    
      shiftOut(dioPin, clkPin, LSBFIRST, digits[0]);//thousand data
     shiftOut(dioPin, clkPin, LSBFIRST, 0x00);                //filling high 8-bit data  
     shiftOut(dioPin, clkPin, LSBFIRST, digits[0]); //hundred data
     shiftOut(dioPin, clkPin, LSBFIRST, 0x00);                //filling high 8-bit data 
     shiftOut(dioPin, clkPin, LSBFIRST, digits[0]);  //ten data
     shiftOut(dioPin, clkPin, LSBFIRST, 0x00);                //filling high 8-bit data
     shiftOut(dioPin, clkPin, LSBFIRST, digits[atoi(val)%10]);     //bit data
     shiftOut(dioPin, clkPin, LSBFIRST, 0x00);                //filling high 8-bit data  
   }
   digitalWrite(stbPin, HIGH);
   delay(500);  
} 
                               //pin high.  Stop receiving data
packetSend(packetDataSaveTrans(NULL, datastr, val)); //将新数据值上传至数据流
    

break;
default:
;
break;
}
}
//delay(4);
}
  if (rcv_pkt.len > 0)
  packetClear(&rcv_pkt);
  delay(150);
}
 
/*
* readEdpPkt
* 从串口缓存中读数据到接收缓存
*/
bool readEdpPkt(edp_pkt *p)
{
    
    
    int tmp;
    if ((tmp = WIFI_UART.readBytes(p->data + p->len, sizeof(p->data))) > 0 )
    {
    
    
      rcvDebug(p->data + p->len, tmp);
      p->len += tmp;
    }
    return true;
}
 
/*
* packetSend
* 将待发数据发送至串口，并释放到动态分配的内存
*/
void packetSend(edp_pkt* pkt)
{
    
    
  if (pkt != NULL)
  {
    
    
      WIFI_UART.write(pkt->data, pkt->len);    //串口发送
      WIFI_UART.flush();
      free(pkt);              //回收内存
  }
}
 
void rcvDebug(unsigned char *rcv, int len)
{
    
    
    int i;
}

EHT11.cpp

 /*
 File name:  EHT11.cpp
*/

#include "DHT11.h"

// Return values:
// DHTLIB_OK
// DHTLIB_ERROR_CHECKSUM
// DHTLIB_ERROR_TIMEOUT
int DHT11::read(int pin)
{
    
    
	// BUFFER TO RECEIVE
	uint8_t bits[5];
	uint8_t cnt = 7;
	uint8_t idx = 0;

	// EMPTY BUFFER
	for (int i=0; i< 5; i++) bits[i] = 0;

	// REQUEST SAMPLE
	pinMode(pin, OUTPUT);
	digitalWrite(pin, LOW);
	delay(18);
	digitalWrite(pin, HIGH);
	delayMicroseconds(40);
	pinMode(pin, INPUT);

	// ACKNOWLEDGE or TIMEOUT
	unsigned int loopCnt = 10000;
	while(digitalRead(pin) == LOW)
		if (loopCnt-- == 0) return DHTLIB_ERROR_TIMEOUT;

	loopCnt = 10000;
	while(digitalRead(pin) == HIGH)
		if (loopCnt-- == 0) return DHTLIB_ERROR_TIMEOUT;

	// READ OUTPUT - 40 BITS => 5 BYTES or TIMEOUT
	for (int i=0; i<40; i++)
	{
    
    
		loopCnt = 10000;
		while(digitalRead(pin) == LOW)
			if (loopCnt-- == 0) return DHTLIB_ERROR_TIMEOUT;

		unsigned long t = micros();

		loopCnt = 10000;
		while(digitalRead(pin) == HIGH)
			if (loopCnt-- == 0) return DHTLIB_ERROR_TIMEOUT;

		if ((micros() - t) > 40) bits[idx] |= (1 << cnt);
		if (cnt == 0)   // next byte?
		{
    
    
			cnt = 7;    // restart at MSB
			idx++;      // next byte!
		}
		else cnt--;
	}

	// WRITE TO RIGHT VARS
        // as bits[1] and bits[3] are allways zero they are omitted in formulas.
	humidity    = bits[0]; 
	temperature = bits[2]; 

	uint8_t sum = bits[0] + bits[2];  

	if (bits[4] != sum) return DHTLIB_ERROR_CHECKSUM;
	return DHTLIB_OK;
}

EHT11.h

 /*
 /*
 File name:  EHT11.h
*/
*/

#ifndef DHT11_H
#define DHT11_H

#if defined(ARDUINO) && (ARDUINO >= 100)
#include <Arduino.h>
#else
#include <WProgram.h>
#endif

#define DHT11LIB_VERSION "V1.0"

#define DHTLIB_OK				0
#define DHTLIB_ERROR_CHECKSUM	-1
#define DHTLIB_ERROR_TIMEOUT	-2

class DHT11
{
    
    
public:
    int read(int pin);
	int humidity;
	int temperature;
};
#endif

edp.c

 /*
 File name:  edp.c
*/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#define CONNREQ             0x10
#define CONNRESP            0x20
#define PUSHDATA            0x30
#define SAVEDATA            0x80
#define SAVEACK             0x90
#define CMDREQ              0xA0
#define CMDRESP             0xB0
#define PINGREQ             0xC0
#define PINGRESP            0xD0
#define ENCRYPTREQ          0xE0
#define ENCRYPTRESP         0xF0

#define MAX_LEN				200
#define PROTOCOL_NAME       "EDP"
#define PROTOCOL_VERSION    1

typedef unsigned char   uint8;
typedef char            int8;
typedef unsigned int    uint16;
typedef int             int16;
typedef unsigned long   uint32;
typedef long            int32;

typedef struct
{
    
    
  uint8 data[MAX_LEN];
  int16 len;
  int16 read_p;
} edp_pkt;


/*
 * packetCreate
 * 创建一个EDP包缓存空间
 */
edp_pkt *packetCreate(void)
{
    
    
  edp_pkt *p;

  if((p = (edp_pkt *)malloc(sizeof(edp_pkt))) != NULL)
    memset(p, 0, sizeof(edp_pkt));
  return p;
}

/*
 * writeRemainlen
 * 向EDP包中写入剩余长度字段
 * len_val: 剩余长度的值
 */
int8 writeRemainlen(edp_pkt* pkt, int16 len_val)
{
    
    
  int8 remaining_count = 0;
  int8 tmp = 0;

  do {
    
    
    tmp = len_val % 128;
    len_val = len_val / 128;
    /* If there are more digits to encode, set the top bit of this digit */
    if (len_val > 0) {
    
    
      tmp = tmp | 0x80;
    }
    pkt->data[pkt->len++] = tmp;
    remaining_count++;
  } while (len_val > 0 && remaining_count < 5);

  return remaining_count;
}

/*
 * writeByte
 * 向EDP包中写入一个字节
 */
int16 writeByte(edp_pkt* pkt, int8 byte)
{
    
    
  pkt->data[pkt->len++] = byte;
  return 0;
}

/*
 * writeBytes
 * 向EDP包中写入多个字节
 */
int16 writeBytes(edp_pkt* pkt, const void* bytes, int16 count)
{
    
    
  memcpy(pkt->data + pkt->len, bytes, count);
  pkt->len += count;
  return 0;
}


/*
 * writeStr
 * 向EDP包中写入字符串字段
 * 首先写入两个字节的长度，随后紧跟字符串内容
 */
int16 writeStr(edp_pkt* pkt, const int8* str)
{
    
    
  short len = strlen(str);

  writeByte(pkt, len >> 8);
  writeByte(pkt, len & 0x00ff);

  memcpy(pkt->data + pkt->len, str, len);
  pkt->len += len;
  return 0;
}


/*---------------------------------------------------------------------------*/
/*
 * readUint8
 * 从EDP包中读出一个字节
 */
uint8 readUint8(edp_pkt* pkt)
{
    
    
  return pkt->data[pkt->read_p++];
}

/*
 * readUint16
 * 从EDP包中读出16bit的字段
 */
uint16 readUint16(edp_pkt* pkt)
{
    
    
  uint16 tmp;
  uint8 msb, lsb;
  
  msb = readUint8(pkt);
  lsb = readUint8(pkt);

  tmp = (msb<<8) | lsb;
  return tmp;
}

/*
 * readUint32
 * 从EDP包中读出4个字节的字段
 */
uint32 readUint32(edp_pkt* pkt)
{
    
    
  uint32 tmp = 0;
  int i = 4;

  while (--i >= 0) 
  {
    
    
    tmp <<= 8;
    tmp |= readUint8(pkt);
  }
  return tmp;
}

/*
 * readStr
 * 根据长度，从EDP包中读出字符串数据
 * len : 字符串的长度
 */
void readStr(edp_pkt* pkt, char* str, uint16 len)
{
    
    
  memcpy(str, pkt->data + pkt->read_p, len);
  pkt->read_p += len;
}

/*
 * readRemainlen
 * 从EDP包中读出剩余长度
 */
int32 readRemainlen(edp_pkt* pkt)
{
    
    
  uint32 multiplier = 1;
  uint32 len_len = 0;
  uint8 onebyte = 0;
  int32 len_val = 0;
  do 
  {
    
    
    onebyte = readUint8(pkt);

    len_val += (onebyte & 0x7f) * multiplier;
    multiplier *= 0x80;

    len_len++;
    if (len_len > 4) 
    {
    
    
      return -1; /*len of len more than 4;*/
    }
  } while((onebyte & 0x80) != 0);
  return len_val;
}

/*
 * packetConnect：组EDP连接包
 * 首先创建EDP缓存空间，按照EDP协议组EDP连接包
 * 分配的内存需要在发送之后free掉
 * devid: 设备id
 * key：APIKey
 */
edp_pkt *packetConnect(const int8* devid, const int8* key)
{
    
    
  int32 remainlen;
  edp_pkt* pkt;
  
  if((pkt = packetCreate()) == NULL)
    return NULL;
  
  /* msg type */
  writeByte(pkt, CONNREQ);
  /* remain len */
  remainlen = (2 + 3) + 1 + 1 + 2 + (2 + strlen(devid)) + (2 + strlen(key));
  writeRemainlen(pkt, remainlen);
  /* protocol desc */
  writeStr(pkt, PROTOCOL_NAME);
  /* protocol version */
  writeByte(pkt, PROTOCOL_VERSION);
  /* connect flag */
  writeByte(pkt, 0x40);
  /* keep time */
  writeByte(pkt, 0);
  writeByte(pkt, 0x80);

  /* DEVID */
  writeStr(pkt, devid);
  /* auth key */
  writeStr(pkt, key);
  
  return pkt;
}


/*
 * packetDataSaveTrans：组EDP数据存储转发包
 * 首先创建EDP缓存空间，按照EDP协议组EDP数据存储转发包
 * 分配的内存需要在发送之后free掉
 * devid: 设备id
 * streamId：数据流ID，即数据流名
 * val: 字符串形式的数据值
 */
edp_pkt *packetDataSaveTrans(const int8* destId, const int8* streamId, const int8 *val)
{
    
    
  int32 remainlen;
  int8 tmp[200];
  int16 str_len;
  edp_pkt *pkt;
  
  if((pkt = packetCreate()) == NULL)
    return pkt;

  /* 生成数据类型格式5的数据类型 */
  sprintf(tmp, ",;%s,%s", streamId, val);
  str_len = strlen(tmp);

  /* msg type */
  writeByte(pkt, SAVEDATA);

  if (destId != NULL)
  {
    
    
    /* remain len */
    remainlen = 1 + (2 + strlen(destId)) + 1 + (2 + str_len);
    writeRemainlen(pkt, remainlen);
    /* translate address flag */
    writeByte(pkt, 0x80);
    /* dst devid */
    writeStr(pkt, destId);
  }
  else
  {
    
    
    /* remain len */
    remainlen = 1 + 1 + (2 + str_len);
    writeRemainlen(pkt, remainlen);
    /* translate address flag */
    writeByte(pkt, 0x00);
  }

  /* json flag */
  writeByte(pkt, 5);
  /* json */
  writeStr(pkt, tmp);
  
  return pkt;
}


void packetClear(edp_pkt* pkt)
{
    
    
  memset(pkt, 0, sizeof(edp_pkt));
}


/*
 * isEdpPkt
 * 按照EDP数据格式，判断是否是完整数据包
 */
int16 isEdpPkt(edp_pkt* pkt)
{
    
    
  uint32 data_len = 0;
  uint32 multiplier = 1;
  uint32 len_val = 0;
  uint32 len_len = 1;
  uint32 pkt_total_len = 0;
  uint8* pdigit;

  pdigit = pkt->data;
  data_len = pkt->len;

  if (data_len <= 1)
  {
    
    
    return 0;   /* continue receive */
  }

  do {
    
    
    if (len_len > 4)
    {
    
    
      return -1;  /* protocol error; */
    }
    if (len_len > data_len - 1)
    {
    
    
      return 0;   /* continue receive */
    }
    len_len++;
    pdigit++;
    len_val += ((*pdigit) & 0x7f) * multiplier;
    multiplier *= 0x80;
  } while (((*pdigit) & 0x80) != 0);

  pkt_total_len = len_len + len_val;

  /* receive payload */
  if (pkt_total_len == data_len)
  {
    
    
    return 1;   /* all data for this pkt is read */
  }
  else
  {
    
    
    return 0;   /* continue receive */
  }
}


/*
 * edpCommandReqParse
 * 按照EDP命令请求协议，解析数据
 */
int edpCommandReqParse(edp_pkt* pkt, char *id, char *cmd, int32 *rmlen, int32 *id_len, int32 *cmd_len)
{
    
    
  readUint8(pkt);     /* 包类型 */
  *rmlen = readRemainlen(pkt);    /* 剩余长度 */
  *id_len = readUint16(pkt);      /* ID长度 */
  readStr(pkt, id, *id_len);      /* 命令ID */
  *cmd_len = readUint32(pkt);     /* 命令长度 */
  readStr(pkt, cmd, *cmd_len);    /* 命令内容 */
}


/*
 * edpPushDataParse
 * 按照EDP透传数据格式，解析数据
 */
int edpPushDataParse(edp_pkt* pkt, char *srcId, char *data)
{
    
    
  uint32 remain_len;
  uint16 id_len;
  
  readUint8(pkt);     /* 包类型 */
  remain_len = readRemainlen(pkt);    /* 剩余长度 */
  id_len = readUint16(pkt);           /* 源ID长度 */
  readStr(pkt, srcId, id_len);    /* 源ID */
  readStr(pkt, data, remain_len - 2 - id_len);    /* 数据内容 */
}