programmation d'un MSP430

[invite57b37f86]

bonjour,
je débute la programmation avec le micro-contrôleurs MSP430, je recontre des problèmes au niveau de la programmation:

void loop()
{
int m=0;
  if(PousOn(P1_5)&& m>=0 && m<5){
   
  m+=1;
  
  }
  else if(PousOn(P1_4)){

  m-=1;}
  else if(m=5){
  digitalWrite(P1_0,HIGH);
  digitalWrite(P1_6,LOW);
  }
  else {
    digitalWrite(P1_6,HIGH);
    digitalWrite(P1_0,LOW);
}}

PousOn est une fonction P1_X c'est les pin.
le problème que j'ai c'est niveau de l'incrémentation et la décrémentation, et j'ai le même problème avec un autre programme ou j'utilise de l'incrémentation.
Merci de me dire ce qu'il faut faire ^_^
-----

[invite8bf8ba05]

Essaye plutôt :

void loop()
 {
  int m=0;
  if( (PousOn(P1_5)==1) && (m>=0) && (m<5) )
   {
   m=m+1;
   }
  else if(PousOn(P1_4)==1)
   {
   m=m-1;
   }
  else if(m==5)
   {
   digitalWrite(P1_0,HIGH);
   digitalWrite(P1_6,LOW);
   }
  else 
   {
   digitalWrite(P1_6,HIGH);
   digitalWrite(P1_0,LOW);
   }
}

[invite57b37f86]

Toujours le même problème !!

[invite8bf8ba05]

Tu as un message d'erreur ?
Tu as essayé de visualisé l'état de la variable m à différente étape ?
Donne le code en entier, le problème est peut-être autre part

[A voir en vidéo sur Futura]

[invite8bf8ba05]

Trouvé !!!

int m=0;
void loop()
 {
  if( (PousOn(P1_5)==1) && (m>=0) && (m<5) )
   {
   m=m+1;
   }
  else if(PousOn(P1_4)==1)
   {
   m=m-1;
   }
  else if(m==5)
   {
   digitalWrite(P1_0,HIGH);
   digitalWrite(P1_6,LOW);
   }
  else 
   {
   digitalWrite(P1_6,HIGH);
   digitalWrite(P1_0,LOW);
   }
}

[invite57b37f86]

j'avais essyé de sortir l'initialisation de m mais j'ai laissé d'autres fautes et je l'ai remit dedans
je simule sur le launchpad ^_^ et ça fonctionne voici le code complet

boolean PousOn(const int Pous) {
  boolean etatPous;
  etatPous= ! digitalRead(Pous)==HIGH;
  return etatPous;
}
void setup()
{
  pinMode(P1_0,OUTPUT);//LED 1
  pinMode(P1_6,OUTPUT);//LED 2
  pinMode(P1_5,INPUT);
  pinMode(P1_4,INPUT);
}
  int m=0;
void loop()
{

  if(PousOn(P1_5)&& (m>=0) && (m<5)){
   
  m++;
  
  }
  else if(PousOn(P1_4)&& (m>0) && (m<=5)){

  m--;}
  if(m==5){
  digitalWrite(P1_0,HIGH);
  digitalWrite(P1_6,LOW);
  }
  else if ((m>=0) &&  (m<5)){
    digitalWrite(P1_6,HIGH);
    digitalWrite(P1_0,LOW);
}
delay(200);
}

[invite8bf8ba05]

j'avais essyé de sortir l'initialisation de m mais j'ai laissé d'autres fautes et je l'ai remit dedans

Dans le code que tu as mis, "int m=0;" est bien à l'extérieur. Du coup tu ne l'as pas remis dedans.
De plus le problème c'est que tu le déclaré à chaque boucle...

ça fonctionne voici le code complet

Impecc

[Murayama]

Bonjour!

Un petit commentaire. Le MSP430 est un processeur spécialisé dans la basse consommation.
Il est donc nécessaire de faire des programmes en conséquence.
Ce que vous avez écrit, je ne doute pas que ça fonctionne bien, mais ce n'est pas
la bonne manière de procéder avec un MSP. La raison est que votre boucle ne fait que
consommer des cycles même quand il n'y a rien à faire. Si vous l'utilisez à la
fréquence de défaut, ce qui est vraisemblablement le cas, la boucle va tourner
avec une fréquence d'horloge de 1MHz et consommera dans les 200µA. Pour quelque chose qui
ne fait que voir l'état d'un bouton de temps en temps, c'est beaucoup.

Voici le code complet d'un programme qui fait la même chose (à peu près). La carte
utilisée est un launchpad de FR5739. Les leds sont sur le port 3, les boutons sur le
port 1. La consommation est inférieure à 1 µA quand on n'appuie pas sur un bouton,
(je crois me souvenir que c'est 250 nA, soit environ 800 fois moins, mais il faudrait vérifier
avec des docs récentes).

