Monitor de temperatura e nível de luz com exibição no LCD NOKIA 5110: 4 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Olá pessoal!

Nesta seção, fazemos um dispositivo eletrônico simples para monitorar a temperatura e o nível de luz. As medições desses parâmetros são exibidas no LCD NOKIA 5110. O dispositivo é baseado no microcontrolador AVR ATMEGA328P. O dispositivo de monitoramento é equipado com termômetro digital DS18B20 e fotoresistor para medir o nível de luz.

Etapa 1: Descrição dos componentes

Componentes básicos do dispositivo de monitoramento:

• Microcontrolador AVR «ATMEGA328P»
• LCD gráfico monocromático «NOKIA 5110»
• Termômetro digital de 1 fio de resolução programável «DS18B20»
• Resistor dependente de luz
• Fios

Microcontrolador AVR «ATMEGA328P»

O dispositivo de monitoramento usa os seguintes recursos periféricos do microcontrolador:

1. Interrupção do temporizador / contador de 16 bits
2. ADC de 8 canais e 10 bits
3. Interface serial SPI mestre / escravo

LCD gráfico monocromático «NOKIA 5110»

Especificações:

1. Tela LCD de 48 x 84 pontos
2. Interface de barramento serial com alta velocidade máxima de 4 Mbits / S
3. Controlador / driver interno «PCD8544»
4. Retroiluminação LED
5. Funciona com tensão 2,7-5 volts
6. Baixo consumo de energia; é adequado para aplicações de bateria
7. Faixa de temperatura de -25˚C a + 70˚C
8. Entrada de sinal CMOS de suporte

Tratamento do endereço LCD (endereçamento):

O arranjo de endereço da memória que é mostrado no display LCD (DDRAM) é a matriz que consiste em 6 linhas (endereço Y) do endereço Y 0 ao endereço Y 5 e 84 colunas (endereço X) do endereço X 0 ao X- Endereço 83. Se o usuário deseja acessar a posição de exibição do resultado no visor LCD, deve consultar a relação entre o endereço X e o endereço Y.

Os dados que serão enviados ao display são de 8 bits (1 Byte) e serão organizados como uma linha vertical; neste caso, o Bit MSB será inferior e o Bit LSB será superior, conforme mostrado na figura.

Termômetro digital de resolução programável com 1 fio DALLAS «DS18B20»

Recursos:

1. Interface única de 1 fio® requer apenas um pino de porta para comunicação
2. Reduza a contagem de componentes com sensor de temperatura integrado e EEPROM
3. Mede temperaturas de -55 ° C a + 125 ° C (-67 ° F a + 257 ° F)
4. ± 0,5 ° C Precisão de -10 ° C a + 85 ° C
5. Resolução programável de 9 bits a 12 bits
6. Nenhum componente externo necessário
7. O modo de energia parasita requer apenas 2 pinos para operação (DQ e GND)
8. Simplifica as aplicações distribuídas de detecção de temperatura com capacidade multiponto
9. Cada dispositivo possui um código serial exclusivo de 64 bits armazenado na ROM on-board
10. Configurações flexíveis de alarme não volátil (NV) definidas pelo usuário com o comando de pesquisa de alarme identifica dispositivos com temperaturas fora dos limites programados

Formulários:

1. Controles termostáticos
2. Sistemas Industriais
3. Produtos de consumo
4. Termômetros
5. Sistemas termicamente sensíveis

Resistor dependente de luz

O Resistor Dependente de Luz (LDR) é um transdutor que muda sua resistência quando a luz incide em sua superfície.

Normalmente, um LDR terá de um megaOhms a dois megaOhms na escuridão total, de dez a vinte kiloOhms a dez LUX, de dois a cinco quiloohms a 100 LUX. A resistência entre os dois contatos do sensor diminui com a intensidade da luz ou a condutância entre os dois contatos do sensor aumenta.

Use o circuito divisor de tensão para converter a mudança na resistência em mudança na tensão.

Etapa 2: Código de firmware do microcontrolador

#ifndef F_CPU # define F_CPU 16000000UL // informando a frequência do cristal do controlador (16 MHz AVR ATMega328P) #endif

// INTERFACE SPI DEFINA # define MOSI 3 // MOSI é PORTA B, PIN 3 # define MISO 4 // MISO é PORTA B, PIN 4 # define SCK 5 // SCK é PORTA B, PIN 5 # define SS 2 // SS é PORTA B, PIN 2

