RFID RC522 Aumentar números +1 y escribirlo SOLUCIONADO

Hola Chicos/as.
OJO ! NOVATO

Estoy inmerso en un nuevo proyecto para control de stock con RFID. Utilizo un UNO, RFID-RC522 y cada producto llevará un TAG RFID adhesivo oculto.

Ya tengo el boceto funcionando para leer los TAGS en decimal y me los muestra en lcd y serial. He ido encontrando codigos y he modificado para mis intereses. Falta perfeccionarlo y añadir funciones.

Ahora estoy con la parte de escribir numero de UID en cada TAG para empezar de 0 e ir escribiendo el siguiente numero en el siguiente TAG que se acerque al RC522.

Tengo ya un código donde escribes qué UID quieres y lo graba. De hecho muestra el UID actual y el nuevo. Si paso varios tags uno tras otro, escribirá el mismo numero que está definido en el código, en todos los tags.
Lo que me gustaría es que cada vez que acerco un nuevo tag, escriba el numero siguiente…(+1)

En el codigo se define el numero a escribir en HEX, aunque para mostrarlo en serial o lcd, he modificado a DEC que es más operativo para el stock.

El problema principal es que el UID se compone de 4 números HEX que muestra por separado. No sé como decirle que sume al ultimo +1.

Por ejemplo 0xDE, 0xB1, 0xFA, 0x07. ¿ Como sumo +1 al 07(hex) para que se refleje esa suma en el numero total Decimal.

Alguien podría sugerirme como decirle al código que sume +1 cada vez que acerco una tarjeta ??

Estos son los códigos de lectura y de escritura con el que tengo la duda:

#include <SPI.h>
#include <MFRC522.h>

#define SS_PIN 10
#define RST_PIN 9
#include <LiquidCrystal_I2C.h>

  MFRC522 mfrc522(SS_PIN, RST_PIN);   
  LiquidCrystal_I2C lcd(0x27,20,4);  // set the LCD address to 0x27 for a 16 chars and 2 line display


 
void setup() 
{
  Serial.begin(9600);   // Initialize serial communications with the PC
  while (!Serial);    // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
  pinMode(3, OUTPUT);//buzzer
  SPI.begin();     
  mfrc522.PCD_Init();   
  mfrc522.PCD_SetAntennaGain(mfrc522.RxGain_max);

  Serial.println("Esperando UID: ");
  
  lcd.init();
  lcd.backlight();
  lcd.setCursor(1,0);
  lcd.print("Aproxime una Tarjeta");
  

}
void loop() 
{

  if ( ! mfrc522.PICC_IsNewCardPresent()) 
  {
    return;
  }

  if ( ! mfrc522.PICC_ReadCardSerial()) 
  {
    return;
  }

  lcd.clear();
  lcd.setCursor(1,0);
  lcd.print("UID tag :");
  String content= "";
  byte letter;
  for (byte i = 0; i < mfrc522.uid.size; i++) 
  {
    content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? "0" : ""));
    content.concat(String(mfrc522.uid.uidByte[i], DEC));
  }

  digitalWrite(3, HIGH);//Al detectar RFID 13,56 MHz suena buzzer
  delay(50);
  digitalWrite (3, LOW);
  delay(50);
  digitalWrite(3, HIGH);
  delay(50);
  digitalWrite (3, LOW);
  
  lcd.clear();
  lcd.setCursor(1,1);
  lcd.print("UID: ");
  lcd.setCursor(1,2);
  lcd.print(content);
  content.toUpperCase();

 Serial.print("Card UID: ");
 Serial.println(content);


  
  delay(1000);
   
  }

Este el de escritura:

//Conexiones de RFID-RC522 para UNO:
  // 3,3V -> 3,3V
  // GND -> GND
  // SDA(SS) -> 10
  // SCK -> 13
  // MOSI -> 11
  // MOSOI -> 12
  // RST -> 9 

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN   9     // Configurable, see typical pin layout above
#define SS_PIN    10    // Configurable, see typical pin layout above

MFRC522 mfrc522(SS_PIN, RST_PIN);   // Create MFRC522 instance


