2 arduino con un lettore rfid

imdany · February 1, 2021, 10:34pm

buonasera a tutti, volevo sapere se è possibile collegare 2 arduino mega con un unico lettore rfid, il lettore di prossimità è di tipo wiegand (doppia frequenza) a due fili d0 su pin 2 d1 su pin 3 ,
metterei in parallelo i pin 2 e 3 e negativo sull'altro arduino mega con identico sketch. questo per aumentare i numero di dispositivi registrati ( e usando tag a doppia frequenza renderei un pò più sicuro il sistema).
a banco ho fatto delle prove ma non ho ancora il lettore a doppia frequenza quindi ho solo provato con un 125khz e funziona ma dopo un pò se collegati tramite pc con seriale aperte sembra si blocchi , collegato alla sua alimentazione sembra che lavorino bene. La mia domanda è : ci sono delle controindicazioni per quello che sto facendo cioè mettere in parallelo i pin 2 e 3 ?

grazie

docdoc · February 2, 2021, 8:14am

Non ho ben capito perché vorresti fare questo, ed in genere non è mai opportuno "parallelizzare" linee dati pensate per un collegamento singolo quantomeno per questioni puramente elettriche. Inoltre dato che il DI (ossia Data In) servirebbe per inviare dati al device, due Arduino in parallelo su quella linea non possono "parlare contemporaneamente", danneggiando la comunicazione (e da qui il "blocco").

Ma scusa, non potresti più semplicemente collegare tra loro i due Arduino? Ossia uno dei due, diciamo A, collegato fisicamente al lettore e via seriale (direi SoftwareSerial) a B, il secondo: "A" potrebbe dialogare con il lettore e riportare via seriale al "B" solamente l'identificativo del tag.

I codici non saranno proprio identici, ma lo saranno quasi completamente se "inscatoli" la lettura della card in una funzione la quale in "A" accedendo direttamente al lettore se non è presente la card semplicemente restituirebbe degli zeri, mentre rilevando la presenza di una card riporterebbe il codice card dopo averlo anche trasmesso via seriale a B. La stessa funzione in B si limiterebbe a leggere dalla seriale e restituire ciò che riceve (o zeri se non ha ricevuto ancora nulla).

cotestatnt · February 2, 2021, 9:49am

Io in questi casi non posso fare a meno di chiedermi.. ma sono veramente necessari due Mega?

pippo72 · February 2, 2021, 9:58am

imdany:
... questo per aumentare i numero di dispositivi registrati...

Ma se non ti basta la memoria del Mega perchè usare memorie esterne tipo eeprom o SDcard?

imdany · February 2, 2021, 10:21am

pippo72:
Ma se non ti basta la memoria del Mega perchè usare memorie esterne tipo eeprom o SDcard?

ho provato ad usare una SD card ma poi quando cerco l'id ci mette una vita, provo a linkare qui il mio codice cosi magari mi date un dritta su che strada prendere, per ora sto studiando la prima opzione data da docdoc e do un occhiata alle eprom esterne. la sd card penso di scartarla anche se era per me la soluzione migliore per aggiornare i tag .

#include <Wiegand.h>


#define FALSE 0
#define TRUE  1


int i = 0;
//int c = 0;
//int b = 0;
WIEGAND wg;
String codiceLetto = "";
///////////////////

// qui sotto creo un "array" con dentro i codici ID
int maxU = 50; //maxUtenti  cambiarlo in base a quanti codici metti qui sotto

String  codiceAutorizzato[50] = {"6170129", "6170131",  "6170132",  "6170133",  "6170134",  "6170135",  "6170136",  "6170137",  "6170138",  "6170139",  "6170140",  "6170141",  "6170142",  "6170143",  "6170144",  "6170145",  "6170146",  "6170147",  "6170148",  "6170149",  "6170150",  "6170151",  "6170152",  "6170153",  "6170154",  "6170155",  "6170156",  "6170157",  "6170158",  "6170159",  "6170160",  "6170161",  "6170162",  "6170163",  "6170164",  "6170165",  "6170166",  "6170167",  "6170168",  "6170169",  "6170170",  "6170171",  "6170172",  "6170173",  "6170174",  "6170175",  "6170176",  "6170177",  "6170178",  "6179443"};
String  codiceAutorizzato1[50] = {"6170133", "6170129",  "6170132",  "6170133",  "6170134",  "6170135",  "6170136",  "6170137",  "6170138",  "6170139",  "6170140",  "6170141",  "6170142",  "6170143",  "6170144",  "6170145",  "6170146",  "6170147",  "6170148",  "6170149",  "6170150",  "6170151",  "6170152",  "6170153",  "6170154",  "6170155",  "6170156",  "6170157",  "6170158",  "6170159",  "6170160",  "6170161",  "6170162",  "6170163",  "6170164",  "6170165",  "6170166",  "6170167",  "6170168",  "6170169",  "6170170",  "6170171",  "6170172",  "6170173",  "6170174",  "6170175",  "6170176",  "6170177",  "6170178",  "6179443"};
String  codiceAutorizzato2[50] = {"6230956", "6170131",  "6170132",  "6170133",  "6170134",  "6170135",  "6170136",  "6170137",  "6170138",  "6170139",  "6170140",  "6170141",  "6170142",  "6170143",  "6170144",  "6170145",  "6170146",  "6170147",  "6170148",  "6170149",  "6170150",  "6170151",  "6170152",  "6170153",  "6170154",  "6170155",  "6170156",  "6170157",  "6170158",  "6170159",  "6170160",  "6170161",  "6170162",  "6170163",  "6170164",  "6170165",  "6170166",  "6170167",  "6170168",  "6170169",  "6170170",  "6170171",  "6170172",  "6170173",  "6170174",  "6170175",  "6170176",  "6170177",  "6170178",  "6179443"};
String  codiceAutorizzato3[50] = {"6170132", "6170129",  "6170132",  "6170133",  "6170134",  "6170135",  "6170136",  "6170137",  "6170138",  "6170139",  "6170140",  "6170141",  "6170142",  "6170143",  "6170144",  "6170145",  "6170146",  "6170147",  "6170148",  "6170149",  "6170150",  "6170151",  "6170152",  "6170153",  "6170154",  "6170155",  "6170156",  "6170157",  "6170158",  "6170159",  "6170160",  "6170161",  "6170162",  "6170163",  "6170164",  "6170165",  "6170166",  "6170167",  "6170168",  "6170169",  "6170170",  "6170171",  "6170172",  "6170173",  "6170174",  "6170175",  "6170176",  "6170177",  "6170178",  "6179444"};
String  codiceAutorizzato4[50] = {"6170130", "6170131",  "6170132",  "6170133",  "6170134",  "6170135",  "6170136",  "6170137",  "6170138",  "6170139",  "6170140",  "6170141",  "6170142",  "6170143",  "6170144",  "6170145",  "6170146",  "6170147",  "6170148",  "6170149",  "6170150",  "6170151",  "6170152",  "6170153",  "6170154",  "6170155",  "6170156",  "6170157",  "6170158",  "6170159",  "6170160",  "6170161",  "6170162",  "6170163",  "6170164",  "6170165",  "6170166",  "6170167",  "6170168",  "6170169",  "6170170",  "6170171",  "6170172",  "6170173",  "6170174",  "6170175",  "6170176",  "6170177",  "6170178",  "6179443"};
String  codiceAutorizzato5[50] = {"13781091",  "507397", "13781092", "13781093", "13781094", "13781095", "13781096", "13781097", "13781098", "13781099", "13781100", "13781101", "13781102", "13781103", "13781104", "13781105", "13781106", "13781107", "13781108", "13781109", "13781110", "13781111", "13781112", "13781113", "13781114", "13781115", "13781116", "13781117", "13781118", "13781119", "13781120", "13781121", "13781122", "13781123", "13781124", "13781125", "13781126", "13781127", "13781128", "13781129", "13781130", "13781131", "13781132", "13781133", "13781134", "13781135", "13781136", "13781137", "13781138", "6170279"};
String  codiceAutorizzato6[50] = {"6170180",  "6170181",  "6170182",  "6170183",  "6170184",  "6170185",  "6170186",  "6170187",  "6170188",  "6170189",  "6170190",  "6170191",  "6170192",  "6170193",  "6170194",  "6170195",  "6170196",  "6170197",  "6170198",  "6170199",  "6170200",  "6170201",  "6170202",  "6170203",  "6170204",  "6170205",  "6170206",  "6170207",  "6170208",  "6170209",  "6170210",  "6170211",  "6170212",  "6170213",  "6170214",  "6170215",  "6170216",  "6170217",  "6170218",  "6170219",  "6170220",  "6170221",  "6170222",  "6170223",  "6170224",  "6170225",  "6170226",  "6170227",  "6170228",  "13781090"};



const int Releserratura = 8;       // rele
const long delayserr = 250;


//////////////////

void setup() {

  Serial.begin(9600);
  Serial.println("num...550.....");
  pinMode(Releserratura, OUTPUT);

  // PIN assigment and declaration for Arduino Mega
  //GATE A
  wg.D0PinA = 2;
  wg.D1PinA = 3;
  delay(75);
  //GATE B
  //con arduino uno va solo con pin 2 e 3...
  //usare mega 2560 se si vogliono piu gate
  wg.D0PinB = 18; //18
  wg.D1PinB = 19;  //19
  delay(75);
  //GATE C
  wg.D0PinC = 20;
  wg.D1PinC = 21;
  delay(75);
  // Reader enable

  wg.begin(TRUE, TRUE, TRUE);  // wg.begin(GateA , GateB, GateC)
  //wg.begin(FALSE, FALSE, TRUE);  // wg.begin(GateA , GateB, GateC)

}
//void(* Riavvia)(void) = 0;
void loop() {
  if (wg.available())
  {
    codiceLetto = "";
    codiceLetto += String (wg.getCode(), DEC);//bella soluzione di coversione

    Serial.print("Wiegand HEX = ");
    Serial.print(wg.getCode(), HEX);
    Serial.print(", DECIMAL = ");
    Serial.print(wg.getCode());
    Serial.print(", Gate= ");
    Serial.print(wg.getGateActive());
    Serial.print(", Type W");
    Serial.println(wg.getWiegandType());
    Serial.print("codiceLetto=" );
    Serial.println(codiceLetto );
    //---//////////-----//////---------/////////-/-/-/
    //---//////////-----//////---------/////////-/-/-/

    for (i = 0; i < maxU; i++) {


      if (verificaCodice(codiceLetto, codiceAutorizzato[i])) {


        // if (codiceLetto.equals(codiceAutorizzato[i]))
        if (codiceLetto == (codiceAutorizzato[i]))
        {

          Serial.println("Bella Apro - blocco codiceAutorizzato............");
          Apri();
          codiceLetto = "";

          // Serial.println("codiceAutorizzatoArray[0]......");
          // Serial.println(codiceAutorizzatoArray[0]);
          break;
        }
        else
        {
          Serial.println("codice non trovato  ...........");

        }

      }
    }
  
    for (i = 0; i < maxU; i++) {


      if (verificaCodice(codiceLetto, codiceAutorizzato1[i])) {


        // if (codiceLetto.equals(codiceAutorizzato[i]))
        if (codiceLetto == (codiceAutorizzato1[i]))
        {

          Serial.println("Bella Apro - blocco codiceAutorizzato6............");
          Apri();
          codiceLetto = "";

          // Serial.println("codiceAutorizzatoArray[0]......");
          // Serial.println(codiceAutorizzatoArray[0]);
          break;
      
        }
    else
    {
      Serial.println("codice non trovato  ...........");

    }
    Serial.println("codice non trovato 1 ...........");

    }
   
      }
      if (codiceLetto != ""){//se non ha trovato il codice fino a qui passa sull'altra scheda arduino a cercare il codice 
        Serial.println("cerco sull'altro arduino!!!");
      }
    }
}

// Questa funzione verifica se il codice Letto è autorizzato
boolean verificaCodice(String codiceLetto, String codiceAutorizzato) {
  if (codiceLetto.equals(codiceAutorizzato)) { // if (codiceLetto.equals(codiceAutorizzato1) || (codiceLetto.equals(codiceAutorizzato2)) || (codiceLetto.equals(codiceAutorizzato3)) || (codiceLetto.equals(codiceAutorizzato4))) {
    return true;
  } else {
    return false;
  }
}


void Apri() {
  digitalWrite(Releserratura, HIGH );
  Serial.println("Releserratura, HIGH");

  delay(delayserr);
  digitalWrite(Releserratura, LOW );
  Serial.println("Releserratura, LOW");


}

imdany · February 2, 2021, 10:37am

ho visto delle eeprom AT 24C256 IC e farebbero al caso mio perchè ho il copiatore di queste memorie,quanti id riesco a memorizzare su una scheda da 256?? la stringa di lettura della chiave e di 10 numeri decimali.
grazie

