arduino uno通过esp8266-01s连接onenet平台

最新推荐文章于 2024-03-20 07:00:00 发布
最新推荐文章于 2024-03-20 07:00:00 发布
阅读量5.6k 收藏 103
点赞数 4
分类专栏： esp8266
原文链接：https://www.gewbot.com/blog/1216.html
版权

转自：格物创意 https://www.gewbot.com/blog/1216.html
在这里插入图片描述
一、onenet网站的操作 https://open.iot.10086.cn/
1、开发者中心；
2、顺序：
多协议接入—>EDP协议----->添加产品---->添加设备---->添加设备------>添加数据流----->应用管理
二、设备
arduino板
esp8266-01S
温湿度传感器
8段数码管
led发光二极管
三、程序
在这里插入图片描述
主程序

#include "edp.c"
#include "DHT11.h"
DHT11 dht11;
#define DHT11PIN 3 
#define KEY  "自己填"    //APIkey 
#define ID   "自己填"                          //设备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=\"kyn\",\"20160118\"", "OK"));
while (!doCmdOk("AT+CIPSTART=\"TCP\",\"183.230.40.39\",876", "OK"));//这个是EDP的服务器和端口
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)); //将新数据值上传至数据流
    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);
else
digitalWrite(13, LOW);   // 使Led灭

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

DHT11.cpp 标签代码

 /*
  DHT11 Module library V1.0
  2017 Copyright (c) Adeept Technology Inc.  All right reserved.
  Author: TOM
*/

#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;
}

DHT11.h标签代码

 /*
  Adeept DHT11 Module library V1.0
  2017 Copyright (c) Adeept Technology Inc.  All right reserved.
  Author: TOM
*/

#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标签代码

#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);    /* 数据内容 */
}

四、简单应用（只使用温湿度传感器）
标签代码跟上文一致。
主程序代码：

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

#define DHT11PIN 3 
#define KEY  "NpRfIgD4VCTjzhGR9O6dkFzxZRA="        //APIkey 
#define ID   "587046439"                          //设备ID

// 串口
#define _baudrate   115200
#define WIFI_UART   Serial
int DHT11 = 0; //满足一定次数后，以便程序更新用
edp_pkt *pkt;//主要用于EDP连接

/*
* 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;
}

/*
* packetSend
* 将待发数据发送至串口，并释放到动态分配的内存
*/
void packetSend(edp_pkt* pkt)
{
if (pkt != NULL)
{
        WIFI_UART.write(pkt->data, pkt->len);    //串口发送
        WIFI_UART.flush();
        free(pkt);              //回收内存
}
}


void setup()
{
        int tmp;
        pinMode(13, OUTPUT);   //WIFI模块指示灯，有数据传送的时候亮起
        
        WIFI_UART.begin( _baudrate );
        while (!doCmdOk("AT", "OK"));
        digitalWrite(13, HIGH);   // 使Led亮
        while (!doCmdOk("AT+CWMODE=3", "OK"));            //工作模式
        while (!doCmdOk("AT+CWJAP=\"kyn\",\"20160118\"", "OK"));
        while (!doCmdOk("AT+CIPSTART=\"TCP\",\"183.230.40.39\",876", "OK"));
        while (!doCmdOk("AT+CIPMODE=1", "OK"));           //透传模式
        while (!doCmdOk("AT+CIPSEND", ">"));              //开始发送
}


void loop()
{
        static int edp_connect = 0;
        edp_pkt rcv_pkt;
        int tmp;
        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 && (rcv_pkt.data[0] == 0x20 && rcv_pkt.data[2] == 0x00 && rcv_pkt.data[3] == 0x00))
                {
                        edp_connect = 1;
                        digitalWrite(13, HIGH);   // 使Led亮(这个纯粹装@#￥￥……&)
                } 
                else;
                packetClear(&rcv_pkt);//应该是清空数据之类
        }
        
        
   /*
   			下面的代码，可以换成其他传感器
   */
            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);
            DHT11++;

          /*
          当数据传输150次后，更新一次
          */
         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);
          }
        }

在这里插入图片描述

