les entrées digitales

Pour utiliser une broche en entrée on la configure avec pinMode(numero_broche,Input); On déclare les broches en entrée ou sortie dans la fonction setup.

void setup()   {                 
  pinMode(2, INPUT);    //la broche 2 est configurée en entrée
}

Pour activer la résistance interne (pullup) sur cette entrée il suffit d'écrire un niveau HIGH sur cette broche.
Activer le pullup interne permet économiser une résistance sur le montage. Pour plus explications: pullup interne

void setup()   {                 
  pinMode(2, INPUT);    //la broche 2 est configurée en entrée
  digitalWrite(2, HIGH);  // on active le pullup sur la broche 2
}

Puis on va lire sur cette entrée ainsi:

x=digitalRead(2);    //on lit sur la broche 2 et on met le contenu dans la variable x

La variable x peut être de type boolean vu quelle ne pourra prendre que 2 valeurs.

utiliser des constantes pour assigner les broches

afin de pouvoir se retrouver facilement dans le code et aussi pour pouvoir modifier facilement le brochage sans avoir à modifier tout le code on utilise des constantes pour assigner les broches. c'est une bonne habitude d'utiliser cette méthode systématiquement car elle rend le code plus propre fait gagner beaucoup de temps. très utile aussi lorsque que l'on prend un code existant comme base pour en faire un nouveau…

ex:

const int bpPin =  2;    // bp connecté sur la broche 2

les constantes se déclarent avant la partie setup (cd prog>base structure d'un programme)

du coup lorsque que l'on veut changer l'état de la led c'est plus lisible

x=digitalRead(bpPin);    //on lit sur l'état du bouton-poussoir

Boutons-poussoir et autres inters

C'est l'un des composants qu'on va le plus utiliser avec un microcontroleur pour communiquer simplement avec l'utilisateur… Cette partie va aborder quelques problématiques liées à leurs utilisations au niveau de la programmation.
Évidemment cette partie est lien étroit avec la partie électronique elec:digital_in

Etat d'un bp ou d'un inter

Pour l'arduino un état haut (HIGH) = 5v (ou 3,3v si le microcontroleur est alimenté en 3,3v); un état bas (LOW) = 0v
Mais quand j'appuie sur mon bp l'entrée reçoit un état haut ou état bas?
Évidemment ça dépend du schéma électronique. Dans les schémas de elec:digital_in les résistances de rappel envoient un 5v quand le bp et relâché mais on peut rencontrer l'inverse. Une bonne solution est de déclarer une constante explicite au début programme du coup plus de doute ;-) et on peut la changer facilement si on se retrouve dans le cas inverse…

const bolean bp_close = LOW;
const bolean bp_open = HIGH;

anti-rebond

lorsque l'on appuie sur un bp ou que l'on actionne un interrupteur il se produit des parasites d'une durée courte mais à l'échelle à laquelle fonctionne le microcontroleur cela suffit à poser des problèmes. pour de plus amples détails antirebond(partie elec)

pour éviter que ces parasites gène le fonctionnement de notre programme il existe 2 solutions:

  • créer un anti-rebond matériellement grâce à un circuit RC antirebond(partie elec)
  • créer un anti-rebond de manière logiciel c'est la solution que nous allons traiter ici.

la solution va consister à bloquer l'entrée relié au à l'inter dés que celle-ci reçoit le changement d'état attendu. nous allons voir ici plusieurs méthodes pour y parvenir.

anti-rebond basique mais pas idéal

un petit exemple:

bpState = digitalRead(2);
  if (bpState==bp_close){   //bp_close est une constante à définir en début de programme en fonction du niveau de la tension reçu lorsque que le bp est fermé
    ledState= !ledState;    //on fait inverse l'état de la variable ledState afin de faire un toggle sur la led
    digitalWrite(13,ledState);  
    delay(200);      //l'entrée bpPin se retrouve bloquée pendant 200ms (mais le reste du programme aussi)
  }

cette méthode est très simple mais le problème est que le reste du programme reste bloqué pendant l'exécution de delay(200);

anti-rebond sans entraver le reste du programme.

voici un petit exemple où l'on va scanner une entrée numérique sans entraver le déroulement du reste du programme.
L'idée ici est d'enregistrer le moment où le bp est appuyer et de plus accepter d'évenement sur le bp tant que laps de temps ne s'est pas écoulé.
voici un petit exemple assez simple où la led change d'état à chaque appui sur le bp

#define bp_close  0       
#define bp_open   1
#define antirebond    200    //nb de ms de l'antirebond (je trouve que 200ms ça marche bien...)

const int bp1Pin = 2;        // broche pour le bp1
const int ledPin =  13;      // broche pour la led (la 13 est cablée en interne)

long bp1LastDebounceTime=0;  //enregistre le moment où bp1 a été appuyé pour la dernière fois
int bp1State;                //variable pour enregistrer la valeur de l'entrée de bp1
boolean bp1Flag=true;        //si true l'entrée est active; si false l'entrée est bloqué  
boolean ledState=0;          //état de la led

void setup() 
{ 
  pinMode(bp1Pin, INPUT);     //configure la broche de bp1 en entrée
  digitalWrite(bp1Pin, HIGH); //active le pull-up sur cette entrée
  pinMode(ledPin, OUTPUT);    //configure la broch de la led en sortie
} 

 
void loop() 
{ 
  bp1State = digitalRead(bp1Pin);
  if (bp1State==bp_close   and bp1Flag==true){
    bp1LastDebounceTime = millis();
    ledState= !ledState;      //on inverse la valeur de la led (toggle)
    digitalWrite(ledPin,ledState);
    bp1Flag=false;  //désactive l'éntrée de bp1
  }
  if ((millis() - bp1LastDebounceTime) > antirebond) {
    bp1Flag=true;  //réactive l'éntrée de bp1
  }
  
} 

prog/digital_in.txt · Dernière modification: 2016/05/18 15:55 par admin_memo