Arduino lento con encoder?

International Italiano Hardware
1

ciao
cercando di leggere un encoder, mi serve un solo canale, sto notando che arduino non riesce a leggere tutti gli impulsi che provengono dall'encoder, potrebbe essere il programma troppo lungo?
E' un encoder open collector da 360 impulsi/giro e la massima frequenza degli impulsi attualmente è di 70Hz ma vorrei arrivare a 110Hz.
Quello che non comprendo è come mai in certi momenti funziona e certi no, ho controllato tutti i collegamenti e sono a posto, l'encoder è nuovo anche se cinese.
Ho letto di questo in una discussione
HCTL-2001-A00, HCTL-2017-A00 / PLC, HCTL-2021-A00 / PLC Quadrature Decoder/Counter Interface ICs, pensate possa fare al caso mio?

Stefano

/*
pinza
 programma per il controllo del movimento delle pinze
 with encoder and interrupt
 stato exe
 20141024
 */

#define sensoreAngolo   2  //pin encoder canale 0
#define pin_carpet_out  3 //pin collegato al pin 3 della scheda stepper
#define pin_in          4 //pin da collegare al pin_out 4 della scheda distributore
#define FineCorsa       5  //inductive sensor
#define pulsante        6 //pin interruttore
#define pin_AM          7//switych automatico manuale

const byte dataPin = 11; //Pin connected to DS of 74HC595 14
const byte latchPin = 10;//Pin connected to ST_CP of 74HC595 12
const byte clockPin = 12;//Pin connected to SH_CP of 74HC595 11
const byte OEPin = 9;//Pin connected to OE of 74HC595 13

const int angolo_1 = 0;  //andata
const int angolo_11 = 10;  //andata
const int angolo_2 = 30; //andata
const int angolo_21 = 40;  //andata
const int angolo_22 = 53;  //andata
const int angolo_23 = 55;  //andata
const int angolo_3 = 132;  //andata
const int angolo_4 = 169;  //ritorno
const int angolo_41 = 171;  //ritorno
const int angolo_6 = 250;  //ritorno
const int angolo_61 = 255;  //ritorno

byte stato_pulsante;//pulsante 
byte stato_ciclo;
byte k;
byte i;
char fila;//fila pari 'p' o fila dispari 'd'

int ritardo[3] = {
  100, 200, 150};

byte fase;
byte stato;
int angolo;

long tempo_0;
long delta_t;

void setup()
{
  pinMode(sensoreAngolo, INPUT_PULLUP);  //interrupt
  attachInterrupt(0, ciclo, RISING);

  pinMode(FineCorsa, INPUT_PULLUP);

  pinMode(dataPin, OUTPUT);       
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(OEPin, OUTPUT);

  digitalWrite(latchPin, LOW);
  digitalWrite(OEPin, LOW);

  digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
  shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
  shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
  digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

  pinMode(pin_carpet_out, OUTPUT);
  digitalWrite(pin_carpet_out, HIGH);

  pinMode(pulsante, INPUT_PULLUP);
  stato_pulsante = 0;

  pinMode(pin_in, INPUT_PULLUP);
  pinMode(pin_AM, INPUT_PULLUP);//pin selezione movimento automatico o manuale

  stato = 0;
  angolo = 0;
  fila = 'p';
  fase = 0;
  k = 1;
  i = 0;

//  Serial.begin(115200);
 Serial.println("Pronto");

  tempo_0 = 0;
  delta_t = 0;
  delay(500);
}

void loop()
{
  stato_pulsante = digitalRead(pulsante); 

  if(stato_pulsante == LOW)//switch closed
  {
    stato_ciclo = 1;
    stato = 0;     //per il while quando lo switch è aperto
    //Serial.println("stato_ciclo = 1");
  }

  if(stato_pulsante == HIGH)//switch opened
  {
    while(stato == 0)
    {
      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//G1oi G2oi Ppoi Pdoi
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//AoiBoiCoiDpd
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
      delay(ritardo[0]);
      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B01010101);//G1oi G2oi Ppoi Pdoi
      shiftOut(dataPin, clockPin, MSBFIRST, B01101010);//AoiBoiCoiDpd
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
      delay(ritardo[0]);
      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//G1oi G2oi Ppoi Pdoi
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//AoiBoiCoiDpd
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
      //delay(ritardo[0]);

      fila = 'p';

      stato_ciclo = 0;
      stato = 1;//per uscire dal while
      angolo = 0;
      k = 1;
    }
  }

  if(stato_ciclo == 1)
  {
    switch(k)
    {
    case 1:
      if(digitalRead(pin_AM) == LOW)
      {
        switch(fila)
        {  
        case 'p':
          delay(ritardo[0]);

          digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
          shiftOut(dataPin, clockPin, MSBFIRST, B10100000);//G1oi G2oi Ppoi Pdoi
          shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//Aoi Boi Coi Dpd
          digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
          //Serial.println(millis());

          delay(ritardo[0]);

          //Serial.println(millis());
          digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
          shiftOut(dataPin, clockPin, MSBFIRST, B00001000);//G1oi G2oi Ppoi Pdoi
          shiftOut(dataPin, clockPin, MSBFIRST, B10100000);//Aoi Boi Coi Dpd
          digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

          Serial.println("caso 1p");
          break;

        case 'd':
          delay(ritardo[0]);

          digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
          shiftOut(dataPin, clockPin, MSBFIRST, B10100000);//G1oi G2oi Ppoi Pdoi
          shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//Aoi Boi Coi Dpd
          digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

          delay(ritardo[0]);

          digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
          shiftOut(dataPin, clockPin, MSBFIRST, B00000010);//G1oi G2oi Ppoi Pdoi
          shiftOut(dataPin, clockPin, MSBFIRST, B10100000);//Aoi Boi Coi Dpd
          digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

          Serial.println("caso 1d");
          break;
        }
        Serial.println(angolo);
        k = 0;
      }
      break;

    case 11:

      switch (fila)
      {
      case 'p':
        digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
        shiftOut(dataPin, clockPin, MSBFIRST, B00000100);//G1oi G2oi Ppoi Pdoi
        shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//Aoi Boi Coi Dpd
        digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

        Serial.println("caso 11p"); 
        break;

      case 'd':
        digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
        shiftOut(dataPin, clockPin, MSBFIRST, B00000001);//G1oi G2oi Ppoi Pdoi
        shiftOut(dataPin, clockPin, MSBFIRST, B00000010);//Aoi Boi Coi Dpd
        digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
        Serial.println("caso 11d");
        break;
      }//fine switch fila
      Serial.println(angolo);
      k = 0;
      break;


    case 2:
    
      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      shiftOut(dataPin, clockPin, MSBFIRST, B00010000);//AoiBoiCoiDpd
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
      Serial.println("caso 2");
      Serial.println(angolo);
      k = 0;
      break;

    case 21:

      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//AoiBoiCoiDpd
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
      Serial.println("caso 21");
      Serial.println(angolo); 
      k = 0;
      break;

    case 22:
      switch (fila)
      {
      case 'd':
        digitalWrite(pin_carpet_out, LOW);
        Serial.println("tappeto ON");
        Serial.println(angolo);
        break;
      }

      k = 0;
      break;

    case 23:
      switch (fila)
      {
      case 'd':
        digitalWrite(pin_carpet_out, HIGH);
        Serial.println("tappeto OFF");
        Serial.println(angolo);
        break;
      }
      k = 0;
      break;

    case 3:

      if(digitalRead(pin_in) == LOW)//stato pin_out distributore
      {
        delay(ritardo[0]);

        digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
        shiftOut(dataPin, clockPin, MSBFIRST, B01010000);
        shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
        digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

        delay(ritardo[0]);

        digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
        shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
        shiftOut(dataPin, clockPin, MSBFIRST, B01100000);
        digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

        Serial.println("caso 3");
        Serial.println(angolo);
        k = 0;
      }
      break;

    case 4:

      switch (fila)
      {
      case 'p':

        digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
        shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
        shiftOut(dataPin, clockPin, MSBFIRST, B00000101);
        digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

        Serial.println("caso 4p");
        break;

      case 'd':

        digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
        shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
        shiftOut(dataPin, clockPin, MSBFIRST, B00000100);
        digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

        Serial.println("caso 4d"); 
        break;
      }//fine switch fila 

      Serial.println(angolo);
      k = 0;
      break;

    case 41:

      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

      Serial.println("caso 41"); 
      Serial.println(angolo);
      k = 0;
      break;

    case 6:

      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      shiftOut(dataPin, clockPin, MSBFIRST, B00001000);
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

      Serial.println("caso 6");
      Serial.println(angolo); 
      k = 0;
      break;

    case 61:

      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

      Serial.println("caso 61");
      Serial.println(angolo); 
      k = 0;
      break;
    }//fine switch k

      if(angolo > 260 && digitalRead(FineCorsa) == LOW)
    {
      angolo = 0;
      k = 1;

      if(tempo_0 != millis())//per calcolare quanto tempo impiega il ciclo 
      {
        delta_t = millis() - tempo_0;
        tempo_0 = millis();
        Serial.println(delta_t);
        Serial.println(i++);
      }

      switch(fila)//per passare da una fila all'altra
      {
      case 'p':
        fila = 'd';
        //Serial.println(fila);
        break;

      case 'd':
        fila = 'p';
        //Serial.println(fila);  
        break;
      }//fine switch fila
    }//fine if angolo > 260
  }//fine if principale
}//fine loop

void ciclo()
{
  angolo++;
  //Serial.println(angolo);
  switch(angolo)
  {
    /*case angolo_1:
     k = 1;
     break;*/
  case angolo_11:
    k = 11;
    break;

  case angolo_2:
    k = 2;
    break;

  case angolo_21:
    k = 21;
    break;

  case angolo_22:
    k = 22;
    break;

  case angolo_23:
    k = 23;
    break;

  case angolo_3:
    k = 3;
    break;

  case angolo_4:
    k = 4;
    break;

  case angolo_41:
    k = 41;
    break;

  case angolo_6:
    k = 6;
    break;

  case angolo_61:
    k = 61;
    break;

  }
}
2

ciao
ho provato anche a commentare il Serial.begin(115200); ma il conteggio si ferma a 40 gradi case 21:

3

ho fatto delle misure con oscilloscopio e gli impulsi ci sono tutti e hanno una frequenza di circa 100 Hz, e talvolta arduino riesce a leggerli, possibile che arduino sia lento?

4

ho risolto riducendo al minimo le operazioni sotto interrupt, questo è lo sketch

/*
pinza
 programma per il controllo del movimento delle pinze
 with encoder and interrupt
 stato exe
 20141024_18:41
 */

#define sensoreAngolo   2  //pin encoder canale 0
#define pin_carpet_out  3 //pin collegato al pin 3 della scheda stepper
#define pin_in          4 //pin da collegare al pin_out 4 della scheda distributore
#define FineCorsa       5  //inductive sensor
#define pulsante        6 //pin interruttore
#define pin_AM          7//switych automatico manuale

const byte dataPin = 11; //Pin connected to DS of 74HC595 14
const byte latchPin = 10;//Pin connected to ST_CP of 74HC595 12
const byte clockPin = 12;//Pin connected to SH_CP of 74HC595 11
const byte OEPin = 9;//Pin connected to OE of 74HC595 13

const int angolo_1 = 0;  //andata
const int angolo_11 = 10;  //andata
const int angolo_2 = 30; //andata
const int angolo_21 = 40;  //andata
const int angolo_22 = 53;  //andata
const int angolo_23 = 55;  //andata
const int angolo_3 = 132;  //andata
const int angolo_4 = 169;  //ritorno
const int angolo_41 = 171;  //ritorno
const int angolo_6 = 250;  //ritorno
const int angolo_61 = 255;  //ritorno