#define NEW_UID {0xDE, 0xB1, 0xFA, 0x07}// Set your new UID here! 

MFRC522::MIFARE_Key key;

void setup() {
  Serial.begin(9600);  // Initialize serial communications with the PC
  while (!Serial);     // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
  SPI.begin();         // Init SPI bus
  mfrc522.PCD_Init();  // Init MFRC522 card
  Serial.println(F("Atención, cuando acerque el TAG al lector, se programará el nuevo UID!"));
  
  // Prepare key - all keys are set to FFFFFFFFFFFFh at chip delivery from the factory.
  for (byte i = 0; i < 6; i++) {
  key.keyByte[i] = 0xFF;
 }
}

void loop() {
  
  // Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle. And if present, select one.
  if ( ! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial() ) {
    delay(50);
    return;
  }
  
    
  Serial.print(F("UID: "));
  for (byte i = 0; i < mfrc522.uid.size; i++) {
  Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
  Serial.print(mfrc522.uid.uidByte[i], DEC);
  } 
  Serial.println();

  
  
  // Set new UID
  byte newUid[] = NEW_UID;
  if ( mfrc522.MIFARE_SetUid(newUid, (byte)4, true) ) {
   
  }
  
  // Halt PICC and re-select it so DumpToSerial doesn't get confused
  mfrc522.PICC_HaltA();
  if ( ! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial() ) {
    return;
  }
  
  
  
  delay(2000);
}

Gracias de antemano…
Feliz año nuevo a todo el foro.

Este es tu código de lectura

    for (byte i = 0; i < mfrc522.uid.size; i++)  {
        content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? "0" : ""));
        content.concat(String(mfrc522.uid.uidByte[i], DEC));
    }

y este el de escritura

  for (byte i = 0; i < mfrc522.uid.size; i++) {
        Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
        Serial.print(mfrc522.uid.uidByte[i], DEC);
 }

No veo donde quieres agregarle el +1
Si le agregas +1 a algo que lees que garantiza que la siguiente vez no veras lo mismo +1.

Ejemplo 0xDE, 0xB1, 0xFA, 0x07 y le sumas 1

Tendras

0xDE, 0xB1, 0xFA, 0x08

La siguiente ves que pases la tarjeta leeras de nuevo
0xDE, 0xB1, 0xFA, 0x07
que +1 sera

0xDE, 0xB1, 0xFA, 0x08

Entonces?

No estas guardando una información en la tarjeta, sino al leerla.

Tal vez esta sea la instrucción que necesitas

 // Set new UID
  byte newUid[] = NEW_UID;
  if ( mfrc522.MIFARE_SetUid(newUid, (byte)4, true) ) {
   
  }

No he leído la librería así que no se con que procedimiento se salvan datos en al RFID.

Hola y gracias por contestar.

Me he explicado mal.
Olvídate del código de lectura.

Con el de escritura, puedo escribir un nuevo numero de 4 bytes a un TAG. Luego al leer lo paso de hex a dec para mostrarlo en lcd o serial.
Pero quiero escribir números consecutivos en, por ejemplo 100 Tags.
Lo puedo hacer uno a uno, pero es un trabajo de locos.
En el codigo de escritura le digo donde quiero que empiece, por ejemplo:

En #define NEW_UID {0xDE, 0xB1, 0xFA, 0x07}// Set your new UID here!

Siguiente tag que escriba NEW_UID {0xDE, 0xB1, 0xFA, 0x08}

Al acabar con el ultimo byte (0x08), cuando llegue a 0xFF, que empiece de nuevo en 0x00 y en el penultimo cambie a 0xFB.

Así hasta el infinito y desde donde yo le haya indicado en la primera linea.
Bueno hasta el infinito HEX, 0xFF, 0xFF, 0xFF, 0xFF que creo sería en decimal 255255255255.

La idea es poder "marcar" cada producto con su UID unico y exclusivo, automáticamente.

Si alguien prueba el código de escritura que he postedado antes, verá que sin hacer nada, solo con acercar un tag, lo lee y escribe el nuevo UID. Pasas otro tag y lo mismo y así miles de veces.
El problema es que el num de UID es el que aparece en el sketch...Necesito unas lineas que le digan, sigue así, pero cada tag que detectes, escribele un numero más que el que acabas de escribir en el tag anterior.

Gracias igualmente

He pasado 5 TAGS seguidos por RC522, uno tras otro sin tocar nada y esto es lo que aparece en el monitor serial:

Atención, cuando acerque el TAG al lector, se programará el nuevo UID!

UID:  BA B1 FA 07 <-- UID del TAG antes de escribir
UID:  FF CD D8 FC <-- UID del TAG recién escrito

UID:  34 CB 58 C3 <-- UID del TAG antes de escribir
UID:  FF CD D8 FC <-- UID del TAG recién escrito

UID:  45 B1 FF DE <-- UID del TAG antes de escribir
UID:  FF CD D8 FC <-- UID del TAG recién escrito

UID:  BA F4 F1 BD <-- UID del TAG antes de escribir
UID:  FF CD D8 FC <-- UID del TAG recién escrito

UID:  FC D1 D9 9D <-- UID del TAG antes de escribir
UID:  FF CD D8 FC <-- UID del TAG recién escrito

Quiero que haga lo mismo pero esa segunda linea se vea incrementada +1 en cada escritura…
En este caso siempre escribe el mismo código porque es el que indica el sketch.

Gracias

Se que es complejo pero mira este código rfid_write_personal_data.ino

Te permite guardar información escrita via puerto Serie o sea el Monitor Serie.

Si, lo conozco y lo he probado...
TambiénLee y escribe uno mas clarito uq e este:

Lo malo es que no cambian el UID...Escribe un texto o numero en la memoria de la tarjeta o etiqueta, pero no es el numero único.

Lo estudiaré igual estos días a ver si pudiera servirme, pero creo que no.

Esto es lo que escribe (MANOLITO):

1. Escribir
2. Leer
**Card Detected:**
Card UID: C3 12 D4 B1
Card SAK: 08
PICC type: MIFARE 1KB
MANOLITO        
**End Reading**

Si te fijas, el UID lo mantiene.

Lo miraré con calma el fin de semana.
Gracias

Esta es el llamado al procedimiento o función porque veo que dice bool algo.

/**
 * Reads entire block 0, including all manufacturer data, and overwrites
 * that block with the new UID, a freshly calculated BCC, and the original
 * manufacturer data.
 *
 * It assumes a default KEY A of 0xFFFFFFFFFFFF.
 * Make sure to have selected the card before this function is called.
 */
