Arduino UNO con Lettore NFC/RFID PN532

Buongiorno a tutti,
come da oggetto sto impazzendo con un lettore NFC/RFID acquistato su internet.

Viene venduto con queste caratteristiche: Lettore/scrittore NFC/RFID dotato di 1 LED di stato, antenna integrata sul PCB, interfaccia di comunicazione I²C, SPI e HSU (High Speed UART). Può funzionare come lettore/scrittore di RFID card, come lettore NFC con smartphone Android e in modalità wireless con due dispositivi identici. Può essere utilizzato con Arduino per realizzare dispositivi di controllo accessi, ecc. La confezione comprende il lettore, un trasponder a portachiavi, un trasponder a tessera e i cavetti di collegamento.

Ho scaricato le Librerie PN532, PN532_HSU, PN532_I2C, PN532_SPI in modo da poterlo utilizzare come voglio.

Mi sono messo alla ricerca di un programma già fatto su google ed ho trovato molte cose carine tra cui una guida per vedere se tutto funziona prima di creare apri porta o altro.
Ho aperto l'esempio contenuto nelle librerie scaricate (iso14443a_uid) e notando che veniva inclusa la libreria PN532_SPI.h ho programmato il lettore come SPI.

Collegato il tutto ad Arduino UNO ho inviato il programma e da Monitor Seriale ho atteso la lettura della tessera quando l'ho avvicinata al lettore.

Il messaggio è stato:
Hello!
Didn't find PN53x board

Non trovo PN53x ??? :o

Da qui in poi ho trascorso almeno 3 ore su google alla ricerca del problema ma niente notizie utili.

Lo Sketch è il seguente:

/**************************************************************************/
/*! 
    This example will attempt to connect to an ISO14443A
    card or tag and retrieve some basic information about it
    that can be used to determine what type of card it is.   
   
    Note that you need the baud rate to be 115200 because we need to print
    out the data and read from the card at the same time!

    To enable debug message, define DEBUG in PN532/PN532_debug.h
    
*/
/**************************************************************************/

#include <SPI.h>
#include <PN532_SPI.h>
#include "PN532.h"

PN532_SPI pn532spi(SPI, 10);
PN532 nfc(pn532spi);

void setup(void) {
  Serial.begin(115200);
  Serial.println("Hello!");

  nfc.begin();

  uint32_t versiondata = nfc.getFirmwareVersion();
  if (! versiondata) {
    Serial.print("Didn't find PN53x board");
    while (1); // halt
  }
  
  // Got ok data, print it out!
  Serial.print("Found chip PN5"); Serial.println((versiondata>>24) & 0xFF, HEX); 
  Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC); 
  Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
  
  // Set the max number of retry attempts to read from a card
  // This prevents us from waiting forever for a card, which is
  // the default behaviour of the PN532.
  nfc.setPassiveActivationRetries(0xFF);
  
  // configure board to read RFID tags
  nfc.SAMConfig();
    
  Serial.println("Waiting for an ISO14443A card");
}

void loop(void) {
  boolean success;
  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
  uint8_t uidLength;                        // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
  
  // Wait for an ISO14443A type cards (Mifare, etc.).  When one is found
  // 'uid' will be populated with the UID, and uidLength will indicate
  // if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, &uid[0], &uidLength);
  
  if (success) {
    Serial.println("Found a card!");
    Serial.print("UID Length: ");Serial.print(uidLength, DEC);Serial.println(" bytes");
    Serial.print("UID Value: ");
    for (uint8_t i=0; i < uidLength; i++) 
    {
      Serial.print(" 0x");Serial.print(uid[i], HEX); 
    }
    Serial.println("");
    
    // wait until the card is taken away
    while (nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, &uid[0], &uidLength)) {}
  }
  else
  {
    // PN532 probably timed out waiting for a card
    Serial.println("Timed out waiting for a card");
  }
}

lo schema ?
Mi intendo dove hai collegato il lettore ? Perché se hai messo PN532_SPI.h, è naturale che dovrai collegare alla SPI dell' Arduino. Non lo vedo dichiarato nello sketch, dovrebbe essere il piedino 12.
Poi se vuoi sapere cosa succede dovresti mettere qualche Serial.print(variabile_da_controllare, DEC) nei punti da controllare.

Ciao,
lo schema di collegamento l'ho preso dal manuale che ho allegato.

SCK --> Pin 13
MISO --> Pin 12
MOSI --> Pin 11
SS --> Pin 10

Sul programma viene dichiarato questo PN532_SPI pn532spi(SPI, 10);

Quello che non capisco è perchè mi dice che non trova PN532??

Ho seguito alla lettera il manuale (http://www.elechouse.com/elechouse/images/product/PN532_module_V3/PN532_%20Manual_V3.pdf) e in tutti i casi non funziona.
Ho provato ad avvicinare anche il cellulare, Galaxy S7 Edge ma non emette nessun suono. Mentre se avvicino in cellulare ad una scheda, fornita con il lettore, emette il suono di lettura e mi dice non valida.

Naturalmente ...

  1. hai impostato i due piccoli switch per SPI (OFF-ON) ?

  2. Hai provato uno dei loro esempi così come descritto nel manuale che hai linkato ?

Guglielmo

gpb01:
Naturalmente ...

  1. hai impostato i due piccoli switch per SPI (OFF-ON) ?

  2. Hai provato uno dei loro esempi così come descritto nel manuale che hai linkato ?

Guglielmo

Ciao Guglielmo,

naturalment ho impostato i due micro switch per la configurazione SPI ed ho provato l'esempio riportato per SPI.

Poi ho provato con la modalità I2C sempre impostando i micro switch in I2C ma niente da fare :frowning:

... quindi non va sia in I2C che SPI ... ::slight_smile:

Due possibilità ...

  1. modulo guasto

  2. ... non è che la posizione di quei micro switch è invertita ?
    Prova a mettere gli switch come li metteresti per I2C e collegalo in SPI o viceversa, mettili per SPI e provalo in I2C.

Oltretutto, comunque, messo in I2C (in un modo o nell'altro), lo Scanner I2C, se il modulo funziona, lo DEVE comunque vedere come indirizzo I2C che risponde.

Guglielmo

gpb01:
... quindi non va sia in I2C che SPI ... ::slight_smile:

Due possibilità ...

  1. modulo guasto

Venduto presumo nuovo perchè era in confezione sigillata ma tutto può essere. Il led verde si accende ma quello vuol dir poco >:(

  1. ... non è che la posizione di quei micro switch è invertita ?
    Prova a mettere gli switch come li metteresti per I2C e collegalo in SPI o viceversa, mettili per SPI e provalo in I2C.

Oltretutto, comunque, messo in I2C (in un modo o nell'altro), lo Scanner I2C, se il modulo funziona, lo DEVE comunque vedere come indirizzo I2C che risponde.

A questo non avevo pensato, stasera provo e vi faccio sapere :smiley:

Grazie per l'aiuto

gpb01:
Oltretutto, comunque, messo in I2C (in un modo o nell'altro), lo Scanner I2C, se il modulo funziona, lo DEVE comunque vedere come indirizzo I2C che risponde.

Guglielmo

Ciao Guglielmo,
ho fatto la prova con lo Scanner I2C ed il risultato è che me lo trova quindi il modulo funziona.

Monitor Seriale:
Scanning...
I2C device found at address 0x24 !
done

Ora devo capire perchè non viene visto dallo sketch già compreso nelle librerie PN532 :frowning:

sgamino:
Ciao Guglielmo,
ho fatto la prova con lo Scanner I2C ed il risultato è che me lo trova quindi il modulo funziona.

Bene, questo è già un primo punto ...
... a questo punto prova a configurare gli esempi abilitando il colloquuo I2C (ho visto che ci sono delle #ifdef da toccare) e vedi come si comporta :wink:

Guglielmo

Fine delle prove, mi arrendo.

Dal monitor seriale adesso scrive solamente Hello!

Ho provato mille modi ma nulla, ho persino trovato un'altra discussione dove dicevano di mettere la VCC da 5V a 3,3V e si risolveva il problema.

Nel mio caso non funziona nemmeno a 3,3V

Lo cestino e faccio prima....vale come esperienza personale, la prossima volta acquisterò quello che funziona regolarmente leggendo i forum.
Ho capito che non vale avere un PN532 qualsiasi per leggere le tessere NFC o altro, questa scheda " NFC MODULE V3 ELECHOUSE" sta facendo impazzire il web ed io puntualmente l'ho acquistata :smiling_imp:

Grazie a tutti per l'aiuto che mi avete dato fino ad ora

Spediscila a me :D.

sgamino:
... vale come esperienza personale, la prossima volta acquisterò quello che funziona regolarmente ...

Adafruit fa degli ottimi prodotti, tutti ben supportati e con le relative librerie per Arduino ... guarda QUESTO che è proprio uno shield Arduino (esiste anche la versione board separata).

Guglielmo

SukkoPera:
Spediscila a me :D.

L'ho pagata 25 euro e mi costerebbe più di spedizione :slight_smile:

Però ho il dubbio, se devo spedirtela perchè sai farla funzionare allo puoi dire la tua ahahahahhahahhhh

Apparte tutto, prendo il consiglio di Guglielmo e vado su Adafruit :slight_smile:

25€??? Ma allora DEVE funzionare, prova a perderci ancora un po' di tempo! Ho cinesate da meno di 2€ che funzionano come orologi...

Ciao SukkoPera,
certo 25 euro non sono pochi per una scheda del genere e dovrei continuare a provare, ma sinceramente ho tanti dubbi ::slight_smile:

Il codice qui sotto non l'ho provato ma è simile a quello che ieri sera mi ha portato a dire basta, nel mio caso sembra che venga eseguito solo una parte di codice.
Dal monitor seriale vedo solo la scritta Hello! quindi il codice dopo la ricerca del PN532 sembra non venga nemmeno letto.
La differenza tra questo programma e quello sotto è #include <EEPROM.h> e l'utilizzo di led sui pin 2-3-4

#include <EEPROM.h>

/**************************************************************************/
/*! 
    This example will attempt to connect to an ISO14443A
    card or tag and retrieve some basic information about it
    that can be used to determine what type of card it is.   
   
    Note that you need the baud rate to be 115200 because we need to print
    out the data and read from the card at the same time!

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

int triggerPin1 = 2;
int triggerPin2 = 3;
int triggerPin3 = 4;
// choose to SPI or I2C or HSU
#if 0
  #include <SPI.h>
  #include <PN532_SPI.h>
  #include "PN532.h"

  PN532SPI pn532spi(SPI, 10);
  PN532 nfc(pn532spi);
#elif 0
  #include <PN532_HSU.h>
  #include <PN532.h>
      
  PN532_HSU pn532hsu(Serial1);
  PN532 nfc(pn532hsu);
#else 
  #include <Wire.h>
  #include <PN532_I2C.h>
  #include <PN532.h>

  PN532_I2C pn532i2c(Wire);
  PN532 nfc(pn532i2c);
#endif

void setup(void) {
  pinMode(triggerPin1, OUTPUT);
  pinMode(triggerPin2, OUTPUT);
  pinMode(triggerPin3, OUTPUT);
  Serial.begin(115200);
  Serial.println("Hello!");

  nfc.begin();

  uint32_t versiondata = nfc.getFirmwareVersion();
  if (! versiondata) {
    Serial.print(versiondata);
    Serial.print("PN53x key scanner board not online");
    while (1); // halt
  }
  
  // Got ok data, print it out!
  Serial.print("Found key scanner board PN5"); Serial.println((versiondata>>24) & 0xFF, HEX); 
  Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC); 
  Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
  
  // Set the max number of retry attempts to read from a card
  // This prevents us from waiting forever for a card, which is
  // the default behaviour of the PN532.
  nfc.setPassiveActivationRetries(0xFF);
  
  // configure board to read RFID tags
  nfc.SAMConfig();
    
  Serial.println("Waiting for a valid card");
}

void loop(void) {
  String ringUid;
  boolean success;
  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
  uint8_t uidLength;                        // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
  
  // Wait for an ISO14443A type cards (Mifare, etc.).  When one is found
  // 'uid' will be populated with the UID, and uidLength will indicate
  // if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, &uid[0], &uidLength);
  
  if (success) {
    // Display some basic information about the card
    Serial.println("Found an ISO14443A card");
    Serial.print("  UID Length: "); Serial.print(uidLength, DEC); Serial.println(" bytes");
    Serial.print("  UID Value: ");
    for (uint8_t i = 0; i < uidLength; i++)
    {
      Serial.print("..");
      Serial.print(uid[i], HEX);
      ringUid += String(uid[i], HEX);

    }
    Serial.println(ringUid + "\n");
    if (ringUid == "xxxxxxxxxxx" || ringUid == "xxxxxxxxxxxx"){  // put your authorised UID in here
      Serial.println("PERMISSION GRANTED, DOOR UNLOCKED");
      digitalWrite(triggerPin1, HIGH);   // triggers unlock output for central locking
      delay(1000);                  // waits for a second
      digitalWrite(triggerPin1, LOW);    // removes triggered output
      digitalWrite(triggerPin3, LOW);    // Removes triggered alarm output
    }
    else if (ringUid == "xxxxxxxxxxxx"){  // put your authorised UID in herev
      Serial.println("PERMISSION GRANTED, SYSTEMS TRIGGER");
      digitalWrite(triggerPin2, HIGH);   // sets latching relay trigger on ie for ignition mode in car to allow button start - button start must disable reads until button turns engine off again
      delay(1000);                  // waits for a second
      digitalWrite(triggerPin2, LOW);    // removes latching relay trigger
      digitalWrite(triggerPin3, LOW);    // Removes triggered alarm output
    }
    else{
      Serial.println("I'M AFRAID I CAN'T ALLOW THAT DAVE");
      digitalWrite(triggerPin3, HIGH);   // Trigger latching relay to alarm system
      delay(1000);                  // waits for a second      
    }
  }
}

Con la modifica che ho fatto qui sotto eliminando parte di codice riesco a leggere Waiting for an ISO14443A card, passo la carta o tutte quelle che ho ma non succede nulla.
Quindi posso darti ragione che con 25 euro deve funzionare. :slight_smile:
Proverò l'ultima volta cambiando da I2C a SPI

/**************************************************************************/
/*!
    This example will attempt to connect to an ISO14443A
    card or tag and retrieve some basic information about it
    that can be used to determine what type of card it is.   
   
    Note that you need the baud rate to be 115200 because we need to print
    out the data and read from the card at the same time!

    To enable debug message, define DEBUG in PN532/PN532_debug.h
   
*/
/**************************************************************************/

 #include <Wire.h>
 #include <PN532_I2C.h>
 #include <PN532.h>

  PN532_I2C pn532i2c(Wire);
  PN532 nfc(pn532i2c);

void setup(void) {
  Serial.begin(115200);
  Serial.println("Hello!");

  nfc.begin();

/*
  uint32_t versiondata = nfc.getFirmwareVersion();
  if (! versiondata) {
    Serial.print("Didn't find PN53x board");
    while (1); // halt
  }
 
  // Got ok data, print it out!
  Serial.print("Found chip PN5"); Serial.println((versiondata>>24) & 0xFF, HEX);
  Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC);
  Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
 
  // Set the max number of retry attempts to read from a card
  // This prevents us from waiting forever for a card, which is
  // the default behaviour of the PN532.
  nfc.setPassiveActivationRetries(0xFF);
 
  // configure board to read RFID tags
  nfc.SAMConfig();
 
*/
  
  Serial.println("Waiting for an ISO14443A card");
}

void loop(void) {
  boolean success;
  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
  uint8_t uidLength;                        // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
 
  // Wait for an ISO14443A type cards (Mifare, etc.).  When one is found
  // 'uid' will be populated with the UID, and uidLength will indicate
  // if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, &uid[0], &uidLength);
 
  if (success) {
    Serial.println("Found a card!");
    Serial.print("UID Length: ");Serial.print(uidLength, DEC);Serial.println(" bytes");
    Serial.print("UID Value: ");
    for (uint8_t i=0; i < uidLength; i++)
    {
      Serial.print(" 0x");Serial.print(uid[i], HEX);
    }
    Serial.println("");
   
    // wait until the card is taken away
    while (nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, &uid[0], &uidLength)) {}
  }
  else
  {
    // PN532 probably timed out waiting for a card
    Serial.println("Timed out waiting for a card");
  }
}

No, aspetta, continuna a provare con I2C ... aggiungendo le due resistenze di pull-up che ci devono sempre essere su un bus I2C (vero che lo scanner è riuscito a leggere l'address, ma può essere stato un caso e, se non ho visto male, non mi sembra che il manuale dica che sono già presenti sulla scheda). Quindi, metti due 4.7kΩ tra SCL e Vcc e SDA e Vcc e segui le indicazioni che vedi a pag.4 per il passaggio dei cavi I2C sopra l'antenna.

Per le prove usa un LORO esempio senza metterci le mani se non per attivare la parte I2C. Così siamo sicuri.

Guglielmo

gpb01:
No, aspetta, continuna a provare con I2C ... aggiungendo le due resistenze di pull-up che ci devono sempre essere su un bus I2C (vero che lo scanner è riuscito a leggere l'address, ma può essere stato un caso e, se non ho visto male, non mi sembra che il manuale dica che sono già presenti sulla scheda). Quindi, metti due 4.7kΩ tra SCL e Vcc e SDA e Vcc e segui le indicazioni che vedi a pag.4 per il passaggio dei cavi I2C sopra l'antenna.

Per le prove usa un LORO esempio senza metterci le mani se non per attivare la parte I2C. Così siamo sicuri.

Guglielmo

Ho trovato su youtube un video dove un utente fa vedere il corretto funzionamento in I2C ma utilizza anche i pin IRQ e RST0 del lettore.
Sono collegati su D0 e D1, potrei provare anche in questo modo modificando #include "Adafruit_PN532/Adafruit_PN532.h" con PN532_I2C.h ???

/**************************************************************************/
/*! 
    @file     readMifareClassic.cpp
    @author   Adafruit Industries, Paul Kourany, Technobly
    @license  BSD (see license.txt)

    This example will wait for any ISO14443A card or tag, and
    depending on the size of the UID will attempt to read from it.
   
    If the card has a 4-byte UID it is probably a Mifare
    Classic card, and the following steps are taken:
   
    Reads the 4 byte (32 bit) ID of a MiFare Classic card.
    Since the classic cards have only 32 bit identifiers you can stick
    them in a single variable and use that to compare card ID's as a
    number. This doesn't work for ultralight cards that have longer 7
    byte IDs!
   
    Note that you need the baud rate to be 115200 because we need to
    print out the data and read from the card at the same time!

This is an example sketch for the Adafruit PN532 NFC/RFID breakout boards
This library works with the Adafruit NFC breakout 
  ----> https://www.adafruit.com/products/364
 
Check out the links above for our tutorials and wiring diagrams 
These chips use SPI to communicate, 4 required to interface

Adafruit invests time and resources providing this open source code, 
please support Adafruit and open-source hardware by purchasing 
products from Adafruit

20160528 - Niks Notes
Added AdaFruit_PN532/ to the Include for Adafruit_PN52.h 
Aommented out spark_disable_wlan as its deprecated
Added particle.process within the core While loops as it was causing the breathing green error. 
Added SYSTEM_THREAD(ENABLED)  to help ensure photon processes are not blocked !
Commented out checking for Serial.Available it was just looping there forever.
Removed headers related to SPI and spurious SPARK_WLAN requests.
Current Particle.process() may be redundant but its a difference between breathing Cyan or Breathing green. 

!
*/
/**************************************************************************/

#define SYSTEM_THREAD(ENABLED)

#include "Adafruit_PN532/Adafruit_PN532.h"

#define IRQ_PIN  (D0) // This is how the PN532 Shield gets ready status in I2C mode
#define RST_PIN  (D1) // Necessary for I2C mode

Adafruit_PN532 nfc(IRQ_PIN, RST_PIN);


void setup(void) {
  Serial.begin(115200); // Make sure your serial terminal is closed before power the Core.
  
   
  Serial.println("Hello!");

  nfc.begin();

  uint32_t versiondata;
  
  do {
    versiondata = nfc.getFirmwareVersion();
    if (!versiondata) {
      Serial.print("Didn't find PN53x board\n");
      delay(1000);
      Particle.process();
    }
    Particle.process();
    
    
  }while(!versiondata);
  
  

  // Got ok data, print it out!
  Serial.print("Found chip PN5\n"); Serial.println((versiondata>>24) & 0xFF, HEX); 
  Serial.print("Firmware ver. \n"); Serial.print((versiondata>>16) & 0xFF, DEC); 
  Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
  
  // configure board to read RFID tags
  nfc.SAMConfig();

}


void loop(void) {

  Particle.process();
  Serial.println("Waiting for an ISO14443A Card ...\n");
  delay(1000);
  
  
  uint8_t success;
  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
  uint8_t uidLength;                        // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
    
  // Wait for an ISO14443A type cards (Mifare, etc.).  When one is found
  // 'uid' will be populated with the UID, and uidLength will indicate
  // if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
  
  if (success) {
    // Display some basic information about the card
    Serial.println("Found an ISO14443A card");
    Serial.print("  UID Length: ");Serial.print(uidLength, DEC);Serial.println(" bytes");
    Serial.print("  UID Value: ");
    nfc.PrintHex(uid, uidLength);
    
    if (uidLength == 4)
    {
      // We probably have a Mifare Classic card ... 
      uint32_t cardid = uid[0];
      cardid <<= 8;
      cardid |= uid[1];
      cardid <<= 8;
      cardid |= uid[2];  
      cardid <<= 8;
      cardid |= uid[3]; 
      Serial.print("Seems to be a Mifare Classic card #");
      Serial.println(cardid);
    }
    Serial.println("");
 
  }  else {
    Serial.println("nfc.readPassiveTarget Failed\n");
    
    }
}

Niente da fare, ho provato con le resistenze da 4700 ohm su SDA e SCL con il VCC ma continua a rimanere fermo su Hello!

Riferito al primo programma che ho pubblicato sembra che esegue solo Serial.println("Hello!"); e poi si ferma. Dico questo perchè ho provato a toglierlo e dal seriale non compare nessun messaggio. Ho provato a togliere alimentazione al lettore e scrive Didn't find PN53x board.

Se tolgo tutta la parte che va da // Got ok data, print it out! a nfc.SAMConfig(); compreso scrive sempre Hello!

Devo anche dire che con lo Scanner I2C in esecuzione non sempre mi trova l'indirizzo.
Devo alimentarlo a 3,3V e fare reset ad arduino, dopo di che inizia a trovarlo e posso anche staccarlo dal 3,3V e alimentarlo a 5V senza problemi :o

I2C Scanner
Scanning...
No I2C devices found     //alimentato a 5V


I2C Scanner
Scanning...
I2C device found at address 0x24  !           //passaggio a 3,3V
done

Scanning...
I2C device found at address 0x24  !
done

Scanning...
No I2C devices found     //qui non lo trova perchè ho atteso più tempo per ricollegarlo al 5V

Scanning...
I2C device found at address 0x24  !
done

Scanning...
I2C device found at address 0x24  !
done

Ho terminato le idee :stuck_out_tongue_closed_eyes:

Di dove sei? Questa cosa mi incuriosisce...

SukkoPera:
Di dove sei? Questa cosa mi incuriosisce...

E' un pò complicato spiegarti di dove sono :slight_smile:
Vuoi venirmi a trovare e aiutarmi a prendere a martellate il lettore?? :slight_smile:

Comunque posso dirti che sono a circa 30 Km dal Monte Amiata versante SUD.

Te lo spedisco con Raccomandata e ti diverti ahahahahahhhh, poi se lo fai funzionare lo rivorrei con sketch allegato :slight_smile: