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:
//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
}
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:
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(ph ototrans); //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...
Tout cela est relatif au schéma suivant:
-----
Envoyé par minms 
