Archivo de la etiqueta: SDK ESP8266

Programación ESP8266 con IDE Arduino

Hemos visto como realizar las conexiones y vimos los comandos AT que nos permiten configurar las acciones del WIFI. El ESP8266 dispone internamente de un pequeño procesador, prácticamente es capaz de replicar casi cualquier cosa los Arduinos puedan hacer. Así que los proyectos con sensores más Arduinos que envían los datos a la WIFI mediante un ESP8266, es muy probable que podamos ahorrarnos el Arduino en el proceso.

Gracias a un firmware basado en C ++, permite que la CPU ESP8266 y sus componentes Wi-Fi sean programados como cualquier otro dispositivo Arduino.

  • Puedes desarrollar con el mismo IDE que ya conoces
  • Han hecho un Cross compiler, de forma que prácticamente utilizas los mismos comandos que utilizas con Arduino, con lo que te ahorras aprender nada nuevo
  • Dependiendo del modelo de ESP8266 que tengas, dispones de más o menos pines disponibles con PWM y otras cosas más como I2C y SPI, pero para el modelo ESP8266-01 solo tienes dos pines disponibles GPIO0 y GPIO2
  • Puedes programar el procesador de tu ESP8266 exactamente como si fuera un Arduino con los mismos comandos, y en lo que se refiere a la WIFI, puedes olvidarte de los comandos AT, porque incluye una serie de librerías, que imitan la librería WIFI de Arduino con lo que se pueden reutilizar muchos programas.  

Todo este soporte del ESP8266 para Arduino gracias a Ivan Grokhotkov: https://github.com/igrr y más de 140 personas que colaboran.

El Arduino Core ESP8266 está disponible a través de GitHub: https://github.com/esp8266/Arduino

Wiki de la comunidad esp8266:https://github.com/esp8266/esp8266-wiki/wiki

Este SDK para Arduino incluye el compilador GCC para el microcontrolador LX106 usado en este módulo Incluido en el SDK están las fuentes para SSL, JSON y lwIP, haciéndolo una solución perfecta para Internet de las Cosas.

Este SDK incluye códigos de ejemplo para usar con los pines libres como buses GPIOs, I2C y SPI y como UART

lwIP:

El SDK de ESP8266 para Arduino salio de la comunidad en http://bbs.espressif.com/ y del foro de la comunidad http://www.esp8266.com/

Reference de Arduino core para el ESP8266:

Además el manejo del wifi con la librería ESP8266WiFi.h cuyo código se puede encontrar en https://github.com/esp8266/Arduino/tree/master/doc/esp8266wifi se hace de una forma similar a la librería WiFi de Arduino https://www.arduino.cc/en/Reference/WiFi

Toda la documentación del soporte de Arduino core a ESP8266:

Para usar el SDK de ESP8266 para Arduino debemos instalar el soporte a terceros en nuestro IDE simplemente añadiendo el texto “http://arduino.esp8266.com/stable/package_esp8266com_index.json” en propiedades:

Y luego desde el gestor de tarjetas dar a instalar al soporte para ESP8266.

ESP8266 Community: http://arduino.esp8266.com/stable/package_esp8266com_index.json

  • Generic ESP8266 modules
  • Olimex MOD-WIFI-ESP8266
  • NodeMCU 0.9 (ESP-12)
  • NodeMCU 1.0 (ESP-12E)
  • Adafruit HUZZAH ESP8266 (ESP-12)
  • SparkFun Thing
  • SweetPea ESP-210
  • WeMos D1
  • WeMos D1 mini

Para instalar el Arduino Core ESP8266 en nuestro IDE de Arduino seguir las instrucciones: http://www.instructables.com/id/Setting-Up-the-Arduino-IDE-to-Program-ESP8266/?ALLSTEPS

IMPORTANTE: Cuando cargas un sketch en el ESP8266 con el IDE Arduino estamos cargando en la flash de ESP8266 un nuevo firmware borrando el que viene por defecto visto anteriormente para manejar el módulo con comando hayes.

Otras características de este soporte:

  • Actualización OTA
  • Soporta muchas de las librerías de Arduino y otras librerías hechas por terceros está ya adaptadas para usar con el ESP8266.

Más información:

Programar el módulo ESP-01 con Arduino

Es posible programar el módulo ESP-01 sin necesidad de un programador externo usando un Arduino. Para ello nos valemos del microcontrolador ATmega16U2 para programar y conectar por USB el módulo ESP8266 ESP-01 que disponemos.

En este esquema estamos conectando directamente los puertos Tx y Rx del ATmega16u2 con los del ESP8266 (puertos serie), de forma que el ATmega16U2 me hace de conversor USB a TTL para poder acceder al ESP8266 desde USB. Debe tenerse en cuenta que el ATmega328p de Arduino también está conectado a Tx y Rx, por lo que habrá que tener cargado algún programa que no use la UART de Atmega328p (cualquiera que con tenga Serial.begin)

También se puede usar un adaptador FTDI. Conectar al programador FTDI como hemos visto anteriormente. Pero para programar el módulo (Y para actualizar el firmware) necesitáis colocar el módulo en estado de programación y eso se consigue poniendo a GND la patilla GPIO0.

Vamos a programar el blink de Arduino en la patilla GPIO2, que es la que nos queda libre:

 
void setup()
   { pinMode(2, OUTPUT); }

void loop()
   { digitalWrite(2, HIGH);  
     delay(1000);  
     digitalWrite(2, LOW);
     delay(1000);   
   }

Para probarlo.

IMPORTANTE: Al cargar un programa pierdo el firmware original.

Más información:

Veamos los ejemplos de ESP8266 que vienen en el soporte para el IDE de Arduino, usando la librería ESP8266WiFi.h:

  • Blink
  • ESP8266Wifi/Wifiscan: Scan networks
  • ESP8266Wifi/WifiClient Conectar a wifi
  • ESP8266WebSerber/HelloServer: Servidor web wifi
  • ESP8266Wifi/WiFiAccessPoint: punto de acceso wifi

El reference para programar:

Anuncios

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:

Proyectos con ESP8266:

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.

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

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


<H1>301 Moved</H1>


The document has moved
<A HREF="http://www.google.com/">here</A>.
</BODY></HTML>
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 <SoftwareSerial.h>
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: