El Blog de Joseca

Después de trabajar por separado con el botón y el potenciómetro, llega un ejercicio más interesante: combinar ambos en un mismo proyecto.

En este artículo aprenderás a usar un botón para encender o apagar un LED y un potenciómetro para controlar su brillo, introduciendo así la lógica combinada entre entrada digital, entrada analógica y salida PWM.

🎯 Objetivo

Encender un LED con un botón y, cuando esté encendido, controlar su brillo con un potenciómetro usando analogRead() y analogWrite().

🧩 ¿Qué se va a combinar?

En este ejercicio intervienen tres elementos importantes:

• Botón → entrada digital
• Potenciómetro → entrada analógica
• LED → salida PWM

El botón decide si el LED debe estar encendido o apagado, mientras que el potenciómetro define qué tan fuerte brillará.

🛠️ Materiales

• 1 Arduino Uno
• 1 LED
• 1 resistencia de 220Ω
• 1 pulsador
• 1 resistencia de 10kΩ
• 1 potenciómetro de 10kΩ
• Protoboard y cables

⚡ Conexión

Botón:

• Un terminal → 5V
• Otro terminal → Pin 7
• Resistencia de 10kΩ entre Pin 7 y GND

Potenciómetro:

• Pin izquierdo → 5V
• Pin derecho → GND
• Pin central → A0

LED:

• Ánodo → Pin 9 (~PWM)
• Cátodo → Resistencia de 220Ω → GND

💻 Código Arduino

int boton = 7;
int pot = A0;
int led = 9;

int estadoBoton = 0;
int valorPot = 0;
int brillo = 0;

void setup() {
  pinMode(boton, INPUT);
  pinMode(led, OUTPUT);
}

void loop() {
  estadoBoton = digitalRead(boton);
  valorPot = analogRead(pot);
  brillo = valorPot / 4;

  if (estadoBoton == HIGH) {
    analogWrite(led, brillo);
  } else {
    analogWrite(led, 0);
  }
}

📖 Explicación

• digitalRead(boton) lee si el botón está presionado
• analogRead(pot) obtiene un valor entre 0 y 1023
• Ese valor se divide entre 4 para convertirlo a un rango de 0 a 255
• analogWrite(led, brillo) ajusta el brillo del LED
• Si el botón no está presionado, el LED permanece apagado

⚙️ ¿Qué está pasando?

Aquí Arduino está trabajando con dos tipos de entrada al mismo tiempo:

• Entrada digital → botón
• Entrada analógica → potenciómetro

Y con base en ambas controla una sola salida:

• Salida PWM → LED

La lógica es esta:

• Si el botón está presionado, el LED se enciende con el brillo indicado por el potenciómetro
• Si el botón no está presionado, el LED permanece apagado

Este ejercicio ya no depende de una sola condición, sino de la combinación de dos entradas.

🚀 Mejora del ejercicio

Puedes ampliar este proyecto de varias formas:

• Mostrar el valor del potenciómetro en el monitor serial
• Hacer que el botón funcione como interruptor de encendido y apagado
• Controlar varios LEDs con diferentes niveles de brillo
• Reemplazar el LED por un buzzer o un motor pequeño

⚠️ Errores comunes

❌ Conectar mal el botón

❌ No colocar la resistencia pull-down de 10kΩ

❌ Olvidar la resistencia del LED

❌ Usar un pin que no tenga PWM para controlar el brillo

❌ Pensar que analogWrite() entrega voltaje analógico real

✅ Conclusión

Este proyecto es importante porque introduce la lógica combinada en Arduino. Ya no se trata solo de leer una entrada o activar una salida, sino de hacer que varios componentes trabajen juntos dentro del mismo programa.

Con un botón que habilita el encendido y un potenciómetro que controla el brillo, empiezas a desarrollar una forma de programar más cercana a proyectos reales, donde varias condiciones determinan el comportamiento de un sistema.