Le code qui suit a été compilé avec IAR, mais devrait fonctionner avec CCS.

//    Buttons & LEDs.
//    Pascal @ Kyoto. 2011
//    This is an example showing MSP430's low power mode characteristics.
//    It should be noticed that the program does mostly nothing and that there
//    is no loop in main. It's just an interrupt based program, which means
//    that when there is no interrupt, it does simply nothing.
//
//    What it does:
//    - Increments a static variable "counter" when pressing button 1 until 7,
//      decrements it when pressing button2 until 0.
//    - Displays the result using 3 LEDs.
//
#include "MSP430FR5739.h"

#define    LED1 0x10
#define    LED2 0x20
#define    LED3 0x40
#define    LED4 0x80
#define LEDS    (LED1 | LED2 | LED3 | LED4)

#define    BUTTON1    0x01
#define    BUTTON2 0x02
#define    BUTTONS    (BUTTON1 | BUTTON2)

#define COUNT_MAX    7

char counter;

void main(void) {
    WDTCTL = WDTPW + WDTHOLD;
    counter = 0;            //    Init counter static variable
    P3DIR = LEDS;            //    Set LEDs as output
    P3OUT = 0;                //    Clear all LEDs
    P1DIR &= ~BUTTONS;        //    Set port 1 bit 0 and 1 in input mode
    P1IE = BUTTONS;            //    Enable interrupts on both buttons
    ConfigButtons();
    __bis_SR_register(LPM0_bits + GIE);    //    Enter LPM0 with interrupt
}

#pragma vector=PORT1_VECTOR
__interrupt void Switches1Input(void) {
    _DINT();    //    Avoid nested interrupts
    //    Increment if button1, decrement if button2 between 0 and COUNT_MAX
    if((P1IFG & BUTTON1) && (counter < COUNT_MAX)) counter++;
    else if((P1IFG & BUTTON2) && (counter > 0)) counter --;
    //    Display the result (shift because LEDs are on bits 4 to 7)
    P3OUT = (counter << 4);    //    Display number on LEDS.
    P1IFG &= ~BUTTONS;        //    Reset interrupt flag
    _EINT();                //    Re-enable interrupts
}

D'autre part, les fonctions, c'est bien, mais il ne faut pas en abuser. Par exemple,
PousOn ne fait que regarder l'état d'un port. Si on fait une fonction pour ça, alors
on va mettre en place tout un système dans le code exec, on va pousser des variables
sur la pile, etc, tout ça pour vérifier si le port 1 est haut ou bas.
Je ne sais pas si digitalRead est une fonction ou une macro, mais même problème. Si c'est
une fonction, alors vous aller pousser des variables sur la pile une fois pour PousOn,
et une deuxième fois pour digitalRead. C'est très lourd et ça ne sert à rien.
Au lieu de digitalWrite(P1_0, HIGH), vous pouvez écrire P1OUT = 0x01;
Ceci est exécuté en 3 ou 4 cycles d'horloge.
Pour pinMode, même remarque. Vous pouvez écrire P1DIR |= 0x41;, ce qui en une seule
instruction vous met les bits 1 et 6 du port en sortie. Et de la même façon, P1DIR &= 0x30
vous met les bits 4 et 5 en entrée.

Pascal

PS: votre programme ressemble à de l'Arduino (setup / loop).

[invite57b37f86]

Salut,
comme j'ai mentionné au début je suis qu'un débutant qui suit des cours sur internet sur ce domaine ^_^, donc j'ai pas pigé la moitié du programme que tu viens de donner!!
Pour les déclarations j'ai pas compris aussi même pour la lecture !!

[Murayama]

Bonjour!

comme j'ai mentionné au début je suis qu'un débutant qui suit des cours sur internet sur ce domaine ^_^, donc j'ai pas pigé la moitié du programme que tu viens de donner!!
Pour les déclarations j'ai pas compris aussi même pour la lecture !!

Justement, c'est précisément le moment d'apprendre à l'utiliser correctement.
En fait, je suis serais en peine d'expliquer, mais je vais tout de même essayer.
Il y a tellement de choses à dire en partant de 0...

Le code Arduino n'aide pas pour prendre de bonnes habitudes. Par exemple
vous utlisez des digital_write, digital_read, etc. qui à mon avis ne servent à rien.
Imaginez que vous avez le code suivant:
y = a + b;
Il est toujours possible de créer une fonction "add" pour faire l'addition, mais il
faut bien reconnaître que si vous écrivez y = add(a, b); ce n'est ni plus facile ni
plus clair à lire. Et en plus ça prend plus de temps d'exécution.

Vous n'avez pas compris pour la lecture? La lecture du port, j'imagine.
Bon, dans votre code, vous utilisez digital_read et digital_write. Ce sont des fonctions
(ou peut-être macros vu ce qu'elles font), mais elles sont inutiles. Par exemple,
au lieu de digital_write(PORT1_0, HIGH), vous pouvez directement écrire:
P1OUT = 0x01;
De même, au lieu de digital_write(PORT1_2, LOW), vous pouvez écrire:
P1OUT &= ~0x04;
0x04 est le bit2 en partant de la droite (bit0 = 0x01, bit1 = 0x02, bit2 = 0x04, etc...

Voilà, c'était pour l'écriture. Maintenant la lecture.
On n'utilise maintenant le registre P1IN au lieu de P1OUT.
Au lieu d'écrire if(digital_read(PORT1_0, HIGH)), vous poouvez écrire:
if(P1IN & 0x01)
Et si vous voulez écrire, if(digital_read(PORT1_2, LOW)), vous y gagneriez en
écrivant if(!(P1IN & 0x04)), le ! étant la négation.


1. Definitions
Quand on écrit #define LED1 0x10, cela signifie qu'avant de compiler, un programme qui s'appelle
préprocesseur va remplacer tous les "LED1" par "0x10". Vous pouvez vous amuser
à faire du C français.

#define si if
#define sinon else
#define ben {
#define hein }

si (counter < MAX_COUNT) ben
  counter += 1;
hein
sinon ben
  // Autre  calcul
hein

Ensuite...
0x, c'est la notation hexadécimale. On compte comme ça :
0x00, 0x01, 0x02 ... 0x08, 0x09, 0x0A, 0x0B .... 0x0F, 0x10
et ce sont ici les nombres de 0 à 16.

En binaire, 0x10 donnerait 0001 0000, ce qui veut dire que seul le bit 4 (en partant
de la droite) est à 1. Pour les bits seuls, il faut se souvenir des valeurs en 1, 2, 4, 8.
Exemple des bits 0 à 7: 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80

2. Affecter une valeur à un port
Quand je dis P1OUT = 0x10 (voir plus haut), cela signifie que je mets le bit 4 du port 1
à 1, et tous les autres à 0. J'impose donc la valeur des 8 bits et pas seulement du bit 4.

Si je veux changer 1 seul bit à 1:
ex: mettre le bit 4 à 1: P1OUT |= 0x10;
Le |= ajoute tous les bits du paramètre qui sont à 1, donc le bit 4 uniquement pour 0x10.
Si je veux changer 2 bits, par exemple mettre le bit 0 et le bit 7 à 1:
P1OUT |= 0x81

Si je veux changer 1 seul bit à 0:
ex: mettre le bit 4 à 0: P1OUT &= ~0x10;
le &= écrase tous les bits de P1OUT qui sont en face des 0 du paramètre.
Le seul 0 de ~0x10 est le bit 4, et donc le &= ~0x10 écrase le bit 4.

Dans le code par exemple :
P1DIR &= ~BUTTONS;
je dis que la direction du port 1 doit être entrante (pour le MSP430, entrée = 0,
sortie = 1), donc j'écrase les bits de direction qui correspondent aux 2 boutons.

Ah oui, je vois que j'ai laissé une fonction ConfigButtons qui ne sert plus à rien
dans mon code puisque c'est configuré en 2 lignes. Voir code corrigé à la fin.

Si je reprends ligne par ligne le main:

----------- Programme principal ----------
WDTCTL = WDTPW + WDTHOLD;
Ligne absolument nécessaire pour arrêter le watchdog. Si vous ne savez pas ce que c'est
ce n'est pas grave, mais elle est obligatoire.

counter = 0; // Init counter static variable
Initialiser le compteur à 0 en début de programme. C'est de bonne guerre.

P3DIR = LEDS; // Set LEDs as output
Mettre le port 3 en sortie pour piloter les LEDs. Voir plus haut. Sur la carte que j'avais utilisée,
les leds sont sur le port 3, mais vous devez adapter à votre programme les définitions LED1
LED2, LED3, etc... et le numéro du port.

P3OUT = 0; // Clear all LEDs
Éteindre toutes les leds.

P1DIR &= ~BUTTONS; // Set port 1 bit 0 and 1 in input mode
Mettre le port 1 en entrée pour les boutons.

P1IE = BUTTONS; // Enable interrupts on both buttons
Configurer les interruptions pour les boutons.

__bis_SR_register(LPM0_bits + GIE); // Enter LPM0 with interrupt
Mettre en veille avec attente d'interruption.
Note: le programme main est fini, il n'y a pas de boucle. À chaque fois qu'il y aura une
interruption (un appui de bouton), c'est la fonction d'interruption qui sera appelée.

----------- Fin du Programme principal ----------

----------- Routine d'interruption ----------
#pragma vector=PORT1_VECTOR
Directive pour dire que vous allez déclarer l'interruption du port 1. Vous ne pouvez pas changer
cette ligne et elle doit précéder la déclaration d'interruption.

__interrupt void Switches1Input(void) {
Nom de la routine d'interruption. Vous pouvez mettre n'importe quel nom, mais vous ne
pouvez pas changer __interrupt void

_DINT(); // Avoid nested interrupts
D'une manière générale, vous devez éviter d'avoir une nouvelle interrupton pendant que
vous êtes en train d'en traiter une. Désactiver les interruptions en début de traitement
d'interruption.

// Increment if button1, decrement if button2 between 0 and COUNT_MAX
if((P1IFG & BUTTON1) && (counter < COUNT_MAX)) counter++;
P1IFG est le vecteur d'interruption. Comme c'est configuré pour les bits 0 et 1, les
seules valeurs possibles sont 0x01, 0x02 et (peu probable dans le cas où les 2 boutons
auraient été poussés exactement en même temps) : 0x03
Donc si P1IFG contient le bit de BUTTON1, c'est qu'il y a eu un appui sur le bouton 1.
Donc augmenter le compteur s'il est inférieur à MAX_COUNT.

else if((P1IFG & BUTTON2) && (counter > 0)) counter --;
De même, si P1IFG contient le bouton 2, alors décrémenter le compteur s'il est positif.
Dans tous les autres cas (si on est déjà à 7 et qu'on essaie de monter, ou à 0 et qu'on
essaie de descendre), on ne fait rien.

// Display the result (shift because LEDs are on bits 4 to 7)
P3OUT = (counter << 4); // Display number on LEDS.
Sur la carte utilisée, les leds sont sur les bits 4 à 7. (donc 0x10 à 0xF0). Mais les nombres
que j'obtiens sont entre 0 et 7 inclus (donc 0x00 à 0x07). Si je veux voir le résultat, il faut
le déplacer vers la gauche de 4 bits (donc counter << 4).

P1IFG &= ~BUTTONS; // Reset interrupt flag
Réarmer les interruptions du port 1 (remettre les flags d'interruption à 0).

_EINT(); // Re-enable interrupts
Réautoriser les interriptions maintenant que le traitement est fini.
}
----------- Fin de la routine d'interruption ----------

Voilà!

Pascal

//    Buttons & LEDs.
//    Pascal @ Kyoto. 2011
//    This is an example showing MSP430's low power mode characteristics.
//    It should be noticed that the program does mostly nothing and that there
//    is no loop in main. It's just an interrupt based program, which means
//    that when there is no interrupt, it does simply nothing.
//
//    What it does:
//    - Increments a static variable "counter" when pressing button 1 until 7,
//      decrements it when pressing button2 until 0.
//    - Displays the result using 3 LEDs.
//
#include "MSP430FR5739.h"

#define    LED1 0x10
#define    LED2 0x20
#define    LED3 0x40
#define    LED4 0x80
#define LEDS    (LED1 | LED2 | LED3 | LED4)

#define    BUTTON1    0x01
#define    BUTTON2 0x02
#define    BUTTONS    (BUTTON1 | BUTTON2)

#define COUNT_MAX    7

char counter;

void main(void) {
    WDTCTL = WDTPW + WDTHOLD;
    counter = 0;            //    Init counter static variable
    P3DIR = LEDS;            //    Set LEDs as output
    P3OUT = 0;                //    Clear all LEDs
    P1DIR &= ~BUTTONS;        //    Set port 1 bit 0 and 1 in input mode
    P1IE = BUTTONS;            //    Enable interrupts on both buttons
    __bis_SR_register(LPM0_bits + GIE);    //    Enter LPM0 with interrupt
}

#pragma vector=PORT1_VECTOR
__interrupt void Switches1Input(void) {
    _DINT();    //    Avoid nested interrupts
    //    Increment if button1, decrement if button2 between 0 and COUNT_MAX
    if((P1IFG & BUTTON1) && (counter < COUNT_MAX)) counter++;
    else if((P1IFG & BUTTON2) && (counter > 0)) counter --;
    //    Display the result (shift because LEDs are on bits 4 to 7)
    P3OUT = (counter << 4);    //    Display number on LEDS.
    P1IFG &= ~BUTTONS;        //    Reset interrupt flag
    _EINT();                //    Re-enable interrupts
}