Lettura di due comparatori Mitutoyo contemporaneamente

Buongiorno a tutti,
sto creando un banchetto per testare dei pezzi e mi servono 2 comparatori mitutoyo ed un sensore di pressione.
Ho trovado la parte di codice (e l’interfaccia hw) per la lettura de comparatore in rete e funziona perfettamente, ma se metto 2 comparatori le letture diventano instabili ovvero ricevo dai comparatori valori impossibili.

In prima battuta avevo usato un nano, pensando che fosse un problema di potenza di calcolo ho trasferito tutto su un mega ma non ho avuto alcun guadagno.

A questo punto mi vien da pensare che il problema sia la gestione del clock dei comparatori ma francamente non so da che parte muovermi (ammesso che il problema sia quello).

Ho provato ad alternare le letture ad ogni ciclo (con una variabile b)
ma non risolvo niente.

Idee?

#include <SPI.h>
#include <printf.h>

// variabili per sensore pressione ****************************************
int ValoreADC;
float PressioneBar;
// variabili per sensore pressione ****************************************

// variabili per mitutoyo 1 ****************************************
int req = 45; //  through q1 (arduino high pulls request line low)
int dat = 53; //  Linea dati del comparatore
int clk = 49; //  clock del comparatore
int i = 0; int j = 0; int k = 0;
byte mydata[14];
int num = 0;   //    <-- DATO DA INVIARE
int num_prec = 0;
int sign;
int conta;
int errore;
// variabili per mitutoyo 1 ****************************************

// variabili per mitutoyo 2 ****************************************
int req2 = 43; //   through q1 (arduino high pulls request line low)
int dat2 = 51; //   Linea dati del comparatore
int clk2 = 47; //   clock del comparatore
int ii = 0; int jj = 0; int kk = 0;
byte mydata2[14];
int num2 = 0;   //    <-- DATO DA INVIARE
int num_prec2 = 0;
int sign2;
int conta2;
int errore2;
// variabili per mitutoyo 2 ****************************************

int b = 0; // variabile per alternare le letture dei comparatori


void setup() {
  Serial.begin(115200);
  Serial.println(" Test Bench V0.1");

  // setting lettura mitutoyo ************************************
  pinMode(req, OUTPUT);         // setta il pin come OUTPUT
  pinMode(req2, OUTPUT);
  pinMode(clk, INPUT_PULLUP);   // setta il pin come Input abilitando la resistenza di pullup
  pinMode(clk2, INPUT_PULLUP);
  pinMode(dat, INPUT_PULLUP);   // setta il pin come input abilitando la resistenza di pullup
  pinMode(dat2, INPUT_PULLUP);
  digitalWrite(req, LOW);       // porta a LOW il pin
  digitalWrite(req2, LOW);
  // setting lettura mitutoyo ************************************
}



void loop() {
  // ValoreADC = analogRead(A0);
  // PressioneBar = (ValoreADC - 97 ) * 0.0072763;
  // PressioneBar = (ValoreADC)*5/1024;
  if (b == 0) {             // se b è a zero leggo il primo comparatore e metto b a 1
    read_mitutoyo_2();
    b = 1;
    delay(200);
  } else {                   //se b è a 1 leggo il secondo comparatore e rimetto b a 0
    read_mitutoyo2_2();
    b = 0;
    delay(200);
  }
  delay(50);
  // read_mitutoyo();
  // read_mitutoyo2();
  // read_mitutoyo_2();
  //  read_mitutoyo2_2();

  Serial.print("   Pressione: ");
  Serial.print(PressioneBar);
  Serial.print(" ");
  Serial.print("Comparatore 1 ");
  Serial.print(num);
  Serial.print(" ");
  Serial.print("Comparatore 2 ");
  Serial.print(num2);
  Serial.println();
}



void read_mitutoyo() {

  digitalWrite(req, HIGH);      // genera set request portando il pin 11 a HIGH
  for (i = 0; i < 13; i++ ) {
    k = 0;
    for (j = 0; j < 4; j++) {
      while ( digitalRead(clk) == LOW) { // hold until clock is high
      }
      while ( digitalRead(clk) == HIGH) { // hold until clock is low
      }
      bitWrite(k, j, (digitalRead(dat) & 0x1)); // read data bits, and reverse order )
    }
    mydata[i] = k; // estrai i dati da mydata
  }
  sign = mydata[4]; // sign = mydata[4]    decimal = mydata[11]  units = mydata[12];
  char buf[8];    // assemble measurement from bytes
  for (int lp = 0; lp < 6; lp++) {
    buf[lp] = mydata[lp + 5] + '0';
    buf[6] = 0;
    num = atol(buf); //converte la riga in long integer
    if (sign == 8)
    {
      num = num - (2 * num);
    }
  }

}

