Archivo de la categoría: Curso Avanzado 2017

EEPROM

La EEPROM es una memoria no volátil que dispone el microcontrolador de Arduino que nos permite guardar datos para poder recuperar en caso de pérdida de alimentación de nuestro dispositivo.

La gran desventaja que tiene la EEPROM es que tiene un número limitado de escrituras, por lo que debemos calcular cuántas veces se va a escribir en ella para calcular su vida útil con nuestro programa. Además la velocidad de lectura y escritura en inferior que en la SRAM y Flash.

Más información en: http://en.wikipedia.org/wiki/EEPROM

Las celdas de memoria de una EEPROM están constituidas por un transistor MOS, que tiene una compuerta flotante (estructura SAMOS), su estado normal está cortado y la salida proporciona un 1 lógico.

Aunque una EEPROM puede ser leída un número ilimitado de veces, sólo puede ser borrada y reprogramada entre 100.000 y un millón de veces.

Además de la memoria EEPROM integrada en el chip del microcontrolador, hay disponibles memorias EEPROM externas. Estos dispositivos suelen comunicarse mediante protocolos como I²C, SPI y Microwire.

La memoria flash es una forma avanzada de EEPROM.

La librería EEPROM nos permite leer y escribir bytes de la EEPROM de Arduino. La EEPROM en cada MCU tiene un tamaño diferente, en nuestro caso con el Arduino UNO es de 1024 bytes. Esta librería solo me permite leer y escribir a nivel de byte, por lo que si quiero guardar variables cuyo tamaño sea mayor de 1 byte, deberemos hacer operaciones.

Librería http://arduino.cc/en/Reference/EEPROM

read() – Lee un byte de la EEPROM. http://arduino.cc/en/Reference/EEPROMRead
write() – Escribe un byte de la EEPROM. http://arduino.cc/en/Reference/EEPROMWrite
update() – Escribe un byte de la EEPROM, el valor solo es escrito si es diferente al almacenado. https://www.arduino.cc/en/Reference/EEPROMUpdate
get() – Lee cualquier tipo de dato u objeto de la EEPROM. https://www.arduino.cc/en/Reference/EEPROMGet
put() – Escribe cualquier tipo de dato u objeto de la EEPROM. https://www.arduino.cc/en/Reference/EEPROMPut
EEPROM[ ] – Este operador permite usar el identificador ‘EEPROM’ como un array. Las celdas de la EEPROM pueden leerse y escribirse con este método. https://www.arduino.cc/en/Reference/EEPROMObject

Una EEPROM tarda unos 3,3 ms en completar una escritura y para Arduino se ha especificado una vida de 100000 ciclos de escritura/borrado.

Tutorial lectura EEPROM: http://en.wikipedia.org/wiki/EEPROM

Tutorial escritura EEPROM: http://arduino.cc/en/Tutorial/EEPROMWrite

Tutorial limpiado EEPROM: http://arduino.cc/en/Tutorial/EEPROMClear

Para grabar estructuras de datos en la EEPROM de una forma muy sencilla podemos usar EEPROMAnything.h. http://playground.arduino.cc/Code/EEPROMWriteAnything

AVR Libc dispone de métodos de la librería <avr/eeprom.h> para manejar la EEPROM: http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__eeprom.html

La librería EEPROMex es una extensión de la librería EEPROM que amplía sus funcionalidades:

El acceso entre la EEPROM y la CPU se hace mediante los registros:

EEPROM Address Registers: EEARH y EEARL
EEPROM Data Register: EEDR
EEPROM Control Register: EECR

Más información en la página 36 del http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf

Cosas a tener en cuenta con la EEPROM: https://engineerzero.wordpress.com/2013/07/11/five-things-to-remember-pun-about-arduino-eeprom/

Los datos deben guardarse en formato byte para ser usados
EEPROM puede los datos de configuración de usuario
Dañar la EEPROM no es un problema grave
Dañar la EEPROM puede ser un problema si no se tiene cuidado
Dañar la EEPROM no es el fin del mundo

Muy buen tutorial de Luis Llamas: https://www.luisllamas.es/guardar-variables-entre-reinicios-con-arduino-y-la-memoria-no-volatil-eeprom/

