Guía de programación del ESP8266 en entorno Arduino

La designación de los pines está (en teoría correctamente) asociada en la implementación del ESP8266 en el entorno de Arduino, según la siguiente tabla:

Para hacer referencia a un pin podemos usar ambas designaciones indistintamente. Así que, en teoría, las dos sentencias siguientes son equivalentes,

digitalWrite(D5, LOW);  // D5, que es igual a GPIO14

digitalWrite(14, LOW);  // GPIO14 directamente

Sin embargo, en la práctica, sabemos que no todos los fabricantes siguen el mismo criterio a la hora de identificar los pines en las placas (sobre todo los chinos).

Por tanto, al realizar la programación del ESP8266 deberemos prestar especial atención al pinout de nuestra placa y tener muy presente posibles equivocaciones en la designación para evitarnos quebraderos de cabeza.

Las entradas y salidas digitales (GPIO) se programan prácticamente igual que en cualquier Arduino. Así, podemos cambiar el modo de un GPIO entre entrada o salida con la función:

pinMode(pin, mode)

Donde el modo puede ser OUTPUT, INPUT o INPUT_PULLUP. El pin 16 tiene un modo adicional INPUT_PULLDOWN_16, pero no es frecuente que vayamos a usarlo. Como en Arduino, por defecto todos los pines se inicializan como INPUT.

Por otro lado, cuando el GPIO están en modo OUTPUT podemos emplearlo como salida asignando un valor (LOW o HIGH) igual que en Arduino con:

digitalWrite(pin, output)

Por último, cuando el GPIO está en modo entrada podemos leer su valor igual que en Arduino con:

digitalRead(pin)

La programación de salidas PWM (salidas “analógicas”) es muy parecida a Arduino convencional. Sin embargo el ES8266 no dispone de PWM por hardware por lo que, en su lugar, lo realiza por software.

Esto supone un coste computacional adicional que Arduino no tiene. Sin embargo, también permite que podamos usar PWM en cualquier GPIO.

Para ello, igual que en Arduino, para usar una salida PWM empleamosla función:

analogWrite(pin, value)

Por defecto el rango es de 10bits, por lo que value toma valores de 0-1023 (la mayoría de modelos de Arduino toman valores de 0-255). No obstante, podemos cambiar el rango hasta 14bits de salida con:

analogWriteRange(range)

La frecuencia por defecto es de 1kHz, pero puede ser cambiado con la función (el mínimo es 100Hz y el máximo es 40kHz)

analogWriteFreq(frequency)

Otra diferencia con un Arduino es que si en el mismo programa queremos usar una salida PWM como digital posteriormente, deberemos desactivar el PWM de forma explícita. Para ello simplemente hacemos:

analogWrite(pin, 0)

El ESP8266 tiene una única entrada analógica (ADC), que en el entorno Arduino se designa con A0. Para leerlo se emplea la misma función que Arduino, es decir, simplemente usamos la función:

analogRead(A0)

La respuesta es un valor de 10bits en el rango de 0-1023 (igual que en la mayoría de Arduinos), cuyo voltaje es proporcional a la tensión en la entrada. Recordar que el ESP8266 tiene una entrada analógica máxima de 1V, aunque muchas placas tienen un conversor para ampliarlo hasta 5V.

Por otro lado, el ESP8266 tiene un modo adicional que permite medir su voltaje de alimentación. Esto es útil, por ejemplo, al funcionar con baterías. Para activarlo, añadimos esta línea en nuestro Sketch.

ADC_MODE(ADC_VCC)

Mientras estemos usando este modo el pin ADC real deberá estar desconectado y, lógicamente, no podremos usarlo como entrada analógica.

El ESP8266 tiene interrupciones en todos los pines GPIO, excepto en el GPIO16 (D2). El uso es similar a las interrupciones por hardware en Arduino.

attachInterrupt(digitalPinToInterrupt(interruptPin), handler, FALLING);

Las opciones son RISING, FALLING, CHANGE, ONLOW, ONHIGH, ONLOW_WE, ONHIGH_WE.

La macro PROGMEM, que guarda variables en la memoria flash en lugar de en la memoria dinámica, también funciona en el ESP8266 con una pequeña pero importante diferencia.

En lugar de Arduino, que realiza un análisis previo para evitar tener la misma variable múltiples veces, el equivalente en ESP8266 no realiza este preprocesamiento.

Así, por ejemplo:

string text1 = F("hello");
string text2 = F("hello");

Guardará dos veces el literal “hello” en la memoria. Podemos evitar esto con la función FPSTR así

const char hello[] PROGMEM = "hello";
string texto1 = FSPTR(hello);
string texto2 = FSPTR(hello);