msp430 launchpad, partie 6

Sujets traités:

• Générateur de nombre aléatoire utilisant l'ADC10
• Utilisation de fonctions en assembleur dans un projet en 'C'
• Utilisation du PWM pour contrôler un LED RGB

Générateur de nombres aléatoires

Les générateurs de nombres aléatoires sont très utilisés mais la fonction rand() qu'on retrouve dans la librairie standard 'C' est en fait un PRNG (Pseudo Random Number Generator), c'est à dire une fonction chaotique qui génère une séquence de nombres qui est toujours la même si on démarre avec le même seed. De plus la période d'un tel générateur a une valeur finie, ce qui signifie que la séquence va se répétée identique à elle-même après un certain nombres d'itérations. Un véritable générateur de nombre aléatoire ne peut pas être construit sur un algorithme il doit-être lié à un phénomène réellement aléatoire. Le générateur proposé ici utilise le bruit qui existe dans tout composant électronique pour produire un tel générateur.

Comme mentionné dans un article précédent les msp430 qui sont équipés d'un périphérique ADC10 ont aussi une sonde de température interne. Cette sonde est constituée de 2 diodes en série alimentées par un courant constant. Hors comme tout composant électronique chacune de ces jonctions génère un certain niveau de bruit aléatoire. Comme il y a deux jonctions en série ces bruits s'additionnent. En plus du bruit généré par cette sonde le source qui sert de voltage de référence pour l'ADC a aussi son propre bruit. De plus il faut ajouter le bruit électromagnétique généré par le CPU et de sources externes. Tout ça fait que lorsqu'on fait une lecture avec le convertisseur analogue/numérique les bits les plus faibles fluctuent aléatoirement d'une lecture à l'autre. Lors d'une utilisation normale de l'ADC10 on prend la moyenne de plusieurs lectures pour éliminer ce bruit.

Pour notre générateur aléatoire au contraire on veut se servir de ce bruit pour générer des entiers 16 bits qui auront on l'espère une distribution réellement aléatoire et non répétitive.

Le générateur utilisé dans le démo suivant utilise donc la sonde de température en faisant une série de lectures et en construisant une entier à partir du bit le moins significatif de chaque lecture car c'est celui qui est le plus susceptible de varier aléatoirement puisque son poids ne représente que Vref/1023. Pour un Vref de 1,5 Volt il a donc une valeur de 1,5 millivolt.

Pour obtenir un entier de 16 bits ont fait donc 16 lectures et pour chacune d'elle on ne garde que le bit le plus faible. On accumules les bits dans une variable par décalages successifs.

Le démo utilise ces nombres aléatoires pour changer à intervalle régulier la couleur d'un LED RGB qui est branché sur P2.0, P2.1 et P2.3. Le deuxième timer TA1 est utiliser en mode comparateur pour généner 3 signaux PWM sur ces broches.

/* * 2013-07-12 * auteur: Jacques Deschênes * description: demo PWM * contrôle d'un LED RGB PWM du timer1 * */ #include <msp430.h> #define USE_ASM_RAND #define NO_ADC10_INT extern int adc_rand(unsigned int n); // position des anodes du LED RGB #define RED 1 // (sur P2.0) #define BLUE 2 // (sur P2.1) #define GREEN 4 // (sur P2.2) #define BITS 16 // nombre de bits qui compose le nombre aléatoire /* * rand(unsigned int n) * avec N lectures de la sonde de température interne * on cronstruit un nombre avec le bit * le moins significatif de chaque lecture. */ unsigned int rand(unsigned int n){ unsigned int rn; // nombre aléatoire ADC10CTL1 = INCH_10; // selection sonde température interne #ifdef NO_ADC10_INT ADC10CTL0 = SREF_1+ADC10SHT_1+REFON+ADC10ON; #else ADC10CTL0 = SREF_1+ADC10SHT_1+REFON+ADC10ON+ADC10IE; #endif rn=0; if (n>16) n=16; for (;n;n--){ ADC10CTL0 |= ENC+ADC10SC; #ifdef NO_ADC10_INT while (ADC10CTL1 & ADC10BUSY); #else LPM0; #endif rn = (rn<<1) | (ADC10MEM & 1); } return rn; } // rand() void new_color(){ #ifdef USE_ASM_RAND TA1CCR0=adc_rand(BITS); TA1CCR1=adc_rand(BITS); TA1CCR2=adc_rand(BITS); #else TA1CCR0=rand(BITS); TA1CCR1=rand(BITS); TA1CCR2=rand(BITS); #endif if (TA1CCR0<15) TA1CCR0=15; if (TA1CCR1<15) TA1CCR1=15; if (TA1CCR2<15) TA1CCR2=15; } // new_color() void configure_clock(){ // configure le DCO BCSCTL1 = CALBC1_8MHZ; DCOCTL = CALDCO_8MHZ; } // configure_clock() /* * main.c */ void main(void) { int new_color_dly; WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer configure_clock(); // configuration E/S P2DIR = 0x3F; P2OUT = 0; // configuration TIMER1 // SMCLK, continuous, interruption activé. TA1CTL = TASSEL_2+ID_0+MC_2+TAIE; TA1CCTL0 = CCIE; TA1CCTL1 = CCIE; TA1CCTL2 = CCIE; _enable_interrupts(); new_color(); new_color_dly=0; // délais entre changement de couleur while (1){ new_color_dly++; if ((new_color_dly&63)==0){ new_color(); } LPM0; } } #ifdef NO_ADC10_INT #pragma vector=ADC10_VECTOR __interrupt void adc10_isr(void){ ADC10CTL0 &=~ADC10IFG; LPM0_EXIT; } #endif #pragma vector=TIMER1_A0_VECTOR __interrupt void ccr0_isr(void){ P2OUT &= ~RED; } #pragma vector=TIMER1_A1_VECTOR __interrupt void ccrx_isr(void){ switch (TA1IV){ case TA1IV_TAIFG: P2OUT = RED+BLUE+GREEN; LPM0_EXIT; break; case TA1IV_TACCR1: P2OUT &= ~BLUE; break; case TA1IV_TACCR2: P2OUT &= ~GREEN; break; default:; } } // main()

Assemleur dans un projet en C

Inspiré par le document slaa338.pdf trouvé sur le site de Texas Instruments, j'ai adapté la version assembleur trouvé dans le code de TI pour l'utiliser dans ce démo. C'est une bonne occasion de voir comment on peut utiliser des routines en assembleur dans un projet en C.

; 2013-07-14 ; code extrait d'un example fournis par TI ; REF: document TI slaa338 .cdecls C,LIST, "msp430.h" .text .global adc_rand adc_rand: mov.w R12, R15 ; R15 compteur de boucle mov.w #0, R12 ; initialise RN à 0 mov.w #INCH_10, &ADC10CTL1 mov.w #SREF_1 + ADC10SHT_1 + REFON + ADC10ON, &ADC10CTL0 adcloop: bis.w #ENC + ADC10SC, &ADC10CTL0 sampling: bit.w #ADC10BUSY, &ADC10CTL1 jnz sampling bit.w #0x01, &ADC10MEM rrc.w r12 dec.w r15 jnz adcloop ret

Lorsqu'on ajoute un fichier dont l'extension du nom est .asm dans un projet en C il est reconnu par l'IDE comme un fichier en assembleur.

Conventions à respecter

Pour que ça fonctionne sans problème il faut respecter les conventions de registres et d'appel de sous-routines.

