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.