msp430 launchpad, partie 3

Une simple modification au programme démo version 2 de la partie 2 de cette série. J'ai remplacé l'affichage binaire par un affichage BCD.

BCD signifie Binary Coded Decimal. Ça consiste à grouper les bits par 4 et à limiter la valeur de chaque groupe à un chiffre entre 0 et 9. Par exemple en binaire le chiffre 52 = 0011 0100 mais en BCD ce serais 0101 0010. Alors qu'en binaire un octet permet de compter de 0 à 255, en BCD on ne peut compter que de 0 à 99.

Le voltage Vdd sur le launchpad est de 3,6 volt. Cette version du programme affiche le voltage à l'entrée P1.3 avec seulement 2 chiffres BCD. Par rapport à la version 2 on perd en résolution mais comme il ne s'agit que d'un démo du principe.

code source voltmètre à affichage BCD:
/* * 2013-07-06 * démo ADC10, voltmètre à affichage BCD * * configuration du DCO à 16Mhz * utilisation d'une interruption * utilistation du DTC (data transfert control) * utilisation du LPM (Low Power Mode) * */ #include <msp430.h> void configure_clock(){//REF: http://www.glitovsky.com/Tutorialv0_3.pdf, page 29 // Set system DCO to 16MHz BCSCTL1 = CALBC1_16MHZ; DCOCTL = CALDCO_16MHZ; // Set LFXT1 to the VLO @ 12kHz BCSCTL3 |= LFXT1S_2; } void delay_ms(unsigned int ms){ while (ms--) __delay_cycles(16000); } /* read_adc() * retourne la moyenne de 8 lectures * la routine utilise le transfert de bloc */ int read_adc(){ volatile static unsigned int voltages[8]; // contient les 8 lectures int i,m; // MCU de retour en mode normal. ADC10DTC1 = 8 ; // 8 lectures ADC10CTL0 &= ~ENC; while (ADC10CTL1 & BUSY); // attend que le périphérique ADC10 soit innocupé (précaution) ADC10SA = (unsigned int)&voltages; // démarre le bloc transfert ADC10CTL0 |= ENC + ADC10SC; // démarre la conversion LPM3; // met le MCU en mode Low Power 0 // exécution suspendu jusqu'à ce que // l'ISR adc10() sorte le MCU // de ce mode. m=0; for (i=0;i<8;i++) m += voltages[i]; return m>>3; // retourne la moyenne m/8 } #pragma vector=ADC10_VECTOR; __interrupt void adc10(void){ // déclenchée à la fin du transfert des 16 lectures dans voltages[] ADC10CTL0 &=~ADC10IFG; // réinitialisation de l'indicateur d'interruption LPM3_EXIT; // sortie du mode Low Power 0 } /* * main.c */ void main() { unsigned char P1, P2; unsigned int voltage,v,d1,d2; WDTCTL = WDTPW | WDTHOLD; // désactivation watchdog timer configure_clock(); P2DIR=0x3F; // bits 0-5 en sortie ADC10AE0 |= 1<<3; // activation ADC canal 3 (sur P1.3) ADC10CTL1 |= INCH_3+CONSEQ_2; // selection canal ADC 3 (sur P1.3) en mode conversion répétition ADC10CTL0 |= ADC10SHT_0+ADC10ON+MSC+ADC10IE; // activation du périphérique en mode multiconversion et de son interruption ADC10DTC0 &= ~ADC10TB; // 1 seul bloc transféré. _enable_interrupts(); // activation interruption globale while (1){ voltage=read_adc(); // lecture ADC sur P1.3 v=voltage*36/1023; // Vdd=3,6 volt d1=(v/10); d2=v%10; P2= (d1<<4)+d2; //P1=(voltage&0x3C0)>>2; // extraction des 4 bits de poids fort //P2=(voltage&0x3F); // extraction des 6 bits de poids faible P2OUT=P2; // P2.0-P2.6 (bits 0 à 6) delay_ms(333); // délais entre chaque lecture } }

Le port P1 n'est plus utilisé pour l'affichage, puisque le voltage maximal est inférieur à 4 volt on peut représenté le chiffre le plus significatif avec seulement 2 bits, P2.4-P2.5 et la fraction décimale utilise les bits P2.0-P2.3.

Comme on travaille avec des entiers et qu'on veut conserver la première décimale de la fraction on multiplie la valeur de la lecture par 36 au lieu de 3,6 ensuite on divise par 1023. Donc la variable v contient le voltage multiplié par 10. On divise donc v par 10 pour obtenir le chiffre le plus significatif qu'on conserve dans la variable d1. Pour obtenir la fraction décimale on prend le modulo de 10 de cette même variable v et on conserve le résultat dans d2. On met ensuite ces 2 digits dans la variable P2 en décalant vers la gauche de 4 bits la valeur de d1. Il ne reste plus qu'à assigner P2 à P2OUT pour afficher le résultat.

Pour quelqu'un qui a l'habitude de lire des nombres binaires en groupant les bits par 4, lire un affichage BCD est presque aussi facile que de lire un affichage 7 segments, surtout si on prend soin de laisser un espace entre chaque groupe de 4 bits.

msp430 launchpad, partie 2

Ces derniers jours j'ai continuer mon exploration du msp430 launchad en m'intéressant plus particulièrement au convertisseur analogue/numérique 10 bits (ADC10) qu'on retrouve sur le MSP430G2553. Associé à ce convertisseur il y a un canal DMA (Direct Memory Access) qui permet de transférer automatiquement sans intervention logicielle une séquence de conversions A/N dans la mémoire RAM. On peut par exemple programmer le périphérique ADC10 pour qu'il effectue une série de conversions sur le même canal ou sur une séquence de canaux. Le DMA permet même de transférer 2 blocs consécutifs. Le MCU peut donc traiter le contenu de l'un pendant que l'autre se rempli. J'ai écris 2 programmes de démonstration. Le premier montre la façon la plus simple d'utiliser l'ADC10 et le second utilise le DTC, LPM et une interruption. On va voir aussi comment configurer le DCO (Digitally Controlled Oscillator) pour modifier la fréquence du Master Clock (MCLK) ainsi que configurer l'Auxiliary Clock (ACLK) pour l'alimenter par l'oscillateur interne basse fréquence (VLO).

Le Basic Clock Module en bref

Commençons d'abord par présenter le BCS (Basic Clock System). Les msp430 ont 3 signaux d'horloges internes, MCLK (Main Clock), SMCLK (Sub-Main Clock) et ACLK (Auxiliary Clock). Le signal MCLK est utilisé pour cadencer le core du MCU et peut aussi être sélectionné pour alimenter un périphérique. Les signaux SMCLK et ACLK servent seulement pour les périphériques. Ces 3 signaux sont alimentés par divers oscillateurs internes ou externe. Il y a 2 à 4 oscillateurs internes le DCOCLK (Digitally Controlled Oscillator), présent sur tous les MSP430, génère un signal haute fréquence jusqu'à 16Mhz. Le LFXT1CLK utilise un Crystal externe à 32768Khz, il est absent sur les MCU à 8 broches. Le XT2LCK, présent sur les MCU avec plus de 20 broches, utilise un Crystal externe haute fréquence (400Khz à 16Mhz). Le VLOCLK (Very Low power Oscillateur), présent sur tous les MSP430 génère un signal à 12Khz. Normalement LFXT1CLK et utilisé avec un Crystal 32768Khz (horloge temps réel) et XT2CLK pour un oscillateur haute fréquence en remplacement du DCOCLK. Le MSP430G2553 n'a pas de XT2CLK donc soit on utilise un oscillateur externe (400Khz à 16Mhz) dont la sortie est branchée sur XIN (broche 19 sur les DIP20) ou le DCO si on veut fonctionner en haute fréquence.

La table suivante montre comment configurer le BCS (Basic Clock System) pour sélectionner un oscillateur pour chacun des 3 signaux d'horloge.

configuration des signaux horloge
signal/ source	MCLCK	SMCLK	ACLK
VLOCLK	BCSCTL2 |= SELM_3; BCSCTL3 |= LFXT1S1; BCSCLT3 &= ~LFXT1S0;	BCSCTL2 |= SELS; BCSCTL3 |= LFXT1S1; BCSCLT3 &= ~LFXT1S0;	BCSCTL3 |= LFXT1S1; BCSCLT3 &= ~LFXT1S0;
LFXT1CLK	BCSCTL2 |= SELM_3; BCSCTL3= ~(LFXT1S0+LFXT1S1);	BCSCTL2 |= SELS; BCSCTL3= ~(LFXT1S0+LFXT1S1);	BCSCTL3= ~(LFXT1S0+LFXT1S1);2
DCOCLCK	BCSCTL2 &= ~SELM_3;2	BCSCTL2 &= ~SELS;2	N/A
XT2CLK1	BCSCTL2 |= SELM_2;	BCSCTL2 |= SELS;	N/A
osc. externe	BCSCTL2 |= SELM_3; BCSCTL3 |= LFXT1S0+LFXT1S1;	BCSCTL2 |= SELS; BCSCTL3 |= LFXT1S0+LFXT1S1;	N/A

1 Certains MCU seulement.
2 état par défaut après une mise sous tension ou une réinitialisation (RESET).

La fréquence de la source qui alimente chacun des MCLK, SMCLK et ACLCK peut-être divisée par 1,2,4 ou 8.

configuration des diviseur de fréquence.
signal/ diviseur	MCLCK	SMCLK	ACLK
1	BCSCTL2 &= ~DIVM_3;	BCSCTL2 &= ~DIVS_3;	BCSCTL1 &=~DIVA_3;
2	BCSCTL2 &= ~DIVM_3; BCSCTL2 |= DIVM_1;	BCSCTL2 &= ~DIVS_3; BCSCTL2 |=DIVS_1;	BCSCTL1 &=~DIVA_3; BCSCTL1 |= DIVA_1;
4	BCSCTL2 &= ~DIVM_3; BCSCTL2 |= DIVM_2;	BCSCTL2 &= ~DIVS_3; BCSCTL2 |=DIVS_2;	BCSCTL1 &=~DIVA_3; BCSCTL1 |= DIVA_2;
8	BCSCTL2 |= DIVM_3;	BCSCTL2 |= DIVS_3;	BCSCTL1 |= DIVA_3;

Au démarrage c'est le DCO qui alimente MCLK et SMCLK à une fréquence de ~1Mhz. On peut diviser cette fréquence en utilisant les diviseurs mentionnés dans la table ci-haut mais si on veut au contraire augmenter la fréquence il faut modifier la configuration du DCO. Ça se fait en programmant les SFR DCOCTL et BCSCTL1. Le plus simple est d'utiliser les constantes prédéfinies dans le fichier d'entête du MCU (msp430.h). Il y a une constante pour chacun des registres DCOCTL et BCSCTL1 et pour les fréquences suivantes: 1, 8, 12, 16 Mhz. Voir la fonction configure_clock() dans le programme démo qui suis.

Ceci n'est qu'un résumé, pour plus de détails il faut consulter le document le Family user's guide correspondant au MCU choisi. Pour le MSP430G2553 les documents pdf (en anglais) sont ici.

Voltmètre à affichage binaire

Comme le convertisseur a une résolution de 10 bits j'ai simplement utiliser 10 LEDs pour afficher le résultat de la lecture faite sur le potentiomètre RV1.

Je présente 2 versions de ce démo, la première est illustre la méthode la plus simple d'utiliser le convertisseur analogue/numérique et la deuxième utilise le gestionnaire basse consommation (LPM), une interruption et le transfert d'une séquence de lectures vers la mémoire RAM en utilisant le DTC (Data Transfert Control).

première version

Presque toutes les lignes du code source sont commentées. Les étapes sont les suivantes:

1. Désactivation du WDT
2. Configuration de la fréquence du DCO à 16Mhz par la fonction configure_clock()
3. configuration en sortie des bits P1.4 à P1.7 et P2.0 à P2.5
4. configuration et activation du convertisseur analogue/numérique (ADC10)
5. On entre dans la boucle infinie while (1)
   1. appel de la fonction read_adc()
   2. extraction des bits de poids fort 6 à 9 de la variable voltage vers la variable P1
   3. extraction des bits de poids faible 0-5 de la variable voltage vers la variable P2
   4. affichage 4 bits forts, envoie de P1 vers P1.4-P1.7
   5. affichage 6 bits faibles, envoie de P2 vers P2.0-P2.5
   6. délais 1/3 de seconde avant de boucler

Dans la fonction read_adc() on utilise l'indicateur ADC10IFG pour savoir si la conversion est terminée. En effet même si les interruptions ne sont pas activées l'indicateur est mis à 1 à la fin de chaque conversion. Donc avant de démarrer la conversion on le met à zéro, on démarre la conversion et on attend que ADCIFG revienne à 1.

/* 2013-07-03 * démo ADC10, voltmètre binaire * 10 LED connectés sur P1.4-P1.7 et P2.0-P2.5 servent d'afficheur binaire * Le voltage est lu sur P1.3 et le resultat affiché en binaire * sur les 10 LEDS. */ #include <msp430.h> void configure_clock(){//REF: http://www.glitovsky.com/Tutorialv0_3.pdf, page 29 // configure la fréquence du DCO à 16MHz BCSCTL1 = CALBC1_16MHZ; DCOCTL = CALDCO_16MHZ; // il n'y a pas de crystal sur les broches XIN/XOUT // il faut transférer la source de ACLCK // sur le VLO LFXT1 to the VLO @ 12kHz BCSCTL3 |= LFXT1S_2; } void delay_ms(unsigned int ms){ while (ms--) __delay_cycles(16000); // MCLK=16Mhz } int read_adc(){ ADC10CTL0 &= ~ADC10IFG; // met à zéro l'indicateur d'interruption ADC10CTL0 |= ADC10SC+ENC; // démarre la conversion while (ADC10CTL0 & ADC10IFG==0); // attend la fin de la conversion. return ADC10MEM; // retourne la valeur } /* * main.c */ void main() { unsigned char P1, P2; unsigned int voltage; WDTCTL = WDTPW | WDTHOLD; // désactivation watchdog timer configure_clock(); P1DIR=0xF0; // bits 4 à 7 en sortie P2DIR=0x3F; // bits 0-5 en sortie ADC10AE0 |= 1<<3; // activation ADC canal 3 (sur P1.3) ADC10CTL1 |= INCH_3; // selection canal ADC 3 (sur P1.3) ADC10CTL0 |= ADC10ON; // activation du périphérique ADC10 while (1){ voltage=read_adc(); // lecture ADC sur P1.3 P1=(voltage&0x3C0)>>2; // extraction des 4 bits de poids fort P2=(voltage&0x3F); // extraction des 6 bits de poids faible P1OUT =P1; // affichage lecture sur P1.4-P1.7 (bits 7 à 9) P2OUT=P2; // P2.0-P2.6 (bits 0 à 6) delay_ms(333);// 1/3 de seconde entre chaque lecture. } }

