Gamoover

Forums " WORKSHOP" => Jamma, cablages, contrôleurs, interfaces & hacks => Microcontrôleurs et électronique => Discussion démarrée par: KodeIn le Lundi 23 Mai 2011, 00:58:32 AM

Titre: Launchpad tuto 002 : Leds clignotantes.
Posté par: KodeIn le Lundi 23 Mai 2011, 00:58:32 AM
Comment faire clignoter les deux leds présentes sur le Launchpad?
Pour ce tuto, je vais utiliser le MSP430G2231 (parce qu'il est déjà sur mon launchpad), mais le 2211 fonctionnera tout aussi bien.
Si vous n'avez pas encore fait vos premiers pas avec CCS, je vous invite à aller voir le tuto-001 (http://www.gamoover.net/Forums/index.php?topic=23696.0), qui explique comment installer CCS et comment créer un projet pour MSP430.
Avant d'attaquer le code, il reste encore une étape importante, il va falloir que je vous explique l'architecture physique et logique de ce µC.
(Attention, je vais vous faire chauffer les neurones!)

L'architecture logique et physique du MSP430 sur son LaunchPad
(http://hico-srv022.pixhotel.fr/sites/default/files/gamoovernet/20110523000810-KodeIn-MSP430G2231-Architecture.png)
Comme on peut voir sur le schéma, le µC est équipé de :
Le reste des éléments composants le µC ne nous intéressent pas dans l'immédiat.
Au niveau logique pure, les leds du launchpad sont connectées au port P1, sur les I/O 0 et 6, et du point de vue physique, la led rouge est connectée à la pin 2 qui correspond à P1.0 et  la led verte est connectée à la pin 8 qui correspond à P1.6.

Voici donc en vert, les éléments du µC qu'on va utiliser de manière "volontaire".
(http://hico-srv022.pixhotel.fr/sites/default/files/gamoovernet/20110528015224-KodeIn-tuto2.png)

Maintenant qu'on sait où sont connectées les leds aussi bien au niveau logique que physique, comment passer cette information au µC?
Et bien, il va falloir configurer les registres liés à P1. Sous le nom "barbare" de registre se cachent une série d'adresses de zones mémoire. Pour simplifier, ce sont ces registres qui font l'interface entre la couche logique et la couche physique du µC.
En premier lieu, il nous faut définir le sens des I/O, dans notre cas P1.0 et P1.6 sont des sorties. Le registre qui s'occupe de ça se trouve à l'adresse 0x22, pour simplifier, on l'a nommé "P1DIR" (Port 1 DIRection). Ce registre est un "mot" de 8 bits et chaque bit correspond à un I/0 de P1. Un bit à 1 indique que que l'I/O est une sortie et inversement, un bit à 0 indique une entrée.
Ils faut donc passer les bits 0 et 6 de P1DIR à 1, de cette façon, le µC sait que ses deux pins sont connectées à quelque chose qui attend de recevoir des impulsions.

Ardu, hein?
Mais c'est indispensable d'avoir une bonne idée sur comment les registres fonctionnent pour pouvoir programmer votre µC.
Toutes les actions qui nécessitent une interaction entre le programme et les composants internes - timer, etc. - ou externes via les ports de communication - GPIO, SPI, I²C, etc. - se font via les registres.
Par exemple, pour allumer ou étreindre les leds, il faudra jouer sur le registres "P1OUT".

Maintenant qu'on a une bonne idée de comment ça marche, il est temps de passer au code!

Les mains dans le cambouis... enfin, le code quoi ;)

#include <msp430g2231.h>

Ce fichier .h (header) va nous permettre - par exemple - d'utiliser le nom du registre plutôt que son adresse hexadécimale. Ça rend le code beaucoup plus clair, je vous recommande de TOUJOURS inclure le .h correspondant au µC que vous utilisez.
C'est dans ce fichier que sont définies, par exemple, les valeurs de BIT0 et BIT6 que nous allons utiliser par la suite.
Si on va regarder dans son code, on découvrira que BIT0 est défini à la valeur 0x01 ( 0000‿0001₂ ) et BIT6 à la valeur 0x40 ( 0100‿0000₂).


void main(void)
{

On définit une fonction "main".
Le "void" qui précède "main" indique que la fonction ne renverra rien comme résultat, alors que celui entre parenthèse nous indique que la fonction ne requiert aucune valeur en entrée.


WDTCTL = WDTPW + WDTHOLD;

Alors, ça, c'est le truc le plus "ésotérique" du code. Cette ligne de code désactive le "watchdog timer" - WDT -... Et là, vous allez remarquer qu'une toute petite ligne de code peut mener à une longue explication :D
D'après ce que j'ai pu décrypter, c'est un système qui permet de détecter si le µC est actif ou si son programme l'a planté, si il est planté, le WDT vas redémarrer le µC.
Et, si j'ai bien compris, c'est à nous de gérer cet outil dans notre logiciel, ce qui est au-delà de mes compétences à l'heure actuelle. Donc, pour gagner du temps, j'ai choisi le désactiver purement et simplement.
WDTCTL (WDT ConTroLler) est donc un registre, mais ce registre est protégé. Pour écrire dedans, il faut utiliser le WDTPW (WDT PassWord). Dans notre cas, on souhaite stopper totalement le WDT, d'ou l'usage de la valeur WDTHOLD (HOLD - suspendre) en combinaison avec WDTPW.


P1OUT &= ~(BIT0 + BIT6);

Et là on a droit à une seconde ligne de code rikiki qui va générer une grosse explication!  :D
Donc, dans cette ligne de code, on s'assure que les leds sont éteintes. Pour ce faire, c'est le registre de 8 bits nommé P1OUT (Port 1 sorties) qu'on doit modifier.
L'I/O P1.0 correspondant au bit 0 de P1OUT et P1.6 correspondant au bit 6 de P1OUT, doivent être à 0 pour que les leds soit éteintes dès le démarrage du µC.
P1OUT
BIT 7
BIT 6
BIT 5
BIT 4
BIT 3
BIT 2
BIT 1
BIT 0
Port 1
P1.7
P1.6
P1.5
P1.4
P1.3
P1.2
P1.1
P1.0
Valeur binaire
X
0
X
X
X
X
X
0
(Les valeurs binaires se lisent de droite à gauche, donc le bit 0 est à droite et le bit 7 à gauche. Les X désignent des emplacements où il on se fiche de la valeur binaire.)
Maintenant, pourquoi utilise "&=" et pas simplement "="?
La combinaison &= c'est comme si on faisait "P1DIR = P1DIR & (BIT0 + BIT6)".
L'opérateur & est ce qu'on appelle un opérateur bitwise, il va effectuer l'opération binaire AND bit à bit* sur les deux membres de l'opération.
(* c'est à dire qu'il va effectuer l'opération & entre le bit 0 du premier membre et du second membre, et ensuite la même chose pour tous les autres bits des membres.)
La table de vérité de la fonction AND est la suivante :

BitA BitB BitA&BitB
0
0
0
0
1
0
1
0
0
1
1
1
~ opérateur bitwise NOT : donc si Octet1 = 0100‿0001₂, alors ~(Octet1) = 1011‿1110₂.
Si P1OUT = 0100‿1001₂, alors 0100‿1001₂ & 1011‿1110₂ = 00001000₂ on a bien modifié que les bits qu'on voulait éteindre.


P1DIR |= (BIT0 + BIT6);

Wohooo et de trois!  ;D Ne m'en voulez pas, je vais faire bref!
Ici, on veux configurer P1.0 et P1.6 en tant que sorties.
Et en va s'en assurer grâce à l'opérateur bitwise | correspondant à la fonction binaire OR:

BitA BitB BitA|BitB
0
0
0
0
1
1
1
0
1
1
1
1
Partons du principe que P1DIR vaut 01001000₂, si on applique un OR avec 0100‿0001₂ nous donnera comme résultat 0100‿1001₂.
Le |= nous permet dont de nous assurer que les bits qui doivent être passés à 1 le sont, sans toucher à l'état des autres bits.  ^-


for (;;)
{

Une petite boucle for sans arguments, ce qui veut dire qu'elle va tourner éternellement.
(Généralement, une boucle for se construit de cette façon : for(initialisation d'une variable compteur ; comparaison entre la variable compteur et une autre valeur; incrémentation ou décrémentation de la variable compteur){code à exécuter})
C'est bien utile quand on veut faire des logiciels "à cycles" rapidement et simplement.


P1OUT ^= (BIT0 + BIT6);

Gniiii encore un opérateur bitwiiiise  >:D
Mais je vous rassure, là, je crois bien qu'on les a tous fait  :D
^ c'est l'opération binaire XOR (ou exclusif)

BitA BitB BitA^BitB
0
0
0
0
1
1
1
0
1
1
1
0
Si P1OUT = 0100‿1001₂, alors 0100‿1001₂ ^ 0100‿0001₂ = 0000‿1000₂ on donc inversé l'état des bits désignés par (BIT0 + BIT6) \o/


__delay_cycles(250000);
}
}

Ahhh, ça, c'est une fonction qui permet de stopper pendant 250000 cycles l'exécution du code.
Ça évite d'avoir les leds qui clignotent trop vite.
Vous pouvez jouer avec cette valeur pour provoquer de jolies crises d'épilepsie... je rigole, ne le faites pas!  :-X

Voilà, le code est complet, si vous compilez et programmez votre MSP430 avec ce code, il devrait faire clignoter les deux leds de concert.

Challenge!
Je vous propose de chercher comment modifier le code pour que les leds s'allument alternativement!
La modif très simple, si vous avez bien lu le tuto, vous devriez trouve très rapidement.
S'il vous plait, ne postez pas votre réponse. ^-




Méthodes pour me contacter
Au cas où vous rencontriez une embûche, si vous voulez discuter ou approfondir les explications ou les explorations à propos de ces tutos, voici quelques méthodes pour me contacter :
- par ce sujet
- par MP
- par mail
- par jabber
- par msn
J'utilise la même adresse mail pour msn et jabber: kodein AT reflexd.com (j'essaye d'éviter les moissonneurs automatiques d'adresse ;) ).
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: Iro le Lundi 23 Mai 2011, 09:49:33 AM
Excelllent !!!
Petite question : Serait ce difficile de tourner le projet exemple en quelque chose qui pourrait piloter une led via USB ?
Pourquoi : Déjà cela m'interreserait :D
Et ensuite et surtout on pourrait faire d'une pierre deux coups : Motiver Elsemi pour ajouter le clignotage de Led dans Model 2 Emulator.
<:)
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: KodeIn le Lundi 23 Mai 2011, 10:41:15 AM
C'est faisable, mais les MSP430 prévus pour le launchpad ne sont pas équipés d'un contrôleur USB.
Donc, pour faire communiquer le µC avec l'ordinateur via usb, il va falloir envisager d'utiliser un contrôleur usb externe genre un MAX320E (http://www.maxim-ic.com/app-notes/index.mvp/id/3637) ou l'équivalent chez un autre fondeur.
Ou alors passer à la série des MSP430F55xx, mais là, il faudra un programmateur autre que le launchpad. (cette série de µC n'ont pas la connexion spy-bi-wire)

Pour ne pas prendre la tête à l'utilisateur, on peut même en faire une interface HID (http://en.wikipedia.org/wiki/Human_interface_device) (Human Interface Device) Du coup, pas besoin de s'amuser à écrire des pilotes pour l'OS. Ce qui permettrait d'en faire une interface d'entrée/sortie reconnue comme un joystick, gamepad ou clavier usb générique.

EDIT:
Je pensais, dans le tuto 3 attaquer les interruptions, genre on pousse sur le bouton, les leds se mette à clignoter jusqu'à ce qu'on pousse à nouveau sur le bouton.
Dans le 4, attaquer l'utilisation du timer pour éclairer les leds avec un signal PWM.
Et finalement, dans le 5, créer une liaison SPI avec un driver de LEDs que j'ai eu chez Ti.
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: ɐɹqoƆ‾ɥƃᴉH le Lundi 23 Mai 2011, 10:56:07 AM
Sinon, Iro, ça se fait facilement avec un PIC ^^
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: KodeIn le Lundi 23 Mai 2011, 11:12:08 AM
High_Cobra ... C'est pas faux :D
Y a tout un tas de PIC avec contrôleur USB intégré.
Mais comme il me parlait des MSP, je n'ai pas cherché plus loin  ;)

En plus, si je me rappelle bien, c'est pas très compliqué d'en faire une interface HID.
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: ɐɹqoƆ‾ɥƃᴉH le Lundi 23 Mai 2011, 11:59:25 AM
Avec les PIC, ça se fait en 3 clics et 4 ligne de code :D

Pour les MSP, me suis pas penché dessus...
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: KodeIn le Lundi 23 Mai 2011, 12:02:37 PM
OH MON DIEU JE VIENS DE ME RELIRE  :-X

Bon, quand je disais que "c'est facile d'en faire une interface HID" je parlais des PICs!
Désolé, j'ai cliqué sur soumettre trop vite.

Pour ce qui est des MSP430, je finirai par mater comment il faut faire, un jour... plus tard quoi  =:))
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: KodeIn le Mardi 24 Mai 2011, 04:52:51 AM
Et ben, je suis pas certain d'avoir été très clair...

Pourvu que ça ne fasse pas trop peur aux gens avec le tas de trucs qui ont été introduits dans ce tuto.
J'aurais pu me contenter de mettre les lignes et juste survoler leur fonctionnement, mais il me semblait essentiel de détailler à fond ce qui se passe.

:-\ Les gens, faut pas avoir peur, hein, juste y aller doucement, étapes par étapes. Vérifier qu'on a bien compris avant de passer à la suite.

Je suis quand même bien content, essayer d'expliquer aux autres m'a forcé à m'assurer que j'avais bien compris.
J'espère avoir été capable de partager cette connaissance toute neuve ;)
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: Iro le Mardi 24 Mai 2011, 08:08:14 AM
Naivement,Je pensais que l'interface USB était intégré. C'est le launchpad qui m'a induit en erreur  :P
En fait je pensais plus à la création d'une DLL que n'importe quel programme pourrait utiliser.

Pour les réponses , on ne les postes pas ou c'est une coquille ?
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: KodeIn le Mardi 24 Mai 2011, 08:21:44 AM
Oui, en fait, sur le launchpad, ça n'est pas le µC qu'on met sur le support qui est connecté en USB, mais le "cerveau" du launchpad, un MSP430F1612, via le contrôleur usb TUSB3410. ;)
Les infos de débug qui viennent de ton MSP430, passent par le Spy-Bi-Wire et son interprétées par le MSP430F1612 pour retransmission à l'ordi.

Et pour la solution, je préfère que les gens s'amusent à trouver par eux-même, il me semble que c'est la meilleure technique pour apprendre.
En plus, ça n'est vraiment pas compliqué, à priori, n'importe qui qui a lu et compris un minimum le tuto doit s'en sortir.
A la limite, j'accepte qu'on me file sa solution ou une demande d'aide par MP.
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: Iro le Mardi 24 Mai 2011, 10:11:22 AM
Oui tout à fait.
Ou les réponses pourraient être écrit sur fond noir un peu comme une balise spoil.
Comme cela, c'est accessible pour tous le monde.
Mais on est à pas la possibilité . :o
HC , il existe une balise spoil ?
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: ɐɹqoƆ‾ɥƃᴉH le Mardi 24 Mai 2011, 10:18:49 AM
Ouaip :

Pitufo en string léopard !



En fait non, mais en bricolant on peut faire... Mais je vais voir pour rajouter ça
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: Iro le Mardi 24 Mai 2011, 10:35:48 AM
merci
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: KodeIn le Mardi 24 Mai 2011, 12:54:50 PM
Sinon, globalement, il est compréhensible et accessible aux intéressés, ce tuto?
Avez-vous des remarques concertant une partie sur laquelle je serais passé un peu vite?
Pas trop de (Gawa?:) ou de  ((:((?? ?

J'ai besoins de retour pour savoir si je peux considérer le tuto terminé et passer à la rédaction du suivant.
Normalement, ça sera un tuto plus soft  ;)
On se contentera de rajouter un bouton on/off à nos leds clignotantes.
Par contre, le 004, il va être gratiné... les timers ça va être chaud  :o
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: keube le Mardi 24 Mai 2011, 13:28:38 PM
Quelques remarques de pinaillage sur ton tuto:
- Une bonne habitude à prendre est de fixer la valeur de sortie des pins avant de les configurer en sortie, on évite ainsi de se retrouver avec une valeur inconnue en sortie. Il faudrait donc inverser P1DIR |= (BIT0 + BIT6); et P1OUT &= ~(BIT0 + BIT6);
- évite de faire un + avec tes #defines de valeur de registre, un | est plus sûr: imagine que tu te loupes et que tu écrives P1DIR &= ~(BIT0 + BIT0); au lieu de BIT6. au final tu vas te retrouver avec un P1DIR &= ~BIT1... Ça semble bête sur cet exemple mais avec des lignes comme WDTCTL = WDTPW + WDTHOLD; c'est tout de suite plus prudent.
- je ne suis pas sur que ta présentation de la table de vérité soit des plus adaptées: P1DIR    (BIT0 + BIT6)    P1DIR|(BIT0+BIT6). C'est surtout le BIT0 + BIT6 qui me gêne, il ne vaut en aucun cas 0 ou 1... On a tous compris ce que tu voulais dire mais un débutant pourrait se poser des questions.
Sinon à mon avis il manque le descriptif des ports que tu utilises pour aider à la compréhension. Ça aide à appréhender une datasheet d'un autre micro!

Bon courage pour la suite!
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: KodeIn le Mardi 24 Mai 2011, 14:01:02 PM
Merci pour tes remarques, je vais les prendre en compte et faire les corrections adéquates. (bon, pas tout de suite parce qu'il faut que je réécrive certaines parties, du coup)

Par contre, je pense que je vais conserver les "+" dans le premier tuto, il me semble que c'est plus compréhensible pour les débutants.
Dans les tutos suivant, je modifierai les lignes pour utiliser l'opérateur kivabien (et qui évite les merdages bête).  ;)

Quand tu parles du descriptif des ports, tu veux parler du schéma des composants pilotant chaque pin?
Si c'est bien ça, j'ai peur de rendre le tuto trop complexe et un peu effrayant pour les "nouveaux convertis".
Déjà comme ça, il est pas léger-léger  :P
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: keube le Mardi 24 Mai 2011, 14:26:47 PM
Citation de: KodeIn le Mardi 24 Mai 2011, 14:01:02 PM
Merci pour tes remarques, je vais les prendre en compte et faire les corrections adéquates. (bon, pas tout de suite parce qu'il faut que je réécrive certaines parties, du coup)

Par contre, je pense que je vais conserver les "+" dans le premier tuto, il me semble que c'est plus compréhensible pour les débutants.
Dans les tutos suivant, je modifierai les lignes pour utiliser l'opérateur kivabien (et qui évite les merdages bête).  ;)

Quand tu parles du descriptif des ports, tu veux parler du schéma des composants pilotant chaque pin?
Si c'est bien ça, j'ai peur de rendre le tuto trop complexe et un peu effrayant pour les "nouveaux convertis".
Déjà comme ça, il est pas léger-léger  :P
non juste le descriptif des bits de chacun des registres, qui explique pourquoi tu mets un 0 ou un 1 dedans.
Du coup ton tuto ça me donne envie de programmer ;D
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: KodeIn le Mardi 24 Mai 2011, 21:22:00 PM
Voilà, j'ai modifié un peu le bouzin.
J'ai rajouté une petite table de correspondance entre n° d'I/O et bits de P1OUT vite fait.
Changé les titre des colonnes des tables de vérité, etc...

Puis sinon, c'est bien mon but, motiver les gens à apprendre à manipuler des µC!
Ils sont les couteaux suisses de l'électronique. Ils s'adaptent facilement à des situations très variées.
Et surtout, ils ne coutent pas grand chose par rapport à la puissance disponible.
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: Maitre_Poulpi le Vendredi 27 Mai 2011, 00:43:10 AM
Bon ben tuto fait aussi.
Pour l'instant RAS, je pense avoir à peu près compris (enfin je crois), on va voir la suite.
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: KodeIn le Vendredi 27 Mai 2011, 01:55:04 AM
Si jamais t'as un doute sur un truc, n'hésite pas à le dire.
J'essayerai de te réexpliquer et d'en profiter pour améliorer le tuto :)

Bon je vais considérer que le tuto est bon  ^-
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: Maitre_Poulpi le Vendredi 27 Mai 2011, 10:50:37 AM
Citation de: KodeIn le Vendredi 27 Mai 2011, 01:55:04 AM
Si jamais t'as un doute sur un truc, n'hésite pas à le dire.
J'essayerai de te réexpliquer et d'en profiter pour améliorer le tuto :)

Bon je vais considérer que le tuto est bon  ^-

Oui, j'ai un doute d'avoir compris à 100% l'histoire des opérateurs bitvouizz  :D
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: KodeIn le Vendredi 27 Mai 2011, 11:41:38 AM
Je vais essayer d'éclairer ta lanterne ;)

Elément important à savoir, les opérations bitwise s'effectuent bit à bit. (j'aurais dû le mettre dans le tuto)
Donc, prenons un octet A, un octet B, un octet resultat et l'opérateur & (au hasard) et effectuons "resultat = A & B";
Le bit0 de résultat sera égal au résultat de l'opérateur & entre le bit0 de A et le bit 0 de B.
Le bit1 de résultat ... égal ... & entre ... bit1 de A et ... B.
Et ainsi de suite pour les autres bits.

Une fois qu'on sait ça, l'usage des tables de vérité des 4 opérateurs bitwise devrait être plus évident.
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: Maitre_Poulpi le Vendredi 27 Mai 2011, 12:57:54 PM
Je crois que je viens de comprendre un truc dans le code en fait.
Dis-moi si je me trompe et si je suis clair dans ce que je dis  :D

Dans cette ligne : P1OUT &= ~(BIT0 + BIT6);

En fait, quand on fait référence à un BIT, d'un point de vue code, c'est qu'on le met à 1.
Comme tu as mis l'opérateur ~ (NOT), on l'apelle à 0.
Donc, peut importe le reste des "BIT" puisqu'on y fait pas référence.
Avec l'opérateur &, on teste l'état précédent si BIT0 était à 0 alors BIT0=0 (car 0&0=0) si BIT0 était à 1 alors BIT0=0 (car 1&0=0).

Je sais pas si je suis clair  ;D
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: KodeIn le Vendredi 27 Mai 2011, 13:07:35 PM
Sisi, t'es à peu près aussi clair que moi  =:))

Bon, en fait je te dévoiler la ruse de sioux : derrière BIT0 se cache en fait cette valeur : 0000‿0000‿0000‿0001₂ ou 0x01 ;)
et BIT6 : 0000‿0000‿0100‿0000₂ ou 0x40
donc BIT1 + BIT6 => 0000‿0000‿0100‿0001₂ ou 0x41

J'aurais dû expliquer ça aussi tien!
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: keube le Vendredi 27 Mai 2011, 13:12:24 PM
Citation de: Maitre_Poulpi le Vendredi 27 Mai 2011, 12:57:54 PM
Je crois que je viens de comprendre un truc dans le code en fait.
Dis-moi si je me trompe et si je suis clair dans ce que je dis  :D

Dans cette ligne : P1OUT &= ~(BIT0 + BIT6);

En fait, quand on fait référence à un BIT, d'un point de vue code, c'est qu'on le met à 1.
Comme tu as mis l'opérateur ~ (NOT), on l'apelle à 0.
Donc, peut importe le reste des "BIT" puisqu'on y fait pas référence.
Avec l'opérateur &, on teste l'état précédent si BIT0 était à 0 alors BIT0=0 (car 0&0=0) si BIT0 était à 1 alors BIT0=0 (car 1&0=0).

Je sais pas si je suis clair  ;D
je pense que tu as compris mais on va détailler tout ça:
#define BIT0 0x01 /* en binaire 00000001 */
#define BIT6 0x40 /* en binaire 01000000 */
BIT0 + BIT6 = 0x41 /* en binaire 01000001 */
~(BIT0 + BIT6) = 0xBE /* en binaire 10111110 */
l'opérateur & va donc mettre à 0 les bits 0 et 6 et conserver la valeurs des autres bits:
valeur du port & 10111110 => X0XXXXX0 (X étant la valeur précédente de la pin)
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: Maitre_Poulpi le Vendredi 27 Mai 2011, 13:19:11 PM
Ca devient plus clair.
Ca veut dire aussi que si on ne mettait pas le ~ devant on serait pas sûr que ça mette à 0 car si l'état précédent était 1 ça ferais 1 comme résultat.

Autre question : c'est quoi le ₂ à la fin ?
Titre: Launchpad Tuto-002 : Leds clignotantes.
Posté par: KodeIn le Vendredi 27 Mai 2011, 13:40:12 PM
Le ₂, c'est de cette manière qu'on informe que la suite de 1 et de 0 est en base 2, en binaire quoi.
Sans le ₂, normalement ça signifie qu'on travaille en décimal.
Il me semble que c'est une notation standardisée internationale.
Pour l'octadécimal, on notera [valeur]₈ et de l'hexa, [valeur]₁₆.
Je n'ai pas utilisé cette notation [valeur]₁₆ pour l'hexa parce que dans le code, on a une notation particulière à l'hexadécimal et ça me paraissait plus intéressant de se familiariser directement avec ce système de notation là.

EDIT: Voilà, j'ai rendu ça plus clair dans le tuto, maintenant on apprends que le fichier .h contient la définition, entre-autres, de BIT0 et BIT6 et j'indique leur valeur binaire et hexa. Ça devrait aider à simplifier la compréhension.

Au fait, merci à toi, Maitre_Poulpi, mon beta-testeur (et non testeur bêta  :D).