<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/es/blog/arduino/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Funduinoshop</name>
    </author>
    <title>Blog / Atom Feed</title>
    <id>https://funduinoshop.com/es/blog/arduino/?sRss=1</id>
    <updated>2026-04-29T19:43:56+02:00</updated>
    
        <entry>
            <title type="text">El módulo MPU-6050: Giroscopio y acelerómetro</title>
            <id>https://funduinoshop.com/es/el-modulo-mpu-6050-giroscopio-y-acelerometro</id>
            <link href="https://funduinoshop.com/es/el-modulo-mpu-6050-giroscopio-y-acelerometro"/>
            <summary type="html">
                <![CDATA[
                
                                            Hay pocos módulos en el mercado que hayan provocado tanto revuelo en los últimos meses como el módulo MPU-6050. La placa de circuitos dos en uno combina dos...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Hay pocos módulos en el mercado que hayan provocado tanto revuelo en los últimos meses como el módulo MPU-6050. Esta placa &quot;dos en uno&quot; combina dos funciones de sensor muy populares: El módulo puede utilizarse como giroscopio y como sensor de aceleración al mismo tiempo.  ¿Cómo? El sensor incluye un giroscopio de 3 ejes y un acelerómetro de 3 ejes en un mismo chip. Esto significa que&amp;nbsp;puede consultar todos (!) los valores del sensor al mismo tiempo. Esto significa que los aficionados siempre están bien informados sobre la posición actual del sensor. Esta función es especialmente interesante para la construcción de maquetas, sobre todo para equilibrar chasis o drones. Además, se puede acceder a magnetómetros externos u otros sensores a través de un bus I2C maestro adicional, de modo que estos datos de los sensores también se pueden registrar completamente.&amp;nbsp; 
 Los datos de los sensores del MPU-6050 (GY-521) de un vistazo: 
 
 Chipset: MPU-6050 (también conocido como GY-521) 
 Fuente de alimentación: 3,3 - 5 V CC 
 Línea de libertad: 6 
 Interfaz: I2C 
 Distancia entre pines: 2,54 mm   
 
 Ahora llegamos a la parte emocionante: la práctica. Para que tengas una buena visión general de las útiles funciones del módulo MPU-6050, hemos desarrollado para ti un esquema de circuito de ejemplo. Un Funduino UNO R3 lee el módulo MPU-6050 y evalúa los datos registrados.  Nos interesan sobre todo los datos del sensor del giroscopio. Queremos leer los valores de los ejes X, Y y Z y determinar si se ha producido un cambio en la posición del sensor. El cambio de posición se nos mostrará mediante LEDs de colores. 
   
 Hasta aquí todo bien, pero ¿cómo lo hacemos? 
 El código del programa del módulo MPU-6050 
 Ha llegado la hora de la verdad: bueno, la mitad. Primero tenemos que descargar la biblioteca adecuada para el módulo MPU6050 e integrarla en nuestro IDE Arduino. La biblioteca se llama &quot;&amp;lt;MPU6050_tockn.h&amp;gt;&quot; y se puede encontrar e instalar directamente a través de la gestión de bibliotecas del IDE de Arduino. 
 Tras este primer paso, empezamos con el código propiamente dicho. En primer lugar, definimos las conexiones para nuestros LEDs, que nos servirán como indicadores de la posición del eje. Después definimos dos variables para la posición de cada uno de los tres ejes.&amp;nbsp; 
 Probablemente te preguntes por qué necesitamos dos variables por eje. Como queremos determinar si la posición del eje respectivo ha cambiado, primero debemos determinar qué valor ha registrado el sensor para la posición actual. Guardamos este valor del sensor del MPU-6050 durante un breve periodo de tiempo en la primera variable. El valor de la posición del eje se guarda de nuevo en la segunda variable un poco más tarde. Ahora podemos comparar entre sí los dos valores medidos registrados. En la medida en que se haya registrado una desviación de la posición por un mínimo previamente definido (+-3 en nuestro código de ejemplo), podemos suponer que el sensor ha modificado la posición. En este caso, encendemos el LED asignado.&amp;nbsp; 
 Especialmente agradable: los datos de medición capturados se pueden visualizar bien en el trazador en serie del IDE de Arduino.   
  // Este sketch compara los ángulos de los ejes X/Y/Z con los valores anteriores. 
 // Si difieren en +/-3°, el sketch conmuta los LEDs. (cada.1 para POS o para NEG) 
 // Atención: No se trata de valores absolutos, sino de valores RELATIVOS comparados con la medición anterior 


  #include   &amp;lt;MPU6050_tockn.h&amp;gt;   // Incluir bibliotecas  
  #include   &amp;lt;Wire.h  &amp;gt;  // &amp;lt;-  

MPU6050 mpu6050 (Alambre ,  0,1 ,  0,1 ); //   Amortiguación de los valores. Cuanto más pequeños (dirección &quot;0&quot;), más nerviosos son los valores 
                                  // cuanto más grandes (dirección &quot;1&quot;), más nerviosos los valores 

 const   int  ledXpos  =2 ;  //*** 
 const   int  ledXneg  =3 ;  // *
 const   int  ledYpos  =4 ; // *   Establecer las conexiones del LED 
 const   int  ledYneg  =5 ;  // *
 const   int  ledZpos  =6 ;  // *
 const   int  ledZneg  =7 ;  //*** 

 int  xPosAhora; //   variable POS X ACTUAL 
 int  yNowPos; // Variable   Y-Pos ACTUAL
 int  zPosAhora; // Variable   POS-Z ACTUAL

 int  xPrePos; // Variable POS X   ANTERIOR 
 int  yPrePos; // Variable Y-Pos   ANTERIOR 
 int  zPrePos; // Variable   ANTERIOR Z-Pos

 int  diferencia =  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   bucle () {  // inicio del bucle bucle 

  mpu6050.update();  // Crea un nuevo conjunto de datos en el giroscopio 

xNowPos=(mpu6050.getGyroAngleX());  // Solicita un nuevo conjunto de datos al giroscopio, escribe en la variable X 
yNowPos=(mpu6050.getGyroAngleY()); // Solicitar un nuevo conjunto de datos al giroscopio, escribir en la variable   Y 
zPosAhora=(mpu6050.getÁnguloGiroZ()); // Solicitar un nuevo conjunto de datos al   giroscopio , escribir en la variable Z

 if  (xNowPos &amp;lt; xPrePos-(diferencia))  // Compara el conjunto de datos antiguo con el nuevo. Diferencia &amp;lt; -3 ? 
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  HIGH );}  // Entonces cambia los LEDs en consecuencia 
 else   if  (xNowPos &amp;gt; xVorPos+(diferencia)) // Compara el conjunto de   datos antiguo con el nuevo.   ¿Diferencia &amp;lt; +3 ? 
{ digitalWrite (ledXpos,  HIGH );  digitalWrite (ledXneg,  LOW );}  // Conecta los LEDs según corresponda 
 else   // O apaga todos los LEDs X ...
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  LOW );}  // Entonces enciende los LEDs según corresponda 

 if  (yNowPos &amp;lt; yPrePos-(diferencia))  // Compara el conjunto de datos antiguo con el nuevo. Diferencia &amp;lt; -3 ? 
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  HIGH );}  // Conecta los LEDs según corresponda 
 else   if  (yNowPos &amp;gt; yVorPos+(diferencia)) // Compara el conjunto de datos antiguo   con el nuevo.   ¿Diferencia &amp;lt; +3 ? 
{ digitalWrite (ledYpos,  HIGH );  digitalWrite (ledYneg,  LOW );}  // Conecta los LEDs según corresponda 
 else   // O apaga todos los LEDs Y ...
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  LOW );}  // Entonces enciende los LEDs según corresponda 

 if  (zNowPos &amp;lt; zPrePos-(diferencia))  // Compara el conjunto de datos antiguo con el nuevo. Diferencia &amp;lt; -3 ? 
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  HIGH );}  // Conecta los LEDs según corresponda 
 else   if  (zNowPos &amp;gt; zPrePos+(diferencia)) // Compara el conjunto de datos antiguo   con el nuevo.   ¿Diferencia &amp;lt; +3 ? 
{ digitalWrite (ledZpos,  HIGH );  digitalWrite (ledZneg,  LOW );}  // Conecta los LEDs según corresponda 
 else   // O apaga todos los LEDs Z ...
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  LOW );}  // Entonces enciende los LEDs según corresponda 

xVorPos=xJetztPos; // Actualiza el   conjunto de datos antiguos ( hasta ahora)
yVorPos=yJetztPos; // Actualiza el conjunto de datos antiguos (hasta ahora  ) 
zVorPos=zJetztPos; // Actualiza el   registro antiguo (hasta ahora)
                                     // Luego, en la siguiente ejecución, se puede volver a comparar con el &quot;antes&quot; 

 Serial  .print (xAhoraPos);  // &amp;gt;&amp;gt; trazador serie&amp;lt;&amp;lt; ortografía justa [salida X] 
 Serial . print (&quot; &quot; ) ;Serial  .print (yJetztPos); //  (&quot; &quot;) = (\t) = Nuevo color [salida Y] 
 Serial  . print(&quot; &quot; ); Serial  .println (zJetztPos); // (&quot;  &quot;) = (\t) = Nuevo color [salida Z]
  delay  (15 );  // (un retardo mínimo calma la salida serie) 
}  // fin del bucle 


 // Siéntete libre de experimentar un poco con la amortiguación en la tercera línea del programa 
 //-&amp;gt; MPU6050 mpu6050(Alambre, 0,3, 0,3); 
 // o con el delay() del final. Luego observa los valores en el &amp;gt;&amp;gt;PLOTTER serial &amp;lt;&amp;lt;  
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Módulo RFID NFC PN532 - Comunicación de campo cercano</title>
            <id>https://funduinoshop.com/es/modulo-rfid-nfc-pn532-comunicacion-de-campo-cercano</id>
            <link href="https://funduinoshop.com/es/modulo-rfid-nfc-pn532-comunicacion-de-campo-cercano"/>
            <summary type="html">
                <![CDATA[
                
                                            En este artículo queremos mostrarte cómo leer etiquetas de identificación. El artículo se centra en el módulo RFID NFC PN532. El módulo se basa en el chip PN532 de NXP. Este chipset es especialmente popular en el campo de la NFC (comunicación de campo cercano)....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 ¿RFID? ¿NFC? ¿Qué es eso? 
 En este artículo, nos gustaría mostrarte cómo leer etiquetas de identificación. El artículo se centra en el módulo RFID PN532 NFC.&amp;nbsp; 
 El módulo se basa en el chip NXP PN532. Este chipset se utiliza ampliamente en el campo de la NFC (Comunicación de Campo Cercano). Un objeto habilitado para NFC, a menudo una tarjeta cheque con un chip NFC, se acerca a un lector NFC. Esto permite intercambiar información en una fracción de segundo.&amp;nbsp; 
 ¿Te parece abstracto? Si tienes una tarjeta CE más reciente y la utilizas para pagar sin contacto, entonces ya conoces la NFC incluso en la vida cotidiana. Al colocar la tarjeta en el terminal, se inicia la transacción, de forma rápida y sencilla. 
 Nos gustaría echar un vistazo más de cerca a los procesos técnicos que hay detrás de esto. El módulo PN532 es ideal para ello, ya que es capaz tanto de I2C como de SPI. El tipo de comunicación deseado se puede seleccionar directamente en la placa PN532 accionando los interruptores situados en ella. La posición de los interruptores necesaria para cada interfaz se encuentra a la derecha del esquema de conexiones, un poco más abajo. 
 &amp;nbsp; 
 El esquema del circuito: 
   
 Consejo: Puedes encontrar una versión de alta resolución de esta imagen  aquí . Allí puedes ver la asignación de pines un poco mejor.   
 El código del programa (versión I2C) 
  //******************************************************************************************************* 
 //** Esquema de ejemplo para leer etiquetas de identificación. Si el ID coincide, el PIN 13 se enciende durante 2 segundos ** 
 //** se enciende (LED). Si el ID es erróneo, se genera un tono en el pin 12. (zumbador / piezzo pasivo) ** 
 //** uso. En lugar de un LED, también se puede conmutar una cerradura de puerta (mediante el amplificador de conmutación TIP120 ** 
 //******************************************************************************************************* 

  #include   &amp;lt;Wire.h&amp;gt;   // Biblioteca para el protocolo I2C  
 ¡¡¡ #include   &amp;lt;Adafruit_PN532.h  &amp;gt; // Biblioteca   para el módulo NFC/RFID !!!   ¡¡¡Por favor, cárgala a través del IDE de Arduino !!!  


  #define  PN532_IRQ (2) //   Define el conector IRQ  
  #define  PN532_RESET (3) // Define   la conexión reset  

 const   int  ClavijaAlarma =  12 ; //   Clavija 12 salida para altavoz piezoeléctrico 
 const   int  SalidaPin =  13 ; // Salida pin 13   para LED o mediante TIP120 a una cerradura magnética 
 unsigned   long  cardid; //   Variable para el TAG-ID de lectura 

 unsigned   long  TAGid1 =  1702536620 ; //   Aquí se pueden introducir los ID que se van a aceptar 
 unsigned   long  TAGid2 =  4070796058 ; //   Si no, déjalo en blanco. El ID de los TAG individuales se puede introducir con 
 unsigned   long  TAGid3 ; //   el monitor serie (establecer 115200 baudios) 

Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);  // Crear instancia con protocolo I2C 


 void    setup() { // inicia la función de configuración 
  pinMode (PinAlarma,  OUTPUT ); //   Define el PIN como salida 
   pinMode (ClavijaSalida,  OUTPUT ); // Define el PIN   como salida
  Serial  .begin  (115200 );  // Abre la transmisión serie con 115200 baudios (¡ser monitoriza la misma configuración de baudios!) 
  Serial  .println ( &quot;¡Hola! &quot;); //   Envía el texto &quot;¡Hola!&quot; al monitor serie
  nfc .begin ();  // Iniciar la comunicación con el lector RFID 
  unsigned   long  versiondata = nfc.getFirmwareVersion(); //   Leer el número de versión 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 encontrado&quot; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX); //   Enviar texto e información de la versión al puerto   serie del lector RFID
  Serial  .print ( &quot;Firmware ver. &quot; );  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC);  // Monitoriza cuándo llega la respuesta de la placa 
  Serial  .print ( &#039;.&#039; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC);  //  
  
  nfc.SAMConfig();  // Configura la placa para leer etiquetas RFID 

  Serial  .println ( &quot;Esperando un chip ISO14443A ...&quot; );  // Envía el texto que espera al monitor serie 
}


 void   bucle () {  // Iniciar función bucle 
  uint8_t éxito;  // Crear variable 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // Búfer para almacenar el UID 
  uint8_t uidLength;  // Longitud del UID (4 ó 7 bytes según el tipo de tarjeta/chip ISO14443A) 

  // Espera a que haya un chip ISO14443A. Si se detecta uno, la variable 
  // se rellena con el UID. Dependiendo de la longitud (4 bytes (Mifare Classic) o 
  // 7 bytes (Mifare Ultralight) se reconoce el tipo de tarjeta. 
  
  éxito = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength);

  if  (éxito) {  // Si se detecta, procesa.... 
    Serial  .println (&quot; Encontrada una tarjeta ISO14443A&quot; );
    Serial . print (&quot; Longitud UID : &quot; );  Serial  .print (uidLength, DEC);  Serial  .println (&quot;  bytes &quot;);
    Serial  . print(&quot;  Valor U ID: &quot;);
    nfc.PrintHex(uid, uidLength);  // envía la información al monitor serie 

    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)) //   consulta si los TAGs 1..2..3 están conectados con el respectivo 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // Encendido o apagado 
 si no 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }  // Fin de la consulta/bucle IF 
} // Fin del   bucle  
 El código del programa (versión SPI) 
  //******************************************************************************************************* 
 //** Sketch de ejemplo para leer etiquetas de identificación. Si el identificador es adecuado, el PIN 13 ** durante 2 segundos 
 //** se enciende (LED). Si el ID es erróneo, se genera un tono en el pin 12. (zumbador / piezzo pasivo) ** 
 //** uso. En lugar de un LED, también se puede conmutar una cerradura de puerta (mediante el amplificador de conmutación TIP120 ** 
 //******************************************************************************************************* 

  #include   &amp;lt;Wire.h&amp;gt;  //   Biblioteca para el protocolo I2C  
  #include   &amp;lt;SPI.  h&amp;gt; // Biblioteca para   el protocolo SPI  
 ¡¡¡ #include   &amp;lt;Adafruit_PN532.h  &amp;gt; //   Biblioteca para el módulo NFC/RFID !!! ¡¡¡Cárgala a través del IDE de Arduino !!!  

 const   byte  PN532_SCK =  2 ;  // 
 const   byte  PN532_MOSI  =3 ; //   Define las conexiones para  
const  byte  PN532_SS =  4 ; //   la conexión SPI al RFID  
 const   byte  PN532_MISO  =5 ; //   la placa 

 const   int  ClavijaAlarma =  12 ; //   Define  las conexiones para 
 const   int  ClavijaSalida =  13 ; //   las salidas (de conmutación )
 unsigned   long  cardid; //   Variable para el TAG-ID leído 

 unsigned   long  TAGid1 =  1702536620 ;  // Aquí se pueden introducir los ID que se van a aceptar 
 unsigned   long  TAGid2 =  4070796058 ; //   Si no, déjalo en blanco. El ID de los TAG individuales se puede introducir con 
 unsigned   long  TAGid3 ; //   el monitor serie (establecer 115200 baudios) 

Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS);  // crea una instancia con protocolo SPI 

 void    setup() { // Inicia la función de configuración 
  pinMode (PinAlarma,  OUTPUT );  // Define el PIN como salida 
   pinMode (ClavijaSalida,  OUTPUT ); //   Define el PIN como salida
  Serial  .begin  (115200 );  // Abre la transmisión serie con 115200 baudios (¡ser monitoriza la misma configuración de baudios!) 
  Serial  .println ( &quot;¡Hola! &quot;); //   Envía el texto &quot;¡Hola!&quot; al monitor serie
  nfc .begin ();  // Iniciar la comunicación con el lector RFID 
  unsigned   long  versiondata = nfc.getFirmwareVersion(); //   Leer el número de versión 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; Encontrado chip PN5&quot; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX); //   Enviar texto e información de la versión al puerto   serie del lector RFID
  Serial  .print ( &quot;Firmware ver. &quot; );  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC);  // Monitoriza cuándo llega la respuesta de la placa 
  Serial  .print ( &#039;.&#039; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC);  //  

  nfc.SAMConfig();  // Configura la placa para leer etiquetas RFID 

  Serial  .println ( &quot;Esperando un chip ISO14443A ...&quot; );  // Envía el texto que espera al monitor serie 
}


 void   bucle () {  // Iniciar función bucle 
  uint8_t éxito;  // Crear variable 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // Buffer para almacenar el UID 
  uint8_t uidLength;  // Longitud del UID (4 ó 7 bytes según el tipo de tarjeta/chip ISO14443A) 

  // Espera a que haya un chip ISO14443A. Si se detecta uno, la variable 
  // se rellena con el UID. Dependiendo de la longitud (4 bytes (Mifare Classic) o 
  // 7 bytes (Mifare Ultralight) se reconoce el tipo de tarjeta. 
 
  éxito = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength);

  if  (éxito) {  // Si se detecta, procesa.... 
    Serial  .println (&quot; Encontrada una tarjeta ISO14443A&quot; );
    Serial . print (&quot; Longitud UID : &quot; );  Serial  .print (uidLength, DEC);  Serial  .println (&quot;  bytes &quot;);
    Serial  . print(&quot;  Valor U ID: &quot;);
    nfc.PrintHex(uid, uidLength);  // envía la información al monitor serie 

    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)) //   consulta si los TAGs 1..2..3 están conectados con el respectivo 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // Encendido o apagado 
 si no 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }  // Fin de la consulta/bucle IF 
} // Fin del   bucle  
 &amp;nbsp; 
                ]]>
            </content>

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

    
</feed>
