Clase 6: Librerías – Cómo usar código de otros para hacer más con menos

¿Qué vas a aprender en esta clase?

Al terminar esta clase vas a poder:

Explicar qué es una librería y por qué se usan
Instalar librerías desde el gestor del Arduino IDE
Conectar una pantalla LCD 16×2 con módulo I2C
Mostrar texto y datos en la pantalla usando la librería LiquidCrystal_I2C
Simular el circuito completo en Wokwi y probarlo en hardware real

1. ¿Qué es una librería?

Imaginá que cada vez que querés enviar un mensaje de texto desde tu celular tuvieras que programar desde cero el protocolo de comunicación, la codificación de caracteres y el manejo de la antena. Sería imposible para la mayoría de las personas.

Las librerías resuelven exactamente ese problema en Arduino. Son colecciones de código ya escrito, probado y empaquetado que podés incorporar a tus proyectos con una sola línea.

En lugar de escribir las decenas de instrucciones necesarias para manejar una pantalla LCD, simplemente usás la librería correspondiente y escribís:

lcd.print("Hola Mundo");

Eso es todo. La librería se encarga del resto.

💡 Analogía: una librería es como una caja de herramientas especializada. Vos no fabricás los destornilladores — los usás. Las librerías son herramientas que otros fabricaron para que vos puedas construir cosas más grandes.

2. Tipos de librerías en Arduino

Existen tres tipos según su origen:

Librerías integradas (built-in): Vienen instaladas con el Arduino IDE. No necesitás hacer nada para usarlas. Ejemplos: Wire (comunicación I2C), SPI, EEPROM, Servo.

Librerías del gestor (Library Manager): Se instalan desde el gestor de librerías del IDE con un clic. Son las más comunes. Ejemplo: LiquidCrystal_I2C, DHT sensor library, IRremote.

Librerías manuales: Se descargan como archivo .zip y se instalan manualmente. Se usan cuando la librería no está en el gestor oficial.

3. Cómo instalar una librería desde el IDE

Abrí el Arduino IDE
En el panel izquierdo hacé clic en el ícono de librerías (📚)
En el buscador escribí el nombre de la librería
Localizá la correcta en la lista y hacé clic en Instalar
Si el IDE pregunta si instalar dependencias, elegí «Instalar todo»

Para esta clase necesitamos instalar:

🔍 Buscá: LiquidCrystal I2C — autor: Frank de Brabander

4. La pantalla LCD 16×2 con módulo I2C

¿Qué es una LCD 16×2?

Una LCD 16×2 (Liquid Crystal Display) es una pantalla que puede mostrar 2 filas de 16 caracteres cada una. Es uno de los componentes más usados en proyectos de Arduino para mostrar datos de sensores, mensajes o menús.

┌────────────────────┐
│Hola, Arduino!      │  ← Fila 1 (16 caracteres)
│Temp: 23.5 C        │  ← Fila 2 (16 caracteres)
└────────────────────┘

¿Qué es el módulo I2C?

La LCD 16×2 en su versión básica necesita entre 6 y 12 cables para conectarse al Arduino, lo que ocupa muchos pines. El módulo I2C (también llamado adaptador I2C o backpack) se suelda en la parte trasera de la LCD y reduce la conexión a solo 4 cables:

Pin del módulo I2C	Conexión en Arduino UNO
VCC	5V
GND	GND
SDA	A4
SCL	A5

📌 Importante: los pines I2C en Arduino UNO son fijos: SDA = A4 y SCL = A5. No podés usar otros pines para I2C en el UNO.

¿Qué es I2C?

I2C (Inter-Integrated Circuit) es un protocolo de comunicación que permite conectar múltiples dispositivos usando solo dos cables: SDA (datos) y SCL (reloj). Cada dispositivo tiene una dirección única — la LCD suele usar la dirección 0x27 o 0x3F.

5. El circuito

Conexión física

Arduino UNO          Módulo I2C (LCD)
─────────────        ────────────────
5V          ───────► VCC
GND         ───────► GND
A4 (SDA)    ───────► SDA
A5 (SCL)    ───────► SCL

Solo 4 cables. Sin resistencias adicionales — el módulo I2C ya las tiene integradas.

Ajuste de contraste

El módulo I2C tiene un pequeño potenciómetro (tornillo azul en la parte trasera) para ajustar el contraste de la pantalla. Si al cargar el programa no ves nada en la pantalla, girá ese tornillo lentamente hasta que aparezca el texto.

6. El código

Estructura básica

#include <Wire.h>               // Librería I2C (integrada, no hay que instalarla)
#include <LiquidCrystal_I2C.h>  // Librería de la LCD

// Creamos el objeto lcd: dirección 0x27, 16 columnas, 2 filas
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();        // Inicializa la pantalla
  lcd.backlight();   // Enciende la luz de fondo

  lcd.setCursor(0, 0);          // Columna 0, fila 0 (primera fila)
  lcd.print("Hola, Arduino!");

  lcd.setCursor(0, 1);          // Columna 0, fila 1 (segunda fila)
  lcd.print("Clase 4 lista!");
}

void loop() {
  // Por ahora no hay nada en el loop
}

Funciones clave explicadas

