Arduino 制作基于OneNET平台的继电器控制（EDP协议）（二）

所需硬件

• Arduino UNO
• ESP8266-01S
• 继电器模块

准备工作

首先在制作前，我们先通过Arduino IDE 烧录一下ESP8266的程序，具体烧录步骤在 https://blog.csdn.net/m0_37738838/article/details/83999561 中可以查看，有部分地方需要修改的
IP地址和端口号修改成OneNET EDP协议的IP地址和端口

IP: jjfaedp.hedevice.com
PORT: 876

烧录完成后，看一下我们在程序中设置连接的WIFI是否连上，如果已连接上就没问题。

接线

ESP8266	Arduino UNO
TX	RX
RX	TX
VCC	3.3V
GND	GND
CH_PD	3.3V

继电器	Arduino UNO
信号脚	D9
VCC	5V
GND	GND

程序

edp.c程序下载链接： https://download.csdn.net/download/m0_37738838/10912961

演示效果

https://v.youku.com/v_show/id_XNDA3MjU4MDI3Mg==.html?spm=a2h3j.8428770.3416059.1

流程说明

#include <Wire.h>
#include<Arduino.h>
#include<math.h>
#include<SoftwareSerial.h>
#include"edp.c"
#include <Metro.h> 

#define JDQ 7 //设置继电器模块输出引脚为9号引脚

#define KEY  "2lSvvpOO4UBjuMwdQSN7jVVe36A="    //APIkey
#define ID   "513758691"                          //设备ID  fish_pond
#define PUSH_ID NULL
#define tem  "TEM"

//串口
#define _baudrate 115200 //波特率
#define _rxpin 2 
#define _txpin 3
#define WIFI_UART dbgSerial //数据传送串口
#define DBG_UART Serial //调试打印串口
static int time_=3000;
Metro Write_metro = Metro(time_); 
SoftwareSerial dbgSerial( _rxpin, _txpin ); // 软串口，调试打印
edp_pkt *pkt;
static int edp_connect = 0; //连接标识
bool read_package = true; //连接标识
void setup()
{
  char buf[100] = {0};
  int tmp;
  
  Serial.begin(9600);//设置通讯波特率为9600
  pinMode(JDQ,OUTPUT); //继电器
  
  WIFI_UART.begin( _baudrate );
  DBG_UART.begin( 9600 );
  WIFI_UART.setTimeout(3000);    //设置find超时时间
  delay(3000);
  DBG_UART.println("Hello World!");
  delay(2000);
}

void loop()
{
  bool trigger = false;
  edp_pkt rcv_pkt;
  unsigned char pkt_type;
  int i, tmp;
   /*EDP连接*/
  if (!edp_connect) {
    while (WIFI_UART.available()) WIFI_UART.read(); //清空串口接收缓存
    packetSend(packetConnect(ID, KEY)); //发送EDP连接包
    while (!WIFI_UART.available()); //等待EDP连接应答
    /*
    WIFI_UART.readBytes(buffer, length)从串口读字符到一个缓冲区       
    buffer：用来存储字节（char[]或byte[]）的缓冲区
    length：读取的字节数（int）
    */
    if ((tmp = WIFI_UART.readBytes(rcv_pkt.data, sizeof(rcv_pkt.data))) > 0) {  
      rcvDebug(rcv_pkt.data, tmp);//打印onenet下发的数据包
      if (rcv_pkt.data[0] == 0x20 && rcv_pkt.data[2] == 0x00 && rcv_pkt.data[3] == 0x00) {//onenet判断下发的数据包是为0x20 0x02 0x00 0x00 
        edp_connect = 1;
        DBG_UART.println("EDP connected.");//连接成功
      }
      else
        DBG_UART.println("EDP again connected."); //重新连接   
    }
    packetClear(&rcv_pkt);//数据包清理 初始化内存
 }
  
  read_package=true;

//解析平台下发数据，这里只关心edp控制命令
  while (WIFI_UART.available())
  {
   
    readEdpPkt(&rcv_pkt);
    if (isEdpPkt(&rcv_pkt))//判断是否为完整edp包
    {
      if(rcv_pkt.data[0] == 0x40){//断开连接后，edp_connect归零，重新连接
        edp_connect = 0;
        DBG_UART.println("waahaha");
      }
      read_package=false;
      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;
          memset(edp_command, 0, sizeof(edp_command));//EDP命令接收缓存数组
          memset(edp_cmd_id, 0, sizeof(edp_cmd_id));//EDP命令ID接收缓存数组
          edpCommandReqParse(&rcv_pkt,edp_cmd_id,edp_command,&rm_len,&id_len,&cmd_len);//解析edp命令
          DBG_UART.print("rm_len: ");
          DBG_UART.println(rm_len, DEC);
          delay(10);
          DBG_UART.print("id_len: ");
          DBG_UART.println(id_len, DEC);
          delay(10);
          DBG_UART.print("cmd_len: ");
          DBG_UART.println(cmd_len, DEC);
          delay(10);
          DBG_UART.print("id: ");
          DBG_UART.println(edp_cmd_id);
          delay(10);
          DBG_UART.print("cmd: ");
          DBG_UART.println(edp_command);
          delay(50);       
          if (atoi(edp_command) == 1)   //LED开关
          {
            digitalWrite(JDQ, LOW);
          }
          if (atoi(edp_command) == 0){
            digitalWrite(JDQ, HIGH);  
          }
           
          break;
        default:
          DBG_UART.print("unknown type: ");
          DBG_UART.println(pkt_type, HEX);
          break;
      }
    }
  }
 /*
  if(edp_connect==1){//判断是否连接
    if(Write_metro.check()&&read_package)
    packetSend(packetDataSaveTrans(ID, tem,"25")); //将温度的数据打包发送至onenet平台
 }*/
 
  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;
  DBG_UART.print("rcv len: ");
  DBG_UART.println(len, DEC);
  for (i = 0; i < len; i++)
  {
    DBG_UART.print(rcv[i], HEX);
    DBG_UART.print(" ");
  }
  DBG_UART.println("");
}