430 mania

mon projet de robot autonome

2012-01-08T20:31:00.003+01:00

En avant première, voici une photo de mon robot autonome à base de MSP430.

Le robot possède :
- 2 moteurs à courant continu pour se déplacer,
- 1 capteur de distance,
- et bien sûr, un launchpad MSP430,
- un peu de mécanique (roues, fixations...).

Pour le moment, le robot se déplace dans une pièce en évitant les obstacles. Je rajouterai de nouvelles fonctions par la suite.

Détail de la réalisation dans les prochains articles...

A bientôt !

Les opérateurs logiques en C

2011-11-08T13:57:00.003+01:00

Pour finir notre explication sur notre premier programme, il faut parler des opérateurs logiques en C.

Ils permettent de faire des opérations sur des valeurs booléennes ou sur les bits d'une variable. Une variable booléenne peut prendre 2 valeurs 0 (faux) ou 1 (vrai).

Il existe 4 opérateurs logiques principaux pour traiter des valeurs booléennes :

- le OU (OR en anglais) : A OR B est vrai si A ou B est vrai,

- le ET (AND en anglais) : A AND B est vrai si A et B sont vrais,

- le OU exclusif (XOR en anglais) : A XOR B est vrai si uniquement A ou uniquement B est vrai (mais pas les 2 en même temps),

- la NEGATION (NOT en anglais) : NOT A est vrai si A est faux.

Le tableau suivant regroupe ces informations :

NOT		AND			OR			XOR
Input A	Output Z	Input A	Input B	Output Z	Input A	Input B	Output Z	Input A	Input B	Output Z
0	1	0	0	0	0	0	0	0	0	0
1	0	0	1	0	0	1	1	0	1	1
		1	0	0	1	0	1	1	0	1
		1	1	1	1	1	1	1	1	0

