Programar fácil con Arduino

Programar fácil con Arduino, entiende cómo funciona el mundo.

  • Blog
  • ¿Quién soy?
  • Podcast
  • Curso Arduino [GRATIS]
  • Curso Domótica [GRATIS]
  • Acceder
Usted está aquí: Inicio / ESP8266 / Cómo programar NodeMCU con el IDE de Arduino

Cómo programar NodeMCU con el IDE de 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.

Si todavía no sabes qué es este kit de desarrollo basado en ESP8266, no te pierdas el tutorial de NodeMCU desde cero. Te dará una visión general para poder empezar tus propios proyectos.

Utilizando el entorno de Arduino, una placa como NodeMCU y un cable USB podemos tener un entorno de programación en unos pocos minutos.

programar nodemcu ide arduino

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.

Cuando fue presentada, no existía la integración de ESP8266 con el entorno de Arduino. No utilizaba un lenguaje compilado sino uno interpretado llamado LUA.

LUA Logo

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.

En cambio, la facilidad para conectarlo al ordenador para programarlo y la posibilidad de hacerlo desde el IDE de Arduino han hecho que el hardware siga disponible en su forma original y en forma de otras muchas placas derivadas.

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.

Si quieres profundizar en el funcionamiento de GitHub entra aquí.

Características de NodeMCU: Hardware

NodeMCU integra el ESP8266 en forma de un ESP12E. Este módulo tiene, además del microprocesador, una antena PCB, un LED conectado al GPIO2 y una memoria flash de 16 Mbit (= 4 MB).

esp12 pinout nodemcu

Alimentación

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.

Pines de entrada salida

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

nodemcu pineado

A continuación puedes ver el pineado de la NodeMCU original.

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.

Estas dos sentencias son equivalentes.

1
2
pinMode(D2, OUTPUT);
digitalWrite(D2,HIGH);
1
2
pinMode(4, OUTPUT);
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.

El sistema operativo normalmente detecta el hardware e instala los drivers automáticamente.

Si tienes un sistema operativo MAC, sigue estas instrucciones.

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.

Configuración NodeMCU

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.

ejemplo uno nodemcu

Lo primero que vamos a hacer es que parpadee el LED de NodeMCU. Copia y pega este código en el IDE de Arduino.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define LED_BUILTIN 2
 
void setup() {
  // El LED integrado está conectado al pin 2.
  pinMode(LED_BUILTIN, OUTPUT);
}
 
void loop() {
  // Encender el LED (Está conectado con una resistencia pull-up,
  // por eso se enciende si el pin está a nivel bajo)
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000); // Esperar un segundo
  // Apagar el LED
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000); // Esperar un segundo
}
Animación Blink NodeMCU

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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define LED_BUILTIN 2
#define BUTTON_BUILTIN 0
 
void setup() {
  // El LED integrado está conectado al pin 2.
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(BUTTON_BUILTIN, INPUT);
}
 
void loop() {
  // Leer el estado del botón. Cuando está pulsado el pin se pone a nivel bajo
  int estado = digitalRead(BUTTON_BUILTIN);
  // Configurar el LED de acuerdo al estado del botón
  digitalWrite(LED_BUILTIN, estado);
}
Animación boton NodeMCU

¿A qué no te ha parecido complicado? ¿A que el código te suena? Como ya te he comentado, hay pocas diferencias entre programar un Arduino y un NodeMCU o cualquier otra placa basada en el ESP8266.

Acceder a una web desde NodeMCU

Cuando tenemos un módulo como el NodeMCU que puede conectarse a Internet mediante WiFi, lo primero que se nos puede ocurrir hacer con él es acceder a datos en la red. Esto podemos hacerlo, por ejemplo, accediendo a una API REST mediante protocolo HTTP.

Las librerías que incluye el framework de Arduino para el ESP8266 hacen que esto sea una tarea muy sencilla.

Conectar a la red WiFi

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
2
WiFi.mode(WIFI_STA); // Modo cliente WiFi
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
3
4
5
6
7
8
9
10
#define HOST "api.wunderground.com"
#define APIKEY = "tu clave de la API" // Necesitas obtener tu clave API en
                                      // https://www.wunderground.com/weather/api/
