Documente Academic
Documente Profesional
Documente Cultură
Arduino
Comentarios(32)
Germán Martín
Muchas veces, hablo del ESP8266 con programadores que usan habitualmente Arduino.
Algunos de ellos me dicen es que programarlo no es fácil. No tienen claro qué firmware
cargar, qué se puede hacer con él, cómo conectarlo o qué entorno de desarrollo utilizar. En
este artículo te enseño cómo programar NodeMCU con el IDE de Arduino.
Probablemente a ti también te han surgido estas mismas preguntas. Si es así, deja que te
diga que programar NodeMCU puede ser tan sencillo como programar Arduino. No hay
tantas diferencias.
Utilizando el entorno de Arduino, una placa como NodeMCU y un cable USB podemos
tener un entorno de programación en unos pocos minutos.
Indice de contenidos
1 ¿Qué es NodeMCU?
2 Características de NodeMCU: Hardware
3 Conectando el NodeMCU al PC
4 NodeMCU: Ejemplos para empezar
5 Acceder a una web desde NodeMCU
6 ¿Y si tengo que conectarme usando HTTP seguro?
7 Conclusiones cómo programar NodeMCU
¿Qué es NodeMCU?
NodeMCU fue una de las primeras placas de desarrollo con el microcontrolador ESP8266.
Hasta entonces este chip solamente estaba disponible como placas ESP-xx como ESP01 o
ESP12.
NodeMCU se popularizó rápidamente porque permitía programar este microcontrolador de
una manera mucho más sencilla que utilizando el kit de desarrollo de Espressif. Su diseño
integra la electrónica necesaria. Para utilizarla no hace falta nada más que un cable USB y
un ordenador. Este concepto enchufar y listo es el mismo que usan las placas de Arduino.
El nombre de NodeMCU representa por tanto la unión de la placa de desarrollo junto con el
firmware. Éste permite escribir código con el lenguaje de programación LUA.
Con la aparición de la integración con el IDE de Arduino, este firmware ha caído poco a
poco en desuso. Aunque aún tiene sus incondicionales, ya no es una de las opciones más
utilizadas para programar NodeMCU.
Como todas las placas que utilizan ESP8266, se les puede cargar cualquier firmware. Puede
usarse desde el propio de NodeMCU con lenguaje LUA, a MicroPython. También se puede
utilizar como una placa de Arduino, donde nosotros hacemos el firmware desde cero.
NodeMCU es, desde sus inicios, un proyecto de código abierto. El código del firmware y
el diseño del hardware están disponibles en GitHub.
El ESP12 se alimenta con 3.3 V, pero NodeMCU incluye un regulador de tensión, lo que
nos permite alimentarla por USB con 5V, por ejemplo desde el ordenador que estamos
utilizando para programarla.
Este regulador tiene un consumo residual de 8mA, lo que hace que esta placa no sea
adecuada como módulo definitivo en un proyecto que se requiera un bajo consumo.
Aunque esto sea así NodeMCU sí se puede utilizar como plataforma de prototipado para
aplicaciones de baja energía que luego pasaremos a otras placas con menos componentes y,
por tanto, con un consumo de corriente más optimizado.
Todos los pines del ESP12E están cableados hasta el interfaz de la NodeMCU, por lo que
tenemos disponible 11 pines de entrada salida y el puerto de entrada analógica.
Los pines GPIO del 6 al 11 están también conectados pero te recomiendo no usarlos. El
ESP12E utiliza estos pines para conectar la memoria flash. Si los usas, lo más seguro es
que el módulo se reinicie de forma inesperada. Tranquilo, si lo haces no romperás nada.
La placa tiene 2 botones, uno conectado al pin de RESET y otro al GPIO0, que permite
activar el modo de carga de firmware. Normalmente, no es necesario utilizar estos botones
si usamos el IDE de Arduino.
Al igual que pasa en las placas de Arduino, la electrónica de NodeMCU, también simula la
secuencia de pulsaciones para entrar en el modo de carga de firmware.
Los pines GPIO 1 y 3 corresponden con el Rx y el Tx del puerto serie. Estos pines están
protegidos con resistencias de 470 Ohm.
NodeMCU también facilita el uso del puerto analógico. El ESP8266 tiene un rango de
entrada en este puerto de 0 a 1V pero gracias a un divisor de tensión NodeMCU lo extiende
de 0 a 3.3V.
Pineado de NodeMCU
El nombre de los pines de NodeMCU tiene una nomenclatura diferente de la que utiliza el
ESP8266. Por ejemplo los pines D0, D1, y D2 en la NodeMCU correponden con GPIO16,
5 y 4 en el ESP8266. El framework para Arduino permite utilizar ambas para referirse a
los pines de entrada salida.
1 pinMode(D2, OUTPUT);
2 digitalWrite(D2,HIGH);
Acceso a los pines con la nomenclatura de ESP8266:
1 pinMode(4, OUTPUT);
2 digitalWrite(4,HIGH);
Conectando el NodeMCU al PC
Las placas NodeMCU incorporan un conversor USB a serie. Solamente es necesario
conectar el puerto USB de la placa a uno de los puertos de nuestro ordenador con un buen
cable.
Hay diferentes fabricantes que hacen tarjetas de este tipo. Cada uno puede utilizar
conversores diferentes. Los más utilizados son el CP1202 de Silabs, y CH340 del fabricante
chino WCH. He leído que también hay placas que utilizan el conversor FT232RL de FTDI,
pero no he llegado a ver ninguna.
Por mi experiencia, estos 3 chips funcionan bien con velocidades de hasta 921kbps sin
problema. Éste es el máximo bitrate que soporta el IDE de Arduino. Te interesa utilizar esta
velocidad para reducir el tiempo de carga del programa en la memoria flash del ESP8266,
pero es necesario utilizar un buen cable USB.
Si ves que no funciona a esa velocidad, prueba a 115200 y haz diferentes pruebas hasta que
encuentres el límite de tu sistema.
Para configurar el entorno de Arduino te recomiendo ver el video sobre cómo programar
el ESP8266 con el IDE de Arduino.
Puede que al principio no sepas para qué sirven las opciones de configuración de la placa.
Ésta es la configuración que yo utilizo y que funcionará con todas las NodeMCU. Si el IDE
de Arduino no puede programar la placa prueba a bajar el campo «upload speed» a 115200
bps.
NodeMCU: Ejemplos para empezar
Ahora vamos a ponernos manos a la obra. Para empezar de la manera más sencilla vamos a
aprender cómo utilizar el botón y el led que incluye la NodeMCU. El LED está conectado,
internamente, al GPIO2 y el botón al GPIO0.
Lo primero que vamos a hacer es que parpadee el LED de NodeMCU. Copia y pega este
código en el IDE de Arduino.
En el siguiente código vamos a utilizar el botón FLASH de NodeMCU. Este botón nos
permite poner en modo carga del firmware. Como ya te he comentado, esto lo hace
automáticamente al igual que las placas de Arduino, en un modo normal no tenemos que
pulsar nada para cargar nuestro código.
Sin embargo, podemos utilizarlo como un botón normal una vez que se ha cargado el
código al NodeMCU pero siempre y cuando se haya iniciado la ejecución. Recuerda, el
GPIO donde está conectado el botón FLASH de NodeMCU es el GPIO0.
Carga el siguiente código que lo que hace es encender el LED conectado el GPIO2 cuando
se pulsa el botón.
Encender el LED si el botón está pulsado:
1 #define LED_BUILTIN 2
2 #define BUTTON_BUILTIN 0
3
4 void setup() {
5 // El LED integrado está conectado al pin 2.
6 pinMode(LED_BUILTIN, OUTPUT);
7 pinMode(BUTTON_BUILTIN, INPUT);
8 }
9
10 void loop() {
11 // Leer el estado del botón. Cuando está pulsado el pin se pone a nivel bajo
12 int estado = digitalRead(BUTTON_BUILTIN);
13 // Configurar el LED de acuerdo al estado del botón
14 digitalWrite(LED_BUILTIN, estado);
15 }
Las librerías que incluye el framework de Arduino para el ESP8266 hacen que esto sea una
tarea muy sencilla.
Lo primero de todo hay que conectar el módulo a la red WiFi. Para ello, dentro de la
función setup() configuramos el NodeMCU como cliente WiFi e iniciamos la conexión
pasando el nombre de nuestra red y la contraseña.
1 WiFi.mode(WIFI_STA); // Modo cliente WiFi
2 WiFi.begin("Nombre_WiFi", "Contraseña");
Conectar al servidor
Después, una vez que verificamos que la conexión se ha realizado correctamente se puede
enviar la petición. En este ejemplo voy a obtener la información de las condiciones
meteorológicas. Lo voy a hacer consultando a la API del servicio Weather Underground.
No te preocupes si no entiendes todo el código. En una próxima entrada del blog
hablaremos de esto con mayor detalle.
1 {
2 "response": {
3 "version": "0.1",
4 "termsofService": "http://www.wunderground.com/weather/api/d/terms.html",
5 "features": {
6 "conditions": 1
7 }
8 },
9 "current_observation": {
10 "image": {
11 "url": "http://icons.wxug.com/graphics/wu2/logo_130x80.png",
12 "title": "Weather Underground",
13 "link": "http://www.wunderground.com"
14 },
15 "display_location": {
16 "full": "Madrid, Spain",
17 "city": "Madrid",
18 "state": "M",
19 "state_name": "Spain",
20 "country": "SP",
21 "country_iso3166": "ES",
22 "zip": "00000",
23 "magic": "1",
24 "wmo": "08221",
25 "latitude": "40.45000076",
26 "longitude": "-3.54999995",
27 "elevation": "609.0"
28 },
29 "observation_location": {
30 "full": "Madrid, ",
31 "city": "Madrid",
32 "state": "",
33 "country": "ES",
34 "country_iso3166": "ES",
35 "latitude": "40.45000076",
36 "longitude": "-3.54999995",
37 "elevation": "1909 ft"
38 },
39 "estimated": {},
40 "station_id": "LEMD",
41 "observation_time": "Last Updated on Marzo 23, 8:30 AM CET",
42 "observation_time_rfc822": "Thu, 23 Mar 2017 08:30:00 +0100",
43 "observation_epoch": "1490254200",
44 "local_time_rfc822": "Thu, 23 Mar 2017 09:02:09 +0100",
45 "local_epoch": "1490256129",
46 "local_tz_short": "CET",
47 "local_tz_long": "Europe/Madrid",
48 "local_tz_offset": "+0100",
49 "weather": "Parcialmente nublado",
50 "temperature_string": "32 F (0 C)",
51 "temp_f": 32,
52 "temp_c": 0,
53 "relative_humidity": "93%",
54 "wind_string": "From the SSE at 8 MPH",
55 "wind_dir": "SSE",
56 "wind_degrees": 150,
57 "wind_mph": 8,
58 "wind_gust_mph": 0,
59 "wind_kph": 13,
60 "wind_gust_kph": 0,
61 "pressure_mb": "1011",
62 "pressure_in": "29.86",
63 "pressure_trend": "0",
64 "dewpoint_string": "30 F (-1 C)",
65 "dewpoint_f": 30,
66 "dewpoint_c": -1,
67 "heat_index_string": "NA",
68 "heat_index_f": "NA",
69 "heat_index_c": "NA",
70 "windchill_string": "25 F (-4 C)",
71 "windchill_f": "25",
72 "windchill_c": "-4",
73 "feelslike_string": "25 F (-4 C)",
74 "feelslike_f": "25",
75 "feelslike_c": "-4",
76 "visibility_mi": "6.2",
77 "visibility_km": "10.0",
78 "solarradiation": "--",
79 "UV": "1",
80 "precip_1hr_string": "-9999.00 in (-9999.00 mm)",
81 "precip_1hr_in": "-9999.00",
82 "precip_1hr_metric": "--",
83 "precip_today_string": "0.00 in (0.0 mm)",
84 "precip_today_in": "0.00",
85 "precip_today_metric": "0.0",
86 "icon": "partlycloudy",
87 "icon_url": "http://icons.wxug.com/i/c/k/partlycloudy.gif",
88 "forecast_url": "http://www.wunderground.com/global/stations/08221.html",
89 "history_url":
90 "http://www.wunderground.com/history/airport/LEMD/2017/3/23/DailyHistory.html",
91 "ob_url": "http://www.wunderground.com/cgi-
92 bin/findweather/getForecast?query=40.45000076,-3.54999995",
93 "nowcast": ""
}
}
Programa completo
El código del sketch será éste. Para hacerlo funcionar necesitas rellenar los datos de tu red
WiFi y de la clave del API de Weather Underground que puedes obtener registrándote en
su web.
Con NodeMCU, programar el ESP8266 es mucho más sencillo que hacerlo con módulos
como el ESP01.
Hemos visto cómo conectar NodeMCU a nuestro ordenador y cómo configurar el IDE de
Arduino para programarlo. También nos hemos iniciado con programas básicos para el
control de los puertos de entrada salida.