// RESET O DISPLAY #define RST 0 // RESET é PORTA B, PIN 0

// DISPLAY MODE SELECT - Entrada para selecionar comando / endereço ou entrada de dados. # define DC 1 // DC é PORTA B, PIN 1

// array de códigos de signstatic negativo const unsigned char neg [4] = {0x30, 0x30, 0x30, 0x30};

// codes array of digits [0..9] static const unsigned char font6x8 [10] [16] = {{0xFC, 0xFE, 0xFE, 0x06, 0x06, 0xFE, 0xFE, 0xFC, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 0 {0x00, 0x00, 0x18, 0x1C, 0xFE, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00}, // 1 { 0x0C, 0x8E, 0xCE, 0xE6, 0xE6, 0xBE, 0x9E, 0x0C, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 2 {0x00, 0x04, 0x06, 0x26, 0x76, 0xFE, 0xDE, 0x8C, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 3 {0x3C, 0x3E, 0x7C, 0x60, 0x60, 0xFC, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01}, // 4 {0x1C, 0x3E, 0x3E, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 5 {0xFC, 0xFE, 0xFE, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 6 {0x04, 0x06, 0x06, 0x86, 0xE6, 0xFE, 0x7E, 0x1C, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00}, // 7 {0xCC, 0xFE, 0xFE, 0x36, 0x36, 0xFE, 0xFE, 0xCC, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x0 3, 0x01}, // 8 {0x3C, 0x7E, 0x7E, 0x66, 0x66, 0xFE, 0xFE, 0xFC, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01} // 9};

// codifica a matriz da palavra "TEMP:" static const unsigned char TEMP_1 [165] = {0x02, 0x06, 0x06, 0xFE, 0xFE, 0xFE, 0x06, 0x06, 0x02, 0x00, 0xFC, 0xFE, 0xFE, 0x26, 0x26, 0x24, 0x00, 0xFC, 0xFE, 0xFE, 0x1C, 0x38, 0x70, 0x38, 0x1C, 0xFE, 0xFE, 0xFC, 0x00, 0xFC, 0xFE, 0xFE, 0x66, 0x66, 0x7E, 0x7E, 0x3C, 0x00, 0x8C, 0x8C, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x0C, 0x1E, 0x33, 0x33, 0x1E, 0x0C, 0x00, 0xF8, 0xFC, 0x0C, 0x9C, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x01,};

// codifica a matriz da palavra "LUX:" const unsigned char TEMP_2 [60] = {0xFC, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFE, 0xFC, 0x00, 0x00, 0xFC, 0xFE, 0xFC, 0x00, 0x04, 0x8E, 0xDE, 0xFC, 0xF8, 0xFC, 0xDE, 0x8E, 0x04, 0x00, 0x8C, 0x8C, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x01};

#incluir

#include #include

// Inicialização da porta evita Port_Init () {DDRB = (1 << MOSI) | (1 << SCK) | (1 << SS) | (1 << RST) | (1 << DC); // Definir MOSI, SCK, SS, RST, DC como saída, todas as outras entradas PORTB | = (1 << RST); // Definir pino RST como alto PORTB | = (1 << SS); // Definir pino SS como alto - Display é Desative DDRC = 0xFFu; // Defina todos os pinos do PORTC como saída. DDRC & = ~ (1 << 0); // Faz o primeiro pino de PORTC como Entrada PORTC = 0x00u; // Defina todos os pinos de PORTC para baixo, o que o desliga. }

// Inicialização ADC void ADC_init () {// Habilitar ADC, amostragem freq = osc_freq / 128 definir prescaler para valor máximo, 128 ADCSRA | = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); ADMUX = (1 << REFS0); // Selecione a referência de tensão para o ADC // Selecione o canal zero por padrão usando o registro ADC Multiplexer Select (ADC0). }

// Função para ler o resultado da conversão de analógico para digital uint16_t get_LightLevel () {_delay_ms (10); // Aguarde algum tempo até que o canal seja selecionado ADCSRA | = (1 << ADSC); // Inicie a conversão ADC definindo o bit ADSC. escreva 1 para ADSC enquanto (ADCSRA & (1 << ADSC)); // espera que a conversão seja concluída // ADSC torna-se 0 novamente até então, execute o loop continuamente _delay_ms (10); retorno (ADC); // Retorna o resultado de 10 bits}