Un uso típico con la EEPROM es crear un firmware único muchos dispositivos y guardar las variables de cada dispositivo en la EEPROM, por ejemplo la IP, MAC, identificador, número de sondas conectadas, etc… De esta forma con un único firmware único que en el setup() lee la configuración de la EEPROM, se personaliza el comportamiento de cada dispositvo.

Comprobación de EEPROM no corrompida: https://www.arduino.cc/en/Tutorial/EEPROMCrc

La verificación por redundancia cíclica (CRC) es un código de detección de errores usado frecuentemente en redes digitales y en dispositivos de almacenamiento para detectar cambios accidentales en los datos. https://es.wikipedia.org/wiki/Verificaci%C3%B3n_de_redundancia_c%C3%ADclica

Calculo CRC: http://www.lammertbies.nl/comm/info/crc-calculation.html

Sketch para grabar en la EEPROM en diferentes celdas y no machacar una misma zona de memoria, comprobando el nivel de desgaste de las celdas de la EEPROM: http://blog.blinkenlight.net/experiments/counting-resets/wear-leveling/

EEPROM Externa

Para proteger un arduino que queremos comercializar y que no se pueda replicar el programa en otros microcontroladores Atmel.

Un ejemplo es usar una EEPROM externa usado como “mochila” donde guardamos un número único. Este mismo módulo lo podríamos usar como contador o con otras funcionalidades.

EEPROM externa : http://datasheets.maximintegrated.com/en/ds/DS2430A.pdf
Como trabajar con ella: http://playground.arduino.cc/Learning/OneWire

Práctica: Volcado EEPROM

Si estamos depurando un proyecto de Arduino usando EEPROM, es posible que queramos ver la EEPROM para entender lo que está pasando.

Si tenemos un programador ISP como el USBtinyISP de Adafruit, siempre se puede utilizar avrdude para volcar la EEPROM a un archivo. Por ejemplo, el siguiente código crea un archivo denominado e2data.ee con contenido de EEPROM.

 
$ avrdude -p m328p -c usbtiny -P usb -U eeprom:r:e2data.ee:r

Otra opción es usar un sketch que nos saque por el puerto serie el contenido de la EEPROM.

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_Avanzado_2017/tree/master/Ejercicio23-leeEEPROM

Práctica: Termómetro con Máximas y Mínimas.

Partiendo del ejercicio https://aprendiendoarduino.wordpress.com/2017/06/24/ejemplo-sensor-de-temperatura/ hacer que guarde los valores máximos y mínimos en las direcciones de memoria 100 y 200 respectivamente.

Para recuperarlo pulsar en el monitor serie M para máximo y m para mínimo. Para inicializar los valores de max y min pulsar R.

Como las temperaturas máximas y mínimas son de tipo float, usar los métodos:

Uso sensor tmp36: http://www.prometec.net/sensor-tmp36/

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_Avanzado_2017/tree/master/Ejercicio24-Temperatura_Max_Min

Programación ESP8266 con IDE Arduino

5 respuestas

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:

https://github.com/esp8266/Arduino/tree/master/doc
El reference de wifi es similar a https://www.arduino.cc/en/Reference/WiFi

Uso ESP8266 con Arduino (Puerto Serie)

3 respuestas

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:

ESP8266 y Arduino

3 respuestas

El microcontrolador ESP8266 puede usarse con Arduino de dos formas:

Usando el firmware propio, de forma que el ESP8266 es una pasarela de puerto serie 3.3V a wifi. De hecho, originalmente el módulo ESP8266 fue creado con este objetivo por la empresa espressif: http://espressif.com/. Para usarlo de esta forma es necesario tener un arduino que programaremos y al que conectamos el módulo ESP8266 por puerto serie para darle capacidad wifi a nuestro Arduino. En este caso el ESP8266 no es programado.
Programar ESP8266, en este caso en lugar de usar el firmware que trae por defecto el módulo ESP8266, lo programamos nosotros y para ello usamos el IDE de Arduino y el lenguaje de programación de Arduino junto con alguna librería adicional para manejar el wifi.

Firmware propio

