Réveil numérique basé sur

microcontrôleur PIC16F877A
EMBARQUÉ
ParAswinth Raj 25 mai 20187

Réveil numérique utilisant le microcontrôleur PIC

La révolution numérique commencée en 1950 transforme toutes les structures électroniques
mécaniques et analogiques existantes en ordinateurs numériques. Étant donné que la
croissance de l'électronique numérique a été exponentielle, il est aujourd'hui presque
impossible pour une personne de résister à l'utilisation d'un équipement électronique. À
partir du réveil qui vous réveille et du grille-pain qui vous sert le petit déjeuner, tout est une
contribution de l'électronique numérique. En pensant à tout cela, il est vraiment excitant de
programmer nos propres trucs qui pourraient faire des tâches simples mais utiles, comme
le réveil que nous allons construire dans ce projet avec PIC Microcontroller . Nous avons
déjà construit un réveil avec d'autres microcontrôleurs:

 Réveil Raspberry Pi utilisant le module RTC DS1307

 Horloge numérique basée sur Arduino avec alarme
 Réveil utilisant le microcontrôleur ATmega32
Ce réveil aura un écran LCD 16x2 qui affichera l'heure actuelle et l'heure réglée. Nous
utiliserons quelques boutons poussoirs pour régler l'heure de l'alarme chaque fois que
nécessaire. L'heure actuelle sera conservée à l'aide du module RTC DS3231 et nous
utiliserons la communication IIC pour obtenir ces valeurs du module RTC. Nous avons déjà
appris le module RTC et comment l'interfacer avec PIC. Il est donc recommandé de lire ce
tutoriel, nous sauterons la plupart des informations couvertes dans ce tutoriel.

Matériaux nécessaires:
 Planche à pain - 2Nos
 PIC16F877A
 Source d'alimentation 5V - Module d'alimentation
 Cristal de 20 MHz
 Condensateur 33pf - 2Nos
 Module DS3231 RTC
 Module d'affichage LCD 16 * 2
 POT 10K
 Résistance 10k et 1K
 Boutons poussoirs - 5Nos
 Avertisseur sonore
 Fils de connexion

Conditions préalables:
Ce projet nécessite que vous connaissiez quelques notions de base sur le microcontrôleur
PIC et comment le programmer. Nous utiliserons des GPIO, un écran LCD et un module
RTC pour ce projet. Il vaut donc mieux apprendre à utiliser ces modules au préalable. Les
liens suivants vous aideront à apprendre la même chose

 Ecrire votre premier programme avec PIC Microcontroller

 Interfaçage LCD avec PIC
 Communication I2C via PIC
 Interfaçage DS3231 RTC avec PIC

Schéma:
Le schéma de circuit de ce projet de réveil basé sur PIC est illustré ci-dessous, qui a été
créé à l'aide du logiciel proteus. Le sera également utilisé pour la simulation plus loin dans
ce projet.
  

Les cinq boutons-poussoirs agiront comme une entrée pour régler l'alarme pendant la durée
requise. Ainsi, une extrémité de tous les boutons-poussoirs est connectée à la masse et les
autres extrémités sont connectées à la broche PORTB, une résistance de rappel interne
sera utilisée sur ces broches pour éviter que les broches ne flottent. Le buzzer agira comme
une sortie et nous émettra un bip lorsque l'alarme se déclenchera et sera connectée à la
broche PORT S. L'heure actuelle est toujours conservée par le module RTC DS3231
à partir duquel le PIC reçoit les données via le bus I2C, de sorte que les broches SCL et
SDA du module RTC sont connectées aux broches SCL et SDA du contrôleur PIC. Un
écran LCD est attaché au PORTD du PIC qui est utilisé pour afficher l'heure actuelle et
régler l'heure. En savoir plus sur l'utilisation du module DS3231 RTC avec PIC ici.

Le circuit complet peut être construit sur une maquette. Puisqu'il y a une douzaine de fils à
connecter, soyez patient et assurez-vous que les connexions sont correctes. Ma
configuration matérielle ressemblait à ceci ci-dessous une fois que j'ai terminé les
connexions
J'ai utilisé un module de maquette et un adaptateur 12V pour alimenter le module. Ceci est
ma source de tension d'alimentation + 5V. Je dois aussi utiliser deux planches à pain pour
garder le circuit propre. Vous pouvez également souder l'ensemble du circuit à une carte de
performance si vous souhaitez créer un projet plus robuste.

