Moniteur de température et de niveau de luminosité avec affichage sur LCD NOKIA 5110 : 4 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Bonjour à tous!

Dans cette section, nous fabriquons un dispositif électronique simple pour surveiller la température et le niveau de lumière. Les mesures de ces paramètres sont affichées sur le LCD NOKIA 5110. L'appareil est basé sur le microcontrôleur AVR ATMEGA328P. Le dispositif de surveillance est équipé d'un thermomètre numérique DS18B20 et d'une photorésistance pour mesurer le niveau de lumière.

Étape 1: Description des composants

Composants de base du dispositif de surveillance:

• Microcontrôleur AVR « ATMEGA328P »
• LCD graphique monochrome «NOKIA 5110»
• Thermomètre numérique à 1 fil à résolution programmable « DS18B20 »
• Résistance dépendante de la lumière
• Fils

Microcontrôleur AVR « ATMEGA328P »

Le dispositif de surveillance utilise les fonctionnalités périphériques suivantes du microcontrôleur:

1. Interruption du temporisateur/compteur 16 bits
2. CAN 10 bits à 8 canaux
3. Interface série SPI maître/esclave

LCD graphique monochrome «NOKIA 5110»

Caractéristiques:

1. Écran LCD 48 x 84 points
2. Interface de bus série avec une vitesse maximale de 4 Mbits/s
3. Contrôleur/pilote interne « PCD8544 »
4. Rétro-éclairage LED
5. Fonctionne à une tension de 2,7 à 5 volts
6. Basse consommation énergétique; il convient aux applications de batterie
7. Plage de température de -25˚C à +70˚C
8. Prise en charge de l'entrée CMOS du signal

Gestion de l'adresse LCD (adressage):

L'agencement des adresses de la mémoire qui est affiché sur l'écran LCD (DDRAM) est une matrice qui se compose de 6 lignes (adresse Y) de l'adresse Y 0 à l'adresse Y 5 et 84 colonnes (adresse X) de l'adresse X 0 à X- Adresse 83. Si l'utilisateur souhaite accéder à la position d'affichage du résultat sur l'écran LCD, il doit se référer à la relation entre l'adresse X et l'adresse Y.

Les données qui seront envoyées à l'affichage sont de 8 bits (1 octet) et seront disposées sous forme de ligne verticale; dans ce cas, le Bit MSB sera inférieur et le Bit LSB sera supérieur comme indiqué dans l'image.

Thermomètre numérique à 1 fil à résolution programmable DALLAS « DS18B20 »

Caractéristiques:

1. L'interface unique 1-Wire® ne nécessite qu'une seule broche de port pour la communication
2. Réduisez le nombre de composants avec le capteur de température intégré et l'EEPROM
3. Mesure des températures de -55°C à +125°C (-67°F à +257°F)
4. ±0,5°C Précision de -10°C à +85°C
5. Résolution programmable de 9 bits à 12 bits
6. Aucun composant externe requis
7. Le mode d'alimentation parasite ne nécessite que 2 broches pour le fonctionnement (DQ et GND)
8. Simplifie les applications de détection de température distribuées avec une capacité multipoints
9. Chaque appareil a un code série unique de 64 bits stocké dans la ROM intégrée
10. Les paramètres d'alarme non volatiles (NV) flexibles définissables par l'utilisateur avec la commande de recherche d'alarme identifie les appareils avec des températures en dehors des limites programmées

Applications:

1. Commandes thermostatiques
2. Systèmes industriels
3. Les produits de consommation
4. Thermomètres
5. Systèmes thermiquement sensibles

Résistance dépendante de la lumière

La résistance dépendante de la lumière (LDR) est un transducteur qui change sa résistance lorsque la lumière tombe sur sa surface change.

Typiquement, un LDR aura d'un mégaOhm à deux mégaOhms dans l'obscurité totale, de dix à vingt kiloOhms à dix LUX, de deux à cinq kiloohms à 100 LUX. La résistance entre les deux contacts du capteur diminue avec l'intensité lumineuse ou la conductance entre deux contacts du capteur augmente.

Utilisez un circuit diviseur de tension pour convertir le changement de résistance en changement de tension.

