Pages: [1] 2   Go Down
Author Topic: Encodeur rotatif Com-10982, un petit peu de code...  (Read 2180 times)
0 Members and 1 Guest are viewing this topic.
Offline Offline
Newbie
*
Karma: 0
Posts: 28
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Bonjour,

Débutant complet en électronique et en programmation, je prépare un projet pour faire de la photo haute vitesse que l'on peut retrouver sur ce forum sous le titre arduino et photo haute vitesse.
Grâce à l'aide reçu, j'ai réussi à construire mon schéma et à écrire quelques lignes de code pour le faire tourner mais j'avoue avoir du mal à trouver comment faire fonctionner mon encodeur rotatif.
Cette petite chose vendu chez sparkfun sous la ref com-10982 rassemble un encodeur 24 clics/tour, un bouton poussoir et une led RVB... Intéressant mais pas simple à programmer pour moi.
 
En m'inspirant de ceci: http://bildr.org/2012/08/rotary-encoder-arduino/
J'en suis arrivé au code suivant qui se compile correctement:

Quote
//Les pins 2&3 ne peuvent être change car ce sont les pins d’interruption.
int encodeurB = 2;  //définition de la broche 2 de la carte en tant que variable, encodeur B
int encodeurA = 3;  //définition de la broche 3 de la carte en tant que variable, encodeur A
int encodeurBouton = 11;  //définition de la broche 11 de la carte en tant que variable, B. poussoir
volatile int retard= 500;  //variable pour mémoriser le temps de retardement appeler à évoluer
volatile long encodeurValue = 0;  //je sais pas ce que c’est mais ça doit être important
long lastencodeurValue = 0 ;  //je sais pas ce que c’est mais ça doit être important
int lastMSB = 0;  //je sais pas ce que c’est mais ça doit être important
int lastLSB = 0;  //je sais pas ce que c’est mais ça doit être important

void setup() {
  
  pinMode(encodeurB, INPUT);  // initialisation de la broche 2 comme étant une entrée
  pinMode(encodeurA, INPUT);  //initialisation de la broche 3 comme étant une entrée
  pinMode(encodeurBouton, INPUT);  //initialisation de la broche 3 comme étant une entrée
  digitalWrite(encodeurB, HIGH);  // initialisation de la broche 2 en pullup
  digitalWrite(encodeurA, HIGH);  // initialisation de la broche 3 en pullup
  digitalWrite(encodeurBouton, HIGH);  // initialisation de la broche 11 en pullup

 //appelle updateEncodeur() quand un changement Haut ou Bas est détécté sur les broches //interrupt 0 (broche 2) ou interrupt 1 (broche 3)
  attachInterrupt(0, updateEncodeur, CHANGE);
  attachInterrupt(1, updateEncodeur, CHANGE);
}

void loop(){
  // déroulement du programme
  if(digitalRead(encodeurBouton)){
    //bouton non poussé
  }else{
    //bouton poussé
  }
     delay(1000); //ou autres actions
  }
 
void updateEncodeur(){
  int MSB = digitalRead(encodeurB); //MSB = most significant bit, bit le plus significatif
  int LSB = digitalRead(encodeurA); //LSB = least significant bit, bit le moins significatif

  int encodeur = (MSB << 1) |LSB; // conversion de la valeur des 2 broches en une valeur unique
  int sum  = (retard << 2) | encodeur; // ajouter à la valeur précédente d’encodeur

  if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011) encodeurValue ++;
  if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000) encodeurValue --;

  retard = encodeur; //stock la nouvelle valeur de retard
}


Jusqu'ici tout va bien...


Tout cela est relatif au schéma suivant:


* SCHEMA.jpg (324.23 KB, 2318x656 - viewed 58 times.)
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 28
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Je continue:

Le code complet devant faire tourner tout le programme se voit augmenter du code suivant, ne prenant pas en compte l'encodeur mais qui semble se compiler également correctement:

Quote
int retard=500; // variable pour mémoriser le temps de retardement
int phototransState = 1;  //variable pour mémoriser l'état du phototrans
const int opto_coupl = 13;   //définition de la broche 13 de la carte en tant que variable
const int led_IR = 7;   //définition de la broche 7 de la carte en tant que variable, masse Led IR
const int phototransmass = 6;   //définition de la broche 6 de la carte en tant que variable, masse phototransistor
const int phototrans = 4;   //définition de la broche 4 de la carte en tant que variable, phototrans

void setup()          //fonction d'initialisation de la carte
{
pinMode(opto_coupl,OUTPUT);   //initialisation de la broche 13 comme étant une sortie
pinMode(led_IR, OUTPUT);   //initialisation de la broche 7 comme étant une sortie
pinMode(phototransmass, OUTPUT);   //initialisation de la broche 6 comme étant une sortie
pinMode(phototrans, INPUT);   //initialisation de la broche 4 comme étant une entrée
}
 
void loop()           //fonction principale, elle se répète à l'infini
{
digitalWrite(led_IR, LOW); //allume LED IR
digitalWrite(phototransmass, LOW);  //allume phototrans
phototransState=digitalRead(phototrans);  //lit la valeur de l'état du phototrans

if(phototransState!=1) //teste si le faisceau  est coupé
{
delay(retard);  // fait une pause de la valeur de retard
digitalWrite(led_IR, HIGH); // coupe LED IR
digitalWrite(phototransmass, HIGH);  // coupe phototrans
digitalWrite(opto_coupl, HIGH);  // déclenche optocoupleur
delay(50) ; //durée d'impulsion vers flash
digitalWrite(opto_coupl, LOW);  // coupe optocoupleur
delay(15000);  // fait une pause de 15000 milli-seconde avant reprise du programme
}
}


Suite au prochain message...
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 28
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Forcément, il faut que ça se gâte à un moment...

L'ensemble donne donc la chose suivante qui OH surprise bloque sur
attachInterrupt(0, updateEncodeur, CHANGE);  
relatif à la ligne volatile long encodeurValue = 0;
et sur MSB...

Quote
volatile int retard = 500;  //variable pour mémoriser le temps de retardement appeler à évoluer
const int opto_coupl = 13;   //définition de la broche 13 de la carte en tant que variable, optocoupl
const int led_IR = 7;   //définition de la broche 7 de la carte en tant que variable, masse Led IR
const int phototransmass = 6;   //définition de la broche 6 de la carte en tant que variable, masse phototrans
const int phototrans = 4;   //définition de la broche 4 de la carte en tant que variable, phototrans
int phototransState = 1;  //variable pour mémoriser l'état du phototrans
int encodeurB = 2;  //définition de la broche 2 de la carte en tant que variable, encodeur B
int encodeurA = 3;  //définition de la broche 3 de la carte en tant que variable, encodeur A
int encodeurC = 12;  //définition de la broche 12 de la carte en tant que variable, encodeur C
int encodeurBouton = 11;  //définition de la broche 11 de la carte en tant que variable, B. poussoir
int encodeurBoutonState = 0;  //variable pour mémoriser l'état du bouton
volatile long encodeurValue = 0;  //je sais pas ce que c’est mais ça doit être important
long lastencodeurValue = 0 ;  //je sais pas ce que c’est mais ça doit être important
int lastMSB = 0;  //je sais pas ce que c’est mais ça doit être important
int lastLSB = 0;  //je sais pas ce que c’est mais ça doit être important
const int encod_1 = 10;   //définition de la broche 10 de la carte en tant que variable, led rouge
const int encod_2 = 9;   //définition de la broche 9 de la carte en tant que variable, led verte
const int encod_4 = 8;   //définition de la broche 8 de la carte en tant que variable, led bleue