void read_mitutoyo2() {

  digitalWrite(req2, HIGH);      // genera set request portando il pin 11 a HIGH
  for (ii = 0; ii < 13; ii++ ) {
    kk = 0;
    for (jj = 0; jj < 4; jj++) {
      while ( digitalRead(clk2) == LOW) { // hold until clock is high
      }
      while ( digitalRead(clk2) == HIGH) { // hold until clock is low
      }
      bitWrite(kk, jj, (digitalRead(dat2) & 0x1)); // read data bits, and reverse order )
    }
    // estrai i dati da mydata
    mydata2[ii] = kk;
  }
  sign2 = mydata2[4]; // sign = mydata[4]    decimal = mydata[11]  units = mydata[12];
  char buf2[8];   // assemble measurement from bytes
  for (int lp2 = 0; lp2 < 6; lp2++) {
    buf2[lp2] = mydata2[lp2 + 5] + '0';
    buf2[6] = 0;
    num2 = atol(buf2); //converte la riga in long integer
    if (sign2 == 8)
    {
      num2 = num2 - (2 * num2);
    }
  }

}



void read_mitutoyo_2() {
  digitalWrite(req, HIGH);
  for ( i = 0; i < 13; i++ ) {
    k = 0;
    for (j = 0; j < 4; j++) {
      while ( digitalRead(clk) == LOW) {
        conta++;
        if (conta > 16000) {
          errore = 1;
          break;
        }
      } if (errore == 0) {
        conta = 0;
        while ( digitalRead(clk) == HIGH) {
          conta++;
          if (conta > 16000) {
            errore = 1;
            break;
          }
        }
      } if (errore == 0) {
        //k = k | (digitalRead(dat) && 0x1) << ( 3 - j);
        bitWrite(k, j, (digitalRead(dat) & 0x1));
      }
      //byteDatiRilevamento = k;
      mydata[i] = k;
    }
  }
  sign = mydata[4]; // sign = mydata[4]    decimal = mydata[11]  units = mydata[12];
  char buf[8];    // assemble measurement from bytes
  for (int lp = 0; lp < 6; lp++) {
    buf[lp] = mydata[lp + 5] + '0';
    buf[6] = 0;
    num = atol(buf); //converte la riga in long integer
    if (sign == 8)
    {
      num = num - (2 * num);
    }
  }
}

void read_mitutoyo2_2() {
  digitalWrite(req2, HIGH);
  for ( ii = 0; ii < 13; ii++ ) {
    kk = 0;
    for (jj = 0; jj < 4; jj++) {
      while ( digitalRead(clk2) == LOW) {
        conta2++;
        if (conta2 > 16000) {
          errore2 = 1;
          break;
        }
      } if (errore2 == 0) {
        conta2 = 0;
        while ( digitalRead(clk2) == HIGH) {
          conta2++;
          if (conta2 > 16000) {
            errore2 = 1;
            break;
          }
        }
      } if (errore2 == 0) {
        //k = k | (digitalRead(dat) && 0x1) << ( 3 - j);
        bitWrite(kk, jj, (digitalRead(dat2) & 0x1));
      }
      //byteDatiRilevamento = k;
      mydata2[ii] = kk;
    }
  }
  sign2 = mydata2[4]; // sign = mydata[4]    decimal = mydata[11]  units = mydata[12];
  char buf2[8];    // assemble measurement from bytes
  for (int lp2 = 0; lp2 < 6; lp2++) {
    buf2[lp2] = mydata2[lp2 + 5] + '0';
    buf2[6] = 0;
    num2 = atol(buf2); //converte la riga in long integer
    if (sign2 == 8)
    {
      num2 = num2 - (2 * num2);
    }
  }
}

Scusate non trovo come allegare diversamente il codice

Due cose:

  1. Il codice va correttamente indentato (vd. anche punto 17.2 del REGOLAMENTO)

  2. il codice, una volta sistemato, va selezionato e va usato il bottone </> per racchiudderlo negli appositi TAG CODE.

Grazie.

Guglielmo

Grazie,
non trovavo come visualizzarlo correttamente,
ho corretto.

:slight_smile:

p.s. ovviamente tutti i sottoprogrammi funzionano singolarmente,