Remote Control Communication - Control LED Lights Based on Arduino + ESP8266

Arduino is the first choice for many intelligent hardware enthusiasts. It is easy to use and fast, and the ESP8266 module is also the most popular WIFI module. This project completed the Arduino access to the OneNET server through the ESP8266 WIFI module using the EDP protocol, and remotely controls the LED lights through the application created in the access device.

[1] Hardware connection:

Prepare components:

Arduino UNO

ESP8266 WIFI module

USB to TTL cable

Hardware connection:

Arduino UNO USB to TTL

D2-----------------RX

D3-----------------TX

GND---------------GND

Arduino UNO ESP8266

RX-----------------TX

TX-----------------RX

GND---------------GND

The USB to TTL connection computer is used to debug the printout, and then the serial port of the Arduino is connected to the serial port of the ESP8266.

The physical connection is as follows:

[2] ESP8266 configuration and EDP upload data introduction:

The ESP8266 serial WIFI module is selected to control the WIFI module to access the Internet through the AT command, and the operations of accessing the Internet, establishing a TCP connection with the OneNet server, and transmitting data are sequentially completed.

1) Configure the WIFI module;

The module configuration is connected to OneNet, and the following commands are sent to the WIFI module in sequence:

AT+CWMODE=3

AT+RST

AT+CIFSR

AT+CWJAP=“your ssid”, “password”

2) Establish a TCP connection with the OneNet server and send the commands in sequence:

AT+CIPSTART=“TCP”, “183.230.40.39”, 876 // establish a TCP connection with the server

AT+CIPMODE=1 //Enter transparent transmission mode

AT+CIPSEND //Start transmission

The command execution result is shown in the following figure:

[3] Create devices and applications:

Add the product and create an access device. For details, please visit http://open.iot.10086.cn/doc/art243.html#66. The data transmission protocol selects EDP.

Add an application to the device, create a switch control, and select the switch0 data stream of the corresponding device in the properties on the right. Note that there are two properties of the switch open value and switch off value in the attribute, respectively, the default is 1,0, here is not Make changes (because 1 is open in the code, and off in the 1st) · Modify the contents of the EDP command to switch0:{v} (corresponding to the code, the code will be the part of the uploaded stream ID and the colon will be the colon The latter part is the data value as the upload.) The {v} is a wildcard. When the command is issued, it will be replaced by the on/off value of the switch. We will see the contents of the command later.

Click Save app when editing is complete.

[4] Software code:

The D13 of the Arduino development board is used as the controlled LED light, and the device ID and APIKey are added in the program.

/*

The external power supply is used for separate power supply, and the 23 ports are used as the soft serial port to connect to the PC as the debug end.

1 0 is the serial port, connected to the WIFI module

*/

#include

#include "edp.c"

#define KEY "XpAhYrqhsZbk9eVqESnMJznDb3A=" //APIkey

#define ID "4051313" //Device ID

//#define PUSH_ID "680788"

#define PUSH_ID NULL

// serial port

#define _baudrate 115200

#define _rxpin 3

#define _txpin 2

#define WIFI_UART Serial

#define DBG_UART dbgSerial //Debug the print serial port

SoftwareSerial dbgSerial( _rxpin, _txpin ); // soft serial port, debug print

Edp_pkt *pkt;

/*

* doCmdOk

* Send a command to the module to get the expected keyword from the reply

* keyword: the expected keyword

* Returns true if the keyword is successfully found, otherwise returns false

*/

Bool doCmdOk(String data, char *keyword)

{

Bool result = false;

If (data != "") / / For the tcp connection command, wait directly for the second reply

{

WIFI_UART.println(data); //Send AT command

DBG_UART.print("SEND: ");

DBG_UART.println(data);

}

If (data == "AT") / / check the module exists

Delay(2000);

Else

While (!WIFI_UART.available()); // Wait for the module to reply

Delay(200);

If (WIFI_UART.find (keyword)) / / return value judgment

{

DBG_UART.println("do cmd OK");

Result = true;

}

Else

{

DBG_UART.println("do cmd ERROR");

Result = false;

}

While (WIFI_UART.available()) WIFI_UART.read(); //Clear the serial receive buffer

Delay(500); //Command interval

Return result;

}

Void setup()

{

Char buf[100] = {0};

Int tmp;

pinMode (13, OUTPUT); / / WIFI module indicator

pinMode (8, OUTPUT); / / LED for connecting EDP control

WIFI_UART.begin( _baudrate );

DBG_UART.begin( _baudrate );

WIFI_UART.setTimeout(3000); //Set the find timeout time

Delay(3000);

DBG_UART.println("hello world!");

Delay(2000);

While (!doCmdOk("AT", "OK"));

digitalWrite(13, HIGH); // Make Led bright

While (!doCmdOk("AT+CWMODE=3", "OK")); //Work mode

While (!doCmdOk("AT+CWJAP=\"PDCN\",\"1234567890\"", "OK"));

While (!doCmdOk("AT+CIPSTART=\"TCP\",\"183.230.40.39\",876", "CONNECT"));

While (!doCmdOk("AT+CIPMODE=1", "OK")); //Transparent mode

While (!doCmdOk("AT+CIPSEND", ">")); //Start sending

}

Void loop()

{

Static int edp_connect = 0;

Bool trigger = false;

Edp_pkt rcv_pkt;

Unsigned char pkt_type;

Int i, tmp;

Char num[10];

/* EDP connection*/

If (!edp_connect)

{

While (WIFI_UART.available()) WIFI_UART.read(); //Clear the serial receive buffer

packetSend(packetConnect(ID, KEY)); //Send EPD connection package

While (!WIFI_UART.available()); //Wait for EDP connection reply

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;

DBG_UART.println("EDP connected.");

}

Else

DBG_UART.println("EDP connect error.");

}

packetClear(&rcv_pkt);

}

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

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

/ / Data processing and application EDP command content corresponding

//The format in this example is datastream:[1/0]

Sscanf(edp_command, "%[^:]:%s", datastr, val);

If (atoi(val) == 1)

digitalWrite(13, HIGH); // Make Led bright

Else

digitalWrite(13, LOW); // Let Led go out

packetSend(packetDataSaveTrans(NULL, datastr, val)); //Upload new data values ​​to the data stream

Break;

Default:

DBG_UART.print("unknown type: ");

DBG_UART.println(pkt_type, HEX);

Break;

}

}

//delay(4);

}

If (rcv_pkt.len > 0)

packetClear(&rcv_pkt);

Delay(150);

}

/*

* readEdpPkt

* Read data from the serial buffer to the receive buffer

*/

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

* Send pending data to the serial port and release it to dynamically allocated memory

*/

Void packetSend(edp_pkt* pkt)

{

If (pkt != NULL)

{

WIFI_UART.write(pkt->data, pkt->len); //Serial port send

WIFI_UART.flush();

Free(pkt); //reclaim memory

}

}

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

}

[5] Functional test:

After the device is powered on, you can see the contents of the computer serial port printout. First connect to the OneNET server:

After the connection is successful, you can see the device online status:

Click the switch button in the device app to send a switch command to the device:

After the device receives the command, it parses it and prints it out on the serial port:

When the value of the data stream switch0 is resolved to 1, the device turns on the light, and D13 of the Arduino development board is lit. When it is 0, the light is off.