// SPI Initialization void SPI_Init () {SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0); // Habilitar SPI, definir como mestre, definir pré-escalador como Fosc / 16 no controle SPI registro }

// inicializa o Timer1 de 16 bits, interrupção e variável void TIMER1_init () {// configura o timer com prescaler = 256 e modo CTC TCCR1B | = (1 << WGM12) | (1 << CS12); // inicializa o contador TCNT1 = 0; // inicializa o valor de comparação - 1 s OCR1A = 62500; // habilita a interrupção de comparação TIMSK1 | = (1 << OCIE1A); // habilita interrupções globais sei (); }

// Exibir habilitar void SPI_SS_Enable () {PORTB & = ~ (1 << SS); // Habilite o pino SS para o lógico 0}

// Exibir Desabilitar void SPI_SS_Disable () {PORTB | = (1 << SS); // Desative o pino SS para lógica 1}

// Função para enviar dados para o buffer de exibição void SPI_Tranceiver (unsigned char data) {SPDR = data; // Carrega dados no buffer while (! (SPSR & (1 << SPIF))); // Espere até a transmissão terminar}

// Reinicia o display no início da inicialização void Display_Reset () {PORTB & = ~ (1 << RST); _delay_ms (100); PORTB | = (1 << RST); }

// Função de escrita do comando void Display_Cmnd (unsigned char data) {PORTB & = ~ (1 << DC); // torna o pino DC para o lógico 0 para operação de comando SPI_Tranceiver (dados); // envia dados no registro de dados PORTB | = (1 << DC); // torna o pino DC para a lógica alta para operação de dados}

// Inicialização do Display void Display_init () {Display_Reset (); // redefine o display Display_Cmnd (0x21); // comando definido no modo de adição Display_Cmnd (0xC0); // define a tensão enviando C0 significa VOP = 5V Display_Cmnd (0x07); // definir a temperatura. coeficiente para 3 Display_Cmnd (0x13); // definir o valor do sistema de polarização de tensão Display_Cmnd (0x20); // comando definido no modo básico Display_Cmnd (0x0C); // exibe o resultado no modo normal}

// Limpa a exibição void Display_Clear () {PORTB | = (1 << DC); // torna DC pin para lógica alta para operação de dados para (int k = 0; k <= 503; k ++) {SPI_Tranceiver (0x00);} PORTB & = ~ (1 << DC); // faz DC pin para lógica zero para operação de comando}

// define a coluna e linha para a posição de exibição do resultado no visor LCD void Display_SetXY (unsigned char x, unsigned char y) {Display_Cmnd (0x80 | x); // coluna (0-83) Display_Cmnd (0x40 | y); // linha (0-5)}

// Função para exibir o sinal negativo void Display_Neg (unsigned char neg) {Display_SetXY (41, 0); // Define o endereço da posição no display para (int index = 0; index0) {SPDR = 0x30;} // Carrega os dados no buffer do display (mostra o sinal negativo) else {SPDR = 0x00;} // Carrega os dados no o buffer de exibição (limpar o sinal negativo) enquanto (! (SPSR & (1 << SPIF))); // Espere até a transmissão terminar _delay_ms (100); }}

// Função para limpar o sinal digital void Off_Dig (unsigned char x, unsigned char y) {Display_SetXY (x, y); // Defina o endereço da posição no visor (linha superior) para (int índice = 0; índice <8; índice ++) {SPI_Tranceiver (0);} // Carregar dados no buffer do visor (limpar a parte superior do sinal digital) y ++; Display_SetXY (x, y); // Definir o endereço da posição no display (linha inferior) para (int índice = 0; índice <8; índice ++) {SPI_Tranceiver (0);} // Carregar dados no buffer do display (limpar a parte inferior do sinal digital)}

// Função para exibir o sinal digital void Display_Dig (int dig, unsigned char x, unsigned char y) {Display_SetXY (x, y); // Definir o endereço da posição no display (linha superior) para (int índice = 0; índice <16; índice ++) {if (índice == 8) {y ++; Display_SetXY (x, y);} // Define o endereço da posição no display (linha inferior) SPI_Tranceiver (font6x8 [dig] [índice]); // Carrega array de códigos de dados de dígitos no buffer de display _delay_ms (10); }}

