Uso ESP8266 con Arduino (Puerto Serie)

El ESP8266 se puede usar con un microcontrolador como Arduino conectado por puerto serie y manejarlo con comandos hayes o programarlo como si de un microcontrolador se tratara con el IDE de Arduino usando el SDK https://github.com/esp8266/Arduino y usar el lenguaje de programación de Arduino (el core de Arduino).

En este capítulo vamos a ver como usarlo con el SDK NONOS donde manejamos el ESP8266 mediante comandos AT.

Web de recursos del ESP8266: http://espressif.com/en/products/hardware/esp8266ex/resources

Los SDK oficiales de expressif son:

El SDK RTOS está basado en FreeRTOS:

Guía de programación de ESP8266 RTOS SDK: http://espressif.com/sites/default/files/documentation/20a-esp8266_rtos_sdk_programming_guide_en.pdf

RTOS es un sistema operativo de tiempo real es un sistema operativo que ha sido desarrollado para aplicaciones de tiempo real. Como tal, se le exige corrección en sus respuestas bajo ciertas restricciones de tiempo. Si no las respeta, se dirá que el sistema ha fallado. Para garantizar el comportamiento correcto en el tiempo requerido se necesita que el sistema sea predecible.

Más información: https://es.wikipedia.org/wiki/Sistema_operativo_de_tiempo_real

SDK NONOS ESP8266

Las versiones del SDK NONOS para ESP8266 es la que usa comandos AT para manejarlos. Las verisiones pueden descargarse desde https://github.com/espressif/ESP8266_NONOS_SDK/releases

El firmware puede descargarse de: https://github.com/espressif/ESP8266_NONOS_SDK/tree/master/bin

Github de expressif: https://github.com/espressif

Pinout ESP8266:

Pines:

TX (goes to the 3.3V Rx of the UART USB adapter to the PC)
CH_PD (enable/power down, must be pulled to 3.3v directly or via resistor)
RESET
VCC (3.3v power supply)
GND (connect to power ground)
GPIO 2
GPIO 0 (leave open or pull up for normal, pull down to upload new firmware)
RX (goes to the 3.3V Tx of the UART USB adapter to the PC)

Para usar el ESP8266 con Arduino vamos a conectarnos por el puerto serie y mandar comandos AT (hayes) para manejarlo. Este es el esquema.

IMPORTANTE:

El ESP8266 va alimentado a 3,3V, ¡no alimentarlo con 5 voltios!
El ESP8266 necesita comunicarse vía serie a 3.3V y no tiene entradas tolerantes 5V, por lo que necesita la conversión de nivel para comunicarse con un microcontrolador 5V como la mayoría de los Arduinos

Sin embargo, esta segunda advertencia puede ser ignorada y conectar el puerto serie directamente a Arduino, pero existe el peligro de dañar el módulo.

Con un programador FTDI que tenga salida a 3.3V podemos hacer lo mismo que con un Arduino pero sin ningún peligro.

ESP8266 quick start guide: http://rancidbacon.com/files/kiwicon8/ESP8266_WiFi_Module_Quick_Start_Guide_v_1.0.4.pdf

Guia sparkfun del ESP8266: https://learn.sparkfun.com/tutorials/esp8266-thing-hookup-guide

Level Shifter

Los pines Rx y Tx del ESP8266 no son tolerantes a 5V, por lo tanto para trabajar seguro es conveniente usar un bi-directional level shifter: http://www.adafruit.com/datasheets/txb0108.pdf

Este tipos de dispositivos es necesario para comunicar Arduino con otras MCUs que van a 3.3V, con el ESP8266 y con Raspberry Pi entre otros.

Ejemplo de level shifter para usar con Arduino:

Por lo tanto la primera forma de usar el módulo ESP8266 es comunicarse con él a través del puerto serie y manejarlo mediante los comandos AT (hayes) que tiene en su firmware.

Comandos Hayes

El conjunto de comandos Hayes es un lenguaje desarrollado por la compañía Hayes Communications que prácticamente se convirtió en estándar abierto de comandos para configurar y parametrizar módems. Los caracteres «AT», que preceden a todos los comandos, significan «Atención», e hicieron que se conociera también a este conjunto de comandos como comandos AT. Midiendo la longitud de los bits se puede determinar en detalle la velocidad de transmisión.