voltmètre version 2

Si vous faites le montage et exécutez la version 1 du programme vous allez constater qu'il y a beaucoup de fluctuation sur les 4 bits faible d'une lecture à l'autre. Ceci est du au fait que les voltages de référence utilisé par le convertisseur sont Vdd/Vss. Hors il y a beaucoup de bruit sur l'alimentation causé par le fonctionnement du MCU lui-même. Le MCU possède 2 références de voltage interne. L'Utilisation d'une référence interne (1,5Volt, 2,5Volt) réduirait grandement ce bruit de fond. Il y a une autre façon de réduire ce bruit de fond et c'est celle que j'ai utilisé dans cette version du démo. Le programme fait 8 lectures consécutives et retourne la moyenne. De plus le MCU est arrêté pendant la lecture. Comme c'est le fonctionnement du core qui est en grande partie responsable des fluctuations sur Vdd le fait de l'arrêter pendant la lecture va forcément réduire le bruit de fond.

/* * 2013-07-04 * démo ADC10, voltmètre binaire version 2 * configuration du DCO à 16Mhz * utilisation d'une interruption * utilistation du DTC (data transfert control) * utilisation du LPM (Low Power Mode) * */ #include <msp430.h> void configure_clock(){//REF: http://www.glitovsky.com/Tutorialv0_3.pdf, page 29 // Set system DCO to 16MHz BCSCTL1 = CALBC1_16MHZ; DCOCTL = CALDCO_16MHZ; // Set LFXT1 to the VLO @ 12kHz BCSCTL3 |= LFXT1S_2; } void delay_ms(unsigned int ms){ while (ms--) __delay_cycles(16000); } /* read_adc() * retourne la moyenne de 8 lectures * la routine utilise le transfert de bloc */ int read_adc(){ volatile static unsigned int voltages[8]; // contient les 8 lectures int i,m; // MCU de retour en mode normal. ADC10DTC1 = 8 ; // 8 lectures ADC10CTL0 &= ~ENC; while (ADC10CTL1 & BUSY); // attend que le périphérique ADC10 soit innocupé (précaution) ADC10SA = (unsigned int)&voltages; // démarre le bloc transfert ADC10CTL0 |= ENC + ADC10SC; // démarre la conversion LPM3; // met le MCU en mode Low Power 0 // exécution suspendu jusqu'à ce que // l'ISR adc10() sorte le MCU // de ce mode. m=0; for (i=0;i<8;i++) m += voltages[i]; return m>>3; // retourne la moyenne m/8 } #pragma vector=ADC10_VECTOR; __interrupt void adc10(void){ // déclenchée à la fin du transfert des 8 lectures dans voltages[] ADC10CTL0 &=~ADC10IFG; // réinitialisation de l'indicateur d'interruption LPM3_EXIT; // sortie du mode Low Power 0 } /* * main.c */ void main() { unsigned char P1, P2; int voltage; WDTCTL = WDTPW | WDTHOLD; // désactivation watchdog timer configure_clock(); P1DIR=0xF0; // bits 4 à 7 en sortie P2DIR=0x3F; // bits 0-5 en sortie ADC10AE0 |= 1<<3; // activation ADC canal 3 (sur P1.3) ADC10CTL1 |= INCH_3+CONSEQ_2; // selection canal ADC 3 (sur P1.3) en mode conversion répétition ADC10CTL0 |= ADC10SHT_0+ADC10ON+MSC+ADC10IE; // activation du périphérique en mode multiconversion et de son interruption ADC10DTC0 &= ~ADC10TB; // 1 seul bloc transféré. _enable_interrupts(); // activation interruption globale while (1){ voltage=read_adc(); // lecture ADC sur P1.3 P1=(voltage&0x3C0)>>2; // extraction des 4 bits de poids fort P2=(voltage&0x3F); // extraction des 6 bits de poids faible P1OUT =P1; // affichage lecture sur P1.4-P1.7 (bits 7 à 9) P2OUT=P2; // P2.0-P2.6 (bits 0 à 6) delay_ms(333); // délais entre chaque lecture } }

Attardons-nous pour commencer aux 4 lignes suivantes:
ADC10CTL1 |= INCH_3+CONSEQ_2; ADC10CTL0 |= ADC10ON+MSC+ADC10IE; ADC10DTC0 &= ~ADC10TB; _enable_interrupts(); Cette version utilise le transfert de bloc vers la RAM donc il faut activer un mode de conversion en séquence. CONSEQ_2 indique une séquence de lectures sur le même canal, INCH_3 dans ce cas ci. Le bit MSC dans ADC10CTL0 active la multi-conversion automatique. Le bit ADC10TB indique si le DTC va transférer 1 ou 2 bloc de lectures. Dans ce cas ci on met le bit à zéro ce qui signifie 1 bloc. On va utiliser l'interruption sur fin de transfert de bloc donc on active l'indicateur d'interruption global en appelant la fonction _enable_interrupts() et en mettant le bit ADC10IE à 1 dans ADC10CTL0.

#pragma vector=ADC10_VECTOR; __interrupt void adc10(void){ // déclenchée à la fin du transfert des 16 lectures dans voltages[] ADC10CTL0 &=~ADC10IFG; // réinitialisation de l'indicateur d'interruption LPM3_EXIT; // sortie du mode Low Power 0 } Les msp430 supportent les interruptions multi-vecteurs. Pour définir une routine d'interruption on commence par indiquer au compilateur quel est le vecteur associé à l'ISR qui suis. C'est fait avec une directive #pragma vector. La directive est suivit par une fonction de la forme __interrupt void nom_isr(void). Notre ISR est très courte, on commence par remettre à zéro l'indicateur ADC10IFG et ensuite la macro LPM3_EXIT indique qu'à la sortie de l'ISR le MCU doit-être remis en mode actif. Normalement si le MCU est dans un mode LPMx lorsqu'une interruption est déclenchée il retourne dans le même mode LPMx à la sortie de l'ISR qui répond à l'interruption. Si on veut que le MCU demeure actif après la sortie de l'ISR comme dans ce cas si on doit l'indiquer par la macro LPMx_EXIT correspondant au mode LPMx initial. Dans notre cas la fonction read_adc()mais le MCU en LPM3 juste après le déclenchement de la série de lectures, donc l'ISR doit utilisez LPM3_EXIT pour réactiver le MCU.

volatile static unsigned int voltages[8]; // contient les 8 lectures int i,m; // MCU de retour en mode normal. ADC10DTC1 = 8 ; // 8 lectures ADC10CTL0 &= ~ENC; // mettre à zéro le bit ENC arrête la conversion en cours s'il y en a une. while (ADC10CTL1 & BUSY); // attend que le périphérique ADC10 soit innocupé (précaution) ADC10SA = (unsigned int)&voltages; // démarre le bloc transfert ADC10CTL0 |= ENC + ADC10SC; // démarre la conversion LPM3; // met le MCU en mode Low Power 0 // exécution suspendu jusqu'à ce que // l'ISR adc10() sorte le MCU // de ce mode. m=0; for (i=0;i<8;i++) m += voltages[i]; // somme des 8 échantillons. return m>>3; // retourne la moyenne m/8 Comme on peut le voir la fonction read_adc() est plus complexe que celle de la version 1. le SFR ADC10DTC1 indique le nombre de lecture consécutives qui seront effectuées. Huit dans ce cas ci. Les 2 lignes suivantes ne servent qu'à s'assurer que le convertisseur n'est pas déjà occupé. La boucle while (ADC10CTL1 & BUSY); attends simplement la libération du périphérique. Au début de la fonction on a déclaré une variable tableau volatile static unsigned int voltages[8]. C'est dans ce tableau que seront transférés les 8 lectures. Le DCT doit savoir où transférer les lectures, on lui indique en mettant l'adresse du tableau dans le SFR ADC10SA. Au moment où cette adresse est écrite dans ce registre la procédure DCT est enclenchée mais pas la série de conversions qui elle est déclenchée en mettant à 1 les bits ENC (enable conversion) et ADC10SC (start conversion) dans ADC10CTL0;

Maintenant on met le MCU en mode LPM3. Dans ce mode le MCU, MCLK, SMCLK, DCO et le générateur DCO sont inactif ce qui a pour effet de réduire la consommation du MCU à presque rien, moins de 1µA¹ pour un Vdd de 3volt. L'ADC10 fonctionne quand même car il utilise son propre oscillateur interne. Notez qu'on peut configurer l'ADC10 pour qu'il utilise MCLK ou SMCLK au lieu de son oscillateur interne mais dans ce cas on ne pourrait pas passé en mode LPM3. C'est l'ISR qui va sortir le MCU du coma par l'exécution de LPM3_EXIT et ce n'est qu'à ce moment que les instructions qui suivent LPM3 dans la fonction read_adc() seront exécutées.

Conclusion

Le convertisseur ADC10 avec le DTC forme un système très sophistiqué dont on a fait qu'effleuré la surface. Il en va de même pour le BCS. Le user's guide pour cette famille de MCU fait plus de 600 pages. On comprendra que je ne reproduirai pas toute cette documentation ici. Comme les fabricants de circuits intégrés traduisent rarement leur documentation en français, il est quasiment essentiel de savoir lire l'anglais. Encore heureux que ce ne soit pas seulement disponible ne chinois.

---

NOTES:
1) Dans ce démo la consommation de courant viens majoritairement des LED donc le fait de mettre le MCU en mode LPM3 ne réduit pas la consommation significativement mais réduit le bruit sur Vdd. Avec la version 2 du programme, lorsque je mets l'entrée P1.3 à zéro volt la lecture oscille entre 1 et 2 alors qu'avec la version 1 ça oscille entre 1 et 4.

présentation du msp430 launchpad

