Réveil numérique basé sur un microcontrôleur PIC16F877A

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. Comme il y a quelques dizaines 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. De plus, je dois 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 à l'aide de 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 # définir UB RB3 // Bouton supérieur #define BB RB4 // Bouton inférieur // Définir le 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 rester 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 (valeur_alarme + '0'); Lcd_Print_Char (valeur_alarme + '0'); Lcd_Print_Char (':'); Lcd_Print_Char (valeur_alarme + '0 '); Lcd_Print_Char (valeur_alarme + '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 central, 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é 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 }

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 de commutateur. C'est-à-dire que 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 ++; // 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--; // 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érifier si la valeur de consigne est égale à la valeur actuelle if (set_alarm == 0 && alarm_val == hour_1 && alarm_val == hour_0 && alarm_val == min_1 && alarm_val == 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 à intervalle régulier 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