Currículo: aquí encontrarás el desarrollo detallado de los contenidos que forman parte de la primera sesión del Curso avanzado de pensamiento computacional, robótica e internet de las cosas, impartido por el CEP de Huelva – Isla Cristina.
Tabla de contenidos
- 1. ¿Qué es IoT?
- 2. ¿Por qué debemos estudiar IoT?
- 3. Primera conexión de Arduino a Internet
- 4. Enviando datos a la nube
- 5. Cuando Arduino es la propia nube.
Hasta ahora hemos seguido un recorrido muy intencionado. En la primera sesión trabajamos el pensamiento computacional. Aprendimos que antes de programar una máquina necesitamos aprender a pensar como quien diseña una solución: dividir problemas grandes en otros más pequeños, identificar patrones, abstraer lo importante y construir algoritmos.
Después dimos un paso hacia el mundo físico con Micro:bit. Ahí comenzamos a ver algo fundamental: la programación no tiene por qué quedarse dentro de la pantalla. Un programa puede interactuar con la realidad, leer sensores, mostrar información, emitir sonidos o responder a eventos del entorno.
En la tercera sesión dimos otro salto con Arduino Uno R4 WiFi. Empezamos a trabajar con una plataforma mucho más cercana al mundo profesional, entendiendo cómo dar instrucciones a una placa electrónica para controlar componentes reales.
Hoy llegamos a un nuevo nivel. Hasta ahora nuestras placas podían pensar, podían tomar decisiones e incluso podían interactuar con el entorno. Pero aún les faltaba algo muy útil: comunicarse con el mundo.
Eso es precisamente lo que vamos a descubrir hoy.
1. ¿Qué es IoT?
Cuando hablamos de internet de las cosas, o IoT (Internet of Things), nos referimos a objetos físicos capaces de conectarse a Internet para enviar información, recibir instrucciones o interactuar con otros dispositivos.
Dicho de una forma muy sencilla: hablamos de objetos cotidianos que, gracias a la electrónica, la programación y la conectividad, dejan de ser objetos “pasivos” para convertirse en objetos “inteligentes”.
Un termómetro tradicional mide temperatura. Un termómetro con IoT mide temperatura, la envía a Internet, la almacena, genera gráficas, lanza alertas si algo va mal y puede incluso activar automáticamente otros sistemas.
Ahí está la gran diferencia.
2. ¿Por qué debemos estudiar IoT?
Porque ya forma parte de nuestra vida diaria, aunque muchas veces no seamos conscientes de ello.
✅ Cuando una pulsera deportiva registra nuestros pasos y sincroniza los datos con el móvil, estamos usando IoT.
✅ Cuando un coche moderno detecta una avería y envía información al fabricante, estamos usando IoT.
✅ Cuando un sistema de climatización detecta que no hay nadie en una habitación y reduce el consumo energético, estamos usando IoT.
✅ Cuando una explotación agrícola mide la humedad del suelo y activa automáticamente el riego, estamos usando IoT.
¿Qué elementos necesita un sistema IoT?
Para que exista un sistema IoT normalmente necesitamos cuatro elementos:
- Sensorización: el dispositivo recoge información de su entorno, como temperatura, luz, movimiento, sonido o humedad.
- Procesamiento: un microcontrolador, como Arduino Uno R4 WiFi, interpreta esa información y toma decisiones.
- Conectividad: el dispositivo se conecta a Internet mediante WiFi, Bluetooth u otros sistemas de comunicación.
- Visualización y/o actuación: los datos se almacenan, se representan en gráficas, generan alertas y/o activan otros dispositivos.
Es decir, no se trata simplemente de medir. Se trata de medir, comunicar y actuar.
3. Primera conexión de Arduino a Internet
Antes de enviar datos a la nube o construir proyectos IoT más complejos, necesitamos comprobar algo previamente: que nuestra placa controladora es capaz de conectarse correctamente a una red WiFi.
En esta primera práctica no vamos a usar sensores ni plataformas externas. Nuestro único objetivo es que Arduino intente conectarse a Internet y nos diga a través del monitor serie si lo ha conseguido.
Vamos a intentar escribir el programa más simple que podemos usar para hacer esta comprobación:
#includechar ssid[] = "NOMBRE_DE_TU_WIFI"; char password[] = "CONTRASEÑA_DE_TU_WIFI"; void setup() { Serial.begin(9600); Serial.println("Iniciando conexion WiFi..."); while (WiFi.begin(ssid, password) != WL_CONNECTED) { Serial.println("Intentando conectar..."); delay(3000); } Serial.println("Conexion realizada correctamente."); Serial.println("Arduino ya tiene acceso a Internet."); } void loop() { // Aquí directamente usaremos la conexión a Internet }
Vamos a analizarlo paso a paso.
La primera línea:
#include
Le dice a Arduino que cargue la librería de red inalámbrica que utiliza la Arduino Uno R4 WiFi.
Una librería es como una caja de herramientas ya preparada que nos evita programar todo desde cero.
En este caso, esa caja de herramientas contiene todo lo necesario para que la placa pueda conectarse a redes WiFi.
Después encontramos esto:
char ssid[] = "NOMBRE_DE_TU_WIFI"; char password[] = "CONTRASEÑA_DE_TU_WIFI";
Aquí estamos guardando dos datos: el nombre de la red WiFi (ssid) y su contraseña (password).
Es exactamente la misma información que introduciríamos en un móvil o en un portátil cuando nos conectamos a Internet.
Ahora entramos en setup():
Serial.begin(9600);
Esto activa la comunicación con el ordenador a través del monitor serie.
Gracias a esto, Arduino podrá “hablarnos” y mostrarnos mensajes en pantalla.
Es decir, aunque la placa no tenga pantalla propia, podremos saber qué está ocurriendo internamente.
Después aparece:
Serial.println("Iniciando conexion WiFi...");Aquí simplemente mostramos un mensaje para saber que el proceso ha comenzado.
Y ahora llega la parte importante:
while (WiFi.begin(ssid, password) != WL_CONNECTED)
Aquí estamos diciendo: “Mientras no consigas conectarte correctamente, sigue intentándolo.”
Es como si Arduino dijera: “Todavía no tengo Internet… voy a volver a probar.“
Si falla, ejecuta:
Serial.println("Intentando conectar...");
delay(3000);Es decir: muestra un mensaje y espera 3 segundos antes de volver a intentarlo.
Esto evita que la placa haga miles de intentos por segundo.
Finalmente, cuando lo consigue:
Serial.println("Conexion realizada correctamente.");
Serial.println("Arduino ya tiene acceso a Internet.");En ese momento sabemos que la placa está conectada.
Y el loop() queda vacío porque en esta práctica solo queríamos comprobar la conexión.
Si todo funciona correctamente, veremos algo parecido a esto:
4. Enviando datos a la nube
Muy bien, sabemos como conectar nuestra placa a Internet, y también sabemos cómo tomar datos de los distintos sensores.
Así que, estamos preparados para enviar los datos a la nube, con la idea de que cualquiera que quiera consultarlos, pueda hacerlo desde una aplicación móvil, un ordenador o una tablet desde cualquier parte del mundo.
Existen montones de plataformas que nos permiten realizar esto, pero quizás la más sencilla de utilizar sea la popular ThingSpeak.
En este punto, debemos ir a la web de este servicio y registrarnos.
En la página que se nos abrirá, pulsamos en el botón verde:
Escribimos nuestro correo electrónico y pulsamos en Create Account.
Escribimos la contraseña, la confirmamos y Siguiente.
Introducimos el código que nos habrá llegado a nuestro correo electrónico, aceptamos el acuerdo, pulsamos en Siguiente y rellenamos los datos personales que nos piden (ojo con esos datos porque no pueden ser cualesquiera).
Ahora, lo que haremos será crear un canal:
Lo único que necesitamos rellenar es: el nombre del canal y al menos un campo. El nombre del canal hace referencia al proyecto que estamos desarrollando, y Field es cada uno de los sensores que tiene nuestro proyecto. Cada Field tendrá su propia gráfica.
Lo dejamos así y pulsamos el botón inferior:
Lo que estás viendo es ya el panel de control de tu proyecto. Ahí puedes colocar todas las gráficas que quieras y jugar con los datos como te interese.
Lo único que nos queda conocer para saber cómo Arduino puede hacerle llegar los datos, está en la pestaña API Keys:
Localizamos la Write API Key (podemos generar una nueva si queremos) y la guardamos, porque la vamos a necesitar luego en Arduino IDE.
Si miras un poco más abajo a la derecha verás que se indica cómo debemos hacer para enviar datos a tu proyecto en la nube:
En el enlace Learn More, tienes mucha más información sobre cómo hacer esto.
Bueno, tenemos una plataforma en la nube preparada para recibir nuestros datos.
Ya lo único que nos queda es escribir nuestro programa en Arduino para que envíe datos a esa plataforma y que podamos visualizarlos de manera remota.
Vamos a ello.
Este programa va a generar un número aleatorio entre 0 y 99 para simular lecturas de la temperatura de un sensor y va a enviar el dato a la nube cada 20s (porque la cuenta gratuita de ThingSpeak no nos permite enviar datos con más frecuencia).
Veamos el código con comentarios auto explicativos:
// Cargamos la librería que permite usar el WiFi de la Arduino UNO R4 WiFi #include// Nombre de la red WiFi a la que queremos conectarnos char ssid[] = "EL-ID-DE-TU-WIFI"; // Contraseña de la red WiFi char pass[] = "LA-CONTRASEÑA-DE-TU-WIFI"; // Dirección del servidor al que enviaremos los datos // En este caso usamos la plataforma ThingSpeak char server[] = "api.thingspeak.com"; // Clave privada que autoriza a nuestra placa a escribir datos en nuestro canal String apiKey = "LA-WRITE-API-KEY-QUE-COPIASTE"; // Creamos un cliente de red. // Este objeto será quien abra la conexión con el servidor de Internet. WiFiClient client; void setup() { // Iniciamos la comunicación con el ordenador // para poder ver mensajes en el monitor serie Serial.begin(9600); // Mientras no consigamos conectarnos al WiFi, // seguimos intentándolo while (WiFi.begin(ssid, pass) != WL_CONNECTED) { // Mostramos un mensaje informativo Serial.println("Intentando conectar a WiFi..."); // Esperamos 3 segundos antes de volver a probar delay(3000); } // Si hemos salido del bucle, significa que la conexión ha funcionado Serial.println("Conectado a WiFi."); } void loop() { // Generamos un número aleatorio entre 0 y 99 // Aquí podría ir un sensor real, pero para empezar // usamos datos simulados int dato = random(0, 100); // Intentamos conectarnos con el servidor ThingSpeak // Puerto 80 = comunicación web HTTP if (client.connect(server, 80)) { // Construimos la URL que enviará el dato // Ejemplo real: // /update?api_key=XXXXX&field1=42 String url = "/update?api_key=" + apiKey + "&field1=" + String(dato); // Enviamos una petición web HTTP al servidor client.println("GET " + url + " HTTP/1.1"); // Indicamos el servidor al que estamos llamando client.println("Host: api.thingspeak.com"); // Le decimos al servidor que cierre la conexión // cuando termine de responder client.println("Connection: close"); // Línea en blanco obligatoria en HTTP para indicar // que la petición ha terminado client.println(); // Mostramos en el monitor serie qué valor estamos enviando Serial.print("Dato enviado: "); Serial.println(dato); // Mostramos la respuesta del servidor Serial.println("Respuesta de ThingSpeak:"); // Mientras el servidor siga conectado // o siga enviando información... while (client.connected() || client.available()) { // Si hay datos disponibles... if (client.available()) { // Leemos un carácter char c = client.read(); // Lo mostramos en pantalla Serial.print(c); } } // Cerramos la conexión con el servidor client.stop(); } else { // Si no hemos podido conectar con ThingSpeak Serial.println("No se pudo conectar con ThingSpeak."); } // Separador visual para distinguir cada envío Serial.println(); Serial.println("--------------------"); // Esperamos 20 segundos antes del siguiente envío // ThingSpeak gratuito requiere al menos 15 segundos delay(20000); }
Despés de cargar el programa en la placa comenzará a enviar un dato cada 20s (recuerda un valor aleatorio entre 0 y 99, pero podría ser la lectura de cualquier sensor que se te ocurra).
Luego desde cualquier parte del mundo, vas a ThingSpeak, entras en tu Channel y miras la gráfica para ver qué está pasando:
5. Cuando Arduino es la propia nube.
Arduino Uno R4 WiFi puede actuar tanto como cliente (como habéis hecho con ThingSpeak) como servidor web.
Hasta ahora vuestra placa estaba actuando como cliente: Arduino iniciaba la comunicación y enviaba datos a un servidor externo como ThingSpeak.
Lo que hacíamos era: Arduino → Internet → servidor externo
Pero también puede funcionar al revés: Móvil/ordenador → Arduino
En ese caso, Arduino levanta un pequeño servidor web dentro de vuestra red WiFi, y cualquier dispositivo conectado a esa misma red puede abrir un navegador y acceder a la placa mediante su dirección IP.
Por ejemplo, podrías escribir en el navegador:
y ver una página generada directamente por Arduino.
¿Qué puede hacer ese servidor web?
Aunque no tenga la potencia de un servidor tradicional, para proyectos de IoT en red local ofrece muchísimo juego:
✅ Podemos mostrar sensores en tiempo real: temperatura, presión, CO2, humedad,…
✅ Podemos activar actuadores desde el móvil: activar alarma, mover servomotor, abrir puerta,…
✅ Podemos construir cualquier sistema domótico que se te ocurra.
En otras palabras: la placa no solo envía datos, también puede recibir órdenes desde una interfaz web.
Y esto tiene una ventaja enorme: no es necesario “subir datos privados a la nube de un tercero”.
Vamos a escribir el código que nos permite conseguir esto:
#includechar ssid[] = "EL-ID-DE-TU-WIFI"; char pass[] = "LA-CONTRASEÑA-DE-TU-WIFI"; WiFiServer server(80); void setup() { Serial.begin(9600); delay(2000); while (WiFi.begin(ssid, pass) != WL_CONNECTED) { Serial.println("Conectando..."); delay(3000); } server.begin(); Serial.println("Servidor iniciado"); Serial.print("Direccion IP: "); Serial.println(WiFi.localIP()); } void loop() { WiFiClient client = server.available(); if (client) { Serial.println("Cliente conectado"); client.println("HTTP/1.1 200 OK"); client.println("Content-Type: text/html"); client.println(); client.println(" Hola desde Arduino
"); client.println("Tu placa esta funcionando como servidor web.
"); delay(100); client.stop(); Serial.println("Cliente desconectado"); } }
Sube el programa a la placa.
Abre el monitor serie.
Arduino mostrará algo parecido a:
Luego, desde un móvil o un portátil conectado al mismo WiFi, abres el navegador y escribes esa IP.
Y de repente aparece una página web servida directamente por la placa.
Encender un LED desde el servidor web de Arduino
Lo realmente interesante de esta opción de configurar Arduino como un servidor web, no está tanto en que sea capaz de recoger datos de sensores de toda clase de dispositivos presentes en una red local y poderlos visualizarlos en el móvil o en una tablet, sino en poder activar o desactivar dispositivos desde la propia web.
Ahora nuestra Arduino Uno R4 WiFi no solo será un servidor web, sino que además permitirá controlar un dispositivo físico desde el navegador. En este caso, un LED (pero podría ser cualquier cosa que se os ocurra).
La idea es muy potente: abrimos una página web desde el móvil → pulsamos un enlace → Arduino recibe la petición → Arduino activa o desactiva un actuador.
Eso es IoT puro.
Para probarlo vamos a usar el LED integrado de la propia placa, conectado internamente al pin 13. Así no hace falta montar ningún circuito adicional y vamos más rápido.
#includechar ssid[] = "EL-ID-DE-TU-WIFI"; char pass[] = "LA-CONTRASEÑA-DE-TU-WIFI"; // Creamos el servidor web en el puerto 80 WiFiServer server(80); // Estado del LED bool ledEncendido = false; void setup() { // Configuramos el LED integrado como salida pinMode(LED_BUILTIN, OUTPUT); // Iniciamos monitor serie Serial.begin(9600); delay(2000); // Conectamos al WiFi while (WiFi.begin(ssid, pass) != WL_CONNECTED) { Serial.println("Conectando a WiFi..."); delay(3000); } // Iniciamos el servidor web server.begin(); Serial.println("Servidor iniciado."); Serial.print("Abre esta IP en el navegador: "); Serial.println(WiFi.localIP()); } void loop() { // Esperamos conexiones desde navegador WiFiClient client = server.available(); if (client) { Serial.println("Cliente conectado"); String peticion = ""; // Leemos la petición del navegador while (client.connected()) { if (client.available()) { char c = client.read(); peticion += c; // Cuando termina la primera línea HTTP if (c == '\n') { // Si la URL contiene /ON, encendemos LED if (peticion.indexOf("GET /ON") >= 0) { digitalWrite(LED_BUILTIN, HIGH); ledEncendido = true; Serial.println("LED encendido"); } // Si la URL contiene /OFF, apagamos LED if (peticion.indexOf("GET /OFF") >= 0) { digitalWrite(LED_BUILTIN, LOW); ledEncendido = false; Serial.println("LED apagado"); } // Enviamos la página web client.println("HTTP/1.1 200 OK"); client.println("Content-Type: text/html"); client.println(); client.println(""); client.println(""); client.println(" Servidor IoT con Arduino
"); if (ledEncendido) { client.println("LED ENCENDIDO
"); } else { client.println("LED APAGADO
"); } client.println("
"); client.println(""); client.println("
"); client.println(""); client.println(""); client.println(""); break; } } } delay(100); client.stop(); Serial.println("Cliente desconectado"); Serial.println("----------------------"); } }
Subimos el programa a la Arduino Uno R4 WiFi.
En el monitor serie aparecerá algo parecido a:
Ahora cogemos cualquier móvil, tablet u ordenador conectado al mismo WiFi, escribimos esa IP en el navegador y veremos una página con dos botones:
Cuando pulsemos:
- ENCENDER → el LED de la placa se ilumina.
- APAGAR → el LED se apaga.
Mover un servomotor desde el servidor web de Arduino
El ejemplo anterior lo podemos extender todo lo que queramos. Por ejemplo, podríamos modificar nuestro programa anterior para tener 5 botones que muevan un servomotor a 5 posiciones distintas simplemente pasando en la URL el número de grados que queremos moverlo.
Así:
#include#include char ssid[] = "EL-ID-DE-TU-WIFI"; char pass[] = "LA-CONTRASEÑA-DE-TU-WIFI"; WiFiServer server(80); Servo miServo; void setup() { miServo.attach(6); Serial.begin(9600); delay(2000); while (WiFi.begin(ssid, pass) != WL_CONNECTED) { Serial.println("Conectando a WiFi..."); delay(3000); } server.begin(); Serial.println("Servidor iniciado."); Serial.print("Abre esta IP en el navegador: "); Serial.println(WiFi.localIP()); } void loop() { WiFiClient client = server.available(); if (client) { Serial.println("Cliente conectado"); String peticion = ""; while (client.connected()) { if (client.available()) { char c = client.read(); peticion += c; if (c == '\n') { // Si la URL contiene /0, movemos a 0º if (peticion.indexOf("GET /0") >= 0) { miServo.write(0); // ponemos el servo a 0º Serial.println("Servo a 0 grados"); } // Si la URL contiene /45, movemos a 45º if (peticion.indexOf("GET /45") >= 0) { miServo.write(45); // ponemos el servo a 45º Serial.println("Servo a 45 grados"); } // Si la URL contiene /90, movemos a 90º if (peticion.indexOf("GET /90") >= 0) { miServo.write(90); // ponemos el servo a 45º Serial.println("Servo a 90 grados"); } // Si la URL contiene /180, movemos a 180º if (peticion.indexOf("GET /180") >= 0) { miServo.write(180); // ponemos el servo a 180º Serial.println("Servo a 180 grados"); } // Enviamos la página web client.println("HTTP/1.1 200 OK"); client.println("Content-Type: text/html"); client.println(); client.println(""); client.println(""); client.println(""); client.println(" Servidor IoT con Arduino
"); client.println("
"); client.println(" "); client.println(" "); client.println(" "); client.println(" "); client.println("
"); client.println(""); break; } } } delay(100); client.stop(); Serial.println("Cliente desconectado"); Serial.println("----------------------"); } }
Además, la usabilidad de estas soluciones en red local aumentan mucho cuando usamos el móvil para acceder a la web y pulsar los botones.
A partir de aquí, ya puedes programar cualquier cosa que se te ocurra.
Eso es exactamente lo que ocurre en muchos sistemas domóticos modernos: luces, persianas, climatización, cerraduras o alarmas pueden controlarse desde una interfaz web o una app.
Las posibilidades son infinitas.
Espero que hayas aprovechado estos contenidos, que los repases y por supuesto, que los pongas en práctica en tu aula.
Si quieres compartir con nosotros tu experiencia, no dudes en dejar un comentario.
👋 Hasta la próxima sesión.