fabpolli · February 2, 2021, 10:38am

Tralascio il fatto che usi la classe String perché anche se non è bene usarla per i problemi che causa discussi più volte sul forum, ti consiglio comunque di usare la classe indicata qui che ti da solito modo di usarla senza gi svantaggi della classe String.
Se la SD per te è troppo lenta potresti usare EEPROM esterne e andare quindi ad utilizzare una Arduino UNO o nano o micro insomma se deve solo aprire il cancello dopo la lettura due mega sono veramente sprecati.
Se poi non vuoi usare EEPROM esterne per semplificarti la vita, visto che i due MEGA sono tanto vicini da "condividere" il medesimo lettore potresti pensare di, come suggerito in precedenza, demandare ad un MEGA di leggere e validare il tag e l'altro arduino potrebbe essere una UNO che colloquia tramite SoftwareSerial con il MEGA e si fa dire se aprire o meno. In questo modo riduci anche il costo totale.
Considera anche il fatto che in questo modo se devi invalidare un codice o aggiungerne uno nuovo sarai costretto a riprogrammare la MEGA mentre con una SD ti basterebbe estrarla ed aggiornare il file. Se ci mette una vita a leggerlo può dipendere da come avevi scritto il codice perché aprire un file e leggere 300 righe non dovrebbe impiegare così tanto tempo.
Magari se metti anche il codice che usavi possiamo vedere di aiutarti nel migliorarlo

fabpolli · February 2, 2021, 10:47am

imdany:
ho visto delle eeprom AT 24C256 IC e farebbero al caso mio perchè ho il copiatore di queste memorie,quanti id riesco a memorizzare su una scheda da 256?? la stringa di lettura della chiave e di 10 numeri decimali.
grazie

sono 32K x 8 (256 Kbit) quindi 32K se memorizzati come stringhe sono più di 2500 codici consideranto i caratteri CRLF di ogni riga, se ometti uno di questi o suddividi i codici con un solo carattere (Es. la virgola) aumenti ancora di più il numero di codici gestibili

cotestatnt · February 2, 2021, 11:21am

Comincio a pensare che le board Arduino costino troppo poco... troppo facile la tentazione di prenderne un'altra con l'unico risultato di scrivere del codice "non-sense".

I tuoi codici RFID sono tali che per memorizzarli è sufficiente un unsigned long, ovvero 4 byte di memoria.
Tu invece salvi l'equivalente in stringa di un numero, usando quindi 1 byte per ciascuna singola cifra e complicando inutilmente gestione e verifica del codice letto dall'RFID.

fabpolli · February 2, 2021, 11:36am

Quoto @cotestatnt, non avevo fatto caso al codice, e davo per scontato che il lettore avesse una libreria che restituisse una stringa, da li l'uso. Invece poi ho visto questa:

codiceLetto += String (wg.getCode(), DEC);//bella soluzione di coversione

quindi la libreria è fatta bene e restituisce il codice numerico letto e poi viene convertito in stringa.

docdoc · February 2, 2021, 11:52am

imdany:
ho provato ad usare una SD card ma poi quando cerco l'id ci mette una vita

Allora, se il motivo è "solo" quello di poter avere tanti ID da memorizzare, vedendo il tuo codice ora mi è tutto molto più chiaro.

Come già ti ha detto cotestatnt, evita la classe "String" in favore delle "stringhe C" che sono degli array di char con carattere terminatore 0x0: è molto importante che tu prenda pratica con queste perché con le risorse limitate di Arduino devi saperle usare;
Io sono per cercare di evitare conversioni inutili: i codici delle card leggili e memorizzali in binario (unsigned long, come sempre cotestatnt ti ha suggerito) invece che come stringa decimale, perché così dimezzi l'occupazione (4 byte invece di 8 ossia 7 cifre +1 per il terminatore della stringa); inoltre essendo un array di valori costanti, magari dichiaralo "const";
Quando si cerca di "dimensionare" un progetto è sempre bene avere una stima realistica di cosa si vuole manipolare; nel tuo caso vedo che vorresti avere circa 400 elementi quindi, per quanto detto sopra, l'array "unsigned long" con tutti i codici delle card occuperebbe circa 1.6 kbyte di SRAM e dato che il Mega ha 8 kbyte, penso che potrebbe andare tranquillamente, a patto che tu rimuova tutte le "String" e magari con la funzione "F()" sposti in Flash e riduci di dimensione tutte le (quasi inutilmente lunghe) stringhe costanti che hai messo nei vari Serial.print().
Mi sfugge per quale motivo la ricerca su SD sarebbe talmente lenta da essere per te inaccettabile, sospetto che anche qui tu abbia fatto largo uso di variabili "String", e magari anche un formato del file non propriamente ottimizzato: ad es. se proprio vuoi renderlo "leggibile" fai una riga per ogni card, nella quale metti il valore esadecimale dei 4 byte, quindi anche della card rilevata comporrai una stringa (ma non "String", una "stringa C" dimensionata per contenere 8 caratteri più terminatore quindi per sicurezza fai "char codice[10]") e la confronti riga per riga con i dati del file, sempre leggendo ogni riga come stringa "char riga[10]" ed usando la funzione "strcmp()".
Facci vedere anche il codice che avevi fatto per la SD, che secondo me puoi anche risolvere con quella.