Texas instruments produits plusieurs types de micro-contrôleurs, 8, 16, 32 bits. Ils ont leur propres architecture pour certains d'entre eux alors que pour d'autres ils utilisent le core ARM. Les processeurs msp430 sont des processeurs 16 bits développés par TI et le launchpad est une carte d'évaluation économique qui désigne un ensemble de produits dont le msp430 launchpad. J'ai acheté cette carte d'évaluation il y a plus d'un an alors qu'elle se vendait au prix incroyablement bas de 4,67CAN$ chez Digikey.ca, aujourd'hui elle se vend plus de 11,77CAN$. Le kit contient les éléments suivants:

• La carte d'Évaluation avec embase DIP 20 broches
• 1 MCU MSP430G2553, avec 16Ko flash/512o RAM
• 1 MCU MSP430G2452, avec 8Ko flash/256o RAM
• 1 Crystal 32,768Khz non soudé sur la carte
• 2 connecteurs 10 contacts femelle non soudé sur la carte
• 1 câble mini USB-B
• 1 livret de démarrage rapide

Brève description du core msp430

Le core msp430 est un core 16 bits et son architecture est de type Von Neumann, ce qui signifie que les mémoires programme et donnée sont unifiées contrairement à l'architecture Harvard ou mémoire programme et mémoire donnée sont sur des bus séparés.
Quelques exemples d'architectures Von Neumann:

• Zilog z80
• Intel x86
• TI msp430

Quelques exemples d'architectures Harvard:

• ARM
• MIPS
• Microchip PIC
• Atmel AVR

Un des avantages de l'architecture Von Neumann est que le code peut aussi bien être exécuté à partir de la mémoire RAM que de la mémoire FLASH. Du code machine peut donc être créé à la volé et copié en RAM pour être exécuter.

Le core msp430 possède une banque de registres (16 registres) d'usage général sur le même principe que les AVR, ARM et MIPS mais il possède beaucoup plus de modes d'adressage (7 modes). Ces nombreux modes d'adressage permettent de diminuer le nombres d'instructions. On a donc un processeur qui fonctionne avec un code plus compacte. Contrairement aux AVR le compteur ordinal (Program Counter) et le registre d'états (Status Register) sont installés dans cette banque de registre. Le PC utilise R0 et le SR utilise R2. Le pointeur de pile (SP) utilise R1. R3 est un générateur de constantes. Il reste donc en fait 12 registres d'usage général.

Installation logicielle

Il existe plusieurs environnements de développement qui supportent les MSP430, IAR, CCS, MSPGCC. Texas instruments fourni code composer studio gratuitement avec une limitation de 16Ko de programme flash. Comme le MSP430G2553 a 16Ko de flash ce n'est pas une limitation pour ce processeur. Pour cette présentation je vais donc utiliser la dernière version de CCS disponible en ce moment. CCS est disponible aussi bien pour les plateformes Windows que Linux. Le fichier à télécharger fait plus de 1Go. TI offre aussi une multitude de documents en format PDF, spécifications, guides d'utilisation, notes applicatives. Une fois installé le logiciel s'ouvre sur la page TI resource explorer.

Cet environnement ressemble à tous les IDE du genre et sa prise en main ne présente aucune difficulté pour un programmeur habitué à ce type d'environnement. Cependant je trouve qu'il n'a pas autant de fonctionnalités que le MPLABX. Entre autre l'éditeur n'offre pas la possibilité de modifier la marge gauche (indentation) d'un bloc de texte sélectionné, fonction pourtant très utile.

Premier projet en 'C'

Pour créer un projet on va dans le menu File - New - CCS project

Il suffit de donner un nom au projet dans le champ project name, choisir le modèle de MCU (device) et le modèle de fichier (project templates and examples) et de cliquer sur le bouton Finish.

la carte doit-être branchée à l'ordinateur avec le câble mini USB-B. l'Alimentation de fait par ce câble. Pour ce premier projet j'ai utilisé les 2 LED montés sur la carte 1 rouge sur la broche P1.0, 1 vert sur la broche P1.6 ainsi que la switch S2 sur P1.3. P1 désigne le port E/S et .x désigne le bit sur le port. Il s'agit simplement de faire clignoter en alternance les LEDs ROUGE et VERT. La vitesse de clignotement est modifiée en pressant S2. La vitesse augmente jusqu'au maximum (délais nul) et ralenti à nouveau.

Discription du programme