El módulo WIFI ESP8266, que es algo muy parecido a los módulos Bluetooth y que al igual que ellos incluye toda la electrónica necesaria para la comunicación Radio Frecuencia en la banda WiFi, así como la pila TCP/IP y que se comunica con nosotros a través de un puerto serie. De hecho, exactamente igual que los modos HC-06 y HC-05 se gobierna mediante comandos AT (comandos hayes https://es.wikipedia.org/wiki/Conjunto_de_comandos_Hayes) y todo por un precio similar al de los Bluetooth.

El ESP8266 con su firmware de fábrica nos permite conectarnos a Internet desde Arduino conectando ambos módulos mediante el puerto serie y ejecutar comandos AT sobre el ESP8266 y recibiendo la respuesta en Arduino.

Tutorial uso ESP con comandos AT: https://create.arduino.cc/projecthub/user16726/configuring-the-esp8266-using-an-arduino-0ab2e6?ref=similar&ref_id=27809&offset=5

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

Programación ESP8266 con IDE Arduino

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 ++. Este 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.

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

Reference de Arduino core para el ESP8266:

Listado de URLs para soporte de tarjetas no oficiales: https://github.com/arduino/Arduino/wiki/Unofficial-list-of-3rd-party-boards-support-urls

Podemos 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.

Para programar el microcontrolador del ESP8266 necesitamos un adaptador de USB a puerto serie, pero podemos usar el propio ATmega16U2 que viene en Arduino UNO para programarlo.

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

En este caso para poder programar el ESP8266, en el Arduino no puede haber ningún sketch con el puerto serie funcionando ya que interferiría con el puerto serie del ESP8266. Por ejemplo podemos cargar el blink.

Módulo:

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)

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

ESP8266Wifi/Wifiscan: Scan networks
ESP8266Wifi/WifiClient Conectar a wifi
ESP8266WebSerber/HelloServer: Servidor web wifi

Paso 1 – Cargar el programa blink en Arduino par que no haya interferencias por el puerto serie.

Paso 2 – Conexión:

Paso 3 – Con el IDE de arduino cargar cualquiera de estos tres programas de ejemplos y comprobar que funcionan:

ESP8266Wifi/Wifiscan: Scan networks
ESP8266Wifi/WifiClient Conectar a wifi
ESP8266WebSerber/HelloServer: Servidor web wifi

También se podría programar el blink de Arduino en la patilla GPIO2, que es la que nos queda libre y hacer parpadear el led:

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

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

Para probarlo, conectar independiente el ESP8266 del Arduino.

Probar a enviar mensajes a la plataforma http://www.aprendiendoarduino.com/servicios/mensajes/index.html con el ESP8266 de forma que pasando los datos por el monitor serie, se envían y almacenan en la plataforma.

Solución: https://github.com/jecrespo/aprendiendoarduino-servicios/tree/master/arduino_code/graba_mensaje_ESP

Comparar cómo se haría con el shield de Ethernet: https://github.com/jecrespo/aprendiendoarduino-servicios/tree/master/arduino_code/graba_mensaje_DHCP

Qué es ESP8266

5 respuestas

El ESP8266 es un chip Wi-Fi de bajo coste con pila TCP/IP completa y capacidad de MCU (Micro Controller Unit) producida por el fabricante chino Espressif Systems, con sede en Shanghai.

El chip primero llegó a la atención de los fabricantes occidentales en agosto de 2014 con el módulo ESP-01. Este pequeño módulo permite a los microcontroladores conectarse a una red Wi-Fi y realizar conexiones TCP/IP sencillas utilizando comandos de tipo Hayes. Sin embargo, en ese momento casi no había documentación en inglés sobre el chip y los comandos que aceptaba. El precio muy bajo y el hecho de que había muy pocos componentes externos en el módulo que sugiere que podría ser muy barato en el volumen, atrajo a muchos hackers para explorar el módulo, el chip y el software en él, así como para traducir La documentación china.

Web del producto: http://espressif.com/en/products/hardware/esp8266ex/overview

Módulo con memoria flash: http://espressif.com/en/products/hardware/esp-wroom-02/overview

Recursos: http://espressif.com/en/products/hardware/esp8266ex/resources

Datasheet: http://espressif.com/sites/default/files/documentation/0a-esp8266ex_datasheet_en.pdf

Wikipedia:

https://es.wikipedia.org/wiki/ESP8266
https://en.wikipedia.org/wiki/ESP8266
System on chip (SOC) https://en.wikipedia.org/wiki/System_on_a_chip

Artículos a leer para nuevos en ESP8266:

4 cosas que hay que saber del ESP8266: https://www.baldengineer.com/four-esp8266-gotchas.html
5 razones para usar ESP8266: https://www.baldengineer.com/esp8266-5-reasons-to-use-one.html

El ESP8285 es un ESP8266 con 1 MB de flash incorporado, lo que permite dispositivos de un solo chip capaces de conectarse a Wi-Fi. Muchos encapsulados del ESP8266 viene con 1 MB de flash.

Foro de la comunidad de ESP8266: http://www.esp8266.com/

Más información:

SDK ESP8266

A finales de octubre de 2014, Espressif lanzó un kit de desarrollo de software (SDK) que permite programar el chip, eliminando la necesidad de un microcontrolador por separado.Desde entonces, ha habido muchos lanzamientos oficiales de SDK; Espressif mantiene dos versiones del SDK – una basada en RTOS y la otra basada en callbacks mediante comadnos AT:.

NONOS SDK: https://github.com/espressif/ESP8266_NONOS_SDK
RTOS SDK: https://github.com/espressif/ESP8266_RTOS_SDK

Una alternativa al SDK oficial de Espressif es el open source esp-open-sdk que se basa en la cadena de herramientas (toolchain) GCC. ESP8266 utiliza el microcontrolador Cadence Tensilica LX106 y la cadena de herramientas GCC que es de código abierto y mantenida por Max Filippov. Otra alternativa es «Unofficial Development Kit» de Mikhail Grigorev.

Otros SDK de código abierto para el ESP8266:

esp-open-sdk: https://github.com/pfalcon/esp-open-sdk
Unofficial Development Kit for Espressif ESP8266 http://www.programs74.ru y github https://github.com/CHERTS/esp8266-devkit
NodeMCU: un firmware basado en Lua. https://github.com/nodemcu/nodemcu-firmware
Arduino: un firmware basado en C ++. Este núcleo permite que la CPU del ESP8266 y sus componentes Wi-Fi sean programados como cualquier otro dispositivo Arduino. El Arduino Core ESP8266 está disponible a través de GitHub: https://github.com/esp8266/Arduino y cuyo wiki es https://github.com/esp8266/esp8266-wiki/wiki
MicroPython: una implementación de Python para dispositivos embebidos a la plataforma ESP8266. https://docs.micropython.org/en/latest/esp8266/index.html
ESP8266 BASIC: Un intérprete básico de código abierto específicamente diseñado para el Internet de las cosas. http://www.esp8266basic.com/
Mongoose Firmware: Un firmware de código abierto con servicio gratuito en la nube: https://github.com/cesanta/mongoose-iot

ESP8266 core for Arduino: https://github.com/esp8266/Arduino mantenido por al comunidad.

Más información:

Características

El esp8266 es un módulo muy de moda que va alimentado a 3.3V y que hay mucha documentación en internet. EL ESP8266 no tiene ROM y usa una ROM externa SPI y soporta hasta 16MB.

Características:

32-bit RISC CPU: Tensilica Xtensa LX106 running at 80 MHz*
64 KiB of instruction RAM, 96 KiB of data RAM
External QSPI flash – 512 KiB to 4 MiB* (up to 16 MiB is supported)
IEEE 802.11 b/g/n Wi-Fi
- Integrated TR switch, balun, LNA, power amplifier and matching network
- WEP or WPA/WPA2 authentication, or open networks
16 GPIO pins
SPI, I²C,
I²S interfaces with DMA (sharing pins with GPIO)
UART on dedicated pins, plus a transmit-only UART can be enabled on GPIO2
1 port 10-bit ADC

* Both the CPU and flash clock speeds can be doubled by overclocking on some devices. CPU can be run at 160 MHz and flash can be sped up from 40 MHz to 80 MHz.

Datos de ESP8266 de datasheet:

802.11 b/g/n
Integrated low power 32-bit MCU
Integrated 10-bit ADC • Integrated TCP/IP protocol stack
Integrated TR switch, balun, LNA, power amplifier and matching network
Integrated PLL, regulators, and power management units
Supports antenna diversity
WiFi 2.4 GHz, support WPA/WPA2
Support STA/AP/STA+AP operation modes
Support Smart Link Function for both Android and iOS devices
SDIO 2.0, (H) SPI, UART, I2C, I2S, IR Remote Control, PWM, GPIO
STBC, 1×1 MIMO, 2×1 MIMO
A-MPDU & A-MSDU aggregation & 0.4s guard interval
Deep sleep power <10uA, Power down leakage current < 5uA
Wake up and transmit packets in < 2ms
Standby power consumption of < 1.0mW (DTIM3) • +20 dBm output power in 802.11b mode
Operating temperature range -40C ~ 125C
FCC, CE, TELEC, WiFi Alliance, and SRRC certified

