Implementación de PWM con Arduino para Control de Brillo en LEDs

Clase 27 de 38 • Curso Fundamentos de Desarrollo de Hardware con Arduino

Resumen

¿Cómo implementar PWM en Arduino?

La técnica de Modulación de Ancho de Pulso (PWM, por sus siglas en inglés) puede ser intimidante al principio, pero con el uso de Arduino se simplifica considerablemente gracias a su función analogWrite. Este documento explora cómo implementar PWM usando Arduino y sacar el máximo partido a sus capacidades.

¿Qué es PWM?

El Pulse Width Modulation (PWM) es una técnica que permite simular señales analógicas a través de una salida digital. Cambiando el ancho del "pulso" de una señal digital, puedes variar la cantidad de energía enviada a un dispositivo, regulando, por ejemplo, la resistencia de un LED o la velocidad de un motor.

¿Qué componentes necesitamos?

Antes de empezar a implementar PWM en Arduino, asegúrate de tener los siguientes componentes:

Un Arduino (cualquier modelo compatible)
Un potenciómetro
Tres LEDs ultra brillantes (o un LED RGB)
Cables de conexión
Una protoboard
Resistencias de 220 ohmios (una para cada LED)

¿Cómo configurar el sistema con Arduino?

Para implementar PWM, necesitamos configurar nuestro sistema de manera que los componentes interactúen correctamente. Aquí te mostramos cómo realizar la conexión básica:

Configura los pines PWM en Arduino:
- Define los pines donde los LEDs estarán conectados. En este caso usaremos pines 3, 5 y 6, que soportan PWM.

int led1 = 3;
int led2 = 5;
int led3 = 6;

Conecta el potenciómetro:
- Conecta el potenciómetro al pin A0 de tu Arduino. Este actuará como una entrada analógica.

int potPin = A0;

¿Cómo escribir el código en Arduino?

Comencemos a escribir el código necesario para controlar la intensidad de los LEDs usando PWM:

Declara variables globales:

int potValue;
int brightValue = 0;

Configura el ‘setup’ de Arduino:

El 'setup' no necesita especificar los pines como output ya que analogWrite() se encarga de esto:

void setup() {
  // No hay necesidad de configurar pines como salida
}

Desarrolla la lógica en el ‘loop’:

Aquí es donde la magia sucede. Leemos el valor del potenciómetro y ajustamos la intensidad de los LEDs:

void loop() {
  potValue = analogRead(potPin);
  brightValue = map(potValue, 0, 1023, 0, 255);
  analogWrite(led1, brightValue);
  analogWrite(led2, brightValue);
  analogWrite(led3, brightValue);
  delay(10); 
}

¿Cómo ajustar la resolución de PWM?

Con Arduino, la resolución del PWM es de 8 bits, lo que significa que podemos ajustar las intensidades del LED en 256 niveles diferentes, de 0 a 255. Utilizamos la función map() para ajustar la lectura analógica del potenciómetro (0 a 1023) a este rango de PWM.

¿Cómo conectar los LEDs y otros componentes?

Para conectar tus componentes, sigue estos pasos:

LEDs:
- Conecta el cátodo de cada LED a la tierra común en la protoboard.
- Conecta el ánodo de cada LED a los pines PWM seleccionados.
Potenciómetro:
- Conecta un extremo a 5V, el otro a tierra, y el terminal central a A0.

¿Qué problemas comunes podemos enfrentar?

Conexiones incorrectas: Asegúrate de que todos los LEDs estén correctamente orientados y que las conexiones sean sólidas.
Valore de resistencias inadecuadas: Utiliza resistencias adecuadas para no dañar los LEDs.
Errores en el código: Comprueba que todos los elementos del código estén correctamente escritos y que las variables estén bien definidas.

¿Qué desafíos puedes intentar?

Te animo a explorar más con este proyecto. Prueba integrar un LED RGB para manipular el color a través del PWM, o utiliza un segundo potenciómetro para alterar el patrón de los cambios de luminosidad.

Este ejercicio no solo te ayudará a comprender mejor el PWM, sino que ampliará tus habilidades en programación y hardware con Arduino. Si tienes alguna duda, aprovecha las discusiones en línea, comparte tus resultados y continúa explorando. ¡Tu creatividad es el límite!

Martin Mendoza

student•

prototipo:

Codigo:

Hugo Montoya Diaz

student•

Muy bien felicitaciones

Johann Sebastian Pérez E

student•

Les comparto mi solución del reto. Led RGB que cambia de colores giranto los potenciómetros