cotestatnt · February 2, 2021, 12:07pm

docdoc:

Come già ti ha detto cotestatnt, evita la classe "String" in favore delle "stringhe C"

Veramente io gli avevo suggerito di evitare proprio del tutto l'utilizzo di qualsiasi tipo di stringhe visto che non sono necessarie ;D

imdany · February 2, 2021, 1:30pm

#include <SD.h>
File myFile;
//char buf[6];//12//10//12
char buf[7];//12//10//12//riga 185 circa

//char *mystr;
//String miastringa;
//** MOSI - pin 11
//** MISO - pin 12
//** CLK - pin 13
//** CS - pin 4

//////////////28/01/2021



#include <Wiegand.h>


#define FALSE 0
#define TRUE  1

WIEGAND wg;
//attenzione le lettere delle id le vuole in minuscolo se no non le accetta come giuste
String codiceLetto = "";



void setup() {

  //////////////28/01/2021
  //mystr = buf;
  //////////////28/01/2021
  Serial.begin(9600);
  Serial.println("num...0530.....");



  // PIN assigment and declaration for Arduino Mega
  //GATE A
  wg.D0PinA = 2;
  wg.D1PinA = 3;
  delay(75);
  //GATE B
  //con arduino uno va solo con pin 2 e 3...
  //usare mega 2560 se si vogliono piu gate
  wg.D0PinB = 18; //18
  wg.D1PinB = 19;  //19
  delay(75);
  //GATE C
  wg.D0PinC = 20;
  wg.D1PinC = 21;
  delay(75);
  // Reader enable

  wg.begin(TRUE, TRUE, TRUE);  // wg.begin(GateA , GateB, GateC)
  //wg.begin(FALSE, FALSE, TRUE);  // wg.begin(GateA , GateB, GateC)

}
//void(* Riavvia)(void) = 0;
void loop() {



  if (wg.available())
  {
    codiceLetto = "";
    //  codiceLetto += String (wg.getCode(), HEX);//bella soluzione di coversione
    codiceLetto +=  String(wg.getCode(), DEC);//bella soluzione di coversione

    //    buf1 +=  String (buf[8], DEC);

    // String codiceLetto = wg.getCode;
    Serial.print("Wiegand HEX = ");
    // Serial.print(wg.getCode(), HEX);
    Serial.print(wg.getCode(), HEX);
    Serial.print(", DECIMAL = ");
    Serial.print(wg.getCode());
    Serial.print(", Gate= ");
    Serial.print(wg.getGateActive());
    Serial.print(", Type W");
    Serial.println(wg.getWiegandType());
    Serial.print("codiceLetto=" );
    Serial.println(codiceLetto );

    /* Serial.print("lunghezza codiceLetto =" );
      Serial.println ( sizeof (codiceLetto) );

      Serial.print("lunghezza  wg.getCode() =" );
      Serial.println ( sizeof ( wg.getCode()) );

      Serial.print("lunghezza buf =" );
      Serial.println ( sizeof (buf) );


      Serial.println("prima del test" );

      Serial.print("wg.getCode  = " );
      Serial.println( wg.getCode());
      Serial.print("wg.getCode =" );
      Serial.println( wg.getCode());
    */

    test();
    // Serial.println("usciti dal test" );
    Serial.print("*************************************************");
    /* if (verificaCodice(codiceLetto, codiceAutorizzato1) || verificaCodice(codiceLetto, codiceAutorizzato2)
         || verificaCodice(codiceLetto, codiceAutorizzato3) || verificaCodice(codiceLetto, codiceAutorizzato4) || verificaCodice(codiceLetto, codiceAutorizzato5))  {



       Serial.println("Bella-............");
       codiceLetto = "";

      }
      else {
       Serial.println("no   ...........");
      }*/

  }
}
// Questa funzione verifica se il codice Letto è autorizzato
boolean verificaCodice(String codiceLetto, String codiceAutorizzato) {
  if (codiceLetto.equals(codiceAutorizzato)) { // if (codiceLetto.equals(codiceAutorizzato1) || (codiceLetto.equals(codiceAutorizzato2)) || (codiceLetto.equals(codiceAutorizzato3)) || (codiceLetto.equals(codiceAutorizzato4))) {
    return true;
  } else {
    return false;
  }
}
////////////////////////////////////