En C, on utilise les signes suivant pour les opérateurs :
- le '!' (point d'exclamation) pour le NOT,
- le '&' (et commercial) pour le AND,
- le '|' (barre verticale) pour le OR,
- le '^' (accent circonflexe) pour le XOR.

par exemple, la ligne suivante :

z = a | b;

signifie que la vaiable z prend la valeur de a OU b (si a ou b sont vrai, alors z sera vrai).

Tous ces opérateurs agissent aussi sur les bits d'une variable. Par exemple dans le programme suivant :

a = 0x48;

b = 0x11;

z = a | b;

la valeur de z prend comme nouvelle valeur 0x48 | 0x11 = 0b01001000 | 0b00010001 = 0b01011001, c'est à dire la valeur 0x59 en hexadécimal.

A présent, revenons à notre premier programme (voir posts précédents). Le corps du programme était le suivant :

// test de P1.3 (boutton poussoir)
if ((P1IN & 0x08)==0)
{
// activation de la LED sur P1.0
P1OUT = 0x01;
}
else
{
// activation de la LED sur P1.6
P1OUT = 0x40;
}

l'instruction "if" en C permet de tester une condition. Ici si (P1IN & 0x08) est égal à 0 , c'est à dire si le bit numéro 3 de P1IN est égal à 0, alors la condition est vraie.
Au passage on remarque que pour le test d'égalité en C, on utilise une syntaxe "==" avec 2 signes "=". Cela permet au compilateur de faire la différence avec l'opérateur d'affectation de valeur qui lui n'utilise qu'un seul signe égale (comme dans a = 0x48).
Donc pour résumer, si le bit 3 de P1IN est nul (c'est à dire si le bouton poussoir est enfoncé), alors on allume la LED sur P1.0. Sinon on allume la LED sur P1.6.

Les ports d'entrée-sortie du MSP430

2011-11-02T12:12:00.016+01:00

Pour expliquer notre premier programme, nous allons tout d'abord rentrer dans l'architecture du MSP430G2231 et parler des ports d'entrée-sortie.

Comme vous l'avez sans doute remarqué, le MSP430G2231 possède 16 pattes. Pour trouver la fonction électrique de chacune de ces pattes, il faut consulter un document qui s'appelle le "datasheet" du MSP430G2231. Chez Texas Instruments, un datasheet est un document qui décrit et qui donne toutes les caractéristiques d'un circuit. Vous pouvez trouver le datasheet du MSP430G2231 au format PDF ici : http://www.ti.com/lit/ds/symlink/msp430g2231.pdf .

Au début du document, vous trouverez la description des pattes du circuit :

La patte 1 est utilisée pour l'alimentation. Elle doit être relié à une source de tension d'environ 3 volts (entre 2 volts et 3.6 volts pour être précis). En général, on utilise du 3.3 volts. Sur le Launchpad elle est déjà reliée au 3.3 volts.

La patte 14 doit être reliée à la masse (0 volts) ou à la broche '-' d'une pile. Sur le Launchpad elle est déjà reliée à la masse.

Les pattes 2 à 9 sont utilisées (entre autre) par le port d'entrée-sortie P1. Ce port d'entrée-sortie possède 8 connections nommées P1.0 à P1.7.

Les pattes 12 et 13 sont utilisées (entre autre) par le port d'entrée-sortie P2 (P2.6 et P2.7).

On voit aussi que certaines pattes ont plusieurs fonctionnalités. Par exemple la patte 12 peut être soit P2.7, soit XOUT (utilisé par un oscillateur externe). Par défaut, à la mise sous tension, ce sont les fonctionnalités des ports d'entrées-sorties qui sont active. Si on veut utiliser une autre fonctionnalité, il faudra écrire une instruction dans le programme pour cela.

Voici un schéma fonctionnel de notre circuit (également tiré du datasheet) :

On retrouve nos 2 pattes d'alimentation (DVCC; DVSS) et nos 2 ports d'entrées-sortie (P1.x et P2.x). On voit également les périphériques internes du microcontrôleur (nous les détaillerons dans un autre post).

C'est bien beau tout ça, mais revenons à nos moutons : c'est quoi donc une patte d'entrée-sortie ?

C'est une patte du microcontrôleur qu'on peut définir soit :

- en entrée : dans ce cas, on peut lire la valeur logique appliqué sur cette tension. Par exemple, si on applique 3 volts sur cette patte, le programme pourra lire la valeur de cette entrée à un '1' logique. Par contre si on met cette entrée à la masse, on lira un '0' logique. Cela permet par exemple de détecter l'appui sur un bouton poussoir.

- en sortie : dans ce cas, le programme peut contrôler la valeur logique sur cette patte. Le programme peut écrire un '1' - on aura alors environ 3 volts sur cette patte. Il peut écrire un '0' - cette pate sera à un potentiel proche de la masse.

Un port d'entrée sortie regroupe plusieurs de ces pattes (par exmple le port P1 regroupe 8 signaux P1.0 à P1.7).

Mais comment peut-on commander les ports d'entrée sortie ?

Pour cela on utilise ce qu'on appelle des registres du micro. Les registres sont des cases mémoires qui sont reliées aux périphériques du micro. Il y a plusieurs centaines de registres dans un MSP430. Il y en a pour les ports d'entrée-sortie, mais aussi pour d'autres périphériques comme les timers, l'UART, les horloges (nous parlerons de ces périphériques un autre jour).

Aujourd'hui, on va s'intéressé à 3 registres du port P1. Leur petits noms sont P1DIR, P1IN et P1OUT.

P1DIR sert à définir la direction des pattes du ports P1 : en entrée ou en sortie. P1DIR est stocké sur 1 octets, c'est à dire sur 8 bits. Chaque bit correspond à une patte (bit 0 pour P1.0, but 1 pour P1.1, etc...). Par définition, un bit ne peut prendre que 2 valeurs 0 ou 1. Les bits à 0 placent la patte correspondante en entrée. Les bits à 1 placent les pattes correspondantes en sortie.

Sur l'image ci-dessus, on voit les 8 bits de P1DIR. Dans cet exemple, on constate que P1.0 et P1.6 sont en sortie. Les autres ports sont en entrée. (sur le Launchpad, les ports P1.0 et P1.6 sont utilisés pour commander les 2 LEDs).

P1OUT sert à définir la valeur effective sur les pattes de sorties. P1OUT contient également 8 bits (ça on s'en doutait !). Un bit à '1' applique une tension proche de VCC ( ici 3.3 volts) sur la patte correspondante. Un bit à '0' applique une tension proche de GND (0 volts) sur la patte correpondante.

P1IN permet de lire les valeurs logiques appliquées sur les pattes (qu'elles soient en entrée ou en sortie).

Maintenant nous allons nous amuser à modifier ces registres grâce au debugger de Code Composer Studio.

Pour cela, déramez Code Composer en utilisant le même workspace que dans le post précédent. Vous devriez tomber sur une fenêtre similaire à la suivante :

On retrouve le programme que nous avions créé dans le post précédent. Si vous n'êtes pas dans cette configuration, suivez les étapes décrites dans le post précédent.

On peut vérifier les propriétés du projet en faisant Project->Properties :

En choisissant l'option "CCS Build", on peut vérifier que le processeur ciblé est bien un MSP430G2231.

Maintenant passons en mode Debug. Pour cela, cliquez sur le petit insecte vert (je l'ai entouré en rouge sur la copie d'écran de l'interface). Bien sûr à ce stade, le Launcpad doit être branché sur un port USB du PC pour que le Debuger puisse communiquer avec lui.

Maintenant nous allons visualiser quelques registres du MSP430 grâce au Debuger. Pour cela : View->Registers

Maintenant, choisissez Port_1_2. En effet nous voulons visualiser les registres liés aux ports d'entrée-sortie :

Oh miracle ! Voici les fameux registres P1IN P1OUT et P1DIR dont nous avons parlé ! :)

On va pouvoir faire joujou. Grâce au débugger on peut directement modifier la valeur de ces registres dans le MSP430.

Commençons par mettre P1.0 et P1.6 en sortie. Pour cela, on modifie P1DIR :

Vous vous rappelez sans doute que P1.0 et P1.6 sont reliés aux 2 LEDs du Launchpad. Maintenant on peut commander ces LEDs grâce à P1OUT. On va les allumer en mettant P1OUT.P0 et P1OUT.P6 à '1' :

Oh magie ! Comme c'est beau ! Notre Launchpad s'illumine :

De la même manière vous avez aussi accès à P1IN pour lire les valeurs en entrée (bien que cet affichage ne soit pas 100% dynamique pour les entrées).

Vous remarquez qu'on a changé les valeurs des registres un bit après l'autre. Dans la vue sur les registres, on peut aussi changer la valeur globale d'un registre (donc plusieurs bits à la fois). Par exemple on aurait pu directement modifier P1DIR en lui donnant la valeur 0x41.

Mais c'est quoi ce 0x ? Le 0x signifie que la valeur est affichée en hexadécimal.... Je vous vois faire une drôle de tête ! Je vais devoir expliquer ce qu'est la représentation hexadécimale qui est beaucoup utilisé pour la programmation des registres.

Compter en hexadécimal :

Dans la vie de tout les jours on utilise la représentation décimale (base 10) pour compter. Cela veut dire qu'on utilise 10 caractères de base pour compter qui sont 0, 1, 2, 3, 4, 5, 6, 7, 8 et 9.

La représentation hexadécimale (base 16) utilise 16 caractère pour compter : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.

Pour vous donner une idée des différences, voici un tableau de conversion décimal vers hexadécimal :

Par exemple 46 en décimal, c'est 0x2E en hexa. En effet 46 = 2*16 + 15. Ce qui donne '2' et 'E' (15) => 0x2E.

Da,s la programmation en C embarqué, on utilisé souvent cette notation. Un des avantages de cette notation est de pouvoir écrire 8 bits sur 2 caractères. En effet avec 8 bits, on peut compter de 0 à 255, ce qui en hexadécimal fait de 0x00 à 0xFF. Notre tableau contient également les équivalence entre hexa et bianire. On remarque que :

0b00000000 = 0x00

0b00000001 = 0x01

0b00000010 = 0x02

0b00000100 = 0x04

0b00001000 = 0x08

0b00001111 = 0x0F

0b00010000 = 0x10

0b00100001 = 0x20

0b01000010 = 0x40

0b10000100 = 0x80

0b11111111 = 0xFF

Pour revenie à P1DIR, on a mis les bits 0 et 6 à 1, ce qui donne :

0b01000001 = 0x41

On retrouve la valeur 0x41 affichée dans notre fenêtre de Debug.

Essayez dès à présent de vous habituer à utiliser la représentation binaire. Vous verrez, cela deviendra vite un automatisme pour vous, et vous en comprendrez les avantages.

Bien sûr ce que nous avons fait grâce au debugger, nous pouvons aussi le faire par le biais d'un programme en C. Reprenons donc notre premier programme pour l'expliquer.

Premier programme

2011-11-01T08:48:00.003+01:00

Ca y est ! Le Launchpad a été livré à la maison. On va pouvoir créer notre premier programme.

Commençons par brancher le Launpad au PC avec le câble USB fourni.

Lorsque le branchement est effectué, une LED verte s'allume et le Launchpad est reconnu pas le PC comme un périphérique USB composite. En effet, la connection USB permet non seulement de faire de l'émulation, mais aussi de créer une interface type port COM vers la liaison série du microcontrôleur. Pour résumer, cela veut dire que dans nos porgrammes, on pourra utiliser le port USB pour afficher des données, ou recevoir des ordres de l'utilisateur. Nous verrons celà dans un tutoriel dédié.

Maintenant que le Launchpad est branché, on peut démarrer un IDE. Commençons donc par lancer Code Composer Studio.

Le programme vous demandera de spécifier un répertoire de travail appelé "workspace". C'est dans ce répertoire que seront stoqués tous vos projets, vos fichiers, vos programmes.

Ensuite une fenêtre de bienvenue "welcome" apparaît. Vous pouvez la fermer. Vous devez alors obtenir cette interface :

A présent, créons notre premier projet. Pour cela, faire File->New->CCS Project.

appelons notre projet "tutoriel1".

Le type du projet est MSP430 puisque c'est notre processeur cible.

Ici, il faut choisir le microcontrôleur que nous voulons utiliser pour notre projet. CCS propose toutes les types de MSP430 existants. Nous choisissons le MSP430G2231, car c'est le nom du microcontrôleur qui est placé sur le Launchpad. Vous pouvez d'ailleurs le vérifier en lisant la référence imprimée sur la puce à 16 pattes.

Voilà, nous avons créé un projet pour le MSP430G2231. Mais à ce stade le projet est vide. Il ne contient aucun programme. Nous allons donc créer un fichier C qui va contenir du code. Pour cela, on va faire File->New->Source File.

Appelons ce fichier "main.c". Ce fichier contiendra la fonction main() qui est la fonction appelée après le démarrage du microcontrôleur.

Plaçons nous dans l'onglet main.c, et ajoutons le code suivant :

#include <msp430.h>

void main(void)
{
// activation des ports P1.0 et P1.6 en sortie
// pour controller les 2 LEDs
P1DIR = 0x41;

while (1)
{
// test de P1.3 (boutton poussoir)
if ((P1IN & 0x08)==0)
{
// activation de la LED sur P1.0
P1OUT = 0x01;
}
else
{
// activation de la LED sur P1.6
P1OUT = 0x40;
}
}
}

Vous pouvez simplement copier-coller le texte du programme vers CCS.
Que fait ce programme ? Lorsque le bouton poussoir est appuyé, il allume la LED rouge sinon, il allume la LED verte. Nous expliquerons les détails du code dans le post suivant.

A présent compilons ce programme. Il faut faire Project->Build Project

En bas de votre fenêtre de code, il y a 2 onglets :
1) Console : cet onglet affiche ce qui se passe lors de votre compilation
2) Problems : cet onglet affiche les éventuelles erreurs ou les avertissements obtenus lors de la compilation.

Si l'onglet "problems" ne contient pas d'erreurs, tout c'est bien passé. Sinon, vérifiez votre code pour voir si il n'y a pas d'erreur de syntaxe, et corrigez les éventuelles erreurs.

Maintenant, nous allons charger le programme vers le microcontrôleur. Pour cela, faites Target->Debug Launch (vous pouvez aussi cliquer sur le petit insecte vert, c'est pareil). Vous passez alors en mode "Debug" :

Il ne vous reste plus qu'à faire Target->Run, et votre programme démarre sur le Launchpad.

Appuyez sur le bouton (P1.3) et vous verrez la LED rouge s'allumer (cela prouve que le programme tourne). Quand vous relâchez le bouton la LED rouge s'éteint et la LED verte se rallume.

Voilà, vous avez exécuté votre premier programme sur le MSP430 du Launchpad.

Dans le prochain post, j'expliquerai en détail ce programme, et je parlerai des ports d'entrée-sortie du MSP430.

Installation des environnements de développment C pour MSP430

2011-10-25T16:48:00.017+02:00

En attendant la livraison de notre Launchpad MSP430, intéressons-nous aux compilateurs C.

Le rôle du compilateur C est de transformer des fichiers codés en langages C vers un fichier binaire en code machine. Ce code machine est le langage de base du microcontrôleur.

En réalité, c'est un peu plus compliqué que cela, car un compilateur C génère du code assembleur (c'est un langage de très bas niveau). Ensuite le code "assembleur" est transformé en code "objet". Pour finir, les fichiers "objets" passent par le "linker" qui va les lier en un fichier binaire. C'est ensuite ce fichier binaire que nous pourrons télécharger dans la mémoire programme (non volatile) du microcontrôleur.

Aujourd'hui, le compilateur C et le linker sont souvent intégrés dans un environnement de développement (appelé aussi IDE en anglais).

Pour le MSP430, les 2 principaux IDE du marché sont :

- Code Composer Studio : c'est l'outil fourni par TEXAS INSTRUMENT. Il est basé sur l'éditeur Eclipse pour ceux qui connaissent. La version gratuite de Code Composer permet de générer des fichiers binaires de taille maximale de 16 Koctets (ce qui est suffisant pour pas mal d'applications sympathiques).

- IAR Embedded Workbench : cet IDE proposé par la société IAR offre de meilleures performances en terme de compilation (le code généré prend souvent moins de place dans la mémoire et est plus rapide en temps d’exécution). La version gratuite de IAR permet de générer des fichiers binaires jusqu'à 4 Koctets.

Passons à l'installation de ces 2 IDE.

1) Installation de Code Composer Studio

