Categoría: Arduino-robotica

PRIMEROS PASOS CON ARDUINO Y WOKWI
1. Presentación

En este proyecto aprenderás los fundamentos de Arduino utilizando Wokwi, un simulador electrónico que funciona directamente desde el navegador. Durante la primera parte no necesitarás instalar Arduino IDE ni disponer de una placa física.

Realizarás varios ejercicios guiados y resueltos. Deberás reproducirlos, comprobar su funcionamiento, introducir pequeñas modificaciones y documentar el trabajo realizado.

En la última parte trasladarás uno de los circuitos a un Arduino real.

No basta con copiar el código. Debes montar cada circuito, ejecutarlo, observar qué sucede y explicar con tus palabras cómo funciona.

2. Objetivos

Al terminar el proyecto serás capaz de:
- Crear y guardar proyectos en Wokwi.
- Reconocer las partes principales de una placa Arduino Uno.
- Comprender la función de setup() y loop().
- Configurar pines digitales como entradas o salidas.
- Encender y apagar LED.
- Utilizar pausas con delay().
- Enviar información al monitor serie.
- Leer el estado de un pulsador.
- Construir un circuito sencillo en una protoboard.
- Documentar una práctica técnica en formato Markdown.
3. Herramientas necesarias

Parte simulada
- Ordenador con navegador web.
- Cuenta de Wokwi.
- Acceso a https://wokwi.com/.
- Editor de Markdown utilizado en clase.
Parte física final
- Arduino Uno o placa compatible.
- Cable USB.
- Protoboard.
- Un LED rojo, uno amarillo y uno verde.
- Tres resistencias de 220 Ω o 330 Ω.
- Un pulsador.
- Cables de conexión.
- Un equipo preparado por el profesor con Arduino IDE o Arduino Cloud Agent.
4. Normas de trabajo

Para cada ejercicio debes:
1. Crear o duplicar un proyecto en Wokwi.
2. Montar el circuito indicado.
3. Copiar y ejecutar el código proporcionado.
4. Abrir el monitor serie cuando se solicite.
5. Comprobar el resultado.
6. Realizar la modificación propuesta.
7. Guardar el enlace del proyecto.
8. Añadir a la documentación una captura y una explicación personal.
En la documentación no se aceptarán explicaciones como «funciona bien» o «enciende el LED». Debes indicar qué elementos intervienen, qué instrucciones se ejecutan y cuál es el resultado observado.

Parte I. Ejercicios guiados y resueltos en Wokwi

Ejercicio 1. Hola, Arduino: uso del monitor serie

Objetivo

Aprender a enviar mensajes desde Arduino al ordenador mediante la comunicación serie.

Componentes
- Arduino Uno.
No es necesario añadir componentes externos.

Esquema visual

En este ejercicio no existe cableado externo: la salida se observa en el monitor serie.
```
flowchart LR
    A["Arduino Uno"] -->|"USB / comunicación serie a 9600 baudios"| M["Monitor serie de Wokwi"]
    M --> R["Mensajes y resultados"]
```
Preparación en Wokwi
1. Entra en https://wokwi.com/.
2. Selecciona Start from Scratch.
3. Elige Arduino Uno.
4. Abre el archivo sketch.ino.
5. Sustituye su contenido por el siguiente código.
Código resuelto
```
void setup() {
  Serial.begin(9600);
  Serial.println("Arduino iniciado correctamente");
}

void loop() {
  Serial.println("El programa sigue funcionando");
  delay(1000);
}
```
Explicación
- Serial.begin(9600) inicia la comunicación serie a 9600 bits por segundo.
- Serial.println() envía un texto y añade un salto de línea.
- El mensaje incluido en setup() aparece una sola vez.
- El mensaje incluido en loop() se repite cada segundo.
- delay(1000) detiene el programa durante 1000 milisegundos.
Comprobación

Inicia la simulación. La consola o monitor serie debería mostrar:
```
Arduino iniciado correctamente
El programa sigue funcionando
El programa sigue funcionando
El programa sigue funcionando
```
Modificación obligatoria

Modifica el programa para que:
- Muestre tu nombre al comenzar.
- Muestre el texto Han pasado dos segundos cada dos segundos.
Documentación

Incluye una captura del monitor serie y explica por qué el primer mensaje aparece una sola vez y el segundo se repite.

Ejercicio 2. LED integrado intermitente

Objetivo

Controlar una salida digital utilizando el LED integrado de Arduino Uno.

Componentes
- Arduino Uno.
- LED integrado de la placa, conectado internamente al pin 13.
Esquema visual
```
flowchart LR
    A["Arduino Uno"] --> P["Pin digital 13"]
    P --> L["LED integrado L"]
    A -.->|"USB"| M["Monitor serie"]
```
El LED marcado como L ya está montado en la placa. No debes añadir cables ni componentes.

Código resuelto
```
const int LED = 13;

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
  Serial.println("Prueba del LED iniciada");
}

void loop() {
  digitalWrite(LED, HIGH);
  Serial.println("LED encendido");
  delay(1000);

  digitalWrite(LED, LOW);
  Serial.println("LED apagado");
  delay(1000);
}
```
Explicación
- const int LED = 13 asigna un nombre al número del pin.
- pinMode(LED, OUTPUT) configura el pin como salida.
- digitalWrite(LED, HIGH) activa el pin y enciende el LED.
- digitalWrite(LED, LOW) desactiva el pin y apaga el LED.
- Los mensajes permiten relacionar el estado físico del LED con la ejecución del programa.
Modificación obligatoria

Consigue que el LED:
1. Permanezca encendido durante dos segundos.
2. Permanezca apagado durante medio segundo.
3. Muestre los estados correspondientes en el monitor serie.
Preguntas
1. ¿Para qué sirve pinMode()?
2. ¿Qué diferencia hay entre HIGH y LOW?
3. ¿Cuántas veces se ejecuta setup()?
4. ¿Cuántas veces se ejecuta loop()?
Ejercicio 3. Conexión de un LED externo

Objetivo

Aprender a conectar un LED externo y una resistencia a Arduino.

Componentes
- Arduino Uno.
- Un LED rojo.
- Una resistencia de 220 Ω o 330 Ω.
- Cables.
Conexiones

Elemento Conexión
Pin 8 de Arduino Resistencia
Resistencia Pata larga del LED, ánodo
Pata corta del LED, cátodo GND

La resistencia limita la corriente que atraviesa el LED y ayuda a evitar que se dañe.

Esquema visual
```
flowchart LR
    D8["Arduino D8"] --> R["Resistencia 220–330 Ω"]
    R --> A["Ánodo + · pata larga"]
    A --> L["LED rojo"]
    L --> C["Cátodo − · pata corta"]
    C --> G["Arduino GND"]
    USB["Conexión USB"] -.-> M["Monitor serie"]
```
Recorrido de la corriente: D8 → resistencia → ánodo del LED → cátodo → GND.

Código resuelto
```
const int LED_ROJO = 8;
int numeroParpadeo = 0;

void setup() {
  pinMode(LED_ROJO, OUTPUT);
  Serial.begin(9600);
  Serial.println("LED externo preparado");
}

void loop() {
  numeroParpadeo++;

  digitalWrite(LED_ROJO, HIGH);
  Serial.print("Parpadeo numero: ");
  Serial.println(numeroParpadeo);
  delay(500);

  digitalWrite(LED_ROJO, LOW);
  delay(500);
}
```
Explicación

Serial.print() escribe sin realizar un salto de línea. A continuación, Serial.println(numeroParpadeo) muestra el valor y termina la línea. De esta manera, texto y número aparecen juntos.

Resultado esperado
```
LED externo preparado
Parpadeo numero: 1
Parpadeo numero: 2
Parpadeo numero: 3
```
Modificación obligatoria

Conecta el LED al pin 7, adapta el programa y haz que parpadee cada 250 milisegundos.

Preguntas
1. ¿Por qué se utiliza una resistencia?
2. ¿Qué ocurriría si cambias el montaje al pin 7 pero no modificas el código?
3. ¿Para qué sirve la variable numeroParpadeo?
Ejercicio 4. Semáforo sencillo

Objetivo

Controlar varias salidas digitales y crear una secuencia.

Componentes
- Arduino Uno.
- Un LED rojo.
- Un LED amarillo.
- Un LED verde.
- Tres resistencias de 220 Ω o 330 Ω.
Conexiones

LED Pin de Arduino Conexión restante
Rojo 10 Resistencia y GND
Amarillo 9 Resistencia y GND
Verde 8 Resistencia y GND

Cada LED debe disponer de su propia resistencia.

Esquema visual

Los tres puntos GND representan la misma conexión de tierra de Arduino. Puedes unir los tres cátodos a la línea negativa de la protoboard y conectar esa línea a un pin GND de la placa.
```
flowchart LR
    D10["D10"] --> RR["Resistencia"] --> LR["LED rojo"] --> G1["GND"]
    D9["D9"] --> RA["Resistencia"] --> LA["LED amarillo"] --> G2["GND"]
    D8["D8"] --> RV["Resistencia"] --> LV["LED verde"] --> G3["GND"]
```
Código resuelto
```
const int LED_ROJO = 10;
const int LED_AMARILLO = 9;
const int LED_VERDE = 8;

void setup() {
  pinMode(LED_ROJO, OUTPUT);
  pinMode(LED_AMARILLO, OUTPUT);
  pinMode(LED_VERDE, OUTPUT);

  Serial.begin(9600);
  Serial.println("Semaforo iniciado");
}

void loop() {
  digitalWrite(LED_ROJO, HIGH);
  digitalWrite(LED_AMARILLO, LOW);
  digitalWrite(LED_VERDE, LOW);
  Serial.println("ROJO: detenerse");
  delay(3000);

  digitalWrite(LED_ROJO, LOW);
  digitalWrite(LED_VERDE, HIGH);
  Serial.println("VERDE: avanzar");
  delay(3000);

  digitalWrite(LED_VERDE, LOW);
  digitalWrite(LED_AMARILLO, HIGH);
  Serial.println("AMARILLO: precaucion");
  delay(1000);
}
```
Comprobación

Observa que solamente debe permanecer encendido un LED en cada momento. Comprueba que el monitor serie muestra el mismo estado que representa el circuito.

Modificación obligatoria

Cambia los tiempos para que:
- El rojo dure cuatro segundos.
- El verde dure cinco segundos.
- El amarillo dure dos segundos.
Añade antes de cada cambio el mensaje Cambiando estado del semaforo.

Preguntas
1. ¿Por qué se declaran tres constantes diferentes?
2. ¿Qué LED se enciende después del rojo?
3. ¿Cuánto dura una secuencia completa tras realizar la modificación?
4. ¿Por qué conviene mostrar el estado en el monitor serie?
Ejercicio 5. Pulsador y monitor serie

Objetivo

Leer una entrada digital y mostrar su estado en el monitor serie.

Componentes
- Arduino Uno.
- Un pulsador.
- Un LED.
- Una resistencia para el LED.
Conexiones

Elemento Conexión
Una patilla del pulsador Pin 2
Patilla opuesta del pulsador GND
Pin 8 Resistencia y ánodo del LED
Cátodo del LED GND

Se utilizará la resistencia interna de Arduino mediante INPUT_PULLUP. Por ello, el pulsador tendrá lógica invertida:
- Sin pulsar: HIGH.
- Pulsado: LOW.
Esquema visual
```
flowchart LR
    D2["Arduino D2 · INPUT_PULLUP"] --> B["Pulsador"] --> G1["GND"]
    D8["Arduino D8 · OUTPUT"] --> R["Resistencia 220–330 Ω"]
    R --> A["Ánodo + del LED"] --> L["LED"] --> C["Cátodo −"] --> G2["GND"]
```
El pulsador se conecta entre D2 y GND. No necesita una resistencia externa porque el programa activa la resistencia interna con INPUT_PULLUP.