WiFiClient client;
client.connect(host, 80); // Conectamos al puerto HTTP
String url = "/api/" + APIKEY + "/conditions/lang:SP/q/autoip.json"
// Enviamos la petición
client.print(String("GET ") + url + " HTTP/1.1\r\n" +
"Host: " + HOST+ "\r\n" +
"Connection: close\r\n\r\n");

Ahora ya podemos esperar y leer la respuesta.

1
2
3
4
5
6
7
8
9
10
11
12
while (client.available() == 0) { // Mientras no se ha recibido ningún dato
  if (millis() - timeout > 5000) { // Tiempo de espera de 5 segundos
  Serial.println(">>> Superado el tiempo de espera !");
  client.stop(); return; }
}
 
// Leemos la respuesta y la enviamos al monitor serie
while(client.available()){
  // Mientras quedan datos por leer
  String line = client.readStringUntil('\r');
  Serial.print(line);
}

Si todo ha ido correctamente, esto es lo que vamos a ver en el monitor serie:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
{
  "response": {
    "version": "0.1",
    "termsofService": "http://www.wunderground.com/weather/api/d/terms.html",
    "features": {
      "conditions": 1
    }
  },
  "current_observation": {
    "image": {
      "url": "http://icons.wxug.com/graphics/wu2/logo_130x80.png",
      "title": "Weather Underground",
      "link": "http://www.wunderground.com"
    },
    "display_location": {
      "full": "Madrid, Spain",
      "city": "Madrid",
      "state": "M",
      "state_name": "Spain",
      "country": "SP",
      "country_iso3166": "ES",
      "zip": "00000",
      "magic": "1",
      "wmo": "08221",
      "latitude": "40.45000076",
      "longitude": "-3.54999995",
      "elevation": "609.0"
    },
    "observation_location": {
      "full": "Madrid, ",
      "city": "Madrid",
      "state": "",
      "country": "ES",
      "country_iso3166": "ES",
      "latitude": "40.45000076",
      "longitude": "-3.54999995",
      "elevation": "1909 ft"
    },
    "estimated": {},
    "station_id": "LEMD",
    "observation_time": "Last Updated on Marzo 23, 8:30 AM CET",
    "observation_time_rfc822": "Thu, 23 Mar 2017 08:30:00 +0100",
    "observation_epoch": "1490254200",
    "local_time_rfc822": "Thu, 23 Mar 2017 09:02:09 +0100",
    "local_epoch": "1490256129",
    "local_tz_short": "CET",
    "local_tz_long": "Europe/Madrid",
    "local_tz_offset": "+0100",
    "weather": "Parcialmente nublado",
    "temperature_string": "32 F (0 C)",
    "temp_f": 32,
    "temp_c": 0,
    "relative_humidity": "93%",
    "wind_string": "From the SSE at 8 MPH",
    "wind_dir": "SSE",
    "wind_degrees": 150,
    "wind_mph": 8,
    "wind_gust_mph": 0,
    "wind_kph": 13,
    "wind_gust_kph": 0,
    "pressure_mb": "1011",
    "pressure_in": "29.86",
    "pressure_trend": "0",
    "dewpoint_string": "30 F (-1 C)",
    "dewpoint_f": 30,
    "dewpoint_c": -1,
    "heat_index_string": "NA",
    "heat_index_f": "NA",
    "heat_index_c": "NA",
    "windchill_string": "25 F (-4 C)",
    "windchill_f": "25",
    "windchill_c": "-4",
    "feelslike_string": "25 F (-4 C)",
    "feelslike_f": "25",
    "feelslike_c": "-4",
    "visibility_mi": "6.2",
    "visibility_km": "10.0",
    "solarradiation": "--",
    "UV": "1",
    "precip_1hr_string": "-9999.00 in (-9999.00 mm)",
    "precip_1hr_in": "-9999.00",
    "precip_1hr_metric": "--",
    "precip_today_string": "0.00 in (0.0 mm)",
    "precip_today_in": "0.00",
    "precip_today_metric": "0.0",
    "icon": "partlycloudy",
    "icon_url": "http://icons.wxug.com/i/c/k/partlycloudy.gif",
    "forecast_url": "http://www.wunderground.com/global/stations/08221.html",
    "history_url": "http://www.wunderground.com/history/airport/LEMD/2017/3/23/DailyHistory.html",
    "ob_url": "http://www.wunderground.com/cgi-bin/findweather/getForecast?query=40.45000076,-3.54999995",
    "nowcast": ""
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
{
  "response": {
    "version": "0.1",
    "termsofService": "http://www.wunderground.com/weather/api/d/terms.html",
    "features": {
      "conditions": 1
    }
  },
  "current_observation": {
    "image": {
      "url": "http://icons.wxug.com/graphics/wu2/logo_130x80.png",
      "title": "Weather Underground",
      "link": "http://www.wunderground.com"
    },
    "display_location": {
      "full": "Madrid, Spain",
      "city": "Madrid",
      "state": "M",
      "state_name": "Spain",
      "country": "SP",
      "country_iso3166": "ES",
      "zip": "00000",
      "magic": "1",
      "wmo": "08221",
      "latitude": "40.45000076",
      "longitude": "-3.54999995",
      "elevation": "609.0"
    },
    "observation_location": {
      "full": "Madrid, ",
      "city": "Madrid",
      "state": "",
      "country": "ES",
      "country_iso3166": "ES",
      "latitude": "40.45000076",
      "longitude": "-3.54999995",
      "elevation": "1909 ft"
    },
    "estimated": {},
    "station_id": "LEMD",
    "observation_time": "Last Updated on Marzo 23, 8:30 AM CET",
    "observation_time_rfc822": "Thu, 23 Mar 2017 08:30:00 +0100",
    "observation_epoch": "1490254200",
    "local_time_rfc822": "Thu, 23 Mar 2017 09:02:09 +0100",
    "local_epoch": "1490256129",
    "local_tz_short": "CET",
    "local_tz_long": "Europe/Madrid",
    "local_tz_offset": "+0100",
    "weather": "Parcialmente nublado",
    "temperature_string": "32 F (0 C)",
    "temp_f": 32,
    "temp_c": 0,
    "relative_humidity": "93%",
    "wind_string": "From the SSE at 8 MPH",
    "wind_dir": "SSE",
    "wind_degrees": 150,
    "wind_mph": 8,
    "wind_gust_mph": 0,
    "wind_kph": 13,
    "wind_gust_kph": 0,
    "pressure_mb": "1011",
    "pressure_in": "29.86",
    "pressure_trend": "0",
    "dewpoint_string": "30 F (-1 C)",
    "dewpoint_f": 30,
    "dewpoint_c": -1,
    "heat_index_string": "NA",
    "heat_index_f": "NA",
    "heat_index_c": "NA",
    "windchill_string": "25 F (-4 C)",
    "windchill_f": "25",
    "windchill_c": "-4",
    "feelslike_string": "25 F (-4 C)",
    "feelslike_f": "25",
    "feelslike_c": "-4",
    "visibility_mi": "6.2",
    "visibility_km": "10.0",
    "solarradiation": "--",
    "UV": "1",
    "precip_1hr_string": "-9999.00 in (-9999.00 mm)",
    "precip_1hr_in": "-9999.00",
    "precip_1hr_metric": "--",
    "precip_today_string": "0.00 in (0.0 mm)",
    "precip_today_in": "0.00",
    "precip_today_metric": "0.0",
    "icon": "partlycloudy",
    "icon_url": "http://icons.wxug.com/i/c/k/partlycloudy.gif",
    "forecast_url": "http://www.wunderground.com/global/stations/08221.html",
    "history_url": "http://www.wunderground.com/history/airport/LEMD/2017/3/23/DailyHistory.html",
    "ob_url": "http://www.wunderground.com/cgi-bin/findweather/getForecast?query=40.45000076,-3.54999995",
    "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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
// Esta es la librería para utilizar las funciones de red del ESP8266
#include <ESP8266WiFi.h>
 
const char* ssid = "SSID"; // Rellena con el nombre de tu red WiFi
const char* password = "Contraseña"; // Rellena con la contraseña de tu red WiFi
 
const char* host = "api.wunderground.com";
const char* apiKey = "tu clave API de wunderground.com"; // Puedes obtenerla en
                                                         // https://www.wunderground.com/weather/api/
 
void setup() {
  Serial.begin(115200);
  delay(10);
 
  // Conectamos a la red WiFi
 
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  /* Configuramos el ESP8266 como cliente WiFi. Si no lo hacemos
     se configurará como cliente y punto de acceso al mismo tiempo */
  WiFi.mode(WIFI_STA); // Modo cliente WiFi
  WiFi.begin(ssid, password);
 
  // Esperamos a que estemos conectados a la red WiFi
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
 
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP()); // Mostramos la IP
}
 
void loop() {
 
  Serial.print("connecting to ");
  Serial.println(host);
  // Creamos el cliente
  WiFiClient client;
  const int httpPort = 80; // Puerto HTTP
  if (!client.connect(host, httpPort)) {
    // ¿hay algún error al conectar?
    Serial.println("Ha fallado la conexión");
    return;
  }
  // Creamos la URL para la petición
  String url = "/api/";
  url += apiKey;
  url += "/conditions/lang:SP/q/autoip.json";
  Serial.print("URL de la petición: http://");
  Serial.print(host);
  Serial.print(":");
  Serial.print(httpPort);
  Serial.println(url);
  // Enviamos la petición
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
         "Host: " + host + "\r\n" +
         "Connection: close\r\n\r\n");
  unsigned long timeout = millis();
  while (client.available() == 0) {
    if (millis() - timeout > 5000) {
      Serial.println(">>> Superado el tiempo de espera !");
      client.stop();
      return;
    }
  }
 
  // Consutar la memoria libre
  // Quedan un poco más de 40 kB
  Serial.printf("\nMemoria libre en el ESP8266: %d Bytes\n\n",ESP.getFreeHeap());
  // Leemos la respuesta y la enviamos al monitor serie
  while(client.available()){
    String line = client.readStringUntil('\r');
    Serial.print(line);
  }
  Serial.println();
  Serial.println("Cerrando la conexión");
 
  while(1){
    delay(0); // Siempre que hay un bucle que pueda durar mucho tiempo
              // hay que llamar a la función delay() para atender a los
              // procesos de la conexión WiFi. Si no se hace el ESP8266
              // generará un error y se reiniciará a los pocos segundos
  }
}

¿Y si tengo que conectarme usando HTTP seguro?

Cada vez más sitios web exigen que las conexiones utilicen el protocolo seguro HTTPS. ¿Qué puedo hacer si el API al que tengo que acceder me obliga a usar comunicación segura?

El ESP8266 no tiene hardware de seguridad para encriptar la comunicación por lo tanto, NodeMCU tampoco. Pero la librería WiFi incluye funciones de encriptación por software. Gracias a esto podremos acceder de una forma muy similar a sitios HTTPS.

Solamente hay que cambiar la declaración WiFiClient client por WiFiClientSecure client. Adicionalmente para asegurarnos de que estamos conectándonos realmente al servidor que queremos se puede comprobar que el certificado es el correcto, comprobando que la huella corresponde con la esperada.

Pero esto tiene un inconveniente. La encriptación y gestión de los certificados mediante software consume alrededor de 20 kB. Esto representa prácticamente la mitad de la memoria disponible para nuestro programa.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
// Esta es la librería para utilizar las funciones de red del ESP8266
#include <ESP8266WiFi.h>
 
const char* ssid = "SSID"; // Rellena con el nombre de tu red WiFi
const char* password = "Contraseña"; // Rellena con la contraseña de tu red WiFi
 
const char* host = "api.wunderground.com";
const char* apiKey = "tu clave API de wunderground.com"; // Puedes obtenerla en
                                         // https://www.wunderground.com/weather/api/
 
// Huella digital del certificado del servidor https://www.wunderground.com
const char * fingerprint = "a9 1f b9 fe 35 b8 38 b9 54 67 e7 34 52 8a 24 d4 17 29 fa 32";
 
void setup() {
  Serial.begin(115200);
  delay(10);
 
  // Conectamos a la red WiFi
 
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  /* Configuramos el ESP8266 como cliente WiFi. Si no lo hacemos
  se configurará como cliente y punto de acceso al mismo tiempo */
  WiFi.mode(WIFI_STA); // Modo cliente WiFi
  WiFi.begin(ssid, password);
 
  // Esperamos a que estemos conectados a la red WiFi
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
 
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP()); // Mostramos la IP
}
 
void loop() {
 
  Serial.print("connecting to ");
  Serial.println(host);
  // Creamos el cliente
  WiFiClientSecure client;
  const int httpPort = 443; // Puerto HTTPS
  if (!client.connect(host, httpPort)) {
    // ¿hay algún error al conectar?
    Serial.println("Ha fallado la conexión");
    return;
  }
 
  // Verificamos que el certificado coincide con el esperado
  if(client.verify(fingerprint,host)){
    Serial.println("El certificado es correcto");
  } else {
    Serial.println("Error de certificado");
  }
  // Creamos la URL para la petición
  String url = "/api/";
  url += apiKey;
  url += "/conditions/lang:SP/q/autoip.json";
  Serial.print("URL de la petición: https://");
  Serial.print(host);
  Serial.print(":");
  Serial.print(httpPort);
  Serial.println(url);
  // Enviamos la petición
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                "Host: " + host + "\r\n" +
                "Connection: close\r\n\r\n");
  unsigned long timeout = millis();
  while (client.available() == 0) {
    if (millis() - timeout > 5000) {
      Serial.println(">>> Superado el tiempo de espera !");
      client.stop();
      return;
    }
  }
 
  // Consutar la memoria libre
  // Utilizando HTTPS se necesitan unos 20 kB de memoria libres adicionales
  Serial.printf("\nMemoria libre en el ESP8266: %d Bytes\n\n",ESP.getFreeHeap());
  // Leemos la respuesta y la enviamos al monitor serie
  while(client.available()){
    String line = client.readStringUntil('\r');
    Serial.print(line);
  }
  Serial.println();
  Serial.println("Cerrando la conexión");
 
  while(1){
    delay(0); // Siempre que hay un bucle que pueda durar mucho tiempo
              // hay que llamar a la función delay() para atender a los
              // procesos de la conexión WiFi. Si no se hace el ESP8266
              // generará un error y se reiniciará a los pocos segundos
   }
}