void setup()          //fonction d'initialisation de la carte
{
pinMode(opto_coupl, OUTPUT);   //initialisation de la broche 13 comme étant une sortie
pinMode(led_IR, OUTPUT);   //initialisation de la broche 7 comme étant une sortie
pinMode(phototransmass, OUTPUT);   //initialisation de la broche 6 comme étant une sortie
pinMode(phototrans, INPUT);   //initialisation de la broche 4 comme étant une entrée
pinMode(encodeurB, INPUT);  // initialisation de la broche 2 comme étant une entrée
pinMode(encodeurA, INPUT);  //initialisation de la broche 3 comme étant une entrée
pinMode(encodeurC, OUTPUT);  //définition de la broche 12 comme étant une sortie  
pinMode(encodeurBouton, INPUT);  //initialisation de la broche 11 comme étant une entrée
digitalWrite(encodeurB, HIGH);  // initialisation de la broche 2 en pullup
digitalWrite(encodeurA, HIGH);  // initialisation de la broche 3 en pullup
digitalWrite(encodeurBouton, HIGH);  // initialisation de la broche 11 en pullup
pinMode(encod_1, OUTPUT);   //initialisation de la broche 10 comme étant une sortie
pinMode(encod_2, OUTPUT);   //initialisation de la broche 9 comme étant une sortie
pinMode(encod_4, OUTPUT);   //initialisation de la broche 8 comme étant une sortie
 //appelle updateEncodeur() quand un changement Haut ou Bas est détécté sur les broches //interrupt 0 (broche 2) ou interrupt 1 (broche 3)
attachInterrupt(0, updateEncodeur, CHANGE);
attachInterrupt(1, updateEncodeur, CHANGE);
}
 
void loop()           //fonction principale, elle se répète à l'infini
{
digitalWrite(encodeurC, LOW); //allume encodeur, le met en attente
digitalWrite(led_IR, LOW); //allume Led IR
digitalWrite(phototransmass, LOW);  //allume phototrans
phototransState=digitalRead(phototrans);  //lit la valeur de l'état du phototrans
encodeurBoutonState = digitalRead(encodeurBouton);  //lit la valeur de l'état du bouton

if(encodeurBoutonState!=0) ;  //teste si le bouton est poussé

digitalWrite (led_IR, HIGH);  //éteint LED IR
digitalWrite(phototransmass, HIGH);  //éteint phototrans

if(retard == 500);  //si retard = 500 milli-seconde
{
digitalWrite(encod_1, LOW); //allume Led rouge
}
if(retard >500);  //si retard > 500 milli-seconde
{
digitalWrite(encod_2, LOW); //allume Led verte
}
if(retard<500);  //si retard < 500 milli-seconde
{
digitalWrite (encod_4, LOW);  //allume Led Bleu
}

void updateEncodeur()
int MSB = digitalRead(encodeurB);  //MSB = most significant bit, bit le plus significatif
int LSB = digitalRead(encodeurA);  //LSB = least significant bit, bit le moins significatif

int encodeur = (MSB << 1) |LSB;  //conversion de la valeur des 2 broches en une valeur unique
int sum  = (retard << 2) | encodeur;  //ajouter à la valeur précédente d’encodeur
if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011) encodeurValue ++;
if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000) encodeurValue --;
retard = encodeur;  //stock la nouvelle valeur de retard
}

if(phototransState!=1);  //teste si le faisceau IR est coupé
{
delay(retard);  //fait une pause de la valeur de retard
digitalWrite(led_IR, HIGH);  //coupe LED IR
digitalWrite(phototransmass, HIGH);  //coupe phototrans
digitalWrite(opto_coupl, HIGH);  //déclenche optocoupleur
delay(50);  //durée d'impulsion vers flash
digitalWrite(opto_coupl, LOW);  //coupe optocoupleur
delay(15000);  //fait une pause de 15000 milli-seconde avant reprise du programme
}
}


Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 28
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Ou me suis-je planté?

Question subsidiaire,  
Que faire de la broche C de l’encodeur relié au pin 12 de l’arduino? La brancher plutôt sur le pin
GND ?

Ici, si je ne m’abuse, l’interruption est produite par la rotation de l’encodeur, mais je souhaiterais que l’interruption soit produite par l’appui sur le  on poussoir. Dois-je recablé mon schéma pour poser la broche du BP sur une des broches 2ou 3 de l’arduino ?


