Afficheur + encodeur

Salut à tous,

J'aurais besoin de vos conseils car je bloque sur un petit (future) projet. Les composant utiliser seront, un afficheur 7 segments et un encodeur 5 pins ( rotary encoder). Le but serait de faire défiler les chiffre de l'afficheur via l'encodeur.

J'arrive à afficher en boucle des chiffres sur l'afficheur, j'arrive à faire défiler les valeurs dans le moniteur avec l'encodeur. Par contre je ne vois pas comment faire pour fusionner les deux.

Si vous pouviez m'éclairer....

#define outputA 10
#define outputB 11

int counter =0;
int aState;
int aLastState;

int A = 2;
int B = 3;
int C = 4;
int D = 5;
int E = 6;
int F = 7;
int G = 8;
int DP =9;
int TEMPS1 = 400;
int TEMPS2 = 200;


void setup() {

 pinMode(outputA, INPUT);
 pinMode (outputB, INPUT);

  Serial.begin (9600);
  aLastState = digitalRead(outputA);
  
  // put your setup code here, to run once:
pinMode(A,OUTPUT);
pinMode(B,OUTPUT);
pinMode(C,OUTPUT);
pinMode(D,OUTPUT);
pinMode(E,OUTPUT);
pinMode(F,OUTPUT);
pinMode(G,OUTPUT);
pinMode(DP,OUTPUT);

digitalWrite(A,LOW);
digitalWrite(B,LOW);
digitalWrite(C,LOW);
digitalWrite(D,LOW);
digitalWrite(E,LOW);
digitalWrite(F,LOW);
digitalWrite(G,LOW);


}