Étape 2: Code du micrologiciel du microcontrôleur

#ifndef F_CPU#define F_CPU 16000000UL // indiquant la fréquence du cristal du contrôleur (16 MHz AVR ATMega328P) #endif

// INTERFACE SPI DEFINE #define MOSI 3 // MOSI c'est PORT B, PIN 3 #define MISO 4 // MISO c'est PORT B, PIN 4 #define SCK 5 // SCK c'est PORT B, PIN 5 #define SS 2 // SS c'est PORT B, PIN 2

// RESET L'AFFICHAGE #define RST 0 // RESET c'est PORT B, PIN 0

//SÉLECTION DU MODE D'AFFICHAGE - Entrée pour sélectionner la commande/l'adresse ou l'entrée de données. #define DC 1 // DC c'est PORT B, PIN 1

// code un tableau de signe statique const unsigned char neg[4] = {0x30, 0x30, 0x30, 0x30};

// code tableau de chiffres [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, 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, 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, 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, 0x01} // 9 };

// tableau de codes du mot "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, 0x0x8, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x01, 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, 0x0, 0xF8 0x9C, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x01, };

// tableau de codes du mot "LUX:" const unsigned char TEMP_2[60] = { 0xFC, 0xFE, 0xFC, 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, 0x 001, 0, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x01 };

#comprendre

#include #include

// Initialisation du port void Port_Init() { DDRB = (1<<MOSI)|(1<<SCK)|(1<<SS)|(1<<RST)|(1<<DC);// Définir MOSI, SCK, SS, RST, DC en sortie, toutes les autres entrées PORTB |= (1<<RST); // Définir la broche RST comme haute PORTB |= (1<<SS); // Définir la broche SS comme haute - L'affichage est Désactiver DDRC=0xFFu; // Définit toutes les broches du PORTC comme sortie. DDRC &= ~(1<<0);//Fait la première broche de PORTC comme entrée PORTC=0x00u; // Définit toutes les broches de PORTC à un niveau bas, ce qui le désactive. }

// Initialisation de l'ADC void ADC_init() { // Activer l'ADC, l'échantillonnage freq=osc_freq/128 définir le pré-échelonneur sur la valeur maximale, 128 ADCSRA |= (1<<ADEN) | (1<<ADPS2)| (1<<ADPS1)| (1<<ADPS0); ADMUX = (1<<REFS0); // Sélectionnez la référence de tension pour l'ADC // Sélectionnez la voie zéro par défaut à l'aide du registre de sélection du multiplexeur ADC (ADC0). }

// Fonction pour lire le résultat de la conversion analogique-numérique uint16_t get_LightLevel() { _delay_ms(10); // Attendez un certain temps pour que le canal soit sélectionné ADCSRA |= (1<<ADSC); // Démarrez la conversion ADC en définissant le bit ADSC. écrire 1 dans ADSC while(ADCSRA & (1<<ADSC)); // attend la fin de la conversion // ADSC redevient 0 jusque-là, exécute la boucle en continu _delay_ms(10); retour (ADC); // Retourne le résultat 10 bits }

// Initialisation SPI void SPI_Init() { SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);//Activer SPI, Définir comme maître, Définir le pré-échelonneur comme Fosc/16 dans le contrôle SPI S'inscrire }

// initialiser 16 bits Timer1, interruption et variable void TIMER1_init() { // configurer le timer avec prescaler = 256 et le mode CTC TCCR1B |= (1 << WGM12)|(1 << CS12); // initialise le compteur TCNT1 = 0; // initialise la valeur de comparaison - 1 sec OCR1A = 62500; // active l'interruption de comparaison TIMSK1 |= (1 << OCIE1A); // activer les interruptions globales sei(); }

//Afficher Activer void SPI_SS_Enable() { PORTB &= ~(1<<SS); // Activer la broche SS au 0 logique }

//Afficher Désactiver void SPI_SS_Disable() { PORTB |= (1<<SS); // Désactive la broche SS sur la logique 1 }

//Fonction pour envoyer des données dans le tampon d'affichage void SPI_Tranceiver (données de caractère non signées) { SPDR = data; //Charge les données dans le tampon while(!(SPSR & (1<<SPIF))); //Attendez la fin de la transmission }