• Les registres R12-R15 sont réservés pour les arguments et la valeur retournée par la routine. Dans notre exemple la fonction en assembleur adc_rand, n'a qu'un seul argument: le nombre de bits que doit avoir le nombre aléatoire généré. Lorsque la fonction est appellée à partir du programme principal cet argument se retrouve dans R12. S'il y avait un deuxième argument il serait dans R13, le troisième dans R14 et le quatrième dans R15. S'il y en a plus de 4 les suivants sont sur la pile.
• Si votre fonction en assembleur utilise les registres R4-R10, elle doit les sauvegardés sur la pile avant de les modifiés et les restaurés avant de quitter.
• La fonction retourne sa valeur dans les registres R12-R15, les même qui servent à recevoir les arguments. Un entier 16 bits est retourné dans R12, un 32 bits dans R12,R13 et un 64 bits dans R12-R15. R12 a le poids le plus faible.
• Un fichier d'entête 'C' peut-être utilisé en mettant son nom dans dans une directive .cdecls
• Votre code assembleur se retrouve dans la section .text
• Les variables et fonctions exportées sont déclarées comme .global et les externes importées de la même façon.
• Si des variables sont définies dans le fichier en assembleur elle doivent l'être dans une section .data pour les variables qui sont initialisées et une section .bss pour les autres.

Test de différentes options

J'ai écris une version en C de la routine adc_rand et j'ai testé les 2. Au départ ma version en 'C' utilisait une interruption et le mode LPM0 mais j'ai constaté que les nombres générés étaient moins aléatoires que pour adc_rand. J'ai donc modifié la fonction pour qu'elle n'utilise pas les interruptions et le mode LPM0 et le résultat est semblable la version en assembleur. Je pense que le fait de mettre le MCU en mode LPM0 réduit le bruit et que la lecture est donc plus stable d'où la moins bonne distribution des nombres avec cette version. Pour cette application il est bon d'avoir du bruit.

Contrôle d'un LED RGB par PWM

Le msp430G2553 a deux minuteries de 16 bits munies chacune de 3 comparateurs. Ces minuteries peuvent-être utilisées en mode capture ou comparateur. En mode capture il s'agit de compter des impulsions durant intervalle de temps fixe. En mode comparateur un registre est incrémenté et sa valeur comparée à celle des 3 registres comparateurs à chaque cycle d'incrémentation. Lorsque les valeurs sont égales, dépendant du mode de fonctionnement, il y en a 4, un état est altéré. Le résultat de la comparaison peut-être utilisé pour altérer l'état d'une broche de sortie sans intervention logiciel. Mais dans ce démo les broches qui alimentent la LED sont contrôlées en logiciel. La minuterie est programmée pour que lorsque le registre TAR atteint la valeur d'un des 3 registres CCR une interruption est déclenchée. a l'intérieur de cette interruption l'état de la broche de sortie est mise à zéro. Lorsque le registre TAR déborde une autre interruption est déclenchée qui elle sert à débuté un nouveau cycle PWM en mettant les 3 anodes de la LED à 1. La période du cycle PWM est de SMCLK/65536 soit 8000000/65536=122Hz.

Il y a 2 vecteurs d'interruption affectés à chaque minuterie. Le premier vecteur est déclenché lorsque TAR==TAxCCR0. Le deuxième vecteur se déclenche pour débordement de TAR, TAR==TAxCCR1 et TAR==TAxCCR2. Pour ce second vecteur on distingue la source de l'interruption en faisant la lecture du registre TAxIV.

Dans une chronique ultérieure je vais donner d'autres exemples d'utilisation des minuteries.

msp430 launchpad, partie 5

Les sujets abordés dans cette chronique sont:

• Opération du MCU en mode burst.
• Utilisation du USCI A en mode UART.
• Sonde de température interne

Contrôle de la consommation électrique

Texas instruments décris la famille des MCU MSP430xxx comme étant de très faible consommation idéal pour l'utilisation dans des appareils à piles. Pour une consommation minimale il faut cependant respecter certains critères:

1. Conserver le MCU en mode suspendu et ne l'activer qu'au besoin. TI appelle ça le burst mode.
2. Faire fonctionner les oscillateurs et les périphériques à la plus basse fréquence possible compte tenu des contraintes de l'application.

