2024

Práctica 5.2.
Sistemas integrados
de hardware libre.

MMQ05. ROBOTS Y MANIPULADORES.

ANA MARILIS JIMENEZ ROSAS
MODULO Mantenimiento de Equipos de Electrónica Industrial (MEL_MMQ)

UNIDAD MMQ05. Robots y manipuladores.

PRACTICA MMQ05.2. Sistemas integrados de hardware libre.

DESARROLLO PRACTICO

ENTRADA DIGITAL CON MICRO INTERRUPTOR TÁCTIL 2 PIN.

Código

int led_rojo = 3;

int led_verde = 5;

int pulsador = 2;

bool Valor_pulsador;

void setup()

pinMode(led_rojo,OUTPUT);

pinMode(led_verde,OUTPUT);

pinMode(pulsador,OUTPUT);

void loop()

digitalWrite(led_rojo,LOW);

digitalWrite(led_verde,LOW);

Valor_pulsador = digitalRead(pulsador);

if ((Valor_pulsador == HIGH)&&(led_rojo == LOW))

digitalWrite(led_verde,HIGH);

else

{
 digitalWrite(led_verde,LOW);

Otro código para el pulsador junto a un zumbador

int buttonState = 0;

#define NOTE_C4 262

#define NOTE_G3 196

#define NOTE_A3 220

#define NOTE_B3 247

#define NOTE_C4 262

int melody[] = {

NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4

};

int noteDurations[] = {

4, 8, 8, 4, 4, 4, 4, 4

};

void setup() {

pinMode(2, INPUT);

pinMode(LED_BUILTIN, OUTPUT);

for (int thisNote = 0; thisNote < 8; thisNote++) {

int noteDuration = 1000 / noteDurations[thisNote];

tone(8, melody[thisNote], noteDuration);

int pauseBetweenNotes = noteDuration * 1.30;

delay(pauseBetweenNotes);

// stop the tone playing:

noTone(8);

void loop()

buttonState = digitalRead(2);

if (buttonState == HIGH) {

// turn LED on

digitalWrite(LED_BUILTIN, HIGH);

} else {

// turn LED off

digitalWrite(LED_BUILTIN, LOW);

delay(10);

}
2. ENTRADA ANALÓGICA CON SENSOR DE TEMPERATURA Y HUMEDAD DHT22.

Sensor de humedad TINKERCAD

int moisture = 0;

void setup()

pinMode(A0, OUTPUT);

pinMode(A1, INPUT);

Serial.begin(9600);

pinMode(8, OUTPUT);

pinMode(9, OUTPUT);

pinMode(10, OUTPUT);

pinMode(11, OUTPUT);

pinMode(12, OUTPUT);

void loop()

digitalWrite(A0, HIGH);

delay(10); // Wait for 10 millisecond(s)

moisture = analogRead(A1);

digitalWrite(A0, LOW);

Serial.println(moisture);

digitalWrite(8, LOW);

digitalWrite(9, LOW);

digitalWrite(10, LOW);

digitalWrite(11, LOW);

digitalWrite(12, LOW);

if (moisture < 200) {

digitalWrite(12, HIGH);

} else {

if (moisture < 400) {

 digitalWrite(11, HIGH);

} else {

if (moisture < 600) {

digitalWrite(10, HIGH);

} else {

if (moisture < 800) {

digitalWrite(9, HIGH);

} else {

digitalWrite(8, HIGH);

delay(100); // Wait for 100 millisecond(s)

Otra opción

Para programar un Arduino con un sensor de temperatura y humedad DHT11 utilizando una entrada analógica,
necesitarás el sensor DHT11 y la librería DHT para Arduino. El DHT11 se conecta generalmente a un pin digital,
pero leeremos sus valores y mostraremos los datos de temperatura y humedad en el monitor serial. Aquí te dejo
el código necesario y una breve explicación de cómo realizar la conexión.
Conexión del Sensor DHT11 al Arduino

1. VCC del DHT11 al pin 5V del Arduino.

2. GND del DHT11 al pin GND del Arduino.

3. DATA del DHT11 a cualquier pin digital del Arduino (usaremos el pin digital 2 en este ejemplo).

4. Resistor de 10kΩ entre VCC y DATA del DHT11 (pull-up).

Código Arduino

#include <DHT.h>

// Definir el pin digital donde está conectado el sensor

#define DHTPIN 2

// Definir el tipo de sensor DHT11

#define DHTTYPE DHT11

// Crear una instancia del sensor DHT

DHT dht(DHTPIN, DHTTYPE);

void setup() {

// Inicializar la comunicación serial

Serial.begin(9600);

// Iniciar el sensor DHT

dht.begin();

void loop() {

// Esperar unos segundos entre lecturas

delay(2000);

// Leer la humedad relativa (en %)

float h = dht.readHumidity();

// Leer la temperatura en grados Celsius

float t = dht.readTemperature();

// Verificar si alguna lectura falló y salir en ese caso

if (isnan(h) || isnan(t)) {

Serial.println("Error al leer del sensor DHT!");

return;
 }

// Imprimir los resultados en el monitor serial

Serial.print("Humedad: ");

Serial.print(h);

Serial.print(" %\t");

Serial.print("Temperatura: ");

Serial.print(t);

Serial.println(" *C");

Explicación del Código

• Librerías y Definiciones: Incluye la librería DHT y define el pin donde está conectado el sensor y el tipo de
sensor (DHT11).

• Setup: Inicializa la comunicación serial y el sensor DHT.

• Loop:

• Espera 2 segundos entre lecturas (esto es importante porque el DHT11 no puede proporcionar
lecturas continuamente).

• Lee la humedad y la temperatura.

• Verifica si las lecturas son válidas (no son NaN - Not a Number).

• Imprime los valores de temperatura y humedad en el monitor serial.

SALIDA DIGITAL CON MÓDULO DE RELÉS 2 CANALES
Para programar un Arduino con un módulo de relés de 2 canales y controlar dispositivos eléctricos (como luces,
motores, etc.), necesitas conectar correctamente el módulo de relés al Arduino y escribir un código para activar o
desactivar los relés. Aquí te dejo el código y una breve explicación sobre la conexión.

Conexión del Módulo de Relés al Arduino

1. VCC del módulo de relés al pin 5V del Arduino.

2. GND del módulo de relés al pin GND del Arduino.

3. IN1 del módulo de relés a un pin digital del Arduino (usaremos el pin digital 7 en este ejemplo).

4. IN2 del módulo de relés a otro pin digital del Arduino (usaremos el pin digital 8 en este ejemplo).

Código Arduino

// Definir los pines de los relés

#define RELAY1_PIN 7

#define RELAY2_PIN 8

void setup() {

// Configurar los pines de los relés como salidas

pinMode(RELAY1_PIN, OUTPUT);

pinMode(RELAY2_PIN, OUTPUT);

// Inicializar los relés en estado apagado

digitalWrite(RELAY1_PIN, LOW);

digitalWrite(RELAY2_PIN, LOW);

// Inicializar la comunicación serial

Serial.begin(9600);

void loop() {

// Activar el relé 1 (enciende el dispositivo conectado al canal 1)

Serial.println("Activando Relé 1");

digitalWrite(RELAY1_PIN, HIGH);

delay(1000); // Esperar 1 segundo

// Desactivar el relé 1 (apaga el dispositivo conectado al canal 1)

 Serial.println("Desactivando Relé 1");

digitalWrite(RELAY1_PIN, LOW);

delay(1000); // Esperar 1 segundo

// Activar el relé 2 (enciende el dispositivo conectado al canal 2)

Serial.println("Activando Relé 2");

digitalWrite(RELAY2_PIN, HIGH);

delay(1000); // Esperar 1 segundo

// Desactivar el relé 2 (apaga el dispositivo conectado al canal 2)

Serial.println("Desactivando Relé 2");

digitalWrite(RELAY2_PIN, LOW);

delay(1000); // Esperar 1 segundo

Explicación del Código

• Definir los Pines de los Relés: Se definen los pines digitales a los que están conectados los relés.

• Setup:

• Configura los pines de los relés como salidas utilizando pinMode.

• Inicializa los relés en estado apagado (LOW).

• Inicia la comunicación serial para monitorear el estado de los relés desde el monitor serial.

• Loop:

• Activa y desactiva cada relé en intervalos de 1 segundo (1000 ms).

• Imprime mensajes en el monitor serial para indicar el estado de cada relé.

SALIDA ANALÓGICA CON LED RGB ULTRA BRILLANTE.

Para controlar un LED RGB ultra brillante con salidas analógicas en un Arduino, puedes utilizar los pines PWM
(modulación por ancho de pulso) para variar el brillo de cada componente de color (rojo, verde y azul). Esto te
permitirá crear una amplia gama de colores.

Conexión del LED RGB al Arduino

Un LED RGB tiene cuatro pines:

• Ánodo común (catodo común): Esto depende del tipo de LED RGB que tengas. El ánodo común va al +5V
y el cátodo común va a GND.

• Rojo: Conectado a un pin PWM del Arduino (usaremos el pin 9).

• Verde: Conectado a otro pin PWM del Arduino (usaremos el pin 10).
 • Azul: Conectado a otro pin PWM del Arduino (usaremos el pin 11).

Si tu LED RGB es de ánodo común, conecta el pin común al +5V del Arduino. Si es de cátodo común, conecta el
pin común al GND del Arduino. Luego conecta resistencias de 220Ω entre los pines del LED y los pines del Arduino
para limitar la corriente.

Código Arduino

// Definir los pines de los colores del LED RGB

#define RED_PIN 9

#define GREEN_PIN 10

#define BLUE_PIN 11

void setup() {

// Configurar los pines de los colores como salidas

pinMode(RED_PIN, OUTPUT);

pinMode(GREEN_PIN, OUTPUT);

pinMode(BLUE_PIN, OUTPUT);

void loop() {

// Ciclo para mostrar varios colores

setColor(255, 0, 0); // Rojo

delay(1000);

setColor(0, 255, 0); // Verde

delay(1000);

setColor(0, 0, 255); // Azul

delay(1000);

setColor(255, 255, 0); // Amarillo

delay(1000);

setColor(0, 255, 255); // Cian

delay(1000);

setColor(255, 0, 255); // Magenta

delay(1000);
setColor(255, 255, 255); // Blanco

delay(1000);

setColor(0, 0, 0); // Apagado

delay(1000);

// Función para establecer el color del LED RGB

void setColor(int red, int green, int blue) {

analogWrite(RED_PIN, red);

analogWrite(GREEN_PIN, green);

analogWrite(BLUE_PIN, blue);

Explicación del Código

• Definir los Pines de los Colores: Define los pines PWM a los que están conectados los componentes rojo,
verde y azul del LED RGB.

• Setup: Configura los pines de los colores como salidas utilizando pinMode.

• Loop:

• Llama a la función setColor con diferentes valores para mostrar varios colores.

• Cada color se muestra durante 1 segundo (1000 ms).

• Función setColor:

• Utiliza analogWrite para establecer el brillo de cada componente del LED RGB. Los valores
pueden variar de 0 a 255, donde 0 es apagado y 255 es el máximo brillo.
MINISERVO
Para programar un Arduino y controlar un miniservo, necesitas la librería Servo que facilita el manejo de
servomotores. Aquí te dejo el código y una breve explicación de la conexión.

Conexión del Miniservo al Arduino

1. Cable de Señal verde del servo al pin digital 9 del Arduino.

2. Cable de Alimentación (rojo) del servo al pin 5V del Arduino.

3. Cable de Tierra (negro o marrón) del servo al pin GND del Arduino.

Código Arduino

#include <Servo.h>

// Crear una instancia del servo

Servo myservo;

// Definir el pin de control del servo

const int servoPin = 9;

void setup() {

// Adjuntar el servo al pin de control

myservo.attach(servoPin);

void loop() {

// Mover el servo de 0 a 180 grados

for (int pos = 0; pos <= 180; pos += 1) {

myservo.write(pos); // Mover a la posición 'pos'

delay(15); // Esperar 15 ms para que el servo alcance la posición

// Mover el servo de 180 a 0 grados

for (int pos = 180; pos >= 0; pos -= 1) {

myservo.write(pos); // Mover a la posición 'pos'

delay(15); // Esperar 15 ms para que el servo alcance la posición

}
Explicación del Código

• Librería Servo: Incluye la librería que proporciona las funciones necesarias para controlar el servo.

• Instancia del Servo: Crea una instancia del objeto Servo llamado myservo.

• Definir el Pin del Servo: Define el pin digital al que está conectado el servo (servoPin).

• Setup:

• Adjunta el servo al pin definido usando myservo.attach(servoPin).

• Loop:

• Un bucle for mueve el servo de 0 a 180 grados en incrementos de 1 grado. Cada posición se
mantiene durante 15 ms para permitir que el servo se mueva.

• Otro bucle for mueve el servo de 180 a 0 grados en decrementos de 1 grado, con el mismo
retraso de 15 ms.

MÓDULO ZUMBADOR DIGITAL

Para programar un módulo zumbador digital (buzzer) con Arduino, puedes utilizar funciones básicas para generar
tonos y controlar cuándo el zumbador suena. A continuación te presento el código y una breve explicación sobre
cómo conectar el módulo zumbador al Arduino.

Conexión del Módulo Zumbador al Arduino

1. Pin de Señal del zumbador al pin digital 8 del Arduino.

2. VCC del zumbador al pin 5V del Arduino.

3. GND del zumbador al pin GND del Arduino.

Código Arduino

// Definir el pin del zumbador

const int buzzerPin = 8;

void setup() {

// Configurar el pin del zumbador como salida

pinMode(buzzerPin, OUTPUT);

void loop() {

// Hacer sonar el zumbador

tone(buzzerPin, 1000); // Emitir un tono de 1000 Hz

delay(1000); // Esperar 1 segundo

// Detener el sonido del zumbador

noTone(buzzerPin);

delay(1000); // Esperar 1 segundo

Explicación del Código

• Definir el Pin del Zumbador: Define el pin digital al que está conectado el zumbador (buzzerPin).

• Setup: Configura el pin del zumbador como salida utilizando pinMode.

• Loop:

• La función tone(buzzerPin, 1000) genera un tono de 1000 Hz en el pin del zumbador.

• delay(1000) espera 1 segundo con el zumbador sonando.

• La función noTone(buzzerPin) detiene el sonido del zumbador.

• Otro delay(1000) espera 1 segundo con el zumbador apagado.

SENSOR DE MOVIMIENTO
Para programar un sensor de movimiento PIR (Passive Infrared Sensor) con Arduino, necesitas conectar el sensor
al Arduino y escribir un código para detectar el movimiento y realizar alguna acción, como encender un LED o
enviar un mensaje al monitor serial.

Conexión del Sensor PIR al Arduino

1. VCC del sensor PIR al pin 5V del Arduino.

2. GND del sensor PIR al pin GND del Arduino.

3. OUT del sensor PIR a un pin digital del Arduino (usaremos el pin digital 2 en este ejemplo).
 4. Opcionalmente, si deseas encender un LED cuando se detecte movimiento: 4. Conecta el ánodo de un
LED al pin digital 13 del Arduino (con una resistencia de 220Ω en serie).

5. Conecta el cátodo del LED al GND del Arduino.

Código Arduino

// Definir el pin del sensor PIR y el pin del LED

const int pirPin = 2;

const int ledPin = 13;

void setup() {

// Configurar el pin del sensor PIR como entrada

pinMode(pirPin, INPUT);

// Configurar el pin del LED como salida

pinMode(ledPin, OUTPUT);

// Inicializar la comunicación serial

Serial.begin(9600);

void loop() {

// Leer el estado del sensor PIR

int pirState = digitalRead(pirPin);

// Verificar si se ha detectado movimiento

if (pirState == HIGH) {

// Movimiento detectado

Serial.println("Movimiento detectado!");

digitalWrite(ledPin, HIGH); // Encender el LED

} else {

// No hay movimiento

digitalWrite(ledPin, LOW); // Apagar el LED

// Pequeño retardo para evitar múltiples lecturas seguidas

delay(200);

}
Explicación del Código

• Definir los Pines: Define los pines para el sensor PIR (pirPin) y el LED (ledPin).

• Setup:

• Configura el pin del sensor PIR como entrada utilizando pinMode(pirPin, INPUT).

• Configura el pin del LED como salida utilizando pinMode(ledPin, OUTPUT).

• Inicializa la comunicación serial para enviar mensajes al monitor serial.

• Loop:

• Lee el estado del sensor PIR con digitalRead(pirPin).

• Si el sensor detecta movimiento (pirState == HIGH), se enciende el LED y se imprime un mensaje

en el monitor serial.

• Si no se detecta movimiento (pirState == LOW), se apaga el LED.

• Se incluye un pequeño retardo (delay(200)) para evitar múltiples lecturas seguidas y estabilizar la
detección.

RELOJ EN TIEMPO REAL AT24C32

Para programar un reloj en tiempo real (RTC) con el módulo AT24C32 y Arduino, normalmente utilizas un módulo
RTC DS1307 o DS3231, que ya incluyen memoria EEPROM (como la AT24C32) para almacenar datos. Aquí te
proporcionaré el código para un módulo RTC DS3231, que es muy común y fácil de usar con Arduino.

Conexión del Módulo RTC DS3231 al Arduino

1. VCC del módulo RTC al pin 5V del Arduino.

2. GND del módulo RTC al pin GND del Arduino.

3. SDA del módulo RTC al pin A4 del Arduino (para el Arduino Uno).

4. SCL del módulo RTC al pin A5 del Arduino (para el Arduino Uno).
Código Arduino

#include <Wire.h>

#include <RTClib.h>

// Crear una instancia del RTC

RTC_DS3231 rtc;

void setup() {

// Inicializar la comunicación serial

Serial.begin(9600);

// Inicializar la comunicación I2C

Wire.begin()

// Verificar si el RTC está conectado correctamente

if (!rtc.begin()) {

Serial.println("No se pudo encontrar RTC");

while (1);

// Verificar si el RTC está funcionando

if (rtc.lostPower()) {

Serial.println("RTC perdió el poder, configurando la fecha y hora!");

// Establecer la fecha y hora a la compilación del sketch

rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

void loop() {

// Obtener la fecha y hora actual

DateTime now = rtc.now();

// Imprimir la fecha y hora en formato legible

Serial.print(now.year(), DEC);

Serial.print('/');

Serial.print(now.month(), DEC);

Serial.print('/');

Serial.print(now.day(), DEC);
 Serial.print(" ");

Serial.print(now.hour(), DEC);

Serial.print(':');

Serial.print(now.minute(), DEC);

Serial.print(':');

Serial.print(now.second(), DEC);

Serial.println();

// Esperar 1 segundo antes de la siguiente lectura

delay(1000);

Explicación del Código

• Librerías Wire y RTClib: Se incluyen para manejar la comunicación I2C y el RTC.

• Instancia del RTC: Se crea una instancia del objeto RTC_DS3231 llamado rtc.

• Setup:

• Inicializa la comunicación serial para imprimir mensajes en el monitor serial.

• Inicializa la comunicación I2C.

• Verifica si el RTC está conectado correctamente utilizando rtc.begin().

• Si el RTC perdió el poder, ajusta la fecha y hora a la fecha y hora de la compilación del sketch
utilizando rtc.adjust(DateTime(F(__DATE__), F(__TIME__))).

• Loop:

• Obtiene la fecha y hora actual utilizando rtc.now().

• Imprime la fecha y hora en formato legible en el monitor serial.

• Espera 1 segundo antes de realizar la siguiente lectura.

MÓDULO RFID
Para programar un módulo RFID con Arduino, necesitas un módulo RFID, como el RC522, y la librería MFRC522
que facilita la interacción con el lector RFID. Aquí te dejo el código y la explicación para conectar y programar el
módulo RFID con Arduino.

Conexión del Módulo RFID RC522 al Arduino

1. VCC del módulo RFID al pin 3.3V del Arduino (el RC522 funciona mejor con 3.3V).

2. GND del módulo RFID al pin GND del Arduino.

3. SDA del módulo RFID al pin 10 del Arduino.

4. SCK del módulo RFID al pin 13 del Arduino.

5. MOSI del módulo RFID al pin 11 del Arduino.

6. MISO del módulo RFID al pin 12 del Arduino.

7. RST del módulo RFID al pin 9 del Arduino.

Código Arduino

#include <SPI.h>

#include <MFRC522.h>

#define SS_PIN 10

#define RST_PIN 9

MFRC522 mfrc522(SS_PIN, RST_PIN); // Crear una instancia del objeto MFRC522

void setup() {

// Inicializar la comunicación serial

Serial.begin(9600);

while (!Serial);

// Inicializar el bus SPI

SPI.begin();

// Inicializar el módulo MFRC522

mfrc522.PCD_Init();

Serial.println("Aproxima una tarjeta RFID al lector...");

void loop() {

// Revisa si hay una nueva tarjeta presente

if (!mfrc522.PICC_IsNewCardPresent()) {

return;

// Selecciona una tarjeta (PICC)

if (!mfrc522.PICC_ReadCardSerial()) {

return;

// Mostrar UID de la tarjeta en el monitor serial

Serial.print("UID de la tarjeta:");

for (byte i = 0; i < mfrc522.uid.size; i++) {

Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");

Serial.print(mfrc522.uid.uidByte[i], HEX);

Serial.println();

// Detener la lectura de la tarjeta

mfrc522.PICC_HaltA();

Explicación del Código

Librerías SPI y MFRC522: Se incluyen para manejar la comunicación SPI y el módulo RFID.

Definición de Pines: Define los pines de SS y RST para el módulo RFID.

Instancia del RFID: Crea una instancia del objeto MFRC522 llamado mfrc522.

Setup:

Inicializa la comunicación serial.

Inicializa el bus SPI.

Inicializa el módulo RFID utilizando mfrc522.PCD_Init().

Imprime un mensaje en el monitor serial para indicar que el lector RFID está listo.

Loop:

Verifica si hay una nueva tarjeta presente con mfrc522.PICC_IsNewCardPresent().

Si hay una tarjeta, lee el UID de la tarjeta con mfrc522.PICC_ReadCardSerial().

Imprime el UID de la tarjeta en el monitor serial.

Detiene la lectura de la tarjeta con mfrc522.PICC_HaltA().

MÓDULO WIFI
Para programar un módulo WiFi ESP8266 con Arduino, puedes utilizar la biblioteca ESP8266WiFi. Este ejemplo te
mostrará cómo conectar tu ESP8266 a una red WiFi y enviar datos a través de la red. Aquí te dejo el código y la
explicación para conectar y programar el módulo WiFi ESP8266 con Arduino.

Conexión del Módulo ESP8266 al Arduino

Para programar el ESP8266 con Arduino, a menudo se usa una placa como el NodeMCU o el Wemos D1 Mini, que
tiene el ESP8266 integrado y puede ser programado directamente desde el Arduino IDE. Si estás usando un
ESP8266 independiente, las conexiones básicas son:

1. VCC del ESP8266 al pin 3.3V del Arduino (el ESP8266 funciona con 3.3V).

2. GND del ESP8266 al pin GND del Arduino.

3. TX del ESP8266 al pin RX del Arduino (usa un divisor de voltaje para reducir el 5V del Arduino a 3.3V si es
necesario).

4. RX del ESP8266 al pin TX del Arduino.

5. CH_PD del ESP8266 al pin 3.3V del Arduino.

6. GPIO0 del ESP8266 al pin GND del Arduino para modo de carga de firmware.

Para este ejemplo, se asume que estás utilizando un NodeMCU o Wemos D1 Mini.

Configuración del Entorno Arduino IDE

1. Abre el Arduino IDE.

2. Ve a File -> Preferences.

3. En el campo "Additional Board Manager URLs", agrega esta URL:

http://arduino.esp8266.com/stable/package_esp8266com_index.json.

4. Ve a Tools -> Board -> Boards Manager.

 5. Busca e instala "esp8266".

6. Selecciona tu placa ESP8266 en Tools -> Board.

Código Arduino

#include <ESP8266WiFi.h>

// Reemplaza con los detalles de tu red WiFi

const char* ssid = "TU_SSID";

const char* password = "TU_PASSWORD";

void setup() {

// Inicializar la comunicación serial

Serial.begin(115200);

delay(10);

// Conectar a la red WiFi

Serial.println();

Serial.println();

Serial.print("Conectando a ");

Serial.println(ssid);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(500);

Serial.print(".");

Serial.println("");

Serial.println("WiFi conectado");

Serial.println("Dirección IP: ");

Serial.println(WiFi.localIP());

void loop() {

// Tu código principal aquí

}
Explicación del Código

• Librería ESP8266WiFi: Se incluye para manejar las funciones de WiFi.

• Credenciales de WiFi: Reemplaza TU_SSID y TU_PASSWORD con el nombre y la contraseña de tu red

WiFi.

• Setup:

• Inicializa la comunicación serial.

• Intenta conectarse a la red WiFi especificada con WiFi.begin(ssid, password).

• Espera hasta que la conexión WiFi se establezca (WiFi.status() != WL_CONNECTED).

• Imprime la dirección IP asignada al ESP8266 en el monitor serial.

• Loop: No hace nada en este caso, pero aquí es donde agregarías el código principal de tu aplicación.