Bloque II: Physical Computing y Sistemas Basados en Microcontrolador

Julia Múgica Gallart

Crédito de ejercicios: Carles Araguz

S00: Presentación

Objetivos

Durante este bloque vamos a aprender a construir sistemas físicos interactivos combinando sensores, código y actuadores mediante microcontroladores, a.k.a Physical Computing.

¿Qué es un microcontrolador?

Un microcontrolador permite que el código tenga efectos directos en el mundo físico.

Definición

Un microcontrolador es un pequeño ordenador de bajo consumo diseñado para ejecutar una tarea específica mediante un programa determinado.
Generalmente se encuentra integrado (embebido) dentro de un dispositivo, donde controla su comportamiento interactuando con diferentes componentes electrónicos.

LOS MICROCONTROLADORES ESTÁN EN TODAS PARTES

¿De qué va la asignatura?

1 · Programación de electrónica interactiva

Programar un microcontrolador para que perciba el entorno, tome decisiones y responda en tiempo real.

Luminaria interactiva

2 · Componentes electrónicos de baja potencia

Componentes diseñados para funcionar con muy poco consumo energético.

Funcionan especialmente bien para sistemas autónomos y portables.

3 · Herramientas básicas de prototipado

Construir de forma flexible y rápida un sistema para probar ideas, no para hacer un producto final.

4 · Sensores y actuadores (compatibles con Arduino)

Sensores Permiten percibir inputs del entorno.

Actuadores Permiten actuar sobre el mundo físico.

Sensores + código + actuadores = sistemas interactivos

5 · Plataformas Open-Source / Open-Hardware

El diseño y el código son públicos.

Cualquiera puede modificar y reutilizar.

arduino open hardware and source

Arduino

Microcontrolador de baja potencia al que se le envían instrucciones.
Programable de codigo abierto.
Capaz de leer entradas (sensor de luz, presión de un botón) y convertirlas en salidas (activar un motor, encender un led).
Hace a los objetos interactivos.

¿Por qué Arduino?

Familias Arduino

Arduinos Originales

Clones de Arduino

Y más aqui

Proyectos con Arduino

El diseño puede aplicarse tanto a la construcción de productos funcionales, como a la reflexión crítica sobre la manera en la que nos relacionamos con los objetos.

HELIOS TOCH - James Vanderpant

Iluminación modular sensible al tacto

TIME SAVER – Adrián Pascual

¿Somos conscientes del tiempo que malgastamos consumiendo contenido vacío y de la cantidad de veces que el móvil interrumpe nuestro día a día?

Arduino como herramienta (creativa) para controlar otros dispositivos, materiales, procesos…

LO-FI WOODEN PIXELS DISPLAY

Bloques analógicos de madera que actúan como píxeles digitales.

CHRONOS & KAIROS - Axel Bluhme

Motion Graphics Interfaces

BASURERO INTELIGENTE

Prototipo de basurero interactivo

https://www.youtube.com/watch?v=9yrP1CZN3Ds

Otros proyectos

Useless boxes

Cool projects

and…more…

Evaluación

BLOQUE II – 50 % de la nota final

¿Qué hay que hacer?

20 % — Experimentación con sistemas de sensores y microcontrolador (no recuperable)
- Ejercicios semanales de conexión de Arduino y programación.
- Puntualidad y participación activa en clase (se pasará lista al inicio).
- Seguimiento continuo del proceso y del artefacto digital, incluyendo las entregas programadas.
30 % – Prototipado y programación de un artefacto digital/electrónico basado en Arduino (recuperable)
- (.PDF) Conceptualización y propuesta de realización: originalidad, complejidad y aplicabilidad.
- (.INO) Código fuente: estructura, legibilidad, documentación y eficiencia.
- (----) Entrega física del prototipo + Material gráfico de soporte.

Ejercicios semanales

Se entregan cada semana…duh!

Código (50%)
Vídeo de la arduino ejecutando el código con las conexiones correctas (50%)

Patrón de nomenclatura:

eX_Y_gN.ino
eX_Y_gN.mp4

Ejemplo: e1_2_g5.ino (Ejercicio 1.2 del Grupo 5)

Consideraciones importantes

Solo con justificante válido se permitirá la entrega del ejercicio semanal al final del curso.
El uso de funciones, estructuras o fragmentos de código no vistos en clase se considerará equivalente a un trabajo no presentado. Esto incluye trabajos realizados total o parcialmente mediante Inteligencia Artificial Generativa.
Asistencia != puntualidad.
La asistencia se evaluará a partir de la participación en clase.
La no puntualidad o no asistencia a clase solo podrá justificarse mediante un justificante válido.

Artefacto Digital

Un demostrador tecnológico que ilustre, replique o implemente la funcionalidad de un objeto digital/electrónico, sin necesidad de reproducir la forma o materiales del mismo.

Objetivo del Artefacto Digital

Concebir un sistema digital, implementado a partir de módulos compatibles con Arduino vistos en clase.
Seleccionar e integrar tecnologías de sensores y actuadores en un prototipo de producto funcional.
Programar el código que implementa la función del artefacto.

Realización

Prototipado a nivel electrónico (componentes, módulos comerciales, cableado, sistema de alimentación, etc.)
Código fuente de Arduino.
Material gráfico de soporte visual.

Conceptualización

Realización

Presentación

Prototipado

Materiales

Puedes encontrar la lista de materiales AQUÍ

Calendario

Horarios

Del 9 de febrero al 9 de marzo:
- Lunes 9:30h - 11h - Grupo 1
- Lunes 11:30h - 13h - Grupo 2
Del 16 de marzo al 18 de mayo
- Lunes 9:15 a 11:15h - Grupo 1
- Lunes 12h a 13:30h - Grupo 2

Plan por semanas

Semana	Fecha	Contenido	Entregas
S01	02/feb	Presentación	—
S02	09/feb	Introducción a Arduino, programación y variables	Ejercicios semanales
S03	16/feb	Festivo	—
S04	23/feb	Fundamentos de electrónica y Hello World	Ejercicios semanales
S05	02/mar	Estructuras de control y Botón	Ejercicios semanales
S06	09/mar	Arrays	Ejercicios semanales
S07	16/mar	Estructuras de control II y Buzzer	Ejercicios semanales
S08	23/mar	Inputs analógicos: Potenciómetro	Ejercicios semanales
S09	06/abr	Festivo
S10	13/abr	Inputs analógicos: LDR y outputs analógicos	Ejercicios semanales y Propuesta de Artefacto Digital
S11	20/abr	Outputs analógicos	Ejercicios semanales
S12	27/abr	Expandiendo Arduino (I)	Ejercicios semanales
S13	04/may	Expandiendo Arduino (II)	Ejercicios semanales
S14	11/may	Seguimiento de Artefacto	—
S15	18/may	Seguimiento de Artefacto	—
S16	01/jun	Evaluación	Entrega de Artefacto Digital

Semana

Fecha

Contenido

Entregas

S01

02/feb

Presentación

—

S02

09/feb

Introducción a Arduino, programación y variables

Ejercicios semanales

S03

16/feb

Festivo

—

S04

23/feb

Fundamentos de electrónica y Hello World

Ejercicios semanales

S05

02/mar

Estructuras de control y Botón

Ejercicios semanales

S06

09/mar

Arrays

Ejercicios semanales

S07

16/mar

Estructuras de control II y Buzzer

Ejercicios semanales

S08

23/mar

Inputs analógicos: Potenciómetro

Ejercicios semanales

S09

06/abr

Festivo

S10

13/abr

Inputs analógicos: LDR y outputs analógicos

Ejercicios semanales y Propuesta de Artefacto Digital

S11

20/abr

Outputs analógicos

Ejercicios semanales

S12

27/abr

Expandiendo Arduino (I)

Ejercicios semanales

S13

04/may

Expandiendo Arduino (II)

Ejercicios semanales

S14

11/may

Seguimiento de Artefacto

—

S15

18/may

Seguimiento de Artefacto

—

S16

01/jun

Evaluación

Entrega de Artefacto Digital

S01: Introducción a Arduino

Recordemos: Una arduino es un microcontrolador de baja potencia al que se le envían instrucciones, capaz de leer entradas y convertirlas en salidas.

Hardware

La manera de interactuar con sensores y actuadores es a través de señales eléctricas de voltaje.

Los puertos (o pines) de entrada leen un voltaje generado externamente.
Los puertos (o pines) de salida generan una señal de voltaje internamente.

Entradas y salidas digitales: sólo pueden tomar un valor binario.

0 volts = false = 0 = LOW
5 volts = true = 1 = HIGH

Entradas analógicas: Permiten leer valores continuos.

Arduino convierte un voltaje (normalmente entre 0 y 5 volts) en un número entero positivo.
1. 0 volts = 0
2. 5 volts = valor máximo (1023 en Arduino Uno)

Salidas analógicas: Permiten controlar valores graduales.

Arduino convierte un valor entre 0 y 255 en una señal de salida.
1. 0 volts = 0
2. 5 volts = 255
Estos puertos están etiquetados con el símbolo ~

Puertos de alimentación: Sirven para distribuir energía a los componentes conectados a Arduino.

0 volts = ground (GND)
5 volts = Máximo voltaje en Arduino

Software

¿Qué es un lenguaje de programación?

Arduino IDE

Escribir nuestro código
Comprobar sintaxis
Cargar programa en Arduino
Instalar/gestionar librerías
Depurar el programa.

Link de descarga aquí