Le démo utilise ces principes et consiste à utiliser le périphérique ADC10 pour lire la sonde de température interne au MCU et à transmettre le résultat à l'ordinateur qui est relié au launchpad par un port sériel. J'utilise un Pololu 2301a comme adapteur de niveau. L'adapteur est alimenté directement par la carte launchpad par les broches GND et VCC qui sont à adjacentes à S2 sur la carte. Organisation du programme.

1. À la mise sous tension: initialisation horloge et périphériques.
2. Envoie du message "OK\n" au PC hôte.
3. entre dans la boucle du programme principal.
4. Le MCU est suspendu en attente de réception d'une commande du PC hôte.
5. Lorsqu'un caractère est reçu du PC hôte. l'ISR uart0_rx_isr() réactive le MCU.
6. Le programme vérifie si le caractère reçu est 't'. Sinon remet le MCU en mode suspendu et retourne au point 4.
7. Si reçu 't', sort de la boucle d'attente et lance la lecture de température et remet le MCU en mode suspendu.
8. Lorsque le périphérique ADC10 a terminé sa lecture l'ISR adc10_isr() extrait la valeur qui est dans ADC10MEM dans les 2 variables b1 et b2 et réactive le MCU.
9. L'exécution du programme principal se poursuit par la transmission de b1 et b2 au PC hôte par la fonction uart_tx(). Notez que durant la transmission le MCU est encore suspendu jusqu'à que ce la transmission du caractère soit complétée. C'est l'ISR uart_tx_isr qui réactive le MCU.
10. Le Watchdog timer est configuré en mode minuterie avec délais de 1 seconde et le MCU est encore suspendu jusqu'à l'expiration du délais. Le mcu est réactivé par l'ISR wdt_isr().
11. Le programme retourne au début de la boucle principale (point 3) pour attendre une nouvelle commande 't' du PC hôte.

Le programme a en fait 2 variantes:

1. Lorsque #define LP_MODE3 est défini le MCU est conservé en mode basse consommation LPM3. À ce niveau l'activité du MCU est suspendu et le seul oscillateur en fonction est ACLK. Les périphériques qui fonctionnent dans ce mode doivent utiliser ACLK ou avoir leur propre oscillateur comme l'ADC10. La fréquence du DCO est de 1Mhz. Le générateur baudrate du UART est alimenté par ACLK et le baudrate est à 9600.
2. Lorsque la ligne #define LP_MODE3 est supprimée (ou mise en commentaire), le MCU est suspendu en mode LPM0. À ce niveau l'activité du MCU est suspendu mais le signal SMCLCK est toujours disponible pour les périphérique. Dans cette variante le DCO est configuré à 8Mhz, le générateur baudrate est alimenté par SMCLK et la transmission UART est à 115200 baud. Cette variante consomme plus d'énergie que la première mais permet d'utiliser le UART à vitesse supérieure.