//////////////28/01/2021
void test() {//cerca nel sd il valore "codiceLetto"  riga 94
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
  // Serial.println("siamo nel test" );
  // Serial.print("codiceletto no string" );
  //  Serial.println(codiceLetto);
  Serial.print("Initializing SD card...");
  // On the Ethernet Shield, CS is pin 4. It's set as an output by default.
  // Note that even if it's not used as the CS pin, the hardware SS pin
  // (10 on most Arduino boards, 53 on the Mega) must be left as an output
  // or the SD library functions will not work.
  pinMode(10, OUTPUT);//10

  if (!SD.begin(4)) {
    Serial.println("initialization failed!");
    return;
  }
  Serial.println("initialization done.");

  // re-open the file for reading:
  myFile = SD.open("test.csv");
  if (myFile) {
    Serial.println("Trovato test.csv:");
    Serial.println("*************************************************");
    // read from the file until there's nothing else in it:


    /////////////////////
  /*  String ReadLine;

    int c;
    while ((c = myFile.read()) > 0) {
      ReadLine += (char)c;
      if ((char)c == '\n') {
        if (c > 0) ReadLine = "";
      }
      // var=c;
      // }

*/
      //////////////////////

     while (myFile.available()) {

            //   myFile.readStringUntil('\n');//12/10
           myFile.read(buf,7);//12/10   riga 9 circa

            //  if (strncmp(buf, "6170131", 7) == 0)//10//if (strncmp(buf, "1218438846", 10) == 0)
    

      unsigned long number = atol(buf); // convert result string to numeric value
      //int number = atol(buf); // convert result string to numeric value

      //if (strncmp(buf, wg.getCode(), 7) == 0)//10//if (strncmp(buf, "1218438846", 10) == 0)
     if ( number == wg.getCode())//<----questo funziona il 29/01/2021

   // if ( ReadLine == wg.getCode())//<----questo funziona il 29/01/2021
   


        //  if (strncmp(buf, codiceLetto[8], 10) == 0)//if (strncmp(buf, "1218438846", 10) == 0)
        // if (strncmp(buf, wg.getCode(), 10) == 0)//if (strncmp(buf, "1218438846", 10) == 0)
        // if (strncmp(buf, wg.getCode(), 10) == 0) //if (strncmp(buf, "1218438846", 10) == 0)
        // if ( buf == wg.getCode())//codiceLetto
        // if ( buf == ( codiceLetto[10]) )//String(wg.getCode(), DEC
        // if ( buf == (char(wg.getCode()), DEC) )//String(wg.getCode(), DEC

        // unsigned long number = strtoul( buf, NULL, 9 );
        //  unsigned long number = strtoul( buf,NULL , 9 );


        // if (strncmp(number, wg.getCode(), 8) == 0) //if (strncmp(buf, "1218438846", 10) == 0)
        // if ((number) == (wg.getCode()) )//String(wg.getCode(), DEC

        // if (strncmp(buf, codiceLetto[9], 11) == 0)//if (strncmp(buf, "1218438846", 10) == 0)
        // if ((buf) == (wg.getCode()) )//String(wg.getCode(), DEC

        // if ((buf1) == (wg.getCode()) )//String(wg.getCode(), DEC

      {
        Serial.print("Match!");
        Serial.print("--->");
        Serial.print((wg.getCode()));
        Serial.print("  =  ");//
        Serial.println(number);

        break;
      }
      else {


        Serial.println("***********************************");
        Serial.println("non trovato !!!");

       Serial.print("number = ");
      Serial.println(number);


     /*   Serial.print("ReadLine = ");
        Serial.println(ReadLine);
        Serial.print("lunghezza  ReadLine =" );
        Serial.println ( sizeof ( ReadLine) );

*/

        Serial.print("codiceLetto=" );
        Serial.println(codiceLetto );
        Serial.print("lunghezza  codiceLetto =" );
        Serial.println ( sizeof ( codiceLetto) );
        Serial.println("***********************************");


      }

      /* myFile.read(buf,8);
        if(strncmp(&buf[0],"18429880",8)==0)
        {
           Serial.println("Match!");
        }*/
    }
    // close the file:

    myFile.close();
    // Serial.println("non trovato !!!");
  } else {
    // if the file didn't open, print an error:
    Serial.println("error opening test.csv");
  }

}

