Componentes Básicos de Arduino

Introducción

En mi opinión, conocer los básicos de Arduino es una de las decisiones más inteligentes que puede tomar una persona.

El hecho de poder crear aparatos que interactuan con el mundo real, sea leyéndolo o ejecutando acciones da un poder fascinante desde la simplicidad de su uso: Conectar pines y escribir código.

Sin gran esfuerzo, sin conocer código ensamblador, sin necesidad de saber crear PCBs y soldar se pueden crear aparatos que nos faciliten la vida.

Son una herramienta que nos permiten pasar conocimientos informáticos al mundo real, y además con una infinidad de usos.

Hay proyectos simples y complejos, de alto coste y de bajo coste, pero lo cierto es que todos pueden ser útiles.

Un ejemplo reciente, a fecha de escritura de este post, es un cronómetro que me he hecho para llevar en el coche, juntando impresora 3D y unos pocos componentes de arduino:

Es cierto que podría haber comprado uno, pero aprovechando el poder de la impresión 3D he decidido crear uno con una estética simple y a mi gusto, adaptado a mis necesidades y sin necesidad de esperar al repartidor.

Pantallas I2C

¿Qué es una pantalla I2C?

Las pantallas con bus I2C (Inter-Integrated Circuit) son las pantallas más simples de utilizar en Arduino, y es que simplifican el proceso de trabajo.

A diferencia de las conexiones paralelas tradicionales, el bus I2C permite la comunicación con múltiples dispositivos utilizando solo dos cables: SDA (datos en serie) y SCL (reloj en serie).

Esta configuración simplifica enormemente el cableado y la integración de componentes, haciendo que sea una opción muy popular entre los entusiastas de Arduino.

Ejemplo: Pantalla LCD 16×2

Un ejemplo clásico de pantalla I2C es la LCD 16×2.

Esta pantalla permite mostrar dos líneas de texto con 16 caracteres cada una, suficiente para la mayoría de las aplicaciones básicas de visualización.

La versión con módulo I2C integrado reduce el número de pines necesarios de 16 a solo 4 (VCC, GND, SDA, SCL), lo que simplifica el diseño del circuito y libera pines en el Arduino para otros usos.

Librerías necesarias para el IDE de Arduino

Para utilizar una pantalla LCD I2C, es necesario instalar algunas librerías en el IDE de Arduino.

La librería más común es LiquidCrystal_I2C, que facilita la interacción con la pantalla. Para instalarla, sigue estos pasos:

1. Abre el IDE de Arduino.
2. Ve a «Sketch» > «Incluir Librería» > «Administrar Bibliotecas».
3. Busca «LiquidCrystal_I2C» e instálala.

Una vez instalada, puedes incluirla en tu código con #include <LiquidCrystal_I2C.h>, lo que te permitirá inicializar y controlar la pantalla fácilmente.

Conexiones y montaje

La conexión de una pantalla LCD 16×2 con módulo I2C a un Arduino es bastante sencilla. Solo necesitas conectar los cuatro pines de la pantalla al Arduino de la siguiente manera:

• VCC: Conéctalo al pin de 5V del Arduino.
• GND: Conéctalo a un pin de tierra (GND) del Arduino.
• SDA: Conéctalo al pin A4 del Arduino (en la mayoría de las placas Arduino).
• SCL: Conéctalo al pin A5 del Arduino (en la mayoría de las placas Arduino).

Una vez realizadas las conexiones, puedes usar el siguiente código básico para probar la pantalla:

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

LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.begin();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Hola, Arduino!");
}

void loop() {
}

Uso de botones

Diferencias entre botones de dos y tres pines

En cualquier proyecto que queramos hacer los botones son casi siempre obligatorios, de otra forma podremos leer el mundo pero no interactuar con él.

Existen dos tipos de botones, de dos pines y de tres pines, podemos utilizar ambos en nuestros proyectos, aunque tienen sus diferencias.