[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458844627181408257 [/warning]

En este punto del aprendizaje, ya has trabajado con LEDs, botones y sensores.

Ahora es momento de usar una herramienta clave en Arduino: El Monitor Serial

🎯 Objetivo

Aprender a usar el Monitor Serial para:

• Mostrar mensajes en pantalla
• Ver el estado de un botón
• Visualizar valores de sensores

🧠 ¿Qué es el Monitor Serial?

El Monitor Serial es una herramienta del IDE de Arduino que permite:

• 📤 Enviar datos desde Arduino a la computadora
• 📥 Recibir datos desde la computadora

👉 Es fundamental para depurar (debug) programas.

⚙️ Configuración básica

Antes de usarlo, debes iniciar la comunicación en el código:

Serial.begin(9600);

👉 Esto establece la velocidad de comunicación (baud rate).

💻 Funciones principales

• Serial.print() → muestra texto en la misma línea
• Serial.println() → muestra texto y baja a la siguiente línea

🔘 Ejercicio 1: Mostrar estado de un botón

🔌 Conexión

(Usa el mismo circuito del botón que ya tienes)

💻 Código Arduino

int boton = 7; 

void setup() { 
	pinMode(boton, INPUT); 
	Serial.begin(9600); 
	
} void loop() { 
	int estado = digitalRead(boton); 
	Serial.print("Estado del botón: "); 
	Serial.println(estado); 
	delay(500); 
}

🔍 ¿Qué verás?

En el Monitor Serial aparecerá:

• 0 → botón no presionado
• 1 → botón presionado

👉 Esto te permite verificar si tu circuito funciona correctamente.

[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458797368993424385 [/warning]

🎛️ Ejercicio 2: Mostrar valores de un sensor (potenciómetro)

🔌 Conexión

(Usa el mismo circuito del potenciómetro que ya tienes)

💻 Código Arduino

int pot = A0; 

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

void loop() { 
	int valor = analogRead(pot); 
	Serial.print("Valor del potenciómetro: "); 
	Serial.println(valor); 
	delay(500); 
}

🔍 ¿Qué verás?

Valores que cambian entre:

👉 0 y 1023

Al girar el potenciómetro, verás cómo los números cambian en tiempo real.

[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458795005088655361 [/warning]

🚀 Mejora del ejercicio

Puedes combinar todo lo aprendido:

• 🔘 Mostrar estado del botón + encender LED
• 🎚️ Mostrar valor del potenciómetro + controlar brillo
• 📊 Crear gráficos usando el “Serial Plotter”

⚠️ Errores comunes

❌ No usar Serial.begin() en setup()

❌ No coincidir la velocidad (9600) con el Monitor Serial

❌ Olvidar seleccionar el puerto correcto

🧾 Conclusión

El Monitor Serial es una herramienta indispensable para cualquier proyecto en Arduino.

👉 Te permite ver lo que está pasando “dentro” del programa, facilitando la detección de errores y la comprensión del funcionamiento.

💡 Consejo: A partir de ahora, acostúmbrate a usar el Monitor Serial en todos tus proyectos. Es como tener una “ventana” al cerebro del Arduino.

Después de trabajar con salidas digitales y PWM, es momento de dar el siguiente paso: leer valores del mundo real.

En este artículo aprenderás a usar un potenciómetro como entrada analógica para controlar el brillo de un LED.

🎯 Objetivo

Leer el valor de un potenciómetro con analogRead() y usar ese valor para controlar el brillo de un LED con analogWrite().

🧠 ¿Qué es un potenciómetro?

Un potenciómetro es una resistencia variable que permite cambiar el voltaje girando una perilla.

👉 Arduino interpreta ese cambio como un valor numérico.

• Valor mínimo → 0
• Valor máximo → 1023

🔌 Materiales

• 1 Arduino Uno
• 1 LED
• 1 resistencia (220Ω)
• 1 potenciómetro (10kΩ recomendado)
• Protoboard y cables

⚡ Conexión

🔘 Potenciómetro:

• Pin izquierdo (VCC) → 5V
• Pin derecho (GND) → GND
• Pin central (SIG) → A0

💡 LED:

• Ánodo → Pin 9 (~PWM)
• Cátodo → Resistencia → GND

💻 Código Arduino

int pot = A0; 
int led = 9; 
int valor = 0; 

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

void loop() { 
	valor = analogRead(pot); // Lee valor (0 - 1023) 
	valor = valor / 4; // Convierte a (0 - 255) 
	analogWrite(led, valor); // Controla brillo 
}

🔍 Explicación

• analogRead(A0) devuelve valores entre 0 y 1023
• analogWrite() trabaja de 0 a 255, por eso dividimos entre 4
• Al girar el potenciómetro, el LED cambia su brillo en tiempo real

🎚️ ¿Qué está pasando?

Estás combinando:

• 📥 Entrada analógica → potenciómetro
• 📤 Salida PWM → LED

👉 Este es uno de los conceptos más importantes en Arduino: leer datos y reaccionar a ellos

🚀 Mejora del ejercicio

Puedes ampliar este proyecto:

• 🔢 Mostrar el valor en el monitor serial
• 🌈 Controlar varios LEDs
• 🔊 Usar el valor para controlar un buzzer
• 🎮 Crear un controlador tipo “volumen”

⚠️ Errores comunes

🧾 Conclusión

El uso del potenciómetro introduce el concepto de entrada analógica, fundamental para trabajar con sensores en proyectos más avanzados.

💡 Consejo: Este mismo principio se usa con sensores reales como temperatura, luz o sonido.

[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458786656051462145 [/warning]

Después de aprender a encender y apagar un LED, el siguiente paso es hacerlo más interesante: controlar su brillo.

Para lograrlo, Arduino utiliza una técnica llamada PWM (Modulación por Ancho de Pulso).

🎯 Objetivo

Controlar la intensidad (brillo) de un LED utilizando la función analogWrite().

🌈 Efecto Fade (subir y bajar brillo)

🧠 ¿Qué es PWM?

PWM significa Pulse Width Modulation (Modulación por Ancho de Pulso).

👉 Aunque Arduino no tiene salidas analógicas reales, simula una señal analógica encendiendo y apagando el LED muy rápidamente.

• Más tiempo encendido → más brillo
• Menos tiempo encendido → menos brillo

🔌 Pines PWM en Arduino Uno

Los pines que permiten PWM son:

👉 3, 5, 6, 9, 10 y 11 (marcados con ~)

🧰 Materiales

• 1 Arduino Uno
• 1 LED
• 1 resistencia (220Ω)
• Protoboard y cables

⚡ Conexión

• LED (ánodo) → Pin 9 (~PWM)
• LED (cátodo) → Resistencia → GND

💻 Código Arduino

int led = 9; 

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

void loop() { 
	// Aumenta brillo 
	for (int i = 0; i <= 255; i++) { 
		analogWrite(led, i); 
		delay(5); 
	} 
	// Disminuye brillo 
	for (int i = 255; i >= 0; i--) { 
		analogWrite(led, i); 
		delay(5); 
	} 
}

🔍 Explicación

• analogWrite(pin, valor) controla el brillo
• El valor va de:
• 0 → apagado
• 255 → máximo brillo

🚀 Mejora del ejercicio

Puedes hacer este proyecto más interesante:

• 🎚️ Controlar brillo con un potenciómetro
• 🔘 Cambiar niveles de brillo con un botón
• 💡 Usar varios LEDs con diferentes intensidades

⚠️ Errores comunes

🧾 Conclusión

El uso de PWM permite controlar dispositivos de manera más precisa, como la intensidad de luces o la velocidad de motores. Es una herramienta fundamental para proyectos más avanzados en Arduino.

💡 Consejo: Experimenta con diferentes valores entre 0 y 255 para ver cómo cambia el brillo del LED.

[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458784387357356033 [/warning]

En los primeros proyectos con Arduino es común usar la función delay() para controlar el tiempo. Sin embargo, esta función tiene una gran limitación: detiene completamente el programa mientras espera.

En este artículo aprenderás a hacer parpadear un LED sin usar delay(), utilizando una técnica más avanzada y profesional con la función millis().

🎯 Objetivo

Lograr que un LED parpadee sin bloquear el programa, permitiendo ejecutar otras tareas al mismo tiempo.

⚠️ Problema con delay()

Ejemplo clásico:

    digitalWrite(led, HIGH);

    delay(1000);

    digitalWrite(led, LOW);

    delay(1000);

👉 ¿Qué pasa aquí?

• Arduino se detiene completamente durante cada delay()
• No puede leer botones ni sensores en ese tiempo
• No permite hacer múltiples tareas

🧠 ¿Qué es millis()?

La función millis() devuelve el tiempo en milisegundos desde que el Arduino comenzó a ejecutar el programa.

👉 Es como un cronómetro interno que nunca se detiene.

🔌 Materiales

• 1 Arduino Uno
• 1 LED
• 1 resistencia (220Ω)
• Protoboard y cables

⚡ Conexión

• LED (ánodo) → Pin 8
• LED (cátodo) → Resistencia → GND

💻 Código Arduino

int led = 8; 
unsigned long tiempoAnterior = 0; 
int intervalo = 1000;    // 1 segundo 
int estadoLed = LOW; 

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

void loop() { 
	unsigned long tiempoActual = millis(); 
	if (tiempoActual - tiempoAnterior >= intervalo) { 
		tiempoAnterior = tiempoActual;    // Cambia el estado del LED 
		if (estadoLed == LOW) { 
			estadoLed = HIGH; 
			} 
		else { estadoLed = LOW; 
		} 
		digitalWrite(led, estadoLed); 
	} 
}

🔍 Explicación del Código

• millis() obtiene el tiempo actual
• Se compara con el tiempo anterior
• Si pasa el intervalo (1 segundo), se ejecuta la acción
• El LED cambia de estado sin detener el programa

🔁 ¿Qué ventaja tiene?

✔ Permite hacer varias cosas al mismo tiempo

✔ Arduino no se “congela”

✔ Es la base de proyectos más avanzados

🚀 Mejora del ejercicio

Puedes combinar este código con otros elementos:

• 🔘 Leer un botón mientras el LED parpadea
• 🎚️ Cambiar la velocidad con un potenciómetro
• 🔊 Activar un buzzer al mismo tiempo

🧾 Conclusión

El uso de millis() en lugar de delay() es un paso fundamental para pasar de proyectos básicos a proyectos más profesionales con Arduino. Permite crear sistemas más eficientes, dinámicos y capaces de realizar múltiples tareas al mismo tiempo.

💡 Consejo: Intenta modificar el intervalo para cambiar la velocidad del parpadeo. 

[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458781252932657153 [/warning]

Uno de los proyectos más básicos y útiles al iniciar con Arduino es controlar un LED mediante un botón. Este ejercicio permite comprender cómo funcionan las entradas digitales y las salidas digitales, base de casi todos los proyectos electrónicos.

🎯 Objetivo

Encender un LED al presionar un botón y apagarlo al soltarlo.

🧰 Materiales

• 1 Arduino Uno
• 1 LED
• 1 botón (push button)
• 2 resistencias (220Ω y 10kΩ)
• Protoboard
• Cables jumper

🔌 Descripción del Circuito

En este proyecto:

• El LED se conecta a un pin digital de salida (por ejemplo, el pin 8).
• El botón se conecta a un pin digital de entrada (por ejemplo, el pin 7).
• Se usa una resistencia para proteger el LED y otra como pull-down para el botón.

👉 Cuando presionas el botón, el Arduino detecta un HIGH (1) y enciende el LED.

💻 Código Arduino

//Mientras mantenga presionado el botón
//se mantiene encendido el Led

int led=8;                //definimos el valor del pin para el led
int boton=7;              //definimos el valor del pin para el boton

void setup() {
  pinMode(led, OUTPUT);   //declaramos el pin led como salida
  pinMode(boton, INPUT);  //declaramos el pin boton como entrada
}

void loop() {
  if (digitalRead(boton) == HIGH) {   //si el botón esta presionado
    digitalWrite(led, HIGH);          //encendemos el led
  }
  else {                              //caso contrario
    digitalWrite(led, LOW);           //apagamos el led
  }
}

[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458711382664387585 [/warning]

🔁 Encender LED con Botón en Modo Interruptor (Toggle)

En el ejemplo anterior, el LED solo se encendía mientras mantenías presionado el botón. Ahora vamos a mejorar el proyecto para que funcione como un interruptor real (modo toggle).

🎯 ¿Qué es el modo Toggle?

El modo toggle permite que:

• 🔘 Presionas una vez → el LED se enciende
• 🔘 Presionas otra vez → el LED se apaga

Es decir, cada pulsación cambia el estado del LED, igual que un interruptor de luz en casa.

🔌 Circuito

✔ Se utiliza exactamente el mismo circuito anterior

(No necesitas hacer ningún cambio en las conexiones)

🧠 ¿Cómo funciona?

El Arduino debe detectar el momento exacto en que presionas el botón, no solo si está presionado.

Para eso:

• Se guarda el estado anterior del botón
• Se compara con el estado actual
• Si detecta un cambio (de LOW a HIGH), cambia el estado del LED

💻 Código en Arduino

// Presiona botón enciende LED
// Vuelve a presionar botón y se apaga el LED

int led = 8;           // definimos el valor del pin para el led
int boton = 7;         // definimos el valor del pin para el boton


// Variable que guarda el estado actual del botón
int estadoBoton = 0;       

// Variable que guarda el estado que tenía el botón en la vuelta anterior
// del programa. Se usa para detectar cuándo el botón acaba de ser presionado
int estadoAnterior = 0;

// Variable que almacena el estado del LED
// 0 (LOW) = Apagado - 1 (HIGH) = Encendido
int estadoLed = 0;         

void setup() {
  pinMode(led, OUTPUT);     // declaramos el pin led como salida
  pinMode(boton, INPUT);    // declaramos el pin boton como entrada
}

void loop() {

// Lee el estado actual del botón 
// Si está presionado devuelve HIGH. Si no está presionado devuelve LOW.

   estadoBoton = digitalRead(boton);

// Detecta cuando se presiona el botón. Esto ocurre cuando:
// Ahora está en HIGH (presionado) - Antes estaba en LOW (sin presionar)

   if (estadoBoton == HIGH && estadoAnterior == LOW) {

        // Cambia el estado del LED.
        // Si estaba apagado (0), pasa a encendido (1).
        // Si estaba encendido (1), pasa a apagado (0).

        estadoLed = !estadoLed; // Cambia el estado del LED
        
        // Espera 200 milisegundos (anti-rebote)
        delay(200); // Pequeño anti-rebote
   }

// Envía el valor almacenado en estadoLed al pin del LED
// Si estadoLed vale HIGH, el LED se enciende. Si vale LOW, el LED se apaga.

  digitalWrite(led, estadoLed);


// Guarda el estado actual del botón para compararlo 
// en la siguiente repetición del programa
  estadoAnterior = estadoBoton;
}

[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458764769388938241 [/warning]

🔍 Explicación del Código

• estadoAnterior guarda el estado previo del botón
• Se detecta el cambio de LOW → HIGH (cuando presionas)
• estadoLed = !estadoLed invierte el estado:
• Si estaba apagado → se enciende
• Si estaba encendido → se apaga

⚠️ Importante: Anti-rebote

Los botones físicos generan pequeñas vibraciones eléctricas al presionarse (rebote), lo que puede hacer que el Arduino detecte múltiples pulsaciones.

Por eso usamos:

delay(200);

🚀 Aplicaciones del modo Toggle

Este tipo de control es muy útil en proyectos reales:

• 💡 Encendido/apagado de luces
• 🔐 Sistemas de seguridad
• 🤖 Robots
• 🎮 Interfaces con botones

🧾 Conclusión

Este proyecto es fundamental para entender cómo Arduino interactúa con el mundo físico mediante entradas (botón) y salidas (LED). Dominar este ejercicio te permitirá avanzar hacia proyectos más complejos como sistemas automatizados, alarmas o interfaces interactivas.

El modo toggle convierte un simple botón en un verdadero interruptor digital. Dominar esta técnica te permitirá crear interfaces más avanzadas y mejorar la interacción en tus proyectos con Arduino.

 

En este proyecto realizaremos un semáforo con Leds, un ejercicio clásico que te ayudará a dominar conceptos básicos de programación y montaje de circuitos en Protoboard de forma rápida y sencilla.

🛠️Materiales Necesarios

Para este proyecto, asegúrate de tener a mano los siguientes componentes:

• 1 x Arduino UNO
• 1 x Protoboard
• 1 x Led rojo
• 1 x Led amarillo
• 1 x Led verde
• 3 x resistencias de 220Ω.
• Cables Jumper (macho - macho)

🔌Montaje del Circuito

Sigue el esquema que verás a continuación. Es fundamental conectar cada componente en su lugar para que el código funcione correctamente.

Configuración de Pines

/*************/
/*  SEMAFORO */
/*************/

//** Definiciones **//
int rojo=2;      //definimos el valor del pin para el led rojo
int amarillo=4;  //definimos el valor del pin para el led amarillo
int verde=7;     //definimos el valor del pin para el led verde

//** Programa **//

void setup() {
  pinMode(verde,OUTPUT);   //declaramos el pin verde como salida  
  pinMode(amarillo,OUTPUT);//declaramos el pin amarillo como salida
  pinMode(rojo,OUTPUT);    //declaramos el pin rojo como salida  
}

void loop() {
 digitalWrite(verde,HIGH); //encendemos el led rojo
 delay(2000);             //esperamos 2 segundos
 digitalWrite(verde,LOW);  //apagamos el led rojo
 delay(500);              //esperamos medio segundo
 
 digitalWrite(amarillo,HIGH); //encendemos el led amarillo
 delay(2000);                 //esperamos 2 segundos
 digitalWrite(amarillo,LOW);  //apagamos el led amarillo
 delay(500);                  //esperamos medio segundo
 
 digitalWrite(rojo,HIGH); //encendemos el led verde
 delay(2000);              //esperamos 2 segundos
 digitalWrite(rojo,LOW);  //apagamos el led verde
 delay(500);               //esperamos medio segundo
}

[warning title="Simulación en Wokwi" icon="check-circle"] https://wokwi.com/projects/458705807342132225 [/warning]