docdoc ecco il codice per sd ....ma qui sono in alto mare!!

fabpolli · February 2, 2021, 3:12pm

Premesso che non ho esperienza con il lettore in se per se ma, metti anche il riferimento preciso alla libreria che usi perché quella che trovo sul sito Arduino è completamente differente.
Così com'è non mi torna il metodo getCode che viene richiamato N volte, cosa restituisce il codice parziale, sempre il medesimo codice finché un altra tessera non viene scansionata?
In ogni caso il tuo codice è molto confusionario perché è la somma di copia incolla selvaggi da varie parti (suppongo).
Ti propongo di andare per gradi perché così diventa difficile arrivare in fondo e aiutarti.
Riparti con un programma minimale che non fa altro che leggere le tessere abilitate dalla SD passando un codice fisso valido o non valido alla funzione in modo da renderti conto quanto tempo serve per l'operazione e se non soddisfacente posti il codice (che farà solo quello) e vediamo se ci sono miglioramenti da applicare.
Quando quello va spedito potrai integrare questa funzione nel programma generale in un batter d'occhio.
Poi, la libreria che usi per il dispositivo, se il metodo che restituisce il codice richiede una String io penserei anche a cambiare la libreria di gestione e passare ad esempio a quella indicata sul sito Arduino che non necessita di String e ti permetterà poi di leggere e scrivere i codici in un formato che occupa meno memoria e che sarà anche più rapido a ricercare se il codice è abilitato o meno.

gpb01 · February 2, 2021, 3:26pm

Io la butto li ...
... chi ha voglia di studiare e capire lo fa, altrimenti pazienza ... :

Bubble sort ... è il più banale in assoluto e permette di mettere in ordine (ascendente o discendente) tutte le chiavi presenti.
Una volta che le chiavi sono tutte ordinate ... ricerca dicotomica, detta anche ricerca binaria ...
... con un massimo di log₂(Numero_chiavi_totali) si trova l'elemento cercato (es. con 16384 chiavi presenti, bastano al massimo 14 tentativi per trovare, o dire che non è presente, una chiave).

Sono algoritmi BANALI ... basta andare a studiare un po ...

Guglielmo

docdoc · February 2, 2021, 3:28pm

Anche se ho solo dato una rapida occhiata al tuo codice, concordo al 100% con fabpolli, sono praticamente le stesse cose che avrei scritto io.

Se vuoi usare la scheda SD (essenzialmente perché non vuoi avere limiti sul numero di card e soprattutto vuoi poter modificare la lista sostituendo la SD, il che ha un senso) ti dico anche io di andare per gradi.

Inizia a fare un primo sketch usando la libreria standard SD Arduino, e che sia in grado semplicemente di leggere i dati da una SD (quindi un file testo dal nome fisso, un codice per riga, formattato in esadecimale, nel tuo caso se gli id sono di 4 byte allora le righe avranno sempre 8 caratteri seguiti dalla coppia standard di caratteri "a capo" ossia "\r\n") e mostrarli sulla seriale.

Quando questo funziona, allora "inscatola" tutto in una funzione (es. "bool controllaCard()") alla quale passando in una variabile globale la stringa esadecimale della card, ti restituisce "true" se la card è stata trovata nella lista, e "false" in caso contrario. Per test chiama due volte la funzione, una volta con un codice buono ed una seconda con un codice sconosciuto.

Fatto questo, il passo successivo è aggiungere il "vero" lettore ossia popolare la variabile globale con il vero codice acquisito dal lettore (usando la libreria che ti ha indicato fabpolli) e mostrare il risultato.

E ricorda due cose:

Niente "String"
Indenta bene il codice almeno prima di postarlo (premi Ctrl-T nell'IDE) magari rimuovendo anche le righe vuote inutili (se vuoi separare blocchi di codice o funzioni, usa UNA riga vuota).

imdany · February 2, 2021, 3:51pm

fabpolli:
non mi torna il metodo getCode che viene richiamato N volte

la libreria che uso è la Wiegand-V3-Library-for-all-Arduino-master. per ora grazie ,comincio con tutti i consigli che mi avete dato,ma mi conviene partire con la sd e non sdfat?

imdany · February 2, 2021, 8:51pm

fabpolli:
Poi, la libreria che usi per il dispositivo, se il metodo che restituisce il codice richiede una String io penserei anche a cambiare la libreria di gestione e passare ad esempio a quella indicata sul sito Arduino che non necessita di String e ti permetterà poi di leggere e scrivere i codici in un formato che occupa meno memoria e che sarà anche più rapido a ricercare se il codice è abilitato o meno.

ok , ho provato ad usare le librerie di arduino ma non capisco come ricavare l'id letto, su seriale lo compone in piu cicli .

    Serial.print(data[i] >> 4, 16);   
    Serial.print(data[i] & 0xF, 16);

proveriei con qualcosa del genere per ricavarmelo

   c=rfid.read(); <------ ma questo con cosa lo sostituisco?
    msg += c;

void receivedData(uint8_t* data, uint8_t bits, const char* message) {
  Serial.print(message);
  Serial.print(bits);
  Serial.print("bits / ");
  //Print value in HEX
  uint8_t bytes = (bits + 7) / 8;
  for (int i = 0; i < bytes; i++) {
    Serial.print(data[i] >> 4, 16);   
    Serial.print(data[i] & 0xF, 16);
    ////////////

    ////////////
  }
  Serial.println();



}

Grazie

fabpolli · February 3, 2021, 8:23am

Come già suggerito devi studiarti le stringhe classiche del C (array di char), al posto di fare le due print sulla seriale devi inserire i valori in un array, penso sommando le due operazioni per ciascun elemnto dell'array. Ma non avendo mai usato quel dispositivo e non avendo messo l'output del monitor seriale e il codice che hai passato è difficile darti una risposta precisa.
Ovvero, ad esempio, ho letto la tessera con codice 1234567890 e sulla seriale leggo
2
3
1
2
3
ecc.
Così magari anche chi non ha il dispositivo può cercare di risponderti con qualche dato in mano

cotestatnt · February 3, 2021, 8:56am

Scusate, ma a me sfugge proprio il senso dell'utilizzo di stringhe e di tutte le conversioni e i passaggi necessari per utilizzarle, quando il risultato della lettura di una tessera RFID è un unsigned long....

// potresti popolare l'array leggendo un elenco dalla SD, oppure prevedere 
// una modalità che ti consente di aggiungere dinamicamente (entro un limite predefinito per semplificare l'array)
// una nuova card ad esempio premendo un pulsante o qualche meccanismo più sicuro
unsigned long enabledCards[] = { 1000001, 1000002, 1000003, 1000004, 1000005 };   

...
if (wg.available())
{
  // Salvo il codice della scheda in una variabile lcoale
  unsigned long actualCode = wg.getCode();

  // Ciclo l'array per tutta la sua lunghezza e verifico se è abilitata
  // Se gli elementi dell'array sono ordinati, si possono usare gli algoritmi suggeriti da Guglielmo per una ricerca più efficiente.

  int arrayLen = sizeof(enabledCards)/sizeof(unsigned long); // può essere messo direttamente nel for
  for(int i=0; i<arrayLen;  i++) {

      // contronto l'elemento i dell'array con il codice letto
      if( actualCode == enabledCards[i]) {  // NON SERVE ALTRO!
        Serial.print("Card with id ");
        Serial.print(actualCode, HEX);
        Serial.println( "enabled");
      }
   }
}
...

Topic		Replies	Views
lettori rfid in parallelo Hardware	13	2577	May 7, 2021
comunicazione seriale tra arduino uno e arduino mega 2650 Software	11	2388	May 7, 2021
Lettore RFID Generale	7	1369	May 7, 2021
lettore rfid e motore ? Hardware	3	1030	May 7, 2021
apricancello con rfid Hardware	13	3668	May 7, 2021

2 arduino con un lettore rfid

Related Topics