Programmare ESP8266-01 con Arduino Uno

Con il passaggio a Windows 10 l'adattatore USB to TTL (1x PL2302HX USB to TTL converter) che usavo per programmare lo ESP8266-01 non funziona più'.

Questo perché'  il chip usato nell'adattatore e' "falso" e non riconosciuto dal driver di windows.

A questo punto avevo due cose da fare: o comprare un nuovo adattatore o ingegnarmi.

Allora ho pensato: "ma in fondo ho una scheda Arduino a casa che sicuramente potrà' aiutarmi"

In effetti dopo un po' di prove ecco come ho rimpiazzato l'adattatore USB - TTL con una scheda Arduino Uno (simile per altre schede Arduino)

Arduino come adattatore Seriale

L'idea e' di utilizzare l'adattatore USB - Serial già' a bordo di Arduino Uno per poter programmare lo ESP8266-01 tramite l'IDE Arduino.

Per fare cio' e' necessario bypassare il bootloader dell'Atmega e far si che su Arduino non giri nessun programma.

Cio' si fa' semplicemente collegando il pin RST (Reset) a  GND. 

Sotto lo schema su breadboard dei collegamenti necessari per poter programmare correttamente lo ESP8266-01 con Arduino.

Nota:

lo ESP8266-01 e' perfettamente tollerante a segnali seriali da 5V

Il lettore che per qualche ragione pensasse che ciò' non e' sicuro e' invitato a non realizzare il circuito.

In ogni caso la responsabilità' del buon funzionamento di Arduino e dello ESP8266 e' demandata al lettore.

Qui sotto il relativo schema elettrico

e la realizzazione su breadboard

Uso dei pulsanti

Come e' possibile notare dallo schema elettrico sono presenti due pulsanti collegati nel seguente modo:

• SW Reset: sul pin RST di ESP8266
• SW Flash: sul pin GPIO0 di ESP8266