code source /* * 2013-07-09 * Auteur: jacques Deschênes * Description: démo utilisation de la sonde de température intégrée au MCU * et du UART pour envoyé la lecture à un PC */ #include <msp430.h> #define LP_MODE3 // test du mode LPM3 avec UART alimenté par ACLCK et baud 9600 volatile unsigned char b1,b2; // octets résultants du contenu de ADC10MEM // envoyés au PC. void configure_clock(){//REF: http://www.glitovsky.com/Tutorialv0_3.pdf, page 29 // configure le DCO BCSCTL1 = CALBC1_8MHZ; DCOCTL = CALDCO_8MHZ; }// configure_clock() void uart_tx(unsigned char c){ UCA0TXBUF=c; // transmet charactère #ifdef LM_MOD3 LPM3; // arrête le CPU #else LPM0; // attend fin transmission #endif } void main(void) { WDTCTL = WDTPW+WDTHOLD; // désactive le watchdog timer #ifndef LP_MODE3 configure_clock(); #endif BCSCTL3 = XCAP_3; /* sélection des condensateurs internes de 12,5pF pour que LFXT1 fonctionne avec le crystal 32768Hz fourni avec le launchpad */ IE1 |= OFIE; // active interruption sur faute oscillateur. IFG1 |= OFIFG; // pour déclencler l'interrution sur faute oscillateur. _enable_interrupts(); // nmi_isr() va être appellée. _disable_interrupts(); // LFXT1 est prêt mais pas le reste de l'initalisation /*configuration ADC10, * SREF_1, Référence interne 1,5Volt, * ADC10SHT_3, sampling time 64*ADC10CLk * ADC10SR, 50Khz * REFON, Référence interne activé * ADC10ON, périphérique activé * ADC10IE, interruption sur conversion activé */ ADC10CTL1 |= INCH_10; // selection sonde température ADC10CTL0 = SREF_1+ADC10SHT_3+ADC10SR+REFON+ADC10ON+ADC10IE; /* * configuration UART */ P1SEL |= ((1<<1)|(1<<2)); // P1SEL.1 et P1SEL.2 =1, fonction 3 P1SEL2 |= ((1<<1)|(1<<2)); // P1SEL2.1 et P1SEL2.2 = 1, UART /* * valeurs par défaut pour USCA0CTL0 -> mode UART, pas de parity, 8 bits, 1 stop */ UCA0CTL1 |= UCSWRST; // bloque le uart #ifdef LP_MODE3 UCA0CTL1 |= UCSSEL_1; // FRQ_BRCLK=FRQ_ACLK=32768 #else UCA0CTL1 |= UCSSEL_2; // FRQ_BRCLK=FRQ_SMCLK #endif /* * configuration baud rate generator * pour LP_MODE3 BRCLK=32768 et BAUDRATE=9600 * sinon BRCLK=8Mhz et BAURATE=115200 * voir table 15-4 et 15-5 du msp430x2xx user's guide. */ #ifdef LP_MODE3 UCA0BR0 = 3; // diviseur: BRCLK/3 9600BAUD UCA0BR1 = 0; UCA0MCTL = (3<<1); //UCBRFx=0, UCBRSx=3, UCOS16=0 #else UCA0BR0 = 69; // diviseur: BRCLK/69 115200BAUD UCA0BR1 = 0; UCA0MCTL = 4<<1; //UCBRFx=0, UCBRSx=4, UCOS16=0 #endif UCA0CTL1 &= ~UCSWRST; // activation UART UC0IFG &= ~(UCA0TXIFG+UCA0RXIFG); // RAZ indicateurs interruption (précaution) UC0IE |= UCA0TXIE + UCA0RXIE; // interruption sur réception et transmission UART _enable_interrupts(); // maintenant on peut activer les interruptions. uart_tx('O'); uart_tx('K'); uart_tx('\n'); while (1){ do // attend un caractère 't' du PC { // à ce moment si seul UAC0_RX peut déclencher une interruption // et sortir le MCU du mode LPM0 #ifdef LP_MODE3 LPM3; #else LPM0; #endif if (UCA0RXBUF=='t') break; }while (1); ADC10CTL0 |= ENC+ADC10SC; //démarre conversion #ifdef LP_MODE3 LPM3; #else LPM0; #endif uart_tx(b1); uart_tx(b2); //configuration du Watchdog timer en mode minuterie WDTCTL = WDT_ADLY_1000; // minuterie 1 seconde IE1 |= WDTIE; #ifdef LP_MODE3 LPM3; #else LPM0; #endif WDTCTL = WDTPW+WDTHOLD; } } // on peut placer les ISR à la fin // pas besoin de prototypes au début du fichier // car les ISR ne sont par référencées par le programme. #pragma vector=ADC10_VECTOR __interrupt void adc10_isr(void){ ADC10CTL0 &= ~ADC10IFG; // RAZ indicateur d'interruption b1 = ADC10MEM & 0xFF; // sépare les dix bits en b2 = (ADC10MEM & 0x300)>>8; // 2 octets pour transmission #ifdef LP_MODE3 LPM3_EXIT; #else LPM0_EXIT; // sortie mode low power 0 #endif } #pragma vector=USCIAB0RX_VECTOR __interrupt void uart0_rx_isr(void){ UC0IFG &= ~UCA0RXIFG; // RAZ indicateur d'interruption #ifdef LP_MODE3 LPM3_EXIT; #else LPM0_EXIT; // sortie mode low power 0 #endif } #pragma vector=USCIAB0TX_VECTOR __interrupt void uart0_tx_isr(void){ UC0IFG &= ~UCA0TXIFG; // RAZ indicateur d'interruption #ifdef LP_MODE3 LPM3_EXIT; #else LPM0_EXIT; // sortie mode low power 0 #endif } #pragma vector=WDT_VECTOR __interrupt void wdt_isr(void){ #ifdef LP_MODE3 LPM3_EXIT; #else LPM0_EXIT; // sortie mode low power 0 #endif } volatile unsigned int dly_cnt; #pragma vector=NMI_VECTOR __interrupt void nmi_isr(void){ // va rester dans cette ISR tant que LFXT1 ne sera pas stable. do { IFG1 &= ~OFIFG; // remet à zéro l'indicateur erreur Osc. for (dly_cnt = 0xFFF; 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. }

