Encendido suave de Arduino de un LED RGB desde un botón. Control de brillo del LED mediante potenciómetro. Descripción del programa para Arduino.

En este experimento, agregamos una porción de brillo al LED con un botón y lo reducimos con el otro.

LISTA DE PIEZAS PARA EL EXPERIMENTO

- 1 placa Arduino Uno;

- 1 placa de pruebas sin soldadura;

- 2 botones de reloj;

- 1 resistencia de valor nominal 220 Ohmios;

- 1 LED;

- 7 cables macho-macho.

DIAGRAMA DE CIRCUITO

DIAGRAMA EN PANEL

NOTA

• Si está reelaborando el circuito del experimento anterior, tenga en cuenta que esta vez necesitamos conectar el LED a un puerto que admita PWM.

BOSQUEJO

descargar boceto para Arduino IDE

#definir PLUS_BUTTON_PIN 2 #definir MINUS_BUTTON_PIN 3 #definir LED_PIN 9 int brillo = 100; booleano plusUp = verdadero; booleano menosArriba = verdadero; void setup() ( pinMode(LED_PIN, OUTPUT); pinMode(PLUS_BUTTON_PIN, INPUT_PULLUP); pinMode(MINUS_BUTTON_PIN, INPUT_PULLUP); ) void loop() ( analogWrite(LED_PIN, brillo); // responde a los clics usando la función que escribimos plusUp = handleClick(PLUS_BUTTON_PIN, plusUp, +35); minusUp = handleClick(MINUS_BUTTON_PIN, minusUp, -35); ) // Función propia con 3 parámetros: el número de pin con el botón // (buttonPin), el estado antes de la verificación (wasUp ) y gradación // de brillo al hacer clic en el botón (delta). La función devuelve // ​​(retorno en inglés) el nuevo estado actual del botón boolean handleClick(int buttonPin, boolean wasUp, int delta) ( boolean isUp = digitalRead(buttonPin); if (wasUp && !isUp) ( delay(10 ); isUp = digitalRead(buttonPin); // si hubo un clic, cambia el brillo de 0 a 255 if (!isUp) brillo = constrain(brillo + delta, 0, 255); ) return isUp; // devuelve el valor de regreso al código de la persona que llama)

EXPLICACIONES DEL CÓDIGO

• Podemos utilizar no solo funciones integradas, sino también crear las nuestras propias. Esto se justifica cuando necesitamos repetir las mismas acciones en diferentes lugares del código o, por ejemplo, necesitamos realizar las mismas acciones sobre diferentes datos, como en este caso: procesar la señal de los puertos digitales 2 y 3.
• Puede definir sus propias funciones en cualquier parte del código fuera del código de otras funciones. En nuestro ejemplo, definimos una función después bucle .
• Para definir nuestra propia función necesitamos:
  • Declare qué tipo de datos devolverá. En nuestro caso es booleano. Si la función solo realiza algunas acciones y no devuelve ningún valor, use la palabra clave vacío
  • Asigne a la función un nombre: identificador. Aquí se aplican las mismas reglas que cuando se nombran variables y constantes. Las funciones se nombran con el mismo estilo. comoVariables .
  • Entre paréntesis, enumere los parámetros pasados ​​a la función, indicando el tipo de cada uno. Esta es una declaración de variables que son visibles dentro de la función recién creada, y solo dentro de ella. Por ejemplo, si en este experimento intentamos acceder estaba arriba o depende de bucle() Recibiremos un mensaje de error del compilador. Asimismo, las variables declaradas en bucle, no son visibles para otras funciones, pero sus valores se pueden pasar como parámetros.
  • Entre un par de llaves, escriba el código ejecutado por la función
  • Si la función debe devolver algún valor, use la palabra clave devolver especifique qué valor devolver. Este valor debe ser del tipo que declaramos.
• Las llamadas variables globales, es decir Las variables a las que se puede acceder desde cualquier función generalmente se declaran al comienzo del programa. En nuestro caso, esto es brillo .
• Dentro de la función que creamos manejarHaga clic Sucede lo mismo que en el experimento.
• Dado que con un aumento de brillo de 35, después de no más de ocho clics consecutivos en uno de los botones, el valor de la expresión brillo + delta saldrá del intervalo . Usando la función constreñir limitamos los valores permitidos para la variable brillo límites de intervalo especificados.
• en expresión plusUp = handleClick(PLUS_BUTTON_ ALFILER , másArriba, +35) accedemos a la variable más arriba dos veces. Porque el = pone el valor del operando derecho en el izquierdo, calculando primero lo que devolverá manejarHaga clic. Entonces cuando le damos más arriba como parámetro, todavía tiene el valor anterior calculado durante la última llamada manejarHaga clic .
• Adentro manejarHaga clic Calculamos el nuevo valor de brillo del LED y lo escribimos en una variable global. brillo, que en cada iteración bucle acaba de pasar a analógicoEscribir .

PREGUNTAS PARA PONERTE A PRUEBA

1. ¿Qué significa la palabra clave? vacío ?
2. Cómo se comporta un programa cuando se menciona una variable desde diferentes lados del operador de asignación = ?

TAREAS PARA SOLUCIÓN INDEPENDIENTE

1. Modifique el código para que el paso de cambio de brillo se ajuste en un solo lugar.
2. Cree otra función y vuelva a trabajar el código para que una función sea responsable de rastrear las pulsaciones de teclas y otra sea responsable de calcular el brillo del LED y devolverlo a analógicoEscribir .

​

Ahora veamos el LED multicolor, que a menudo se llama abreviadamente: LED RGB. RGB es una abreviatura que significa: Rojo - rojo, Verde - verde, Azul - azul. Es decir, dentro de este dispositivo se colocan tres LED separados. Dependiendo del tipo, un LED RGB puede tener un cátodo común o un ánodo común.

1. Mezclando colores

¿Por qué es mejor un LED RGB que tres convencionales? Se trata de la capacidad de nuestra visión para mezclar la luz de diferentes fuentes ubicadas una cerca de la otra. Por ejemplo, si colocamos los LED azules y rojos uno al lado del otro, a una distancia de varios metros su brillo se fusionará y el ojo verá un punto violeta. Y si además le añadimos verde el punto nos aparecerá blanco. Así es exactamente como funcionan los monitores de ordenador, los televisores y las pantallas exteriores. La matriz del televisor consta de puntos individuales de diferentes colores. Si tomas una lupa y miras el monitor encendido, podrás ver fácilmente estos puntos. Pero en una pantalla exterior, los puntos no están muy densos, por lo que se pueden distinguir a simple vista. Pero desde una distancia de varias decenas de metros estos puntos son indistinguibles. Resulta que cuanto más cerca están los puntos multicolores entre sí, menos distancia necesita el ojo para mezclar estos colores. De ahí la conclusión: a diferencia de tres LED separados, la mezcla de colores de un LED RGB ya se nota a una distancia de 30-70 cm. Por cierto, un LED RGB con lente mate funciona aún mejor.

2. Conexión de un LED RGB a Arduino

Dado que el LED multicolor consta de tres LED normales, los conectaremos por separado. Cada LED está conectado a su propio pin y tiene su propia resistencia independiente. En este tutorial estamos usando un LED RGB con un cátodo común, por lo que solo habrá un cable a tierra. Diagrama esquemático
Aspecto del diseño

3. Programa para controlar un LED RGB

vamos a componer un programa sencillo, que iluminará cada uno de los tres colores por turno. byte constante rPin = 3; byte constante gPin = 5; byte constante bPin = 6; void setup() ( pinMode(rPin, SALIDA); pinMode(gPin, SALIDA); pinMode(bPin, SALIDA); ) void loop() ( // apaga el azul, enciende el rojo digitalWrite(bPin, LOW); digitalWrite( rPin, ALTO); retraso(500); // apaga el rojo, enciende el verde digitalWrite(rPin, LOW); digitalWrite(gPin, ALTO); retraso(500); // apaga el verde, enciende el azul digitalWrite(gPin , LOW); digitalWrite( bPin, HIGH); delay(500); ) Cargue el programa en Arduino y observe el resultado. Tu navegador no es admite la etiqueta de video. Optimicemos un poco el programa: en lugar de las variables rPin, gPin y bPin, usaremos una matriz. Esto nos ayudará en las siguientes tareas. byte constante rgbPins = (3,5,6); configuración vacía() (para(byte i=0; i<3; i++) pinMode(rgbPins[i], OUTPUT); } void loop() { digitalWrite(rgbPins, LOW); digitalWrite(rgbPins, HIGH); delay(500); digitalWrite(rgbPins, LOW); digitalWrite(rgbPins, HIGH); delay(500); digitalWrite(rgbPins, LOW); digitalWrite(rgbPins, HIGH); delay(500); }

4. Siete colores del arcoiris

Ahora intentemos iluminar dos colores al mismo tiempo. Programemos la siguiente secuencia de colores:

• rojo
• rojo + verde = amarillo
• verde
• verde + azul = azul claro
• azul
• azul + rojo = morado

Omitimos el color naranja por simplicidad. Entonces, resultaron ser seis colores del arco iris 🙂 const byte rgbPins = (3,5,6); const byte arcoiris = ( (1,0,0), // rojo (1,1,0), // amarillo (0,1,0), // verde (0,1,1), // azul ( 0,0,1), // azul (1,0,1), // violeta); configuración vacía() (para(byte i=0; i<3; i++) pinMode(rgbPins[i], OUTPUT); } void loop() { // перебираем все шесть цветов for(int i=0; i<6; i++){ // перебираем три компоненты каждого из шести цветов for(int k=0; k<3; k++){ digitalWrite(rgbPins[k], rainbow[i][k]); } delay(1000); } } В результате работы программы получается: Your browser does not support the video tag.

5. Cambio de color suave

No en vano conectamos el LED RGB a los pines 3, 5 y 6. Como sabes, estos pines te permiten generar una señal PWM de diferentes ciclos de trabajo. En otras palabras, no podemos simplemente encender o apagar el LED, sino controlar el nivel de voltaje en él. Esto se hace usando la función analógicoEscribir. Asegurémonos de que nuestro LED realice una transición entre los colores del arco iris no de forma abrupta, sino suave. byte constante rgbPins = (3,5,6); int tenue = 1; configuración vacía() (para(byte i=0; i<3; i++){ pinMode(rgbPins[i], OUTPUT); } // начальное состояние - горит красный цвет analogWrite(rgbPins, 255); analogWrite(rgbPins, 0); analogWrite(rgbPins, 0); } void loop() { // гасим красный, параллельно разжигаем зеленый for(int i=255; i>=0; i--)( analogWrite(rgbPins, i/dim); analogWrite(rgbPins, (255-i)/dim); delay(10); ) // apaga el verde, enciende el azul en paralelo for(int i=255 ; i> =0; i--)( analogWrite(rgbPins, i/dim); analogWrite(rgbPins, (255-i)/dim); delay(10); ) // apaga el azul, enciende el rojo en paralelo for(int i=255 ; i>=0; i--)( analogWrite(rgbPins, i/dim); analogWrite(rgbPins, (255-i)/dim); delay(10); ) ) La variable tenue determina el brillo del resplandor. En tenue = 1 tenemos el brillo máximo. Cargue el programa en Arduino. Su navegador no soporta la etiqueta de vídeo.

Tareas

1. Indicador de temperatura. Agreguemos un termistor al circuito y conéctelo a la entrada analógica. El LED debe cambiar de color dependiendo de la temperatura del termistor. Cuanto más baja es la temperatura, más azul es el color y cuanto más alta es la temperatura, más rojo.
2. Lámpara RGB con regulador. Agreguemos tres resistencias variables al circuito y conéctelas a las entradas analógicas. El programa debe leer continuamente los valores de resistencia y cambiar el color del componente LED RGB correspondiente.

En este ejemplo, aprenderá cómo cambiar el brillo de un LED usando resistencias con diferentes resistencias.

Para este ejemplo necesitarás

1 LED de 5 mm de diámetro

Resistencia de 1 270 ohmios (rojo, morado, marrón)

Resistencia de 1 470 ohmios (amarillo, morado, marrón)

1 resistencia de 2,2 kOhm (roja, roja, roja)

1 resistencia de 10 kOhm (marrón, negro, naranja)

LED - información general

Los LED funcionan bien en dispositivos para varios tipos de indicación. Consumen poca electricidad y son duraderos.

En este ejemplo utilizamos los LED más comunes con un diámetro de 5 mm. También son comunes los LED con un diámetro de 3 milímetros y los LED grandes con un diámetro de 10 mm.

No se recomienda conectar el LED directamente a una batería o fuente de voltaje. En primer lugar, primero debe averiguar dónde exactamente tiene el LED sus patas negativas y positivas. Bueno, en segundo lugar, es necesario utilizar resistencias limitadoras de corriente; de ​​lo contrario, el LED se quemará muy rápidamente.

Si no utiliza una resistencia con el LED, el LED fallará muy rápidamente porque fluirá demasiada corriente a través de él. Como resultado, el LED se calentará y el contacto que genera luz se destruirá.

Hay dos formas de distinguir entre las patas positivas y negativas de un LED.

La primera es que el tramo positivo es más largo.

La segunda es que al entrar en la carcasa del propio diodo, hay un borde plano en el conector de la pata negativa.

Si te encuentras con un LED que tiene un borde plano en el lado más largo, el lado más largo sigue siendo positivo.

Resistencias - información general

Resistir - resistencia (inglés)

Como sugiere el nombre, las resistencias resisten el flujo de electricidad. Cuanto mayor sea el valor (ohmios) de la resistencia, mayor será la resistencia y menos corriente fluirá a través del circuito en el que está instalada. Usaremos esta propiedad de las resistencias para regular la corriente que pasa por el LED y así su brillo.

Pero primero hablemos un poco de resistencias.

Las unidades en las que se mide la resistencia son los Ohmios, que en muchas fuentes se denotan con la letra griega Ω - Omega Dado que Ohm es un valor pequeño de resistencia (casi imperceptible en un circuito), muchas veces operaremos con unidades como kOhm - kiloohm (1000 ohmios) y MOhm megaohmios (1.000.000 ohmios).

En este ejemplo, usaremos resistencias con cuatro valores diferentes: 270 Ω, 470 Ω, 2,2 kΩ y 10 kΩ. Los tamaños de estas resistencias son los mismos. Color también. Lo único que los distingue son las rayas de colores. Es a partir de estas tiras que se determina visualmente el valor de las resistencias.

Para resistencias que tienen tres franjas de colores y la última franja dorada, funcionan las siguientes correspondencias:

Marrón 1

rojo 2

naranja 3

Verde 5

Púrpura 7

Las dos primeras franjas indican los primeros 2 valores numéricos, por lo que rojo y morado significan 2, 7. La siguiente franja es el número de ceros que se deben colocar después de los dos primeros dígitos. Es decir, si la tercera tira es marrón, como en la foto de arriba, habrá un cero y el valor de la resistencia será de 270 Ω.

Resistencia con franjas de color marrón, negro, naranja: 10 y tres ceros, es decir, 10000 Ω. Es decir, 10 kΩ.

A diferencia de los LED, las resistencias no tienen patas positivas y negativas. No importa qué pata uses para conectarlos a la alimentación o a tierra.

Diagrama de conexión

Conéctese de acuerdo con el siguiente diagrama:

El Arduino tiene un pin de 5V para alimentar periféricos. Lo usaremos para alimentar un LED y una resistencia. No necesitarás nada más de la placa, simplemente conéctala vía USB a tu ordenador.

Con una resistencia de 270 Ω, el LED debería iluminarse con bastante intensidad. Si reemplaza la resistencia de 270 Ω con una resistencia de 470 Ω, el LED no brillará tanto. Con una resistencia de 2,2 kΩ, el LED debería apagarse un poco más. Después de todo, con una resistencia de 10 kΩ, el LED apenas será visible. Es probable que para poder ver la diferencia en el último paso tengas que sacar el adaptador rojo, usándolo como interruptor. Entonces podrás ver la diferencia de brillo.

Por cierto, puedes realizar este experimento con las luces apagadas.

Varias opciones de instalación de resistencias

En el momento en que se conectan 5 V a una pata de la resistencia, la segunda pata de la resistencia se conecta a la pata positiva del LED y la segunda pata del LED se conecta a tierra. Si movemos la resistencia para que quede detrás del LED como se muestra a continuación, el LED seguirá encendido.

LED parpadeando

Podemos conectar el LED a la salida de Arduino. Mueva el cable rojo del pin de alimentación de 5 V a D13 como se muestra a continuación.

Ahora descargue el ejemplo de "Blink" que vimos. Tenga en cuenta que ambos LED, el integrado y el externo que instaló, comenzaron a parpadear.

Intentemos usar un pin diferente en el Arduino. Digamos D7. Mueva el conector del pin D13 al pin D7 y cambie la siguiente línea de su código:

Sube el boceto modificado al Arduino. El LED seguirá parpadeando, pero esta vez usando energía del pin D7.

En lecciones anteriores nos familiarizamos con los circuitos más simples: montaje y. Hoy estamos montando un modelo con potenciómetro (resistencia variable) y LED. Un modelo de este tipo se puede utilizar para controlar un robot.

Potenciómetro es una variable Resistencia con resistencia ajustable.Los potenciómetros se utilizan en robótica como reguladores de diversos parámetros: volumen del sonido, potencia, voltaje, etc. En nuestro modelode girar la perilla del potenciómetroEl brillo del LED dependerá. Este es también uno de los esquemas básicos.

Instrucciones en vídeo para montar el modelo:

Para montar el modelo necesitamos:

• Placa Arduino (o análogas);
• Tablero de circuitos;
• 6 cables y/o jumpers macho a macho;
• Diodo emisor de luz;
• potenciómetro (resistencia variable);
• resistencia de 220 ohmios;
• Arduino IDE, que se puede descargar desde el sitio web de Arduino.

¿Qué necesitas para conectar un potenciómetro y un LED a Arduino?

Esquema de conexión para modelo Arduino con potenciómetro y LED:

Esquema de conexión modelo Arduino con potenciómetro y LED

El siguiente programa es adecuado para que funcione este modelo (simplemente puede copiar el programa en el IDE de Arduino):

// dar nombres de pines con LED
// y potenciómetro
#definir led 9
#definir olla A0
configuración nula()
{
// pin con LED - salida
pinMode(led, SALIDA);
// pin con potenciómetro - entrada
pinMode(potenciómetro, ENTRADA);
}
bucle vacío()
{
// declarar la variable x
intx;
// lee el voltaje del potenciómetro:
//se recibirá un número del 0 al 1023
// lo dividimos entre 4 y obtenemos un número en el rango
// 0-255 (se descartará la parte fraccionaria)
x = lectura analógica(potenciómetro) / 4;
// enviar el resultado al LED
escritura analógica(led, x);
}

Así es como se ve el modelo Arduino ensamblado de un potenciómetro con LED:

Modelo Arduino con potenciómetro y LED montado.

Esto completa la tercera lección “Arduino para principiantes”. ¡Continuará!

Publicaciones de lecciones:

1. Primera lección: .
2. Segunda lección: .
3. Tercera lección: .
4. Cuarta lección: .
5. Quinta lección: .
6. Lección seis: .
7. Séptima lección: .
8. Octava lección: .
9. Novena lección:

E intentemos completar una nueva tarea. Creo que todo el mundo ha visto las guirnaldas de Año Nuevo en las que los LED parpadean suavemente. Digamos que queremos hacer algo como esto.
Ya hemos visto la función digitalWrite() y sabemos que el valor que escribe puede tener dos opciones: alto o bajo. En este caso, la función analogWrite() nos ayudará. Las "formulaciones" de funciones difieren sólo en los prefijos iniciales, por lo que son fáciles de recordar.

La función analogWrite(), como digitalWrite(), contiene dos argumentos entre paréntesis y funciona según el mismo principio verbal: "dónde, qué". La principal diferencia es la capacidad de registrar una amplia gama de valores en lugar de los habituales BAJOS o ALTOS. Esto nos permitirá ajustar el brillo del LED. La nota principal a tener en cuenta es que esta función sólo funciona en determinados contactos. Estos pines están marcados con un símbolo "~". Este símbolo indica que se trata de un contacto PWM. PWM (modulación de ancho de pulso) suena como PWM (modulación de ancho de pulso) en ruso. El principio de funcionamiento se basa en cambiar la duración del pulso. Gráficamente esto se puede representar así:

Intentemos descubrir cómo funciona esto mirando un ejemplo sencillo. Para hacer esto, necesita conectar el LED al contacto PWM a través de una resistencia de 150 ohmios y "conectar" un programa simple al Arduino. El diagrama de conexión y el código de boceto se presentan a continuación:

configuración nula()
{
pinMode(led,SALIDA);
}

bucle vacío()
{
para(int i=0; i<=255; i++)
{
escritura analógica(led,i);
retraso(10);
}
para(int i=255; i>=0; i--)
{
escritura analógica(led,i);
retraso(10);
}
}

Creo que el código es claro en general, pero debemos prestar un poco de atención al bucle for(). Existe el permiso. Como estamos trabajando con una resolución de 8 bits (esto se discutirá un poco más adelante), el valor mínimo será 0 y el máximo será 255. Al final de cada iteración, configuramos el retraso de tiempo en 10 ms.

Volvamos al diagrama de la lección anterior e intentemos hacer una guirnalda similar usando la función analogWrite().

botón intPin = 2;
int pines = (3,5,6,9,10,11);

booleano último botón = BAJO;
booleano botónactual = BAJO;
habilitación booleana = falso;

configuración nula()
{
pinMode(botónPin, ENTRADA);
para(int modo = 0; modo<= 5; mode++) pinMode(pins, OUTPUT);
}

rebote booleano (último booleano)
{
corriente booleana = digitalRead(buttonPin);
si (¡último! = actual)
{
retraso(5);
actual = digitalRead(botónPin);
}
corriente de retorno;
}

bucle vacío()
{
botónactual = antirrebote(últimoBotón);
if(últimoBotón == BAJO && botónactual == ALTO)
{
habilitar = !habilitar;
}

Si (habilitar == verdadero)
{
para (int i=0; i<=5; i++)
{
para (int brillo = 0; brillo<= 255; brightness++)
{
retraso(1);
}
retraso(40);
}
para (int i=0; i<=5; i++)
{
para (int brillo = 255; brillo >= 0; brillo--)
{
analogWrite(pines[i], brillo);
retraso(1);
}
retraso(40);
}
}

Si (habilitar == falso)
{
para(int i = 0; i<= 5; i++) digitalWrite(pins[i], LOW);
}

ÚltimoBotón = botónactual;
}

Visualmente el boceto se ha vuelto algo más complejo. De hecho, aquí todo es sencillo y averigüémoslo. Necesitamos identificar todos los LED conectados, pero en lugar del LED int habitual utilizamos una matriz, cada elemento del cual es un pin PWM en el Arduino. En el cuerpo de la función void setup(), también actuamos de forma astuta. Confiamos el "listado" de todos los contactos al bucle for(), con cada iteración del cual se configura el contacto correspondiente en SALIDA. Pasemos a la función void loop(). La función antirrebote() y la condición if() inicial permanecen sin cambios. Todavía estamos comprobando los niveles de dos variables: el valor anterior (inicialmente BAJO) y el estado actual del botón. Cuando se cumplen estas condiciones, el valor de la variable de habilitación se invierte. Con esto en mente, hemos agregado dos condiciones if() más simples. Si enable = true, entonces se enciende la guirnalda, cuya suavidad "fluye" está controlada por el bucle for(). Si enable = false, entonces todos los LED se apagan. Al final de las condiciones, la variable lastButton toma el estado actual del botón.
Mientras probábamos nuestro programa, notamos que no todo funcionaba como se esperaba. ¿Recuerda que en la última lección hicimos una enmienda que indica que si el retraso es grande, el botón se activará después de que haya expirado? En el ejemplo anterior, cuando se encendió la guirnalda, el retraso total en el cuerpo de la función void loop() fue de 85 ms. Esto nos dio la oportunidad de “llegar allí” en un determinado período de tiempo. En este boceto, bajo la misma condición, el retraso difiere varias veces. Quizás, si desea apagar la guirnalda, se le ocurra la palabra "interrumpir". ¡Esta será la solución a este problema!

Espero que este artículo te haya resultado útil. En el próximo tutorial veremos las interrupciones en Arduino y lograremos el resultado deseado.