// Réinitialise l'affichage au début de l'initialisation void Display_Reset() { PORTB &= ~(1<<RST); _delay_ms(100); PORTB |= (1<<RST); }

//Command write function void Display_Cmnd (données de caractères non signées) { PORTB &= ~(1<<DC); // faire passer la broche DC à la logique 0 pour l'opération de commande SPI_Tranceiver(data); // envoie des données sur le registre de données PORTB |= (1<<DC); // faire passer la broche DC au niveau logique haut pour l'opération de données }

//Initialisation de l'affichage void Display_init() { Display_Reset(); // réinitialiser l'affichage Display_Cmnd(0x21); // commande définie en mode supplémentaire Display_Cmnd(0xC0); // régler la tension en envoyant C0 signifie VOP = 5V Display_Cmnd (0x07); // définit la température. coefficient à 3 Display_Cmnd(0x13); // définir la valeur de Voltage Bias System Display_Cmnd (0x20); // commande définie en mode de base Display_Cmnd(0x0C); // affiche le résultat en mode normal }

// Efface l'affichage void Display_Clear() { PORTB |= (1<<DC); // rend la broche DC à l'état logique haut pour l'opération de données pour (int k=0; k<=503; k++){SPI_Tranceiver(0x00);} PORTB &= ~(1<<DC);// rend la broche DC à la logique zéro pour l'opération de commande }

// définit la colonne et la ligne sur la position d'affichage du résultat sur l'écran LCD void Display_SetXY(unsigned char x, unsigned char y) { Display_Cmnd(0x80|x); // colonne (0-83) Display_Cmnd(0x40|y); // ligne (0-5) }

// Fonction pour afficher le signe négatif void Display_Neg(unsigned char neg) { Display_SetXY(41, 0); // Définit l'adresse de position sur l'affichage pour (int index=0; index0) {SPDR = 0x30;} //Charge les données dans le tampon d'affichage (affiche le signe négatif) else {SPDR = 0x00;} //Charge les données dans le buffer d'affichage (effacer le signe négatif) while(!(SPSR & (1<<SPIF))); //Attendez la fin de la transmission _delay_ms(100); } }

// Fonction pour effacer le signe numérique void Off_Dig(unsigned char x, unsigned char y) { Display_SetXY(x, y); // Définir l'adresse de position sur l'affichage (ligne du haut) pour (int index=0; index<8; index++) {SPI_Tranceiver(0);} //Charger les données dans le tampon d'affichage (effacer la partie supérieure du signe numérique) y++; Display_SetXY(x, y);// Définit l'adresse de position sur l'affichage (ligne du bas) pour (int index=0; index<8; index++) {SPI_Tranceiver(0);}// Charge les données dans le tampon d'affichage (effacer la partie inférieure du panneau numérique) }

// Fonction pour afficher le signe numérique void Display_Dig(int dig, unsigned char x, unsigned char y) { Display_SetXY(x, y); // Définit l'adresse de la position sur l'affichage (ligne du haut) pour (int index=0; index <16; index++) { if (index==8){y++;Display_SetXY(x, y);} // Définit l'adresse de la position sur l'affichage (ligne du bas) SPI_Tranceiver(font6x8[dig][index]); // Charge le tableau de codes de données de chiffres dans le tampon d'affichage _delay_ms(10); } }

// Initialisation du char non signé DS18B20 DS18B20_init() { DDRD |= (1 << 2); // Définir la broche PD2 du PORTD comme sortie PORTD &= ~(1 << 2); // Définir la broche PD2 comme faible _delay_us (490); // Délai d'initialisation DDRD &= ~(1 << 2); // Définir la broche PD2 du PORTD comme entrée _delay_us (68); // Timing OK_Flag = (PIND & (1 << 2)); // obtient l'impulsion du capteur _delay_us(422); renvoie OK_Flag; // retourne le capteur 0-ok est branché, le capteur 1-error est débranché }