Questo e' necessario in quanto per poter programmare correttamente lo ESP8266-01 e' necessario portarlo nello stato UART Download Mode (piu' informazioni qui)

Questo si ottiene con la seguente procedura:

1. si mantiene premuto il pulsante SW Flash
2. si preme e si rilascia il pulsante SW Reset
3. si rilascia il pulsante SW Flash

Suggerisco di effettuare tale procedura solo alcuni secondi prima dell'inizio del caricamento dello sketch dal PC allo ESP8266-01

ESP8266-01 Dev Board

Siccome i pin dello ESP8266-01 non sono compatibili con una breadboard io utilizzo una dev board realizzata da me.

Potete trovare tutti i dettagli qui se volete divertirvi a costruirla.

Test

Qui un semplice Sketch di test per verificare che in effetti si riesce a caricare uno sketch su EPS8266-01

Qui sotto il dettaglio di cosa dovreste ottenere nel vostro ambiente se il caricamene avviene con successo.

ESP8266–01 Home Made Dev Board v1

In this post I describe the way I have designed and built a simple and useful development board for ESP8266–01

The main goal of this board is to make the use of ESP8266–01 simple during development phase on breadboard.

Schema

The schema is quite simple.

A detailed explanation on how to correctly connect EPS8266–01 pins is available here [http://www.instructables.com/id/How-to-use-the-ESP8266-01-pins/?ALLSTEPS]

The pinheader J1 and J2, in the above electrical schema, are the 8 pin of the ESP8266–01 module (as seen from above view)

The 5 pin on the left, in the above electrical schema, are the pin of the dev board. More in detail:

• VCC: 3V3 (+) from a couple of AA batteries or any other power source (in the schema is writte 5V as I was not able to change it in Fritzing)
• GND: the negative (-) wire from the two AA batteries or from any DC 3V3 power source
• USB GND: the ground from the USB2TTL module
• USB RX/TX: RX/TX from the USB2TTL module

The two pin top-right are the GPIO0 and PIO2 available on the ESP8266–10 module

The pin header J3 and J4 are not electrically connected and wired and are only used to mount the dev board on the breadboard

Two micro-buttons are available to reset the ESP8266–01 module (SW RST) and to switch into flashing/programming mode (SW GPIO0)

PCB

The PCB has been made using Fritzing software and is a single side PCB for an easy development at home

Making the PCB

I have use a home made development process to build the PCB which is called “toner transfer”. In short I have printed the circuit on glossy photo paper with a laser printer and later transferred the PCB tracks on the copper clad with a normal iron (borrowed from my wife :) )

The result is not 100% perfect (doing that at home with basic tools) as half track and few pad have not been transferred correctly

No worries, we are maker so we always find a solution. I have manually corrected the missing toner with a permanent maker (the pad which are missing are the one which are not electrically connected so no big issue)

Below the final result after the copper etching

Now I remove the toner with some simple acetone (borrowed from my wife)

now I drill the board with a 1mm drill bit

Assembling the Board

Now it is time to assemble the board with just few components

Here the list of components:

I start by soldering the resistors, the pin header and then the push buttons

Below the final result

and also with ESP8266–01 module

and everything mounted on breadboard

File

The full fritzing project with electrical schema and PCB layout is available here qui

Suggestion

The two pin header rows on the side of the dev board, are slightly larger than the breadboard. In order to overcame this small issue I have removed the 6th pin from the row.

In version 2 of this board I will fix this bug but until then I can use the dev board with the small trick explained above.

This allows me to work on my project base don ESP8266–01 in a clean and easy way avoiding flying wires.

MQTT 101 for ESP8266

Introduction

Recently many people asked my help in the implementation of ESP8266 sketches to let two or more modules communicate over the MQTT protocol.

This article provides and describes a basic MQTT source code working skeleton to interconnect ESP8266 modules over MQTT protocol.

The goal of this code is to provide a start point to beginner developers to develop their application by extending it.

MQTT

The main site for MQTT (Message Queuing Telemetry Transport) is [http://mqtt.org/].

MQTT is define in this way: “MQTT is a machine-to-machine (M2M)/”Internet of Things” connectivity protocol. It was designed as an extremely lightweight publish/subscribe messaging transport.”

The basic and key actors in a Publish/Subscribe architecture are:

• A communication Broker : a central communication component which orchestrates all the communication processes and that manages the entire life-cycle of topics and messages
• An agent which take the role of Publisher: sending messages to a specific topic living within a given MQTT
• An agent which take the role of Subscriber: receiving messages from a specific topic on a broker
• A Topic: a dedicated communication channels between devices

In this architecture a Publisher communicates with one or more Subscriber without knowing its/their identity (any type of addressing)

In other words when a Publisher wants to communicate, it just sends a message to a broker for a specific topic.

After the message has been delivered to the broker, it’s broker responsibility to propagate the message to all the Subscriber which are “listening” of a given topic (Publisher and Subscriber must publish and listen on the same topic).

Such architecture is present in many different IT domains and it is not limited to MQTT only.

As an example (over simplified), the Pub/Sub architecture is used by most of the GUI systems (Windows, Linux, …). For instance when I click on a button in a window, the windows manager send a message (Publisher). The handler of the button is listening (Subscriber) and when receiving a message from the manager it execute a specific piece of code (i.e. close the window)

ESP and MQTT

The MQTT protocol and its Pub/Sub architecture perfectly fits in the communication between ESP8266 devices and between ESP8266 and the external world (cloud). This provides a very easy, lightweight and fast communication mechanism to be used in ESP8266 projects.

A huge advantage, from a networking and security point of view, is that a given ESP can communicates with external devices with no necessity to open a TCP port in the router/firewall (if you implement a more traditional web model yo must open a port in your firewall to accept incoming web requests).

The MQTT protocol is supported by virtually any platform out there and for sure by Android, iOS, Javascript. This allow for an easy communication between a mobile/web application and an ESP module.

CLOUDMQTT

The MQTT broker I typically use for my projects and in this sketch is provided by https://www.cloudmqtt.com/

The cloud service is available in different pricing tiers, included my preferred one: the free of charge :)

Once you have sign-up to the service you can access the cloud console

Here you can find all the detailed information about your MQTT broker that you can use to configure the ESP sketch

MQTT Basic

The sample code allows one or more ESP to communicate over MQTT protocol and is available here github.

Below some important #define which should be configured before compiling and uploading the sketch to ESP8266

• WIFI_SSID: the SSID of your WiFi network
• WIFI_PASSWD: WiFi password
• MQTT_CLIENT_ID: just a unique (random) ID for your MQTT client
• MQTT_SERVER: the FQDN of the MQTT broker
• MQTT_UNAME: authentication user name at the broker
• MQTT_PASSWD: authentication password at the broker
• MQTT_BROKER_PORT: listening broker port
• MQTT_TOPIC: the MQTT topic on which exchange messages
• ESP_NAME: a name for your ESP module
• ESP_PUB_ROLE: ESP is behaving as a Publisher
• ESP_SUB_ROLE: ESP is behaving as a Subscriber

ESP Libraries

This code uses the following libraries

MQTT.h and PubSubClient.h — v 1.99.0 — https://github.com/Imroy/pubsubclient

MQTT Basic Testing

The demonstration code can be tested either with 2x ESP communication between each other or 1x ESP and 1x MQTT client (for instance I will show how to use a mosquitto client on Linux, but any other MQTT client will be ok)

ESP as Publisher

On the ESP sketch un-comment #define ESP_PUB_ROLE, then compile and upload the generated binary to ESP

Once the program starts you can see in the serial monitor something similar to the below

On a Linux shell you need to subscribe to this topic: esp8266/sensori

you can use the following command:

mosquitto_sub -h <host name> -p <port> -u <user name> -p <password> -i <client id univoco> t- esp8266/sensori

where the parameters between <> are the one visible in your CloudMQTT cloud console

As you can see from the screenshot, my client running on Linux somewhere in the Internet receives commands (the string “Hello I m ESP-my_ESP_8266”) from my ESP8266 running on my desk in my office. Pretty cool ah!!

ESP as Subscriber

On the ESP sketch un-comment #define ESP_SUB_ROLE, then compile and upload the generated binary to ESP

Once the program starts you can see in the serial monitor something similar to the below

On the Linux client now I send commands to my ESP through the following command:

mosquitto_pub -h <host name> -p <port> -u <user name> -p <password> -i <client id univoco> t- esp8266/sensori -m “hi this is another ESP8266”

where the parameters between <> are the one visible in your CloudMQTT cloud console

As you can see from the screenshot, my ESP8266 running on my desk receives commands from my Linux client.

Conclusion

The MQTT protocol and the Pub/Sub architecture are used in different environments and especially in the IoT market. They provide and lightweight and flexible communication mechanism that we can leverage to give our Arduino/ESP projects connectivity to the cloud or local network.

Let me know if you find this short introduction to MQTT on ESP useful and if use it in your projects send me a picture :)