Programa vacío de Arduino

arduino loop example

void setup(){

	// put your setup code here, to run once:
}

void loop(){

	// put your main code here, to run repeatedly:
}

setup() y loop()` son funciones predeterminadas en Arduino.

Una función es parte de un programa computacional que ejecuta un comando específico

Sintaxis en Arduino I

El lenguaje de programación de Arduino está basado en el lenguaje de programación c++

Arduino empaqueta funciones que facilitan la interacción con los pines, sensores y actuadores.

Variables

Una variable es una región de la memoria, a la que le asignamos un nombre para guardar un valor.
Es un contenedor de información.
Cada variable tiene un tipo (int, float, bool, etc.) que define qué valores puede almacenar.

Creación y uso de variables

int mi_variable = 10;

int el_nombre_de_variable_que_quiera_pero_que_haga_sentido = 42;

int n = 2;

function setup(){


}

function loop(){
    mi_variable = 20;

    n = n + 1;
}

Notas sobre el código:

int mi_variable = 10; declara una variable de tipo entero
mi_variable = 20; asigna un nuevo valor a la variable
Podemos usar cualquier nombre de variable válido: el_nombre_de_variable_que_quiera_pero_que_haga_sentido
Pero los nombres de variables deben ser descriptivos para que el código sea más fácil de entender
El valor de la variable n va aumentando por 1 cada vez que se ejecuta el bucle loop().

Tipos de variables

La memoria es finita: cada “contenedor” tiene un valor mínimo y máximo.

Números enteros:

int numero = 20;
unsigned int numero_positivo = 10;
long numero_muy_muy_grande = 2000000000;

Números con decimales:

float numero_con_decimal = 3.1416;
double mas_grande_y_más_preciso = 5.12345678987;

Caracteres:

char una_letra = 'h';
String una_frase = 'hola'

Tipo	Tamaño (bits)	Valor mínimo	Valor máximo
int	16	-32,768	32,767
char	8	-128	127
float	32	3.4e-38 (aprox)	3.4e+38 (aprox)
long	32	-2,147,483,648	2,147,483,647
unsigned char	8	0	255
unsigned int	16	0	65,535

Comunicación por Texto (Serial)

Details

Mostrar mensajes de texto por el terminal serie con la clase Serial.

Primero configuramos la transmisión (sólo una vez, dentro de setup)
```
void setup{

	Serial.begin(baudrate)
}
```
Los baud-rates (velocidad de bits) más comunes son: 9600 , 19200, 115200.

Luego, en nuestro loop, podemos escribir tantos mensajes como queramos:

int una_variable = 42;

void loop(){
	Serial.println("mensaje con final de línea");

	Serial.print("mensaje sin final de línea");

	Serial.println(una_variable);


	// Podemos agregar la función delay(ms) que hace que el loop se detenga por x cantidad de milisegundos:

	delay(1000) // el loop se detiene por 1 segundo.

}

Ejercicio (e_1_1): Variables

En este ejercicio declararemos y actualizaremos variables de diferentes tipos en Arduino, e imprimiremos sus valores por el Serial Monitor de forma repetitiva, cada segundo.

Entrega

Sube a Teams, en la carpeta 'BLOQUE_II/e1_1_variables' un archivo comprimido .zip que contenga:

Código de Arduino (.ino)

Grabación de pantalla mostrando los valores impresos en el Serial Monitor (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_1_1_N.zip
- Código: e_1_1_N.ino
- Video: e_1_1_N.mp4

Donde N es tu número de equipo.

Instrucciones

Instalar Arduino IDE
Abre Arduino IDE
Conecta la Arduino al ordenador
Selecciona "Arduino UNO" en el Board Manager:
Escribe un programa en el que haya las siguientes variables:
- Edad persona 1: (un entero)
- Altura persona 1: (con decimales)
- Nombre persona 1: (una cadena de texto)
- Edad persona 2: (un entero)
- Altura persona 2: (con decimales)
- Nombre persona 2: (una cadena de texto)
En el loop, cada segundo representará un año:
- La edad aumentará en 1 año
- La altura disminuirá ligeramente
- El nombre permanecerá igual

El programa debe imprimir estos valores en el Serial Monitor con el siguiente formato de ejemplo:

Serial.print("Nombre: ");
Serial.println(nombre1);
Serial.print("Edad: ");
Serial.println(edad1);
Serial.print("Altura: ");
Serial.println(altura1);

Serial.print("Nombre: ");
Serial.println(nombre2);
Serial.print("Edad: ");
Serial.println(edad2);
Serial.print("Altura: ");
Serial.println(altura2);

Pistas

/* Declarar variables antes de setup() */

int edadAna = 20;
float = ...
String = ....

void setup{

	//Inicializar Serial
	Serial.begin(9600);

}

void loop(){

    // Actualizar las variables de forma lógica
    edadAna = edadAna + 1;

    // Mostrar los valores usando Serial.print() o Serial.println()
	Serial.print("Edad:");
	Serial.println(edadAna);

    // Agregar un retardo entre iteraciones
	delay(1000);
}

S02: Fundamentos de electrónica y Hello World

La energía eléctrica fluye a través de materiales conductivos, como los cables.

La energía eléctrica puede ser convertida en otras formas de energía: encender una luz o emitir un sonido por un altavoz.

Transductores

Los sensores convierten otras formas de energía en energía eléctrica.

Los actuadores convierten la energía eléctrica en otras formas de energía.

Circuito Eléctrico

Corriente (I)

Flujo de electrones a través de un material conductor.

Cuantos más electrones fluyan, más corriente.

La unidad de medida de la corriente es el Amperio (A).

Voltaje (V)

La diferencia de energía entre un punto del circuito y otro.

Los dispositivos de electrónica de consumo suelen trabajar a voltajes bajos (5V).

Resistencia ( R )

Capacidad de un dispositivo de oponerse al paso de la corriente.

Transforma la energía eléctrica en calor.

Permite controlar la corriente que circula en un circuito.

La unidad es el Ohm (Ω).

Ley de Ohm (I = V/R)

La corriente que circula en un circuito con una resistencia es directamente proporcional al voltaje e inversamente proporcional al valor de la resistencia.

Corto Circuito

…o circuito corto!

Ruta de baja resistencia para la corriente.

Esto sucede si conectamos el polo positivo y negativo, sin ningún componente entre los dos.

La energía eléctrica es convertida en calor y luz: explosión.

Circuito Abierto

Para que un circuito funcione se necesita un camino completo desde la fuente (alimentación, 5V), hasta el punto de menor energía (Ground).

SI el circuito pierde conexión entre sus materiales conductores, no fluye corriente: es un circuito abierto.

Componentes básicos

Protoboard

Una protoboard es una placa reutilizable que permite construir y probar circuitos electrónicos sin necesidad de soldar.

Permite:

Prototipar circuitos
Modificar conexiones fácilmente

Conexiones de la Protoboard

Para realizar las conexiones del circuito se utilizan jumper wires (cables puente) para llevar corriente de un punto a otro.

Resistencias

Limita la corriente en un circuito
Protege otros componentes
Convierte parte de la energía eléctrica en calor
Su valor se mide en ohmios (Ω).

Código de colores

LED (Light emitting diode)

Convierte la energía eléctrica en energía lumínica (Actuador).

Los LED son componentes polarizados: solo permiten que la corriente fluya en una única dirección.

La pata más larga (+) del LED se llama ánodo y se conecta a la alimentación (5V).
La pata más corta (-) se llama cátodo y se conecta a tierra (GND).

arduino led catodo anodo

Sintaxis en Arduino II: Hello World

El Hello World en Arduino consiste en hacer parpadear un LED.

Blinking LED

Se utilizan los puertos (pins) digitales de salida.

En setup(), se configura un pin específico como salida:

void setup(){

	pinMode(2, OUTPUT);
}

En este ejemplo, hemos configurado el pin 2 como salida.

Los pines digitales tienen dos estados posibles: HIGH y LOW

HIGH significa: “Hay voltaje en este pin", i.e. está a 5V respecto a GND.

LOW significa: “No hay voltaje en este pin”, i.e. está a 0V respecto a GND..

Cuando configuras un pin como OUTPUT y lo pones en HIGH usando digitalWrite(), estás encendiendo el pin.

void loop()){

	digitalWrite(2, HIGH);
}

Cuando pones un pin configurado como OUTPUT en LOW, estás apagando el pin:

void loop()){

	digitalWrite(2, LOW);
}

Si agregamos un delay entre un encendido y un apagado, podemos hacer un led que parpadee, a.k.a Hello World.

void setup(){

	// Configuramos pin 2 como salida
	pinMode(2, OUTPUT);
}

void loop()){

	// Encendemos el pin 2
	digitalWrite(2, HIGH);

	// Detenemos el loop por 1 segundo
	delay(1000);

	// Apagamos el pin 2
	digitalWrite(2, LOW);

	// Detenemos el loop por 1 segundo
	delay(1000);
}

Vamos a conectar el circuito en la Arduino Física:

Ejercicio (e_2_1): LED Runner

En este ejercicio practicaremos conectar un circuito con 5 LEDs y programaremos una secuencia en la que la luz avanza y retrocede, controlando el encendido y apagado de cada LED con una velocidad ajustable mediante una variable.

Entrega

Sube a Teams, en la carpeta 'BLOQUE_II/e2_1_LedRunner' un archivo comprimido .zip que contenga:

Código de Arduino (.ino)

Grabación de pantalla mostrando el funcionamiento físico del circuito conectado (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_2_1_N.zip
- Código: e_2_1_N.ino
- Video: e_2_1_N.mp4

Donde N es tu número de equipo.

Instrucciones

Conecta un circuito con 5 LEDs en la protoboard y la Arduino.

Cada LED debe estar conectado a un pin digital distinto de la Arduino con su resistencia, y el circuito debe quedar referenciado a GND:

Programa una secuencia en la que los cinco LEDs se enciendan uno a uno de izquierda a derecha, apagándose cada LED antes de que se encienda el siguiente. Al alcanzar el quinto LED, la secuencia debe invertirse y continuar en sentido contrario (de derecha a izquierda), manteniendo el mismo comportamiento.

La velocidad de la secuencia debe poder modificarse mediante una variable:

int speed = 200;

Recuerda inicializar en el setup los pines como salidas:

void setup(){

	pinMode(2, OUTPUT);

	pinMode(3, OUTPUT);
	....
	...
	..
}

Y utilizar digitalWrite() y delay() para encender y apagar los LEDs:

void loop()){

	digitalWrite(2, HIGH);

	delay(speed);

	digitalWrite(2, LOW);

	digitalWrite(3, HIGH);
	....
	...
	..
	.

}

Extra!

Modifica el código para crear el efecto del “coche fantástico”:

Criterios de Evaluación

Puntos	Criterio de evaluación
1	Formato de entrega correcto (.zip en la carpeta indicada, nomenclatura exacta de archivos)
2	Montaje correcto del circuito (5 LEDs con resistencias y conexión adecuada a pines digitales y GND)
3	Funcionamiento de la secuencia izquierda - derecha - izquierda.
3	Uso correcto de variables y funciones vistas en clase.
1	Código ordenado y comentado. NO hay código que no se utilice.
1	Trabajo extra

NOTA: El uso de funciones, estructuras o fragmentos de código no vistos en clase se considerará equivalente a un trabajo no presentado.

S03: Estructuras de control I y Botón

Sintaxis en Arduino III: Condicional if-else

Una expresión booleana es una condición que sólo puede ser:

true
false

Ejemplos

¿Cuáles de estas expresiones son booleanas?

Traigo puesto un jersey

10 < 5

Hoy es Lunes

20 >= 20

Hace calor

Condicional `if()`

El condicional if() nos permite preguntar si una condición es true o false

Si la condición es true, entonces se ejecuta una acción

if(Hoy es lunes) {

	//Instrucciones si la condición es verdadera:
	Aplaude de emoción

}

Condicional `else()`

Si la condición de if() no se cumple, aka es false, entonces se ejecuta otra acción con el condicional else()

Las dos posibilidades son mutuamente excluyentes:

if(Está lloviendo){

	Usar paraguas

} else {

	Usar gafas de sol
}

O usas paraguas o gafas de sol. Nunca ambas a la vez.

Si no utilizaramos el else(), la segunda acción dejaría de ser la alternativa a la primera y se volvería una acción independiente.

Usar gafas de sol

if(Está lloviendo){

	Usar paraguas

}

En este caso, siempre llevas gafas de sol.

Si además llueve, también usas paraguas.

Operadores

Se utilizan para construir expresiones condicionales que se evalúan como verdaderas o falsas.

Tipos

Operador	Definición
>	Verdadero si el valor de la izquierda es mayor que el de la derecha.
<	Verdadero si el valor de la izquierda es menor que el de la derecha.
>=	Verdadero si el valor de la izquierda es mayor o igual que el de la derecha.
⇐	Verdadero si el valor de la izquierda es menor o igual que el de la derecha.
==	Igual que. Verdadero si ambos valores son iguales.
!=	. Verdadero si los valores son diferentes.

Operador

Definición

Verdadero si el valor de la izquierda es mayor que el de la derecha.

Verdadero si el valor de la izquierda es menor que el de la derecha.

Verdadero si el valor de la izquierda es mayor o igual que el de la derecha.

⇐

Verdadero si el valor de la izquierda es menor o igual que el de la derecha.

Igual que. Verdadero si ambos valores son iguales.

. Verdadero si los valores son diferentes.

Operadores lógicos

Se utilizan para combinar o modificar expresiones condicionales.

Tipos

Operador	Definición
AND (&&)	Devuelve verdadero si todas las condiciones que conecta son verdaderas.
OR (\|\|)	Devuelve verdadero si al menos una de las condiciones que conecta es verdadera.
NOT (!)	Invierte el valor de verdad de una condición.

Operador

Definición

AND (&&)

Devuelve verdadero si todas las condiciones que conecta son verdaderas.

OR (||)

Devuelve verdadero si al menos una de las condiciones que conecta es verdadera.

NOT (!)

Invierte el valor de verdad de una condición.

Componentes básicos II: Botón

Un botón es un componente que permite cerrar un circuito eléctrico cuando se acciona.

Hay de muchas formas y dimensiones, pero todos operan igual: cierran el circuito mecánicamente

Leer el estado de un botón

Se utilizan los puertos (pins) digitales de entrada

En setup(), se configura un pin específico como entrada:

void setup(){

	pinMode(2, INPUT);
}

Los pines digitales tienen dos estados posibles: HIGH y LOW

HIGH: Está a 5V respecto a GND.
LOW: Está a 0V respecto a GND.

Cuando configuramos un pin como INPUT y leemos la entrada del pin, podemos saber si está o no presionado el botón.

Para leer el estado del botón utilizamos la función digitalRead().

void loop(){

	//Nos dirá HIGH o LOW
	digitalRead(2);

}

Más documentación sobre digitalRead() aquí.

Conectar un botón

Necesitamos una configuración que permita tanto alimentar el circuito como leer el estado eléctrico con un pin de entrada digital.

Circuito:

El pin de 5V de Arduino se usa como fuente de alimentación para el circuito del botón.
El pin 2 se configura como pin de entrada digital, por lo solo lee el voltaje presente en ese punto del circuito: 5V (HIGH) o 0V (LOW).

Ejercicio (e_3_1): Un botón y un LED

En este ejercicio conectaremos un circuito con un botón y un LED, y programaremos un código para que al presionar el botón, se encienda el LED.

Entrega

Sube a Teams, en la carpeta BLOQUE_II/e_3_1_BotonLed, un archivo comprimido .zip que contenga:

Código de Arduino (.ino)
Grabación del circuito funcionando (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_3_1_N.zip
- Código: e_3_1_N.ino
- Video: e_3_1_N.mp4

Donde N es tu número de equipo.

Este ejercicio cuenta como PARTICIPACIÓN en clase.

Instrucciones

Conecta un circuito con:

1 botón conectado al pin digital de entrada 2, a la alimentación con (5V) y a GND.
1 LED conectado al pin digital de salida 3 y a GND

Programa un código que encienda el LED mientras el botón esté presionado y lo mantenga apagado cuando el botón no esté presionado. Utiliza el condicional if() para implementar esta lógica.
Declara una variable int boton_value para almacenar el valor leído desde el botón.
Imprime en el Serial Monitor "El LED está encendido" cuando se presiona el botón.

// Declaramos una variable para leer la entrada del botón
int boton_value;

void setup(){

	// Configuramos pin 2 como salida para el botón
	pinMode(2, INPUT);

	// Configuramos pin 3 como entrada para el led
	pinMode(3, OUTPUT);

}

void loop() {

	// Leemos el estado del pin 2, y lo almacenamos en la variable boton_value
	boton_value = digitalRead(2);

	//El led está apagado en condiciones normales
	digitalWrite(3, LOW);

	// Implementamos el condicional if()
	if(boton_value == HIGH){ // Si el botón está presionado
		digitalWrite(3, HIGH); // enciende el led

		Serial.println("El led está encendido");
	}

}

Ejercicio (e_3_2): Dos botones y tres LED

En este ejercicio se conectarán tres LEDs y se controlará su comportamiento lumínicon dos botones.

Entrega

Sube al CAMPUS VIRTUAL un archivo comprimido .zip que contenga:

Código de Arduino (.ino)

Grabación del circuito funcionando, mostrando todas las funcionalidades (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_3_2_N.zip
- Código: e_3_2_N.ino
- Video: e_3_2_N.mp4

Donde N es tu número de equipo.

Instrucciones

2 botones conectados a los pines digitales de entrada 2 y 3, a la alimentación con 5V y a GND.
3 LED conectados a los pines digitales de salida 4,5,y 6.
Cada circuito debe quedar referenciado a GND:

Escribe un programa que controle dos botones y tres LEDs utilizando la estructura condicional if-else.

Primero declara las variables necesarias al inicio del código:

Variables para almacenar el estado de los botones (tipo int). Estas variables guardarán el resultado de leer cada botón.
Variables para controlar la velocidad de parpadeo de los LEDs (tipo int). Usar una variable para definir el tiempo de encendido y apagado del parpadeo normal y otra para el parpadeo más rápido.

Programa el código con las siguientes condiciones:

Si se presiona solo el primer botón, el primer LED debe parpadear. Los otros dos LEDs deben mantenerse apagados.
Si se presiona solo el segundo botón, el segundo LED debe encenderse de forma fija, sin parpadeo. El primer y tercer LED deben mantenerse apagados.
Si se presionan los dos botones al mismo tiempo, el tercer LED debe encenderse con un parpadeo más rápido. Para este caso, utiliza el operador lógico AND.

if(state_boton1 == HIGH && state_boton2 == HIGH){
    // Instrucciones para que el tercer LED parpadee rápidamente.
}

Si no se presiona ningún botón, los LEDs se mantienen apagados.

Criterios de Evaluación

Puntos	Criterio de evaluación
1	Formato de entrega correcto (.zip en la carpeta indicada, nomenclatura exacta de archivos)
2	Montaje correcto del circuito.
3	Funcionamiento del ejercicio.
3	Uso correcto de variables y funciones vistas en clase.
1	Código ordenado y comentado. NO hay código que no se utilice.

NOTA: El uso de funciones, estructuras o fragmentos de código no vistos en clase se considerará equivalente a un trabajo no presentado.

S04: Arrays

Sintaxis en Arduino IV Arrays (Arreglos)

En el lenguaje de Arduino, podemos organizar colecciones de N valores del mismo tipo y acceder a cada valor por su índice:

Sintaxis de un array

String semana[7] = {"lunes", "martes", "miercoles", "jueves", "viernes", "sabado", "domingo"};

int num_dias[7] = {9, 10, 11, 12, 13, 14, 15};
void setup(){

	Serial.begin(9600);

}

void loop(){

	Serial.print("Día: ");

	Serial.print(semana[0]);

	Serial.print(", ");

	Serial.println(num_dias[0]);

}

Recorrer un array

Para acceder a cada valor dentro del array, podemos utilizar un índice que vaya aumentando su valor en cada vuelta del loop():

String semana[7] = {"lunes", "martes", "miercoles", "jueves", "viernes", "sabado", "domingo"};

int num_dias[7] = {9, 10, 11, 12, 13, 14, 15};

int indice = 0;

void setup(){

	Serial.begin(9600);

}

void loop(){

	Serial.print("Día: ");

	Serial.print(semana[indice]);

	Serial.print(", ");

	Serial.println(num_dias[indice]);

	delay(1000);

	indice = indice + 1;


}

Ejercicio (e_4_1): Patrones de LEDs

En este ejercicio conectaremos 5 LEDs y programaremos tres patrones de encendido usando arrays y un índice.

Entrega

Sube a Teams, en la carpeta BLOQUE_II/e_4_1_PatronesLED, un archivo comprimido .zip que contenga:

Código de Arduino (.ino)
- Incluye como comentario al principio el nombre de las integrantes del equipo que participaron.
Grabación del circuito funcionando (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_4_1_N.zip
- Código: e_4_1_N.ino
- Video: e_4_1_N.mp4

Donde N es tu número de equipo.

Este ejercicio cuenta como PARTICIPACIÓN en clase.

Instrucciones

Conecta un circuito con:

5 LEDs conectados a los pines digitales de salida 2, 3, 4, 5 y 6 y a GND.

Declara un array int pins[] con los pines de los 5 LEDs y configúralos como OUTPUT en el setup() usando pinMode().
Declara una array de patrón con los valores que tú elijas:
- Cada posición del array corresponde a un LED.
- El valor 1 enciende el LED, el valor 0 lo apaga.
```
int patron1[] = { , , , , };  // inventa tu patrón aquí
```
Declara una variable int indice = 0 que usarás para acceder a cada posición de los arrays dentro del loop().
En cada vuelta del loop(), usa digitalWrite() con pins[indice] y patron1[indice] para encender o apagar el LED correspondiente.
Suma 1 al índice en cada iteración. Cuando el índice sea mayor a 4, reinícialo a 0.

int pins[]    = {2, 3, 4, 5, 6};
int patron1[] = { , , , , };

int indice = 0;

void setup() {

	// Inicializa como OUTPUT cada pin
}

void loop() {

    // Usa digitalWrite para indicar al pin en turno su estado


	// Detener el loop lo suficiente para que el pin mantenga su estado.


	// Apagar el pin antes de pasar al siguiente


	// Aumenta el valor de la variable "indice"


    // Si el valor de indice es igual a 5, regresar su valor a 0.


}

Extra: PARA EL VIERNES 13 DE MARZO

Declara dos arrays adicionales con patrones de encendido distintos:

int patron2[] = { , , , , };
int patron3[] = { , , , , };

Añade una variable int indicePatron = 0 que cambie el patrón activo automáticamente cada vez que indice complete un ciclo completo.

Cuando indicePatron sea 0 → se muestra patron1
Cuando indicePatron sea 1 → se muestra patron2
Cuando indicePatron sea 2 → se muestra patron3

Cuando indicePatron llegue a 3, reinícialo a 0.

Este ejercicio se entrega por TEAMS en la misma carpeta BLOQUE_II/e_4_1_PatronesLED agregando un "extra" a la nomenclatura:

Archivo comprimido: e_4_1_N_extra.zip
- Código: e_4_1_N_extra.ino
- Video: e_4_1_N_extra.mp4

FECHA LÍMITE: Viernes 13 de marzo, 23:55h

S05: Buzzer y Estructuras de Control II

Componentes Básicos III: Buzzer

Un Buzzer o Zumbador es un actuador que convierte la energía eléctrica en sonido.

Contiene una membrana piezoeléctrica que vibra al recibir voltaje, generando sonido.
Activo — oscilador interno, frecuencia fija, solo necesita digitalWrite().
Pasivo — sin oscilador, frecuencia variable, puede usar tone().

Conexión de Buzzer en el circuito

Al igual que el LED, el buzzer tiene polaridad.
El lado + se conecta al pin de salida, el lado - a GND.

Tiene resistencia interna que limita su consumo a ~7mA.
No necesita resistencia externa, a diferencia del LED.

Sintaxis de Arduino V: `for()` loop

El for() loop es una estructura de control que permite ejecutar un bloque de código repetidamente con base en una condición específica.

La semana pasada recorrimos un array con un índice que sumábamos y reiniciábamos a mano.

Recordatorio: contador manual

int indice = 0;
void loop() {
  digitalWrite(pins[indice], patron1[indice]);
  delay(500);
  digitalWrite(pins[indice], LOW);
  indice = indice + 1;
  if (indice == 5) {
    indice = 0;
  }
}

El for() resuelve eso: inicia, avanza y se detiene en la misma línea.

for ( inicio ; condición ; actualización ) {
  // lo que se repite
}

Parte Qué hace Ejemplo

Parte	Qué hace	Ejemplo
`inicio`	Se ejecuta una sola vez al principio	`int indice = 0`
`condición`	Se evalúa antes de cada vuelta. Si es `false`, el loop termina	`indice < 5`
`actualización`	Se ejecuta al final de cada vuelta	`indice = indice + 1`

inicio

Se ejecuta una sola vez al principio

int indice = 0

condición

Se evalúa antes de cada vuelta. Si es false, el loop termina

indice < 5

actualización

Se ejecuta al final de cada vuelta

indice = indice + 1

Uso de for loop I: no hay que reiniciar el índice

El for() termina solo cuando indice llega al límite, sin if() extra.

void loop() {
  for (int indice = 0; indice < 5; indice = indice + 1) {
    digitalWrite(pins[indice], patron1[indice]);
    delay(500);
    digitalWrite(pins[indice], LOW);
  }
  // cuando indice llega a 5, el for termina solo
}

Uso de for loop II: bloqueo secuencial

El for() permite que el código después del bloque solo se ejecuta cuando todas las iteraciones han terminado.

En este ejemplo, solo hasta que buzzer termina el LED se enciende:

int duraciones[] = {100, 300, 100, 500, 200};

void loop() {
  for (int i = 0; i < 5; i=i+1) {
    digitalWrite(8, HIGH);
    delay(duraciones[i]);
    digitalWrite(8, LOW);
    delay(100);
  }
  // esto corre solo cuando las 5 iteraciones terminaron
  digitalWrite(13, HIGH);
}

Ejercicio (e_5_1): LED y Buzzer con for() loop

En este ejercicio conectaremos un LED y un buzzer, y programaremos dos for() loops en secuencia: primero el LED parpadea 3 veces, y cuando termina, el buzzer reproduce un patrón de sonidos.

Entrega

Sube a Teams, en la carpeta BLOQUE_II/e_5_1_LedBuzzer, un archivo comprimido .zip que contenga:

Código de Arduino (.ino)
- Incluyir como comentario al principio el nombre de las integrantes del equipo que participaron.
Grabación del circuito funcionando (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_5_1_N.zip
- Código: e_5_1_N.ino
- Video: e_5_1_N.mp4

Donde N es tu número de equipo.

Este ejercicio cuenta como PARTICIPACIÓN en clase.

Instrucciones

Conecta un circuito con:

1 LED conectado al pin digital de salida 2 y a GND.
1 buzzer conectado al pin digital de salida 8 y a GND.

Programa un código que permita

// Declara un array con 5 duraciones en milisegundos (inventar las duraciones como querais).

int duraciones[] = { , , , , };

void setup() {
  // Configura el pin 2 como OUTPUT (LED)

  // Configura el pin 8 como OUTPUT (buzzer)

}

void loop() {

  // FOR 1: escribe un for() que repita 3 veces lo siguiente:
  //   - Enciende el LED
  //   - Espera 300ms
  //   - Apaga el LED
  //   - Espera 300ms

  // FOR 2: escribe un for() que recorra el array duraciones[] y haga:
  //   - Enciende el buzzer
  //   - Espera duraciones[i] milisegundos
  //   - Apaga el buzzer
  //   - Espera 100ms antes del siguiente sonido

}

Ejercicio (e_5_2): Alarmas con Buzzer y for() loop

En este ejercicio conectaremos un buzzer y un botón para programar tres patrones de alarma distintos controlados por arrays y for() loops.

Entrega

Sube al CAMPUS VIRTUAL un archivo comprimido .zip que contenga:

Código de Arduino (.ino)
- Incluye como comentario al principio el nombre de las integrantes del equipo que participaron.
Grabación del circuito funcionando, mostrando todas las funcionalidades (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_5_2_N.zip
- Código: e_5_2_N.ino
- Video: e_5_2_N.mp4

Donde N es tu número de equipo.

FECHA LÍMITE: viernes 20 de marzo, 23:59h

Instrucciones

Conecta un circuito con:

1 buzzer activo conectado al pin digital de salida 8 y a GND.
1 botón conectado al pin digital de entrada 2, a la alimentación con 5V y a GND.

Declara las variables necesarias al inicio del código:

Tres pares de arrays, uno de duraciones y uno de silencios, con valores distintos para cada alarma. Los valores son libres, pero cada alarma debe sonar claramente diferente a las otras dos:

int duraciones1[] = { , , , , };
int silencios1[]  = { , , , , };

int duraciones2[] = { , , , , };
int silencios2[]  = { , , , , };

int duraciones3[] = { , , , , };
int silencios3[]  = { , , , , };

Una variable int numAlarma = 0 para saber qué patrón de alarma está activo.

Programa el código con las siguientes condiciones:

En el loop(), usa un if() para reproducir el patrón correspondiente según el valor de numAlarma. Por ejmplo, cuando numAlarma sea 0, usa duraciones1 y silencios1.
Cada patrón se reproduce con un for() loop que recorra el array completo. Dentro de cada vuelta del for():
- Enciende el buzzer durante duraciones[i] milisegundos.
- Apaga el buzzer durante silencios[i] milisegundos.
- Lee el botón con digitalRead(). Si está presionado, avanza numAlarma en 1.
- Si numAlarma es mayor a 2, reinícialo a 0.

int duraciones1[] = { , , , , };
int silencios1[]  = { , , , , };

int duraciones2[] = { , , , , };
int silencios2[]  = { , , , , };

int duraciones3[] = { , , , , };
int silencios3[]  = { , , , , };

int numAlarma = 0;

void setup() {
  // Configura el pin 8 como OUTPUT (buzzer)

  // Configura el pin 2 como INPUT (botón)

}

void loop() {

  // Si numAlarma es igual a 0
  	// Para i = 0, hasta i < 3

      // Enciende el buzzer durante duraciones1[i]

      // Apaga el buzzer durante silencios1[i]

      // Lee el botón. Si está presionado, suma 1 a numAlarma
      // Si numAlarma > 2, reinícialo a 0
      // Agrega un delay(300) después de cambiar de alarma


  }

	// Y así para el resto de numAlarma
	....
	....
	....


}

Criterios de Evaluación

Puntos	Criterio de evaluación
1	Formato de entrega correcto (.zip en la carpeta indicada, nomenclatura exacta de archivos)
2	Montaje correcto del circuito.
3	Funcionamiento de los tres patrones de alarma con cambio de botón.
3	Uso correcto de arrays, `for()` loop y lectura del botón dentro del loop.
1	Código ordenado y comentado. NO hay código que no se utilice.

NOTA: El uso de funciones, estructuras o fragmentos de código no vistos en clase se considerará equivalente a un trabajo no presentado.

S06: Inputs analógicos

Los pines analógicos de Arduino convierten un voltaje analógico a un rango de valores.

Lectura de inputs analógicos

analogRead(pin): Leer un voltaje de entrada en un puerto analógico.

int valor = analogRead(A0);

Valores de ejemplo que podemos obtener:

0 = 0 volts
1023 = 5 volts
512 = 2.5 volts
1 = 0.00488 volts

Documentación completa sobre analogRead aquí.

Potenciómetro

Un potenciómetro es un tipo de resistencia ajustable.
Al girarlo, cambia la cantidad de resistencia a la corriente.
Permite regular el voltaje en un circuito de forma gradual.

Para conectarlos al Arduino, el pin central se conecta a un input analógico y los dos del extremo se conectan a 5V y GND

Conexión de potenciómetro en el circuito

Código para leer el potenciómetro

// Declarar variable que guardará el valor recibido del potenciómetro.
int pot_value;

void setup() {

 // Inicializar el monitor serial
 Serial.begin(9600);

 // Configurar el pin análogo A0 como INPUT
 pinMode(A0, INPUT);
}

void loop() {

 // Leer el valor del pin A0 y guardar en variable "pot_value"
 pot_value = analogRead(A0);

 // Imprimir el valor de la variable "pot_value".
 Serial.println(pot_value);
}

Sintáxis en Arduino VI: `map()`

Función que transforma valores de un rango a otro.

int output = map(input, input_min, input_max, output_min, output_max);

Ejemplos!

map(2, 0, 10, 0, 100);

map(5, 0, 10, 0, 100);

map(5, 0, 10, 0, 50);

map(5, 0, 10, 100, 200);

map(5, 0, 10, 100, 0); // Invertido!

map(pot_value, 0, 1023, 0, 10);

\[output = \frac{(input - input_{min}) \times (output_{max} - output_{min})}{input_{max} - input_{min}} + output_{min}\]

Ejercicio (e_6_1): Potenciómetro y LED con `map()`

En este ejercicio conectaremos un potenciómetro para encender un LED únicamente cuando el potenciómetro supere el 50% de su recorrido.

Entrega

Sube a Teams, en la carpeta BLOQUE_II/e_6_1_PotLED, un archivo comprimido .zip que contenga:

Código de Arduino (.ino)
- Incluir como comentario al principio el nombre de las integrantes del equipo que participaron.
Grabación del circuito funcionando (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_6_1_N.zip
- Código: e_6_1_N.ino
- Video: e_6_1_N.mp4

Donde N es tu número de equipo.

Este ejercicio cuenta como PARTICIPACIÓN en clase.

Instrucciones

Conecta un circuito con:

1 LED conectado al pin digital de salida 2 y a GND.
1 potenciómetro con la patilla central conectada al pin analógico A0.

Programa un código siguiendo los siguientes comentarios:

// Declara variable globales para almacenar el valor del potenciómetro
int pot_value;

// Declara variable global para almacenar el valor mapeado del valor del potenciómetro
int pot_mapped;

void setup() {
  // Configura el pin 2 como OUTPUT (LED)
  // Configura el pin A0 como INPUT (potenciómetro)
}

void loop() {
  // Lee el valor del potenciómetro (0–1023) con analogRead()

  // Usa map() para convertir el valor leído del potenciómetro a un rango de 0 a 100

  // Si el porcentaje es mayor que 50:
  //   - Enciende el LED
  // Si no:
  //   - Apaga el LED
}

Ejercicio (e_6_2): Indicador de velocidad

En este ejercicio conectaremos un potenciómetro, tres LEDs y un buzzer para simular un indicador de velocidad. Usaremos map() para convertir la lectura analógica a un rango de 0 a 300, y según el nivel, se encenderán más LEDs y el buzzer sonará con diferente ritmo.

Entrega

Sube al CAMPUS VIRTUAL un archivo comprimido .zip que contenga:

Código de Arduino (.ino)
- Incluye como comentario al principio el nombre de las integrantes del equipo que participaron.
Grabación del circuito funcionando, mostrando todas las funcionalidades (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_6_2_N.zip
- Código: e_6_2_N.ino
- Video: e_6_2_N.mp4

Donde N es tu número de equipo.

FECHA LÍMITE: viernes 27 de marzo, 23:59h

Instrucciones

Conecta un circuito con:

3 LEDs conectados a los pines digitales de salida 2, 3 y 4, cada uno con su resistencia a GND.
1 buzzer activo conectado al pin digital de salida 5 y a GND.
1 potenciómetro con la patilla central conectada al pin analógico A0.

arduino potenciometro buzzer 3leds circuito

El comportamiento del circuito debe ser el siguiente:

Rango (0–300)	LEDs	Buzzer	Situación
0 – 99	1 LED fijo (pin 2)	silencio	Velocidad normal
100 – 199	2 LEDs parpadeando lento (pins 2 y 3)	pita lento (200ms on, 200ms off)	Velocidad alta
200 – 300	3 LEDs parpadeando rápido (pins 2, 3 y 4)	pita rápido (50ms on, 50ms off)	Velocidad peligrosa

Rango (0–300)

LEDs

Buzzer

Situación

0 – 99

1 LED fijo (pin 2)

silencio

Velocidad normal

100 – 199

2 LEDs parpadeando lento (pins 2 y 3)

pita lento (200ms on, 200ms off)

Velocidad alta

200 – 300

3 LEDs parpadeando rápido (pins 2, 3 y 4)

pita rápido (50ms on, 50ms off)

Velocidad peligrosa

Programa el código con las siguientes condiciones:

Lee el potenciómetro con analogRead() y conviértelo con map() a un rango de 0 a 300.
Usa if para determinar en qué rango está el valor.
En cada rango, enciende los LEDs que toquen y apaga los que no. Los LEDs deben parpadear junto con el buzzer usando el mismo delay().
El buzzer debe sonar con ritmo diferente en cada rango (usa digitalWrite() y delay()).

Criterios de Evaluación

Puntos	Criterio de evaluación
1	Formato de entrega correcto (.zip, nomenclatura exacta de archivos)
2	Montaje correcto del circuito (tres LEDs, buzzer y potenciómetro en los pines indicados)
3	Funcionamiento correcto de los tres niveles: LEDs y buzzer responden al potenciómetro.
3	Uso correcto de `map()`, `analogRead()`, `digitalWrite()` y estructura `if`.
1	Código ordenado y comentado. No hay código que no se utilice.

NOTA: El uso de funciones, estructuras o fragmentos de código no vistos en clase se considerará equivalente a un trabajo no presentado.

S07: LDR y Outputs analógicos

Light Dependent Resistor (LDR)

El LDR es uno de los sensores más simples que podemos encontrar.

Es una resistencia variable, cuyo valor depende de la cantidad de luz a la que está expuesta.

Poca luz → Resistencia ALTA
Mucha luz → Resistencia BAJA

Es decir, su resistencia disminuye a medida que aumenta la intensidad de luz:

Conexión del LDR en el circuito

El LDR necesita una resistencia de 10kOhms ente el componente y GND

Como cualquier entrada analógica (ej. potenciómetro), utilizamos analogRead(pin) y los valores que leemos van de 0 a 1023.

Código para leer el LDR

// Declarar variable que guardará el valor recibido del LDR.
int ldr_value;

void setup() {

 // Inicializar el monitor serial
 Serial.begin(9600);

 // Configurar el pin análogo A0 como INPUT
 pinMode(A0, INPUT);

}

void loop() {

 // Leer el valor del pin A0 y guardar en variable "ldr_value"
 ldr_value = analogRead(A0);

 // Imprimir el valor de la variable "ldr_value".
 Serial.println(ldr_value);
}

Output analógico

Arduino en realidad no tiene pines de salida analógica, son todos digitales.

Pero aún así podemos utilizar las salidas digitales como salidas analógicas.

Entonces, lo que hacemos es simular salidas analógicas con una técnica llamada PULSE WIDTH MODULATION (PWM).

Pulse Width Modulation (PWM)

Arduino simula un valor analógico encendiendo y apagando muy rápido la señal eléctrica (corriente) que sale por el pin.

Ajustando el tiempo de encendido/apagado de la señal, se pueden simular voltajes intermedios entre 0V y 5V:

Si está encendido todo el tiempo, 5V
Si está apagado todo el tiempo, 0V
Si está encendido la mitad del tiempo, 2.5V

Los valores para modular la señal van de 0 a 255 (8-bit)

Por lo tanto, los pines de salida analógica son los pines que permiten PWM (marcados con un ~):

Para controlar la salida analógica utilizamos la función analogRead(pin):

void setup(){

	// Definimos el pin 3 (que tiene ~) como output
	pinMode(3, OUTPUT);

}

void loop() {

	// Escribimos la salida en el pin 3, con un valor entre 0 y 255
	analogWrite(3, 127);

}

Ejercicio (e_7_1): Fading LED con contador

En este ejercicio usaremos un contador para incrementar progresivamente el brillo de un LED mediante una señal PWM con analogWrite().

Entrega

Sube a Teams, en la carpeta BLOQUE_II/e_7_1_FadingLED, un archivo comprimido .zip que contenga:

Código de Arduino (.ino)
- Incluir como comentario al principio el nombre de las integrantes del equipo que participaron.
Grabación del circuito funcionando (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_7_1_N.zip
- Código: e_7_1_N.ino
- Video: e_7_1_N.mp4

Donde N es tu número de equipo.

Este ejercicio cuenta como PARTICIPACIÓN en clase.

Instrucciones

Conecta un circuito con:

1 LED conectado al pin PWM de salida 3 y a GND.

Programa un código siguiendo los siguientes comentarios:

int contador = 0;

void setup() {
  // Configura el pin 3 como OUTPUT (LED)
}

void loop() {
  // Escribe el valor del contador en el pin 3 con analogWrite()
  // Espera 10 milisegundos
  // Incrementa el contador en 1
  // Si el contador es mayor o igual a 255:
  //   - Reinicia el contador a 0
}

Ejercicio (e_7_2): Luminaria Adaptativa

En este ejercicio conectaremos un LDR y un LED para simular una luminaria adaptativa. Usaremos analogRead() para leer la luz captada por el LDR y analogWrite() para ajustar la intensidad del LED en función de la luz ambiental.

Cuando haya poca luz, el LED se encenderá con mayor intensidad; cuando haya mucha luz, se atenuará hasta apagarse.

Entrega

Sube al CAMPUS VIRTUAL un archivo comprimido .zip que contenga:

Código de Arduino (.ino)
- Incluye como comentario al principio el nombre de las integrantes del equipo que participaron.
Grabación del circuito funcionando, mostrando todas las funcionalidades (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_7_2_N.zip
- Código: e_7_2_N.ino
- Video: e_7_2_N.mp4

Donde N es tu número de equipo.

FECHA LÍMITE: viernes 17 de abril, 23:59h

Instrucciones

Conecta un circuito con:

1 LDR conectado a un pin de entada analógico.
1 LED conectado a un pin de salida analógica PWM (~).

El comportamiento del circuito debe ser el siguiente:

Programa el código con las siguientes condiciones:

Lee el LDR con analogRead()
Usa map() para transformar el valor leído (0–1023) al rango de analogWrite() (0–255) y guárdalo en la variable int ldr_map.
Usa analogWrite() para controlar el brillo del LED: a mayor valor de ldr_map, menor debe ser la intensidad del LED.
Imprime en el Monitor Serial un mensaje según el nivel de luz:
- Si ldr_map es menor a 85: imprime "Está muy oscuro".
- Si no, si ldr_map es menor a 170: imprime "Luz intermedia".
- Si no: imprime "Hay mucha luz".

Criterios de Evaluación

Puntos	Criterio de evaluación
1	Formato de entrega correcto (.zip, nomenclatura exacta de archivos)
2	Montaje correcto del circuito
3	Funcionamiento correcto: el LED ajusta su brillo según la luz captada por el LDR y los mensajes se imprimen correctamente en el Monitor Serial.
3	Uso correcto de `map()`, `analogRead()`, `analogWrite()` y estructura `if` con opeadores lógicos.
1	Código ordenado y comentado. No hay código que no se utilice.

NOTA: El uso de funciones, estructuras o fragmentos de código no vistos en clase se considerará equivalente a un trabajo no presentado.

S08 Servomotor

S09 Rotary Encoder y el tiempo en Arduino

Rotary Encoder (Encoder rotatorio)

El Rotary encoder es un dispositivo digital que pemite calcular los ángulos de rotación, como un potenciómetro, pero sin estar limitado por un núemro de vueltas predefinido.

La mayoría de los rotary encoder incluyen un botón interno (SW).

Mecanismo interno

En su interior, el encoder tiene un disco al girar interrumpe una señal eléctrica de forma regular, generando pulsos digitales.
El contador de un rotary encoder variará de valor cuando haya pasos completos en la rotación de su mecanismo interno.

El encoder genera dos señales, A y B, con pulsos idénticos pero ligeramente desfasados.
- Si A cambia antes que B, el giro es clockwise (CW);
- Si B cambia antes que A, el giro es counterclockwise (CCW).
Los rotary encoder tienen diferentes resoluciones (pulsos por revolución), que les dan diferentes niveles precisión en la detección del movimiento.

Lectura con Arduino

Arduino debe leer las señales A y B del rotary encoder de forma muy precisa y sin perder información sobre los cambios. Para ello, lo más óptimo es conectar estas señales a puertos que pueda generar interrupciones.

En Arduino UNO, los pins habilitados para interrupciones son el 2 y el 3.

Conexión del Rotary Encoder en el circuito

Código para leer el Rotary Encoder

Para trabajar con el Rotary encoder utilizaremos la librería Encoder de Paul Stoffregen.

// Llamamos a la librería
#include <Encoder.h>

// Creamos un tipo "Encoder", con pins 2 y 3
Encoder mi_encoder(2, 3);

int valor_encoder = 0;
int estado_boton = 0;

void setup() {

  // configuramos el pin 4 como input para el botón
  pinMode(4, INPUT_PULLUP);

  // Inicializamos el monitor serial
  Serial.begin(9600);

}

void loop() {

  // Leer el valor del encoder
  valor_encoder = mi_encoder.read();

  // Imprimir el valor del encoder en el monitor serial
  Serial.print("Valor del encoder = ");
  Serial,println(valor_encoder);

  // Leer el botón
  estado_boton = digitalRead(4);
  if(estado_boton == LOW){
  	Serial.println("Botón presionado");
  }

  delay(100);

}

Ejercicio (e_9_1): Dirección de giro con Rotary Encoder

Leer las señales A y B de un rotary encoder n los pines 2 y 3 para detectar si el giro es clockwise o counter clockwise y mostrar la dirección por el Serial Monitor.

Entrega

Sube a Teams, en la carpeta BLOQUE_II/e_9_1_RotaryEncoder, un archivo comprimido .zip que contenga:

Código de Arduino (.ino)
- Incluir como comentario al principio el nombre de las integrantes del equipo que participaron.
Grabación del circuito funcionando (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_9_1_N.zip
- Código: e_9_1_N.ino
- Video: e_9_1_N.mp4

Donde N es tu número de equipo.

Este ejercicio cuenta como PARTICIPACIÓN en clase.

Instrucciones

Conecta el rotary encoder como vimos en la sección anterior.

Programa un código siguiendo los siguientes comentarios:

#include <Encoder.h>

Encoder mi_encoder(2, 3);

int valor_actual_encoder =0;
int valor_anterior_encoder = 0;


void setup() {
  // Inicia la comunicación Serial

}

void loop() {
  // Lee el valor actual del encoder

  // Si el valor actual es mayor que la anterior:
  //     imprime "Clockwise: " y el valor actual
  // Si no:
  //     imprime "Counter clockwise: " y el valor actual
  //     Actualiza el valor anterior con el valor actual
}

El tiempo en Arduino: `millis()`

Para contar tiempo en Arduino utilizamos millis():

Devuelve el tiempo transcurrido desde el inicio del programa en milisegundos (ms).
Devuelve un valor de tipo unsigned long (32 bits), con un valor máximo de 4,294,967,295 (approx 49.7 días).

Ejemplo: medir duración de una operación

unsigned long t_start = millis();

// ... instrucciones

unsigned long t_end = millis();
unsigned long duration = t_end - t_start;

Usar unsigned long para almacenar el valor de millis(). Si se usa int, el valor desbordará rápidamente y se obtendrán resultados incorrectos.

Documentación completa: millis()

millis() vs delay()

delay() bloquea el programa completamente durante el tiempo indicado: Arduino no puede leer sensores, detectar un botón presionado ni ejecutar ninguna otra tarea mientras espera.

millis() en cambio permite medir el tiempo sin detener el programa, de forma que el resto del código sigue ejecutándose con normalidad.

Ejercicio (e_9_2): Cronómetro entre dos clics

En este ejercicio usaremos millis() para medir el tiempo transcurrido entre haber presionado dos veces el botón SW del Rotary Encoder y mostrar el resultado por el Monitor Serial. El buzzer confirmará el segundo clic con un pitido corto.

Entrega

Sube al CAMPUS VIRTUAL un archivo comprimido .zip que contenga:

Código de Arduino (.ino)
- Incluye como comentario al principio el nombre de las integrantes del equipo que participaron.
Grabación del circuito funcionando, mostrando todas las funcionalidades (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_9_2_N.zip
- Código: e_9_2_N.ino
- Video: e_9_2_N.mp4

Donde N es tu número de equipo.

FECHA LÍMITE: viernes 2 de mayo, 23:59h

Instrucciones

Conecta un circuito con:

Botón SW del rotary encoder al pin 4.
1 Buzzer conectado al pin 5.

Programa el código con las siguientes condiciones:

Al pulsar SW por primera vez, guarda el tiempo actual con millis() e imprime "Primer clic" en el Monitor Serial.
Al pulsar SW por segunda vez, guarda el tiempo final con millis() y calcula la diferencia entre el tiempo actual y el tiempo guardado, imprime el resultado en milisegundos e imprime "Segundo clic".
El buzzer genera un sonido al segundo clic como confirmación.
El programa se reinicia y queda listo para una nueva medición.

unsigned long t_inicio = 0;
insigned long t_final = 0;
int numero_clic = 0;

void setup() {
  // Inicia el monitor serial
  // Configura el pin 4 como INPUT_PULLUP
  // Configura el pin 5 como OUTPUT
}

void loop() {
  // Si el botón SW está presionado:
  //   Incrementa numero_clic en 1
  //   Si numero_clic es 1:
  //     Guarda millis() en la variable t_inicio
  //     Imprime "Primer clic"
  //  Si numero_clic es 2:
  //     Guarda millis() en la variable t_final

  //     Calcula la diferencia: t_final - t_inicio
  //     Imprime "Segundo clic: X milisegundos"
  //     Activa el buzzer 100 milisegundos y apágalo
  //     Reinicia la vaiable numero_clic a 0
  //  Espera 100 milisegundos
}

Criterios de Evaluación

Puntos	Criterio de evaluación
1	Formato de entrega correcto (.zip, nomenclatura exacta de archivos)
2	Montaje correcto del circuito
3	Funcionamiento correcto: mide el tiempo entre dos clics y lo muestra por Serial Monitor. El buzzer indica el segundo clic.
3	Uso correcto de `millis()`, `INPUT_PULLUP`, `OUTPUT` y estructura `if`.
1	Código ordenado y comentado. No hay código que no se utilice.

NOTA: El uso de funciones, estructuras o fragmentos de código no vistos en clase se considerará equivalente a un trabajo no presentado.

S10 Variables de estado y Tira LED NeoPixel

Variables de estado

Arduino no recuerda nada entre una iteración y la siguiente.
Cuando queremos que el programa reaccione diferente según el contexto, necesitamos darle memoria.

Para eso usamos variables de estado: variables que guardan en qué "situación" se encuentra el sistema en cada momento, y que persisten entre iteraciones del loop().

¿Por qué no basta con un if?

Queremos que un botón encienda y apague un LED cada vez que se pulsa.

Un primer intento sin variable de estado:

void loop() {
  if (digitalRead(2) == HIGH) {
    digitalWrite(LED, HIGH); // Encender
  } else {
    digitalWrite(LED, LOW);  // Apagar
  }
}

¿Qué problema tiene esto? El LED solo está encendido mientras el botón está físicamente pulsado. En cuanto sueltas el botón, se apaga. El programa no recuerda si el LED tenía que estar encendido o apagado.

Solución: variable de estado

Añadimos una variable led_encendido que recuerda si el LED debe estar encendido o no, independientemente de si el botón está pulsado ahora mismo:

int led_encendido = 0; // Variable de estado: ¿debe estar encendido el LED?
int boton_anterior  = 0; // Variable de estado del botón en la iteración anterior
int boton_actual = 0;

void loop() {
  boton_actual = digitalRead(2);

  // Solo actuamos cuando el botón pasa de LOW a HIGH (momento del clic)
  if (boton_actual == HIGH && boton_anterior == LOW) {

    // Voltear el estado del LED
    if (led_encendido == 1) {
      led_encendido = 0;
    } else {
      led_encendido = 1;
    }
  }

  // Aplicamos el estado al LED
  if (led_encendido ==1) {
    digitalWrite(LED, HIGH);
  } else {
    digitalWrite(LED, LOW);
  }

  boton_anterior = boton_actual; // Guardamos para la próxima iteración
}

led_encendido es una variable de estado: recuerda si el LED debe estar encendido entre una iteración y la siguiente. El botón no controla el LED directamente, solo cambia el valor de la variable, y la variable controla el LED.
boton_anterior es una variable de estado que nos ayuda a detectar el momento exacto en que se pulsa el botón.
Ahora led_encendido recuerda si el LED debe estar encendido entre una iteración y la siguiente. El botón ya no controla el LED directamente: solo cambia el valor de la variable, y la variable controla el LED.

Tira LED NeoPixel

Los LEDs programables son dispositivos que incorporan 3 o 4 LEDs (RGB o RGBW) junto con un pequeño chip de control en su interior.

A diferencia de un LED normal, estos no necesitan una señal PWM para controlar el brillo. En su lugar, reciben instrucciones digitales a través de un único cable de datos.

También se denominan LEDs direccionables, porque podemos encadenar muchos en serie y controlar cada uno de forma independiente desde un único pin digital de Arduino:

Cada LED de la cadena se denomina pixel. Arduino envía un mensaje con las instrucciones de todos los pixels a la vez, y cada chip se queda con la parte que le corresponde y pasa el resto al siguiente.

Conexión de los LEDs programables

Los LEDs programables necesitan tres conexiones:

VCC → 5V
GND → GND
DIN → Pin digital de Arduino

Para controlarlos utilizamos la librería Adafruit_NeoPixel, que nos permite decidir el color de cada pixel con tres valores (R, G, B) de 0 a 255.

Código básico apra tiras de LED

#include <Adafruit_NeoPixel.h>


// Crear objeto para controlar los LEDs
Adafruit_NeoPixel leds(8, 6, NEO_GRB + NEO_KHZ800);


void setup() {
  // Inicializar la tira de LEDss
  leds.begin();
  leds.setBrightness(128); // Brillo al 50%
  leds.show();
}

void loop() {
  // Poner el primer LED en rojo (R=255, G=0, B=0)
  leds.setPixelColor(0, leds.Color(255, 0, 0));
  leds.show();
}

Funciones principales de la librería

Adafruit_NeoPixel leds(num_leds, pin, config)
Crea el objeto leds para controlar la tira de LEDs.

La config tiene el orden en el que el chip recibe los colores (GRB), y la velocidad con las que se envían los datos (800000 señales por segundo).

leds.setBrightness(255)
Ajusta el brillo global: 0 (mínimo, OFF) a 255 (máximo, 100%).

leds.setPixelColor(pixel_num, leds.Color(R, G, B))
Define el color de un único pixel.

leds.show()
Aplica los cambios y emite los colores.

leds.clear()
Apaga todos los LED.

leds.fill(colorRGB, pixel_inicio, pixel_fin)
Define el color para un intervalo de píxeles.

Documentación básica y ejemplos de uso

Listado completo de funciones de la librería

Ejercicio (e_10_1): Tira de LEDs con variables de estado

Usar un botón para cambiar el patrón de color de una tira de LED entre 4 estados distintos.

Entrega

Sube al CAMPUS VIRTUAL un archivo comprimido .zip que contenga:

Código de Arduino (.ino)
- Incluye como comentario al principio el nombre de las integrantes del equipo que participaron.
Grabación del circuito funcionando, mostrando todas las funcionalidades (.mp4)

Nomenclatura de archivos:

Archivo comprimido: e_10_1_N.zip
- Código: e_10_1_N.ino
- Video: e_10_1_N.mp4

Donde N es tu número de equipo.

FECHA LÍMITE: viernes 8 de mayo, 23:59h

Instrucciones

Conecta la tira de LEDs y el botón como hemos visto en las secciones anteriores.

Cada vez que se pulse el botón, la tira debe cambiar al siguiente estado:

Estado 0: todos los LEDs apagados
Estado 1: todos los LEDs en rojo
Estado 2: todos los LEDs en verde
Estado 3: todos los LEDs en azul

Al llegar al estado 3, el siguiente clic vuelve al estado 0.

Programa un código siguiendo los siguientes comentarios:

#include <Adafruit_NeoPixel.h>

Adafruit_NeoPixel strip(8,6, NEO_GRB + NEO_KHZ800);

int  estado  = 0;   // Variable de estado: 0, 1, 2 o 3
int boton_anterior = 0; // Variable del estado del botón anterior
int boton_actual = 0; // Variable del estado actual del botón

void setup() {


  // Inicializar la tira de LEDs


  // Configurar el pin del botón como INPUT

}

void loop() {
  // Leer el valor actual del botón
  boton_actual = digitalRead(2);

  // Si el botón acaba de ser presionado (antes estaba LOW, ahora HIGH):

    // Sumarle 1 a nuestra variable "estado"

    // Si hemos llegado al último estado, reiniciar la variable estado a 0.

  }

  // Si estado == 0: apagar todos los LEDs (leds.clear())
  // Si estado == 1: poner todos los LEDs en rojo
  // Si estado == 2: poner todos los LEDs en verde
  // Si estado == 3: poner todos los LEDs en azul

  // Mostrar el estado de la tira de led (leds.show())

  // Guardar el estado actual del botón en la variable "boton_anterior" para la próxima iteración

}

Criterios de Evaluación

Puntos	Criterio de evaluación
1	Formato de entrega correcto (.zip, nomenclatura exacta de archivos)
2	Montaje correcto del circuito
3	Funcionamiento correcto: mide el tiempo entre dos clics y lo muestra por Serial Monitor. El buzzer indica el segundo clic.
3	Uso correcto de variables de estado, tira led y estructuras `if()`
1	Código ordenado y comentado. No hay código que no se utilice.

NOTA: El uso de funciones, estructuras o fragmentos de código no vistos en clase se considerará equivalente a un trabajo no presentado.

Artefacto Digital

30% Prototipado y programación de un artefacto digital/electrónico basado en Arduino (recuperable)

Objetivos

Prototipar un artefacto digital con Arduino sin tener que desarrollar su forma física
El artefacto debe tener como MÍNIMO un sensor y dos actuadores.
Programar el código necesario para que el artefacto cumpla su función
Visualizar la forma física que podría tener el objeto y describir cómo se integraría en ella la funcionalidad desarrollada

Componentes permitidos

Actuadores:

LED
LED rgb
Tira LED Neopixel
Buzzer
Servomotor
Motor de vibración
Pantalla OLED

Sensores:

Botón
Potenciómetro
LDR
Encoder rotatorio
Sensor de temperatura/humedad
Sensor de humedad del suelo
Sensor ultrasónico de distancia
Sensor de sonido

La lista de componentes nuevos permitidos está AQUÍ.

Primera Entrega: 13 de abril de 2026

Detalles de entrega

Formato

.PDF

Contenido

Propuesta de realización del artefacto digital.

Descripción

Describir la propuesta de realización del artefacto digital y el objeto al que representa.

El documento tendrá máximo 1 página por propuesta (1 propuesta = 1 página). La propuesta deberá contener como mínimo:

1. Bocetos de contexto y concepto — descripción visual detallada del tipo de sistema electrónico que se quiere concebir, con su función y forma finales.
2. Lista de inputs — qué magnitudes se miden con sensores y qué tipo de interacción tiene el sistema.
3. Lista de outputs — qué cambios o acciones realiza el sistema sobre el entorno o la persona usuaria.
4. Referencias — URL e imágenes.

Fecha límite

13 de abril de 2026

IMPORTANTE: Si no se entrega la propuesta, no será posible realizar la entrega final del proyecto. El equipo se va directo a recuperación.

Entrega Final: 1 de junio de 2026

Detalles de entrega

Formato

Descripción

Presentación presencial

Presentación del prototipo físico del Artefacto Digital.

.PDF

Ficha final del artefacto digital, prototipo en simulador y visualización del objeto al que representa (max. 1 página).

.INO

Código de Arduino implementado para la funcionalidad del artefacto.

Fecha

01 de junio de 2026

Criterios de evaluación

Detalles de evaluación

Entrega	Porcentaje	Criterio
Propuesta de realización del Artefacto Digital	TRUE/FALSE	Claridad y originalidad del concepto y su funcionamiento.
Propuesta de realización y Ficha final del Artefacto Digital	10%	Claridad y originalidad del concepto y su funcionamiento. Visualización de la forma física del artefacto.
Código del Artefacto Digital	10%	Limpieza y claridad del código. Comentarios detallados de su funcionamiento.
Presentación del Artefacto Digital	10%	Funcionamiento correcto y limpieza de presentación.

Entrega

Porcentaje

Criterio

Propuesta de realización del Artefacto Digital

TRUE/FALSE

Claridad y originalidad del concepto y su funcionamiento.

Propuesta de realización y Ficha final del Artefacto Digital

10%

Claridad y originalidad del concepto y su funcionamiento.
Visualización de la forma física del artefacto.

Código del Artefacto Digital

10%

Limpieza y claridad del código.
Comentarios detallados de su funcionamiento.

Presentación del Artefacto Digital

10%

Funcionamiento correcto y limpieza de presentación.

Metodología de trabajo

Antes de escribir una sola línea de código, es importante tener claro qué debe hacer el artefacto. Para eso usamos un diagrama de flujo: una representación visual de cómo se comporta el sistema.

Pasos a seguir

1. Define qué hace tu artefacto
Describan en una frase qué problema resuelve o qué función cumple.

2. Identifica tus inputs y outputs
¿Qué sensores van a usar? ¿Qué actuadores?

3. Dibujen el diagrama de flujo
Representen visualmente cómo fluye la información: qué lee el sistema, qué decisiones toma y qué acciones ejecuta.

4. Identifiquen los estados de tu sistema
¿El artefacto tiene modos o situaciones distintas? Definirlos como variables de estado antes de programar.

5. Programa por partes
No intenten programar todo a la vez. Empiecen por leer un sensor, luego controlar un actuador, luego combínarlos….división del equipo.

6. Prueba y ajusta
Carguen el código, observen qué pasa y ajusten. Es normal que no funcione a la primera!!

Main

Bloque II: Physical Computing y Sistemas Basados en Microcontrolador

S00: Presentación

Objetivos

¿Qué es un microcontrolador?

¿De qué va la asignatura?

Arduino

Proyectos con Arduino

Evaluación

Ejercicios semanales

Artefacto Digital

Materiales

Calendario

S01: Introducción a Arduino

Hardware

Software

Sintaxis en Arduino I

Variables

Comunicación por Texto (Serial)

Ejercicio (e_1_1): Variables

S02: Fundamentos de electrónica y Hello World

Circuito Eléctrico

Componentes básicos

Protoboard

Resistencias

LED (Light emitting diode)

Sintaxis en Arduino II: Hello World

Ejercicio (e_2_1): LED Runner

S03: Estructuras de control I y Botón

Sintaxis en Arduino III: Condicional if-else

Condicional if()

Condicional else()

Operadores

Operadores lógicos

Componentes básicos II: Botón

Leer el estado de un botón

Conectar un botón

Ejercicio (e_3_1): Un botón y un LED

Ejercicio (e_3_2): Dos botones y tres LED

S04: Arrays

Sintaxis en Arduino IV Arrays (Arreglos)

Ejercicio (e_4_1): Patrones de LEDs

S05: Buzzer y Estructuras de Control II

Componentes Básicos III: Buzzer

Sintaxis de Arduino V: for() loop

Ejercicio (e_5_1): LED y Buzzer con for() loop

Ejercicio (e_5_2): Alarmas con Buzzer y for() loop

S06: Inputs analógicos

Potenciómetro

Sintáxis en Arduino VI: map()

Ejercicio (e_6_1): Potenciómetro y LED con map()

Ejercicio (e_6_2): Indicador de velocidad

S07: LDR y Outputs analógicos

Light Dependent Resistor (LDR)

Output analógico

Ejercicio (e_7_1): Fading LED con contador

Ejercicio (e_7_2): Luminaria Adaptativa

S08 Servomotor

S09 Rotary Encoder y el tiempo en Arduino

Rotary Encoder (Encoder rotatorio)

Ejercicio (e_9_1): Dirección de giro con Rotary Encoder

El tiempo en Arduino: millis()

Ejercicio (e_9_2): Cronómetro entre dos clics

S10 Variables de estado y Tira LED NeoPixel

Variables de estado

Tira LED NeoPixel

Ejercicio (e_10_1): Tira de LEDs con variables de estado

Artefacto Digital

Objetivos

Primera Entrega: 13 de abril de 2026

Entrega Final: 1 de junio de 2026

Criterios de evaluación

Metodología de trabajo

Condicional `if()`

Condicional `else()`

Sintaxis de Arduino V: `for()` loop

Sintáxis en Arduino VI: `map()`

Ejercicio (e_6_1): Potenciómetro y LED con `map()`

El tiempo en Arduino: `millis()`