int ledRgbRojo = 3;
int ledRgbAzul = 5;
int ledRgbVerde = 6;
int potPin0 = A0;
int potPin1 = A1;
int potPin2 = A2;
int brighValue0 = 0;
int brighValue1 = 0;
int brighValue2 = 0;
int potValue0 = 0;
int potValue1 = 0;
int potValue2 = 0;
void setup()
{
// no se declara nanda

}

void loop()
{
	potValue0 = analogRead(potPin0);
 	potValue1 = analogRead(potPin1);
  	potValue2 = analogRead(potPin2);
  
	brighValue0 = map(potValue0, 0, 1023, 0, 255);
  	brighValue1 = map(potValue1, 0, 1023, 0, 255);
  	brighValue2 = map(potValue2, 0, 1023, 0, 255);
  
	analogWrite(ledRgbRojo, brighValue0);
	analogWrite(ledRgbAzul, brighValue1);
	analogWrite(ledRgbVerde, brighValue2);
	delay(10);

}```

Jeremías Ojeda

student•

Le faltaría un resistor a tu led, para que no se queme cuando potencias al máximo, con una resistencia de 220 en el negativo de tu led ya se solucionaría.

Miguel Angel Velazquez Romero

student•

¿Y donde esta practica de la lampara de mesa?

Andrés Fernando Cortés Pinzón

student•

Nicolas Pennisi

student•

Hice el reto! Un boton cambia el color y un potenciómetro, la intensidad de la luz.

int led_rojo = 11;
int led_verde = 10;
int led_azul = 9;

int boton = 8;
int boton_value;
int pulsos = 0;
int boton_presionado = 0;

int pot_pin = A0;
int pot_value = 0;
int bright_value = 0;

void setup() 
{
  pinMode(boton, INPUT_PULLUP);
  pinMode(led_azul,OUTPUT);
  pinMode(led_verde,OUTPUT);
  pinMode(led_rojo,OUTPUT);
}

void loop() 
{
  pot_value = analogRead(pot_pin);
  bright_value = map(pot_value, 0, 1023, 0, 255);
  boton_value = digitalRead(boton);
  if(boton_presionado == LOW && boton_value == HIGH)
  {
    pulsos ++;
    boton_presionado = HIGH; //Reconocer el boton presionado
  }
  if(boton_presionado == HIGH && boton_value == LOW)
    boton_presionado = LOW;
  if(pulsos > 7)
    pulsos = 0;

  color(pulsos);
}
//Cada vez que se pulsa el boton, se le suma 1 al contador. Cuando llega a 8 (cantidad de casos del switch) se reinicia todo
//nro_color refiere al caso, este refiere a color que varia segun el pulso
void color(int nro_color)
{
  switch (nro_color)
  {
    case 0: 
      analogWrite(led_rojo, bright_value);
      analogWrite(led_verde, 0);
      analogWrite(led_azul, 0);
    break;
    
    case 1:
      analogWrite(led_rojo, 0);
      analogWrite(led_verde, bright_value);
      analogWrite(led_azul, 0);
    break;
    
    case 2:
      analogWrite(led_rojo, 0);
      analogWrite(led_verde, 0);
      analogWrite(led_azul, bright_value);
    break;    

    case 3:
      analogWrite(led_rojo, bright_value);
      analogWrite(led_verde, bright_value);
      analogWrite(led_azul, 0);
    break;

    case 4:
      analogWrite(led_rojo, 0);
      analogWrite(led_verde, bright_value);
      analogWrite(led_azul, bright_value);
    break;

     case 5:
      analogWrite(led_rojo, bright_value);
      analogWrite(led_verde, 0);
      analogWrite(led_azul, bright_value);
    break;  

    case 6:
      analogWrite(led_rojo, bright_value);
      analogWrite(led_verde, bright_value);
      analogWrite(led_azul, bright_value);
    break;

    case 7:
      analogWrite(led_rojo, 0);
      analogWrite(led_verde, 0);
      analogWrite(led_azul, 0);
    break;
      
    return;
  }
  
}

José Guillermo

student•

¿Qué micro controladores has usado que tengan un mayor nivel de dificultad que Arduino profesor @celismx?

Ricardo Celis

teacher•

esta belleza: https://www.microchip.com/wwwproducts/en/dsPIC33FJ128MC802
para un proyecto que requería utilizar 2 encoders de cuadratura con mucha presición =)

David Santiago Pinchao Ortiz

student•

Cuanto es el valor de resistencia maximo que tiene el potenciometro ?

Roger Carlos Ariel Alba

student•

Hola!

Regularmente los potenciometros indican su valor. Además siempre hay un pequeño margen de oscilación.

Saludos!

Ricardo Celis

teacher•

en mi caso utilice uno de 10k Ohms

Alexis Antonio Moraga Gallardo

student•

comparto el código que implemente para el mismo ejercicio, pero con solo un led

y pregunto

Cual es la diferencia entre

brightValue = map(potValue, 0, 1023, 0, 255);

brightValue = potValue / 4;

Ambos nos entregan valores entre 0 y 255. existe alguna razón para preferir una sobre otra?

int led = 3;
int potPin = A0;//declaracion de pin analogico 
int potValue = 0;//declaramos una variable para guardar el valor del potenciometro
int brightValue = 0;
void setup() {
}



void loop() {

potValue = analogRead(potPin);//almacenamos el valor del pin analogico de nuestro potenciometro

brightValue = potValue / 4;


analogWrite(led, potValue);//encendemos el led

}

Jonathan Macalupu Reyes

student•

Si, es cierto, pero, la función map() te permite hacer una equivalencia más exacta. Otro caso que puede darse es cuando mides valores (0 a 1023) y lo tienes que traducir en una magnitud (temperatura, luz, peso, etc.). En vez de hacer una ecuación para calcular, puedes usar map(), colocando los valores máximos y mínimos.

Benjamin Ignacio Barrera Vásquez

student•

La función map() lo que hace exactamente es un escalamiento, basandose en la ecuación punto pendiente, esto aplica solo a valores que son lineales.

La ecuación punto pendiente en matemáticas es: y - y1 = m(x – x1) dónde m es la pendiente que relaciona don magnitudes que son directamente proporcionales.

De echo en la página de Arduino puedes encontrar la función por dentro que se ve de esta forma:

long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}```

Rafael Schmidt

student•

Al codigo le hice una pequeña modificación para que vaya variando el color y se mezcle un poco

int led1 = 3; int led2 = 5; int led3 = 6;

int potPin = A0; int potValue =0; int brightValue = 0;

void setup() { // put your setup code here, to run once:

}

void loop() { // put your main code here, to run repeatedly: potValue = analogRead(potPin); brightValue = map(potValue, 0, 1023, 0, 255); if (brightValue < 85) { analogWrite(led1, brightValue * 3); analogWrite(led2, 0); analogWrite(led3, 0); delay(10); } else if ((brightValue > 85) && (brightValue < 170)) { analogWrite(led1, brightValue); analogWrite(led2, (brightValue - 85) * 3); analogWrite(led3, 0); delay(10); } else { analogWrite(led1, 0); analogWrite(led2, brightValue); analogWrite(led3, (brightValue - 170) * 3); delay(10); } }

Martín Gutiérrez Hernández

student•

PWM en uC

Talvez entendí mal la clase, pero creo que seria un desperdicio utilizar tres pines como salida para el PWM si todas van a tener el mismo ciclo de trabajo (Duty cicle)

Por eso yo propondría utilizar solo un pin y con un transistor encargarse de controlar la corriente de varios led, en mi caso puse 8 leds de color blanco. Y ya fue personal usar un uC más pequeño el ATtiny13 es de la misma marca AVR, aunque si nos ponemos más ahorradores se podría sustituía el arduino por un 555

Aquí abajo esta el código en C, por si ven alguna forma de optimizar el código u otro algoritmo que también funcione,

Fernando Daniel Adanalian Vigni

student•

SIIIIII Funciona !!!!!!

Carlos Andrés Pupiales Córdoba

student•

esos pobres leds sin resistencia no duraran mucho

Marcel Nahir Samur

student•

Comparto el código para variar los colores de un led RGB. El principio es el mismo, se varia la intensidad del brillo de cada led que compone el RGB y estas variaciones afectan el color final

int rled = 11; // Pin PWN 11 para led rojo
int bled = 9; // Pin PWM 10 para led azul
int gled = 8; // Pin PWM 9  para led verde

int pot1 = A0; //Pin Analogico 0
int pot2 = A1; //Pin Analogico 1
int pot3 = A2; //Pin Analogico 0

int p1 = 0;
int p2 = 0;
int p3 = 0;

void setup() {

}

void loop() {
  //Colores Aleatorios
  p1=analogRead(pot1);
  p2=analogRead(pot2);
  p3=analogRead(pot3);
  
  p1 = map(p1,0,1023,0,255);
  p2 = map(p2,0,1023,0,255);
  p3 = map(p3,0,1023,0,255);
  
  
  analogWrite(rled, p1);
  analogWrite(bled, p2);
  analogWrite(gled, p3);
 }

Adjunto el prototipo hecho en tinkercad

Jonathan Gallego

student•

¿Qué frecuencia de señal genera la función analogWrite?

Francisco Javier Pedrosa Ruiz

student•

analogWrite genera una señal DC.

Jonathan Gallego

student•

Estuve leyendo y encontré esto:
analogWrite Writes an analog value (PWM wave) to a pin. Can be used to light a LED at varying brightnesses or drive a motor at various speeds. After a call to analogWrite(), the pin will generate a steady square wave of the specified duty cycle until the next call to analogWrite() (or a call to digitalRead() or digitalWrite()) on the same pin. The frequency of the PWM signal on most pins is approximately 490 Hz. On the Uno and similar boards, pins 5 and 6 have a frequency of approximately 980 Hz.

Jesús Adrián Sevilla Azuara

student•

int Led1 = 3;
int Led2 = 5;
int Led3 = 6;
int AnalogPin1 = A0;
int AnalogPin2 = A1;
int AnalogPin3 = A2;
int AnalogValue1 = 0;
int AnalogValue2 = 0;
int AnalogValue3 = 0;
int LightValue1 = 0;
int LightValue2 = 0;
int LightValue3 = 0;

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

void loop() {
  AnalogValue1 = analogRead(AnalogPin1);
  LightValue1 =  map(AnalogValue1, 0, 1023, 0, 255);
  Serial.println(LightValue1);
  AnalogValue2 = analogRead(AnalogPin2);
  LightValue2 =  map(AnalogValue2, 0, 1023, 0, 255);
  Serial.println(LightValue2);
  AnalogValue3 = analogRead(AnalogPin3);
  LightValue3 =  map(AnalogValue3, 0, 1023, 0, 255);
  Serial.println(LightValue3);
  analogWrite(Led1, LightValue1);
  analogWrite(Led2, LightValue2);
  analogWrite(Led3, LightValue3);
  Serial.println("---------------------------------------");
  delay(10);
}

Raul Zarza

student•

solo se ven sus manos XD

Ricardo Portillo

student•

una consulta xq no usa una resitencía en cada led ????

Luis Augusto Zuñe Bispo

student•

Probablemente este usando un led de 3.5 voltios.

Juan Sebastian Alvarez Marin

student•

ten en cuenta 2 cosas, la primera es que la conexión que tiene es en paralelo, por lo tanto el voltaje se divide en el numero de resistencias, en este caso en 3 leds, por lo poner resistencias solo atenuarí la luz de los led, y la otra cosa es que si notas, cuando conecta todo los led iluminan muchísimo, eso es porque están trabajando a un voltaje alto (alto en comparación a un led con resistencias)

José Manuel Rodríguez Villarreal

student•

reto cumplido convinar colores usando dos pots



int ledRed = 3;
int ledGreen = 5;
int ledBlue = 9;

int potPin1 = A0;
int potPin2 = A1;
int potValue1 = 0;
int potValue2 = 0;


void setup() {

  Serial.begin(9600);
 
}

void loop() {
  
  potValue1 = analogRead(potPin1);
  potValue1 = map(potValue1, 0, 1023, 0, 255);
  Serial.print("potValue1: ");
  Serial.print(potValue1);
  delay(100);
  
  potValue2 = analogRead(potPin2);
  potValue2 = map(potValue2, 0, 1023, 0, 255);
  Serial.print(" potValue2: ");
  Serial.println(potValue2);
  delay(100);
 
if(potValue1 < 63 && potValue2 > 250)
{
    analogWrite(ledRed, 36); //color violeta
    analogWrite(ledGreen, 0);
    analogWrite(ledBlue, 54);
   
}
 else 
 {
    analogWrite(ledRed, 255);
    analogWrite(ledGreen, 255);
    analogWrite(ledBlue, 255);
   
 }

 if(potValue1 >= 63 && potValue1 < 126 && potValue2 < 63) 
 {
    analogWrite(ledRed, 255); //color turquesa
    analogWrite(ledGreen, 0);
    analogWrite(ledBlue, 20);
 }
  else if(potValue1 >= 126 && potValue2 >=63 && potValue2 <=250)
  {
    analogWrite(ledRed, 255); // color naranja
    analogWrite(ledGreen, 18);
    analogWrite(ledBlue, 0);
  }
  
  
}**

<code> ``` **```

Lee Oble

student•

Saludos, en relación al potenciometro y la función map. podría usarla para que el potenciometro fuera un timer de 1 hora. valor mínimo 1 minuto, calor máximo 60?

Erik Elyager

student•

Al ser una lectura análoga, no veo problema con que definas una escala del 1 al 60 desde la mínima hasta la máxima.

Camilo Alexander Fernandez Valberde

student•

como convertiste los 8bits en 255 ?

Martín Gutiérrez Hernández

student•

(2^n) -1 = 2^8 -1 = 255

Juan Luis Jr. Vargas Mayurí

student•

Hola chicos una consulkta, porque declara potPin como int si su valor es A0 ..si no es un numero entero ?