Los botones de tres pines ofrecen una ventaja significativa en términos de estabilidad de señal y reducción de ruido, comparados con los tradicionales de dos pines.

Mientras que los botones de dos pines son simples interruptores, los de tres pines añaden un pin adicional para el voltaje de referencia (VCC), lo cual proporciona una señal más limpia y consistente al Arduino.

Conexiones de pines: Out, VCC y GND

Para conectar correctamente un botón de tres pines, primero debemos identificar sus pines: Out, VCC y GND. Cada uno de estos pines tiene una función específica:

• Out: Este pin envía la señal de pulsación al Arduino.
• VCC: Este pin se conecta al voltaje de referencia, generalmente 5V.
• GND: Este pin se conecta a tierra.

La conexión al Arduino se realiza de la siguiente manera:

• Conecta Out a un pin digital del Arduino, por ejemplo, el pin 2.
• Conecta VCC al pin de 5V del Arduino.
• Conecta GND a un pin de tierra (GND) del Arduino.

Ejemplo de código

El uso de botones en Arduino no requiere necesariamente librerías adicionales. Aquí te dejo un ejemplo sencillo de cómo leer el estado de un botón de tres pines y controlar un LED integrado en el pin 13 del Arduino.

const int buttonPin = 2;  // Pin al que está conectado el botón
const int ledPin = 13;    // Pin del LED integrado
int buttonState = 0;      // Variable para almacenar el estado del botón

void setup() {
  pinMode(buttonPin, INPUT);  // Configura el pin del botón como entrada
  pinMode(ledPin, OUTPUT);    // Configura el pin del LED como salida
}

void loop() {
  buttonState = digitalRead(buttonPin);  // Lee el estado del botón

  if (buttonState == HIGH) {  // Si el botón está presionado
    digitalWrite(ledPin, HIGH);  // Enciende el LED
  } else {  // Si el botón no está presionado
    digitalWrite(ledPin, LOW);   // Apaga el LED
  }
}

En este ejemplo, configuramos el pin del botón como entrada y el pin del LED como salida. Dentro del bucle principal (loop), leemos el estado del botón. Si el botón está presionado (HIGH), encendemos el LED; si no lo está (LOW), apagamos el LED.

Sensor de temperatura DHT-11

Descripción y características del DHT-11

El sensor de temperatura y humedad DHT-11 es uno de los componentes más populares y accesibles para proyectos de Arduino.

Este sensor, el cual viene en todos y cada uno de los paquetes «starter» de Arduino nos permite tomar la temperatura y humedad del ambiente.

Cabe decir que es un sensor que dura poco tiempo a la intemperie, ya que funciona por resistencias y tienden a quemarse.

No obstante, es increíblemente útil para proyectos de toda índole, sea dar la temperatura del interior de un coche o medir la humedad del ambiente.

El DHT-11 destaca por su fácil uso, bajo costo y fiabilidad en condiciones estándar.

Librerías necesarias

Para facilitar la interacción con el sensor DHT-11 en el entorno de desarrollo de Arduino, es recomendable utilizar la librería DHT de Adafruit. Esta librería simplifica el proceso de leer datos del sensor y es ampliamente utilizada por la comunidad Arduino. Para instalarla, sigue estos pasos:

1. Abre el IDE de Arduino.
2. Ve a «Sketch» > «Incluir Librería» > «Administrar Bibliotecas».
3. Busca «DHT sensor library by Adafruit» e instálala.

Incluye la librería en tu código con #include <DHT.h> para acceder a todas sus funciones.

Cómo conectar el DHT-11 al Arduino

El sensor DHT-11 tiene cuatro pines, pero normalmente solo tres se utilizan para la conexión con Arduino. Estos pines son:

• VCC: Se conecta al pin de 5V del Arduino.
• GND: Se conecta a uno de los pines de tierra (GND) del Arduino.
• DATA: Se conecta a un pin digital del Arduino, por ejemplo, el pin 2.
• NC: No conectado, se puede dejar sin conexión.