Programmation pour le réveil:

Le programme PIC complet pour ce projet de réveil se trouve au bas de cette page. Ce
projet nécessite également trois bibliothèques pour utiliser LCD, I2C et RTC avec PIC. Le
code complet avec les fichiers d'en-tête peut être téléchargé à partir du fichier ZIP ici et peut
être ouvert en utilisant MPLABX après l'extraction. Plus loin, j'explique simplement le fichier
c principal sous forme de petits extraits. Vous pouvez revenir aux didacticiels mentionnés ci-
dessus si vous souhaitez savoir comment fonctionnent les fichiers d'en-tête.
Avant d'entrer dans le programme principal, nous devons définir les broches que nous
avons utilisées avec un nom plus significatif. De cette façon, il sera facile de les utiliser
pendant la programmation. Les broches définies dans notre programme sont présentées ci-
dessous

// Définir les broches LCD

#define RS RD2 // Réinitialiser la broche de l'écran LCD

#define EN RD3 // Activer la broche de l'écran LCD

#define D4 RD4 // Bit de données 0 de l'écran LCD

#define D5 RD5 // Bit de données 1 de l'écran LCD

#define D6 RD6 // Bit de données 2 de l'écran LCD

#define D7 RD7 // Bit de données 3 de l'écran LCD

// Définir les boutons

#define MB RB1 // Le bouton du milieu

#define LB RB0 // Bouton gauche

#define RB RB2 // Bouton droit

#define UB RB3 // Bouton supérieur

#define BB RB4 // Bouton du bas

// Définir Buzz

#define BUZZ RD1 // Le buzzer est connecté à RD1

Dans la fonction principale , nous commençons par déclarer les broches d'entrée et de

sortie . Dans notre projet, le PORTB est utilisé pour les boutons-poussoirs qui est un
périphérique d'entrée, nous définissons donc leurs broches comme entrées et PORTD est
utilisé pour l'écran LCD et le buzzer, nous définissons donc leurs broches comme sortie. De
plus, une broche ne doit jamais être laissée flottante, ce qui signifie que les broches d'E / S
doivent toujours être connectées à la terre ou à la tension + 5V. Dans notre cas pour les
boutons poussoirs, les broches ne seront connectées à rien lorsque le bouton n'est pas
enfoncé, nous utilisons donc une résistance de rappel interne qui règle la broche sur High
lorsqu'elle n'est pas utilisée. Ceci est fait en utilisant les registres de contrôle comme indiqué
ci-dessous

TRISD = 0x00; // Rendre les broches du port D comme outptu pour l'interface LCD

TRISB = 0xFF; // Les commutateurs sont déclarés comme broches d'entrée

OPTION_REG = 0b00000000; // Activer la résistance de rappel sur le port B pour les

commutateurs

BUZZ = 0; // Tourner le buzzer

Puisque nous avons le fichier d'en-tête LCD et I2C lié au programme principal, nous
pouvons démarrer l'initialisation de l'écran LCD en appelant une fonction simple. La
même chose peut être faite pour l' initialisation I2C . Ici, nous commençons la
communication I2C à 100 kHz puisque le module RTC fonctionne à 100 kHz.

Lcd_Start (); // Initialise le module LCD

I2C_Initialize (100); // Initialisation du maître I2C avec une horloge à 100 KHz

La fonction ci-dessous est utilisée pour régler l'heure et la date sur le module RTC , une
fois que l'heure et la date sont réglées, supprimez cette ligne. Sinon chaque fois que vous
démarrez le programme, l'heure et la date seront réglées encore et encore

// Supprime la ligne ci-dessous une fois que l'heure et la date sont définies pour la
première fois.

Set_Time_Date (); // régler l'heure et la date sur le module RTC

Pour indiquer que le programme démarre, nous affichons un petit écran

d'introduction qui affiche le nom du projet et le nom du site Web comme indiqué ci-
dessous

// Donne un message d'introduction sur l'écran LCD

Lcd_Clear ();

Lcd_Set_Cursor (1,1);

Lcd_Print_String ("Réveil");

Lcd_Set_Cursor (2,1);

Lcd_Print_String ("-Circuit Digest");

 __delay_ms (1500);

Suivant l' intérieur du tout boucle , nous devons lire l'heure et la date à partir du module

RTC , cela peut se faire simplement en appelant la fonction ci - dessous.

Update_Current_Date_Time (); // Lire la date et l'heure actuelles du module RTC

L'appel de la fonction ci-dessus mettra à jour les variables sec, min et heure avec la valeur
actuelle. Afin de les afficher sur l'écran LCD, nous devons les diviser en caractères
individuels en utilisant le code ci-dessous. 

// Divise le en caractère pour l'afficher sur lcd

char sec_0 = sec% 10;

char sec_1 = (sec / 10);

char min_0 = min% 10;

char min_1 = min / 10;

char hour_0 = heure% 10;

char heure_1 = heure / 10;

Ensuite, nous mettons à jour les valeurs sur l'écran LCD . L'heure actuelle sera affichée
sur la première ligne et l'heure réglée à laquelle l'alarme doit être déclenchée est affichée
sur la deuxième ligne. Le code qui fait la même chose est indiqué ci-dessous.

// Affiche l'heure actuelle sur l'écran LCD

Lcd_Clear ();

Lcd_Set_Cursor (1, 1);

Lcd_Print_String ("TIME:");

Lcd_Print_Char (heure_1 + '0');

Lcd_Print_Char (heure_0 + '0');

Lcd_Print_Char (':');

Lcd_Print_Char (min_1 + '0');

 Lcd_Print_Char (min_0 + '0');

Lcd_Print_Char (':');

Lcd_Print_Char (sec_1 + '0');

Lcd_Print_Char (sec_0 + '0');

// Affiche la date sur l'écran LCD

Lcd_Set_Cursor (2, 1);

Lcd_Print_String ("Alarme:");

Lcd_Print_Char (alarm_val [0] + '0');

Lcd_Print_Char (alarm_val [1] + '0');

Lcd_Print_Char (':');

Lcd_Print_Char (alarm_val [2] + '0');

Lcd_Print_Char (valeur_alarme [3] + '0');

Maintenant, nous avons affiché l'heure et l'heure réglée sur l'écran LCD, nous
devons vérifier si l'utilisateur essaie de régler l'heure de l'alarme . Pour ce faire,
l'utilisateur doit appuyer sur le bouton du milieu, nous allons donc vérifier si le bouton du
milieu est enfoncé et basculer une variable pour entrer en mode de réglage d'alarme. Le
même bouton sera à nouveau pressé pour confirmer que les valeurs sont réglées et dans ce
cas, nous devons sortir du mode de réglage d'alarme. Nous utilisons donc la ligne de code
ci-dessous pour changer le statut de la variable set_alarm .

// Utilisez le bouton du milieu pour vérifier si l' alarme doit être définie