void loop() {

aState = digitalRead(outputA);
  if (aState != aLastState) {
      if (digitalRead(outputB) != aState) {
        counter ++;
      } else {
        counter --;
      }
      Serial.print("position: ");
      Serial.println(counter);
  }
  aLastState = aState;



  
  //1
digitalWrite(A,LOW);
digitalWrite(B,HIGH);
digitalWrite(C,HIGH);
digitalWrite(D,LOW);
digitalWrite(E,LOW);
digitalWrite(F,LOW);
digitalWrite(G,LOW);
delay(TEMPS1);

//2
digitalWrite(A,HIGH);
digitalWrite(B,HIGH);
digitalWrite(C,LOW);
digitalWrite(D,HIGH);
digitalWrite(E,HIGH);
digitalWrite(F,LOW);
digitalWrite(G,HIGH);
delay(TEMPS1);

Un petit coup de main ?

void displayCounter(int count)
{
  switch (count) {
    case 0:
    break;
  case 1:
    digitalWrite(A, LOW);
    digitalWrite(B, HIGH);
    digitalWrite(C, HIGH);
    digitalWrite(D, LOW);
    digitalWrite(E, LOW);
    digitalWrite(F, LOW);
    digitalWrite(G, LOW);
    break;
  case 2:
    digitalWrite(A, HIGH);
    digitalWrite(B, HIGH);
    digitalWrite(C, LOW);
    digitalWrite(D, HIGH);
    digitalWrite(E, HIGH);
    digitalWrite(F, LOW);
    digitalWrite(G, HIGH);
    break;
  case 3:
    break;
  case 4:
    break;
  case 5:
    break;
  case 6:
    break;
  case 7:
    break;
  case 8:
    break;
  case 9:
    break;
  }
}

Je te laisse remplir les cases qui manquent.

Ensuite tu appelles la fonction dans la loop :

  Serial.print("position: ");
  Serial.println(counter);
  displayCounter(counter);

On peut faire mieux qu’un switch/case pour gérer un afficheur mais vois d’abord comme cela.

@+

Bonjour;

Un encodeur se lit en "temps réel".
tu dois intégrer les interruptions pour son exploitation.

Quelle type d'encodeur a tu ?

Salutations.

hbachetti:
Un petit coup de main ?

On peut faire mieux qu'un switch/case pour gérer un afficheur mais vois d'abord comme cela.

@+

Merci pour ta réponse, je vais mettre ça en application.

manumanu:
Bonjour;

Un encodeur se lit en "temps réel".
tu dois intégrer les interruptions pour son exploitation.

Quelle type d'encodeur a tu ?

Salutations.

J'utilise ce genre d'encodeur (fourni dans un pack arduino )

http://www.satistronics.com/5-pin-rotary-encoder-with-on-switch_p3604.html

Bonjour,

j’utilise cette librairie pour les encodeurs.

ici exemple avec 2 encodeurs :

/* Encoder Library - TwoKnobs Example
 * http://www.pjrc.com/teensy/td_libs_Encoder.html
 *
 * This example code is in the public domain.
 */

#include <Encoder.h>

// Change these pin numbers to the pins connected to your encoder.
//   Best Performance: both pins have interrupt capability
//   Good Performance: only the first pin has interrupt capability
//   Low Performance:  neither pin has interrupt capability
Encoder knobLeft(5, 6);
Encoder knobRight(7, 8);
//   avoid using pins with LEDs attached

void setup() {
  Serial.begin(9600);
  Serial.println("TwoKnobs Encoder Test:");
}

long positionLeft  = -999;
long positionRight = -999;

void loop() {
  long newLeft, newRight;
  newLeft = knobLeft.read();
  newRight = knobRight.read();
  if (newLeft != positionLeft || newRight != positionRight) {
    Serial.print("Left = ");
    Serial.print(newLeft);
    Serial.print(", Right = ");
    Serial.print(newRight);
    Serial.println();
    positionLeft = newLeft;
    positionRight = newRight;
  }
  // if a character is sent from the serial monitor,
  // reset both back to zero.
  if (Serial.available()) {
    Serial.read();
    Serial.println("Reset both knobs to zero");
    knobLeft.write(0);
    knobRight.write(0);
  }
}

Penser à utiliser les pins capablent de gérer les interruptions :

https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/

@+

j'utilise cette librairie pour les encodeurs.

Oui. +1.
Les encodeurs génèrent deux signaux décalés qui permettent de déterminer le sens de rotation.
Pas simple à faire sans la librairie.

bonjour;

Il est facilement possible d'utiliser un encodeur sans librairie.

Suivant ta demande de fusionner les deux éléments "encodeur / afficheur".

Tu vas devoir monter ton programme en prenant les deux individuellement.
Une fois cela fait tu pourra aisément les "fusionner".

Tout programmes "système" commence par l'acquisition des entrées et signaux.
Ensuite tu traitera la gestion de ces entrées et signaux dans ton programme (proprement dit)
Pour finalement en faire la gestion des action en sortie.

Je te propose donc de commencer à faire un bout de programme qui ne gère que l'encodeur et les boutons utiles à ton système.
Une fois que tu aura fait cela tu pourra faire ce que tu veux des acquisitions pour ton exploitation programme !! voir même plus !!

Voici pour commencer (Sans utiliser de librairie pour encodeur.)
Suivant le fonctionnement d'un encodeur (incrémentale) lorsque l'état logique de la "voie A" et égale à celui la "voie B" l'on considère une impulsion de codeur validé.
Mais pour réaliser une lecture dans les temps d'activations rapide de l'encodeur il vas te manquer un outil.
La bibliothèque "digitalWriteFast.h" => Permet une lecture rapide de ton entrée.
Exploitation => digitalReadFast(entrée à lire). Soit ton encodeur. N'oublie pas tu a deux entrée A et B!!

Regarde les exemples d'exploitations cela t'aidera à comprendre. Manipule cet outils avec les exemples et intègre son fonctionnement. (Si tu veux en savoir plus encore (et si tu a le niveau) vas dans le programme de la "lib")

Tu a là un première outils!! :wink: Je te laisse rechercher et réaliser l'acquisition de ton encodeur.
Une bonne maitrise de son projet passe par la recherche de la mise en application de sa propre logique !!! :wink:
Concentre toi sur l'encodeur le but pour toi est de pouvoir réaliser l'incrémentation et la décrémentation des impulsions !!!

Méthodes et patience...

Je reste dispo. à d'autres questions...

Merci pour vos messages, je me plancher pleinement sur le sujet / projet des encoders car c'est quelque chose de je voudrais maitriser.