Código resuelto
```
const int PULSADOR = 2;
const int LED = 8;

void setup() {
  pinMode(PULSADOR, INPUT_PULLUP);
  pinMode(LED, OUTPUT);

  Serial.begin(9600);
  Serial.println("Sistema preparado");
}

void loop() {
  int estadoPulsador = digitalRead(PULSADOR);

  if (estadoPulsador == LOW) {
    digitalWrite(LED, HIGH);
    Serial.println("Pulsador presionado - LED encendido");
  } else {
    digitalWrite(LED, LOW);
    Serial.println("Pulsador libre - LED apagado");
  }

  delay(200);
}
```
Explicación
- INPUT_PULLUP configura el pin como entrada y activa una resistencia interna.
- digitalRead() lee el estado del pin.
- La estructura if permite tomar una decisión.
- Cuando se pulsa, el estado leído es LOW y el LED se enciende.
Modificación obligatoria

Modifica únicamente los textos para que el monitor serie muestre:
- ALARMA ACTIVADA al pulsar.
- Sistema en espera al soltar.
Después cambia el LED del pin 8 al pin 6, tanto en el circuito como en el programa.

Preguntas
1. ¿Qué valor devuelve el pulsador cuando está presionado?
2. ¿Por qué en este montaje se considera pulsado cuando devuelve LOW?
3. ¿Qué estructura del código permite decidir si el LED se enciende?
Parte II. Implementación final en Arduino real

Reto final: semáforo físico con diagnóstico serie

En esta parte trasladarás el ejercicio 4 a un Arduino real. Es el único ejercicio del proyecto que debe implementarse físicamente.

Esquema de referencia para el montaje físico
```
   
```
```
flowchart LR
    D10["D10"] --> R1["220–330 Ω"] --> RO["LED rojo"] --> G["Línea GND de la protoboard"]
    D9["D9"] --> R2["220–330 Ω"] --> AM["LED amarillo"] --> G
    D8["D8"] --> R3["220–330 Ω"] --> VE["LED verde"] --> G
    G --> AG["Arduino GND"]
    AU["Arduino Uno"] -.->|"USB"| PC["Arduino IDE y monitor serie"]
```
Antes de conectar el USB, comprueba que la pata larga de cada LED queda orientada hacia su resistencia y la pata corta hacia GND.

Trabajo que debes realizar
1. Recupera tu proyecto del semáforo en Wokwi.
2. Comprueba que la simulación funciona correctamente.
3. Reúne los componentes necesarios.
4. Desconecta la placa del USB mientras realizas el montaje.
5. Conecta los tres LED, cada uno con su propia resistencia.
6. Revisa la polaridad de los LED.
7. Solicita al profesor la revisión del circuito antes de alimentarlo.
8. Conecta Arduino al ordenador.
9. Abre el código con la herramienta indicada por el profesor.
10. Selecciona la placa y el puerto correspondientes.
11. Carga el programa.
12. Abre el monitor serie a 9600 baudios.
13. Comprueba que los LED y los mensajes siguen la misma secuencia.
Requisitos mínimos
- Los tres LED deben funcionar.
- Nunca deben encenderse los tres a la vez.
- Cada LED debe utilizar una resistencia.
- El monitor serie debe indicar el estado actual.
- El montaje físico debe corresponder con los pines declarados en el código.
Pequeña adaptación obligatoria

En el Arduino real, cambia la secuencia para que:
- Rojo: 5 segundos.
- Verde: 4 segundos.
- Amarillo: 2 segundos.
El monitor serie deberá mostrar también la duración de cada estado, por ejemplo:
```
ROJO: detenerse durante 5 segundos
VERDE: avanzar durante 4 segundos
AMARILLO: precaucion durante 2 segundos
```
Evidencias necesarias
- Fotografía general del montaje real.
- Fotografía donde puedan reconocerse los pines utilizados.
- Captura del monitor serie.
- Código final.
- Explicación de las diferencias encontradas entre Wokwi y el montaje físico.
- Breve descripción de cualquier error y de cómo se solucionó.
Seguridad y buenas prácticas
- No cambies conexiones con la placa alimentada.
- No conectes un LED directamente sin resistencia.
- Comprueba la polaridad antes de encender.
- No fuerces los conectores.
- Si el circuito se calienta o se comporta de forma extraña, desconecta el USB y avisa al profesor.
Parte III. Documentación y entrega

Formato de entrega

La documentación se entregará en un archivo llamado:
```
README.md
```
Se redactará en Markdown con el editor utilizado en clase. Además del archivo, se entregará una carpeta img que contenga las capturas y fotografías.

La estructura recomendada es:
```
proyecto-arduino/
├── README.md
└── img/
    ├── ejercicio1-monitor-serie.png
    ├── ejercicio2-led-integrado.png
    ├── ejercicio3-led-externo.png
    ├── ejercicio4-semaforo.png
    ├── ejercicio5-pulsador.png
    └── semaforo-real.jpg
```
Estructura obligatoria del README
```
# Proyecto de iniciación a Arduino

## Datos del alumno

- Nombre:
- Grupo:
- Fecha:

## Introducción

Explicación breve del objetivo del proyecto.

## Ejercicio 1. Monitor serie

### Montaje y funcionamiento

Explicación personal.

### Código

```cpp
// Código utilizado
```

### Resultado

![Monitor serie](img/ejercicio1-monitor-serie.png)

### Modificación realizada

Explicación y resultado.

### Respuestas

Respuestas a las preguntas del ejercicio.

## Ejercicio 2. LED integrado

Repetir la misma organización.

## Ejercicio 3. LED externo

Repetir la misma organización.

## Ejercicio 4. Semáforo

Repetir la misma organización.

## Ejercicio 5. Pulsador

Repetir la misma organización.

## Implementación en Arduino real

Descripción, código, fotografías y problemas encontrados.

## Conclusiones

Qué has aprendido y qué parte te ha resultado más difícil.

## Enlaces a los proyectos de Wokwi

- Ejercicio 1:
- Ejercicio 2:
- Ejercicio 3:
- Ejercicio 4:
- Ejercicio 5:
```
Para evitar problemas al incluir bloques de código dentro del README, utiliza tres acentos graves antes y después del código y escribe cpp junto a los tres primeros.

Requisitos de la documentación

