Dans nos précédents didacticiels sur le microcontrôleur Nuvoton, nous avons utilisé un programme de base de clignotement des LED comme guide de démarrage et avons également interfacé GPIO comme entrée pour connecter un interrupteur tactile. Avec ce tutoriel, nous savons parfaitement comment configurer le projet Keil et configurer l’environnement de programmation du microcontrôleur N76E003 Nuvoton. Il est temps d’utiliser un périphérique interne de l’unité du microcontrôleur et d’aller un peu plus loin en utilisant le Minuterie intégrée du N76E003.
Dans notre tutoriel précédent, nous avons uniquement utilisé un délai logiciel pour faire clignoter une LED. Dans ce tutoriel, nous allons donc apprendre à utiliser la fonction de délai Timer ainsi que le Timer ISR (Interrupt Service Routine) et à faire clignoter deux LED individuelles. Vous pouvez également consulter le didacticiel Arduino Timer et le didacticiel PIC Timer pour vérifier comment utiliser les minuteries avec d’autres microcontrôleurs. Sans perdre beaucoup de temps, évaluons le type de configuration matérielle dont nous avons besoin.
Configuration matérielle et exigences
Comme l’exigence de ce projet est d’apprendre Minuterie ISR et fonction de temporisationnous utiliserons deux LED, dont une clignotera en utilisant un délai de minuterie dans la boucle while et une autre clignotera à l’intérieur de la fonction ISR.
Puisqu’une LED est disponible dans la carte de développement N76E003, ce projet nécessite une LED supplémentaire et la résistance de limitation de courant pour limiter le courant de la LED. Les composants dont nous avons besoin –
- N’importe quelle couleur de la LED
- Résistance 100R
Sans oublier qu’outre les composants ci-dessus, nous avons besoin Microcontrôleur N76E003 conseil de développement basé ainsi que le Programmeur Nu-Link. De plus, une planche à pain et des fils de connexion sont également nécessaires pour connecter tous les composants.
Schéma de circuit pour l’interface LED avec Nuvoton N76E003
Comme nous pouvons le voir dans le schéma ci-dessous, la LED de test est disponible à l’intérieur de la carte de développement et elle est connectée sur le port 1.4. Une LED supplémentaire est connectée au port 1.5. La résistance R3 sert à limiter le courant des LED. À l’extrême gauche, la connexion de l’interface de programmation est affichée.
Broches de minuterie sur Nuvoton N76E003
Le schéma des broches du N76E003 peut être vu dans l’image ci-dessous-
Comme nous pouvons le voir, chaque broche a des spécifications différentes et chaque broche peut être utilisée à plusieurs fins. Cependant, la broche 1.5 qui est utilisée comme broche de sortie LED, perdra le PWM et d’autres fonctionnalités. Mais ce n’est pas un problème car aucune autre fonctionnalité n’est requise pour ce projet.
La raison du choix de la broche 1.5 comme sortie et de la broche 1.6 comme entrée est due à la disponibilité la plus proche des broches GND et VDD pour une connexion facile. Cependant, dans ce microcontrôleur sur 20 broches, 18 broches peuvent être utilisées comme broche GPIO et toutes les autres broches GPIO peuvent être utilisées à des fins liées à la sortie et à l’entrée, à l’exception de la broche 2.0 qui est spécifiquement utilisée pour l’entrée de réinitialisation et qui ne peut pas être utilisée comme sortie. Toutes les broches GPIO peuvent être configurées dans le mode décrit ci-dessous.
Selon la fiche technique, PxM1.n et PxM2.n sont deux registres utilisés pour déterminer l’opération de contrôle du port d’E/S. Puisque nous utilisons des LED et que nous avons besoin de la broche comme broche de sortie générale, nous utiliserons donc le mode quasi-bidirectionnel pour les broches.
Registres de minuterie dans Nuvoton N76E003
La minuterie est une chose importante pour toute unité de microcontrôleur. Le microcontrôleur est livré avec un périphérique de minuterie intégré. Le nuvoton N76E003 est également livré avec Périphériques de minuterie 16 bits. Cependant, chaque minuterie est utilisée à des fins différentes, et avant d’utiliser une interface de minuterie, il est important de connaître la minuterie.
Types d’heures à Nuvoton N76E003
Minuteries 0 et 1 :
Ces deux timers timer0 et timer1 sont identiques aux timers 8051. Ces deux timers peuvent être utilisés comme timer général ou comme compteurs. Ces deux minuteries fonctionnent selon quatre modes. Dans Mode 0ces minuteries fonctionneront en mode Minuterie/Compteur 13 bits. Dans Mode 1le bit de résolution de ces deux temporisateurs sera de 16 bits. Dans Mode 2les minuteries sont configurées en mode de rechargement automatique avec une résolution de 8 bits. Dans Mode 3le temporisateur 1 est arrêté et le temporisateur 0 peut être utilisé à la fois comme compteur et comme temporisateur.
Parmi ces quatre modes, le mode 1 est utilisé dans la plupart des cas. Ces deux timers peuvent utiliser le Fsys (System Frequency) en mode fixe ou pré-échelonné (Fys/12). Il peut également être cadencé à partir d’une source d’horloge externe.
Minuterie 2 :
Timer 2 est également un timer 16 bits principalement utilisé pour la capture de forme d’onde. Il utilise également l’horloge système et peut être utilisé dans différentes applications en divisant la fréquence d’horloge à l’aide de 8 échelles différentes. Il peut également être utilisé en mode comparaison ou pour générer du PWM.
Tout comme Timer 0 et Timer 1, Timer 2 peut être utilisé en mode de rechargement automatique.
Minuterie 3 :
Le temporisateur 3 est également utilisé comme temporisateur 16 bits et est utilisé pour la source d’horloge à débit en bauds pour l’UART. Il dispose également d’une fonction de rechargement automatique. Il est important d’utiliser ce temporisateur uniquement pour la communication série (UART) si l’application nécessite une communication UART. Dans un tel cas, il est conseillé de ne pas utiliser cette minuterie à d’autres fins en raison du processus conflictuel dans la configuration de la minuterie.
Minuterie de surveillance :
Watchdog Timer peut être utilisé comme un timer 6 bits standard, mais il n’est pas utilisé à cette fin. L’utilisation de la minuterie Watchdog comme minuterie à usage général est applicable aux applications à faible consommation d’énergie où le microcontrôleur reste principalement en mode veille.
Watchdog Timer, comme son nom l’indique, vérifie toujours si le microcontrôleur fonctionne correctement ou non. Dans le cas d’un microcontrôleur bloqué ou arrêté, WDT (Watchdog Timer) réinitialise automatiquement le microcontrôleur, ce qui garantit que le microcontrôleur fonctionne dans un flux de code continu sans rester bloqué, suspendu ou arrêté.
Minuterie de réveil automatique :
Il s’agit d’un autre périphérique de minuterie qui sert un processus de synchronisation dédié, identique à celui d’une minuterie de surveillance. Cette minuterie réveille périodiquement le système lorsque le microcontrôleur fonctionne en mode faible consommation.
Ce périphérique de minuterie peut être utilisé en interne ou à l’aide de périphériques externes pour sortir le microcontrôleur du mode veille. Pour ce projet, nous utiliserons Timer 1 et Timer 2.
Programmation du microcontrôleur Nuvoton N76E003 pour minuteries
Définition des broches comme sortie :
Commençons par la section de sortie. Nous utilisons deux LED, l’une est la LED intégrée, nommée Test, et connectée au port P1.4 et une LED externe connectée à la broche P1.5.
Par conséquent, ces deux broches sont configurées comme broche de sortie pour connecter ces deux LED à l’aide des extraits de code ci-dessous.
#define Test_LED P14 #define LED1 P15
Ces deux broches sont définies comme broches quasi-bidirectionnelles dans la fonction de configuration.
void setup (void){
P14_Quasi_Mode;
P15_Quasi_Mode;
}
Réglage de la fonction minuterie :
Dans la fonction de configuration, la minuterie 2 doit être configurée pour obtenir la sortie souhaitée. Pour cela, nous allons définir le registre T2MOD avec un facteur de division d’horloge de 1/128 et l’utiliser dans un mode de retard de rechargement automatique. Voici l’aperçu du registre T2MOD-
Les 4,5 et 6ème bits du registre T2MOD définissent le diviseur d’horloge de la minuterie 2 et le 7ème bit définit le mode de rechargement automatique. Cela se fait en utilisant la ligne ci-dessous –
TIMER2_DIV_128; TIMER2_Auto_Reload_Delay_Mode;
Ces deux lignes sont définies dans le fichier Function_define.h comme
#define TIMER2_DIV_128 T2MOD|=0x50; T2MOD&=0xDF #define TIMER2_Auto_Reload_Delay_Mode T2CON&=~SET_BIT0; T2MOD|=SET_BIT7; T2MOD|=SET_BIT3
Désormais, ces lignes définissent la valeur de synchronisation requise pour le Timer 2 ISR.
RCMP2L = TIMER_DIV128_VALUE_100ms; RCMP2H = TIMER_DIV128_VALUE_100ms>>8;
Qui est défini plus en détail dans le fichier Function_define.h comme-
TIMER_DIV128_VALUE_100ms 65536-12500 //12500*128/16000000 = 100 ms
Ainsi, 16 000 000 est la fréquence cristalline de 16 MHz qui définit le délai de 100 ms.
Ci-dessous, deux lignes videront les octets bas et haut du Timer 2.
TL2 = 0; TH2 = 0;
Enfin, le code ci-dessous activera l’interruption du minuteur 2 et démarrera le minuteur 2.
set_ET2; // Enable Timer2 interrupt set_EA; set_TR2; // Timer2 run
La fonction de configuration complète peut être vue dans les codes ci-dessous-
void setup (void){
P14_Quasi_Mode;
P15_Quasi_Mode;
TIMER2_DIV_128;
TIMER2_Auto_Reload_Delay_Mode;
RCMP2L = TIMER_DIV128_VALUE_100ms;
RCMP2H = TIMER_DIV128_VALUE_100ms>>8;
TL2 = 0;
TH2 = 0;
set_ET2; // Enable Timer2 interrupt
set_EA;
set_TR2; // Timer2 run
}
Fonction ISR de la minuterie 2 :
La fonction Timer 2 ISR est visible dans le code ci-dessous.
void Timer2_ISR (void) interrupt 5
{
clr_TF2; //Clear Timer2 Interrupt Flag
LED1 = ~LED1; // LED1 toggle, connected in P1.5;
}
Clr_TF2 Effacera l’indicateur d’interruption de la minuterie 2 et la LED basculera chaque fois que la fonction ISR est appelée. Comme l’interruption est réglée sur 100 ms, la LED clignotera à intervalles de 100 ms.
Fonction principale et boucle while :
Un matériel, s’il est connecté à l’alimentation et fonctionne parfaitement, il doit fournir une sortie en continu et l’application ne s’arrête jamais. Cela fait la même chose pendant des temps infinis. Voici la fonction while boucle. L’application à l’intérieur de la boucle while s’exécute à l’infini. Dans un premier temps, la fonction de configuration est appelée.
setup();
while(1){
Test_LED = 0;
Timer1_Delay10ms(100);
Test_LED = 1;
Timer1_Delay10ms(100);
}
}
La boucle while ci-dessus fait clignoter la LED selon le délai de la minuterie 1. La valeur est définie pour 1 seconde.
La minuterie 1 est configurée dans le fichier delay.c disponible dans le package de support Board.
void Timer1_Delay10ms(UINT32 u32CNT){
clr_T1M; //T1M=0, Timer1 Clock = Fsys/12 TMOD |= 0x10; //Timer1 is 16-bit mode
set_TR1; //Start Timer1
while (u32CNT != 0) {
TL1 = LOBYTE(TIMER_DIV12_VALUE_10ms); //Find define in "Function_define.h" "TIMER VALUE"
TH1 = HIBYTE(TIMER_DIV12_VALUE_10ms);
while (TF1 != 1); //Check Timer1 Time-Out Flag
clr_TF1;
u32CNT --;
}
clr_TR1; //Stop Timer1
}
Dans la fonction ci-dessus, l’horloge de la minuterie 1 est définie sur Fsys/12 en mode 16 bits. La minuterie démarre et compte le temps de tic-tac pendant un intervalle de 10 ms, puis elle s’arrête. Comme la minuterie est configurée pour 100 fois Timer1_Delay10ms(100); le temps qu’il obtient 10 ms x 100 = 1 seconde.
Code clignotant et vérification de la sortie pour la fonctionnalité de minuterie
Le code (donné ci-dessous) une fois compilé a renvoyé 0 avertissement et 0 erreur et je l’ai flashé en utilisant la méthode de clignotement par défaut dans Keil. Après avoir clignoté, les LED clignotaient selon un délai défini comme programmé.
Regardez la vidéo ci-dessous pour une démonstration complète du fonctionnement de la carte pour ce code. J’espère que vous avez apprécié le didacticiel et appris quelque chose d’utile. Si vous avez des questions, laissez-les dans la section commentaires ci-dessous. Vous pouvez également utiliser nos forums pour poster d’autres questions techniques.
Retrouvez l’histoire de Raspberry Pi dans cette vidéo :