Pour trouver cet IDE, allons sur le lien suivant :
http://processors.wiki.ti.com/index.php/Download_CCS

En bas de la page, il y a un bouton pour télécharger la version gratuite (voir copie d'écran ci-dessous) :

Ensuite TEXAS INSTRUMENT vous demandera de vous connecter avec votre compte TI (le même que vous avez créé pour commander le LaunchPad). Si vous n'en possédez pas encore, vous pouvez en créer un.
Ensuite TI vous pose quelques question sur l'usage que vous allez faire de leur produit. Il faut remplir un formulaire qui ressemble à ça :

Pour certains champs que vous ne pouvez pas remplir faute d'information, vous pouvez les compléter par la mention "N/A" (not applicaple).
Ensuite il faut cliquer sur le bouton "Submit" tout en bas de la page.
Une nouvelle page doit apparaître avec un bouton "Download". Cliquez donc sur "Download" pour démarrer le téléchargement.
Cela peut prendre un peu de temps car le fichier d'installation fait plus de 300 Moctets.
Voilà ! Il ne reste plus qu'à décompresser le fichier (avec WinZip par exemple), et à lancer "setup_CCS_MC_Core.exe".

2) Installation de IAR Embedded Workbench

Pour télécharger l'IDE gratuit de IAR, il faut se rendre à l'adresse suivante : http://supp.iar.com/Download/SW/?item=EW430-KS4
En bas de la page, il faut cliquer sur "Continue".
Un formulaire apparaît alors. Il faut donner vos coordonnées puis répondre à quelques questions.
Ensuite, en bas de page, cliquez sur "Submit Registration".
IAR vous envoie alors un email de contenant un lien de confirmation d'inscription.
Sur ce lien, vous pouvez alors télécharger l'IDE :