El README.md debe contener:
- Portada o título.
- Datos del alumno.
- Índice.
- Explicación de cada ejercicio con palabras propias.
- Código correctamente presentado en bloques cpp.
- Una captura de cada simulación.
- Capturas del monitor serie.
- Enlaces a los proyectos de Wokwi.
- Respuestas a todas las preguntas.
- Evidencias del montaje real.
- Problemas encontrados y soluciones aplicadas.
- Conclusión personal.
Penalizaciones
- No entregar enlaces funcionales de Wokwi.
- No incluir las capturas solicitadas.
- Presentar código sin explicar su funcionamiento.
- Copiar explicaciones de otras personas o generadas automáticamente sin revisarlas.
- Conectar físicamente LED sin resistencia.
- Entregar un documento distinto de README.md sin autorización.
6. Lista de comprobación antes de entregar
- He completado los cinco ejercicios de Wokwi.
- He realizado todas las modificaciones obligatorias.
- He probado el monitor serie.
- He respondido las preguntas con mis palabras.
- Los enlaces de Wokwi se pueden abrir.
- He construido y probado el semáforo real.
- He incluido el código en bloques Markdown.
- Las imágenes se encuentran dentro de la carpeta img.
- Todas las imágenes aparecen correctamente en el README.md.
- He escrito una conclusión personal.
- El archivo principal se llama exactamente README.md.
7. Ampliación voluntaria

Si terminas antes, modifica el semáforo de Wokwi para que el LED amarillo parpadee tres veces antes de encenderse el rojo. El monitor serie deberá informar de cada parpadeo.

Documenta la ampliación indicando qué instrucciones has añadido y por qué.
septiembre 22, 2026
2 – Lectura y almacenamiento de datos de sensores en Windows
PARTE 1 – Preparar el Arduino para enviar datos correctamente

1.1 Conectar el Arduino
1. Conectar el cable USB tipo A-B.
2. Abrir Arduino IDE.
3. Ir a:
Herramientas → Placa → Arduino Mega 2560
Herramientas → Puerto → Seleccionar el puerto COM correcto.

Si no sabes cuál es:
- Desconecta el cable.
- Mira qué puerto desaparece.
- Vuelve a conectar.
- Ese es el correcto.
1.2 Código base para enviar datos estructurados

Es FUNDAMENTAL que los datos tengan formato fijo.

Ejemplo usando un sensor analógico en A0:
```
void setup() {
  Serial.begin(9600);
}void loop() {
  int valor = analogRead(A0);  
Serial.print("S1;ANALOGICO;");
  Serial.println(valor);  
  delay(2000);
}
```
Esto genera una línea clara:

S1;ANALOGICO;523

Siempre el mismo patrón. Sin texto decorativo.

Subir el programa.

⚠️ Muy importante:
NO abrir el Monitor Serie después. El puerto solo puede usarse por un programa a la vez.

PARTE 2 – Preparar Windows para capturar datos

Windows no guarda automáticamente lo que sale por USB. Necesitamos un programa que lea el puerto serie y lo escriba en un archivo.

La solución más limpia: Python.

PARTE 3 – Instalar Python en Windows

3.1 Descargar

Ir a:
https://www.python.org/downloads/

Descargar versión para Windows.

3.2 Instalación correcta

Durante la instalación:

✔ Marcar “Add Python to PATH”
✔ Install Now

Finalizar instalación.

PARTE 4 – Instalar librería para comunicación serie

Abrir:

Inicio → escribir “cmd” → Enter

Ejecutar:
```
pip install pyserial
```
Si aparece “Successfully installed”, está correcto.

PARTE 5 – Crear el programa que guarda datos

5.1 Crear archivo

En el escritorio:

Crear archivo llamado:

guardar_datos.py

Abrir con Bloc de notas y pegar:
```
import serial
import csv
from datetime import datetime

# CAMBIAR ESTE PUERTO POR EL CORRECTO
PUERTO = "COM3"
BAUDIOS = 9600

try:
    ser = serial.Serial(PUERTO, BAUDIOS, timeout=1)
except:
    print("No se puede abrir el puerto. Verifica el COM.")
    exit()

archivo = open("datos_sensores.csv", mode="a", newline="")
writer = csv.writer(archivo, delimiter=";")

print("Capturando datos... Presiona Ctrl+C para detener.")

try:
    while True:
        linea = ser.readline().decode("utf-8").strip()

        if linea:
            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            datos = linea.split(";")

            fila = datos + [timestamp]
            writer.writerow(fila)
            archivo.flush()

            print(fila)

except KeyboardInterrupt:
    print("Finalizando captura...")
    archivo.close()
    ser.close()
```
Guardar archivo.

PARTE 6 – Ejecutar captura de datos
1. Cerrar el Monitor Serie del IDE.
2. Abrir CMD.
3. Ir al escritorio:
```
cd Desktop
```
1. Ejecutar:
```
python guardar_datos.py
```
Si todo funciona, verás:

[‘S1’, ‘ANALOGICO’, ‘523’, ‘2026-03-02 21:30:10’]

Y se creará automáticamente:

datos_sensores.csv

PARTE 7 – Verificar archivo generado

Abrir el archivo con Excel.

Formato típico:

S1;ANALOGICO;523;2026-03-02 21:30:10
S1;ANALOGICO;517;2026-03-02 21:30:12

Ya tienes registro histórico con timestamp.

Eso significa:
- Persistencia de datos
- Trazabilidad
- Capacidad de análisis
PARTE 8 – Problemas comunes y solución

Error: “Access denied”
→ El Monitor Serie está abierto.

Error: “No se puede abrir el puerto”
→ Puerto incorrecto.

Símbolos extraños
→ Baudrate incorrecto (debe coincidir con Serial.begin).

No se guardan datos
→ El Arduino no está enviando líneas con println.
marzo 2, 2026
3 – Instalación de Raspberry Pi OS y conexión por WiFi (en remoto)
En esta práctica aprenderás a:
- Preparar una tarjeta microSD con Raspberry Pi OS.
- Configurar la Raspberry Pi sin monitor ni teclado (modo headless).
- Conectar la Raspberry Pi a una red WiFi.
- Acceder a ella desde tu portátil mediante SSH.
La Raspberry Pi funcionará como un pequeño servidor Linux conectado por WiFi.

1. Material necesario