// Fonction pour lire l'octet de DS18B20 unsigned char read_18b20() { unsigned char i, data = 0; for(i = 0; i < 8; i++) { DDRD |= (1 << 2); // Définir la broche PD2 du PORTD comme sortie _delay_us(2); // Timing DDRD &= ~(1 1; // Bit suivant if(PIND & (1 << 2)) data |= 0x80; // met le bit dans l'octet _delay_us(62); } renvoie les données; }

// Fonction pour écrire l'octet dans DS18B20 void write_18b20 (données de caractère non signé) { caractère non signé i; for(i = 0; i < 8; i++) { DDRD |= (1 << 2); // Définir la broche PD2 du PORTD comme sortie _delay_us(2); // Timing if(data & 0x01) DDRD &= ~(1 << 2); //si on veut écrire 1, relâcher la ligne else DDRD |= (1 1; // Next bit _delay_us(62); // Timing DDRD &= ~(1 << 2); // Définir la broche PD2 du PORTD en entrée _delay_us(2); } }

// Fonction pour afficher le niveau de lumière void Read_Lux() { uint16_t buffer; int non signé temp_int_1, temp_int_2, temp_int_3, temp_int_0; // chiffres simples, chiffres doubles, chiffres triples, chiffres quarts buffer = get_LightLevel(); // lit le résultat de la conversion analogique-numérique du niveau de luminosité temp_int_0 = buffer % 10000 / 1000; // quart de chiffre temp_int_1 = buffer % 1000 / 100; // temp_int_2 à trois chiffres = buffer % 100 / 10; // temp_int_3 à deux chiffres = buffer % 10; // un seul chiffre if(temp_int_0 > 0) // si le résultat est un nombre à un quart de chiffre { Display_Dig(temp_int_0, 32, 2); // affiche 1 chiffre du niveau de luminosité Display_Dig(temp_int_1, 41, 2); // affiche 2 chiffres du niveau de luminosité Display_Dig(temp_int_2, 50, 2); // affiche 3 chiffres du niveau de luminosité Display_Dig(temp_int_3, 59, 2); // affiche 4 chiffres du niveau de luminosité } else { if(temp_int_1 > 0) // si le résultat est un nombre à trois chiffres { Off_Dig(32, 2); // effacer 1 signe du nombre Display_Dig(temp_int_1, 41, 2); // affiche 1 chiffre du niveau de luminosité Display_Dig(temp_int_2, 50, 2); // affiche 2 chiffres du niveau de luminosité Display_Dig(temp_int_3, 59, 2); // affiche 3 chiffres du niveau de luminosité } else { if(temp_int_2 > 0) // si le résultat est un nombre à deux chiffres { Off_Dig(32, 2); // efface 1 signe du nombre Off_Dig(41, 2); // effacer le signe 2 du nombre Display_Dig(temp_int_2, 50, 2); // affiche 1 chiffre du niveau de luminosité Display_Dig(temp_int_3, 59, 2); // affiche 2 chiffres du niveau d'éclairage } else // si le résultat est un nombre à un chiffre { Off_Dig(32, 2); // efface 1 signe du nombre Off_Dig(41, 2); // efface le signe 2 du nombre Off_Dig (50, 2); // effacer le signe 3 du nombre Display_Dig(temp_int_3, 59, 2); // affiche 1 chiffre du niveau de luminosité } } } }

// Fonction pour afficher la température void Read_Temp() { unsigned int buffer; int non signé temp_int_1, temp_int_2, temp_int_3; // chiffres simples, doubles chiffres, triples chiffres, quarts de chiffres caractère non signé Temp_H, Temp_L, OK_Flag, temp_flag; DS18B20_init(); // Initialisation du DS18B20 write_18b20(0xCC); // Vérification du code du capteur write_18b20 (0x44); // Démarrer la conversion de température _delay_ms(1000); // Délai d'interrogation du capteur DS18B20_init(); // Initialisation du DS18B20 write_18b20(0xCC); // Vérification du code du capteur write_18b20(0xBE); // Commande pour lire le contenu de la Sensor RAM Temp_L = read_18b20(); // Lecture des deux premiers octets Temp_H = read_18b20(); indicateur_temp = 1; // 1-température positive, 0-température négative // Obtenir la température négative if(Temp_H &(1 << 3)) // Sign Bit Check (si le bit est défini - température négative) { sign int temp; indicateur_temp = 0; // l'indicateur est défini sur 0 - température négative temp = (Temp_H <<8)|Temp_L; temp = -temp; // Convertir le code supplémentaire en direct Temp_L = temp; Temp_H = temp>> 8; } buffer = ((Temp_H 4); temp_int_1 = buffer % 1000 / 100; // à trois chiffres temp_int_2 = buffer % 100 / 10; // à deux chiffres temp_int_3 = buffer % 10; // à un chiffre