Merci du coup de main...
Logged

Ile-de-France (92 sud), France
Offline Offline
Edison Member
*
Karma: 24
Posts: 2055
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

1) Oui, la broche C de l'encodeur doit etre relié à la masse. Cf page 4 de la datasheet de l'encodeur
Pas besoin de le relier à une broche digitale de l'Arduino

2) Coté LED aussi, tu va utiliser 3 broches pour piloter les LEDs RGB (je suppose en PWM) mais après il faut que le commun des LEDs aille vers le VCC et non pas vers une pin de l'Arduino. Apparemment c'est ce que tu as fait sur la broche 5 de l'encodeur.

3) Si tu n'utilise pas les interruption pour A/B il va falloir traiter en polling.
Ca me parait plus simple et plus fiable de gerer A/B sous interruption et le poussoir en polling que l'inverse.

4) Mauvais cablage du bouton poussoir :
Quote
The button shorts the common anode of the LEDs to th center pin of the five pin group.
Connect the center pin to your uC with a pull-down resister to monitor its position.

Le point commun des anodes étant relié au 5V, il faut donc effectivement :
- Ne pas activer le pull-up interne sur la pin 11
- Mettre un pull-down externe sur la pin 11
- La lecture de la pin 11 fournit un HIGH lorsque le bouton est pressé.

Logged

Barbuduino: Arduino sur Breadboard & VinciDuino: Clone Leonardo // WR703: Mini-routeur hacké // LauchPad MSP430 et Stellaris // Panda II Arduino-like .NetMF sous VisualC#
RTFC: Read That F.....g Code / RTFD: Read That F.....g Doc / RTFDS: Read That F.....g DataSheet / RTFS: Read That F.....g Schematic / Wot da ya wanna D.I.Y. today ?

Offline Offline
Faraday Member
**
Karma: 34
Posts: 5189
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset


3) Si tu n'utilise pas les interruption pour A/B il va falloir traiter en polling.
Ca me parait plus simple et plus fiable de gerer A/B sous interruption et le poussoir en polling que l'inverse.

dans la pratique c'est la gestion la plus employée, le "poussoir" étant la plupart du temps utilisé pour sortir "rapidement" de la routine d'int
« Last Edit: November 02, 2012, 02:53:57 pm by Artouste » Logged

Ile-de-France (92 sud), France
Offline Offline
Edison Member
*
Karma: 24
Posts: 2055
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Pas compris Mr Artouste
Pour moi A et B vont vers des interruptions.
Comme toute interruption qui se respecte, tu n'y passes pas 3 heures. Juste de quoi gérer une petite machine d'état pour incrémenter/décrémenter ta variable, et tu sorts.
Le poussoir tu le testes en polling dans ta loop.

On est en phase ou déphasés ?
Logged

Barbuduino: Arduino sur Breadboard & VinciDuino: Clone Leonardo // WR703: Mini-routeur hacké // LauchPad MSP430 et Stellaris // Panda II Arduino-like .NetMF sous VisualC#
RTFC: Read That F.....g Code / RTFD: Read That F.....g Doc / RTFDS: Read That F.....g DataSheet / RTFS: Read That F.....g Schematic / Wot da ya wanna D.I.Y. today ?

Offline Offline
Faraday Member
**
Karma: 34
Posts: 5189
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Pas compris Mr Artouste
Pour moi A et B vont vers des interruptions.
Comme toute interruption qui se respecte, tu n'y passes pas 3 heures. Juste de quoi gérer une petite machine d'état pour incrémenter/décrémenter ta variable, et tu sorts.
Le poussoir tu le testes en polling dans ta loop.

On est en phase ou déphasés ?