Cette page contient également un numéro de licence et une clef de licence que vous devrez copier/coller lors de l'installation.

Allons-y ! Mise en place des outils de développement !

2011-10-24T15:27:00.003+02:00

Bon ça y est, on va enfin commencer à créer son petit labo de développement.

Pour cela nous aurons besoin d'un kit de développement pour MSP430 le moins cher possible.

Ca tombe bien, car Texas Instrument propose son MSP430 Launchpad pour moins de 4 euros !
A quoi sert le Launchpad ? Il permet de programmer et d'émuler certains microcontrôleurs de la famille MSP430. Nous expliquerons plus tards ce que sont ces 2 opérations. En gros, le Launchpad permet d’exécuter et de tester des programmes.

Voici une photo du Launchpad :

On peur voir au centre le microcontrôleur posé sur son support. En bas, il y a 2 diodes luminescentes qu'on peut utiliser pour afficher des informations. Il y a également 2 boutons poussoir pour interagir avec l'utilisateur.

En haut de la carte, il y a un port USB qui permet de programmer et de "débugger" le MSP430.

Enfin, à droite et à gauche des points de connections permettent de relier le MSP430 à d'autres périphériques externes.

Le grands avantage du Launchpad est sont prix : $4.30 !

C'est très facile de l'acheter sur le site de TEXAS INSTRUMENT. En plus, les frais de port sont offerts !