Sonde de température

Les msp430xxx qui ont un convertisseur Analogue/Numérique possèdent une sonde de température intégrée. Une application peut-être conçue pour utiliser cette sonde afin de surveiller la température du chip de silicium et entreprendre une action préventive si cette température atteint un seuil critique. Action qui peut consister à simplement mettre le MCU en mode LPM4. J'ai préparé un deuxième démo (code source à la fin de cette chronique) qui montre comment ça peut-être fait.

Pour utiliser la sonde de température il s'agit simplement de sélectionner le canal d'entrée 10
ADC10CTL1 |= INCH_10;
et à utiliser une référence de voltage interne de 1,5volt
ADC10CTL0 = SREF_1+REFON+ADC10ON;
ou 2,5volt
ADC10CTL0 = SREF_1+REF2_5V+REFON+ADC10ON;

UART

Pour communiquer avec le PC hôte il faut configurer le périphérique USCI (Universal Serial Communication Interface) en mode UART. En fait il y a 2 types de USCI le type A et le type B. Le type A est le plus polyvalent, il peut-être configuré en mode LIN, SPI, UART, IrDA . Le type B ne peut-être configuré qu'en modes I2C ou SPI.

Le démo utilise donc le périphérique UCA0. La partie la plus complexe de la configuration est celle qui concerne le générateur baudrate. Heureusement le guide contient 2 tables 15-4 et 15-5 avec les valeurs nécessaires pour différents BRCLK et différents baudrates standards. Les valeurs utilisées dans ce démo sont extraites de la table 15-4.

Ce démo fait une utilisation très rudimentaire du périphérique, il n'y a aucune gestion d'erreur sur réception ni de vérification du l'état du périphérique. Il faut savoir qu'il est possible de configurer une interruption sur erreur de réception et que le SFR UCA0STAT contient des bits indicateurs d'erreurs et autre conditions.

Le périphérique en tant que tel n'a pas de lignes RTS et CTS si l'application requiert un contrôle de flux matériel celui-ci devra être configuré entièrement en logiciel en réservant 2 E/S pour ces lignes.

Contrôle de la surchauffe

