Io ho appena costruito un oggetto vagamente simile al tuo, con display grafico abbastanza impegativo, e per variate alcuni parametri ho usato un encoder rotativo (a mò di Volume autoradio), usando gli interrupt sui pin 2 e 3.

Mi spieghi che problemi avresti con il display, visto che non usa alcun timer interno (unico motivo per cui un Interrupt ext non dovrebbe funzionare)?

Solo usando gli interrupt puoi avere una "fluidità" di utilizzo soddisfacente.

Tieni sempre a mente che l'ambizione e coronamento finale di un "Power user" di MCU, è quella di non scrivere NULLA nella funzione while(), nel caso di Arduino la funzione loop().

Utilizzo display glcd con controller ST7565 (http://www.ladyada.net/learn/lcd/st7565.html) e relative librerie che non mi consentono di usare interrupt, pena lo sputtanamento del display e relativo reset.

Se aumento il numero degli impulsi acquisisti, prelevandoli non solo dal fronte di salita ma anche da quello di discesa, avrei miglioramenti oppure la situazione sarebbe la stessa?

Grazie, ora funziona!
Ho applicato la stessa funzione ad un encoder Hall di un motore che fa al massimo 80 giri/minuto (rapporto riduzione 131:1), con una risoluzione di 64 cpr, ma di cui utilizzo un solo canale, perché la direzione la prendo da una variabile impostata altrove. (non posso usare gli interrupt)
Dopo alcuni calcoli, ho fatto in modo che ad ogni 25 impulsi letti (solo sul fronte di salita) mi faccio aumentare una variabile per indicarmi i millimetri percorsi. Ora per distanze che vanno da 5mm fino ad 80 mm la precisione é buona. Oltre gli 80 mm inizio ad avere imprecisioni non uniformi.
Tengo a precisare che ho modificato gran parte delle funzioni presenti nel codice con quelle proprie della port manipulation ed ora tutto il funzionamento mi sembra molto piú fluido e senza ritardi.

Cosa posso fare per aumentare la precisione?

Purtroppo non posso usare gli interrupt perché mi da problemi con il display.
Inoltre vorrei imparare meglio la port manipulation. Secondo voi il codice é corretto?

Ciao a tutti. Devo controllare un rotary encoder per interfaccia utente e devo modificare il codice in "true C" per velocizzare le letture. Sto usando Arduino Uno (Atmega328).

Il codice di partenza é questo:

Code:

encoderLast=LOW;
n=LOW;
void setup(){
pinMode(2,INPUT);
pinMode(3,INPUT);
digitalWrite(2,HIGH);
digitalWrite(3,HIGH);
}
void loop(){
encoder();
}
void encoder(){
  n = digitalRead(2);
   if ((encoderLast == LOW) && (n == HIGH)) {
    if (digitalRead(3) == LOW) {
       encoderPos--;
     } else {
       encoderPos++;
     }
   }
   encoderLast = n;
}

Ora dovrei velocizzare la funzione encoder utilizzando la port manipulation:

Code:

void encoder(){
  n = PIND & _BV(PIND2);
   if ((encoderLast == LOW) && (n == HIGH)) {
    if ((PIND & _BV(PIND3)) == LOW) {
       encoderPos--;//antiorario
     } else {
       encoderPos++;//orario
     }
   }
   encoderLast = n;
}

Il risultato della modifica é che la variabile encoderPos non si incrementa ne si decrementa ed é come se nelle condizioni vi sia qualcosa che non va. Potete aiutarmi? Grazie

Ragazzi mi inserisco anche io nella discussione perché ho un problema con gli input utilizzando "true C". Non so se devo aprire un'altra discussione, nel dubbio posto la domanda...

In pratica devo sostituire il classico DigitalRead(pin) con PINx.
Il codice di test é questo:

Code:

int encoder0PinALast=LOW;
int countPulses=0;
int n=LOW;

void setup()
{
  Serial.begin(115200);
  
  pinMode(2,INPUT);
  pinMode(3,INPUT);
  digitalWrite(2,HIGH);
  digitalWrite(3,HIGH);
}

void loop()
{
  
  encoderMotor();
 }

void encoderMotor(){
 // n = digitalRead(2);
 n=PIND & _BV(PCINT2);//<== il mio dubbio é qui. n varrá di volta in volta 1 o 0 ??

   if ((encoder0PinALast == LOW) && (n == HIGH ) ) {
      if (PIND & _BV(PCINT19) == LOW) {
       countPulses++;
     } else {
       countPulses--;
     }
   }
   encoder0PinALast = n;
}

Il fatto é che l' if non procede nel modo corretto e non ottengo ne l'incremento ne il decremento della variabile. Potreste chiarirmi il concetto su PINx ? Grazie.

Grazie intanto per le risposte.

Questo é il mio codice modificato:

Code:

#define encoder0PinA  2
#define encoder0PinB  5
#define pinmotorPWM 3
#define pinmotor 4

volatile unsigned int encoder0Pos = 0;
byte pwm=255;
unsigned long timecamp;
unsigned long currentTime;
unsigned long timeold;
float rpm;
//float spost;
void setup() {
  Serial.begin (115200);


  pinMode(encoder0PinA, INPUT);
  digitalWrite(encoder0PinA, HIGH);       // turn on pullup resistor
  pinMode(encoder0PinB, INPUT);
  digitalWrite(encoder0PinB, HIGH);       // turn on pullup resistor

  attachInterrupt(0, doEncoder, RISING);  // encoder pin on interrupt 0 - pin 2
  Serial.println("start");                // a personal quirk
  timecamp=1000;
  rpm=0.0;
  spost=0.0;
}
void avanti() {
digitalWrite(4, HIGH); 
analogWrite(3, (255-pwm)); 
 
}
void indietro() {
      digitalWrite(4, LOW);
analogWrite(3,pwm);   
}

void ferma() {            //ferma i motori
digitalWrite(pinmotor, LOW);   
digitalWrite(pinmotorPWM, LOW);
 
 
} 
void loop(){

currentTime=millis();

if(currentTime-timecamp > 1000){
  rpm=((encoder0Pos/16)/131.25)*60;
  encoder0Pos=0;
  Serial.println(rpm);
  timecamp=millis();

  }
}

void doEncoder() {
 
  if (digitalRead(encoder0PinA) == digitalRead(encoder0PinB)) {
    encoder0Pos++;
  } else {
    encoder0Pos--;
  }

 
}

Ora riesco a vedere i giri/min e dividendo per il rapporto di riduzione ottengo i giri esatti.

L'altra domanda cruciale che vorrei porvi é come calcolare la distanza percorsa ad ogni giro (o anche meno di un giro) del motore. Ho pensato di usare la velocitá tangenziale: V=W x r dove ottengo lo spostamento in metri al secondo (o mm al secondo) attraverso il prodotto della velocitá angolare e del raggio della ruota.

Secondo voi sarebbe una buona soluzione? Avete delle alternative?
Grazie 

ragazzi non c'é nessuno che mi aiuta?

Ciao, ho bisogno di un consiglio su come ottenere i giri di un motoriduttore 12Volt dotato di un encoder Hall a 64 CPR (http://arduino.cc/forum/index.php?PHPSESSID=9ce889364b858aa71b53f24042e5cf26&topic=36204.45).
 Il motore ha una velocitá massima di 80 giri minuto con un rapporto di riduzione di 131:1.
Ho cercato di visualizzare gli rpm con questo codice:

Code:

byte pwm=255;
volatile int rpmcount;
 unsigned int rpm;
 unsigned long timeold;
 float tempFloat = 0.0;
#define SHAFT_ENCODER_PPR 64.0
void setup() {
  //MOTORE DESTRO 
  Serial.begin(115200);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
digitalWrite(3,HIGH);
//attachInterrupt(0, rpm_fun, HIGH);
   rpmcount = 0;
   rpm = 0;
   timeold = 0;

avanti(pwm);      //chiama procedura avanti

}

void avanti(byte pwm) {
digitalWrite(4, HIGH); 
analogWrite(3, (255-pwm)); 
 
}

void indietro(byte pwm) {
digitalWrite(4, LOW);
analogWrite(3, pwm);   

}

void fermo() {            //ferma i motori
digitalWrite(4, LOW);   
digitalWrite(3, LOW);   

} 

void loop() 
{
 
//Update RPM every second
   delay(1000);
   detachInterrupt(0);
 
   tempFloat = (rpmcount / SHAFT_ENCODER_PPR) * 600.0;
   rpmcount = 0;
   Serial.println(tempFloat,DEC);
 

   //Restart the interrupt processing
   attachInterrupt(0, rpm_fun, RISING);

}

void rpm_fun()
 {
   rpmcount++;
 
 }
 
 

Non sono sicuro, peró, se il numero di giri ottenuti sono quelli giusti, anche perché se divido poi per 131 non ottengo nulla che si avvicini ad 80. Potreste dirmi se sbaglio qualcosa e consigliarmi una formula adatta allo scopo?

Grazie

Allora, ho giá ordinato tutto il necessario per la prima slitta, encoder compreso. Ora devo allestire la seconda slitta che la corerá in parallelo con la precedente.

Per questa abbiamo optato per un acquisto di un motoriduttore con encoder incorporato, con cui devo rilevare velocitá, verso di rotazione e distanza percorsa. Vorrei un consiglio tra questi due modelli tenendo conto delle peculiaritá dell' encoder:

opzione1:
http://www.robot-italy.com/it/gearmotor-12vdc-81rpm-encoder.html

opzione 2:
http://www.robotstore.it/product/304/Motoriduttore-12V-80rpm-18Kg-cm-diam.-37mm-con-Encoder.html

Allora, sono in procinto di finire l'ordine e finalmente acquistare da RS . Manca all'appello il connettore da collegare sui pin dell'encoder (http://it.rs-online.com/web/p/encoder-ottici-rotativi/2632889/) . Deve essere a 5 vie e molto fine con passo da 2,54 e la terminazione su cavi. Dato che é la prima volta che mi trovo ad acquistare connettori non preassemblati, vi chiedo gentilmente di aiutarmi a trovare quello giusto nella jungla RS. Ho scoperto che tali connettori vengono venduti senza contatti, che devono essere acquistati a parte e sono nel pallone piú totale.

Ragazzi, dato che ho fretta nel portare a termine il progetto vi rinnovo di nuovo la mia domanda:

É possibile determinare la distanza percorsa dal carrello con soluzioni alternative all'encoder?

Nel caso, sarebbe meglio acquistare un altro motore con encoder incorporato anziché il singolo encoder ? Che dite?

Potresti dirmi il perché non va bene e quale modello/tipo dovrei scegliere?

Perché sono fatti per essere un interfacia utente e percui con un numero di azionamenti limmitati oltre hanno un dispositivo per sentire i scatti.  Quello che hai indicato ha una vita di 100,000 cicli (scatti) ed é sicuramente meccanico (contatti su un disco sagomato) mentre quello che ha indicato astrobeed é ottico percui senza contatto ed é garantito per 10 000 000 giri a una velocita di 300 giri al minuto (versione ENA..) e per 200 000 000 giri a una velocita di 3000 giri al minuto (versione ENS..) (che sono un uso continuo di 23 e 46 giorni alla massima velocitá. Il limite é in questi modelli il cuscinetto sul quale gira l'albero. Altri modelli che non hanno un cucineto interno ma usano quello del motore/ingranaggio hanno una vita utile praticamente infinita che é determinata dalla meccanica del motore/riduttore).

Parli che vuoi determinare la posizio nella grandezza tra i mm e cm. Quanto é la corsa del carello? 10 cm o svariati metri?

Ciao Uwe

la lunghezza della slitta va da 1 metro fino anche ad arrivare a 3-4 metri. Dipende dalle versioni e cmq la lunghezza é sempre nota a priori.

Il modello di astrobeed l'avevo giá visto ed infatti ora ho chiarito i miei dubbi, penso che mi orieteró verso questo modello.

Vorrei farvi un'altra domanda. É possibile calcolare la distanza percorsa senza encoder? Oppure vi sono altre soluzioni oltre all'uso di encoder?

Potresti dirmi il perché non va bene e quale modello/tipo dovrei scegliere?

La precisione non deve essere massima ma sufficiente. L'ordine di misura devono essere i cm non mi interessa il mezzo millimetro. Devo sapere quanti cm ha percorso il carrello per compiere alcune operazioni e magari stopparlo quando arriva a fine corsa. Inoltre é necessario discriminare tra movimento avanti e quello indietro.
Il carrello é mosso da cinghia dentata mediante due pulegge alle estremitá della slitta. La velocitá non é necessaria ma mi sembra che dovró calcolarla per determinare la distanza percorsa, giusto?

Scusate ma questo non va bene?
http://it.rs-online.com/web/p/encoder-meccanici-rotativi/7295558/

Ciao,
Ho necessitá di rilevare la distanza percorsa di una slitta meccanica mossa da un motore DC. Il motore , da 12 Volt, fa al massimo 60 giri/minuto con motoriduttore. La slitta si muoverá avanti ed indietro partendo da un punto conosciuto e per una distanza conosciuta. La mia scelta é ricaduta su un encoder incrementale. La mia confusione nasce sulla scelta della risoluzione dell'encoder.
Sto scegliendo da questa serie:
http://it.rs-online.com/web/c/passivi/encoder-rotativi/encoder-meccanici-rotativi/?searchTerm=encoder+incrementale

e sono tentato da questo:
http://it.rs-online.com/web/p/encoder-meccanici-rotativi/7295558/

potreste darmi un consiglio in merito alla risoluzione ?
Secondo voi un encoder assoluto va meglio per il mio problema?