Practica de Arduino Led con potenciómetro.
/* Práctica 3 Voltajes analogicos y PWM Ajustar el brillo de un led dependiendo del voltaje de un potenciometro.*/
led =3; pot =0;
const int const int
brillo;
int
// led conectado al pin 3 // el pot esta conectado al pin A0
//variable para el brillo
() { pinMode (led,
void setup
);
OUTPUT
// declaramos el led como salida
/* los pin analogicos se declaran como entrada automaticamente */
} void loop
(){
/*leemos el valor del potenciometro divididos entre 4 ya que solo se pueden usar valores entre 0 y 255 en a analog nalog Write */
brillo =
(pot) / 4;
analogRead
/*analogWrite recibe dos valores,el pin a usar y la intensidad del voltaje los valores de voltaje van de 0 a 255*/
(led, brillo);
analogWrite
}
Controlar intensidad de uno o varios LED POR RACSO · 21 MAYO, 2014
Arduino tiene integrado un convertidor análogo digital, por el cual podemos recibir voltajes entre o[V] y 5[V] para ser traducidos en números entre o y 1023. Sin embargo, no contamos con un convertidor digital análogo con el cual enviar señales de voltaje continuo distinto a 5[V], como para, p or ejemplo, controlar la intensidad de un LED.
Para solucionar el problema anteriormente planteado es que se usan los pines que p ueden enviar señales con modulación por ancho de pulso PWM. PWM. Para realizar esto, necesitamos conectar un LED a uno de los pines que permiten señales PWM como salida. En la siguiente figura se muestra un tipo de conexión simple.
Se debe conectar el ánodo del LED (patita más l arga) a la salida q ue permite PWM (tienen el símbolo ~), luego en serie una resistencia de 220[ohm] para limitar la corriente de manera que Arduino esté protegida. Luego, se debe compilar y cargar el siguiente código:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
/* Programa de prueba para el control de la intensidad de un LED por medio de señales PWM. Se hace parpadear el LED cambiando su intensidad de forma oscilatoria. Autor: Arduino UTFSM Fecha: 20 de Mayo 2014 Materiales utilizados: 1 Arduino UNO Rev3 1 LED de color azul conectado a salida PWM 9 1 Resistencia de 220[ohm] 2 Cables de conexión */ /*------Declaración de variables-----*/ int led = 9; //Se escoje la variable donde se conectará el LED int i;//Variable auxiliar para condicionales void setup() { pinMode(led, OUTPUT);//Se inicializa inicializa como OUTPUT el pin a usar. Debe ser PWM } void loop() { //Se recorren los valores desde el 0 al 255 para enviar una señal PWM con ciclo de trabajo de 0% a 100% //aumentando en 2.55% el ciclo de trabajo cada 10 mili segundos. for(i=0; i<256; i++){ analogWrite(led,i); delay(10); } //Se recorren los valores del 255 al 0 de mayor a menor igual que el for anterior. for(i=255; i>-1; i--){ analogWrite(led,i); delay(10); } }
Con el programa anterior veremos cómo el LED parpadea en su intensidad de manera oscilatoria.
A continuación haremos un juego de intensidades para ayudar ejemplificar las capacidades de las señales PWM en el control de LEDs. Para esto, conectaremos 3 LED a distintas salidas PWM como muestra la siguiente figura:
Luego de conectar los LED continuamos con la compilación y la carda del siguiente código, con el cual podremos ver dos tipos de juegos de luces en intensidad.
1 /* 2 Programa para el control de intensidad de 3 LED por medio de señales PWM. 3 Se controla con dos f unciones: 4 funcion wave: Emula una onda de intensidades en ir y venir para los 3 LED 5 funcion random: Enciende de manera aleatoria los LED con un valor de intensidad tambien aleatorio 6 7 Materiales: 8 1 Arduino UNO Rev3
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
3 LED 3 Resistencias de 220[ohm] Cables para conexion Autor: Arduino UTFSM Fecha: 20 - Mayo - 2014 */ /*-----Declaracion de variables-----*/ //Variable para controlad LED a controlar int led[3] = {9,10,11}; //Deben ser PWM int i,j; //Variables auxiliares para ciclos repetitivos int repeat = 10; //Variable para controlar repeticion de funcion void setup() { // Se inicializan los 3 pines PWM a utilizar como salida for(i=0; i<3; i++) pinMode(led[i], OUTPUT); } void loop() { wave(repeat); randomLed(repeat); } void wave(int repeat){ for(j=0; j-1; i--){ //Se disminuye el primer LED de 255 a 0 //Se aumenta el segundo LED de 0 a 255 analogWrite(led[0],i); analogWrite(led[1],255-i); } for(i=0; i<256; i++){ //Se disminuye el segundo LED de 255 a 0 //Se aumenta el tercer LED de 0 a 255 analogWrite(led[1],255-i); analogWrite(led[2],i); } for(i=255; i>-1; i--){ //Se disminuye el tercer LED de 255 a 0 analogWrite(led[2],i); } //Se realiza el ciclo inverso al anterior for(i=0; i<256; i++){ analogWrite(led[2],i); } for(i=255; i>-1; i--){ analogWrite(led[2],i); analogWrite(led[1],255-i); } for(i=0; i<256; i++){ analogWrite(led[1],255-i); analogWrite(led[0],i); } for(i=255; i>-1; i--){ analogWrite(led[0],i); } } } void randomLed(int repeat){ for(i=0; i
Podemos ver el resultado de este programa en la siguiente simulación:
El desafío es que este tipo de juegos de luces está limitado sólo por nuestra creatividad, esperamos puedas inventar combinaciones mucho más atractivas.
Arduino - Control de intensidad de un LED
Ahora en esta entrada mostrare la practica de "Control de intensidad de un LED", donde es usado una Mini fotocelda, el cual es usado para detectar luz. Esta
practica consistira en
controlar
la
intensidad
de
un
LED
y
se
usara
la
luz
para
demostrarlo. demostrar lo.
Material
Arduino UNO
Una Mini fotocelda
LED
Cables
Resistencias 220 y 10K
Protoboard
Montaje de circuito
Enseguida mostrare el codigo del programa que sera subido al Arduino, en donde esta documentado para entender la sintaxis.
Se muestran los ciclos usados en el codigo para recibir los valores de la lectura analoga de la minifotocelda, luego se realiza una conversion y se muestran los datos obtenidos
1. 2.
/* ---------------------------------------------
3. 4. 5.
Control de intensidad de un LED --------------------------------------------*/
6. 7.
//------------------------------------
8.
//Funcion principal
9.
//------------------------------------
10.
void setup void setup() () // Se ejecuta cada vez que el Arduino se inicia
11.
{
12.
Serial.begin Serial.begin( (9600 9600) ); //Inicia comunicacion
13. 14.
pinMode( pinMode(9,OUTPUT) OUTPUT);
//Configurar el pin 9 como salida
}
15. 16. //-----------------------------------17. //Funcion ciclicla 18. //-----------------------------------19.
void loop void loop() () // Esta funcion se mantiene ejecutando
20.
{
//
cuando se da energia al Arduino
21. 22. 23. 24.
//Variable del valor de la lectura analoga de la mini fotocelda
int foto int foto = analogRead( analogRead(A0) A0);
25.
//Verifica el valor máximo y se realiza una conversion
26.
int conversion int conversion = 780 - foto; foto;
27. 28.
//Condicion para establecer un valor absoluto
29.
if ( conversion < 0)
30.
conversion = conversion * -1; //Multiplicar por -1
31. 32.
//Se Imprimen los datos de la mini fotocelda
33.
Serial.print Serial.print( ("Foto : ") ");
34.
Serial.print Serial.print( (foto) foto);
35.
Serial.println Serial.println( ("" "") );
36. 37.
//Se Imprimen los datos del valor de la conversion
38.
Serial.print Serial.print( ("Conv : ") ");
39.
Serial.print Serial.print( (conversion) conversion);
40.
Serial.println Serial.println( ("" "") );
41. 42.
//Escritura análoga de PWM en el LED de acuerdo a la conversion
43.
analogWrite( analogWrite(9, conversion) conversion);
44. 45.
delay( delay(100 100) );
46. 47.
}
48. 49. //Fin programa
A continuación se muestra un video donde se muestra como quedo este pequeño ejemplo en Arduino.
/*Lee la entrada analogica A0, mapea el resultado al rango de 0 a 255 y utiliza el resutado para poner la anchura del pulso PWM. Tambien se escribe en el monitor serie el valor binario de A0 y el valor mapeado para la señal PWM. De esta manera controlamos la luminosidad del led verde de la placa Edubasica El circuito: * potenciometro conectado a la entrada analogica A0. Terminal central del potenciometro a pin A0. Resto de terminales del potenciometro a +5V y masa * Circuito de LED verde conectado a D3-PWM. */ // pines usados: const int int analogInPin analogInPin = A0; // Entrada analogica A0 del potenciometro const int int analogOutPin analogOutPin = 3; // Salida PWM int potValor = 0; int potValor // valor de lectura del potenciometro int outputValor int outputValor = 0; // valor de salida de la señal PWM void setup setup() () { // inicializacion del monitor serie a 9600 bps: Serial.begin begin(9600); (9600); } void loop loop() () { // lee el valor de la entrada analogica: potValor = analogRead analogRead(analogInPin); (analogInPin); // mapea el rango para la señal de salida PWM:
outputValor = map map(potValor, (potValor, 0, 1023, 0, 255); // asigna el valor cambiado a pin 3 PWM: analogWrite(analogOutPin, analogWrite (analogOutPin, outputValor); // escribe el resultado en el monitor serie: Serial.print print(("Potenciometro = " ); " ); Serial.print print(potValor); (potValor); Serial.print print(("\t PWM = "); "); Serial.println println(outputValor); (outputValor); // espera 1 segundo cada bucle para una visualizacion aceptable // conviene tener un valor aunque sea pequeño (10ms) // por el proceso de conversion de A/D delay(10); delay (10); }
Controlando el brillo de un led con un potenciometro - componentes - circuito - diagrama - código - variantes - referencias - otros -
En este proyecto vamos a controlar el brillo de un led utilizando un potenciometro. Tomaremos los valores analógicos del voltaje que nos da el potenciometro y con ellos haremos variar la intensidad de la luz del led. A aumentar el voltaje en el potenciometro, aumentaremos el brillo del led y viceversa. - al inicio
Componentes
arduino protoboard un led un potenciometro una resistencia de 220 oms (rojo, rojo, café) - al inicio
Circuito El circuito de este proyecto es la combinación de dos de los circuitos que ya hemos estado utilizando. Para la entrada, usaremos el circuito para sensar los valores analógicos que nos da un potenciometro. Y para la salida, que también será analógica, el circuito para iluminar un led, por lo que ahora tenemos que poner el led en un pin con salida PWM, el 9 por ejemplo.
- al inicio
Diagrama
- al inicio
Código En el código de este proyecto vamos a usar la función analogRead() para leer los valores que nos da el potenciometro.. Y vamos a usar la función analogWrite() potenciometro analogWrite() para para darle los valores PWM al led e iluminarlo así de acuerdo a los valores del potenciometro potenciometro.. Como los valores que obtenemos del potenciometro están en el rango de 0 a 1023, que son los valores mínimo y máximo que nos devuelve la función analogRead() y al led sólo s ólo podemos podem os darle dar le valores entre 0 y 255, que son los valores PWM que podemos usar con la función analogWrite() , tenemos que hacer una conversión entre estos valores. Para ello usaremos la función map() que nos permite ajustar un valor entre ambos am bos rangos. A esta función map() le tenemos tenem os que pasar 5 parámetros. El primero es el valor que queremos mapear . Después le damos el rango de valores entre los que está este valor y después el rango de valores entre los que queremos convertirlo o mapearlo mapearlo.. La
función nos devolverá el valor equivalente, ajustado al nuevo rango. /* En este proyecto leemos el valor de un potenciometro y con este valorla damos el brillo a un led usando una señal PWM */ // Declaramos las constantes que vamos a usar const int pinSensor int pinSensor = 0; // pin del sensor analogico, con un potenciometro const int pinLed = 9; // pin con el led, tiene pwm // Declaramos las variables que vamos a usar int brilloLed = 0; // variable para guardar el valor con el que se iluminara el led int valorPotenciometro int valorPotenciometro = 0; // variable para guardar el valor leido del sensor void setup() { // Incializa el pin del boton como entrada pinMode(pinSensor, pinMode (pinSensor, INPUT INPUT); ); // Incializa el pin del led como salida, aunque no es necesario pinMode(pinLed, pinMode (pinLed, OUTPUT OUTPUT); ); // Inicializa la comunicacion serial Serial.begin begin(9600); (9600); } void loop (){ // Lee el valor del sensor sensor valorPotenciometro valorPotenci ometro = analogRead analogRead(pinSensor); (pinSensor); // Transforma este valor valor en el valor valor que que usaremos usaremos para para el led // Para ello ello usaremos usaremos la funcion map() map() brilloLed = map map(valorPotenc (valorPotenciometro, iometro, 0, 1023, 0, 255); // Utilizamos este valor para iluminar iluminar el led led analogWrite(pinLed, analogWrite (pinLed, brilloLed); // manda los valores por el serial Serial.print("Valor Serial.print ("Valor del Potenciometro = "); Serial.print(valorPotenciometro); Serial.print (valorPotenciometro); Serial.print(" Serial.print (" Brillo del Led = "); Serial.println(brilloLed); Serial.println (brilloLed); delay(100); delay (100); }
- al inicio
Variantes Prueba a hacer lo mismo con otros sensores analógicos. ¿Que pasa con los valores máximos y mínimos de estos sensores? ¿Que parametros deberías pasarle entonces a la función map()?
LDR con Arduino - Ajuste de intensidad de un LED
Publicado: 13 Febrero 2014
La sencillez de Arduino para interactuar con sensores hace que el desarrollo de proyectos solo tenga los límites de nuestra imaginación. En el siguiente artículo, usaremos una pequeña resistencia variable con la luz llamada LDR para ajustar la intensidad de un LED. Es un circuito bastante sencillo, pero es la base fundamental para proyectos más complejos.
Esquema eléctrico Arduino Mega.
Esquema gráfico Arduino Mega. Funcionamiento Como se puede ver en el esquema eléctrico, en este circuito se usaran muy pocos componentes, un LED con su resistencia limitadora R1, la resistencia LDR junto a una resistencia de 1k que conforman un divisor de tensión del cual se analizará la variación de tensión. Partiendo de un estado de iluminación, cuando a la LDR se le aplique una fuente de luz máxima su resistencia interna disminuirá (supongamos un caso ideal resistencia 0), por tanto, A0 tendrá un valor más bajo (si en el caso ideal LDR es 0 ohmios, A0 estaría conectado a GND, 0 voltios). Por el otro lado, al reducir a la mínima iluminación la resistencia de la LDR aumentará (supongamos un caso ideal resistencia infinita), A0 tendrá un valor más alto (si en el caso ideal LDR es infinito, circuito abierto, A0 es aproximadamente 5 voltios). Para valores intermedios de resistencia en la LDR, A0 tendrá valores intermedios. Código int lightPin = 0; // Pin LDR. int ledPin = 11; // Pin LED. int valor; // Variable para cálculos. int min = 988; // Valor minimo obtenido por A0.
int max = 1018; // Valor maximo obtenido por A0. void setup(){ Serial.begin(9600); // Inicializa el puerto serie. pinMode( ledPin, OUTPUT ); // ledPin como salida. } void loop(){ valor = analogRead(lightPin); // Leemos el valor de A0. Serial.print ("Valor de entrada: "); Serial.println(valor); // Valor de entrada de A0. valor = constrain(valor, min, max); // Normalizamos el valor. valor = map(valor, min, max, 0, 255); // Re-mapeamos. analogWrite(ledPin, valor); // Escribimos el valor. Serial.print ("Valor de salida: "); Serial.println(valor); // Valor de salida del LED delay(1000); }
El código anterior muestra por puerto serie los valores de entrada de A0. Usaremos estos valores para calibrar nuestro sensor LDR. Expondremos la LDR a las condiciones máximas y mínimas de iluminación a las que normalmente será expuesta. Estos valores serán definidos en las variables max y min.
Valores de entrada de A0 vistos desde el puerto serie. Una vez obtenidos los valores máximos y mínimos de A0 podremos sustituirlos en el siguiente código: int lightPin = 0; // Pin LDR. int ledPin = 11; // Pin LED. int valor; // Variable para cálculos. int min = 988; // Valor minimo obtenido por A0. int max = 1018; // Valor maximo obtenido por A0. void setup(){ Serial.begin(9600); // Inicializa el puerto serie. pinMode( ledPin, OUTPUT ); // ledPin como salida. } void loop(){ valor = analogRead(lightPin); // Leemos el valor de A0. Serial.print ("Valor de entrada: "); Serial.println(valor); // Valor de entrda de A0. valor = constrain(valor, min, max); // Normalizamos el valor. valor = map(valor, min, max, 0, 255); // Re-mapeamos. analogWrite(ledPin, valor); // Escribimos el valor. Serial.print ("Valor de salida: "); Serial.println(valor); // Valor de salida del LED. //delay(1000); // Descomentar para calibrado. }
Descripción del código constrain(valor, a, b);
Esta función normaliza valor a un rango [a,b]. Si valor es menor que a, el r esultado de la función será a, si valor es mayor que b, el resultado de la función es b. De esta forma trabajaremos siempre con el margen de valores establecidos por min y max.
map(valor, min, max, 0, 255);
Re-mapea un número desde un rango hacia otro. Esto significa que valor con respecto al rango min-max será mapeado al rango 0-255. Esta función es útil para hacer la variación de luminosidad del LED. A medida que el rango entre min y max sea mayor, mayor serán los valores intermedios de luminosidad del LED, mayor suavidad en los cambios.