Cheatsheet ESP8266: https://cdn.sparkfun.com/datasheets/Wireless/WiFi/ESP8266ModuleV1.pdf

Comandos hayes:

Comandos Hayes para ESP8266:

Command set oficial http://www.espressif.com/sites/default/files/4a-esp8266_at_instruction_set_en_v1.5.4_0.pdf
Command set for ESP8266 (cheatsheet): http://www.pridopia.co.uk/pi-doc/ESP8266ATCommandsSet.pdf
ESP8266 command reference https://room-15.github.io/blog/2015/03/26/esp8266-at-command-reference/
Básico https://github.com/esp8266/at-command-set

Proyectos con ESP8266:

Estación meteorologica con esp8266 + arduino + thingspeak https://create.arduino.cc/projecthub/Blue_jack/personal-weather-station-arduino-esp8266-thingspeak-8d5cba

Más información:

Videos:

Ejemplo de uso de comandos AT: http://www.seeed.cc/project_detail.html?id=1809

Firmware ESP8266

Como hemos hablado el módulo ESP8266 es un microcontrolador como los que hemos visto con Arduino y podemos cargarle un firmware con un programa que hayamos hecho y compilado con el IDE de Arduino o usar un firmware como el que viene por defecto que es el de comandos hayes.

Además de los firmwares anteriores tenemos otros firmware disponibles como el oficial basado en un RTOS.

Firmware nodeMCU (basado en LUA): https://github.com/nodemcu/nodemcu-firmware
Firmware para usar micropython: https://github.com/micropython/micropython/

Para descargar las herramientas y últimas versiones del firmware usar la web: https://espressif.com/en/products/hardware/esp8266ex/resources

Más información de como actualizar firmware (version actualizada en la parte de ejercicios):

Firmware Update

Para actualizar el firmware necesitamos descargar la herramienta “flash download tools” para el ESP8266 y el firmware con los comandos hayes, además aprovechamos para actualizar a la última versión del firmware.

Para programar recordar y actualizar firmware recordar que el pin GPIO0 debe estar a masa y que hay que un reset del módulo para comenzar la carga del nuevo firmware.

Descarga: https://espressif.com/en/products/hardware/esp8266ex/resources

Descargar la última versión de:

Tools / Flash Download Tools (ESP8266 & ESP32)
SDK & demos / ESP8266 NONOS SDK

Descargar la herramienta para cargar el firmware: Flash Download Tools (ESP8266 & ESP32) – V3.4.9.2 – 2017.07.17

El firmware para AT es: ESP8266 NONOS SDK V2.1.0 20170505 – V2.1.0 – 2017.05.05

Enlace al firmware: https://github.com/espressif/ESP8266_NONOS_SDK/tree/master/bin

Ficheros: https://github.com/espressif/ESP8266_NONOS_SDK/tree/v2.1.0/bin

Abrir la aplicación Flash download tool y elegir ESP8266. Luego configurar de la siguiente forma:

Configurando los ficheros para BOOT MODE Flash size 8Mbit: 512KB+512KB:

boot_v1.2.bin 0x00000
user1.1024.new.2.bin 0x01000
esp_init_data_default.bin 0xfc000 (optional)
blank.bin 0x7e000
blank.bin 0xfe000

Que se encuentran en el directorio bin del fichero de SDK que nos hemos descargado.

Para comprobar la frecuencia de cristal del módulo y la flash, simplemente dando a start sin seleccionar los ficheros y reseteando el módulo obtendremos la información.

Para cargar el firmware necesitamos un adaptador de USB a serial a 3.3V. Para ello tenemos dos opciones: usar un adaptador o usar un Arduino donde tenga cargado cualquier programa que no haga uso del puerto serie, por ejemplo el blink.

Esquema de conexión con adaptador:

Esquema de conexión con Arduino:

Más información sobre el Firmware update (como referencia no están actualizados):

IMPORTANTE: no descargar nada de fuentes no fiables

Práctica: ESP8266 programado por puerto serie

Conexión con programador FTDI:

Conexión con Arduino:

Conectar un terminal serie a 115200-8-N y mandar el comando AT, si nos responde OK es que ya estamos conectados con el módulo.