Ejemplos de código y uso

A continuación, un ejemplo de código básico para leer los valores de temperatura y humedad del sensor DHT-11 y mostrarlos en el monitor serial:

#include <DHT.h>

#define DHTPIN 2     // Pin digital conectado al DHT-11
#define DHTTYPE DHT11   // Tipo de sensor DHT-11

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  dht.begin();
}

void loop() {
  delay(2000);  // Espera 2 segundos entre lecturas

  float h = dht.readHumidity();
  float t = dht.readTemperature();
  
  if (isnan(h) || isnan(t)) {
    Serial.println("Error al leer del sensor DHT");
    return;
  }
  
  Serial.print("Humedad: ");
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperatura: ");
  Serial.print(t);
  Serial.println(" *C");
}

En este código, se configura el pin del sensor y el tipo de sensor, se inicializa la comunicación serial y el sensor en el setup(). En el loop(), se leen las valores de temperatura y humedad cada 2 segundos y se muestran en el monitor serial. Si hay un error en la lectura, se imprime un mensaje de error.

Leds y su manejo básico

Tipos de LEDs y sus aplicaciones

Los LEDs (diodos emisores de luz) son componentes esenciales en la electrónica moderna y se utilizan en una amplia variedad de aplicaciones, desde indicadores simples hasta complejos sistemas de iluminación y pantallas.

Existen varios tipos de LEDs, cada uno con características específicas que los hacen adecuados para diferentes usos. Entre los más comunes encontramos:

• LEDs estándar: Utilizados para indicadores básicos.
• LEDs RGB: Combinan tres LEDs en uno (rojo, verde y azul) para crear una amplia gama de colores.
• LEDs de alta potencia: Empleados en aplicaciones de iluminación.
• LEDs direccionables: Como los WS2812B, que permiten el control individual de cada LED en una tira.

Conexiones y resistencias necesarias

La conexión de LEDs al Arduino es sencilla, pero requiere el uso de resistencias para limitar la corriente y evitar dañar tanto el LED como el Arduino. La resistencia adecuada se calcula usando la Ley de Ohm:

R = (V_fuente – V_LED) / I

Donde:

• V_fuente es el voltaje de la fuente (por ejemplo, 5V del Arduino).
• V_LED es el voltaje de caída del LED (aproximadamente 2V para LEDs rojos, 3V para LEDs azules y blancos).
• I es la corriente deseada para el LED (típicamente 20mA o 0.02A para LEDs estándar).

Por ejemplo, para un LED rojo con una fuente de 5V y una corriente deseada de 20mA: R = (5V – 2V) / 0.02A = 150 ohmios

Librerías recomendadas

Para proyectos más avanzados, como el uso de LEDs RGB direccionables, es recomendable utilizar librerías específicas que faciliten el control de estos componentes.

La librería Adafruit NeoPixel es muy popular para este propósito. Para instalarla:

1. Abre el IDE de Arduino.
2. Ve a «Sketch» > «Incluir Librería» > «Administrar Bibliotecas».
3. Busca «Adafruit NeoPixel» e instálala.

Proyectos básicos con LEDs

A continuación, un ejemplo de código básico para encender un LED conectado al pin 13 del Arduino:

const int ledPin = 13;  // Pin al que está conectado el LED

void setup() {
  pinMode(ledPin, OUTPUT);  // Configura el pin del LED como salida
}

void loop() {
  digitalWrite(ledPin, HIGH);  // Enciende el LED
  delay(1000);                 // Espera 1 segundo
  digitalWrite(ledPin, LOW);   // Apaga el LED
  delay(1000);                 // Espera 1 segundo
}

Este código configura el pin 13 como salida y enciende y apaga el LED con intervalos de 1 segundo. Para LEDs RGB, se puede utilizar un código similar, ajustando los pines y las secuencias de color.

