Últimos artículos

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

❌ No conectar bien el pin central del potenciómetro
❌ Olvidar la resistencia del LED
❌ No usar un pin PWM para el LED

🧾 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

❌ Usar un pin que no es PWM
❌ No usar resistencia en el LED
❌ Confundir analogWrite() con entrada analógica (analogRead())

🧾 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

Para este ejemplo, utilizaremos los siguientes pines digitales:

🔴 Pin 2: LED Rojo

🟡 Pin 4: LED Amarillo

🟢 Pin 7: LED Verde


💻Código Arduino

/*************/
/*  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]



En este tutorial aprenderás a controlar el flujo de electricidad para hacer que un LED parpadee. Es un proyecto sencillo, pero sienta las bases de toda la programación embebida.

📋Materiales necesarios

No necesitas mucho para empezar, lo más probable es que ya lo tengas todo en tu kit básico:

    • 1 x Arduino UNO
    • 1 x LED (cualquier color)
    • 1 x Resistencia de 220Ω
    • 1 x Protoboard
    • 2 x Cables Jumper

Conexión

LED

    • Ánodo → Pin 2
    • Cátodo → Resistencia de 220Ω → GND

💻Código Arduino
void setup() {
  // código de configuración, para que se ejecute una sola vez:
  pinMode(2, OUTPUT);
}

void loop() {
  // código principal, para que se ejecute repetidamente:
  digitalWrite(2, HIGH);
  delay(400);
  digitalWrite(2, LOW);
  delay(400);
}


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


marzo 15, 2026 , ,

 

El Arduino Uno es una de las placas más populares en el mundo de la electrónica y la programación, especialmente en el ámbito educativo. Su versatilidad permite trabajar tanto con señales digitales como analógicas, lo que lo convierte en una excelente herramienta para aprender y desarrollar proyectos tecnológicos.

Componentes Digitales

Los componentes digitales trabajan con señales binarias, es decir, solo pueden tener dos estados: HIGH (1) o LOW (0).

🔹Pines Digitales (0–13)

Cuando hablamos de los pines digitales en Arduino Uno, nos referimos a los pines de la parte superior numerados del 0 al 13. El Arduino Uno cuenta con 14 pines digitales, que pueden configurarse como entrada o salida.

Usos comunes:

    • Encender o apagar un LED
    • Leer el estado de un botón
    • Controlar relés o motores

Algunos pines tienen funciones especiales:

    • PWM (~3, ~5, ~6, ~9, ~10, ~11): permiten simular señales analógicas mediante modulación por ancho de pulso.
    • RX-0 y TX-1: comunicación serial.

Nota: El Arduino Uno utiliza los pines 0 y 1 para la comunicación serial con la computadora a través del cable USB. Conectar dispositivos a estos pines puede causar interferencias, afectando tanto la comunicación serial como cualquier otra función prevista, como la carga de programas a la placa Arduino.

📊Componentes Analógicos

A diferencia de los digitales, los componentes analógicos trabajan con valores continuos.

🔹Pines Analógicos (A0–A5)

Arduino Uno dispone de 6 pines de entrada analógica (Analog In), que permiten leer señales variables, numerados a partir de la letra 'A'.

Ejemplos de uso:

    • Sensores de temperatura
    • Potenciómetros
    • Sensores de luz

Estos pines convierten la señal analógica en un valor digital mediante un ADC (Convertidor Analógico-Digital) de 10 bits, generando valores entre 0 y 1023.

🔹Salidas Analógicas (PWM)

Aunque Arduino no tiene salidas analógicas reales, utiliza la tecnología PWM (Pulse Width Modulation) para simularlas.

Aplicaciones:

    • Control de brillo de un LED
    • Regulación de velocidad de un motor
    • Generación de señales variables


MKRdezign

Formulario de contacto

Nombre

Correo electrónico *

Mensaje *

Con tecnología de Blogger.
Javascript DisablePlease Enable Javascript To See All Widget