代码_终结者
关注
  • 4
    点赞
  • 踩
  • 103
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Arduino通过ESP8266模块使用HTTP协议连接至ONENET
05-25
Arduino UNO R3开发板通过ESP8266WIFI模块通过HTTP协议连接至ONENET, 需要在ONENET创建HTTP协议的产品及设备 代码为Arduino代码，使用ArduinoIDE即可编译烧录，代码中需要修改的地方已经标记出来了。 此软件同样适合STM32通过ESP8266连接至onenet,原理是一模一样的。
ESP01S/ESP8266 + ONENET固件上云ONENET(图文教学)
yijujishouweihe的博客
05-03 4746
本文主要阐述如何利用ESP-01S接入Onenet物联网平台
OneNet+EDP+arduino uno+ESP8266+4路5V继电器+dht11+GY30
m0_65026757的博客
06-10 2590
OneNet+EDP+arduino uno+ESP8266+4路5V继电器+dht11+GY30 物联网学习笔记
Arduino 开发 野火ESP8266模块的串口通信
weixin_46158019的博客
03-20 584
打开串行监视器（工具 > 串行监视器），并设置相同的波特率（在此例中为115200）。Arduino ESP8266 串口通信是一个常见的任务，允许通过串行接口与其他设备或计算机进行通信。选择开发板和端口：在Arduino IDE中，选择ESP8266开发板和串口端口。4.上传代码：点击Arduino IDE的上传按钮，将代码上传到ESP8266。以下是一个简单的示例，演示了如何在ESP8266上设置串行通信，发送和接收数据。5.测试：打开串行监视器，查看发送和接收的数据。1.初始化串行通信，设置波特率。
STM32F103RC使用esp-01s MQTT协议接入OneNET平台（AT指令）
青烨慕容
07-26 2679
esp-01s 接入OneNET平台
Arduino Uno R3通过ESP-01S连接网络
zhuozhuo1998的博客
01-28 1840
Arduino Uno R3通过ESP-01S连接网络
ESP-01S连接OneNET上报温湿度信息
qq_45217381的博客
10-26 527
本文介绍了如何利用ESP-01S连接OneNET上报温湿度信息，其中包括如何烧录固件，如何配置OneNET平台，如何进行连接测试。最后，给出了一部分程序设计。
Arduino uno连esp-01s实现底层数据与blynk交互
orient321的博客
04-19 2302
课程设计记录：基于Arduino的智能生态缸设计 本文研究设计了一款智能生态缸，利用光敏传感器、水位传感器、温度传感器以及ESP8266结合嵌入式技术、物联网技术等，实现了对生态缸的光照监测、水位监测、温度监测，并通过Blynk完成了物联网远程监控系统，实现了对生态缸的实时监测。
使用esp8266与arduino通过串口通信实现数据传输
weixin_43762012的博客
10-18 1万+
通过esp8266与arduion通过串口通信实现数据传输，通过控制led的熄灭。实现物联网的基础。 使用的材料 arduion esp8266 nodemcu 面包板 led灯、电阻、杜邦线 连接的示意图
Arduino与ESP8266-01s模块通讯点灯
weixin_50493148的博客
09-20 2997
前言 本文章为方便新手上手直接用最简单的点灯展示，关于ESP8266-01s的AT指令类就上网搜有很多这就不多讲了。 接线 ESP-01S Arduino VCC 3.3V GND GND EN 3.3V TX RX RX TX ...
Arduino与ESP8266进行串口通信
热门推荐
凌顺实验室
04-26 2万+
欢迎关注「凌顺实验室」微信公众号 本文转载于http://blog.csdn.net/q394622124/article/details/70800971 感谢这位网友silver__zy的无私分享，在我那可有可无的指导下给做出来了，经博主同意就转过来了，再次感谢！！ 在与arduino连线之前我们先通过usb转TTL(本文采用的CH...
arduino通过ESP8266透传onenet平台代码.rar
03-09
arduino通过ESP8266透传onenet平台代码，如何通过函数实现透传，如何实现上传报文，如何上传温湿度数据。
Arduino通过ESP8266模块使用HTTP协议连接至ONENET.zip
05-06
代码为Arduino代码，使用ArduinoIDE即可编译烧录，代码中需要修改的地方已经标记出来了。
Arduino uno+esp8266+onenet+dht11温湿度传感器+MQ-2烟雾传感器
11-25
Arduino uno+esp8266+onenet+dht11温湿度传感器+MQ-2烟雾传感器，onenet云平台查看传感器通过WiFi上传的数据。
ESP8266开发板连接onenet—HTTP
01-06
大家好，我是往事匆匆，第一次发博客 如果有不好的地方请批评指正 共同学习，今天给大家分享一点关于esp8266连接onenet的程序代码。用的是Arduino 软件编写的程序，程序实现的功能是上传温度和湿度。 元件和工具： ...
实验-三、数据库安全性(目的、要求和模板).doc
04-24
实验-三、数据库安全性(目的、要求和模板).doc
基于Docker搭建K8s集群离线包
04-24
基于Docker搭建K8s集群离线包，包含部署时所需的全部文件，可在内网环境中使用，K8s为1.23.0版本，docker为20.10.9-3版本
基于springboot+vue实现的求职招聘类型网站源代码+数据库（优质毕设项目）.zip
最新发布
04-24
基于springboot+vue实现的求职招聘类型网站源代码+数据库（优质毕设项目）.zip个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！ 基于springboot+vue实现的求职招聘类型网站源代码+数据库（优质毕设项目）.zip个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！ 基于springboot+vue实现的求职招聘类型网站源代码+数据库（优质毕设项目）.zip个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！基于springboot+vue实现的求
基于Android系统Api封装常用工具类.zip
04-24
基于Android系统Api封装常用工具类.zip
arduino uno通过esp8266-nodemcu能向onenet上传数据吗
01-18
是的，Arduino Uno通过ESP8266 NodeMCU可以实现向OneNet上传数据。 首先，需要将ESP8266 NodeMCU连接到Arduino Uno。将NodeMCU的VCC连接到Uno的3.3V引脚，GND连接到GND引脚，TX引脚连接到Uno的RX引脚，RX引脚连接到Uno的TX引脚。 然后，下载并安装Arduino IDE。在Arduino IDE中，添加ESP8266开发板的库，选择正确的开发板和端口。 接着，在OneNet上创建一个设备和数据流。得到设备ID和API Key，并将其保存以备后用。 在Arduino IDE中，编写程序来连接WiFi网络和OneNet云平台。使用ESP8266库的WiFiClientSecure类连接到WiFi网络，并使用HttpClient库的POST方法将数据发送到OneNet云平台。 在发送数据之前，需要格式化数据。可以将数据保存到一个JSON对象中，然后使用ArduinoJSON库的toJson方法将其转换为JSON字符串。 最后，将数据发送到OneNet云平台。使用HTTPClient库的begin方法指定OneNet的URL，并设置请求标头和正文。然后，使用POST方法发送数据。 通过以上步骤，可以成功地实现Arduino Uno通过ESP8266 NodeMCU向OneNet上传数据。只需编写适当的代码，并进行相应的配置和连接，就能使设备和云平台之间实现数据的传输。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值