Sensores de proximidad

¿Qué es el sensor HC-SR04?

El sensor ultrasónico HC-SR04 es uno de los sensores de proximidad más populares y ampliamente utilizados en proyectos de Arduino.

Este sensor es muy común en los kits de inicio de Arduino debido a su simplicidad de uso, bajo costo y versatilidad. El HC-SR04 es capaz de medir distancias a través de ondas ultrasónicas, lo que lo hace ideal para aplicaciones como robots autónomos, sistemas de seguridad y detección de obstáculos.

Características del HC-SR04

El HC-SR04 funciona emitiendo un pulso ultrasónico a 40kHz desde el pin TRIG y midiendo el tiempo que tarda el eco en regresar al pin ECHO después de rebotar en un objeto.

La distancia al objeto se calcula en función del tiempo que tarda el eco en regresar. Este sensor puede medir distancias desde 2 cm hasta 400 cm con una precisión de aproximadamente 3 mm.

Conexiones y montaje

Para conectar el HC-SR04 a un Arduino, sigue estos pasos:

• VCC: Conéctalo al pin de 5V del Arduino.
• GND: Conéctalo a uno de los pines de tierra (GND) del Arduino.
• TRIG: Conéctalo a un pin digital del Arduino, por ejemplo, el pin 9.
• ECHO: Conéctalo a otro pin digital del Arduino, por ejemplo, el pin 10.

Ejemplo de código

A continuación, un ejemplo de código básico para leer la distancia medida por el sensor HC-SR04 y mostrarla en el monitor serial:

const int trigPin = 9;
const int echoPin = 10;
long duration;
int distance;

void setup() {
  pinMode(trigPin, OUTPUT); // Configura el pin TRIG como salida
  pinMode(echoPin, INPUT);  // Configura el pin ECHO como entrada
  Serial.begin(9600);       // Inicializa la comunicación serial
}

void loop() {
  // Limpia el pin TRIG
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  
  // Genera un pulso en el pin TRIG
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Lee el tiempo del eco
  duration = pulseIn(echoPin, HIGH);
  
  // Calcula la distancia
  distance = duration * 0.034 / 2;
  
  // Muestra la distancia en el monitor serial
  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println(" cm");
  
  delay(1000); // Espera 1 segundo antes de la siguiente lectura
}

Pantallas de matrices de LED

¿Qué es una pantalla de matriz de LED?

Las pantallas de matrices de LED son dispositivos que consisten en una rejilla de LEDs organizados en filas y columnas, comúnmente en configuraciones como 8×8.

Estas matrices permiten mostrar texto, gráficos simples y animaciones, siendo ideales para proyectos que requieren visualización dinámica y atractiva.

Las matrices de LED con conexiones de 4 pines abajo y 4 pines arriba son particularmente populares debido a su facilidad de uso y flexibilidad en la programación.

Conexiones y montaje

Una matriz de LED 8×8 típica tiene 16 pines: 8 para las filas y 8 para las columnas. Sin embargo, en las matrices más comunes, estos pines están organizados en dos grupos de 4 pines, uno en la parte superior y otro en la parte inferior. Para conectar una matriz de LED al Arduino, puedes seguir estos pasos:

1. Conectar las filas (anodos) y columnas (catodos): Identifica los pines de las filas y columnas en la matriz de LED. Esto suele estar especificado en la hoja de datos del componente.
2. Usar resistencias: Para proteger los LEDs de excesiva corriente, conecta resistencias en serie con cada fila o columna.
3. Multiplexado: Utiliza técnicas de multiplexado para controlar cada LED individualmente sin necesidad de usar 64 pines del Arduino. Esto se logra encendiendo rápidamente cada fila o columna una tras otra, haciendo parecer que todos los LEDs están encendidos simultáneamente.

Librerías recomendadas

Para facilitar el uso de matrices de LED, existen varias librerías disponibles en el IDE de Arduino. Una de las más populares es LedControl.

