<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/fr/blog/arduino/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Funduinoshop</name>
    </author>
    <title>Blog / Flux Atom</title>
    <id>https://funduinoshop.com/fr/blog/arduino/?sRss=1</id>
    <updated>2026-05-02T03:53:03+02:00</updated>
    
        <entry>
            <title type="text">Le module MPU-6050 : Gyroscope et accéléromètre</title>
            <id>https://funduinoshop.com/fr/le-module-mpu-6050-gyroscope-et-accelerometre</id>
            <link href="https://funduinoshop.com/fr/le-module-mpu-6050-gyroscope-et-accelerometre"/>
            <summary type="html">
                <![CDATA[
                
                                            Il y a peu de modules sur le marché qui ont suscité autant d&#039;engouement ces derniers mois que le module MPU-6050. Le circuit imprimé deux en un combine deux...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Il existe peu de modules sur le marché qui ont suscité autant d&#039;engouement ces derniers mois que le module MPU-6050. Le circuit imprimé deux en un combine deux caractéristiques de capteur très appréciées : Le module peut être utilisé à la fois comme gyroscope et comme accéléromètre.  Comment faire ? Le capteur comprend un gyroscope à 3 axes et un capteur d&#039;accélération à 3 axes sur une seule et même puce. Ainsi,&amp;nbsp;peut récupérer toutes ( !) les valeurs du capteur en même temps. Ainsi, le bricoleur est toujours bien informé de la position actuelle du capteur. Cette caractéristique est particulièrement intéressante pour le modélisme, surtout pour les châssis équilibrés ou les drones. De plus, il est possible d&#039;accéder à des magnétomètres externes ou à d&#039;autres capteurs via un autre bus I2C maître, de sorte que les données de ces capteurs peuvent également être entièrement collectées.&amp;nbsp; 
 Aperçu rapide des données de capteur du MPU-6050 (GY-521) : 
 
 Chipset : MPU-6050 (également connu sous le nom de GY-521) 
 Alimentation électrique : 3,3 - 5V DC 
 Droite de liberté : 6* 
 Interface : I2C 
 Espacement des broches : 2,54 mm   
 
 Passons maintenant à la partie la plus excitante : la pratique. Pour que tu puisses te faire une idée des fonctions utiles du module MPU-6050, nous avons développé pour toi un exemple de schéma électrique. Le module MPU-6050 est lu par un Funduino UNO R3 et les données recueillies sont analysées.  Nous nous intéressons principalement aux données des capteurs du gyroscope. Nous voulons lire les valeurs des axes X, Y et Z et déterminer si la position du capteur a été modifiée. Le changement de position doit être représenté par des LED de couleur. 
   
 Jusqu&#039;ici, tout va bien : mais comment mettre cela en œuvre ? 
 Le code de programmation du module MPU-6050 
 Maintenant, on entre dans le vif du sujet : enfin, à moitié. Tout d&#039;abord, nous devons télécharger la bibliothèque appropriée pour le module MPU6050 et l&#039;intégrer dans notre IDE Arduino. La bibliothèque s&#039;appelle &quot;&amp;lt;MPU6050_tockn.h&amp;gt;&quot; et peut être trouvée et installée directement via la gestion des bibliothèques de l&#039;IDE Arduino. 
 Après cette première étape, nous commençons le code proprement dit. Tout d&#039;abord, nous définissons les connexions pour nos LED, qui nous serviront d&#039;indicateurs de la position de l&#039;axe. Ensuite, nous définissons deux variables pour la position des trois axes.&amp;nbsp; 
 Tu te demandes certainement pourquoi nous avons besoin de deux variables par axe. Comme nous voulons savoir si la position de chaque axe a changé, nous devons d&#039;abord savoir quelle valeur le capteur a enregistrée pour la position actuelle. La valeur du capteur du MPU-6050 est sauvegardée dans la première variable pendant une courte période. La valeur de la position de l&#039;axe est à nouveau sauvegardée dans la deuxième variable peu après. Nous pouvons maintenant comparer les deux valeurs de mesure saisies. Si une déviation de la position d&#039;une valeur minimale définie au préalable a été enregistrée (dans notre exemple de code +-3), on peut supposer que le capteur a changé de position. Dans ce cas, nous allumons la LED correspondante.&amp;nbsp; 
 Particulièrement agréable : les données de mesure saisies s&#039;affichent bien sur le traceur sériel de l&#039;IDE Arduino.   
  // Ce sketch compare les angles des axes X/Y/Z avec les valeurs précédentes. 
 // S&#039;ils sont différents de +/-3°, le sketch allume des LED. (jew.1 pour POS ou pour NEG) 
 // Attention : ce ne sont pas des valeurs absolues mais des valeurs RELATIVES par rapport à la mesure précédente 


  #include  &amp;lt;MPU6050_tockn  .h&amp;gt;   // inclure les bibliothèques  
  #include  &amp;lt;Wire  .h&amp;gt;   // &amp;lt;-  

MPU6050 mpu6050 (Wire ,  0.1 ,  0.1 ) ;  // Amortissement des valeurs. Plus elles sont petites (direction &quot;0&quot;), plus les valeurs sont nerveuses
                                  // plus grande est la direction &quot;1&quot;, plus les valeurs sont lentes 

 const   int  ledXpos  =2 ;  //*** 
 const   int  ledXneg  =3 ;  // * 
 const   int  ledYpos  =4 ;  // * Définir les connexions des LED 
 const   int  ledYneg  =5 ;  // * 
 const   int  ledZpos  =6 ;  // * 
 const   int  ledZneg  =7 ;  //*** 

 int  xMaintenantPos ;  // variable X-Pos ACTUELLE 
 int  yMaintenantPos ;  // variable Y-Pos ACTUELLE 
 int  zMaintenantPos ;  // variable Z-Pos ACTUELLE 

 int  xPourPos ;  // variable X-Pos PRÉCÉDENTES 
 int  yVorPos ;  // variable Y-Pos PRÉCÉDENTES 
 int  zVorPos ;  // variable Z-Pos PRÉCÉDENTES 

 int  différence =  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 () {  // Début de la boucle 

  mpu6050.update() ;  // créer un nouvel ensemble de données dans le gyroscope 

xMaintenantPos=(mpu6050.getGyroAngleX()) ;  // Demande un nouveau jeu de données au gyroscope, écris dans la variable X 
yMaintenantPos=(mpu6050.getGyroAngleY()) ;  // Demande un nouveau jeu de données au gyroscope, écris dans la variable Y 
zMaintenantPos=(mpu6050.getGyroAngleZ()) ;  // Demande un nouveau jeu de données au gyroscope, écris dans la variable Z 

 if  (xMaintenantPos &amp;lt; xVorPos-(différence))  // Compare l&#039;ancien jeu de données avec le nouveau. Différence &amp;lt; -3 ? 
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  HIGH );}  // Ensuite, commute les LED en conséquence 
 else   if  (xMaintenantPos &amp;gt; xVorPos+(différence))  // Compare l&#039;ancien jeu de données avec le nouveau. Différence &amp;lt; +3 ? 
{ digitalWrite (ledXpos,  HIGH );  digitalWrite (ledXneg,  LOW );}  // Alors, allume les LED en conséquence 
 else   // Ou alors, éteindre toutes les X LEDs ...
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  LOW );}  // Alors allume les LED en conséquence 

 if  (yMaintenantPos &amp;lt; yVorPos-(différence))  // Compare l&#039;ancien jeu de données avec le nouveau. Différence &amp;lt; -3 ? 
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  HIGH );}  // Ensuite, allume les LED en conséquence 
 else   if  (yMaintenantPos &amp;gt; yVorPos+(différence))  // Compare l&#039;ancien ensemble de données avec le nouveau. Différence &amp;lt; +3 ? 
{ digitalWrite (ledYpos,  HIGH );  digitalWrite (ledYneg,  LOW );}  // Alors, allume les LED en conséquence 
 else   // Ou bien toutes les Y LEDs sont éteintes ...
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  LOW );}  // Alors allume les LED en conséquence 

 if  (zJetztPos &amp;lt; zVorPos-(différence))  // Compare l&#039;ancien jeu de données avec le nouveau. Différence &amp;lt; -3 ? 
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  HIGH );}  // Ensuite, allume les LED en conséquence 
 else   if  (zMaintenantPos &amp;gt; zVorPos+(différence))  // Compare l&#039;ancien ensemble de données avec le nouveau. Différence &amp;lt; +3 ? 
{ digitalWrite (ledZpos,  HIGH );  digitalWrite (ledZneg,  LOW );}  // Alors, allume les LED en conséquence 
 else   // Ou bien toutes les Z LEDs sont éteintes ...
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  LOW );}  // Alors allume les LED en conséquence 

xVorPos=xMaintenantPos ;  // Mettre à jour l&#039;ancien jeu de données (jusqu&#039;à présent) 
yVorPos=yMaintenantPos ;  // actualise l&#039;ancien jeu de données (jusqu&#039;à présent) 
zVorPos=zMaintenantPos ;  // Mettre à jour l&#039;ancien jeu de données (jusqu&#039;à présent) 
                                     // Ensuite, lors du prochain passage, on peut à nouveau comparer avec &quot;avant&quot; 

 Serial  .print (xMaintenantPos) ;  // &amp;gt;&amp;gt; traceur sériel&amp;lt;&amp;lt; écriture juste [donner X] 
 Serial  .print ( &quot; &quot; ) ;Serial  .print (yMaintenantPos) ;  // (&quot; &quot;) = (\t) = nouvelle couleur [donner Y] 
 Serial  .print ( &quot; &quot; ) ;Serial  .println (zMaintenantPos) ;  // (&quot; &quot;) = (\t) = Nouvelle couleur [donner Z] 
  delay  (15 ) ;  // (un délai minimal calme la sortie série) 
}  // Fin de la boucle 


 // Expérimente un peu avec l&#039;atténuation dans la troisième ligne de programme 
 //-&amp;gt; MPU6050 mpu6050(Wire, 0.3, 0.3) ; 
 // ou avec le delay() à la fin. Observe ensuite les valeurs dans &amp;gt;&amp;gt;le PLOTTER sériel &amp;lt;&amp;lt;.  
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Module PN532 NFC RFID - communication en champ proche</title>
            <id>https://funduinoshop.com/fr/module-pn532-nfc-rfid-communication-en-champ-proche</id>
            <link href="https://funduinoshop.com/fr/module-pn532-nfc-rfid-communication-en-champ-proche"/>
            <summary type="html">
                <![CDATA[
                
                                            Dans cet article, nous souhaitons te faire découvrir la lecture des étiquettes d&#039;identification. L&#039;article se concentre sur le module PN532 NFC RFID. Le module est basé sur la puce NXP PN532. Ce jeu de puces est surtout utilisé dans le domaine de la NFC (angl. pour &quot;Near Field...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 LA RFID ? NFC ? Qu&#039;est-ce que c&#039;est ? 
 Dans cet article, nous souhaitons te faire découvrir la lecture des tags d&#039;identification. L&#039;article se concentre sur le module PN532 NFC RFID.&amp;nbsp; 
 Le module est basé sur la puce NXP PN532. Ce jeu de puces est surtout répandu dans le domaine de la NFC (anglais pour &quot;Near Field Communication&quot;). Pour cela, un objet compatible NFC, souvent une carte bancaire avec une puce NFC, est tenu devant un lecteur NFC. L&#039;échange d&#039;informations se fait ainsi en une fraction de seconde.&amp;nbsp; 
 Cela semble abstrait ? Si tu as une carte EC récente et que tu l&#039;utilises pour payer sans contact, tu connais même la NFC dans la vie quotidienne. Il suffit de poser la carte sur le terminal de paiement pour déclencher la transaction - c&#039;est rapide et facile. 
 Nous aimerions examiner de plus près les processus techniques sous-jacents. Le module PN532 est idéal pour cela, car il est compatible avec I2C et SPI. Le type de communication souhaité peut être sélectionné directement sur le circuit imprimé du PN532 en déplaçant les commutateurs qui s&#039;y trouvent. La position des commutateurs nécessaires pour chaque interface se trouve à droite du schéma de commutation, qui se trouve un peu plus bas sur la page. 
 &amp;nbsp; 
 Le schéma de câblage : 
   
 Conseil : tu trouveras une version haute résolution de cette image  ici . Tu peux y voir un peu mieux l&#039;affectation des broches.   
 Le code du programme (version I2C) 
  //******************************************************************************************************* 
 //** Exemple de chaîne pour la lecture des tags ID. Si l&#039;ID correspond, PIN 13 est activé pendant 2 secondes **
  //** allume (LED). En cas de mauvaise ID, un son est émis sur la broche 12. (Buzzer / Piezzo PASSIF) ** 
 //** utiliser. Au lieu d&#039;une LED, il est également possible d&#039;activer une serrure de porte (via l&#039;amplificateur de commutation TIP120 **) 
 //******************************************************************************************************* 

  #include  &amp;lt;Wire  .h&amp;gt;   // bibliothèque pour le protocole I2C  
  #include  &amp;lt;Adafruit_PN532  .h&amp;gt;   // bibliothèque pour le module NFC/RFID !   A charger via Arduino IDE !  


  #define  PN532_IRQ (2)  // Définir le port IRQ  
  #define  PN532_RESET (3)  // Définir le port de réinitialisation  

 const   int  AlarmPin =  12 ;  // sortie Pin 12 pour le haut-parleur piézoélectrique 
 const   int  OutputPin =  13 ;  // Pin 13 sortie pour LED ou via TIP120 vers une serrure magnétique 
 unsigned   long  cardid ;  // variable pour le TAG-ID lu 

 unsigned   long  TAGid1 =  1702536620 ;  // Les ID à accepter peuvent être saisis ici 
 unsigned   long  TAGid2 =  4070796058 ;  // Sinon, laisser libre. L&#039;ID d&#039;un TAG peut être modifié avec 
 unsigned   long  TAGid3 ;  // le moniteur série est lu (régler 115200 baud) 

Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET) ;  // créer une instance avec le protocole I2C 


 void   setup () {  // Début de la fonction setup 
  pinMode (AlarmPin,  OUTPUT ) ;  // définir le PIN comme sortie 
   pinMode (OutputPin,  OUTPUT ) ;  // définir le PIN comme sortie 
  Serial  .begin  (115200 ) ;  // ouvrir la transmission série à 115200 bauds (moniteur ser même réglage de bauds !) 
  Serial  .println ( &quot;Bonjour !&quot; ) ;  // Envoie le texte &quot;Bonjour !&quot; sur le moniteur série 
  nfc .begin ()  // Démarre la communication avec le lecteur RFID 
  unsigned   long  versiondata = nfc.getFirmwareVersion() ;  // lire le numéro de version du 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;Puce PN5 trouvée&quot; ) ;  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX) ;  // Envoie le texte et les infos de version à la ligne série 
  Serial  .print ( &quot;Firmware ver. &quot; ) ;  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC) ;  // Moniteur quand la réponse vient de la carte 
  Serial  .print ( &#039;.&#039; ) ;  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC) ;  //  
  
  nfc.SAMConfig() ;  // Configurer la carte pour lire les tags RFID 

  Serial  .println ( &quot;En attente d&#039;une puce ISO14443A ...&quot; ) ;  // Envoie le texte d&#039;attente au moniteur série 
}


 void   loop () {  // Démarrer la fonction de boucle 
  uint8_t success ;  // créer une variable 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // tampon pour stocker l&#039;UID 
  uint8_t uidLength ;  // longueur de l&#039;UID (4 ou 7 octets selon le type de carte/puce ISO14443A) 

  // Attendre une puce ISO14443A. Si une telle puce est détectée, la variable 
  // remplit avec l&#039;UID. En fonction de la longueur (4 octets (Mifare Classic) ou 
  // 7 octets (Mifare Ultralight), le type de carte est détecté. 
  
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength) ;

  if  (success) {  // Si détecté, travaille ...
    Serial  .println ( &quot;Found an ISO14443A card&quot; ) ;
    Serial  .print ( &quot; UID Length : &quot; ) ;  Serial  .print (uidLength, DEC) ;  Serial  .println ( &quot; bytes&quot; ) ;
    Serial  .print ( &quot; UID Value : &quot; ) ;
    nfc.PrintHex(uid, uidLength) ;  // donne des informations sur le moniteur en série 

    if  (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))  // demande si les TAGs 1..2..3 sont compatibles avec leur 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // On ou Off 
 else 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }  // Fin de la requête IF/boucle 
}  // Fin de la boucle  
 Le code du programme (version SPI) 
  //******************************************************************************************************* 
 //** Exemple de chaîne pour la lecture des tags ID. Si l&#039;ID correspond, PIN 13 est activé pendant 2 secondes **
  //** allume (LED). En cas de mauvaise ID, un son est émis sur la broche 12. (Buzzer / Piezzo PASSIF) ** 
 //** utiliser. Au lieu d&#039;une LED, il est également possible d&#039;activer une serrure de porte (via l&#039;amplificateur de commutation TIP120 **) 
 //******************************************************************************************************* 

  #include  &amp;lt;Wire  .h&amp;gt;   // bibliothèque pour le protocole I2C  
  #include  &amp;lt;SPI  .h&amp;gt;   // bibliothèque pour le protocole SPI  
  #include  &amp;lt;Adafruit_PN532  .h&amp;gt;   // bibliothèque pour le module NFC/RFID !   A charger via Arduino IDE !  

 const   byte  PN532_SCK =  2 ;  // 
 const   byte  PN532_MOSI  =3 ;  // définir les connexions pour  
 const   byte  PN532_SS =  4 ;  // la connexion SPI au RFID  
 const   byte  PN532_MISO  =5 ;  // carte 

 const   int  AlarmPin =  12 ;  // définir les connexions pour  
 const   int  OutputPin =  13 ;  // les sorties (de commutation) 
 unsigned   long  cardid ;  // variable pour le TAG-ID lu 

 unsigned   long  TAGid1 =  1702536620 ;  // tu peux saisir ici les ID à accepter 
 unsigned   long  TAGid2 =  4070796058 ;  // Sinon, laisser libre. L&#039;ID d&#039;un TAG peut être modifié avec 
 unsigned   long  TAGid3 ;  // le moniteur série est lu (régler 115200 baud) 

Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS) ;  // créer une instance avec le protocole SPI 

 void   setup () {  // Début de la fonction setup 
  pinMode (AlarmPin,  OUTPUT ) ;  // définir le PIN comme sortie 
   pinMode (OutputPin,  OUTPUT ) ;  // définir le PIN comme sortie 
  Serial  .begin  (115200 ) ;  // ouvrir la transmission sérielle à 115200 bauds (moniteur ser même réglage de bauds !) 
  Serial  .println ( &quot;Bonjour !&quot; ) ;  // Envoie le texte &quot;Bonjour !&quot; sur le moniteur série 
  nfc .begin ()  // Démarre la communication avec le lecteur RFID 
  unsigned   long  versiondata = nfc.getFirmwareVersion() ;  // lire le numéro de version du 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;Found chip PN5&quot; ) ;  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX) ;  // envoie le texte et les infos de version au port série 
  Serial  .print ( &quot;Firmware ver. &quot; ) ;  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC) ;  // Moniteur quand la réponse vient de la carte 
  Serial  .print ( &#039;.&#039; ) ;  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC) ;  //  

  nfc.SAMConfig() ;  // Configurer la carte pour lire les tags RFID 

  Serial  .println ( &quot;En attente d&#039;une puce ISO14443A ...&quot; ) ;  // Envoie le texte d&#039;attente au moniteur série 
}


 void   loop () {  // Démarrer la fonction de boucle 
  uint8_t success ;  // créer une variable 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // tampon pour stocker l&#039;UID 
  uint8_t uidLength ;  // longueur de l&#039;UID (4 ou 7 octets selon le type de carte/puce ISO14443A) 

  // Attendre une puce ISO14443A. Si une telle puce est détectée, la variable 
  // remplit avec l&#039;UID. En fonction de la longueur (4 octets (Mifare Classic) ou 
  // 7 octets (Mifare Ultralight), le type de carte est détecté. 
 
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength) ;

  if  (success) {  // Si détecté, travaille ...
    Serial  .println ( &quot;Found an ISO14443A card&quot; ) ;
    Serial  .print ( &quot; UID Length : &quot; ) ;  Serial  .print (uidLength, DEC) ;  Serial  .println ( &quot; bytes&quot; ) ;
    Serial  .print ( &quot; UID Value : &quot; ) ;
    nfc.PrintHex(uid, uidLength) ;  // donne des informations sur le moniteur en série 

    if  (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))  // demande si les TAGs 1..2..3 sont compatibles avec leur 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // On ou Off 
 else 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }  // Fin de la requête IF/boucle 
}  // Fin de la boucle  
 &amp;nbsp; 
                ]]>
            </content>

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

    
</feed>