/* DATE: 2013-06-29 * premier programme sur msp430 launchpad * cligote en alternance LED1 sur P1.0 et LED2 sur P1.6 * la vitesse du clignotement est modifiée par pression successives sur S2 sur P1.3 * * NOTES: * 1) après un reset MCLK et SMCLK sont alimenté par le DCO à ~=1.1Mhz et * ACLCK est alimenté LFXT1CLK à ~=12Khz * 2) si ACLK est utilisé et qu'il n'y a pas de crystal sur LFXT1 il faut * alimenté ACLK par VLOCLK. */ #include <msp430g2553.h> void delay_ms(unsigned int ms); unsigned int read_s2(); int dly, btn_dly; void main(void) { int delta; WDTCTL = WDTPW + WDTHOLD; // désactivation du watchdog timer P1DIR |= BIT0 | BIT6 ; // bit 0 (LED1) et 6 (LED2) de P1 en mode sortie P1OUT |=BIT3 ; // 1 sur P1OUT active le pullup P1DIR &= ~BIT3; // bit 3 (s2) en mode input P1REN |=BIT3; // active resistor sur P1.3 P1OUT &= ~BIT0; // initialise le bit0 à low. P1OUT |= BIT6 ; // initialise le bit6 à high. delta = -10;//valeur de décrément du délais dly=500; // délais initial 0,5 seconde btn_dly=0; // compteur pour intervalle de lecture du bouton. while (1) // boucle infinie { P1OUT ^= BIT0 | BIT6; // inversion des bits 0 et 6 delay_ms(dly); // délais if (read_s2()){ dly += delta; if (dly<=10 || dly >=500) delta = -delta; } } } void delay_ms(unsigned int ms){ while (ms--) __delay_cycles(1000); } unsigned int read_s2(){ if ((P1IN & BIT3)==BIT3){ btn_dly=0; return 0; } else{ btn_dly += dly; if (btn_dly>200){ btn_dly=0; return 1; } } }

Comme dans les autres environnement semblables, TI fournis les fichiers d'entêtes avec les symboles qui permettent d'accéder les registres spéciaux pour programmer les périphériques. C'est la directive #include <msp430g2553.h> qui permet d'intégrer ces définitions au programme. On peut aussi utiliser la directive #include <msp430.h> qui est plus générale et qui fonctionne quel que soit le MCU sélectionné dans la configuration du projet.

La première chose à faire est de désactiver le Watchdog timer pour éviter que le MCU soit continuellement réinitialisé. c'est ce que fait la ligne
WDTCTL = WDTPW + WDTHOLD;

Configuration des ports E/S

Les lignes suivantes servent à configurer les E/S utilisées par l'application. Dans ce programme on utilise seulement le port P1 en mode numérique. Il y a plusieurs SFR (Special Fonction Register) associés à chaque port E/S.

• PxDIR configure le mode entrée(0) ou sortie(1) de chaque bit du port.
• PxOUT détermine le niveau de la sortie sur la broche Vdd/Vss. Mais lorsque le bit est en mode entrée et que le bit correspondant dans PxREN est actif ce registre détermine si la résistance d'entrée est en pullup(1) ou pulldown(0).
• PxIN permet de lire le niveau d'une broche.
• PxREN permet d'activer/désactiver la résistance d'entrée sur une broche.
• PxIE permet d'activer/désactiver l'interruption sur changement d'état de la broche.
• PxIES détermine si l'interruption doit se produire lors d'une transition montante(0) ou descendante(1).
• PxIFG indique s'il y a eu une condition d'interruption(1) sur cette broche. Le bit doit-être remis à zéro dans l'ISR.
• PxSEL et PxSEL2 sélectionne quel est le périphérique associé à la broche.

Tous ces registres sont de la largeur du port, si c'est un port 8 bits ils ont 8 bits, si c'est un port 16 bits ils ont 16 bits car chaque bit de ces registres est en correspondance avec le bit du port à la même position.

Le reste du code est la logique de l'application. On a une boucle infinie à l'intérieure de laquelle l'état de P1.0 et P1.6 est inversé à intervalle régulier déterminer par la valeur de la variable dly. A chaque bouclage on fait la lecture de la switch S2 et si la valeur lue demeure à zéro plus de 200msec on modifie la valeur de dly en additionnant la variable delta à dly. Lorsque dly atteint zéro la valeur de delta est inversée de sorte que dly est incrémenté. Le délais initial est de 0,5 seconde mais en gardant le doigt sur S2 cette valeur diminue graduellement jusqu'à zéro puis ré-augmente jusqu'à 0,5 seconde.

__delay_cycles() utilisé dans la fonction delay_ms() est une macro fournie par le système qui crée une boucle qui compte le nombre de cycles CPU passé en argument. Comme après un RESET le MCLK (master clock) fonctionne à 1Mhz, 1000 cycles donne 1msec. Si on configure le DCO (Digitally Controlled Oscillator) qui alimente MCLK pour une autre fréquence il faut ajuster l'argument de __delay_cycles en conséquence. Par exemple si MCLK est à 8Mhz il faut __delay_cycles(8000) pour obtenir 1msec.

Projet en assembleur

Je voulais savoir si la prise en main de l'assembleur était simple. Les msp430 n'ont que 27 instructions machine auxquelles il faut ajouter 24 instructions synthétiques reconnues par l'assembleur. Par instructions synthétiques on entends des macros simples intégré à l'assembleur. Ces macros sont traduites par l'assembleur en une instruction machine.