byte stato_pulsante;//pulsante 
byte stato_ciclo;
byte k;
byte i;
char fila;//fila pari 'p' o fila dispari 'd'

int ritardo[3] = {
  100, 200, 150};

byte fase;
byte stato;
int angolo;

long tempo_0;
long delta_t;

void setup()
{
  pinMode(sensoreAngolo, INPUT_PULLUP);  //interrupt
  attachInterrupt(0, ciclo, RISING);

  pinMode(FineCorsa, INPUT_PULLUP);

  pinMode(dataPin, OUTPUT);       
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(OEPin, OUTPUT);

  digitalWrite(latchPin, LOW);
  digitalWrite(OEPin, LOW);

  digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
  shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
  shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
  digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

  pinMode(pin_carpet_out, OUTPUT);
  digitalWrite(pin_carpet_out, HIGH);

  pinMode(pulsante, INPUT_PULLUP);
  stato_pulsante = 0;

  pinMode(pin_in, INPUT_PULLUP);
  pinMode(pin_AM, INPUT_PULLUP);//pin selezione movimento automatico o manuale

  stato = 0;
  angolo = 0;
  fila = 'p';
  fase = 0;
  k = 1;
  i = 0;

  //  Serial.begin(115200);
  Serial.println("Pronto");

  tempo_0 = 0;
  delta_t = 0;
  delay(500);
}

