Brilho de tela adaptável usando script LDR e Python

Requisitos:

1. Arduino com Atmega328p

2. LDR

3. Python 2.7 em sua máquina

4. Bibliotecas Python: Pyserial

Resumo:

Já se perguntou quão útil é o recurso de brilho automático nos telefones? Pode alterar rapidamente o brilho da tela de acordo com a intensidade da luz circundante.

Neste projeto tentei criar algo semelhante para qualquer PC ou Laptop rodando Linux (de preferência Ubuntu 14.04).

Meu objetivo era mantê-lo acessível e simples, tanto quanto possível.

Então para fazer seu protótipo, usei LDR para medir a intensidade da luz e um Arduino para me comunicar com minha máquina. Na minha máquina utilizei um script python para me comunicar via USB com o Arduino e para editar o arquivo responsável pelo brilho da tela.

Este projeto custa cerca de Rs 300 apenas por causa do microcontrolador que está sendo usado (nem é preciso dizer que é um protótipo). Tem uma utilidade muito elevada, especialmente para usuários de PC.

Para obter informações mais detalhadas sobre como controlar o brilho usando o terminal, você pode conferir isto link.

E para obter referências mais detalhadas sobre o atmega328p você pode verificar a documentação do Atmega328p.

Descrição:

Como estou enviando o código no 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

Basta digitar esses quatro comandos, na mesma ordem, em seu terminal e lembrar de colocar o nome do arquivo do código-fonte na variável “f”. Esses comandos são apenas para usuários do Linux.

O primeiro comando armazena o nome do arquivo na variável “f”, o segundo comando é usado para converter o código-fonte em um arquivo .elf, o terceiro comando é usado para converter esse arquivo .elf em um arquivo .hex que pode ser carregado em atmega328p, e o quarto comando é usado para fazer upload desse arquivo .hex.

Um pouco sobre o LDR que está sendo usado

LDR significa Resistor Dependente de Luz. Sua resistência tem relação inversa com a intensidade luminosa. Geralmente, tem uma resistência muito alta, algo em torno de 1000 Kohms, mas quando a luz incide sobre ele, diminui drasticamente em algumas centenas de ohms. O LDR é um dispositivo barato que pode ser usado em muitas de nossas aplicações diárias.

Explicação do código-fonte

Este programa é uma aplicação de ADC e comunicação serial.

Antes de ler este artigo, confira a explicação sobre o ADC aqui.

Fiz algumas alterações na função setup_adc e no bloco ISR .

Na função setup_adc configurei o bit MUX1 no registrador ADMUX para iniciar a conversão do valor em PORTC2.

No bloco ISR , primeiro armazenei o valor de 10 bits do ADC em uma variável (ldrValue). Em seguida, usando declarações condicionais, mapeei “ldrValue” para três níveis de brilho:

a. brilho_mínimo = 500

b. brilho_médio = 2500

c. brilho_máximo = 4880

*Pode ser necessário alterá-los de acordo com sua máquina.

Usei uartLibrary.h para enviar o valor de brilho e o valor ldr para meu laptop usando comunicação serial. Eu construí esta biblioteca referindo-me a este artigo. Depois de incluir esta biblioteca, posso usar a função printf de stdio.h para enviar strings de atmega328p para meu laptop.

Coloquei todos os arquivos de código em uma pasta .zip

Para informações detalhadas, verifique o código-fonte, que está muito bem documentado.

Explicação do script Python

Estou usando bibliotecas pyserial para comunicação serial, estão disponíveis gratuitamente.

O script Python precisa de permissão de root para ser executado corretamente; caso contrário, ele exibirá uma mensagem de erro e sairá.

Depois de obter a permissão de root, ele cria um objeto “ser” da classe “Serial” e recebe dois argumentos nele:

a. Porta serial: No meu caso é '/dev/ttyUSB0'

b. Taxa de transmissão: No meu caso é 9600

Em seguida, define o caminho do arquivo em uma variável (path).

*Pode ser necessário editá-los de acordo com sua máquina.

Então, em um loop infinito, coloquei um bloco try & except apenas para cuidar dos valores iniciais de lixo.

No bloco try, uma variável (valor) armazena a lista de duas strings, uma é o valor do brilho e a outra é o valor LDR.

Depois disso ele abre o arquivo fornecido na variável “path” no modo de gravação e escreve nele o valor do brilho. Em seguida, ele salva e fecha o arquivo.

E para fins de depuração, imprime a lista com brilho e valor LDR.

Para mais informações, você também pode conferir este link alterando o brilho através do terminal.

Fig. 1: Imagem típica do Arduino Uno usada para controle automático de brilho do monitor LED

Figura 2: Imagem típica do Arduino Uno

Código fonte do projeto

###
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                          Varun13169                                                                //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
#define F_CPU           16000000UL
#include "uartLibrary.h"
#include 
#include 
#include 
#include 
 
 
/****************** Limits **************/
#define low_min 0
#define low_max 10
 
#define mid_min 10
#define mid_max 30
 
#define high_min 30
 
#define minimum_brightness 500
#define medium_brightness 2500
#define maximum_brightness 4880
/****************************************/
/*
 You might need to change these limits
 according to your Linux machine and LDR
*/
 
 
int ldrValue=0;
void setup_adc ;
 
int main(void)
{ 
    uart_init ;
    stdout = &uart_output;
    stdin  = &uart_input;
   
    DDRC  = 0x0A;                  // Set Pin5 and Pin7 on arduino as output
    PORTC = 1<
   
    sei ;                        // Enales global interrupt
    setup_adc ;            // Setup ADC according to the defined function
             
    while(1)
    {
    }
}
 
 
 
void setup_adc 
{
    ADCSRA  = 1<
    ADCSRA  = 1<
    ADCSRA  =  1<
    ADMUX  = 1<
    //ADLAR=1 for left adjusted result and REFS0=1 with REFS1=0 to use Vcc as reference voltage
    //MUX1=1 because we want to start conversion from PORTC2
    DIDR0  = 1<
}
 
 
/*********** varun13169 **************/
 
 
/******************************************** ISR Block ********************************************/
ISR(ADC_vect)
{
    uint8_t adcl = ADCL;                                  //This is an 8-bit varible used to store the value of ADLC
    uint16_t adc_ten_bit_value = ADCH<<2   adcl>>6;  //This is an 16-bit varible use to store the 10-bit value of left adjusted result
   
    ldrValue=adc_ten_bit_value;
   
    if(low_min<=ldrValue && ldrValue
    if(mid_min<=ldrValue && ldrValue
    if(ldrValue>=high_min){printf("%d %dn", maximum_brightness, ldrValue);}                    // to my laptop
 
    ADCSRA  = 1<
}
/***************************************************************************************************/
 
 
/*********************************************************** END *******************************************************************/
###
 

Diagramas de circuito

Diagrama de circuito-Arduino-Uno-Based-Automatic-LED-Monitor-Brightness-Controller

Vídeo do projeto