// Inicialização do DS18B20 unsigned char DS18B20_init () {DDRD | = (1 << 2); // Define o pino PD2 do PORTD como saída PORTD & = ~ (1 << 2); // Defina o pino PD2 como baixo _delay_us (490); // Tempo de inicialização DDRD & = ~ (1 << 2); // Define o pino PD2 do PORTD como input _delay_us (68); // Tempo OK_Flag = (PIND & (1 << 2)); // obtém pulso do sensor _delay_us (422); return OK_Flag; // return 0-ok sensor is plug, 1-error sensor is unplug}

// Função para ler byte de DS18B20 unsigned char read_18b20 () {unsigned char i, data = 0; para (i = 0; i <8; i ++) {DDRD | = (1 << 2); // Define o pino PD2 do PORTD como output _delay_us (2); // Timing DDRD & = ~ (1 1; // Próximo bit if (PIND & (1 << 2)) data | = 0x80; // coloca o bit no byte _delay_us (62);} dados de retorno;}

// Função para escrever byte para DS18B20 void write_18b20 (unsigned char data) {unsigned char i; para (i = 0; i <8; i ++) {DDRD | = (1 << 2); // Define o pino PD2 do PORTD como output _delay_us (2); // Tempo se (dados & 0x01) DDRD & = ~ (1 << 2); // se quisermos escrever 1, libere a linha else DDRD | = (1 1; // Próximo bit _delay_us (62); // Timing DDRD & = ~ (1 << 2); // Defina o pino PD2 do PORTD como entrada _delay_us (2);}}

// Função para exibir o nível de luz void Read_Lux () {uint16_t buffer; sem sinal int temp_int_1, temp_int_2, temp_int_3, temp_int_0; // dígitos únicos, dígitos duplos, dígitos triplos, dígitos de um quarto buffer = get_LightLevel (); // lê o resultado do nível de luz de conversão de analógico para digital temp_int_0 = buffer% 10000/1000; // temp_int_1 de um quarto de dígito = buffer% 1000/100; // temp_int_2 de três dígitos = buffer% 100/10; // dois dígitos temp_int_3 = buffer% 10; // dígito único if (temp_int_0> 0) // se o resultado for um número de um quarto de dígito {Display_Dig (temp_int_0, 32, 2); // exibe 1 dígito do nível de luz Display_Dig (temp_int_1, 41, 2); // exibe 2 dígitos do nível de luz Display_Dig (temp_int_2, 50, 2); // exibe 3 dígitos do nível de luz Display_Dig (temp_int_3, 59, 2); // exibe 4 dígitos do nível de luz} else {if (temp_int_1> 0) // se o resultado é um número de três dígitos {Off_Dig (32, 2); // limpa 1 sinal de número Display_Dig (temp_int_1, 41, 2); // exibe 1 dígito do nível de luz Display_Dig (temp_int_2, 50, 2); // exibe 2 dígitos do nível de luz Display_Dig (temp_int_3, 59, 2); // exibe 3 dígitos do nível de luz} else {if (temp_int_2> 0) // se o resultado for um número de dois dígitos {Off_Dig (32, 2); // limpa 1 sinal do número Off_Dig (41, 2); // limpar 2 sinais de número Display_Dig (temp_int_2, 50, 2); // exibe 1 dígito do nível de luz Display_Dig (temp_int_3, 59, 2); // exibe 2 dígitos do nível de luz} else // se o resultado for um número de um dígito {Off_Dig (32, 2); // limpa 1 sinal do número Off_Dig (41, 2); // limpa o sinal 2 do número Off_Dig (50, 2); // limpar 3 sinais de número Display_Dig (temp_int_3, 59, 2); // exibe 1 dígito do nível de luz}}}}