void loop()
{
  stato_pulsante = digitalRead(pulsante); 

  if(stato_pulsante == LOW)//switch closed
  {
    stato_ciclo = 1;
    stato = 0;     //per il while quando lo switch è aperto
    //Serial.println("stato_ciclo = 1");
  }

  if(stato_pulsante == HIGH)//switch opened
  {
    while(stato == 0)
    {
      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//G1oi G2oi Ppoi Pdoi
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//AoiBoiCoiDpd
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
      delay(ritardo[0]);
      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B01010101);//G1oi G2oi Ppoi Pdoi
      shiftOut(dataPin, clockPin, MSBFIRST, B01101010);//AoiBoiCoiDpd
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
      delay(ritardo[0]);
      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//G1oi G2oi Ppoi Pdoi
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//AoiBoiCoiDpd
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
      //delay(ritardo[0]);

      fila = 'p';

      stato_ciclo = 0;
      stato = 1;//per uscire dal while
      angolo = 0;
      k = 1;
    }
  }

  switch(angolo)
  {
    /*case angolo_1:
     k = 1;
     break;
     */
  case angolo_11:
    k = 11;
    break;

  case angolo_2:
    k = 2;
    break;

  case angolo_21:
    k = 21;
    break;

  case angolo_22:
    k = 22;
    break;

  case angolo_23:
    k = 23;
    break;

  case angolo_3:
    k = 3;
    break;

  case angolo_4:
    k = 4;
    break;

  case angolo_41:
    k = 41;
    break;

  case angolo_6:
    k = 6;
    break;

  case angolo_61:
    k = 61;
    break;
  }

  if(stato_ciclo == 1)
  {
    switch(k)
    {
    case 1:
      if(digitalRead(pin_AM) == LOW)
      {
        switch(fila)
        {  
        case 'p':
          delay(ritardo[0]);

          digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
          shiftOut(dataPin, clockPin, MSBFIRST, B10100000);//G1oi G2oi Ppoi Pdoi
          shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//Aoi Boi Coi Dpd
          digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
          //Serial.println(millis());

          delay(ritardo[0]);

          //Serial.println(millis());
          digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
          shiftOut(dataPin, clockPin, MSBFIRST, B00001000);//G1oi G2oi Ppoi Pdoi
          shiftOut(dataPin, clockPin, MSBFIRST, B10100000);//Aoi Boi Coi Dpd
          digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

          Serial.println("caso 1p");
          break;

        case 'd':
          delay(ritardo[0]);

          digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
          shiftOut(dataPin, clockPin, MSBFIRST, B10100000);//G1oi G2oi Ppoi Pdoi
          shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//Aoi Boi Coi Dpd
          digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

          delay(ritardo[0]);

          digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
          shiftOut(dataPin, clockPin, MSBFIRST, B00000010);//G1oi G2oi Ppoi Pdoi
          shiftOut(dataPin, clockPin, MSBFIRST, B10100000);//Aoi Boi Coi Dpd
          digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

          Serial.println("caso 1d");
          break;
        }
        Serial.println(angolo);
        k = 0;
      }
      break;

    case 11:

      switch (fila)
      {
      case 'p':
        digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
        shiftOut(dataPin, clockPin, MSBFIRST, B00000100);//G1oi G2oi Ppoi Pdoi
        shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//Aoi Boi Coi Dpd
        digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

        Serial.println("caso 11p"); 
        break;

      case 'd':
        digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
        shiftOut(dataPin, clockPin, MSBFIRST, B00000001);//G1oi G2oi Ppoi Pdoi
        shiftOut(dataPin, clockPin, MSBFIRST, B00000010);//Aoi Boi Coi Dpd
        digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
        Serial.println("caso 11d");
        break;
      }//fine switch fila
      Serial.println(angolo);
      k = 0;
      break;


    case 2:

      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      shiftOut(dataPin, clockPin, MSBFIRST, B00010000);//AoiBoiCoiDpd
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
      Serial.println("caso 2");
      Serial.println(angolo);
      k = 0;
      break;

    case 21:

      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);//AoiBoiCoiDpd
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data
      Serial.println("caso 21");
      Serial.println(angolo); 
      k = 0;
      break;

    case 22:
      switch (fila)
      {
      case 'd':
        digitalWrite(pin_carpet_out, LOW);
        Serial.println("tappeto ON");
        Serial.println(angolo);
        break;
      }

      k = 0;
      break;

    case 23:
      switch (fila)
      {
      case 'd':
        digitalWrite(pin_carpet_out, HIGH);
        Serial.println("tappeto OFF");
        Serial.println(angolo);
        break;
      }
      k = 0;
      break;

    case 3:

      if(digitalRead(pin_in) == LOW)//stato pin_out distributore
      {
        delay(ritardo[0]);

        digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
        shiftOut(dataPin, clockPin, MSBFIRST, B01010000);
        shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
        digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

        delay(ritardo[0]);

        digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
        shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
        shiftOut(dataPin, clockPin, MSBFIRST, B01100000);
        digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

        Serial.println("caso 3");
        Serial.println(angolo);
        k = 0;
      }
      break;

    case 4:

      switch (fila)
      {
      case 'p':

        digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
        shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
        shiftOut(dataPin, clockPin, MSBFIRST, B00000101);
        digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

        Serial.println("caso 4p");
        break;

      case 'd':

        digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
        shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
        shiftOut(dataPin, clockPin, MSBFIRST, B00000100);
        digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

        Serial.println("caso 4d"); 
        break;
      }//fine switch fila 

      Serial.println(angolo);
      k = 0;
      break;

    case 41:

      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

      Serial.println("caso 41"); 
      Serial.println(angolo);
      k = 0;
      break;

    case 6:

      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      shiftOut(dataPin, clockPin, MSBFIRST, B00001000);
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

      Serial.println("caso 6");
      Serial.println(angolo); 
      k = 0;
      break;

    case 61:

      digitalWrite(latchPin, LOW);          //Pull latch LOW to start sending data
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
      digitalWrite(latchPin, HIGH);         //Pull latch HIGH to stop sending data

      Serial.println("caso 61");
      Serial.println(angolo); 
      k = 0;
      break;
    }//fine switch k

      if(angolo > 260 && digitalRead(FineCorsa) == LOW)
    {
      angolo = 0;
      k = 1;

      if(tempo_0 != millis())//per calcolare quanto tempo impiega il ciclo 
      {
        delta_t = millis() - tempo_0;
        tempo_0 = millis();
        Serial.println(delta_t);
        Serial.println(i++);
      }

      switch(fila)//per passare da una fila all'altra
      {
      case 'p':
        fila = 'd';
        //Serial.println(fila);
        break;

      case 'd':
        fila = 'p';
        //Serial.println(fila);  
        break;
      }//fine switch fila
    }//fine if angolo > 260
  }//fine if principale
}//fine loop