Conclusiones cómo programar NodeMCU

El microcontrolador ESP8266 es un dispositivo muy versátil y relativamente potente. Tiene también algunas limitaciones. Pero su precio hace que siga siendo el microcontrolador elegido por muchos para desarrollar proyectos del IoT.

Con NodeMCU, programar el ESP8266 es mucho más sencillo que hacerlo con módulos como el ESP01.

La integración en el IDE de Arduino evita la necesidad de tener que montar un entorno de desarrollo para utilizar la SDK de Espressif.

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.

La comunicación WiFi es la gran capacidad de este pequeño chip. En los ejemplos os he enseñado lo necesario para comenzar a usarlo. Si no te ha quedado claro todo lo referente a este último punto no te preocupes, en las siguientes entradas te contaré lo pasos para controlar las diferentes capacidades del ESP8266.

¿Que opinas de la placa NodeMCU?

¿Tienes experiencia con alguna otra placa con WiFi como Arduino MKR1000?

Déjame tus comentarios aquí abajo, muchas gracias.

kicad

KiCad diseña y fabrica tu primera PCB

Si alguna vez has desmontado algún equipo electrónico, debes haber visto en su interior una tarjeta que soporta una gran cantidad de componentes. Se … [+ info...]

Fuentes-de-alimentación