Manual oficial de comandos: http://www.espressif.com/sites/default/files/4a-esp8266_at_instruction_set_en_v1.5.4_0.pdf

Ejecutar los siguientes comandos y ver lo que devuelve:

AT+RST: reinicia el módulo
AT+GMR: versión de firmware
AT+CWMODE=3: activa modo AP, comprobar redes wifi
AT+CWLAP: para ver las redes wifi
AT+CWJAP=»SSID»,»password»: Conectarse a una red wifi (AT+CWJAP=»AndroidAP4628″,»esp8266wifi»)
AT+CIFSR: comprobar la IP asignada

Actuar como un cliente TCP:

AT+CIPMUX=1: Habilitar múltiples conexiones
AT+CIPSTART=4,»TCP»,»google.com»,80: Especifica el canal de conexión que desea conectar (0 – 4), el tipo de protocolo (TCP / UDP), la dirección IP (o el dominio si tiene acceso a DNS) y el número de puerto
A continuación, debe especificar la cantidad de datos que desea enviar (después de especificar qué canal). Vamos a enviar «GET / HTTP / 1.0 \ r \ n \ r \ n» que es 18 bytes: AT+CIPSEND=4,18
Y recibiremos la respuesta del servidor:

 
+IPD,4,559:HTTP/1.0 301 Moved Permanently
Location: http://www.google.com/
Content-Type: text/html; charset=UTF-8
Date: Sat, 12 Nov 2016 16:37:23 GMT
Expires: Mon, 12 Dec 2016 16:37:23 GMT
Cache-Control: public, max-age=2592000
Server: gws
Content-Length: 219
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN
Connection: close

&lt;HTML&gt;&lt;HEAD&gt;&lt;meta http-equiv="content-type" content="text/html;charset=utf-8"&gt;
&lt;TITLE&gt;301 Moved&lt;/TITLE&gt;&lt;/HEAD&gt;&lt;BODY&gt;


&lt;H1&gt;301 Moved&lt;/H1&gt;


The document has moved
&lt;A HREF="http://www.google.com/"&gt;here&lt;/A&gt;.
&lt;/BODY&gt;&lt;/HTML&gt;
4,CLOSED

Actuar como servidor:

Comprobar que IP tenemos con AT+CIFSR
AT+CIPSERVER=1,1336: para poner a escuchar en un puerto, en este caso el 1336
Desde otro dispositivo en la red: telnet 192.168.1.2 1336
En el puerto serie veré todo lo que se escriba por telnet
Para responder desde el ESP8266 debo usar AT+CIPSEND=0,8 seguido del texto. En este caso es el canal 0 y mando 8 caracteres.

Hacer lo mismo pero usando Arduino, para ello conectarlo según el esquema superior y cargar el programa:

 
#include &lt;SoftwareSerial.h&gt;
SoftwareSerial BT1(3, 2); // RX | TX

void setup()
{ Serial.begin(9600);
  BT1.begin(115200);
}

void loop()
{ 
  if (BT1.available())
  { char c = BT1.read();
    Serial.print(c);
  }
  if (Serial.available())
  { char c = Serial.read();
    BT1.print(c);
  }
}

Configurar el baud rate de ESP8266 a 9600 para que funcione mejor con el comando “AT+UART_DEF=9600,8,1,0,0”, puesto que a 115200 da problemas con el puerto serie software.

Para hacer una reseteo de la configuración de fábrica usar el comando: “AT+RESTORE”

Hacer un programa con Arduino que se conecte automáticamente a una red y nos muestra la IP asignada:

AT+CWMODE_DEF=1
AT+CWJAP=»SSID»,»paswword»
AT+CIFSR: comprobar la IP asignada

NOTA: si no se quiere usar el software serial por las limitaciones de velocidad, se puede hacer la misma conexión entre Arduino y el ESP8266 que hemos usado para programar el firmware, de forma que los conectamos por el puerto serie hardware. En este caso los comandos que mando desde el monitor serie van directos al ESP8266 en lugar de pasar por el microcontrolador de Arduino.

Solución Ejercicio 61: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio61-ESP8266

Más información:

Aprendiendo Arduino

Aprendiendo a manejar Arduino en profundidad