bool MFRC522::MIFARE_SetUid(byte *newUid, byte uidSize, bool logErrors) {

Bien, espera un puntero a bytes con el nuevo Uid, un byte con el tamaño y algo que le diga si queremos o no leer los errores.

En el código que posteaste (escritura) se lee esto

// Set new UID
  byte newUid[] = NEW_UID;
  if ( mfrc522.MIFARE_SetUid(newUid, (byte)4, true) ) {
    Serial.println(F("Wrote new UID to card."));
  }

quiere decir que se puede cargar un nuevo UId trabajando esos 4 bytes.

Una forma simple de hacerlo que es la que se me ocurre ahora es con union entre una numero unsigned int y sus 4 bytes que lo conforman.

algo asi

union tagname
{
	unsigned int a;
	byte Uid[4];
};

union tagname object;

void setup() {
    Serial.begin(9600);
}

void loop()
{
	char i; //for loop counter
    char buffer[20];

	//assign an integer number
	object.a = 0xDEB1FA07; // tu Uid

	sprintf(buffer, "Integer number: %ld, hex: %X\n",object.a,object.a);
    Serial.println(buffer);
    Serial.println("Indivisual bytes: ");
	for(i=3;i>=0;i--)
		sprintf(buffer,"%02X ",object.Uid[i]);
        Serial.print(buffer);
	Serial.println();
}

A ver si esto funciona. Si funciona entonces solo incrementa el entero y tendras tu UiD listo para ser guardado.

La solución de surbyte no creo que funcione porque el endianness es diferente.

La siguente función incrementa en uno el UID, independientemente del endianness del microcontrolador:

void incrementaUid(void *uid) { 
  for (int i = 3; i >= 0; i--) { 
    if (++((byte *)uid)[i]) { 
      break;
    } 
  } 
}

Incluye la función en el código y simplemente para incrementar, por ejemplo newUid, llámala tal que así:

    incrementaUid(newUid); // Incrementa en uno el UID.

Espero que sea eso lo que buscas.

Yo aun no incrementé nada @IgnoranteAbsoluto.

Y acá lo he probado y si funciona. Había un par de errores.
Esto en el sprintf no funciona correctamente

"Integer number: %ld, hex: %X"

en su lugar va

"Numero entero: %lu\nNúmero hex   : %lX"

Código corregido que se incrementa.

union tagname
{
	unsigned long a;
	unsigned char Uid[8];
};

union tagname object;

void setup() {
  Serial.begin(9600);
  Serial.println("Comanzando.");
  

	//assign an integer number
	object.a = 0xDEB1FA07; // tu Uid


}

void loop()
{
	
  char i; //for loop counter
  char buffer[60];
  sprintf(buffer, "Numero entero: %lu\nNúmero hex   : %lX",object.a,object.a);
  Serial.println(buffer);
  Serial.print("bytes Indepen: ");
	
  for(i=3;i>=0;i--) {
		  sprintf(buffer,"%02X ",object.Uid[i]);
      Serial.print(buffer);
  }
	Serial.println();
  object.a++;
  delay(2000);
  
}

DOMPA, he visto que parece que tratas de convertir el UID a su valor en decimal (base 10), con las lineas de código:

    for (byte i = 0; i < mfrc522.uid.size; i++)  {
        content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? "0" : ""));
        content.concat(String(mfrc522.uid.uidByte[i], DEC));
    }

Y tambíén en las líneas:

  for (byte i = 0; i < mfrc522.uid.size; i++) {
        Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
        Serial.print(mfrc522.uid.uidByte[i], DEC);
  }

Pero eso no obtiene su valor decimal. Así que aquí tienes dos funciones que te permiten convertir el UID a su valor en decimal (has de guardarlo y/o tratarlo con variables de tipo unsingned long) y una función que te convierte el valor decimal en un UID. Esto te sirve tanto para mostrar los valores en decimal, como para hacer lo del incremento. Para lo del incremento lo único que has de hacer es convertir el UID en decimal (unsigned long), incrementar el valor y volverlo a convertir un el UID. Ejemplo de incrementar en uno newUid con las dos funciones:

  convierteEnteroEnUid(convierteUidEnEntero(newUid) - 1, newUid); // Incrementa en uno el UID

Las dos funciones son:

unsigned long convierteUidEnEntero(const void *uid) {
  unsigned long valor = 0;
  for (int i = 0; i < 4; i++) {
    valor = (valor << 8) | ((byte *)uid)[i];
  }
  return valor;
}

void convierteEnteroEnUid(unsigned long valor, const void *uid) {
  for (int i = 3; i >= 0; i--) {
    ((byte *)uid)[i] = valor;
    valor >>= 8;
  }
}

Con esas dos funciones en vez de hacer:

  String content= "";
  for (byte i = 0; i < mfrc522.uid.size; i++)
  {
    content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? "0" : ""));
    content.concat(String(mfrc522.uid.uidByte[i], DEC));
  }

Basta con poner:

  String content = convierteUidEnEntero(mfrc522.uid.uidByte);

Y en lugar de:

  Serial.print(F("UID: "));
  for (byte i = 0; i < mfrc522.uid.size; i++) {
  Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
  Serial.print(mfrc522.uid.uidByte[i], DEC);
  }
  Serial.println();

Basta con:

  Serial.print(F("UID: "));
  Serial.println(convierteUidEnEntero(mfrc522.uid.uidByte));

Espero que te resulten útiles ambas funciones.

Surbyte, el problema que tiene tu solución es el endianness. Si en tu último código sustituyes las líneas:

	//assign an integer number
	object.a = 0xDEB1FA07; // tu Uid

Por las líneas:

	unsigned char newUid[] = {0xDE, 0xB1, 0xFA, 0x07};
	memcpy(object.Uid, newUid, 4);

