Requisitos:
1.Arduino con Atmega328p
2. LDR
3. Python 2.7 en tu máquina
4. Bibliotecas Python: Pyserial
Resumen:
¿Alguna vez te has preguntado qué tan útil es la función de brillo automático en los teléfonos? Puede cambiar rápidamente el brillo de la pantalla según la intensidad de la luz circundante.
En este proyecto intenté crear algo similar para cualquier PC o computadora portátil que ejecute Linux (preferiblemente Ubuntu 14.04).
Mi objetivo era mantenerlo accesible y simple tanto como fuera posible.
Entonces, para hacer su prototipo, usé LDR para medir la intensidad de la luz y un Arduino para comunicarme con mi máquina. En mi máquina utilicé un script en Python para comunicarme vía USB con Arduino y editar el archivo responsable del brillo de la pantalla.
Este proyecto cuesta alrededor de 300 rupias solo por el microcontrolador que se utiliza (no hace falta decir que es un prototipo). Tiene una utilidad muy alta, especialmente para usuarios de PC.
Para obtener información más detallada sobre cómo controlar el brillo usando el terminal, puedes consultar este enlace .
Y para referencias más detalladas sobre atmega328p, puede consultar la documentación de Atmega328p.
Descripción:
Cómo envío el código a Arduino:
f =
avr-gcc -g -mmcu=atmega328p -Wall -Os $(f).c -o $(f).elf
avr-objcopy -j .text -j .data -O ihex $(f).elf $(f).hex
sudo avrdude -F -V -c arduino -p m328p -P /dev/ttyUSB* -b 57600 -e -U flash:w:$(f).hex
Simplemente escribe estos cuatro comandos, en el mismo orden, en tu terminal y recuerda poner el nombre del archivo de código fuente en la variable “f”. Estos comandos son sólo para usuarios de Linux.
El primer comando almacena el nombre del archivo en la variable "f", el segundo comando se usa para convertir el código fuente a un archivo .elf, el tercer comando se usa para convertir este archivo .elf a un archivo .hex que se puede cargar a atmega328p, y el cuarto comando se usa para cargar este archivo .hex.
Un poco sobre el uso del LDR
LDR significa Resistencia Dependiente de la Luz. Su resistencia tiene una relación inversa con la intensidad de la luz. Generalmente tiene una resistencia muy alta, alrededor de 1000 Kohms, pero cuando la luz incide sobre él, disminuye drásticamente en unos pocos cientos de ohmios. El LDR es un dispositivo económico que se puede utilizar en muchas de nuestras aplicaciones diarias.
Explicación del código fuente
Este programa es una aplicación de comunicación serie y ADC.
Antes de leer este artículo, consulte la explicación sobre ADC aquí.
Hice algunos cambios en la función setup_adc y el bloque ISR.
En la función setup_adc configuro el bit MUX1 en el registro ADMUX para comenzar a convertir el valor a PORTC2.
En el bloque ISR, primero almacené el valor de 10 bits del ADC en una variable (ldrValue). Luego, usando declaraciones condicionales, asigne "ldrValue" a tres niveles de brillo:
El. brillo_mínimo = 500
B. brillo_promedio = 2500
w. brillo_máximo = 4880
*Es posible que tengas que cambiarlos según tu máquina.
Utilicé uartLibrary.h para enviar el valor de brillo y el valor ldr a mi computadora portátil mediante comunicación en serie. Construí esta biblioteca consultando este artículo. Después de incluir esta biblioteca, puedo usar la función printf de stdio.h para enviar cadenas desde atmega328p a mi computadora portátil.
Puse todos los archivos de código en una carpeta .zip.
Para obtener información detallada, consulte el código fuente, que está muy bien documentado.
Explicación del script Python
Estoy usando bibliotecas pyserial para la comunicación en serie, están disponibles gratuitamente.
El script de Python necesita permiso de root para ejecutarse correctamente; de lo contrario, mostrará un mensaje de error y saldrá.
Después de obtener el permiso de root, crea un objeto "ser" de clase "Serial" y toma dos argumentos en él:
El. Puerto serie: En mi caso es '/dev/ttyUSB0'
B. Velocidad de transmisión: en mi caso es 9600
Luego define la ruta del archivo en una variable (ruta).
*Es posible que tengas que editarlos según tu máquina.
Entonces, en un bucle infinito puse un bloque try & except solo para ocuparme de los valores iniciales basura.
En el bloque try, una variable (valor) almacena la lista de dos cadenas, una es el valor de brillo y la otra es el valor LDR.
Después de eso, abre el archivo proporcionado en la variable "ruta" en modo de grabación y escribe en él el valor de brillo. Luego guarda y cierra el archivo.
Y para fines de depuración, imprime la lista con brillo y valor LDR.
Para más información, también puedes consultar este enlace cambiando el brillo a través del terminal.
Fig. 1: Imagen típica de Arduino Uno utilizada para el control automático del brillo de la pantalla LED
Figura 2: Imagen típica de Arduino Uno
Código fuente del proyecto
###
////////////////////////////////////////////////// ////////////////////////////////////////////////// //////////////////////////////////
// Varun13169 //
////////////////////////////////////////////////// ////////////////////////////////////////////////// //////////////////////////////////
#definir F_CPU 16000000UL
#incluir "uartLibrary.h"
#incluir
#incluir
#incluir
#incluir
/****************** Límites **************/
#definir bajo_min 0
#definir bajo_max 10
#definir mid_min 10
#definir mid_max 30
#definir alto_min 30
#definir brillo_mínimo 500
#definir brillo_medio 2500
#definir brillo_máximo 4880
/*********************************************/
/*
Es posible que tengas que cambiar estos límites
según su máquina Linux y LDR
*/
int ldrValue=0;
vacío setup_adc;
int principal (vacío)
{
uart_init;
salida estándar = &uart_output;
stdin = &uart_input;
DDRC = 0x0A; // Establece Pin5 y Pin7 en Arduino como salida
PUERTO = 1<
saber ; // Habilita la interrupción global
configuración_adc; // Configurar ADC según la función definida
mientras(1)
{
}
}
vacío setup_adc
{
ADCSRA = 1<
ADCSRA = 1<
ADCSRA = 1<
ADMUX = 1<
//ADLAR=1 para resultado ajustado a la izquierda y REFS0=1 con REFS1=0 para usar Vcc como voltaje de referencia
//MUX1=1 porque queremos iniciar la conversión desde PORTC2
DIDR0 = 1<
}
/*************varun13169 **************/
/********************************************* Bloque ISR *** *******************************/
ISR(ADC_vector)
{
uint8_t adcl = ADCL; //Esta es una variable de 8 bits utilizada para almacenar el valor de ADLC
uint16_t adc_ten_bit_value = ADCH<<2 adcl>>6; //Esta es una variable de 16 bits que se usa para almacenar el valor de 10 bits del resultado ajustado a la izquierda
ldrValue=adc_ten_bit_value;
if(low_min<=valorldr && valorldr
if(mid_min<=valorldr && valorldr
if(ldrValue>=high_min){printf("%d %dn", máximo_brillo, ldrValue);} // a mi computadora portátil
ADCSRA = 1<
}
/*************************************************** ************************************************** /
/*************************************************** ********** FIN *************************************** ****************************/
###
Diagramas de circuito
| Diagrama de circuito-Controlador-de-brillo-monitor-LED-automático-basado-Arduino-Uno |  |
