Arduino y microcontroladores: entradas y salidas, PWM, sensores y primeros programas

Un microcontrolador es un pequeño ordenador completo en un solo chip: procesador, memoria y patillas de entrada y salida para leer sensores y controlar luces, motores o pantallas. Está dentro de lavadoras, mandos, coches y termostatos. Arduino es una plataforma de placas y software libre que hace muy fácil programarlos, y es la forma más habitual de empezar con la electrónica programable en institutos y universidades.

Lo que vas a aprender

Qué es un microcontrolador y qué tiene la placa Arduino Uno.
La estructura de un programa de Arduino.
Cómo encender un LED y leer un pulsador.
Las entradas analógicas y el conversor analógico-digital.
Qué es el PWM y para qué sirve.
La comunicación serie y los sensores más habituales.

Fundamentos

La placa Arduino Uno

Característica	Valor
Microcontrolador	ATmega328P, 8 bits, 16 MHz
Memoria de programa (flash)	32 KB
Memoria de datos (RAM)	2 KB
Tensión de trabajo	5 V
Patillas digitales	14 (D0–D13), 6 con PWM (marcadas con ~)
Entradas analógicas	6 (A0–A5), ADC de 10 bits
Corriente máxima por patilla	20 mA recomendados (40 mA máximo absoluto)

Otras placas habituales: el Arduino Nano (igual pero pequeño), el ESP32 (con wifi y Bluetooth, 3,3 V) y la Raspberry Pi Pico.

Estructura de un programa

Un programa (sketch) se escribe en C++ simplificado y tiene dos funciones obligatorias:

void setup() {
  // Se ejecuta una vez al encender: configurar patillas, iniciar el puerto serie…
}

void loop() {
  // Se repite sin parar mientras la placa tenga alimentación.
}

Salidas digitales: el LED

const int LED = 13;

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  digitalWrite(LED, HIGH);   // 5 V
  delay(500);                // espera 500 ms
  digitalWrite(LED, LOW);    // 0 V
  delay(500);
}

Un LED externo siempre lleva una resistencia en serie:

R = \frac{5 - V_{LED}}{I} = \frac{5 - 2}{0{,}015} = 200

Ω, se elige 220 Ω. Para cargas de más corriente (relés, motores) hace falta un transistor o un MOSFET.

Entradas digitales: el pulsador

Una entrada al aire lee valores aleatorios: hay que fijar su nivel con una resistencia. Arduino tiene resistencias de pull-up internas:

const int BOTON = 2;

void setup() {
  pinMode(BOTON, INPUT_PULLUP);   // en reposo lee HIGH
  pinMode(13, OUTPUT);
}

void loop() {
  if (digitalRead(BOTON) == LOW) {   // pulsado: conecta a masa
    digitalWrite(13, HIGH);
  } else {
    digitalWrite(13, LOW);
  }
}

Los pulsadores mecánicos rebotan: durante unos milisegundos dan varios pulsos. Se filtra por programa (esperar unos 20 ms y volver a leer) o con un condensador.

Entradas analógicas

analogRead(A0) convierte una tensión de 0 a 5 V en un número de 0 a 1023 (10 bits). Cada paso son

5/1024 = 4{,}9

mV. Así se leen potenciómetros, LDR, termistores o sensores de temperatura como el TMP36. La teoría está en muestreo y conversión ADC.

int lectura = analogRead(A0);
float tension = lectura * 5.0 / 1023.0;

Muchos sensores resistivos se conectan como un divisor de tensión con una resistencia fija.

PWM

Arduino no tiene salidas analógicas reales: las patillas marcadas con ~ generan modulación por ancho de pulsos, una onda cuadrada de unos 490 Hz cuyo ciclo de trabajo se fija con analogWrite(pin, valor), de 0 (siempre apagado) a 255 (siempre encendido). La tensión media es

V_{media} = 5\cdot\frac{\text{valor}}{255}

. Sirve para regular el brillo de un LED o la velocidad de un motor.

Comunicación serie

void setup() {
  Serial.begin(9600);          // velocidad en baudios
}

void loop() {
  Serial.println(analogRead(A0));
  delay(200);
}

En el ordenador, el monitor serie muestra los valores: es la herramienta básica para depurar.

Sensores y actuadores habituales

Tipo	Ejemplos	Cómo se leen o manejan
Analógicos	Potenciómetro, LDR, TMP36	`analogRead`
Digitales simples	Pulsador, sensor PIR	`digitalRead`
Con protocolo	DHT22 (temperatura y humedad), ultrasonidos HC-SR04, pantallas I²C	Bibliotecas
Actuadores	LED, zumbador, servo, motor con driver, relé	`digitalWrite`, `analogWrite`, `Servo`