Se supone que con esas dos líneas estoy poniendo el UID que DOMPA puso de ejemplo y que, en su ejemplo, quiere incrementar. Pues si ejecutamos tu programa se muestra por el monitor:

Comenzando.
Numero entero: 133870046
Número hex   : 7FAB1DE
bytes Indepen: 07 FA B1 DE 
Numero entero: 133870047
Número hex   : 7FAB1DF
bytes Indepen: 07 FA B1 DF 
Numero entero: 133870048
Número hex   : 7FAB1E0
bytes Indepen: 07 FA B1 E0

Y eso no es lo que se supone que DOMPA espera obtener. Si nos fijamos, los cuatro bytes aparecen invertidos. A eso me refiero cuando hablo de que hay un problema con el endianness.

Lo que creo que DOMPA desearía ver es:

Comenzando.
Numero entero: 3736205831
Número hex   : DEB1FA07
bytes Indepen: DE B1 FA 07 
Numero entero: 3736205832
Número hex   : DEB1FA08
bytes Indepen: DE B1 FA 08 
Numero entero: 3736205833
Número hex   : DEB1FA09
bytes Indepen: DE B1 FA 09

Y eso se consigue, independientemente del endianness del micro, con el código:

unsigned long convierteUidEnEntero(const void *uid) {
  unsigned long valor = 0;
  for (int i = 0; i < 4; i++) {
    valor = (valor << 8) | ((byte *)uid)[i];
  }
  return valor;
}

void convierteEnteroEnUid(unsigned long valor, const void *uid) {
  for (int i = 3; i >= 0; i--) {
    ((byte *)uid)[i] = valor;
    valor >>= 8;
  }
}

byte newUid[] = {0xDE, 0xB1, 0xFA, 0x07};

void setup() {
  Serial.begin(9600);
  Serial.println("Comenzando.");
}

void loop()
{

  char i; //for loop counter
  char buffer[60];
  unsigned long valorEntero = convierteUidEnEntero(newUid);
  sprintf(buffer, "Numero entero: %lu\nNúmero hex   : %lX", valorEntero, valorEntero);
  Serial.println(buffer);
  Serial.print("bytes Indepen: ");

  for(i=0; i < 4; i++) {
    sprintf(buffer,"%02X ", newUid[i]);
    Serial.print(buffer);
  }
  Serial.println();
  convierteEnteroEnUid(valorEntero + 1, newUid); // Incrementamos el valor del UID
  delay(2000);
}

Resumiendo: el problema es que el endianness es el contrario el uno que el otro. Es decir, en el caso del unsigned long el Arduino UNO guarda en memoria primero el byte menos significativo y por último el más significativo, mientras que DOMPA ha supuesto que se guarda primero el byte más significativo y el último el menos significativo.

El codigo del post #8 no hace lo que dices..

Hace esto

Comenzando.
Numero entero: 3736205831
Número hex : DEB1FA07
bytes Indepen: DE B1 FA 07
Numero entero: 3736205832
Número hex : DEB1FA08
bytes Indepen: DE B1 FA 08
Numero entero: 3736205833
Número hex : DEB1FA09
bytes Indepen: DE B1 FA 09
Numero entero: 3736205834
Número hex : DEB1FA0A
bytes Indepen: DE B1 FA 0A
Numero entero: 3736205835
Número hex : DEB1FA0B
bytes Indepen: DE B1 FA 0B
Numero entero: 3736205836
Número hex : DEB1FA0C
bytes Indepen: DE B1 FA 0C
Numero entero: 3736205837
Número hex : DEB1FA0D
bytes Indepen: DE B1 FA 0D
Numero entero: 3736205838
Número hex : DEB1FA0E
bytes Indepen: DE B1 FA 0E
Numero entero: 3736205839
Número hex : DEB1FA0F
bytes Indepen: DE B1 FA 0F
Numero entero: 3736205840
Número hex : DEB1FA10
bytes Indepen: DE B1 FA 10
Numero entero: 3736205841
Número hex : DEB1FA11
bytes Indepen: DE B1 FA 11
Numero entero: 3736205842
Número hex : DEB1FA12
bytes Indepen: DE B1 FA 12
Numero entero: 3736205843
Número hex : DEB1FA13
bytes Indepen: DE B1 FA 13
Numero entero: 3736205844
Número hex : DEB1FA14
bytes Indepen: DE B1 FA 14
Numero entero: 3736205845
Número hex : DEB1FA15
bytes Indepen: DE B1 FA 15
Numero entero: 3736205846
Número hex : DEB1FA16
bytes Indepen: DE B1 FA 16
Numero entero: 3736205847
Número hex : DEB1FA17
bytes Indepen: DE B1 FA 17