Cada grupo necesitará:
- 1 Raspberry Pi
- 1 tarjeta microSD (16GB o más)
- 1 lector de tarjetas microSD
- 1 portátil
- 1 router WiFi del aula
- alimentación para la Raspberry Pi
No se utilizarán:
- monitor
- teclado
- ratón
Toda la administración se hará desde el portátil mediante SSH.

2. Arquitectura de red de la práctica

La red del aula tendrá esta estructura:
```
           Router WiFi Aula
            192.168.1.1
          ~~~~~~~~~~~~~~~~~
         ))               ((
        ))                 ((
       ))                   ((  
  ┌──────────────┐   ┌──────────────┐
  │ Portátil     │   │ Raspberry Pi │
  │ del alumno   │   │              │
  │              │   │  Servidor    │
  │ SSH Client   │──▶│  SSH Server  │
  └──────────────┘   └──────────────┘
```
La Raspberry Pi se conectará al router por WiFi y el alumno accederá mediante SSH.

3. Descarga del sistema operativo

El sistema operativo oficial es:

Raspberry Pi OS

Descargar la herramienta:

Raspberry Pi Imager

desde:

https://www.raspberrypi.com/software

Disponible para:
- Windows
- Linux
- macOS
4. Instalación de Raspberry Pi Imager

En Windows:
1. Descargar el instalador.
2. Ejecutar el archivo .exe.
3. Instalar el programa.
4. Abrir Raspberry Pi Imager.
5. Insertar la tarjeta microSD
1. Introducir la tarjeta en el lector.
2. Conectarla al ordenador.
3. Abrir Raspberry Pi Imager.
Verás tres botones principales:
```
Choose OS
Choose Storage
Write
```
6. Seleccionar el sistema operativo

Pulsar:
```
Choose OS
```
Seleccionar:
```
Raspberry Pi OS Lite (64-bit)
```
Elegimos esta versión porque:
- no tiene entorno gráfico
- consume menos recursos
- es ideal para servidores
- todo se controla por terminal
7. Seleccionar la tarjeta microSD

Pulsar:
```
Choose Storage
```
Elegir la tarjeta microSD conectada al ordenador.

8. Configuración avanzada (muy importante)

Antes de escribir la tarjeta, pulsar el icono del engranaje ⚙.

Aquí configuraremos la Raspberry antes de arrancarla por primera vez.

Nombre de la máquina

Hostname:
```
raspberry01 (deben ser diferentes en casa maquina)
```
Activar SSH

Activar:
```
Enable SSH
```
Elegir:
```
Use password authentication
```
Usuario y contraseña

Crear usuario:
```
usuario: alumno
contraseña: alumno123
```
Configuración WiFi

Activar WiFi e introducir:
```
SSID: nombre_wifi
Password: passwordwifi
```
Configurar también:
```
Country: ES
```
Esto es importante para que la Raspberry pueda usar correctamente el WiFi.

Configuración regional

Configurar:
```
Time zone: Europe/Madrid
Keyboard layout: es
```
9. Escribir el sistema en la tarjeta

Pulsar:
```
Write
```
El programa:
1. descargará el sistema
2. lo copiará a la tarjeta
3. verificará los datos
Este proceso puede tardar varios minutos.

10. Primer arranque de la Raspberry Pi

Cuando termine:
1. sacar la tarjeta microSD
2. insertarla en la Raspberry Pi
3. conectar la alimentación
La Raspberry Pi arrancará automáticamente.

Durante el arranque:
- se conectará al WiFi
- arrancará el servidor SSH
- quedará disponible en la red
El proceso tarda aproximadamente 1 minuto.

11. Descubrir la IP de la Raspberry Pi

Necesitamos saber qué IP le ha asignado el router.

Hay varias formas.

Escaneo de red

En Linux o macOS:
```
arp -a
```
o
```
nmap -sn 192.168.1.0/24
```
12. Conectarse por SSH

Abrir una terminal en el portátil.

Ejecutar:
```
ssh alumno@192.168.1.37
```
(sustituir la IP por la real).

La primera vez aparecerá un aviso de seguridad:
```
The authenticity of host can't be established
```
Escribir:
```
yes
```
Después introducir la contraseña:
```
alumno123
```
Si usas Windows

Puedes usar:

Terminal de Windows
```
ssh alumno@192.168.1.37
```
o el programa:

PuTTY

13. Primera sesión en la Raspberry Pi

Si todo funciona verás algo como:
```
alumno@raspberry01:~ $
```
Ya estás dentro de la Raspberry Pi.

Estás controlando un ordenador remoto desde tu portátil.

14. Comandos básicos de prueba

Información del sistema:
```
uname -a
```
Versión del sistema:
```
cat /etc/os-release
```
Ver la IP:
```
ip a
```
Actualizar el sistema:
```
sudo apt update
sudo apt upgrade
```
marzo 10, 2026
4 – Práctica guiada: varios Arduinos con sensores conectados a una Raspberry Pi y almacenamiento en CSV o JSON
1. Introducción

En esta práctica vais a construir un pequeño sistema de adquisición de datos distribuido. En lugar de trabajar con un único sensor conectado a un solo dispositivo, vais a montar una arquitectura formada por varios Arduinos, cada uno con uno o varios sensores, y una Raspberry Pi que actuará como centro de recepción y almacenamiento.

El objetivo no es solo «leer sensores», sino comprender cómo se organiza un sistema real donde varios nodos capturan información y un equipo central la recibe, la procesa y la guarda para su análisis posterior.

Este tipo de arquitectura se parece mucho a sistemas reales de monitorización, automatización, IoT, domótica o control industrial.

2. Objetivos de la práctica

Al finalizar la práctica, debéis ser capaces de:
- Conectar sensores a varios Arduinos.
- Leer datos de sensores desde Arduino.
- Enviar esos datos por comunicación serie a través de USB.
- Conectar varios Arduinos a una Raspberry Pi.
- Identificar los puertos serie de cada Arduino en Linux.
- Crear en la Raspberry Pi un programa en Python que reciba datos desde varios Arduinos.
- Guardar los datos recibidos en archivos CSV o JSON.
- Documentar correctamente el montaje, el código y el funcionamiento del sistema.
3. Descripción general del sistema

