> ## Documentation Index
> Fetch the complete documentation index at: https://apuntes.simulab.es/llms.txt
> Use this file to discover all available pages before exploring further.

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

> Introducción a los microcontroladores con Arduino: qué es un microcontrolador, la placa Arduino Uno, estructura de un programa (setup y loop), salidas digitales y LED, entradas digitales y pulsadores con resistencia de pull-up, entradas analógicas y ADC, PWM, comunicación serie, sensores y actuadores, con ejemplos de código explicados.

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:

```cpp theme={null}
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

```cpp theme={null}
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](https://apuntes.simulab.es/electronica/analogica/transistor-bjt.md) o un [MOSFET](https://apuntes.simulab.es/electronica/analogica/mosfet.md).

### 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:

```cpp theme={null}
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](https://apuntes.simulab.es/electronica/senales/muestreo.md).

```cpp theme={null}
int lectura = analogRead(A0);
float tension = lectura * 5.0 / 1023.0;
```

Muchos sensores resistivos se conectan como un [divisor de tensión](https://apuntes.simulab.es/electronica/componentes/divisor-tension.md) 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

```cpp theme={null}
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

> [accordion] Ejemplo 1 · Regular el brillo con un potenciómetro
>
> ```cpp theme={null}
> 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)`.

> [accordion] 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}$.
>
> ```cpp theme={null}
> 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.

> [accordion] 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:
>
> ```cpp theme={null}
> 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](https://apuntes.simulab.es/electronica/logica-secuencial/maquinas-estados.md), la forma habitual de organizar programas de microcontroladores.

> [accordion] 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):
>
> ```cpp theme={null}
> 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

> [accordion] ¿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.

> [accordion] ¿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](https://apuntes.simulab.es/programacion/python/fundamentos-python.md).

## Temas relacionados

> [card] [Divisor de tensión](https://apuntes.simulab.es/electronica/componentes/divisor-tension.md)
>
> Conectar sensores resistivos.

> [card] [Código de colores](https://apuntes.simulab.es/electronica/componentes/codigo-colores.md)
>
> Identificar las resistencias.

> [card] [Controlador PID](https://apuntes.simulab.es/electronica/control/pid.md)
>
> Un PID programado en un microcontrolador.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.