Datos de la MCU Tensilica LX106 que lleva el ESP8266:

Dentro de la gran cantidad de usos para este módulo caben destacar los siguientes:

Electrodomésticos conectados.
Automatización del hogar.
Automatización de la industria.
Cámaras IP.
Redes de sensores.
Wereables.
IoT (Internet of Things o Internet de las Cosas)
IIoT (Industrial Internet of Things o Internet de las Cosas para el sector Industrial)

Pinout ESP8266:

Pinout placas: http://www.pighixxx.com/test/portfolio-items/esp8266/?portfolioID=360

Diagrama de bloques

Buenísimos tutoriales: http://www.prometec.net/indice-tutoriales-esp8266/

Consumo ESP8266

Tabla de consumo del módulo ESP8266:

Si queremos alimentar el módulo ESP8266 con Arduino debemos ver las limitaciones de Arduino: pin power limitations: http://playground.arduino.cc/Main/ArduinoPinCurrentLimitations, a 5V la limitación es de 1A del regulador de tensión. Como va alimentado a 3.3V la limitación es de 150mA limitado por el regulador de tensión. Regulador http://www.ti.com/lit/ds/symlink/lp2985-33.pdf, por lo tanto alimentar el ESP8266 desde el pin de 3.3V puede dar problemas y es recomendable usar otra fuente de alimentación.

Valores de HIGH y LOW en ESP8266 http://henrysbench.capnfatz.com/henrys-bench/arduino-projects-tips-and-more/esp8266ex-gpio-high-and-low-input-thresholds/

Módulos ESP8266

El ESP8266 se presenta con muchos encapsulados: http://www.esp8266.com/wiki/doku.php?id=esp8266-module-family

Los módulos ESP8266 los podemos encontrar en diferentes encapsulados y placas:

Características de los módulos:

Name	Active pins	Pitch	Form factor	LEDs	Antenna	Shielded?	dimensions (mm)	Notes
ESP-01	6	0.1″	2×4 DIL	Yes	PCB trace	No	14.3 × 24.8
ESP-02	6	0.1″	2×4 castellated	No	U-FL connector	No	14.2 × 14.2
ESP-03	10	2 mm	2×7 castellated	No	Ceramic	No	17.3 × 12.1
ESP-04	10	2 mm	2×4 castellated	No	None	No	14.7 × 12.1
ESP-05	3	0.1″	1×5 SIL	No	U-FL connector	No	14.2 × 14.2
ESP-06	11	misc	4×3 dice	No	None	Yes	14.2 × 14.7	Not FCC approved
ESP-07	14	2 mm	2×8 pinhole	Yes	Ceramic + U-FL connector	Yes	20.0 × 16.0	Not FCC approved
ESP-08	10	2 mm	2×7 castellated	No	None	Yes	17.0 × 16.0	Not FCC approved
ESP-09	10	misc	4×3 dice	No	None	No	10.0 × 10.0
ESP-10	3	2 mm?	1×5 castellated	No	None	No	14.2 × 10.0
ESP-11	6	0.05″	1×8 pinhole	No	Ceramic	No	17.3 × 12.1
ESP-12	14	2 mm	2×8 castellated	Yes	PCB trace	Yes	24.0 × 16.0	FCC and CE approved[14]
ESP-12E	20	2 mm	2×8 castellated	Yes	PCB trace	Yes	24.0 × 16.0	4 MB Flash
ESP-12F	20	2 mm	2×8 castellated	Yes	PCB trace	Yes	24.0 × 16.0	FCC and CE approved. Improved antenna performance. 4 MB Flash
ESP-13	16	1.5 mm	2×9 castellated	No	PCB trace	Yes	W18.0 x L20.0	Marked as ″FCC″. Shielded module is placed sideways, as compared to the ESP-12 modules.
ESP-14	22	2 mm	2×8 castellated +6	No	PCB trace	Yes	24.3 x 16.2