msp430 launchpad, partie 4

Dans cette partie j'explore une fonctionnalité particulière du Watchdog timer. Sur la majorité des micro-controleurs que je connais le WDT ne fait que réinitialiser le MCU lorsque son compteur expire. Le WDT+ des msp430 a un mode de fonctionnement supplémentaire qui permet de l'utiliser en mode minuterie qui déclenche une interruption lorsque le compte expire sans réinitialiser le MCU, d'où la signification du + après le WDT. Pour cette expérience le crystal de 32768Hz fournis avec le launchpad doit-être soudé sur la carte car l'expérience consiste à créer une horloge temps réel. Le programme utilise juste un peut plus de 1Ko (1028 octets) et pourrait-être utilisé sans modification sur un msp430g2xxx plus économique que le msp430g2553. Un msp430g2202IN20 ferais aussi bien l'affaire pour moins de la moitié du prix d'un msp430g2553.

Sujets traités:

• Configuration des condensateurs internes pour l'oscillateur LFXT1.
• Utilisation du WDT+ comme minuterie.
• Surveillance de la défectuosité d'un oscillateur.

Comme programme démo j'ai créé une horloge qui affiche les heures et minutes en B.C.D. J'avais déjà beaucoup de LEDs de plantées sur la carte sans soudure suite à mes expériences antérieures, j'ai donc décidé de continuer à les utiliser comme affichage. Comme illustré sur le schéma électronique suivant l'horloge utilise 14 LED, 4 par digit sauf pour les dizaines d'heures qui n'en utilisent que deux.

Horloge à affichage B.C.D.

En gros l'oscillateur interne LFXT1 utilise le crystal 32768Hz branché sur les broches 18 et 19 du MCU. LFXT1 est utilisé comme source pour ACLK qui à son tour cadence le compteur du WDT+. Le WDT+ possède 4 diviseurs: 32768, 8192, 512, 64. Dans cette application j'utilise le diviseur 64 car il faut multiplexer les digits de l'affichage à un fréquence suffisamment élevée pour éviter le scintillement. Avec ce diviseur il y a 512 interruptions par seconde. Le programme est configuré de sorte que la fonction display_time() est appelée à chaque interruption pour afficher un seul digit. La variable q est incrémentée de sorte qu'à l'appel suivant se sera un autre digit qui sera affiché. Le multiplexeur d'affichage fonctionne donc à 512Hz.

En ce qui concerne le crystal installé sur les broches 18 et 19 normalement on devrait aussi installer 2 condensateurs entre Vss et chaque broche pour que l'oscillateur fonctionne. Mais le msp430 a des condensateurs internes. Il y a 4 valeurs de condensateurs: 1pF, 6pF, 10pF et 12,5pF. La sélection de la valeur se fait par les bits XCAPx dans le SFR BCSCTL3. la ligne
BCSCTL3 = XCAP_3;
permet de sélectionner les condensateurs de 12,5pF. Les constantes XCAP_0 à XCAP_3 sont définies dans le fichier d'entête.

La configuration du WDT+ se fait par le SFR WDTCTL et encore une fois le fichier d'entête contient une série de constantes qui simplifient la configuration du WDT+ comme minuterie. Il suffit d'affecter une de ces constantes au registre WDTCTL pour que le minuterie soit correctement configurée:

• WDT_ADLY_1000 délais de 1seconde. 1 interruption par seconde.
• WDT_ADLY_250 délais de 250 millisecondes. 4 interruptions par seconde.
• WDT_ADLY_16 délais de ~16 millisecondes. 64 interruptions par seconde.
• WDT_ADLY_1_9 délais de ~1,9 millisecondes. 512 interruptions par seconde.

Ces valeurs de délais ne sont valables que si ACLK=32768hz. Donc à intervalle régulier il y aura une interruption sur le vecteur WDT_VECTOR qui sera générée à condition que les interruptions soient activées par _enable_interrupts() et IE1 |= WDTIE; comme c'est le cas dans ce programme.

La documentation des msp430 mentionne que ça peut prendre plusieurs microsecondes avant que l'oscillateur LFTXT1 devienne stable après la réinitialisation du MCU. Il est donc conseillé de contrôler l'état de l'oscillateur en début de programme avant de continuer. Il existe un bit dans le SFR IE1 qui s'appelle OFIE Oscillator Fault Interrupt Enable. Lorsque ce bit est mis à 1, l'indicateur OFIFG passera à 1 si il y a un problème avec un des oscillateurs du MCU. Si les interruptions sont activées l'interruption sera générée sur le vecteur NMI_VECTOR. Dans ce programme OFIE est mis à 1 juste après avoir activé les interruptions. À ce moment il est douteux que l'oscillateur LFXT1 soit stable, donc l'interruption nmi_() sera déclenchée immédiatement. Cette routine d'interruption remet à zéro l'indicateur OFIFG et après un certain délais vérifie son état à nouveau. Le programme va rester dans cette ISR tant que l'oscillateur ne sera pas stable. Étant donné le rôle fondamental que joue cet oscillateur dans le programme il faut attendre qu'il soit stable avant de continuer.

La logique du programme est simple. Une fois que les interruptions et les E/S sont configurées on appelle la fonction set_time() car après une mise sous tension l'heure doit-être ajustée. Le bouton 1 sert à passer d'un digit à l'autre et le bouton 2 à ajuster la valeur du digit sélectionné. On sais qu'un digit est sélectionné parce que son affichage bascule entre la valeur du digit et tous les LED du groupe allumés. Une pression brève sur le bouton 2 incrémente la valeur du digit. Une pression brève sur le bouton 2 passe au digit suivant. Une pression d'au moins une seconde sur le bouton 1 permet de sortir du mode ajustement de l'heure. Lorsqu'en mode normal une pression d'au moins une seconde sur le bouton 1 remet le programme en mode ajustement de l'heure.

La routine de service d'interruption watchdog_timer() en plus d'incrémenter la variable tick fait la lecture des 2 boutons et ajuste les indicateurs booléens associés qui sont maintenu dans la variable btns_flags. La fonction set_time() ne lit pas l'état des boutons, elle ne vérifie que les indicateurs booléens qui sont dans btns_flags.

code source
/* 2013-07-07 * horloge à affichage B.C.D. * Auteur: Jacques Deschênes * Description: Le crystal 32768Hz doit-être installé sur la carte launchpad * 14 LEDs sont utilisés pour afficher les heures et minutes en format B.C.D. * Le WDT+ est configuré en minuterie et est alimenté par ACLK (32768Hz) * Il est programmé pour déclencher une interruption 512 fois par seconde * A chaque interruption la fonction la variable tick est incrémentée. * Lorsque la valeur de tick atteint 3839 l'heure est incrémentée * d'une minute. le tableau hour[4] conserve l'heure comme suit: * hour[0]= dizaines d'heure * hour[1]= unités d'heure * hour[2]= dizaines de minutes * hour[3]= unités des minutes * Les 4 digits sont multiplexés à l'aide de 4 transistors NPN dont la base est controllée par * les broches P1.0 à P1.3, P1.0 digit le plus significatif et P1.3 le moins * significatif. * Les anodes des 4 LEDS d'un digit sont branchées sur P2.0 à P2.3, P2.0 est le bit * fort et P2.3 le bit faible. * 2 boutons servent à ajuster l'heure comme suit: * sur P1.6 (BTN1) sert à entrer dans le mode time_set et à passer d'un digit à l'autre * sur P1.7 (BTN2) sert à modifier la valeur du digit sélectionné par BTN1. */ #include <msp430.h> #define BTN2 (1<<7) // bouton 2 sur P1.7 #define BTN1 (1<<6) // bouton 1 sur P1.6 #define BTN1_DN 1 // bouton 1 actuellement enfoncé #define BTN1_SHORT 2 // bouton 1 resté enfoncé plus 1/4 de seconde. #define BTN1_LONG 4 // bouton 1 resté enfoncé plus 1 de seconde. #define BTN2_DN 8 // bouton actuellement enfoncé #define BTN2_SHORT 16 // bouton 2 enfoncé plus 1/4 de seconde. #define select_digit(q) (1<<q) volatile unsigned int dly_cnt; // utilisé par ISR nmi_() unsigned char hour[4]; // garde l'heure unsigned short q=0; // quel digit affiché. unsigned int tick=0; // compte les interruptions du WDT+ unsigned char btns_flags; // indicateurs booléens pour les boutons. volatile unsigned int dly_sw1, dly_sw2; // compteur délais utilisés pour les boutons void configure_clock(){//REF: http://www.glitovsky.com/Tutorialv0_3.pdf, page 29 // configure le DCO à 16MHz BCSCTL1 = CALBC1_16MHZ; DCOCTL = CALDCO_16MHZ; }// configure_clock() void display_time(){ // digits multiplexés 512 fois par seconde P2OUT=0; // fonctionne mieux si on met à zéro P1OUT &= 0xf0; // on ne veut pas affecté les autres bits. P1OUT |= select_digit(q); // active le transistor pour ce digit P2OUT=hour[q]; // affiche la valeur B.C.D. pour ce digit. q++; // la prochaine fois se sera le digit suivant. if (q>3) q=0; }// display_time() volatile unsigned char set[4]; // variable temporaire pour l'heure utilisé par set_time() void set_time(){// ajustement de l'heure unsigned char toggle_display, group; set[0]=hour[0]; set[1]=hour[1]; set[2]=hour[2]; set[3]=hour[3]; btns_flags=0; dly_sw1=0; dly_sw2=0; group=0; toggle_display=0; tick=0; while (1){ LPM3; if (!toggle_display){ hour[group] = 15; }else{ hour[group]=set[group]; } display_time(); if (tick > 255){ toggle_display ^= 1; tick=0; } if (!(btns_flags & BTN1_DN)){ if (btns_flags & BTN1_LONG){ btns_flags = 0; break; }else if (btns_flags & BTN1_SHORT){ btns_flags = 0; hour[group]=set[group]; group = ++group & 3; } } if (!(btns_flags & BTN2_DN) && (btns_flags & BTN2_SHORT)){ btns_flags &= ~BTN2_SHORT; switch (group){ case 0: set[0]++; if (set[0]>2) set[0]=0; break; case 1: set[1]++; if (set[0]<2){ if (set[1]>9) set[1]=0; }else{ if (set[1]>3) set[1]=0; } break; case 2: set[2]++; if (set[2]>5) set[2]=0; break; case 3: set[3]++; if (set[3]>9) set[3]=0; break; default:; } dly_sw2=0; } } hour[group]=set[group]; }// set_time() #pragma vector=WDT_VECTOR /* service d'interruption pour la minuterie WDT+ */ __interrupt void watchdog_timer (void) { // WDTIFG est réinitialisé automatiquement. tick++; if (!(P1IN & BTN1)){ btns_flags |= BTN1_DN; dly_sw1++; if (dly_sw1>511) btns_flags |= BTN1_LONG; else if (dly_sw1>127) btns_flags |= BTN1_SHORT; } else{ dly_sw1=0; btns_flags &= ~BTN1_DN; } if (!(P1IN & BTN2)){ dly_sw2++; btns_flags |= BTN2_DN; if (dly_sw2>127) btns_flags |= BTN2_SHORT; } else{ dly_sw2=0; btns_flags &=~BTN2_DN; } LPM3_EXIT; /* sortie du mode Low Power */ } #pragma vector=NMI_VECTOR /* interruption non masquable. Va se produire si * l'oscillateur LFXT1 tombe en panne. */ __interrupt void nmi_ (void) { do { IFG1 &= ~OFIFG; // remet à zéro l'indicateur erreur Osc. for (dly_cnt = 0xFFF0; dly_cnt > 0; dly_cnt--); // délais pour laissé du temps à OFIFG de // se remettre a 1 s'il y a encore faute. } while (IFG1 & OFIFG); // boucle tant qu'il y a erreur IE1 |= OFIE; // réactive l'interruption sur erreur osc. } void main(void) { WDTCTL = WDT_ADLY_1_9; /* utilisation WDT+ comme minuterie alimentée par ACLK, interruption 512 fois par seconde */ configure_clock(); IE1 |= WDTIE; /* active l'interruption sur WDT (Watch Dog Timer Interrupt Enable)*/ BCSCTL3 = XCAP_3; /* 12.5pF pour que LFXT1 fonctionne avec le crystal 32768Hz fourni avec le launchpad */ P1DIR |= 0xf; // 4 bits les plus faibles de P1 en mode sortie P1OUT &= ~0xf; // 4 bits les plus faibles à zéro. P1REN |= (1<<6) + (1<<7); /* résistance d'entrée active sur P1.6 et P1.7 */ P1OUT |= (1<<6) + (1<<7); // Pullup sur P1.6 et P1.7 P2DIR |= 0xf; // 4 bits les plus faibles de P2 en mode sortie P2OUT &= ~0xf; // 4 bits les plus faibles de P2 à zéro. _enable_interrupts(); // activation globale des interruptions IE1 |= OFIE; /* active interruption sur oscillateur défectueux (Oscillator Fault Ineterrupt Enable) */ set_time(); while (1){ LPM3; /* passe en mode Low Power 3 */ display_time(); if (!(btns_flags & BTN1_DN) && (btns_flags & BTN1_LONG)){ set_time(); } if (tick<30719) continue; // pas encore 1 minute de passé. tick=0; hour[3]++; if (hour[3]>9){ hour[3]=0; hour[2]++; if (hour[2]>5){ hour[2]=0; hour[1]++; if (hour[0]<2){ if (hour[1]>9){ hour[1]=0; hour[0]++; } } else if (hour[1]>3){ hour[0]=0; hour[1]=0; } } } } }

Prochaine étape, remplacé l'affichage B.C.D. par un affichage LCD 16x2 que j'ai en main.