void ciclo()
{
  angolo++;
  //Serial.println(angolo);

}
5

ciao
scusate ma devo togliere il [risolto], ho ancora problemi con la lettura dell'encoder, mi stavo domandando quale sia la velocità di calcolo di arduino UNO, 16Mhz di clock non significano 16M operazioni al secondo circa?

6

stefa24:
ho risolto riducendo al minimo le operazioni sotto interrupt, questo è lo sketch

E' un must, questa cosa. Non si deve mai inserire nell'interrupt codice che esegue molte operazioni che possono rallentare la CPU.

7

stefa24:
ciao
scusate ma devo togliere il [risolto], ho ancora problemi con la lettura dell'encoder, mi stavo domandando quale sia la velocità di calcolo di arduino UNO, 16Mhz di clock non significano 16M operazioni al secondo circa?

La CPU è di tipo RISC, ossia privilegia la semplicità delle istruzioni favorendo la velocità di esecuzione. La maggior parte di esse è eseguita in un solo ciclo di clock ma ce ne sono anche altre che richiedono 2 o più cicli di clock. Se apri il datasheet dell'Atmega328, c'è una sezione con le istruzioni in linguaggio macchina supportate ed il numero di clock impiegati da ognuna di esse.

8

ok grazie leo
ma anche l'ultimo sketch postato non funziona l'output sul serial anche alla massima velocità si ferma al case21, e mi domando
perchè sempre li?
perchè invece certe volte funziona?

9

leo72:

stefa24:
ciao
scusate ma devo togliere il [risolto], ho ancora problemi con la lettura dell'encoder, mi stavo domandando quale sia la velocità di calcolo di arduino UNO, 16Mhz di clock non significano 16M operazioni al secondo circa?

La CPU è di tipo RISC, ossia privilegia la semplicità delle istruzioni favorendo la velocità di esecuzione. La maggior parte di esse è eseguita in un solo ciclo di clock ma ce ne sono anche altre che richiedono 2 o più cicli di clock. Se apri il datasheet dell'Atmega328, c'è una sezione con le istruzioni in linguaggio macchina supportate ed il numero di clock impiegati da ognuna di esse.

proverò a capire quello che dici ma non sono un esperto, però io credo che con 16Mhz non si debbano perdere degli impulsi a 200Hz

10

stefa24:
ok grazie leo
ma anche l'ultimo sketch postato non funziona l'output sul serial anche alla massima velocità si ferma al case21, e mi domando
perchè sempre li?
perchè invece certe volte funziona?

Non so, andrebbe provato dal vivo. Così di primo acchito non ho idea del motivo.

11

stefa24:
proverò a capire quello che dici ma non sono un esperto, però io credo che con 16Mhz non si debbano perdere degli impulsi a 200Hz

Il problema è esattamente l'opposto, Arduino non si perde nulla è il conteggio che avanza di più di quanto atteso durante il ciclo loop.
Devi rivedere il software tenendo conto del fatto che mentre esegui il loop il conteggio può essere arrivato oltre quanto previsto nella switch.

12

grazie per le repliche, ho fatto delle prove con lo sketch sotto, provo a descrivere quello che succede dopo l'accensione della scheda:
metto stato_pulsante == LOW
e poi scelgo tra un funzionamento manuale o automatico:
-se scelgo la modalità automatica il ciclo non viene eseguito,
-mentre se scelgo prima la modalità manuale i vari passi del ciclo vengono eseguiti, e passando poi alla modalità automatica il ciclo viene eseguito e ripetuto. Lo so che è impossibile capire quello che sto facendo appena riesco faccio un video.