Fuente de alimentación

Creo que estarás de acuerdo conmigo si digo que, para la subsistencia de un ser humano, después del aire, lo más importante es el agua y la comida; es … [+ info...]

Motor-AC-asincrono-sincrono-monofasico-trifasico

El mundo del Motor AC

Es incomprensible que uno de los mejores inventos del ser humano pase casi completamente desapercibido. Y es que si le preguntas a muchas personas si … [+ info...]

Copyright © 2023 · Programar Fácil · Aviso legal

Utilizamos cookies propios y de terceros para mejorar nuestros servicios y experiencia de usuario. Si continua navegando, consideramos que acepta su uso.Aceptar Política de privacidad y cookies
Política de cookies

Privacy Overview

This website uses cookies to improve your experience while you navigate through the website. Out of these, the cookies that are categorized as necessary are stored on your browser as they are essential for the working of basic functionalities of the website. We also use third-party cookies that help us analyze and understand how you use this website. These cookies will be stored in your browser only with your consent. You also have the option to opt-out of these cookies. But opting out of some of these cookies may affect your browsing experience.
Necessary
Siempre activado
Necessary cookies are absolutely essential for the website to function properly. This category only includes cookies that ensures basic functionalities and security features of the website. These cookies do not store any personal information.
Non-necessary
Any cookies that may not be particularly necessary for the website to function and is used specifically to collect user personal data via analytics, ads, other embedded contents are termed as non-necessary cookies. It is mandatory to procure user consent prior to running these cookies on your website.
GUARDAR Y ACEPTAR