Controlar la luz (intensidad) de un led por potenciometro (LED PWM)

 Te ayudo a controlar la intensidad de un LED usando un potenciómetro con PWM (Modulación por Ancho de Pulso). Aquí tienes el código y la explicación:

Materiales necesarios:

  • Arduino (Uno, Nano, etc.)

  • LED

  • Resistencia de 220Ω a 1kΩ

  • Potenciómetro de 10kΩ

  • Cables de conexión

Esquema de conexión:

  • LED: Ánodo (+) a pin PWM (ej. pin 9), Cátodo (-) a GND (con resistencia)

  • Potenciómetro:

    • Terminal izquierdo a 5V

    • Terminal derecho a GND

    • Terminal central a pin analógico A0

Código Arduino:

arduino
// Pines de conexión
const int potPin = A0;    // Pin analógico para el potenciómetro
const int ledPin = 9;     // Pin PWM para el LED

// Variables
int potValue = 0;         // Valor leído del potenciómetro (0-1023)
int pwmValue = 0;         // Valor PWM para el LED (0-255)

void setup() {
  // Configurar el pin del LED como salida
  pinMode(ledPin, OUTPUT);
  
  // Iniciar comunicación serial (opcional, para monitoreo)
  Serial.begin(9600);
}

void loop() {
  // Leer el valor del potenciómetro (0-1023)
  potValue = analogRead(potPin);
  
  // Convertir el valor a rango PWM (0-255)
  pwmValue = map(potValue, 0, 1023, 0, 255);
  
  // Escribir el valor PWM al LED
  analogWrite(ledPin, pwmValue);
  
  // Mostrar valores por monitor serial (opcional)
  Serial.print("Potenciometro: ");
  Serial.print(potValue);
  Serial.print(" | PWM: ");
  Serial.println(pwmValue);
  
  // Pequeña pausa para estabilidad
  delay(10);
}

Versión alternativa con filtro para mayor suavidad:

arduino
const int potPin = A0;
const int ledPin = 9;

int potValue = 0;
int pwmValue = 0;
int lastPwmValue = 0;

void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  // Leer potenciómetro
  potValue = analogRead(potPin);
  
  // Convertir a PWM
  pwmValue = map(potValue, 0, 1023, 0, 255);
  
  // Filtro para cambios más suaves
  if (abs(pwmValue - lastPwmValue) > 2) {
    analogWrite(ledPin, pwmValue);
    lastPwmValue = pwmValue;
    
    Serial.print("PWM: ");
    Serial.println(pwmValue);
  }
  
  delay(20);
}

Explicación del código:

  1. Lectura analógica: analogRead(potPin) lee valores de 0 a 1023

  2. Conversión: map() convierte de 0-1023 a 0-255 (rango PWM)

  3. Salida PWM: analogWrite() controla la intensidad del LED

Pines PWM en Arduino:

  • Uno/Nano: Pines 3, 5, 6, 9, 10, 11

  • Mega: Pines 2-13, 44-46

Consejos:

  • Usa una resistencia de 220Ω-1kΩ en serie con el LED

  • El potenciómetro de 10kΩ es ideal para este propósito

  • Puedes ajustar el delay() para mayor o menor respuesta

Tutorial: Controlar Intensidad de LED con Potenciómetro usando Arduino

¡Hola que tal! Bienvenidos a un nuevo vídeo. En este caso vamos a checar cómo manejar la intensidad de lo que es un LED mediante lo que es el potenciómetro controlado con el Arduino.

Materiales Necesarios

Para este proyecto vamos a necesitar:

  • Arduino (Uno, Nano, etc.)

  • LED

  • Resistencia de 220Ω

  • Potenciómetro de 10kΩ

  • Cables de conexión

  • Protoboard

Conexiones

Para el LED:

  • La parte negativa del LED (cátodo) lo vamos a conectar al negativo (GND) del Arduino

  • La parte positiva va a llevar lo que es la resistencia de 220Ω

  • De la resistencia va a llegar a un cable que conectaremos al puerto número 3

Nota importante: Los puertos 3, 5, 6, 9, 10 y 11 tienen lo que se llaman PWM (Pulse Width Modulation) que nos van a ayudar para poder manejar la intensidad de nuestro LED.

Para el Potenciómetro:

  • El pin del lado izquierdo (terminal 1) va a la parte negativa (GND)

  • El pin central (wiper) va a ir conectado al pin A0 (entrada analógica)

  • El pin número 3 va conectado al positivo (5V)

Programación

Vamos a crear el código paso a paso:

arduino
// Declaración de variables
int led = 3;              // Pin donde está conectado el LED
int valorPot = 0;         // Valor leído del potenciómetro
int intensidadLED = 0;    // Valor de intensidad para el LED

void setup() {
    // Configurar el pin del LED como salida
    pinMode(led, OUTPUT);
    
    // Inicializar comunicación serial para monitoreo
    Serial.begin(9600);
}

void loop() {
    // Leer el valor del potenciómetro (0-1023)
    valorPot = analogRead(A0);
    
    // Mostrar el valor del potenciómetro
    Serial.print("Valor Potenciómetro: ");
    Serial.println(valorPot);
    
    // Convertir el valor a rango PWM (0-255)
    intensidadLED = map(valorPot, 0, 1023, 0, 255);
    
    // Aplicar la intensidad al LED
    analogWrite(led, intensidadLED);
    
    // Mostrar el valor de intensidad
    Serial.print("Intensidad LED: ");
    Serial.println(intensidadLED);
    
    delay(100);  // Pequeña pausa para estabilidad
}

Explicación del Código