Pour l'acheter, c'est ici : https://estore.ti.com/MSP-EXP430G2-MSP430-LaunchPad-Value-Line-Development-kit-P2031.aspx

Il faut clicker sur "Add to Cart", puis sur "Checkout Now".

Ensuite, il faudra créer un compte TI si c'est votre premier achat.

Il faut compter entre 48 et 72 heures pour la livraison.

OK, c'est bien beau me direz-vous. On a une carte électronique avec un MSP430, mais comment peut programmer l'engin ?

Eh bien pour celà, on a besoin d'un "compilateur". Un compilateur est un logiciel qui traduit un langage informatique en code machine compréhensible par le microcontrôleur.

Nous utiliserons un compilateur C, puisque nos programme seront écrit en langage C.

Et là, bonne surprise, il existe des compilateurs gratuits de très bonne qualité pour le MSP430 !

Bref pour $4.30 (launchapd) + $0.0 (compilateur) nous avons un environnement de développement complet pour le MSP430.

Dans mon prochain post, je parlerai des compilateurs et je vous aiderai à installer le votre.

Premiers pas

2011-10-24T08:05:00.002+02:00

Mais au fait, c'est quoi un microcontrôleur ?

C'est très simple. Un microcontrôleur est une puce électronique qui intègre un microprocesseur, de la mémoire non volatile et des périphériques d'entrée-sortie.