Ejemplos resueltos

Ejemplo 1 · Regular el brillo con un potenciómetro

void setup() {
  pinMode(9, OUTPUT);              // patilla con PWM
}

void loop() {
  int pot = analogRead(A0);        // 0 a 1023
  analogWrite(9, pot / 4);         // 0 a 255
}

Dividir entre 4 pasa de 10 bits a 8. También se puede usar map(pot, 0, 1023, 0, 255).

Ejemplo 2 · Termómetro con TMP36

El TMP36 da 0,5 V a 0 °C y sube 10 mV por grado:

T = \frac{V - 0{,}5}{0{,}01}

float v = analogRead(A0) * 5.0 / 1023.0;
float t = (v - 0.5) * 100.0;
Serial.println(t);

Con una lectura de 153,

V = 0{,}748

V y

T = 24{,}8

°C. La resolución es de unos 0,5 °C.

Ejemplo 3 · Parpadeo sin bloquear el programa

delay() detiene todo el programa. Para hacer varias cosas a la vez se usa millis(), que da los milisegundos desde el arranque:

unsigned long anterior = 0;
bool estado = false;

void loop() {
  if (millis() - anterior >= 500) {
    anterior = millis();
    estado = !estado;
    digitalWrite(13, estado);
  }
  // aquí se pueden leer sensores sin esperar
}

Es una pequeña máquina de estados, la forma habitual de organizar programas de microcontroladores.

Ejemplo 4 · Distancia con ultrasonidos

El HC-SR04 da un pulso cuya duración es el tiempo de ida y vuelta del sonido (343 m/s):

digitalWrite(TRIG, HIGH); delayMicroseconds(10); digitalWrite(TRIG, LOW);
long t = pulseIn(ECHO, HIGH);          // microsegundos
float cm = t * 0.0343 / 2;

Un eco de 1166 µs corresponde a 20 cm.

Errores frecuentes

Conectar un LED sin resistencia o un motor directamente a una patilla: se quema la patilla o el microcontrolador.
Dejar entradas al aire sin pull-up ni pull-down: leen valores aleatorios.
Mezclar placas de 5 V y 3,3 V sin adaptar niveles: un ESP32 se puede dañar con 5 V en una entrada.
Usar delay() largos cuando el programa tiene que atender varias cosas a la vez.
Olvidar unir las masas de la placa y de una fuente externa.

Preguntas frecuentes

¿Arduino o Raspberry Pi?

Arduino es un microcontrolador: arranca al instante, controla hardware con precisión de microsegundos y consume muy poco, pero tiene poca memoria. La Raspberry Pi es un ordenador completo con Linux: sirve para tareas con red, cámara, interfaz gráfica o mucho cálculo, pero no es tan buena para el control en tiempo real. Muchos proyectos combinan las dos.

¿Se puede programar en Python?

En Arduino Uno, no (tiene muy poca memoria). En placas más potentes como la Raspberry Pi Pico o el ESP32 se puede usar MicroPython, una versión reducida de Python.

Temas relacionados

Divisor de tensión

Conectar sensores resistivos.

Código de colores

Identificar las resistencias.

Controlador PID

Un PID programado en un microcontrolador.

Matemáticas

Física

Química

Electrónica

Programación

Inglés

Infantil

Arduino y microcontroladores: entradas y salidas, PWM, sensores y primeros programas

Lo que vas a aprender

Fundamentos

La placa Arduino Uno

Estructura de un programa

Salidas digitales: el LED

Entradas digitales: el pulsador

Entradas analógicas

PWM

Comunicación serie

Sensores y actuadores habituales

Ejemplos resueltos

Errores frecuentes

Preguntas frecuentes

Temas relacionados

Divisor de tensión

Código de colores

Controlador PID

​Lo que vas a aprender

​Fundamentos

​La placa Arduino Uno

​Estructura de un programa

​Salidas digitales: el LED

​Entradas digitales: el pulsador

​Entradas analógicas

​PWM

​Comunicación serie

​Sensores y actuadores habituales

​Ejemplos resueltos

​Errores frecuentes

​Preguntas frecuentes

​Temas relacionados

Divisor de tensión

Código de colores

Controlador PID

Lo que vas a aprender

Fundamentos

La placa Arduino Uno

Estructura de un programa

Salidas digitales: el LED

Entradas digitales: el pulsador

Entradas analógicas

PWM

Comunicación serie

Sensores y actuadores habituales

Ejemplos resueltos

Errores frecuentes

Preguntas frecuentes

Temas relacionados