Función	Qué hace
`lcd.init()`	Inicializa la pantalla al comenzar
`lcd.backlight()`	Enciende la luz de fondo (backlight)
`lcd.noBacklight()`	Apaga la luz de fondo
`lcd.setCursor(col, fila)`	Mueve el cursor a la posición indicada
`lcd.print("texto")`	Escribe texto desde la posición del cursor
`lcd.clear()`	Borra todo el contenido de la pantalla
`lcd.home()`	Mueve el cursor al inicio (0, 0) sin borrar

📌 Sistema de coordenadas: setCursor(columna, fila). La columna va de 0 a 15, la fila va de 0 a 1. El origen (0,0) es el carácter superior izquierdo.

7. Proyecto de la clase: contador con LCD

Vamos a mostrar un contador que se incrementa cada segundo, con el título en la primera fila y el valor en la segunda.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);

int contador = 0;

void setup() {
  lcd.init();
  lcd.backlight();

  lcd.setCursor(0, 0);
  lcd.print("Contador:");
}

void loop() {
  lcd.setCursor(0, 1);
  lcd.print("                ");  // Limpia la fila 2 con espacios
  lcd.setCursor(0, 1);
  lcd.print(contador);

  contador++;
  delay(1000);
}

¿Por qué limpiamos la fila con espacios en lugar de usar `lcd.clear()`?

lcd.clear() borra toda la pantalla y reposiciona el cursor, lo que provoca un parpadeo visible. Limpiar solo la fila que cambia con espacios en blanco evita ese parpadeo y da una experiencia más prolija.

8. Simulalo en Wokwi

En Wokwi el componente LCD con I2C se llama wokwi-lcd1602 con el atributo "pins": "i2c".

👉 Abrir simulación en Wokwi

JSON del diagrama

{
  "version": 1,
  "author": "Profe Martín López",
  "editor": "wokwi",
  "parts": [
    {
      "type": "wokwi-arduino-uno",
      "id": "uno",
      "top": 120,
      "left": 20,
      "attrs": {}
    },
    {
      "type": "wokwi-lcd1602",
      "id": "lcd",
      "top": 20,
      "left": 240,
      "attrs": { "pins": "i2c" }
    }
  ],
  "connections": [
    [ "uno:5V",  "lcd:VCC", "red",   [] ],
    [ "uno:GND.1", "lcd:GND", "black", [] ],
    [ "uno:A4",  "lcd:SDA", "blue",  [] ],
    [ "uno:A5",  "lcd:SCL", "yellow", [] ]
  ],
  "dependencies": {}
}

9. Probarlo en hardware real

Si tenés la placa y la LCD física, el proceso es:

Conectá los 4 cables según la tabla de la sección 4
Instalá la librería LiquidCrystal I2C de Frank de Brabander desde el gestor
Cargá el código del contador
Si la pantalla no muestra nada, ajustá el potenciómetro de contraste

¿Y si la dirección no es 0x27?

Algunos módulos I2C usan la dirección 0x3F en lugar de 0x27. Si el programa carga pero la pantalla no muestra nada (y el contraste está bien ajustado), probá cambiando:

LiquidCrystal_I2C lcd(0x3F, 16, 2);  // Probá con esta dirección

Para saber la dirección exacta de tu módulo podés usar el Scanner I2C, un sketch de ejemplo que escanea todos los dispositivos conectados al bus I2C y muestra sus direcciones en el Monitor Serie. Lo encontrás en Archivo → Ejemplos → Wire → i2c_scanner.

10. Actividad

Nivel 1 — Mensaje personalizado: Modificá el código para que la primera fila muestre tu nombre y la segunda muestre el mensaje «Bienvenido!».

Nivel 2 — Contador regresivo: Cambiá el contador para que cuente desde 10 hasta 0 y cuando llegue a 0 muestre el mensaje «Tiempo!» en la pantalla.

Nivel 3 — Temperatura simulada: Generá un número aleatorio entre 15 y 35 usando random(15, 35) y mostralo en la pantalla como si fuera la temperatura de un sensor. Actualizalo cada 2 segundos.

11. Resumen de la clase

En esta clase aprendiste:

Una librería es código reutilizable que simplifica el control de componentes complejos
Se instalan desde el gestor de librerías del Arduino IDE en pocos clics
La LCD 16×2 con módulo I2C se conecta con solo 4 cables a los pines 5V, GND, A4 y A5
El protocolo I2C permite comunicar múltiples dispositivos usando solo dos líneas
Las funciones clave son lcd.init(), lcd.backlight(), lcd.setCursor() y lcd.print()
Si la pantalla no muestra nada, ajustá el potenciómetro de contraste o probá la dirección 0x3F

12. Glosario de la clase

Término	Definición
Librería	Colección de código reutilizable que extiende las funciones de Arduino
I2C	Protocolo de comunicación de dos cables (SDA y SCL) para conectar dispositivos
SDA	Serial Data — cable de datos del protocolo I2C
SCL	Serial Clock — cable de reloj del protocolo I2C
Dirección I2C	Identificador único de cada dispositivo en el bus I2C (ej: 0x27)
LCD 16×2	Pantalla de cristal líquido con 2 filas de 16 caracteres cada una
Backlight	Luz de fondo de la pantalla LCD
Potenciómetro	Componente de resistencia variable, usado aquí para ajustar el contraste
lcd.setCursor()	Función que posiciona el cursor en columna y fila indicadas
Scanner I2C	Sketch que detecta las direcciones de todos los dispositivos I2C conectados