// Si la température est négative, affiche le signe de la température, sinon efface

if(temp_flag == 0) {Display_Neg(1);} else {Display_Neg(0);} if(temp_int_1 > 0) // si le résultat est un nombre à trois chiffres { Display_Dig(temp_int_1, 45, 0); // affiche 1 chiffre de la température Display_Dig(temp_int_2, 54, 0); // affiche 2 chiffres de la température Display_Dig(temp_int_3, 63, 0); // affiche 3 chiffres de la température } else { if(temp_int_2 > 0) // si le résultat est un nombre à deux chiffres { Off_Dig(45, 0); // effacer 1 signe du nombre Display_Dig(temp_int_2, 54, 0); // affiche 1 chiffre de la température Display_Dig(temp_int_3, 63, 0); // affiche 2 chiffres de la température } else // si le résultat est un nombre à un chiffre { Off_Dig(45, 0); // efface 1 signe du nombre Off_Dig(54, 0); // effacer le signe 2 du nombre Display_Dig(temp_int_3, 63, 0); // affiche 1 chiffre de température } } }

// Cet ISR est déclenché chaque fois qu'une correspondance se produit entre le compteur de minuterie et la valeur de comparaison (toutes les secondes) ISR (TIMER1_COMPA_vect) { // Lecture, affichage de la température et du niveau de luminosité Read_Temp(); Read_Lux(); }

// Fonction pour afficher les mots "TEMP" et "LUX" void Display_label() { // Word "TEMP" Display_SetXY(0, 0); // Définit l'adresse de la position affichée (ligne du haut) pour (int index=0; index<105; index++) { if (index==40){Display_SetXY(0, 1);} // Définit l'adresse de la position on display (ligne du bas) if (index==80){Display_SetXY(72, 0);} // Définit l'adresse de la position sur l'affichage (ligne du haut) if (index==92){Display_SetXY(72, 1); } // Définir l'adresse de la position sur l'affichage (ligne du bas) SPDR = TEMP_1[index]; // Charge les données du tableau de codes dans le tampon d'affichage while(!(SPSR & (1<<SPIF))); // Attendez la fin de la transmission _delay_ms(10); } // Mot "LUX" Display_SetXY(0, 2); // Définit l'adresse de la position sur l'affichage (ligne du haut) pour (int index=0; index<60; index++) { if (index==30){Display_SetXY(0, 3);} // Définit l'adresse de la position à l'écran (rangée du bas) SPDR = TEMP_2[index]; // Charge les données du tableau de codes dans le tampon d'affichage while(!(SPSR & (1<<SPIF))); // Attendez la fin de la transmission _delay_ms(10); } }

int main(void)

{ Port_Init(); // Initialisation du port ADC_init(); // Initialisation ADC SPI_Init(); // Initialisation SPI SPI_SS_Enable(); // Affichage Activer DS18B20_init(); // Initialisation de DS18B20 Display_init(); // Initialisation de l'affichage Display_Clear(); // Affichage clear Display_label(); // Affiche les mots "TEMP" et "LUX" TIMER1_init(); // Initialisation du temporisateur1. Commencez la surveillance. Obtenir des paramètres toutes les secondes. // Boucle infinie while (1) { } }

Étape 3: Flasher le micrologiciel sur le microcontrôleur

Téléchargement du fichier HEX dans la mémoire flash du microcontrôleur. Regardez la vidéo avec une description détaillée de la gravure de la mémoire flash du microcontrôleur: Gravure de la mémoire flash du microcontrôleur…

Étape 4: Assemblage du circuit du dispositif de surveillance

Connectez les composants conformément au schéma de principe.

Branchez l'alimentation et cela fonctionne!