Surbyte, ¿con qué Arduino has ejecutado el código del post #8?

Yo lo he ejecutado con un Arduino UNO y me sale "otra cosa".

Con un NANO, no veo porque debiera salir otra cosa.
Aclaro que estoy trabajando con PlatformIO y creo que ahí tal vez haya algún cambio, será eso posible?
Se que no debates algo a menos que estes seguro y yo hago lo mismo.

Estoy en Ubuntu y ahora lo corrí con IDE y mismo resultado, ahora con Old Bootloader en mi caso.

Comenzando.
Numero entero: 3736205831
Número hex : DEB1FA07
bytes Indepen: DE B1 FA 07
Numero entero: 3736205832
Número hex : DEB1FA08
bytes Indepen: DE B1 FA 08
Numero entero: 3736205833
Número hex : DEB1FA09
bytes Indepen: DE B1 FA 09
Numero entero: 3736205834
Número hex : DEB1FA0A
bytes Indepen: DE B1 FA 0A
Numero entero: 3736205835
Número hex : DEB1FA0B
bytes Indepen: DE B1 FA 0B
Numero entero: 3736205836
Número hex : DEB1FA0C
bytes Indepen: DE B1 FA 0C

No estoy seguro, pero creo que hay microcontroladores que pueden trabajar tanto big-endian como little-endian y se configuran “al vuelo” mediante software. Así que no descarto que mi compilador “trabaje” con little-endian. He probado desde linux con un Arduino UNO y con un Arduino MEGA el siguiente programa y para ambos me ha dicho que están en little-endian.

#include <Arduino.h>

#include <limits.h>
#include <stdint.h>

#if CHAR_BIT != 8
#error "unsupported char size"
#endif

enum
{
    O32_LITTLE_ENDIAN = 0x03020100ul,
    O32_BIG_ENDIAN = 0x00010203ul,
    O32_PDP_ENDIAN = 0x01000302ul
};

static const union { unsigned char bytes[4]; uint32_t value; } o32_host_order =
    { { 0, 1, 2, 3 } };

#define O32_HOST_ORDER (o32_host_order.value)

void setup()
{
  Serial.begin( 9600 );

  if ( O32_HOST_ORDER == O32_LITTLE_ENDIAN )
  {
    Serial.println( F( "Little Endian" ) );
  }
  else if ( O32_HOST_ORDER == O32_BIG_ENDIAN )
  {
    Serial.println( F( "Big Endian" ) );
  }
  else if ( O32_HOST_ORDER == O32_PDP_ENDIAN )
  {
    Serial.println( F( "PDP Endian" ) );
  }
  else
  {
    Serial.println( F( "Other Endian" ) );
  }
}

void loop() {
  // put your main code here, to run repeatedly:

}

Seguramente tu Arduino está trabajando en big-endian. Precisamente ese es uno de los grandes problemas de depender del endianness, la compatibilidad y trasportabilidad del código.

Tu código funciona según las especificaciones de DOMPA si el micro trabaja en big-endian. Mi código no depende para nada del endianness.

Yo no tengo ahora ningún NANO para probar. ¿Puedes tú probar con un UNO o un MEGA para ver con qué endianness te trabaja?

Si. Ya mismo pruebo con un MEGA. A ver que ocurre.

Con MEGA en Ubuntu bajo IDE

Comenzando.
Numero entero: 3736205831
Número hex : DEB1FA07
bytes Indepen: DE B1 FA 07
Numero entero: 3736205832
Número hex : DEB1FA08
bytes Indepen: DE B1 FA 08
Numero entero: 3736205833
Número hex : DEB1FA09
bytes Indepen: DE B1 FA 09
Numero entero: 3736205834
Número hex : DEB1FA0A
bytes Indepen: DE B1 FA 0A
Numero entero: 3736205835
Número hex : DEB1FA0B
bytes Indepen: DE B1 FA 0B

Buenos días.

Sigo impresionado con este foro y foreros. Ayer me fuí a la cama con mil dudas y hoy amanezco con 10 respuestas a mi tema. Muchas gracias a ambos.

voy a probar estas sugerencias a ver que pasa.

Para decirlo de una forma bruta, no me interesan los números hex para este proyecto... Solo pretendo numerar productos de un almacén del 0 al 9999999999 y que se identifiquen con un numero único para cada producto. Sin mas.

Si tengo que pasar por los hex para hallar el numero DEC, de acuerdo, pero no los necesito.

Pues lo dicho, voy a intentar entender vuestras sugerencias e implementarlas.

Gracias de nuevo.

Hola IgnoranteAbsoluto.

Empiezo a dar la paliza.

He seguido tus sugerencias pero algo no he hecho bien.
Entiendo que me sujieres cambios en sketch de lectura para convertir a decimal y en el sketch de escritura para convertir a decimal e incrementar +1 el UID.

Pues en ambos codigos me da error al hacer tus modificaciones.

Algo he entendido mal. Pego el código de escritura aquí (OJO no funciona):

// CODIGO PARA ESCRIBIR UID EN TARJETA RFID
  // Error en linea 60: exit status 1
  // a function-definition is not allowed here before '{' token

  
  
  //Conexiones de RFID-RC522 para UNO:
  // 3,3V -> 3,3V
  // GND -> GND
  // SDA(SS) -> 10
  // SCK -> 13
  // MOSI -> 11
  // MOSOI -> 12
  // RST -> 9 

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN   9     // Configurable, see typical pin layout above
#define SS_PIN    10    // Configurable, see typical pin layout above

MFRC522 mfrc522(SS_PIN, RST_PIN);   // Create MFRC522 instance


#define NEW_UID {0xFF, 0xCD, 0xD8, 0xFC}// Set your new UID here! 

MFRC522::MIFARE_Key key;

void setup() {
  Serial.begin(9600);  // Initialize serial communications with the PC
  while (!Serial);     // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
  SPI.begin();         // Init SPI bus
  mfrc522.PCD_Init();  // Init MFRC522 card
  Serial.println(F("Atención, cuando acerque el TAG al lector, se programará el nuevo UID!"));
  
  // Prepare key - all keys are set to FFFFFFFFFFFFh at chip delivery from the factory.
  for (byte i = 0; i < 6; i++) {
  key.keyByte[i] = 0xFF;
 }
}

void loop() {
  
  // Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle. And if present, select one.
  if ( ! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial() ) {
    delay(50);
    return;
  }
  
    
  //Serial.print(F("UID: "));
  //for (byte i = 0; i < mfrc522.uid.size; i++) {
  //Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
  //Serial.print(mfrc522.uid.uidByte[i], DEC);
  // } 
  //Serial.println();

/////////////////////////////////////////////////////////////// MODIFICACION
  unsigned long convierteUidEnEntero(const void *uid) {
  unsigned long valor = 0;
  for (int i = 0; i < 4; i++) {
    valor = (valor << 8) | ((byte *)uid)[i];
  }
  return valor;
}

void convierteEnteroEnUid(unsigned long valor, const void *uid) {
  for (int i = 3; i >= 0; i--) {
    ((byte *)uid)[i] = valor;
    valor >>= 8;
  }
}




  Serial.print(F("UID: "));
  Serial.println(convierteUidEnEntero(mfrc522.uid.uidByte));

//////////////////////////////////////////////////////////////////MODIFICACION


  
  
  
  // Set new UID
  byte newUid[] = NEW_UID;
  if ( mfrc522.MIFARE_SetUid(newUid, (byte)4, true) ) {
   
  }
  
  // Halt PICC and re-select it so DumpToSerial doesn't get confused
  mfrc522.PICC_HaltA();
  if ( ! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial() ) {
    return;
  }
  
  
  
  delay(2000);
}

En siguiente post, pego el de lectura para no liarnos.

Gracias

Este es de lectura con tus modificaciones. OJO NO FUNCIONA:

////CODIGO PAR LEER UID DE LA TARJETA
/// ERROR EN LINEA 62. exit status 1 a function-definition is not allowed here before '{' token


#include <SPI.h>
#include <MFRC522.h>

#define SS_PIN 10
#define RST_PIN 9
#include <LiquidCrystal_I2C.h>

  MFRC522 mfrc522(SS_PIN, RST_PIN);   
  LiquidCrystal_I2C lcd(0x27,20,4);  // set the LCD address to 0x27 for a 16 chars and 2 line display


 
void setup() 
{
  Serial.begin(9600);   // Initialize serial communications with the PC
  while (!Serial);    // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
  pinMode(3, OUTPUT);//buzzer
  SPI.begin();     
  mfrc522.PCD_Init();   
  mfrc522.PCD_SetAntennaGain(mfrc522.RxGain_max);

  Serial.println("Esperando UID: ");
  
  lcd.init();
  lcd.backlight();
  lcd.setCursor(1,0);
  lcd.print("Aproxime Tarjeta");
  

}
void loop() 
{

  if ( ! mfrc522.PICC_IsNewCardPresent()) 
  {
    return;
  }

  if ( ! mfrc522.PICC_ReadCardSerial()) 
  {
    return;
  }

  lcd.clear();
  lcd.setCursor(1,0);
  lcd.print("UID tag :");
  
  //String content= "";
  //byte letter;
  //for (byte i = 0; i < mfrc522.uid.size; i++) 
  //{
    //content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? "0" : ""));
    //content.concat(String(mfrc522.uid.uidByte[i], DEC));
  //}

 
//////////////////////////////////////////////////////////////////MODIFICACION
unsigned long convierteUidEnEntero(const void *uid) {
  unsigned long valor = 0;
  for (int i = 0; i < 4; i++) {
    valor = (valor << 8) | ((byte *)uid)[i];
  }
  return valor;
}

void convierteEnteroEnUid(unsigned long valor, const void *uid) {
  for (int i = 3; i >= 0; i--) {
    ((byte *)uid)[i] = valor;
    valor >>= 8;
  }
}
/////////////////////////////////////////////////////////////////MODIFICACION



  digitalWrite(3, HIGH);//Al detectar RFID 13,56 MHz suena buzzer
  delay(50);
  digitalWrite (3, LOW);
  delay(50);
  digitalWrite(3, HIGH);
  delay(50);
  digitalWrite (3, LOW);
  
  lcd.clear();
  lcd.setCursor(1,1);
  lcd.print("UID: ");
  lcd.setCursor(1,2);
  lcd.print(content);
  content.toUpperCase();

 Serial.print("Card UID: ");
 Serial.println(content);


  
  delay(1000);
   
  }

Gracias

IgnoranteAbsoluto, estoy también probando tu primera sugerencia del post #7.

No da errores, lee/escribe, lee/escribe pero no suma uno a lo escrito anteriormente.

Creo que se ha entendido, que aunque este sketch lee primero y luego escribe, no suma +1 a lo leído. Lo tiene que sumar a lo escrito anteriormente. El hecho de que lo lea es solo porque el código original así lo traía y no me he parado a quitarlo....

La suma tiene que hacerla empezando por el numero hex definido en el código, en :

#define NEW_UID {0xBD, 0x8D, 0x1E, 0xC4}// Set your new UID here!

E ir sumando +1 a lo escrito. C4, C5, C6..........FF y luego debe empezar en 0x1F, 0x00 y así hasta llegar a:

0xFF, 0xFF, 0xFF, 0xFF

Creo que en estas modificaciones es cuestión de encontrar donde colar :

incrementaUid(newUid); // Incrementa en uno el UID.

Estoy probando en varios lugares pero no suma.

surbyte, Agradezco tu siempre rápida ayuda...Pero entiendo mejor la otra sugerencia...Gracias

Sigo probando, gracias.