La arquitectura general de la práctica será la siguiente:
```
[Sensores] → [Arduino 1] ┐
[Sensores] → [Arduino 2] ├── USB ──> [Raspberry Pi] ──> [CSV / JSON]
[Sensores] → [Arduino 3] ┘
```
Cada Arduino actuará como nodo de captura de datos.

La Raspberry Pi actuará como:
- receptor central,
- sistema de almacenamiento,
- y punto de análisis de los datos.
4. Material necesario

Cada grupo deberá disponer, como mínimo, de:
- 1 Raspberry Pi con Raspberry Pi OS.
- 2 o más placas Arduino.
- Sensores asignados por el profesor.
- Cables USB para conectar los Arduinos a la Raspberry Pi.
- Protoboard y cables Dupont.
- Resistencias si el sensor lo necesita.
- Tarjeta microSD con sistema operativo funcional en la Raspberry Pi.
- Acceso al terminal de la Raspberry Pi.
Material opcional recomendable
- Hub USB alimentado, si se van a usar muchos Arduinos.
- Teclado, ratón y monitor para la Raspberry Pi, o acceso por SSH.
5. Requisitos mínimos del proyecto

El sistema desarrollado debe cumplir, al menos, con los siguientes requisitos:
1. Usar varios Arduinos conectados a la Raspberry Pi.
2. Cada Arduino debe leer al menos un sensor.
3. Cada Arduino debe enviar sus datos por puerto serie.
4. La Raspberry Pi debe recibir datos de todos los Arduinos.
5. Los datos deben guardarse en un archivo CSV o JSON.
6. Cada dato debe quedar identificado con:
  - fecha y hora,
  - identificador del Arduino,
  - nombre del sensor,
  - valor recibido.
7. El grupo debe entregar documentación técnica y capturas.
FASE 1. Diseño del sistema

6.1. Planificación previa

Antes de montar nada, debéis diseñar vuestro sistema.

Debéis definir:
- Cuántos Arduinos vais a usar.
- Qué sensor o sensores irá conectado a cada Arduino.
- Qué tipo de dato enviará cada uno.
- Qué formato de mensaje vais a usar.
- Si guardaréis los datos en CSV, JSON o ambos.
Ejemplo de reparto
- Arduino 1: temperatura y humedad
- Arduino 2: luz
- Arduino 3: movimiento
6.2. Formato común de los datos

Todos los grupos debéis usar un formato de texto común para enviar los datos desde Arduino a la Raspberry Pi.

Formato recomendado
```
arduino=A1;sensor=temp;valor=23.4
arduino=A1;sensor=hum;valor=41.2
arduino=A2;sensor=luz;valor=820
arduino=A3;sensor=mov;valor=1
```
Reglas del formato
- Cada línea representa una lectura.
- Cada dato estará compuesto por pares clave=valor.
- Los pares estarán separados por ;.
- Cada línea terminará con salto de línea.
Este formato es muy sencillo de leer y muy fácil de procesar en Python.

FASE 2. Montaje del hardware

7. Conexión de sensores a los Arduinos

Cada grupo conectará los sensores asignados a sus placas Arduino.

Recomendaciones
- Revisad siempre el voltaje de trabajo del sensor.
- Comprobad si necesita resistencia pull-up o pull-down.
- Verificad qué pin usaréis: digital o analógico.
- Etiquetad en vuestra documentación qué sensor está conectado a qué pin.
Ejemplo de tabla de montaje

Arduino Sensor Tipo de pin Pin usado
A1 Sensor de temperatura Analógico A0
A1 Sensor de humedad Analógico A1
A2 LDR Analógico A0
A3 PIR Digital D2

8. Conexión de los Arduinos a la Raspberry Pi

Una vez que cada Arduino funcione correctamente con su sensor, debéis conectarlos a la Raspberry Pi mediante USB.

Importante
- Cada Arduino se conectará con su propio cable USB.
- Si no hay suficientes puertos USB en la Raspberry, usad un hub USB.
- Si usáis varios Arduinos, es recomendable que el hub sea alimentado externamente.
FASE 3. Programación de cada Arduino

9. Objetivo del código Arduino

Cada Arduino debe:
1. Inicializar su comunicación serie.
2. Leer el valor del sensor.
3. Construir un mensaje con el formato definido.
4. Enviar ese mensaje por el puerto serie.
5. Repetir el proceso cada cierto tiempo.
10. Estructura general del programa Arduino

Ejemplo genérico
```
const String ID_ARDUINO = "A1";

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

void loop() {
  int valorSensor = analogRead(A0);

  Serial.print("arduino=");
  Serial.print(ID_ARDUINO);
  Serial.print(";sensor=luz;valor=");
  Serial.println(valorSensor);

  delay(2000);
}
```
11. Recomendaciones para el código Arduino
- No enviéis datos demasiado rápido.
- Para empezar, una lectura cada 1 o 2 segundos es suficiente.
- No mezcléis mensajes de depuración con mensajes de datos.
- Usad siempre el mismo formato.
Mal ejemplo
```
Serial.println("Leyendo sensor...");
Serial.println(valor);
```
Buen ejemplo
```
Serial.println("arduino=A1;sensor=luz;valor=830");
```
FASE 4. Comprobación de los Arduinos en la Raspberry Pi

12. Detectar los puertos serie

Cuando conectéis los Arduinos a la Raspberry, debéis comprobar qué puertos se han creado.

Comandos útiles
```
ls /dev/ttyACM*
ls /dev/ttyUSB*
```
También podéis usar:
```
dmesg | tail
```
Posible resultado
```
/dev/ttyACM0
/dev/ttyACM1
/dev/ttyACM2
```
Cada uno suele corresponder a un Arduino distinto.

13. Identificación más estable de los dispositivos

En algunos casos, el nombre /dev/ttyACM0 puede cambiar al reiniciar o reconectar.

Para identificar los puertos de forma más estable, podéis usar:
```
ls /dev/serial/by-id/
```
Esto mostrará nombres más largos, pero normalmente más estables.

14. Prueba manual del puerto serie

Antes de escribir el programa final en Python, comprobad que la Raspberry recibe datos.

Podéis usar herramientas como:
```
cat /dev/ttyACM0
```
O instalar herramientas como screen o minicom.