La seule application utile de la sonde de température intégrée au MCU est son utilisation pour contrôler la surchauffe du MCU. Le démo suivant montre comment configurer un tel contrôle. L'application consiste simplement à faire clignoter la LED2 qui est sur la carte. S'il y a surchauffe la LED2 (verte) est éteinte la LED1 (rouge) est allumée et le MCU est placé en mode LPM4. Il devra alors être réinitialisé par le bouton RESET ou une remise sous tension. Pour ce démo j'utilise un seuil d'environ 40°C de sorte q'un séchoir à cheveux peut déclencher la protection.
SEUIL = 1023*Vt/Vref
Vref = 1,5Volt
Vt = 0,00355*T°C + 0,986
Pour 40°C on a SEUIL=770

/* * 2013-07-11 * auteur: Jacques Deschênes * démo: contrôle de la surchauffe du MCU en utilisant la sonde de températeur interne * l'application fait clignoter le LED2 (vert) du launchpad 2 fois/secconde * s'il y a surchauffe le LED2 est éteint et le LED1 (rouge) est allumé * le MCU est placé en mode LPM4, seul un BOR ou un RST peut le réactivé */ #include <msp430.h> #define SEUIL 770 // environ 40 degrés celcius. SEUIL = 1023 * Vt/Vref, Vt= 0,00355*Tc + 0,986 #define LED_VERT (1<<6) // bit port 1 du LED vert #define LED_ROUGE (1<<0) // bit port 1 du LED rouge /* * main.c */ void main(void) { WDTCTL = WDTPW+WDTHOLD; // désactive le watchdog timer BCSCTL3 = XCAP_3; /* sélection des condensateurs internes de 12,5pF pour que LFXT1 fonctionne avec le crystal 32768Hz fourni avec le launchpad */ IE1 |= OFIE; // active interruption sur faute oscillateur. IFG1 |= OFIFG; // pour déclencler l'interruption sur faute oscillateur. _enable_interrupts(); // nmi_isr() va être appellée. _disable_interrupts(); // LFXT1 est prêt mais pas le reste de l'initalisation P1DIR |= LED_VERT; // mode sortie sur P1.6 P1OUT &= ~LED_VERT; // éteint LED vert /*configuration ADC10, * SREF_1, Référence interne 1,5Volt, * ADC10SHT_3, sampling time 64*ADC10CLk * ADC10SR, 50Khz * REFON, Référence interne activé * ADC10ON, périphérique activé * ADC10IE, interruption sur conversion activé */ ADC10CTL1 |= INCH_10; // selection sonde température ADC10CTL0 = SREF_1+ADC10SHT_3+ADC10SR+REFON+ADC10ON+ADC10IE; _enable_interrupts(); while (1){ P1OUT ^= LED_VERT; ADC10CTL0 |= ENC+ADC10SC; //démarre conversion LPM3; //configuration du Watchdog timer en mode minuterie WDTCTL = WDT_ADLY_250; // minuterie 250 msec IE1 |= WDTIE; LPM3; } } #pragma vector=ADC10_VECTOR __interrupt void adc10_isr(void){ ADC10CTL0 &= ~ADC10IFG; // RAZ indicateur d'interruption if (ADC10MEM>SEUIL){ P1DIR = 0; // configure tous les E/S en mode entrée haute impédance P2DIR = 0; P1REN = 0; P2REN = 0; ADC10CTL0 = 0; // périphérique ADC10 et références de voltage désactivés WDTCTL |= WDTPW+WDTHOLD; // watchdog désactivé _disable_interrupts(); // interruptions désactivées P1DIR |= 1; // met P1.0 en mode sortie P1OUT |= 1; //allume LED1 (rouge) LPM4; // met le MCU en mode de la plus basse consommation. } LPM3_EXIT; } #pragma vector=WDT_VECTOR __interrupt void wdt_isr(void){ LPM3_EXIT; } volatile unsigned int dly_cnt; #pragma vector=NMI_VECTOR __interrupt void nmi_isr(void){ // va rester dans cette ISR tant que LFXT1 ne sera pas stable. do { IFG1 &= ~OFIFG; // remet à zéro l'indicateur erreur Osc. for (dly_cnt = 0xFFF; 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. }

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.