On est en phase, c'est moi qui m'exprime mal  smiley-mr-green
l'int sert à incrementer/decrementer une variable
le push (lorsqu'il est dispo sur les codeurs) ne servant qu'à valider l'action avec la valeur.

je ne suis pas sur finalement à la relecture  d’être plus clair  smiley-mr-green
Logged

Ile-de-France (92 sud), France
Offline Offline
Edison Member
*
Karma: 24
Posts: 2055
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Moi ca me va smiley-wink
Logged

Barbuduino: Arduino sur Breadboard & VinciDuino: Clone Leonardo // WR703: Mini-routeur hacké // LauchPad MSP430 et Stellaris // Panda II Arduino-like .NetMF sous VisualC#
RTFC: Read That F.....g Code / RTFD: Read That F.....g Doc / RTFDS: Read That F.....g DataSheet / RTFS: Read That F.....g Schematic / Wot da ya wanna D.I.Y. today ?

Offline Offline
Newbie
*
Karma: 0
Posts: 28
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Messieurs,

J'avoue ne pas bien saisir toutes les subtilités de votre conversations. Pour ma part, je souhaiterais que l'appui sur le poussoir déclenche l'activation de l'encodeur... Or dans le code actuel, toutes actions sur l'encodeur (incrémentations ou décrémentations) prend le pas sur la rotation du programme à tout moment. Me trompe-je? Remarquez que je ne suis pas sur que cela soit gênant sauf en cas de manœuvre involontaire sur l'encodeur...
Sinon une idée sur le refus de compiler mes lignes
attachInterrupt(0, updateEncodeur, CHANGE);   
et le problème sur MSB...

Barbudor, bien compris je remplace
digitalWrite(encodeurBouton, HIGH);  // initialisation de la broche 11 en pullup
par
digitalWrite(encodeurBouton, LOW);  // initialisation de la broche 11 en pulldown

Pas de commentaire sur le reste du programme?

Merci beaucoup.
Logged

Ile-de-France (92 sud), France
Offline Offline
Edison Member
*
Karma: 24
Posts: 2055
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote
Sinon une idée sur le refus de compiler mes lignes
attachInterrupt(0, updateEncodeur, CHANGE);   

Avec l'erreur retournée par le compilo, on comprendra peut être mieux....

Quote
Barbudor, bien compris je remplace
digitalWrite(encodeurBouton, HIGH);  // initialisation de la broche 11 en pullup
par
digitalWrite(encodeurBouton, LOW);  // initialisation de la broche 11 en pulldown
Oui et non.
Ecrire LOW désactive le pull-up mais ne met pas de pull-down.
Il faut que tu mette toi même une vrai résistance entre la pin et la masse pour faire pull-down.

Quote
Pas de commentaire sur le reste du programme?
Pas regardé.
Si tu as des problèmes particuliers je veux bien regarder un problème particulier mais regarder 3 pages de code pour le plaisir,comment dire... , ben j'ai mon propre code a relire et qui avance pas vite alors ....
 
Logged

Barbuduino: Arduino sur Breadboard & VinciDuino: Clone Leonardo // WR703: Mini-routeur hacké // LauchPad MSP430 et Stellaris // Panda II Arduino-like .NetMF sous VisualC#
RTFC: Read That F.....g Code / RTFD: Read That F.....g Doc / RTFDS: Read That F.....g DataSheet / RTFS: Read That F.....g Schematic / Wot da ya wanna D.I.Y. today ?

France
Offline Offline
Faraday Member
**
Karma: 39
Posts: 3627
There is an Arduino for that
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset


Je crois qu'à la base il y a une mauvaise compréhension du fonctionnement de la routine que tu as copiée.
Code:
volatile int retard= 500;  //variable pour mémoriser le temps de retardement appeler à évoluer
volatile long encodeurValue = 0;  //je sais pas ce que c’est mais ça doit être important

...................

void updateEncodeur(){
  int MSB = digitalRead(encodeurB); //MSB = most significant bit, bit le plus significatif
  int LSB = digitalRead(encodeurA); //LSB = least significant bit, bit le moins significatif

  int encodeur = (MSB << 1) |LSB; // conversion de la valeur des 2 broches en une valeur unique
  int sum  = (retard << 2) | encodeur; // ajouter à la valeur précédente d’encodeur

  if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011) encodeurValue ++;
  if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000) encodeurValue --;

  retard = encodeur; //stock la nouvelle valeur de retard
}

