MSP430 : Faire un blink en utilisant Energia avec un Makefile

Pourquoi diable utiliser autre chose qu'une Arduino ?

La carte Arduino a beaucoup fait parler d'elle sur le web, notamment dans la communauté des makers. A raison, car elle permet une grande facilité de programmation à son prix maintenant accessible. Comptez une poignée d'euros pour des cartes achetées chez des revendeurs chinois (si ils nous lisent, je les remercie car ils rendent l'électronique accessible à tous).

Quand on parle d'Arduino, on parle à la fois de la carte électronique et du logiciel permettant de la programmer. Une carte Arduino c'est avant tout un microcontrôleur AVR sur un circuit imprimé, avec une alimentation et deux trois autres composants autour. Un UART permet de programmer la carte via un simple câble USB. L'utilisation d'un bootloader au niveau du microcontrôleur AVR permet de le reprogrammer via le port série.

Rien de bien méchant, mais le fait est là : ça fonctionne super bien. Peut-être trop bien car j'ai l'impression que beaucoup de makers se limitent à ce genre de cartes alors que le monde des micrôcontroleurs est plein de belles surprises, comme la famille de μC que je vais vous présenter.

Je ne suis pas le seul à vouloir me débarrasser d'Arduino pour passer sur des puces plus récentes et plus puissantes. Des gentils hackers du HAUM pensent également comme moi. J'espère qu'ils seront inspirés par ce billet (d'où le tag haum, pour apparaitre dans le planet).

J'ai que ça à la maison, et à priori je n'en veux pas d'autre. CC BY-SA Arduino.

Et sinon, si vous voulez la vraie raison : j'ai oublié mon Arduino Duemilanove (!) dans un coin et du coup je dois faire avec toutes les autres cartes que j'ai accumulé pour réaliser des projets sympas. C'est en effet la seule carte Arduino en ma possession (et sans doute la dernière, les cartes Arduino sont tout sauf originales).

Présentation de la famille MSP430

Les microcontrôleurs MSP430 de chez Texas Instruments travaillent sur 16 bits et sont réputés pour leurs très faible consommation en mode veille.

Ces caractéristiques non exhaustives sont là pour vous donner une idée. On se situe un tout petit peu au dessus des microcontrôleurs AVR trouvés dans les cartes Arduino, avec un CPU 16 bits au lieu de 8 bits. La page Wikipédia MSP430 (en) liste chaque sous-famille de MSP430 avec ses caractéristiques spécifiques.

Prix à l'unité des microcontrôleurs

Parlons du prix. J'ai acheté ma première fournée chez Farnell il y a quelques temps déjà. On peut trouver un bon modèle MSP430G2553 pour un peu moins de trois euros. Ce qui est rageant chez les fournisseurs d'électronique classiques, c'est que les prix dégressifs nous montrent bien que l'on se fait entuber (comprenne qui pourra) lorsque l'on commande de petites quantités. Ça et les frais de port.

On arrive cependant à trouver des petites quantités au prix du gros chez nos amis chinois qui prennent ça en sortie des lignes de production. Si je rachète des MSP430 plus tard je passerai sans doute par cette alternative.

Il est également possible de demander des samples sur le site de TI. Faites néanmoins attention à ne pas vous déclarer comme étudiant sinon toute demande d'envoi de samples sera refusé. « Independant Developer » semble avoir fonctionné pour moi.

La carte de développement

Pour pouvoir programmer les microcontrôleurs achetés nus, il va falloir utiliser une carte qui va jouer le rôle de programmateur. J'ai pour cela acheté lors de ma commande chez Farnell une carte MSP-EXP430G2 qui fait partie des Launchpads proposées par TI pour se familiariser avec leur gamme de microcontrôleurs.

Carte TI Launchpad MSP430 avec un MSP430G2553 monté

Le fait de rendre le microcontrôleur amovible nous permet de le programmer et de l'incorporer ensuite sur une autre carte faite maison. Une autre possibilité est de brancher les ports de programmation directement sur le microcontrôleur, ce que l'on appelle ICSP : in-circuit serial programming. Pratique pour les boitiers CMS.

Code Composer Studio, dédié aux professionnels

La méthode préconisée par TI pour programmer les MSP430 est d'utiliser leur environnement de développement Code Composer Studio pour MSP basé sur Eclipse (erk). Il est possible de l'utiliser avec le compilateur propriétaire spécialisé de TI ou alors un GCC spécialisé.

Écran de chargement de CCSv7 qu'il est joli

On reconnaitra que le compilateur propriétaire de TI donne des recommandations très pertinentes concernant toutes les optimisations pouvant être apportées au code pour le rendre le moins consommateur d'énergie possible (ce qui est l'objectif principal des MSP430 par rapport aux autres microcontrôleurs du marché). Pour nos besoins non-industriels, utiliser GCC n'est donc pas un problème.

Néanmoins si vous choisissez CCC, il faudra alors programmer les puces en mode « classique », c'est à dire en accédant et modifiant directement les bons registres pour par exemple envoyer un message I2C ou activer une sortie.

Energia, Arduino by TI

Energia est une copie de l'environnement et de l'IDE Arduino, adapté aux microcontrôleurs de chez TI, notamment les MSP430 mais aussi les CC3200 par exemple (bon j'ai essayé sur une carte CC3200 et c'était pas encore ça).

L'avantage de cette solution c'est que l'on retrouve la facilité de programmation d'Arduino et aussi la compatibilité avec de nombreuses bibliothèques existantes (parfois il faut effectuer quelques modifications).

Nous allons donc partir sur cette solution pour réaliser notre premier programme. Pour Archlinux il existe un PKGBUILD sur AUR qui installe le tout dans /opt/energia. Cependant le portage est un peu foireux et l'IDE graphique ne fonctionne pas. Heureusement on peut contourner le problème en utilisant un Makefile.

À cause d'un bug, seul l'écran de chargement d'Energia s'affiche sur Archlinux

Patch de energia-makefile

Voici un petit dépôt contenant le fichier mis à jour. Parmi les problèmes assez bloquants : l'impossibilité d'utiliser un dossier pour les libraries comme c'est le cas par défaut. Il faudra copier le code de toutes les libraries utilisées dans le projet pour l'instant.

Compilation d'un Blink

Vous pouvez trouver le classique exemple Blink.ino dans /opt/energia/examples/01.Basics/Blink/Blink.ino et le copier à côté de votre Makefile pour pouvoir le compiler.

/*
  Blink
  The basic Energia example.
  Turns on an LED on for one second, then off for one second, repeatedly.
  Change the LED define to blink other LEDs.

  Hardware Required:
  * LaunchPad with an LED

  This example code is in the public domain.
*/

// most launchpads have a red LED
#define LED RED_LED

//see pins_energia.h for more LED definitions
//#define LED GREEN_LED

// the setup routine runs once when you press reset:
void setup() {
  // initialize the digital pin as an output.
  pinMode(LED, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(LED, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(LED, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}

Afin de pouvoir compiler avec le Makefile il faut fournir quelques variables d'environnement comme le modèle exact du microcontrôleur MSP430. J'utilise pour cela un fichier env.sh que je source avant de pouvoir lancer la commande make.

# env.sh

export ENERGIADIR=/opt/energia
export ENERGIABOARD=MSP-EXP430G2553LP

Ensuite pour envoyer le programme sur le microcontrôleur on peut appeler make upload qui va faire appel à mspdebug. Je vous invite à vous tourner vers celui-ci pour déboguer facilement votre programme une fois envoyé sur la carte.