Le microprocesseur peut effectuer de opérations, appelées aussi "instructions". L'ensemble des instructions forment un programme. Nous verrons par la suite comment écrire un programme.

Il y a 2 type de mémoires :

- La mémoire volatile : lorsqu'on coupe le courant, ses données sont perdues.

- La mémoire non volatile : ses données sont conservées même en l'absence d'alimentation électrique.

Un microcontrôleur possède ces 2 types de mémoire. Le microcontrôleur sur lequel nous allons travailler s'appelle le MSP430. Il possède une mémoire RAM (volatile) et une mémoire FLASH (non volatile).

Les périphériques d'entrée-sortie permettent au microcontrôleur d'interagir avec le monde physique. Les périphériques standards que l'on retrouve sur le MSP430 sont :

- des ports d'entrée-sortie : permettent de commander une patte de la puce à un niveau logique (0 ou 3 volts par exemple),

- des ports séries : permettent de communiquer avec d'autres puces en leur envoyer des données,

- des timers : permettent de gérer des temporisations et des actions périodiques.

Il y a encore d'autres périphériques. Nous les verrons au fur et à mesure.

Bon tout ça, c'est des mots. Le mieux c'est de passer à la pratique. Ce sera l'objet de mon prochain post !

Ca y est c'est officiel. 430 mania vient d'être créé !

2011-10-23T19:55:00.001+02:00

Bonjour à tous et bienvenu sur mon blog.
Je m'appelle Eric et je suis ingénieur en électronique.
Le but de mon blog est de présenter mes réalisations à base du microcontrôleur MSP430 de Texas Instrument. L'objectif est de permettre à chacun de les refaire ou de les modifier pour s'amuser et pour apprendre. Je présenterai aussi des exemples de programmation embarquée en langage C.
En fait, c'est un peu comme un blog sur la cuisine. Je publierai régulièrement des "recettes" d'électronicien et vous pourez vous en inspirer. Evidemment ces "recettes" ne couterons jamais plus que quelques euros de composants.
Au programme ces prochaines semaines de l'électronique ludique et un peu de robotique.
Alors à bientôt pour notre premier tutoriel ! :)