retard ne sert pas à mémoriser un délai mais l'état précédent de l'encodeur afin de pouvoir déterminer dans quel sens il tourne.
D'ailleurs dans la dernière version de ton code cela apparaît comme:
Code:
volatile long encodeurValue = 0;  //je sais pas ce que c’est mais ça doit être important
long lastencodeurValue = 0 ;  //je sais pas ce que c’est mais ça doit être important
En plus il y a un embrouillamini entre la variable retard que tu utilises dans loop et l'état précédent de l'encodeur que tu appelles aussi retard.

Maintenant d'un point de vue fonctionnel. Il y a quelque chose que je ne comprends pas, pourquoi prendre un encodeur rotatif si tu ne veux utiliser que le poussoir. A te lire
Quote
Or dans le code actuel, toutes actions sur l'encodeur (incrémentations ou décrémentations) prend le pas sur la rotation du programme à tout moment. Me trompe-je? Remarquez que je ne suis pas sur que cela soit gênant sauf en cas de manœuvre involontaire sur l'encodeur...
La fonction incrémentation/décrémentation semble ne pas t'intéresser. Dans ce cas le plus simple c'est de ne pas implémenter la fonction updateEncodeur() et de supprimer les attachInterrupt().
Maintenant si tu as besoin de l'encodeur, 2 possibilités:
 - tu en as besoin tout le temps. Donc tu conserves la fonction (de toute façon elle ne consomme pas beaucoup de ressource)
 - tu en as besoin ponctuellement et tu déroule des tâche très critiques d'un point de vue temporelle. Dans ce cas là tu détaches l'interruption lorsque tu crains qu'elle gène le déroulement du programme et tu l'attaches lorsque c'est nécessaire.
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 28
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

'Lut,

Effectivement, mes capacités étant très limitées dans le domaine, j'ai repris un code dont je ne comprenais pas totalement le fonctionnement... Je retenterais une adaptation plus précautionneuse dès que possible car j ai en effet tripoté le code, principalement autour de "retard" et d "encodeur"... Je pensais bien que le probleme venait de ça mais...

D'autre part, j ai bien sur besoin de l encodeur pour incrementer ou decrementer la valeur du retard entre la coupure de la barrière et le déclenchement du flash mais je souhaitais que l encodeur ne soit actif qu apres que le poussoir ait été actionner.

Je replanche et je repost...
Logged

Offline Offline
Faraday Member
**
Karma: 34
Posts: 5189
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset


D'autre part, j ai bien sur besoin de l encodeur pour incrementer ou decrementer la valeur du retard entre la coupure de la barrière et le déclenchement du flash mais je souhaitais que l encodeur ne soit actif qu apres que le poussoir ait été actionner.

tu a au moins 2 approches possibles simples

-1 : incrementer/decrementer dans la routine d'interruption seulement si le poussoir est aussi enfoncé, ce n'est pas le plus ergonomique, mais c'est le plus secure
-2 : attacher l'interruption par un appui et la detacher par un autre appui = contrainte savoir/indiquer qq part dans quelle situation l'on se trouve
Logged

France
Offline Offline
Faraday Member
**
Karma: 39
Posts: 3627
There is an Arduino for that
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Bon Artouste vient de me prendre de vitesse.
Quote
-1 : incrementer/decrementer dans la routine d'interruption seulement si le poussoir est aussi enfoncé, ce n'est pas le plus ergonomique, mais c'est le plus secure
Oui mais si les IT sont toujours attachées on appelle donc toujours la routine d'interruption donc bénéfice faible

Quote
-2 : attacher l'interruption par un appui et la detacher par un autre appui = contrainte savoir/indiquer qq part dans quelle situation l'on se trouve

Là ce n'est pas très compliqué. Un booléen qui bascule à chaque appui sur le poussoir et qui va autoriser ou non l'activation/désactivation des interruptions et qui va signaler par un voyant l'état du système.
Logged

Pages: [1] 2   Go Up
Jump to: