Cómo Arduino simplifica el PWM

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

Contenido del curso

Bienvenida al curso

Introducción al hardware libre

Sensores, Actuadores y Procesadores

Introducción a la electrónica

Manos a la obra

Automatización de procesos

Tomar examen

Resumen

Domina el control de brillo en LEDs con PWM en Arduino de forma directa y confiable. Aquí verás cómo pasar de la teoría a la práctica usando un potenciómetro para regular tres LEDs en pines con PWM, aprovechando funciones nativas como analogRead, map y analogWrite sin configuraciones complejas del módulo.

¿Qué harás con PWM en Arduino?

Aprenderás a leer un potenciómetro, escalar su valor y ajustar el brillo de tres LEDs en pines PWM. Todo con un flujo claro: declaración de variables, lectura analógica, mapeo de rangos y escritura PWM.

PWM de 8 bits: 256 niveles de brillo de 0 a 255.
Sin configurar pinMode: con analogWrite no necesitas declarar el pin como salida.
Pines con PWM: usa los pines 3, 5 y 6, marcados con la tilde en la serigrafía.
Productividad: sketch nuevo, guarda rápido con Ctrl + S, y nombra de forma clara.

¿Cómo es el código y por qué funciona?

El potenciómetro entrega valores de 0 a 1023 con analogRead. Para que analogWrite acepte esos datos, se usa map y se convierte ese rango a 0–255. Ese valor define el ciclo de trabajo que regula el brillo del LED.

¿Qué variables y pines se usan?

Variables globales claras: LED1, LED2, LED3 y potPin.
Convención camelCase para potValue y brightValue.
Pines PWM: 3, 5, 6 para los LEDs.
Entrada analógica: potPin = 0.

¿Cómo se lee y escala el potenciómetro?

analogRead(potPin) devuelve 0–1023.
map(potValue, 0, 1023, 0, 255) hace la “regla de tres” al rango de PWM.
analogWrite(LEDx, brightValue) aplica el brillo a cada LED.
Un delay(10) suaviza los cambios percibidos.

int LED1 = 3;
int LED2 = 5;
int LED3 = 6;

int potPin = 0;      // Entrada analógica (A0 en placas clásicas).
int potValue;        // Lectura del potenciómetro 0–1023.
int brightValue = 0; // Brillo 0–255 para PWM.

void setup() {
  // Con analogWrite no es necesario configurar pinMode para los pines PWM.
}

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 conectar y probar sin errores?

La conexión correcta garantiza que el brillo varíe de forma suave y visible. Cuida la tierra común, la polaridad de los LEDs y separa cada positivo al pin PWM correspondiente.

¿Qué conexiones eléctricas son clave?

Lleva una línea de tierra a la protoboard para todos los LEDs.
Conecta el negativo de cada LED a la línea de tierra.
Evita unir los positivos: cada LED debe ir a su pin PWM distinto.
Si te equivocas y todos van al mismo pin, corrige conectándolos “en escalerita” a 3, 5 y 6.

¿Qué buenas prácticas al compilar y cargar?

Verifica placa y puerto: en Tools > Board y COM correspondiente.
Compila y haz Upload antes de cablear todo.
Observa el brillo: al girar el potenciómetro, el LED pasa de apagado a máximo gradualmente.

¿Qué desafío puedes intentar?

Usa un LED RGB y un botón para cambiar colores.
Agrega un segundo potenciómetro para controlar cada canal.
Combina valores de red, green y blue o usa tres LEDs independientes para ver mezclas.

¿Te animas a compartir tu resultado? Deja tu código, fotos o un video, y cuéntame cómo resolviste el control de brillo y las combinaciones de color.

Comentarios

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?

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;
  }
  
}

Andrés Fernando Cortés Pinzón

student•

José Guillermo

student•

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

Ricardo Celis

teacher•

esta belleza:
para un proyecto que requería utilizar 2 encoders de cuadratura con mucha presición =)

David Pinchao

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) !esquemático de circuito 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 !demostracion de funcionamiento 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, !codigo de mc

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?

F.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> ``` **```

Patricia Bonaldy

student•

Jaime de Jesús Meza Estrada

student•

PWM

Ever Raúl Chávez chavarria

student•

int led1 = 3;

int led2 = 5;

int led3 = 6;

int potpin1 = A0;

int potpin2 = A1;

int potpin3 = A2;

int potValue1 = 0;

int potValue2 = 0;

int potValue3 = 0;

int ledrgb1 = 0;

int ledrgb2 = 0;

int ledrgb3 = 0;

void setup()

{

}

void loop()

{

potValue1 = analogRead (potpin1);

potValue2 = analogRead (potpin2);

potValue3 = analogRead (potpin3);

ledrgb1 = map(potValue1, 0, 1023, 0, 255);

ledrgb2 = map(potValue2, 0, 1023, 0, 255);

ledrgb3 = map(potValue3, 0, 1023, 0, 255);

analogWrite (led1, ledrgb1);

analogWrite (led2, ledrgb2);

analogWrite (led3, ledrgb3);

delay(10);

}

Aqui esta mi forma de como lo resolvi

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);

}```

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;
  }
  
}

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

}

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);
 }

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);
}

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);
  }
  
  
}**

Cómo Arduino simplifica el PWM

Bienvenida al curso

Servidor Web Asíncrono con ESP8266 y Arduino

Fundamentos de Desarrollo de Hardware con Arduino

Introducción al hardware libre

Arduino: Desarrolla Prototipos Interactivos con Microcontroladores

Desarrollo de Prototipos de Hardware: Diseño y Fabricación

Diseño Mecánico de Hardware con SolidWorks y Herramientas Paramétricas

Desarrollo de Interfaces y Prototipos con QT en Sistemas Embebidos

Limitaciones de Arduino en productos finales

Selección de Arduino para Envío de Datos a Servidor

Fundamentos de Desarrollo de Hardware con Arduino

Proyectos con Arduino: Componentes y Materiales Necesarios

Sensores, Actuadores y Procesadores

Sensores y Actuadores: Fundamentos para Automatización con Arduino

Cómo los robots ven a través de sensores

Tipos de Sensores y sus Aplicaciones en Robótica y Electrónica

Clasificación y Aplicaciones de Actuadores en la Industria

Introducción a la electrónica

Conceptos básicos de electricidad y electrónica para Arduino

Resistencias y capacitores en electrónica básica

Componentes Electrónicos Básicos: LEDs, Transistores y Circuitos Integrados

Uso de la Ley de Ohm para Conectar LEDs sin Quemarlos

Manos a la obra

Conociendo los Puertos y Alimentación del Arduino Uno

Funcionamiento de la Protoboard para Prototipado Electrónico

Programación Básica en Arduino: Primeros Pasos con LED y Código

Declarar variables para pines de Arduino

Creación y Uso de Librerías en Arduino

Uso del Potenciómetro para Control de LED con Arduino

Comunicación Serial en Arduino: Uso del Monitor Serial

Cómo PWM simula voltaje analógico

Cómo Arduino simplifica el PWM

Uso de Botones con Resistencia Pull-Up en Arduino

Monitor temperatura con Arduino y LM35

Cálculo del Multiplicador para Convertir Lecturas de Sensor a Celsius

LCD 16x2 con Arduino sin conexión PC

Programación de Semáforos con Arduino y Sensores

Automatización de procesos

Motores con Arduino y puente H L293D

Cómo funciona un servomotor con Arduino

Potenciómetro controla servomotor en Arduino

Proyecto: Construcción y Programación de un Robot de Evasión de Obstáculos

Programación de Funciones de Control de Movimiento en Arduino

Robot sensor Pololu: lógica inversa y ciclo while