@astrobeed: rifletto sul codice, ma se la frequenza degli impulsi è di 200Hz con 16Mhz di clock il codice non viene eseguito più di una volta tra un impulso e l'altro?

13

stefa24:
@astrobeed: rifletto sul codice, ma se la frequenza degli impulsi è di 200Hz con 16Mhz di clock il codice non viene eseguito più di una volta tra un impulso e l'altro?

Non devi pensare ai 16 MHz, devi pensare a tutto quello che deve fare Arduino in backgorund e al tempo per eseguire tutte le varie cose che fai nella loop, non è certo una novità che il framework di wiring è pesante sotto il profilo esecuzione e Arduino è relativamente lento per questo motivo.

14

@astrobeed
grazie per le spiegazioni ma sono troppo tecniche per le mie capacità e forse l'applicazione è troppo complessa per me e arduino, peccato perchè sta venendo bene, comunque come dici cerco di studiarmi il codice perchè passando da manuale ad automatica dopo una prima esecuzione in manuale funziona.
Con la DUE pensi potrei avere meno problemi?

15

stefa24:
Con la DUE pensi potrei avere meno problemi?

La cosa funziona pure con la UNO, però devi scrivere meglio il codice.

16

Scusate se mi sono perso qualcosa, ma non vedo nel codice sorgente la gestione dell'interrupt, tempo fa ho fatto un progetto simile con Arduino Uno e posso garantire che leggere un encoder tramite interrupt è una cosa semplicissima, e il processore va a una velocità stratosferica senza la minima perdita di dati.

17

ciao
cosa intendi per gestione dell'interrupt, ci sono altre istruzioni oltre a queste:

void setup()
{
pinMode(sensoreAngolo, INPUT_PULLUP); //interrupt
attachInterrupt(0, ciclo, RISING);
...

void ciclo()
{
angolo++;
//Serial.println(angolo);
switch(angolo)
{
/case angolo_1:
k = 1;
break;/
case angolo_11:
k = 11;
break;
....

18

Ciao Stefa
Evidentemente quel pezzo di codice non l'ho visto nel post, in ogni caso all'interno di una routine di interrupt togli assolutamente le trasmissioni seriali, altrimenti uccidi letteralmente l'interrupt, togli if e switch se possibile, e lascia solo calcoli matematici e assegnazioni in variabili, non ci mettere altre letture digitali se puoi evitarle li dentro (o peggio analogiche), quelle cose mettile nel main loop.
Poi non capisco perchè usi lo switch quando devi semplicemente assegnare un valore, fallo direttamente e basta.
Se non risolvi fammi sapere.

19

ciao
grazie per i consigli, di ridurre al minimo lo switch me lo hanno già detto.
La presenza degli switch nasce dal fatto che le parti del codice che eseguono il risultato dell'interrupt/switch/case nel loop venga eseguito una sola volta, è una mia fissa, non so fino a che punto sensata. l'interrupt/switch/case esce con un certo valore di k per lo switch/case nel loop e questo viene eseguito una sola volta perchè alla fine di ogni case k viene messo a 0.
Il programma controlla una macchina e funziona, ma non ho potuto finora fare test più lunghi di qualche minuto.

20 
void GestInt()
{
Impulso =  digitalRead(EncoderA);
Verso =  digitalRead(EncoderB);

if (Impulso==HIGH && Verso==HIGH){
   Posizione++;
  }
  
  if (Impulso==HIGH && Verso==LOW) {
   Posizione--;
  }
}//end GestInt

Questo è il codice che ho scritto nella mia routine di Interrupt, gestisce un encoder ottico azionato da un pistone pneumatico, l'encoder ha 3 segnali A,B,C, (segnale, verso, azzeramento). Impulso nel codice è il segnale ed è collegato al pin dell'interrupt (0) il verso lo legge per avere la direzione, (salita o discesa del pistone pneumatico), ti garantisco che non perde un colpo e va velocissimo, la variabile Posizione poi viene gestita dal main loop in tutta tranquillità.
Spero che ti possa servire.