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.*/

const int led =3; // led conectado al pin 3

const int pot =0; // el pot esta conectado al pin A0

int brillo; //variable para el brillo

void setup () {
pinMode (led, 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 analog Write */
brillo = analogRead (pot) / 4;
/*analogWrite recibe dos valores,el pin a usar y la intensidad del voltaje
los valores de voltaje van de 0 a 255*/
analogWrite(led, brillo);
}

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, por ejemplo, controlar la intensidad de un LED.

Para solucionar el problema anteriormente planteado es que se usan los pines que pueden enviar señales con modulación por

ancho de pulso 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 larga) a la salida que 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 Programa de prueba para el control de la intensidad de un LED por medio de señales PWM.
3 Se hace parpadear el LED cambiando su intensidad de forma oscilatoria.
4
5 Autor: Arduino UTFSM
6 Fecha: 20 de Mayo 2014
7
8 Materiales utilizados:
9 1 Arduino UNO Rev3
10 1 LED de color azul conectado a salida PWM 9
11 1 Resistencia de 220[ohm]
12 2 Cables de conexión
13 */
14
15 /*------Declaración de variables-----*/
16 int led = 9; //Se escoje la variable donde se conectará el LED
17 int i;//Variable auxiliar para condicionales
18
19 void setup() {
20 pinMode(led, OUTPUT);//Se inicializa como OUTPUT el pin a usar. Debe ser PWM
21 }
22
23 void loop() {
24 //Se recorren los valores desde el 0 al 255 para enviar una señal PWM con ciclo de trabajo de 0% a 100%
25 //aumentando en 2.55% el ciclo de trabajo cada 10 mili segundos.
26 for(i=0; i<256; i++){
27 analogWrite(led,i);
28 delay(10);
29 }
30 //Se recorren los valores del 255 al 0 de mayor a menor igual que el for anterior.
31 for(i=255; i>-1; i--){
32 analogWrite(led,i);
33 delay(10);
34 }
35 }

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 funciones:
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 3 LED
10 3 Resistencias de 220[ohm]
11 Cables para conexion
12
13 Autor: Arduino UTFSM
14 Fecha: 20 - Mayo - 2014
15
16 */
17
18 /*-----Declaracion de variables-----*/
19 //Variable para controlad LED a controlar
20 int led[3] = {9,10,11}; //Deben ser PWM
21 int i,j; //Variables auxiliares para ciclos repetitivos
22 int repeat = 10; //Variable para controlar repeticion de funcion
23
24 void setup() {
25 // Se inicializan los 3 pines PWM a utilizar como salida
26 for(i=0; i<3; i++)
27 pinMode(led[i], OUTPUT);
28 }
29
30 void loop() {
31
32 wave(repeat);
33 randomLed(repeat);
34
35 }
36
37 void wave(int repeat){
38 for(j=0; j<repeat; j++){ //Se repite la secuencia segun variable repeat
39 for(i=0; i<256; i++){
40 //Se aumenta el primer LED de 0 a 255
41 analogWrite(led[0],i);
42 }
43 for(i=255; i>-1; i--){
44 //Se disminuye el primer LED de 255 a 0
45 //Se aumenta el segundo LED de 0 a 255
46 analogWrite(led[0],i);
47 analogWrite(led[1],255-i);
48 }
49 for(i=0; i<256; i++){
50 //Se disminuye el segundo LED de 255 a 0
51 //Se aumenta el tercer LED de 0 a 255
52 analogWrite(led[1],255-i);
53 analogWrite(led[2],i);
54 }
55 for(i=255; i>-1; i--){
56 //Se disminuye el tercer LED de 255 a 0
57 analogWrite(led[2],i);
58 }
59 //Se realiza el ciclo inverso al anterior
60 for(i=0; i<256; i++){
61 analogWrite(led[2],i);
62 }
63 for(i=255; i>-1; i--){
64 analogWrite(led[2],i);
65 analogWrite(led[1],255-i);
66 }
67 for(i=0; i<256; i++){
68 analogWrite(led[1],255-i);
69 analogWrite(led[0],i);
70 }
71 for(i=255; i>-1; i--){
72 analogWrite(led[0],i);
73 }
74 }
75 }
76
77 void randomLed(int repeat){
78 for(i=0; i<repeat; i++){
79 //Se elige de forma aleatorioa la intensidad de cada LED
80 //Se escoje un retardo entre cada LED aleatoriamente
81 analogWrite(led[0],random(0,256));
82 delay(random(0,501));
83 analogWrite(led[1],random(0,256));
84 delay(random(0,501));
85 analogWrite(led[2],random(0,256));
86 delay(random(0,501));
87 }
88 }

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.

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. Control de intensidad de un LED
4. ---------------------------------------------
5. */
6.
7. //------------------------------------
8. //Funcion principal
9. //------------------------------------
10. void setup() // Se ejecuta cada vez que el Arduino se inicia
11. {
12. Serial.begin(9600); //Inicia comunicacion
13. pinMode(9,OUTPUT); //Configurar el pin 9 como salida
14. }
15.
16. //------------------------------------
17. //Funcion ciclicla
18. //------------------------------------
19. void loop() // Esta funcion se mantiene ejecutando
20. { // cuando se da energia al Arduino
21.
22. //Variable del valor de la lectura analoga de la mini fotocelda
23. int foto = analogRead(A0);
24.
25. //Verifica el valor máximo y se realiza una conversion
26. int conversion = 780 - 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("Foto : ");
34. Serial.print(foto);
35. Serial.println("");
36.
37. //Se Imprimen los datos del valor de la conversion
38. Serial.print("Conv : ");
39. Serial.print(conversion);
40. Serial.println("");
41.
42. //Escritura análoga de PWM en el LED de acuerdo a la conversion
43. analogWrite(9, conversion);
44.
45. delay(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 analogInPin = A0; // Entrada analogica A0 del potenciometro
const int analogOutPin = 3; // Salida PWM

int potValor = 0; // valor de lectura del potenciometro

int outputValor = 0; // valor de salida de la señal PWM

void setup() {
// inicializacion del monitor serie a 9600 bps:
Serial.begin(9600);
}

void loop() {
// lee el valor de la entrada analogica:
potValor = analogRead(analogInPin);
// mapea el rango para la señal de salida PWM:
 outputValor = map(potValor, 0, 1023, 0, 255);
// asigna el valor cambiado a pin 3 PWM:
analogWrite(analogOutPin, outputValor);

// escribe el resultado en el monitor serie:

Serial.print("Potenciometro = " );
Serial.print(potValor);
Serial.print("\t PWM = ");
Serial.println(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);
}

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() para darle
los valores PWM al led e iluminarlo así de acuerdo a los valores
del 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 podemos darle
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
rangos.
A esta función map() le tenemos 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. 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 = 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 = 0; // variable para guardar el valor leido del sensor

void setup() {
// Incializa el pin del boton como entrada
pinMode(pinSensor, INPUT);
// Incializa el pin del led como salida, aunque no es necesario
pinMode(pinLed, OUTPUT);
// Inicializa la comunicacion serial
Serial.begin(9600);
}

void loop(){
// Lee el valor del sensor
valorPotenciometro = analogRead(pinSensor);
// Transforma este valor en el valor que usaremos para el led
// Para ello usaremos la funcion map()
brilloLed = map(valorPotenciometro, 0, 1023, 0, 255);
// Utilizamos este valor para iluminar el led
analogWrite(pinLed, brilloLed);

// manda los valores por el serial

Serial.print("Valor del Potenciometro = ");
Serial.print(valorPotenciometro);
Serial.print(" Brillo del Led = ");
Serial.println(brilloLed);

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 resultado 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.