if (MB == 0 && set_alarm == 0) {// Si le bouton du milieu est enfoncé et que

l'alarme n'est pas activée

tandis que (! MB); // Attendre que le bouton soit relâché

set_alarm = 1; // démarrer la définition de la valeur de l'alarme

if (MB == 0 && set_alarm == 1) {// Si le bouton central est enfoncé et que

l'alarme n'est pas désactivée tant
 que (! MB); // Attendre que le bouton soit relâché

set_alarm = 0; // arrêter de définir la valeur d'alarme

Si l'utilisateur a appuyé sur le bouton du milieu , cela signifie qu'il essaie de régler
l'heure de l'alarme. Dans ce cas, le programme entre en mode de réglage d'alarme en
utilisant le code ci-dessus. Dans le mode de réglage de l'alarme, si l'utilisateur appuie sur le
bouton gauche ou droit, cela signifie que nous devons déplacer le curseur vers la gauche ou
la droite. Pour ce faire on incrémente ou décrémente simplement la valeur de la position à
laquelle le curseur doit être placé

if (LB == 0) {// Si le bouton gauche est enfoncé

tandis que (! LB); // Attendre que le bouton soit relâché

pos--; // Puis déplacez le curseur vers la gauche

if (RB == 0) {// Si le bouton droit est enfoncé

pendant que (! RB); // Attendre que le bouton soit relâché

pos ++; // Déplacer le curseur vers la droite

Lors de l'utilisation d'un bouton poussoir avec un microcontrôleur ou un microprocesseur, il y

a un problème courant à résoudre. Ce problème s'appelle le rebond du
commutateur . C'est lorsque le bouton est enfoncé, il peut donner des impulsions
bruyantes au MCU / MPU qui pourraient simuler le MCU pour plusieurs entrées. Ce
problème peut être résolu en ajoutant un condensateur à travers le commutateur ou
en utilisant une fonction de retard dès que la pression sur le bouton est détectée. Ce type de
solution est appelé dé-rebond. Nous avons utilisé ici un tout en boucle pour maintenir
le programme en place jusqu'à ce que le bouton est relâché. Ce n'est pas la meilleure
solution de rebond, mais pour nous, cela fonctionnera très bien.

tandis que (! RB);

Semblable aux boutons gauche et droit, nous avons également les boutons supérieur et
inférieur qui peuvent être utilisés pour augmenter ou diminuer la valeur de l'heure de
l'alarme . Le code pour faire de même est indiqué ci-dessous. Notez que chaque caractère
de l'heure d'alarme définie est adressé par la valeur d'index du tableau. C'est ainsi que nous
pouvons facilement accéder au caractère requis dont les valeurs doivent être modifiées.

if (UB == 0) {// Si le bouton supérieur est enfoncé

pendant que (! UB); // Attendre que le bouton soit relâché

alarm_val [(pos - 8)] ++; // Augmente la valeur de ce caractère

particulier

if (BB == 0) {// Si le bouton inférieur est pressé

while (! UB); // Attendre que le bouton soit relâché

alarm_val [(pos - 8)] -; // Diminue cette valeur de caractère

particulière

Une fois l'heure de l'alarme réglée, l'utilisateur appuiera à nouveau sur le bouton
central . Ensuite, nous pouvons commencer à comparer l'heure actuelle avec l'heure
définie. La comparaison en vérifiant si chaque caractère de l'heure actuelle est égal au
caractère de l'heure définie. Si les valeurs sont égales, nous déclenchons l'alarme en
définissant la variable trigger_alarm , sinon nous comparons simplement jusqu'à ce qu'elle
soit égale.

// SI l'alarme est définie Vérifiez si la valeur définie est égale à la valeur

actuelle si (set_alarm == 0 && alarm_val [0] == hour_1 && alarm_val [1] ==

hour_0 && alarm_val [2] == min_1 && alarm_val [3 ] == min_0)

trigger_alarm = 1; // Activer le déclencheur si la valeur correspond

Si l'alarme est définie, nous devons émettre un bip pour avertir l'utilisateur de

l'alarme. Cela peut être fait en basculant simplement le buzzer à intervalles réguliers,
comme indiqué ci-dessous.

if (trigger_alarm) {// Si l'alarme est déclenchée

// Bip le buzzer

BUZZ = 1;

__delay_ms (500);
 BUZZ = 0;

__delay_ms (500);

Simulation:
Ce programme peut également être simulé à l'aide du logiciel proteus. Recréez simplement
le circuit illustré ci-dessus et chargez le fichier hexadécimal dans le PIC. Le code
hexadécimal de ce projet se trouve dans le fichier ZIP lié ici . Une capture d'écran prise
pendant la simulation est présentée ci-dessous

La simulation devient très utile lorsque vous essayez d'ajouter de nouvelles fonctionnalités
au projet. Vous pouvez également utiliser le module de débogage I2C pour vérifier quelles
données entrent et sortent via le bus I2C. Vous pouvez essayer d'appuyer sur les boutons
et également régler l'heure de l'alarme. Lorsque l'heure réglée est égale à l'heure actuelle,
la sonnerie se déclenche.

Fonctionnement du réveil numérique utilisant PIC16F877A:

Construisez le circuit sur la maquette, récupérez le code à partir du lien de téléchargement
et compilez-le à l'aide du compilateur MplabX et XC8. Si vous avez téléchargé le code à
partir du fichier ZIP fourni ici , vous ne devriez avoir aucun problème à le compiler car les
fichiers d'en-tête sont déjà joints.

Après la compilation, téléchargez le programme sur votre matériel à l'aide du programmeur

PicKit3. La connexion pour connecter le programmeur pickit à PIC IC est également
indiquée dans le schéma de circuit. Une fois le programme téléchargé, vous devriez voir
l'écran d'introduction, puis l'heure affichée, vous pouvez ensuite utiliser les boutons-
poussoirs pour régler l'heure de l'alarme. Ma configuration matérielle une fois sous tension
ressemble à ceci ci-dessous.

Lorsque l'heure de l'alarme correspond à l'heure actuelle, le buzzer émettra un

bip pour alerter l'utilisateur. Le travail complet peut être trouvé dans la vidéo ci-dessous. Le
projet a une pléthore d'options sur lesquelles s'appuyer. Le module RTC peut garder une
trace de n'importe quelle heure et date, de sorte que vous pouvez effectuer une tâche
planifiée à n'importe quelle heure / date requise. Vous pouvez également connecter un
appareil CA comme un ventilateur ou une lumière et le programmer pour qu'il s'allume ou
s'éteigne si nécessaire. Il y a encore beaucoup plus que vous pouvez construire sur ce
projet, faites-moi savoir quelle idée vous vient à l'esprit comme une mise à niveau de ce
projet et je serai heureux de vous entendre.
J'espère que vous avez compris le projet et appris quelque chose d'utile du processus. Si
vous avez des doutes sur ce projet, utilisez la section commentaires pour les publier ou
utilisez les forums pour toute aide technique.

Le code PIC complet avec les fichiers d'en-tête peut être trouvé ici

Code
/*
 * Programme: Alarm Clock Using PIC   
 * Auteur: B.Aswinth Raj
 * Plus d'infos: www.circuitdigest.com 
 * Créé le 11 mai 2018, 15h02
 * /
#pragma config FOSC = HS // Oscillator Selection bits (Oscillateur HS)
#pragma config WDTE = OFF // Bit d'activation de l'horloge de surveillance (WDT désactivé)
#pragma config PWRTE = ON // Bit d'activation de la minuterie de mise sous tension (PWRT activé)
#pragma config BOREN = ON // Réinitialisation de la coupure de courant Bit d'activation (BOR activé)
#pragma config LVP = OFF // Bit d'activation de la programmation série en circuit basse tension
(alimentation simple) (RB3 est une E / S numérique, HV sur MCLR doit être utilisé pour la programmation)
#pragma config CPD = OFF // Data EEPROM Memory Code Protection Bit (Data EEPROM code
protection off)
#pragma config WRT = OFF // Flash Program Memory Write Enable bits (Protection en écriture
désactivée; toute la mémoire programme peut être écrite par le contrôle EECON )
#pragma config CP = OFF // Bit de protection de code de mémoire de programme flash (protection de
code désactivée)

#define _XTAL_FREQ 20000000 // Nous fonctionnons sur un cristal de 20 MHz 

// Définir les broches LCD

#define RS RD2 // Réinitialiser la broche de l'écran LCD
#define EN RD3 // Activer la broche de l'écran LCD
#define D4 RD4 // Bit de données 0 de l'écran LCD
#define D5 RD5 // Bit de données 1 de l'écran LCD
#define D6 RD6 // Bit de données 2 de l'écran LCD
#define D7 RD7 // Bit de données 3 de l'écran LCD

// Définir les boutons

#define MB RB1 // Le bouton du milieu 
#define LB RB0 // Bouton gauche 
#define RB RB2 // Bouton droit 
#define UB RB3 // Bouton supérieur 
#define BB RB4 // Bouton du bas 

// Définir Buzz
#define BUZZ RD1 // Le buzzer est connecté à RD1

/ * Définit la valeur actuelle de la date et de l'heure sous * /

int sec = 00;
int min = 55;
heure int = 10;
date int = 06;
mois int = 05;
année int = 18;
/ * Réglage de l'heure et de la date * /
/ * Vars pour réveil * /
char set_alarm = 0;
char trigger_alarm = 0;
char pos = 8;
saut de caractère = 0;

char alarm_h0 = 0;
char alarm_h1 = 0;
char alarm_m0 = 0;
char alarm_m1 = 0;
int alarm_val [4] = {0, 0, 0, 0};
/ * Fin de la déclaration var * /

#include <xc.h>
#include "lcd.h" // En-tête pour l'utilisation du module LCD
#include "PIC16F877a_I2C.h" // En-tête pour l'utilisation du protocole I2C
#include "PIC16F877a_DS3231.h" // En-tête pour l'utilisation du module DS3231 RTC

int main() {

    TRISD = 0x00; // Rendre les broches du port D comme outptu pour l'interface LCD 
    TRISB = 0xFF; // Les commutateurs sont déclarés comme broches d'entrée
    OPTION_REG = 0b00000000; // Activer la résistance de rappel sur le port B pour les commutateurs
    BUZZ = 0; // Tourner le buzzer

    Lcd_Start (); // Initialiser le module LCD

    I2C_Initialize (100); // Initialisation du maître I2C avec une horloge à 100 KHz

    // Supprime la ligne ci-dessous une fois que l'heure et la date sont définies pour la première fois.
    Set_Time_Date (); // régler l'heure et la date sur le module RTC 

    // Donne un message d'introduction sur l'écran LCD

         Lcd_Clear ();
         Lcd_Set_Cursor (1,1);
         Lcd_Print_String ("Réveil");
         Lcd_Set_Cursor (2,1);
         Lcd_Print_String ("-Circuit Digest");
         __delay_ms (1500); 

    tandis que (1) {

        Update_Current_Date_Time (); // Lire la date et l'heure actuelles du module RTC

        // Divise le en caractère pour l'afficher sur lcd

        char sec_0 = sec% 10;
        char sec_1 = (sec / 10);
        char min_0 = min% 10;
        char min_1 = min / 10;
        char hour_0 = heure% 10;
        char heure_1 = heure / 10;

        // Affiche l'heure actuelle sur l'écran LCD

        Lcd_Clear ();
        Lcd_Set_Cursor (1, 1);
        Lcd_Print_String ("TIME:");
        Lcd_Print_Char (heure_1 + '0');
        Lcd_Print_Char (heure_0 + '0');
        Lcd_Print_Char (':');
        Lcd_Print_Char (min_1 + '0');
        Lcd_Print_Char (min_0 + '0');
        Lcd_Print_Char (':');
        Lcd_Print_Char (sec_1 + '0');
        Lcd_Print_Char (sec_0 + '0');

        // Affiche la date sur l'écran LCD

        Lcd_Set_Cursor (2, 1);
        Lcd_Print_String ("Alarme:");
        Lcd_Print_Char (valeur_alarme [0] + '0');
        Lcd_Print_Char (alarm_val [1] + '0');
        Lcd_Print_Char (':');
        Lcd_Print_Char (alarm_val [2] + '0');
        Lcd_Print_Char (valeur_alarme [3] + '0');

        __delay_ms (50);

        // Utilisez le bouton du milieu pour vérifier si l'alarme doit être définie 

        if (MB == 0 && set_alarm == 0) {// Si le bouton du milieu est enfoncé et que l'alarme n'est pas
activée 
            tandis que (! MB); // Attendre que le bouton soit relâché
            set_alarm = 1; // démarrer la définition de la valeur de l'alarme 
    }
        if (MB == 0 && set_alarm == 1) {// Si le bouton central est enfoncé et que l'alarme n'est pas
désactivée tant 
            que (! MB); // Attendre que le bouton soit relâché
            set_alarm = 0; // arrêter de définir la valeur d'alarme 
    }

        // Si l'alarme doit être parcourue par chaque chiffre

        if (set_alarm == 1) {
            if (LB == 0) {// Si le bouton gauche est enfoncé
                pendant que (! LB); // Attendre que le bouton soit relâché
                pos--; // Puis déplacez le curseur vers la gauche
      }
            if (RB == 0) {// Si le bouton droit est enfoncé 
                pendant que (! RB); // Attendre que le bouton soit relâché
                pos ++; // Déplacer le curseur vers la droite
      }

            if (pos> = 10) // élimine le symbole ":" si le curseur y atteint

      {
                jump = 1; // Saute par-dessus le symbole ":" 
            } else
                jump = 0; // retourne au mouvement normal

            if (UB == 0) {// Si le bouton supérieur est enfoncé

                pendant que (! UB); // Attendre que le bouton soit relâché
                alarm_val [(pos - 8)] ++; // Augmente la valeur de ce caractère particulier 
      }
            if (BB == 0) {// Si le bouton inférieur est pressé
                while (! UB); // Attendre que le bouton soit relâché
                alarm_val [(pos - 8)] -; // Diminue cette valeur de caractère particulière 
      }

            Lcd_Set_Cursor (2, pos + saut);

            Lcd_Print_Char (95); // Afficher "_" pour indiquer la position du curseur
    }

        // SI l'alarme est définie Vérifiez si la valeur définie est égale à la valeur actuelle 
        si (set_alarm == 0 && alarm_val [0] == hour_1 && alarm_val [1] == hour_0 && alarm_val [2] ==
min_1 && alarm_val [3 ] == min_0)
            trigger_alarm = 1; // Activer le déclencheur si la valeur correspond

        
        if (trigger_alarm) {// Si l'alarme est déclenchée 
            // Bip le buzzer
            BUZZ = 1; 
            __delay_ms (500);
            BUZZ = 0;
            __delay_ms (500);
    }

        __delay_ms (200); // Intervalle de mise à jour 

  }

    return 0;
}

Vidéo