FASE 5. Preparación del entorno Python en Raspberry Pi

15. Instalar Python y pyserial

Normalmente Python ya estará instalado. Debéis instalar la librería pyserial.
```
sudo apt update
sudo apt install python3-pip -y
pip3 install pyserial
```
Si el sistema os da problemas con permisos, podéis usar entorno virtual o instalar el paquete del sistema si está disponible.

FASE 6. Programa receptor en Raspberry Pi

16. Objetivo del programa Python

El script en Python debe:
- abrir varios puertos serie,
- escuchar los datos de varios Arduinos,
- interpretar cada línea recibida,
- añadir fecha y hora,
- guardar los datos en CSV o JSON.
17. Formato final recomendado de almacenamiento

Opción CSV
```
timestamp,arduino,sensor,valor
2026-03-10 10:15:00,A1,temp,23.4
2026-03-10 10:15:01,A1,hum,41.2
2026-03-10 10:15:03,A2,luz,820
```
Opción JSON (un registro por línea)
```
{"timestamp":"2026-03-10 10:15:00","arduino":"A1","sensor":"temp","valor":"23.4"}
{"timestamp":"2026-03-10 10:15:01","arduino":"A1","sensor":"hum","valor":"41.2"}
{"timestamp":"2026-03-10 10:15:03","arduino":"A2","sensor":"luz","valor":"820"}
```
18. Script Python de ejemplo para varios Arduinos y CSV
```
import serial
import threading
import csv
import os
from datetime import datetime

PUERTOS = [
    "/dev/ttyACM0",
    "/dev/ttyACM1",
    "/dev/ttyACM2"
]

BAUDIOS = 9600
ARCHIVO_CSV = "datos_sensores.csv"
CAMPOS = ["timestamp", "arduino", "sensor", "valor"]
lock_csv = threading.Lock()


def parsear_linea(linea):
    datos = {}
    partes = linea.strip().split(";")
    for parte in partes:
        if "=" in parte:
            clave, valor = parte.split("=", 1)
            datos[clave.strip()] = valor.strip()
    return datos


def inicializar_csv():
    if not os.path.exists(ARCHIVO_CSV) or os.path.getsize(ARCHIVO_CSV) == 0:
        with open(ARCHIVO_CSV, "w", newline="", encoding="utf-8") as f:
            writer = csv.DictWriter(f, fieldnames=CAMPOS)
            writer.writeheader()


def guardar_csv(registro):
    with lock_csv:
        with open(ARCHIVO_CSV, "a", newline="", encoding="utf-8") as f:
            writer = csv.DictWriter(f, fieldnames=CAMPOS)
            writer.writerow(registro)


def escuchar_puerto(puerto):
    try:
        ser = serial.Serial(puerto, BAUDIOS, timeout=1)
        print(f"Escuchando {puerto}")

        while True:
            linea = ser.readline().decode("utf-8", errors="ignore").strip()

            if linea:
                print(f"{puerto} -> {linea}")
                datos = parsear_linea(linea)

                if "arduino" in datos and "sensor" in datos and "valor" in datos:
                    registro = {
                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                        "arduino": datos["arduino"],
                        "sensor": datos["sensor"],
                        "valor": datos["valor"]
                    }
                    guardar_csv(registro)
    except Exception as e:
        print(f"Error en {puerto}: {e}")


def main():
    inicializar_csv()
    hilos = []

    for puerto in PUERTOS:
        hilo = threading.Thread(target=escuchar_puerto, args=(puerto,), daemon=True)
        hilo.start()
        hilos.append(hilo)

    for hilo in hilos:
        hilo.join()


if __name__ == "__main__":
    main()
```
19. Script Python de ejemplo para guardar en JSON
```
import serial
import threading
import json
from datetime import datetime

PUERTOS = [
    "/dev/ttyACM0",
    "/dev/ttyACM1"
]

BAUDIOS = 9600
ARCHIVO_JSON = "datos_sensores.jsonl"
lock_json = threading.Lock()


def parsear_linea(linea):
    datos = {}
    partes = linea.strip().split(";")
    for parte in partes:
        if "=" in parte:
            clave, valor = parte.split("=", 1)
            datos[clave.strip()] = valor.strip()
    return datos


def guardar_json(registro):
    with lock_json:
        with open(ARCHIVO_JSON, "a", encoding="utf-8") as f:
            f.write(json.dumps(registro, ensure_ascii=False) + "\n")


def escuchar_puerto(puerto):
    try:
        ser = serial.Serial(puerto, BAUDIOS, timeout=1)
        print(f"Escuchando {puerto}")

        while True:
            linea = ser.readline().decode("utf-8", errors="ignore").strip()

            if linea:
                print(f"{puerto} -> {linea}")
                datos = parsear_linea(linea)

                if "arduino" in datos and "sensor" in datos and "valor" in datos:
                    registro = {
                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                        "arduino": datos["arduino"],
                        "sensor": datos["sensor"],
                        "valor": datos["valor"]
                    }
                    guardar_json(registro)
    except Exception as e:
        print(f"Error en {puerto}: {e}")


def main():
    hilos = []

    for puerto in PUERTOS:
        hilo = threading.Thread(target=escuchar_puerto, args=(puerto,), daemon=True)
        hilo.start()
        hilos.append(hilo)

    for hilo in hilos:
        hilo.join()


if __name__ == "__main__":
    main()
```
FASE 7. Ejecución del programa

20. Guardar y ejecutar el script

Guardad el script con un nombre como:
```
nano receptor_sensores.py
```
Pegad el código, guardadlo y ejecutadlo:
```
python3 receptor_sensores.py
```
Si todo funciona, deberíais ver en pantalla líneas como estas:
```
/dev/ttyACM0 -> arduino=A1;sensor=temp;valor=23.7
/dev/ttyACM1 -> arduino=A2;sensor=luz;valor=801
/dev/ttyACM2 -> arduino=A3;sensor=mov;valor=1
```
21. Comprobar los archivos generados

Para CSV
```
cat datos_sensores.csv
```
Para JSON
```
cat datos_sensores.jsonl
```
FASE 8. Validación del sistema

22. Qué debéis comprobar