Variables:

  • led: Pin donde está conectado el LED (puerto 3 con PWM)

  • valorPot: Almacena la lectura del potenciómetro (0-1023)

  • intensidadLED: Almacena el valor mapeado para el PWM (0-255)

Setup():

  • pinMode(led, OUTPUT): Configura el pin del LED como salida

  • Serial.begin(9600): Inicia la comunicación serial para monitorear valores

Loop():

  1. Lectura analógica: analogRead(A0) lee valores de 0 a 1023

  2. Mapeo de valores: map() convierte de 0-1023 a 0-255

  3. Salida PWM: analogWrite() controla la intensidad del LED

Simulación y Resultados

Al iniciar la simulación y abrir el Monitor Serie:

  • Veremos dos valores:

    • Primer valor: Valor del potenciómetro (0-1023)

    • Segundo valor: Intensidad mapeada para el LED (0-255)

Comportamiento:

  • Valor mínimo (0): LED apagado

  • Valor medio (512): Intensidad media (127 en PWM)

  • Valor máximo (1023): Intensidad máxima (255 en PWM)

¿Por qué usar PWM?

El Arduino maneja direcciones de 8 bits para salidas analógicas, por lo tanto:

  • Entrada analógica: 0-1023 (10 bits)

  • Salida PWM: 0-255 (8 bits)

La función map() se encarga de hacer esta conversión automáticamente, permitiéndonos controlar suavemente la intensidad del LED.

Consejos Prácticos

  1. Resistencia: Siempre usar resistencia en serie con el LED (220Ω-1kΩ)

  2. Potenciómetro: 10kΩ es ideal para este propósito

  3. Pines PWM: Usar exclusivamente los pines con capacidad PWM (3,5,6,9,10,11 en Arduino Uno)

¡Y listo! Con este proyecto podrán controlar perfectamente la intensidad de un LED girando simplemente el potenciómetro. Es un excelente ejercicio para entender el funcionamiento del PWM y las entradas analógicas en Arduino.

Comentarios

Publicar un comentario

Entradas más populares de este blog

12. Demostracion de como usar Tinkercad para simular Arduino con circuitos

  Simulación de Circuitos con Arduino en Tinkercad ¿Por qué simular circuitos? En el aprendizaje de electrónica y programación con Arduino, lo ideal es trabajar con componentes físicos. Sin embargo, si no tienes acceso a los componentes (Arduino, LEDs, resistencias, etc.), no significa que no puedas aprender y practicar. La simulación es una herramienta poderosa que te permite diseñar, probar y depurar tus circuitos y código de forma virtual. En este tutorial, aprenderás a usar  Tinkercad Circuits , una plataforma en la nube gratuita, para simular el clásico proyecto de parpadeo de dos LEDs. Paso 1: Acceder a Tinkercad Abre tu navegador web y ve a la página de  Tinkercad . Haz clic en  Iniciar sesión  (Sign in). Selecciona la opción  Iniciar sesión con Google  (o crea una cuenta si es necesario). Elige la cuenta de Gmail con la que deseas registrarte e inicia sesión. Paso 2: Crear un Nuevo Circuito En la página principal de Tinkercad, haz clic en la pe...
Leer más

11. Ejemplos Básicos de Leds y Pulsadores

  Programación Básica con Arduino - Control de LEDs y Pulsador 📋 Descripción General Este tutorial te guiará a través de 3 ejemplos prácticos de programación con Arduino, desde el parpadeo básico de un LED hasta el control con un pulsador. Duración:  15:28 minutos 🧩 Ejemplo 1: LED Parpadeante en PIN 8 📌 Objetivo Conectar un LED al PIN 8 y hacerlo parpadear infinitamente con intervalos de 500ms encendido y 500ms apagado. 🔌 Esquemático LED: Ánodo (+) conectado al PIN 8 a través de una resistencia Cátodo (-) conectado a GND (tierra) 💻 Código arduino void setup ( ) { pinMode ( 8 , OUTPUT ) ; // Configurar PIN 8 como salida } void loop ( ) { digitalWrite ( 8 , HIGH ) ; // Encender LED delay ( 500 ) ; // Esperar 500ms digitalWrite ( 8 , LOW ) ; // Apagar LED delay ( 500 ) ; // Esperar 500ms } ⚙️ Configuración En Herramientas → Placa: seleccionar "Arduino Uno" En Herramientas → Puerto: seleccionar el puerto correcto Car...
Leer más

Lectura de Potenciómetro con Arduino Uno en Tinkercad

  Introducción En este tutorial aprenderás a conectar y leer un potenciómetro con una tarjeta Arduino Uno usando Tinkercad. Un potenciómetro es una resistencia variable que nos permite controlar manualmente valores analógicos. Componentes Necesarios 1 x Arduino Uno 1 x Potenciómetro 3 x Cables jumper 1 x Protoboard Paso a Paso Paso 1: Configuración del Circuito Conectar el potenciómetro a la protoboard: Coloca el potenciómetro en la protoboard Tiene 3 pines: dos extremos y un pin central Conexiones del potenciómetro: Pin izquierdo  → Conectar a  5V  de Arduino Pin derecho  → Conectar a  GND  de Arduino Pin central  → Conectar a  A0  (entrada analógica) Paso 2: Diagrama de Conexiones text POTENCIÓMETRO ARDUINO UNO Pin 1 → 5V Pin 2 → A0 Pin 3 → GND Paso 3: Programación en Arduino cpp // Definir el pin del potenciómetro const int potPin = A0 ; // Variable para almacenar el valor leído int potValue...
Leer más