<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/it/blog/arduino/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Funduinoshop</name>
    </author>
    <title>Blog/Atomi</title>
    <id>https://funduinoshop.com/it/blog/arduino/?sRss=1</id>
    <updated>2026-05-27T15:57:28+02:00</updated>
    
        <entry>
            <title type="text">Il modulo MPU-6050: Giroscopio e accelerometro</title>
            <id>https://funduinoshop.com/it/il-modulo-mpu-6050-giroscopio-e-accelerometro</id>
            <link href="https://funduinoshop.com/it/il-modulo-mpu-6050-giroscopio-e-accelerometro"/>
            <summary type="html">
                <![CDATA[
                
                                            Ci sono pochi moduli sul mercato che hanno suscitato un tale clamore negli ultimi mesi come il modulo MPU-6050. Il circuito stampato due in uno combina due popolari...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Sono pochi i moduli sul mercato che hanno suscitato un tale clamore negli ultimi mesi come il modulo MPU-6050. La scheda due-in-uno combina due popolari funzioni di sensore: Il modulo può essere utilizzato sia come giroscopio che come sensore di accelerazione.  Come? Il sensore comprende un giroscopio a 3 assi e un accelerometro a 3 assi su uno stesso chip. Ciò significa che&amp;nbsp;può richiamare tutti (!) i valori del sensore allo stesso tempo. Ciò significa che gli hobbisti sono sempre ben informati sulla posizione attuale del sensore. Questa caratteristica è particolarmente interessante per il modellismo, soprattutto per il bilanciamento di telai o droni. Inoltre, è possibile accedere a magnetometri esterni o ad altri sensori tramite un bus I2C master aggiuntivo, in modo da poter registrare completamente anche i dati di questi sensori.&amp;nbsp; 
 I dati dei sensori della MPU-6050 (GY-521) in sintesi: 
 
 Chipset: MPU-6050 (noto anche come GY-521) 
 Alimentazione: 3,3 - 5V DC 
 Linea di libertà: 6* 
 Interfaccia: I2C 
 Spaziatura tra i pin: 2,54 mm   
 
 Ora veniamo alla parte più interessante: la pratica. Per darti una buona panoramica delle funzioni utili del modulo MPU-6050, abbiamo sviluppato per te uno schema di circuito di esempio. Il modulo MPU-6050 viene letto da una Funduino UNO R3 e i dati registrati vengono valutati.  Siamo interessati soprattutto ai dati del sensore del giroscopio. Vogliamo leggere i valori degli assi X, Y e Z e determinare se c&#039;è stato un cambiamento nella posizione del sensore. La variazione di posizione deve essere visualizzata con dei LED colorati. 
   
 Fin qui tutto bene: ma come possiamo implementare tutto questo? 
 Il codice di programma del modulo MPU-6050 
 Ora è il momento di passare ai dettagli, o meglio alla metà di essi. Per prima cosa dobbiamo scaricare la libreria appropriata per il modulo MPU6050 e integrarla nel nostro IDE Arduino. La libreria si chiama &quot;&amp;lt;MPU6050_tockn.h&amp;gt;&quot; e può essere trovata e installata direttamente tramite la gestione delle librerie dell&#039;IDE di Arduino. 
 Dopo questo primo passo, iniziamo con il codice vero e proprio. Per prima cosa, definiamo i collegamenti per i nostri LED, che serviranno come indicatori della posizione dell&#039;asse. Poi definiamo due variabili per la posizione dell&#039;asse di ciascuno dei tre assi.&amp;nbsp; 
 Probabilmente ti starai chiedendo perché abbiamo bisogno di due variabili per asse. Poiché vogliamo determinare se la posizione del rispettivo asse è cambiata, dobbiamo prima determinare il valore che il sensore ha registrato per la posizione corrente. Salviamo questo valore del sensore dell&#039;MPU-6050 per un breve periodo di tempo nella prima variabile. Il valore della posizione dell&#039;asse viene salvato nuovamente nella seconda variabile poco dopo. Ora possiamo confrontare i due valori misurati registrati tra loro. Se viene registrata una deviazione della posizione di un minimo precedentemente definito (+-3 nel nostro esempio di codice), possiamo supporre che il sensore abbia modificato la posizione. In questo caso, accendiamo il LED assegnato.&amp;nbsp; 
 Particolarmente interessante: i dati di misurazione acquisiti possono essere visualizzati nel plotter seriale dell&#039;IDE di Arduino.   
  // Questo sketch confronta gli angoli degli assi X/Y/Z con i valori precedenti. 
 // Se differiscono di +/-3°, lo sketch commuta i LED. (ogni 1 per POS o per NEG) 
 // Attenzione: non si tratta di valori assoluti ma di valori RELATIVI rispetto alla misurazione precedente 


  #include   &amp;lt;MPU6050_tockn.h&amp;gt;   // Include librerie  
  #include   &amp;lt;Wire.h&amp;gt;   // &amp;lt;-  

MPU6050 mpu6050 (Wire ,  0.1 ,  0.1 );  // Smorzamento dei valori. Più piccoli (direzione &quot;0&quot;), più nervosi sono i valori
                                  // più grandi (direzione &quot;1&quot;), più lenti sono i valori 

 const   int  ledXpos  =2 ;  //*** 
 const   int  ledXneg  =3 ;  // * 
 const   int  ledYpos  =4 ;  // * Imposta i collegamenti dei LED 
 const   int  ledYneg  =5 ;  // *
 const   int  ledZpos  =6 ;  // *
 const   int  ledZneg  =7 ;  //*** 

 int  xNowPos;  // variabile CURRENT X-Pos 
 int  yNowPos;  // variabile CURRENT Y-Pos 
 int  zNowPos; // Variabile CURRENT   Z-Pos 

 int  xPrePos;  // Variabile X-Pos PRECEDENTE 
 int  yPrePos;  // Variabile Y-Pos PRECEDENTE 
 int  zPrePos;  // Variabile Z-Pos PRECEDENTE 

 int  difference =  3 ;

 void   setup () {                   // Beginn Setup-Funktion 
   Serial . begin ( 115200 );          // Öffne serielle Übertragung (115200Baud) !!! Am Monitor ebenfalls einstellen !!! 
  
   pinMode (ledXpos,  OUTPUT );      //*** 
   pinMode (ledXneg,  OUTPUT );      //  * 
   pinMode (ledYpos,  OUTPUT );      //  * Festlegen dass LED-Anschlüsse Ausgänge sind 
   pinMode (ledYneg,  OUTPUT );      //  * 
   pinMode (ledZpos,  OUTPUT );      //  * 
   pinMode (ledZneg,  OUTPUT );      //*** 
  
   Wire . begin ();                  // Beginn I2C Protokoll 
  mpu6050. begin ();               // Start des Gyros 
  mpu6050.calcGyroOffsets();     // Gyro kalkuliert seine Offsets !!! Währenddessen ruhig liegen lassen !!! 
                                 // Benutze mpu6050.calcGyroOffsets(true), um es im seriellen Monitor zu verfolgen. 
 delay ( 1000 );                     // Darauf warten wir... 
}

 void   loop () {  // inizio del ciclo di loop 

  mpu6050.update();  // crea un nuovo set di dati nel giroscopio 

xNowPos=(mpu6050.getGyroAngleX());  // Richiedi un nuovo set di dati dal giroscopio, scrivi nella variabile X 
yNowPos=(mpu6050.getGyroAngleY()); //   Richiedi un nuovo set di dati dal giroscopio, scrivi nella variabile Y 
zNowPos=(mpu6050.getGyroAngleZ());  // Richiedi un nuovo set di dati dal giroscopio, scrivi nella variabile Z 

 if  (xNowPos &amp;lt; xPrePos-(difference))  // Confronta il vecchio set di dati con quello nuovo. Differenza &amp;lt; -3 ? 
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  HIGH );}  // Allora cambia i LED di conseguenza 
 else   if  (xNowPos &amp;gt; xVorPos+(differenza))  // Confronta i dati vecchi con quelli nuovi. Differenza &amp;lt; +3 ? 
{ digitalWrite (ledXpos,  HIGH );  digitalWrite (ledXneg,  LOW );}  // Allora commuta i LED di conseguenza 
 else   // Oppure spegni tutti i LED X ...
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  LOW );}  // Allora cambia i LED di conseguenza 

 if  (yNowPos &amp;lt; yPrePos-(difference))  // Confronta il vecchio set di dati con quello nuovo. Differenza &amp;lt; -3 ? 
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  HIGH );}  // Allora commuta i LED di conseguenza 
 else   if  (yNowPos &amp;gt; yVorPos+(differenza))  // Confronta il vecchio set di dati con quello nuovo. Differenza &amp;lt; +3 ? 
{ digitalWrite (ledYpos,  HIGH );  digitalWrite (ledYneg,  LOW );}  // Allora commuta i LED di conseguenza 
 else   // Oppure spegni tutti i LED Y ...
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  LOW );}  // Allora commuta i LED di conseguenza 

 if  (zNowPos &amp;lt; zPrePos-(difference))  // Confronta il vecchio set di dati con quello nuovo. Differenza &amp;lt; -3 ? 
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  HIGH );}  // Allora commuta i LED di conseguenza 
 else   if  (zNowPos &amp;gt; zPrePos+(differenza))  // Confronta il vecchio set di dati con quello nuovo. Differenza &amp;lt; +3 ? 
{ digitalWrite (ledZpos,  HIGH );  digitalWrite (ledZneg,  LOW );}  // Allora commuta i LED di conseguenza 
 else   // Oppure spegni tutti i LED Z ...
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  LOW );}  // Allora commuta i LED di conseguenza 

xVorPos=xJetztPos;  // Aggiorna il vecchio set di dati (finora) 
yVorPos=yJetztPos;  // aggiorna il vecchio set di dati (finora) 
zVorPos=zJetztPos;  // Aggiorna il vecchio record (finora) 
                                     // Poi, nell&#039;esecuzione successiva, può essere confrontato di nuovo con &quot;prima&quot; 

 Serial  .print (xNowPos);  // &amp;gt;&amp;gt; plotter seriale&amp;lt;&amp;lt; ortografico [output X] 
 Serial  .print ( &quot; &quot; ) ;Serial  .print (yJetztPos);  // (&quot; &quot;) = (\t) = Nuovo colore [output   Y] 
 Serial  . print( &quot; &quot; ) ;Serial  .println (zNowPos);  // (&quot; &quot;) = (\t) = Nuovo colore [uscita   Z] 
  delay  (15 );  // (un ritardo minimo calma l&#039;uscita seriale) 
}  // fine del ciclo 


 // Sentiti libero di sperimentare un po&#039; con lo smorzamento nella terza riga del programma 
 //-&amp;gt; MPU6050 mpu6050(Wire, 0.3, 0.3); 
 // o con il delay() alla fine. Osserva poi i valori nel PLOTTER &amp;gt;&amp;gt;seriale &amp;lt;&amp;lt;  
                ]]>
            </content>

                            <updated>2022-05-15T08:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Il modulo PN532 NFC RFID - Comunicazione in campo vicino</title>
            <id>https://funduinoshop.com/it/il-modulo-pn532-nfc-rfid-comunicazione-in-campo-vicino</id>
            <link href="https://funduinoshop.com/it/il-modulo-pn532-nfc-rfid-comunicazione-in-campo-vicino"/>
            <summary type="html">
                <![CDATA[
                
                                            In questo articolo vogliamo mostrarti come leggere i tag ID. Il fulcro dell&#039;articolo è il modulo PN532 NFC RFID. Il modulo si basa sul chip PN532 di NXP. Questo chipset è particolarmente popolare nel campo dell&#039;NFC (near field communication)....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 RFID? NFC? Che cos&#039;è? 
 In questo articolo vogliamo mostrarti come leggere i tag ID. Il fulcro dell&#039;articolo è il modulo PN532 NFC RFID.&amp;nbsp; 
 Il modulo si basa sul chip PN532 di NXP. Questo chipset è molto utilizzato nel campo dell&#039;NFC (Near Field Communication). Un oggetto abilitato alla NFC, spesso una carta assegni con un chip NFC, viene avvicinato a un lettore NFC. In questo modo è possibile scambiare informazioni in una frazione di secondo.&amp;nbsp; 
 Ti sembra astratto? Se hai una carta EC più recente e la usi per i pagamenti contactless, allora conosci l&#039;NFC anche nella vita di tutti i giorni. Appoggiando la carta sul terminale, la transazione viene avviata in modo semplice e veloce. 
 Vogliamo dare un&#039;occhiata più da vicino ai processi tecnici che stanno alla base di tutto questo. Il modulo PN532 è ideale per questo scopo, in quanto è in grado di gestire sia I2C che SPI. Il tipo di comunicazione desiderata può essere selezionata direttamente sulla scheda PN532, agendo sugli interruttori presenti su di essa. La posizione degli interruttori necessaria per le rispettive interfacce si trova a destra dello schema elettrico, un po&#039; più in basso nella pagina. 
 &amp;nbsp; 
 Lo schema elettrico: 
   
 Suggerimento: puoi trovare una versione ad alta risoluzione di questa immagine  qui . Qui puoi vedere meglio l&#039;assegnazione dei pin.   
 Il codice del programma (versione I2C) 
  //******************************************************************************************************* 
 //** Schizzo di esempio per la lettura di tag ID. Se l&#039;ID corrisponde, il PIN 13 viene acceso per 2 secondi ** 
 //** si accende (LED). Se l&#039;ID è sbagliato, viene generato un segnale acustico al pin 12. (cicalino passivo / piezzo) ** 
 //** utilizzo. Al posto del LED, è possibile attivare la serratura della porta (tramite l&#039;amplificatore di commutazione TIP120) 
 //******************************************************************************************************* 

  #include   &amp;lt;Wire.h&amp;gt;   // Libreria per il protocollo I2C  
  #include   &amp;lt;Adafruit_PN532.h&amp;gt;   // Libreria per il modulo NFC/RFID !!!   Si prega di caricare tramite l&#039;IDE Arduino!!!  


  #define  PN532_IRQ (2)  // Definisce il connettore IRQ  
  #define  PN532_RESET (3)  // Definisce il collegamento di reset  

 const   int  AlarmPin =  12 ;  // Uscita pin 12 per l&#039;altoparlante piezoelettrico 
 const   int  OutputPin =  13 ;  // Uscita del pin 13 per il LED o per il blocco magnetico tramite TIP120 
 unsigned   long  cardid;  // Variabile per la lettura del TAG-ID 

 unsigned   long  TAGid1 =  1702536620 ;  // Gli ID da accettare possono essere inseriti qui 
 unsigned   long  TAGid2 =  4070796058 ;  // Altrimenti lascia in bianco. L&#039;ID dei singoli TAG può essere inserito con 
 unsigned   long  TAGid3 ;  // il monitor seriale (impostare 115200 baud) 

Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);  // Crea un&#039;istanza con il protocollo I2C 


 void    setup() { // avvia la funzione di setup 
  pinMode (AlarmPin,  OUTPUT );  // Definisce il PIN come uscita 
   pinMode (OutputPin,  OUTPUT );  // Definisce il PIN come uscita
  Serial  .begin  (115200 );  // Aprire la trasmissione seriale con 115200 baud (ser monitorare la stessa impostazione di baud!) 
  Serial  .println ( &quot;Ciao! &quot;);  // Invia il testo &quot;Ciao!&quot; al monitor seriale 
  nfc .begin (); //   Inizia la comunicazione con il lettore RFID 
  unsigned   long  versiondata = nfc.getFirmwareVersion();  // Leggi il numero di versione del firmware 
  if  (! versiondata) {                                    // Wenn keine Antwort kommt 
     Serial . print ( &quot;Kann kein Board finden !&quot; );             // Sende Text &quot;Kann kein...&quot; an seriellen Monitor 
     while  ( 1 );                                            // so lange Stopp 
  }

  Serial  .print ( &quot;Chip PN5 trovato&quot; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX);  // Invia testo e informazioni sulla versione alla porta   seriale del lettore RFID
  Serial  .print ( &quot;Firmware ver. &quot; );  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC);  // Controlla quando arriva la risposta dalla scheda 
  Serial  .print ( &#039;.&#039; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC);  //  
  
  nfc.SAMConfig();  // Configura la scheda per leggere i tag RFID 

  Serial  .println ( &quot;In attesa di un chip ISO14443A ...&quot; );  // Invia il testo in attesa al monitor seriale 
}


 void   loop () {  // Avvia la funzione loop 
  uint8_t success;  // Crea una variabile 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // Buffer per memorizzare l&#039;UID 
  uint8_t uidLength;  // Lunghezza dell&#039;UID (4 o 7 byte a seconda del tipo di scheda/chip ISO14443A) 

  // Attendere un chip ISO14443A. Se ne viene rilevato uno, la variabile 
  // viene riempita con l&#039;UID. A seconda della lunghezza (4 byte (Mifare Classic) o 7 byte (Mifare Classic) 
  // 7 byte (Mifare Ultralight) viene riconosciuto il tipo di carta. 
  
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength);

  if  (success) {  // Se viene rilevato, elabora.... 
    Serial  .println ( &quot;Trovata una carta ISO14443A&quot; );
    Serial  .print ( &quot; Lunghezza UID: &quot; );  Serial  .print (uidLength, DEC);  Serial  .println ( &quot; bytes&quot; );
    Serial  . print( &quot; Valore UID: &quot; );
    nfc.PrintHex(uid, uidLength);  // invio delle informazioni al monitor seriale 

    se  (uidLength ==  4 ) {                                   // Hat die Karte/der Chip 4 byte Länge... 
                                                            // Mifare Classic Karte 
      cardid = uid[ 0 ];                                      // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // Setze die 4 byte Blöcke 
      cardid |= uid[ 1 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zu einem einzigen Block 
      cardid |= uid[ 2 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zusammen 
      cardid |= uid[ 3 ];                                     // 
       Serial . print ( &quot;Scheint eine Mifare Classic zu sein #&quot; );   // 
       Serial . println (cardid);                                  // Gib die Informationen aus 
       Serial . println ( &quot;&quot; );                                      //  
       Serial . println ( &quot;&quot; );                                      //  
    }
      if  ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3))  // interroga se i TAG 1..2..3 sono collegati con il rispettivo 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // On o off 
 altrimenti 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }  // Fine della query/loop IF 
}  // Fine del ciclo  
 Il codice del programma (versione SPI) 
  //******************************************************************************************************* 
 //** Esempio di sketch per la lettura di tag ID. Se l&#039;ID è adatto, il PIN 13 viene ** per 2 secondi 
 //** si accende (LED). Se l&#039;ID è sbagliato, viene generato un segnale acustico al pin 12. (cicalino passivo / piezzo) ** 
 //** utilizzo. Al posto del LED, è possibile attivare la serratura della porta (tramite l&#039;amplificatore di commutazione TIP120) 
 //******************************************************************************************************* 

  #include   &amp;lt;Wire.h&amp;gt;   // Libreria per il protocollo I2C  
  #include   &amp;lt;SPI.h&amp;gt;   // Libreria per il protocollo SPI  
  #include   &amp;lt;Adafruit_PN532.h&amp;gt;   // Libreria per il modulo NFC/RFID !!! Si prega di caricarla tramite l&#039;IDE Arduino!!!  

 const   byte  PN532_SCK =  2 ;  // 
 const   byte  PN532_MOSI  =3 ;  // Definisci le connessioni per  
 const   byte  PN532_SS =  4 ;  // la connessione SPI all&#039;RFID  
 const   byte  PN532_MISO  =5 ;  // Scheda 

 const   int  AlarmPin =  12 ;  // Definisci  le connessioni per 
 const   int  OutputPin =  13 ;  // le uscite (di commutazione) 
 unsigned   long  cardid;  // Variabile per la lettura del TAG-ID 

 unsigned   long  TAGid1 =  1702536620 ;  // gli ID da accettare possono essere inseriti qui 
 unsigned   long  TAGid2 =  4070796058 ;  // Altrimenti lascia in bianco. L&#039;ID dei singoli TAG può essere inserito con 
 unsigned   long  TAGid3 ;  // il monitor seriale (impostare 115200 baud) 

Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS);  // crea un&#039;istanza con protocollo SPI 

 void    setup() { // Avvia la funzione di setup 
  pinMode (AlarmPin,  OUTPUT );  // Definisce il PIN come uscita 
   pinMode (OutputPin,  OUTPUT );  // Definisce il PIN come uscita
  Serial  .begin  (115200 );  // Aprire la trasmissione seriale con 115200 baud (ser monitorare la stessa impostazione di baud!) 
  Serial  .println ( &quot;Ciao! &quot;);  // Invia il testo &quot;Ciao!&quot; al monitor seriale 
  nfc .begin (); //   Inizia la comunicazione con il lettore RFID 
  unsigned   long  versiondata = nfc.getFirmwareVersion();  // Leggi il numero di versione del firmware 
  if  (! versiondata) {                                    // Wenn keine Antwort kommt 
     Serial . print ( &quot;Kann kein Board finden !&quot; );             // Sende Text &quot;Kann kein...&quot; an seriellen Monitor 
     while  ( 1 );                                            // so lange Stopp 
  }

  Serial  .print ( &quot;Trovato chip PN5&quot; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX);  // Invia il testo e le informazioni sulla versione alla porta   seriale del lettore RFID
  Serial  .print ( &quot;Firmware ver. &quot; );  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC);  // Controlla quando arriva la risposta dalla scheda 
  Serial  .print ( &#039;.&#039; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC);  //  

  nfc.SAMConfig();  // Configura la scheda per leggere i tag RFID 

  Serial  .println ( &quot;In attesa di un chip ISO14443A ...&quot; );  // Invia il testo in attesa al monitor seriale 
}


 void   loop () {  // Avvia la funzione loop 
  uint8_t success;  // Crea una variabile 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // Buffer per memorizzare l&#039;UID 
  uint8_t uidLength;  // Lunghezza dell&#039;UID (4 o 7 byte a seconda del tipo di scheda/chip ISO14443A) 

  // Attendere un chip ISO14443A. Se ne viene rilevato uno, la variabile 
  // viene riempita con l&#039;UID. A seconda della lunghezza (4 byte (Mifare Classic) o 7 byte (Mifare Classic) 
  // 7 byte (Mifare Ultralight) viene riconosciuto il tipo di carta. 
 
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength);

  if  (success) {  // Se viene rilevato, elabora.... 
    Serial  .println ( &quot;Trovata una carta ISO14443A&quot; );
    Serial  .print ( &quot; Lunghezza UID: &quot; );  Serial  .print (uidLength, DEC);  Serial  .println ( &quot; bytes&quot; );
    Serial  . print( &quot; Valore UID: &quot; );
    nfc.PrintHex(uid, uidLength);  // invio delle informazioni al monitor seriale 

    se  (uidLength ==  4 ) {                                   // Hat die Karte/der Chip 4 byte Länge... 
                                                            // Mifare Classic Karte 
      cardid = uid[ 0 ];                                      // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // Setze die 4 byte Blöcke 
      cardid |= uid[ 1 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zu einem einzigen Block 
      cardid |= uid[ 2 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zusammen 
      cardid |= uid[ 3 ];                                     // 
       Serial . print ( &quot;Scheint eine Mifare Classic zu sein #&quot; );   // 
       Serial . println (cardid);                                  // Gib die Informationen aus 
       Serial . println ( &quot;&quot; );                                      //  
       Serial . println ( &quot;&quot; );                                      //  
    }
      if  ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3))  // interroga se i TAG 1..2..3 sono collegati con il rispettivo 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // On o off 
 altrimenti 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }  // Fine della query/loop IF 
}  // Fine del ciclo  
 &amp;nbsp; 
                ]]>
            </content>

                            <updated>2022-05-10T11:30:00+02:00</updated>
                    </entry>

    
</feed>