Esta librería simplifica el control de matrices de LED utilizando chips controladores como el MAX7219. Para instalarla:

1. Abre el IDE de Arduino.
2. Ve a «Sketch» > «Incluir Librería» > «Administrar Bibliotecas».
3. Busca «LedControl» e instálala.

Ejemplo de código con la librería LedControl

El siguiente código muestra cómo inicializar y controlar una matriz de LED 8×8 utilizando la librería LedControl:

#include <LedControl.h>

// Configuración de los pines del Arduino al MAX7219
const int DIN = 12;   // Pin de datos
const int CS = 11;    // Pin de carga (load)
const int CLK = 10;   // Pin de reloj

LedControl lc = LedControl(DIN, CLK, CS, 1); // Creación del objeto LedControl

void setup() {
  lc.shutdown(0, false);       // Activa el display
  lc.setIntensity(0, 8);       // Ajusta el brillo (0 a 15)
  lc.clearDisplay(0);          // Limpia el display
}

void loop() {
  // Ejemplo: Encender LEDs en la diagonal
  for (int i = 0; i < 8; i++) {
    lc.setLed(0, i, i, true);
    delay(200);
  }
}

En este ejemplo, configuramos los pines necesarios para el control del MAX7219 y usamos la librería LedControl para encender los LEDs en la diagonal de la matriz.

Este es solo un punto de partida; con esta librería, puedes crear textos desplazantes, gráficos y animaciones más complejas.

Zumbadores (Buzzer)

¿Qué es un zumbador y tipos disponibles?

Un zumbador, conocido en inglés como «buzzer», es un dispositivo electromecánico o piezoeléctrico que emite un sonido cuando se le aplica una señal eléctrica. Los zumbadores se utilizan en una amplia variedad de aplicaciones, como alarmas, timbres y señales auditivas en dispositivos electrónicos.

Existen principalmente dos tipos de zumbadores:

• Zumbadores activos: Estos contienen un oscilador interno que genera el sonido cuando se les aplica una corriente continua (DC). Son fáciles de usar ya que solo requieren un voltaje de alimentación.
• Zumbadores pasivos: Estos necesitan una señal de onda cuadrada (PWM) para producir sonido. Ofrecen mayor flexibilidad en el control del tono y la duración del sonido.

Conexión de un zumbador al Arduino

La conexión de un zumbador activo al Arduino es bastante sencilla, ya que solo requiere dos pines: uno para el voltaje de alimentación y otro para tierra. Aquí te muestro cómo conectar un zumbador activo al Arduino:

• Pin positivo (+) del zumbador al pin digital del Arduino (por ejemplo, el pin 8).
• Pin negativo (-) del zumbador a un pin de tierra (GND) del Arduino.

Para un zumbador pasivo, la conexión es similar, pero se debe enviar una señal PWM desde un pin digital del Arduino para generar sonido.

Librerías y ejemplos de uso

Aunque no es necesario usar librerías para manejar zumbadores, el uso de funciones de la librería tone() de Arduino puede facilitar mucho la generación de tonos y sonidos complejos.

Ejemplo de código para un zumbador activo

El siguiente código muestra cómo utilizar un zumbador activo para generar un sonido simple al encender el Arduino:

const int buzzerPin = 8; // Pin al que está conectado el zumbador

void setup() {
  pinMode(buzzerPin, OUTPUT); // Configura el pin del zumbador como salida
}

void loop() {
  digitalWrite(buzzerPin, HIGH); // Enciende el zumbador
  delay(1000);                   // Espera 1 segundo
  digitalWrite(buzzerPin, LOW);  // Apaga el zumbador
  delay(1000);                   // Espera 1 segundo
}

Ejemplo de código para un zumbador pasivo usando tone()

El siguiente ejemplo muestra cómo generar un tono de 1000 Hz durante 1 segundo utilizando un zumbador pasivo:

const int buzzerPin = 8; // Pin al que está conectado el zumbador

void setup() {
  pinMode(buzzerPin, OUTPUT); // Configura el pin del zumbador como salida
}

void loop() {
  tone(buzzerPin, 1000); // Genera un tono de 1000 Hz
  delay(1000);           // Espera 1 segundo
  noTone(buzzerPin);     // Detiene el tono
  delay(1000);           // Espera 1 segundo
}

Solenoides: Un Ejemplo Icónico de los Toyota de los 80

La campana de aviso de velocidad en los Toyota AE86 y AW11

En los años 80, varios modelos de Toyota, como el AE86 y el AW11, incorporaban un sistema de aviso de velocidad mediante una campana mecánica que se activaba a través de un solenoide.

Este mecanismo se hizo famoso gracias al personaje Takumi Fujiwara de la serie «Initial D», quien conducía un Toyota AE86 equipado con la clásica campana.

¿Qué es un solenoide?

Un solenoide es un dispositivo electromecánico que convierte energía eléctrica en movimiento lineal.

Consiste en una bobina de alambre enrollada en forma de espiral alrededor de un núcleo móvil de material ferromagnético.

Cuando se aplica una corriente eléctrica a la bobina, se genera un campo magnético que mueve el núcleo, produciendo un movimiento lineal.

Funcionamiento de la campana de aviso de velocidad

En los Toyota AE86 y AW11, el solenoide formaba parte de un sistema de aviso de velocidad que se activaba al alcanzar cierta velocidad predeterminada.

La señal proveniente del cuentakilómetros enviaba una corriente al solenoide, que al activarse, movía un núcleo que golpeaba dos placas metálicas, produciendo un sonido característico.

Este sonido servía como alerta al conductor para indicar que había excedido la velocidad establecida.

Conexión y uso de solenoides con Arduino

Integrar un solenoide en un proyecto de Arduino puede añadir funcionalidad electromecánica, como el control de válvulas, cerraduras automáticas, o incluso sistemas de aviso como el mencionado en los Toyota.

Para conectar un solenoide al Arduino, es importante utilizar un transistor o un relé, ya que los solenoides requieren más corriente de la que puede suministrar directamente un pin del Arduino.

Ejemplo de conexión con un transistor

Aquí te mostramos cómo conectar un solenoide utilizando un transistor NPN:

1. Colector del transistor al pin negativo del solenoide.
2. Emisor del transistor a tierra (GND).
3. Base del transistor a un pin digital del Arduino a través de una resistencia (por ejemplo, 220 ohmios).
4. Pin positivo del solenoide al voltaje de alimentación (5V o 12V, según el solenoide).

Ejemplo de código para controlar un solenoide

El siguiente código muestra cómo controlar un solenoide con Arduino usando un transistor NPN:

const int solenoidPin = 7; // Pin digital conectado a la base del transistor

void setup() {
  pinMode(solenoidPin, OUTPUT); // Configura el pin del solenoide como salida
}

void loop() {
  digitalWrite(solenoidPin, HIGH); // Activa el solenoide
  delay(1000);                     // Mantén activado por 1 segundo
  digitalWrite(solenoidPin, LOW);  // Desactiva el solenoide
  delay(1000);                     // Espera 1 segundo antes de repetir
}

Conclusión

Conociendo estos componentes básicos ya puedes realizar infinidad de proyectos.

Si además juntas estos con una impresora 3D para crear carcasas puede quedar algo muy profesional con la estética que tu quieras.

Una vez dominados estos, mi recomendación es adquirir un manual de electrónica y aprender a interactuar con el mundo real.

¿Qué señales se le pueden extraer a un coche?

¿Puedo crear una herramienta similar a Flipper Zero?

Las posibilidades son infinitas, yo mismo sigo aprendiendo cada día potenciales proyectos, cada vez más complejos, no todo son cronómetros o integrar Python y Arduino como prueba de concepto.