Pour créer un projet en assembleur on procède exactement comme pour un projet en 'C' sauf qu'on choisi le gabarie (template) empty assembly-only project. Le projet assembleur est très semblable à celui-qui précède sauf que le délais revient à la valeur initiale (rollover) lorsqu'il atteint zéro au lieu de recroître progressivement. ;------------------------------------------------------------------------------- ; MSP430 Assembler Code Template for use with TI Code Composer Studio ; ; ;------------------------------------------------------------------------------- .cdecls C,LIST,"msp430.h" ; Include device header file ;------------------------------------------------------------------------------- .text ; Assemble into program memory .retain ; Override ELF conditional linking ; and retain current section .retainrefs ; Additionally retain any sections ; that have references to current ; section ;------------------------------------------------------------------------------- RESET mov.w #__STACK_END, SP ; Initialize stackpointer StopWDT mov.w #WDTPW|WDTHOLD,&WDTCTL ; Stop watchdog timer ;------------------------------------------------------------------------------- ; Main loop here ;------------------------------------------------------------------------------- .global _main _main bis.b #01000001b, P1DIR ; bits P1.0 et P1.6 en sortie bis.b #00001000b, P1REN ; active résistance sur P1.3 (s2) bis.b #00001001b, P1OUT ; résistance PULLUP sur (s2) et P1.0 sortie HIGH bic.b #01000000b, P1OUT ; P1.6 sortie LOW mov.w #0xFFFF, R13 ; valeur pour délais mov.w #0xFF, R14 ; décrément délais lorsque S2 est enfoncé. _loop nop xor.b #01000001b, P1OUT ; inverse bits P1.0 et P1.6 mov.w R13, R12 ; delais call #_delay ; appelle sous-routine _delay call #_read_s2 jmp _loop _delay dec.w R12 ; R12 est le compteur de délais jz _delay_end jmp _delay _delay_end ret _read_s2 bit.b #00001000b, P1IN ; read s2 jnz _read_s2_end sub.w R14, R13 ; délais réduis lorsque s2 est enfoncé mov.w R13, R14 ; la valeur du décrément est la valeur and #0xFF00, R14 ; du délais divisé par 256 swpb R14 jnz _read_s2_end ; si décrément==0 mov.w #0xFF, R14 ; réinitalise à 255 _read_s2_end ret ;------------------------------------------------------------------------------- ; Stack Pointer definition ;------------------------------------------------------------------------------- .global __STACK_END .sect .stack ;------------------------------------------------------------------------------- ; Interrupt Vectors ;------------------------------------------------------------------------------- .sect ".reset" ; MSP430 RESET Vector .short RESET

Ce petit programme n'a présenté aucune difficulté particulière. Il n'y aucune variable en RAM, elles sont toutes dans les registres généraux R12,R13,R14. Les mnémoniques sont facile à retenir et il n'y en a que 51. Les instructions arithmétiques et logiques peuvent opérées aussi bien sur des octets que sur des mots 16 bits. On choisi le type d'opérandes par le suffixe .b pour byte (8bits) et .w pour word (16bits). Tous les sauts sont relatifs au compteur ordinal et le déplacement est de 10 bits signé, PC-512 à PC+511. Même les appels de sous-routines (call) sont codées par l'assembleur relativement au PC. Le code est donc totalement relocalisable. Mais il existe aussi un mode d'adressage absolu très utile pour atteindre les registres spéciaux (SFR) qui eux sont toujours à la même adresse.

Conclusion

Je suis très satisfait de cette première expérience avec les msp430. Je n'ai rencontré aucune difficulté majeure. J'ai trouvé toute la documentation dont j'avais besoin et de nombreux exemples. Prise en main facile aussi bien en 'C' qu'en assembleur. De plus le launchpad supporte le débogage matériel. On peut mettre des points d'arrêt dans le code et démarrer la session de débogage. Le code s'exécute directement sur le MCU et on peut examiner les registres, les variables, les SFR, faire du pas à pas. C'est bien plus efficace qu'un simulateur. Avec le support de débogage matériel on sauve beaucoup de temps.

Même si son prix a plus que doublé le msp430 launchpad demeure une carte d'expérimentation très intéressante considérant qu'on a n'a pas besoin d'acheter un programmeur. La carte servant de programmeur on peut enlever le MCU de la carte pour le mettre sur la carte du projet final. En plus on a le débogage matériel. Les adeptes du logiciel libre seront heureux de savoir que les outils msp430gcc supportent toutes les fonctionnalités pour développer sur cette carte et déboguer en matériel.

Les msp430 existent en différent format dont des DIP 14 et 20 broches qui peuvent-être programmés sur cette carte. Il y a aussi des msp430 à 8 broches en format 8SOIC. On peut trouvé des adapteurs pour ce type de boitier, donc on devrait pouvoir les programmer en utilisant la carte launchpad.

Le launchpad n'est pas la seule carte d'expérimentation msp430 vendu par TI. Il y a aussi le ez430-F2013 qui est entièrement contenu dans une clé USB. Le module MCU est séparé du programmeur et peut donc être débranché et utilisé indépendamment de la clé. Les modules MCU se vendent séparément. Il existe aussi une carte d'évaluation en format clé USB sur le même principe mais qui utilise un module radio fréquence EZ430-RF2500 pour les projets Wireless.

Un produit intéressant qui vaut amplement son coût d'achat.