Debéis verificar que:
- todos los Arduinos envían datos,
- la Raspberry recibe los mensajes,
- los datos se guardan correctamente,
- cada línea incluye el identificador del Arduino,
- los archivos se actualizan conforme llegan nuevas lecturas.
23. Pruebas recomendadas

Realizad pruebas como estas:
1. Desconectar un Arduino y comprobar qué ocurre.
2. Volver a conectarlo.
3. Modificar el valor del sensor (por ejemplo, tapar una LDR o mover un PIR).
4. Verificar que el cambio se refleja en el CSV o JSON.
5. Comprobar si el sistema sigue funcionando con varios Arduinos enviando datos al mismo tiempo.
FASE 9. Posibles errores y soluciones

24. Error: no aparece /dev/ttyACM0

Posibles causas
- El cable USB no funciona.
- El Arduino no está correctamente conectado.
- El sistema no ha detectado la placa.
Soluciones
- Probar otro cable.
- Ejecutar dmesg | tail.
- Probar con otro puerto USB.
25. Error: permiso denegado al abrir el puerto serie

Solución posible

Añadir el usuario al grupo adecuado:
```
sudo usermod -a -G dialout $USER
```
Después debéis cerrar sesión y volver a entrar.

26. Error: el script recibe líneas vacías o mal formadas

Posibles causas
- El Arduino está enviando texto extra.
- La velocidad en baudios no coincide.
- El formato del mensaje no es correcto.
Soluciones
- Revisar Serial.begin(9600) en Arduino.
- Comprobar que Python usa la misma velocidad.
- Revisar el formato clave=valor;clave=valor.
Entrega del trabajo

27. Qué debéis entregar

Cada grupo debe entregar:
1. Código de todos los Arduinos.
2. Código Python de la Raspberry Pi.
3. Archivo README o memoria técnica.
4. Esquema del sistema.
5. Fotografías del montaje.
6. Capturas del terminal mostrando la recepción de datos.
7. Ejemplo del CSV o JSON generado.
8. Explicación de problemas encontrados y cómo los resolvisteis.
28. Estructura recomendada de carpetas
```
practica-raspberry-arduinos/
├── README.md
├── arduino/
│   ├── arduino_1/
│   │   └── arduino_1.ino
│   ├── arduino_2/
│   │   └── arduino_2.ino
│   └── arduino_3/
│       └── arduino_3.ino
├── raspberry/
│   ├── receptor_csv.py
│   └── receptor_json.py
├── evidencias/
│   ├── foto_montaje_1.jpg
│   ├── terminal_recepcion.png
│   └── csv_generado.png
└── datos_ejemplo/
    ├── datos_sensores.csv
    └── datos_sensores.jsonl
```
Conclusión

Esta práctica os permitirá trabajar con una arquitectura completa de adquisición de datos usando varios microcontroladores y un sistema Linux central.

No se trata solo de conectar cables y leer números, sino de entender cómo diseñar un sistema modular, organizado y ampliable. Ese enfoque es mucho más valioso que hacer una sola lectura aislada en un monitor serie.

Cuando el sistema funcione, habréis construido una pequeña red de sensores con almacenamiento centralizado, algo muy cercano a muchos proyectos reales de automatización, IoT y monitorización.
marzo 10, 2026

Elemento	Conexión
Pin 8 de Arduino	Resistencia
Resistencia	Pata larga del LED, ánodo
Pata corta del LED, cátodo	GND

LED	Pin de Arduino	Conexión restante
Rojo	10	Resistencia y GND
Amarillo	9	Resistencia y GND
Verde	8	Resistencia y GND

Elemento	Conexión
Una patilla del pulsador	Pin 2
Patilla opuesta del pulsador	GND
Pin 8	Resistencia y ánodo del LED
Cátodo del LED	GND

Arduino	Sensor	Tipo de pin	Pin usado
A1	Sensor de temperatura	Analógico	A0
A1	Sensor de humedad	Analógico	A1
A2	LDR	Analógico	A0
A3	PIR	Digital	D2

Categoría: Arduino-robotica

PRIMEROS PASOS CON ARDUINO Y WOKWI

1. Presentación

2. Objetivos

3. Herramientas necesarias

Parte simulada

Parte física final

4. Normas de trabajo

Parte I. Ejercicios guiados y resueltos en Wokwi

Ejercicio 1. Hola, Arduino: uso del monitor serie

Objetivo

Componentes

Esquema visual

Preparación en Wokwi

Código resuelto

Explicación

Comprobación

Modificación obligatoria

Documentación

Ejercicio 2. LED integrado intermitente

Objetivo

Componentes

Esquema visual

Código resuelto

Explicación

Modificación obligatoria

Preguntas

Ejercicio 3. Conexión de un LED externo

Objetivo

Componentes

Conexiones

Esquema visual

Código resuelto

Explicación

Resultado esperado

Modificación obligatoria

Preguntas

Ejercicio 4. Semáforo sencillo

Objetivo

Componentes

Conexiones

Esquema visual

Código resuelto

Comprobación

Modificación obligatoria

Preguntas

Ejercicio 5. Pulsador y monitor serie

Objetivo

Componentes

Conexiones

Esquema visual

Código resuelto

Explicación

Modificación obligatoria

Preguntas

Parte II. Implementación final en Arduino real

Reto final: semáforo físico con diagnóstico serie

Esquema de referencia para el montaje físico

Trabajo que debes realizar

Requisitos mínimos

Pequeña adaptación obligatoria

Evidencias necesarias

Seguridad y buenas prácticas

Parte III. Documentación y entrega

Formato de entrega

Estructura obligatoria del README

Requisitos de la documentación

Penalizaciones

6. Lista de comprobación antes de entregar

7. Ampliación voluntaria

2 – Lectura y almacenamiento de datos de sensores en Windows

PARTE 1 – Preparar el Arduino para enviar datos correctamente

1.1 Conectar el Arduino

1.2 Código base para enviar datos estructurados

PARTE 2 – Preparar Windows para capturar datos

PARTE 3 – Instalar Python en Windows

3.1 Descargar

3.2 Instalación correcta

PARTE 4 – Instalar librería para comunicación serie

PARTE 5 – Crear el programa que guarda datos