// Função para exibir a temperatura void Read_Temp () {unsigned int buffer; sem sinal int temp_int_1, temp_int_2, temp_int_3; // dígitos únicos, dígitos duplos, dígitos triplos, dígitos sem sinal char Temp_H, Temp_L, OK_Flag, temp_flag; DS18B20_init (); // Inicialização do DS18B20 write_18b20 (0xCC); // Verificação do código do sensor write_18b20 (0x44); // Iniciar conversão de temperatura _delay_ms (1000); // Atraso na pesquisa do sensor DS18B20_init (); // Inicialização do DS18B20 write_18b20 (0xCC); // Verificação do código do sensor write_18b20 (0xBE); // Comando para ler o conteúdo do Sensor RAM Temp_L = read_18b20 (); // Lê os primeiros dois bytes Temp_H = read_18b20 (); temp_flag = 1; // temperatura 1-positiva, temperatura 0-negativa // Obtém temperatura negativa if (Temp_H & (1 << 3)) // Verificação do Bit de Sinal (se o bit está definido - temperatura negativa) {assinado int temp; temp_flag = 0; // sinalizador é definido como 0 - temperatura negativa temp = (Temp_H << 8) | Temp_L; temp = -temp; // Converta o código adicional em direto Temp_L = temp; Temp_H = temp >> 8; } buffer = ((Temp_H 4); temp_int_1 = buffer% 1000/100; // dígito triplo temp_int_2 = buffer% 100/10; // dígito duplo temp_int_3 = buffer% 10; // dígito único

// Se a temperatura for negativa, exibirá o sinal de temperatura, caso contrário, limpará

if (temp_flag == 0) {Display_Neg (1);} else {Display_Neg (0);} if (temp_int_1> 0) // se o resultado for um número de três dígitos {Display_Dig (temp_int_1, 45, 0); // exibe 1 dígito de temperatura Display_Dig (temp_int_2, 54, 0); // exibe 2 dígitos da temperatura Display_Dig (temp_int_3, 63, 0); // exibe 3 dígitos da temperatura} else {if (temp_int_2> 0) // se o resultado for um número de dois dígitos {Off_Dig (45, 0); // limpa 1 sinal de número Display_Dig (temp_int_2, 54, 0); // exibe 1 dígito de temperatura Display_Dig (temp_int_3, 63, 0); // exibe 2 dígitos de temperatura} else // se o resultado for um número de um dígito {Off_Dig (45, 0); // limpa 1 sinal do número Off_Dig (54, 0); // limpa 2 sinais de número Display_Dig (temp_int_3, 63, 0); // exibe 1 dígito de temperatura}}}

// Este ISR é disparado sempre que ocorre uma correspondência da contagem do cronômetro com o valor de comparação (a cada 1 segundo) ISR (TIMER1_COMPA_vect) {// Leitura, exibição de temperatura e nível de luz Read_Temp (); Read_Lux (); }

// Função para exibir as palavras "TEMP" e "LUX" void Display_label () {// Palavra "TEMP" Display_SetXY (0, 0); // Define o endereço da posição no display (linha acima) para (int index = 0; index <105; index ++) {if (index == 40) {Display_SetXY (0, 1);} // Define o endereço da posição no display (linha inferior) if (índice == 80) {Display_SetXY (72, 0);} // Define o endereço da posição no display (linha superior) if (índice == 92) {Display_SetXY (72, 1); } // Define o endereço da posição no display (linha inferior) SPDR = TEMP_1 [índice]; // Carrega os dados da matriz de códigos no buffer de exibição while (! (SPSR & (1 << SPIF))); // Espere até a transmissão terminar _delay_ms (10); } // Palavra "LUX" Display_SetXY (0, 2); // Define o endereço da posição no display (linha acima) para (int index = 0; index <60; index ++) {if (index == 30) {Display_SetXY (0, 3);} // Define o endereço da posição no display (linha inferior) SPDR = TEMP_2 [índice]; // Carrega os dados da matriz de códigos no buffer de exibição while (! (SPSR & (1 << SPIF))); // Espere até a transmissão terminar _delay_ms (10); }}

int main (vazio)

{Port_Init (); // Inicialização da porta ADC_init (); // Inicialização ADC SPI_Init (); // Inicialização SPI SPI_SS_Enable (); // Habilitar exibição DS18B20_init (); // Inicialização do DS18B20 Display_init (); // Exibir inicialização Display_Clear (); // Mostra clear Display_label (); // Mostra as palavras "TEMP" e "LUX" TIMER1_init (); // Inicialização Timer1. Comece a monitorar. Obtendo parâmetros a cada segundo. // Loop infinito enquanto (1) {}}

Etapa 3: Flashing Firmware to Microcontrolador

Carregando o arquivo HEX na memória flash do microcontrolador. Assista ao vídeo com uma descrição detalhada da gravação da memória flash do microcontrolador: Gravação da memória flash do microcontrolador…

Etapa 4: Montagem do circuito do dispositivo de monitoramento

Conecte os componentes de acordo com o diagrama esquemático.

Conecte a energia e está funcionando!