Copie RFID, code pour dump et ecrire Module RC522

International Français
1

Bonjour, :smiley:

je débute avec Arduino surtout avec le module RC522

Je souhaite effectuer des clones des puces, badge rfid sur d'autre puce vierge dont le block 0 est modifiable.
J'ai déjà effectuer mes copie du UID avec l'Arduino, et le reste des block avec mon téléphone.

Mais j'aimerais pouvoir effectuer ces copie directement via l’Arduino.

Mais il me manque des connaissances, le code qui permet de copie le dump sur une sorte de variables.
et ensuite pouvoir écrire cette variable (dump) sur ma nouvelle carte.

Après est ce possible pour une variable de stocker autant d'info(ou plusieurs variable pour chaque block), et aussi est-ce possible pour l’Arduino de stocker tous sa sur sa mémoire flash le temps d'une copie.

Merci d'avance de toutes aide.

2

il y a plein de tutos (en voici un par exemple) en ligne pour la lecture et écriture, qu'avez vous essayé ?

Quand le code est petit, le mieux est de le poster directement dans le texte de votre message, avec les balises de code (cf règles du forum). Là je ne peux pas le lire sur mon smartphone.

3

Bonjour, en passant, le code de l'ino de seb6719 donné en lien plus haut.

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

#define RST_PIN   9     
#define SS_PIN    10    

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

/* Set your new UID here! */
#define NEW_UID {0x9D, 0x25, 0x41, 0x3D}

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("Attention, l'UID va etre ecrase !"));
  
  // 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;
  }
}

// Setting the UID can be as simple as this:
//void loop() {
//  byte newUid[] = NEW_UID;
//  if ( mfrc522.MIFARE_SetUid(newUid, (byte)4, true) ) {
//    Serial.println("Wrote new UID to card.");
//  }
//  delay(1000);
//}

// But of course this is a more proper approach
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;
  }
  
  // Now a card is selected. The UID and SAK is in mfrc522.uid.
  
  // Dump UID
  Serial.print(F("Card UID:"));
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
    Serial.print(mfrc522.uid.uidByte[i], HEX);
  } 
  Serial.println();

  // Dump PICC type
//  MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
//  Serial.print(F("PICC type: "));
//  Serial.print(mfrc522.PICC_GetTypeName(piccType));
//  Serial.print(F(" (SAK "));
//  Serial.print(mfrc522.uid.sak);
//  Serial.print(")\r\n");
//  if (  piccType != MFRC522::PICC_TYPE_MIFARE_MINI 
//    &&  piccType != MFRC522::PICC_TYPE_MIFARE_1K
//    &&  piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
//    Serial.println(F("This sample only works with MIFARE Classic cards."));
//    return;
//  }
  
  // Set new UID
  byte newUid[] = NEW_UID;
  if ( mfrc522.MIFARE_SetUid(newUid, (byte)4, true) ) {
    Serial.println(F("Wrote new UID to card."));
  }
  
  // Halt PICC and re-select it so DumpToSerial doesn't get confused
  mfrc522.PICC_HaltA();
  if ( ! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial() ) {
    return;
  }
  
  // Dump the new memory contents
  Serial.println(F("New UID and contents:"));
  mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
  
  delay(2000);
}
4

J-M-L:
il y a plein de tutos (en voici un par exemple) en ligne pour la lecture et écriture, qu'avez vous essayé ?

Quand le code est petit, le mieux est de le poster directement dans le texte de votre message, avec les balises de code (cf règles du forum). Là je ne peux pas le lire sur mon smartphone.

J'avais deja vue ce tuto mais sans grand succes,

Je viens de remarquer que j'ai mis le mauvais fichier ino, l'autre c'est une copie d'un code que j'ai trouver sur internet que je suis en train de le décortiquer pour comprendre le fonctionne des fonction de rc522 pourvoir reprendre des partie de code a gauche a droite pour faire ce que je veux.

voici le code que je suis en train de faire.

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

// Affectation des broches
#define RST_PIN 9
#define SS_PIN 10
MFRC522 mfrc522(SS_PIN, RST_PIN);
MFRC522::MIFARE_Key key;

void setup() 
    {
  // Initialisation du Module RFID
  Serial.begin(9600);
  while(!Serial);
  SPI.begin();
  mfrc522.PCD_Init();
  mfrc522.PCD_DumpVersionToSerial(); // Affichage des données de la bibliothèque
  Serial.println(F("Veuillez Presenté votre badge"));
  for (byte i = 0; i < 6; i++) { key.keyByte[i] = 0xFF; }// surement pour les cle A et B
    }
  
  void loop() {
    // Attente d'une carte RFID
    if( ! mfrc522.PICC_IsNewCardPresent()) {
      return;
      }
      // Récupération des info de la carte RFID
      if( ! mfrc522.PICC_ReadCardSerial()) {
        return;
        }
        // Affichage des info de la carte RFID
        mfrc522.PICC_DumpToSerial(&(mfrc522.uid));


       // -+-+-+-+code a faire-+-+-+-
       //dump  @01@ ?
       //Copie du dump de la carte origine vers variable (DUMP_CARTE).

  Serial.println(F("Dump effectué, veuillez presenter la nouvelle carte."));


      // -+-+-+-+code a faire-+-+-+-
      // Copie le dump de la variable (DUMP_CARTE) sur la nouvelle carte vierge.
      //
      
   Serial.println(F("Copier terminé."));

   
  }

//dump @01@
//  Serial.print(F("Card UID:"));
//  for (byte i = 0; i < mfrc522.uid.size; i++) {
//    Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
 //   Serial.print(mfrc522.uid.uidByte[i], HEX);

Je cherche surtout la liste de toute les fonction qui serait utile pour lecture et écriture d'une puce rfid du module rc522, mais je crois que j'ai trouver quelque truc, je vais regarde sa demain et je reviendrais si j'ai reusis ou si je but encore sur autre truc.

5

Quand vous faites #include <MFRC522.h>vous importez la classe MFRC522 et déclarez les méthodes qui vont existez. en regardant dans ce .h vous allez voir tout ce que la classe sait faire, souvent le développeur donne des noms parlants aux méthodes... et bien sûr ensuite il y a la doc.

Voici par exemple la partie intéressante de ce fichier:

	/////////////////////////////////////////////////////////////////////////////////////
	// Functions for manipulating the MFRC522
	/////////////////////////////////////////////////////////////////////////////////////
	void PCD_Init();
	DEPRECATED_MSG("use PCD_Init(byte chipSelectPin, byte resetPowerDownPin)")
	void PCD_Init(byte resetPowerDownPin);
	void PCD_Init(byte chipSelectPin, byte resetPowerDownPin);
	void PCD_Reset();
	void PCD_AntennaOn();
	void PCD_AntennaOff();
	byte PCD_GetAntennaGain();
	void PCD_SetAntennaGain(byte mask);
	bool PCD_PerformSelfTest();
	
	/////////////////////////////////////////////////////////////////////////////////////
	// Power control functions
	/////////////////////////////////////////////////////////////////////////////////////
	void PCD_SoftPowerDown();
	void PCD_SoftPowerUp();
	
	/////////////////////////////////////////////////////////////////////////////////////
	// Functions for communicating with PICCs
	/////////////////////////////////////////////////////////////////////////////////////
	StatusCode PCD_TransceiveData(byte *sendData, byte sendLen, byte *backData, byte *backLen, byte *validBits = nullptr, byte rxAlign = 0, bool checkCRC = false);
	StatusCode PCD_CommunicateWithPICC(byte command, byte waitIRq, byte *sendData, byte sendLen, byte *backData = nullptr, byte *backLen = nullptr, byte *validBits = nullptr, byte rxAlign = 0, bool checkCRC = false);
	StatusCode PICC_RequestA(byte *bufferATQA, byte *bufferSize);
	StatusCode PICC_WakeupA(byte *bufferATQA, byte *bufferSize);
	StatusCode PICC_REQA_or_WUPA(byte command, byte *bufferATQA, byte *bufferSize);
	virtual StatusCode PICC_Select(Uid *uid, byte validBits = 0);
	StatusCode PICC_HaltA();

	/////////////////////////////////////////////////////////////////////////////////////
	// Functions for communicating with MIFARE PICCs
	/////////////////////////////////////////////////////////////////////////////////////
	StatusCode PCD_Authenticate(byte command, byte blockAddr, MIFARE_Key *key, Uid *uid);
	void PCD_StopCrypto1();
	StatusCode MIFARE_Read(byte blockAddr, byte *buffer, byte *bufferSize);
	StatusCode MIFARE_Write(byte blockAddr, byte *buffer, byte bufferSize);
	StatusCode MIFARE_Ultralight_Write(byte page, byte *buffer, byte bufferSize);
	StatusCode MIFARE_Decrement(byte blockAddr, int32_t delta);
	StatusCode MIFARE_Increment(byte blockAddr, int32_t delta);
	StatusCode MIFARE_Restore(byte blockAddr);
	StatusCode MIFARE_Transfer(byte blockAddr);
	StatusCode MIFARE_GetValue(byte blockAddr, int32_t *value);
	StatusCode MIFARE_SetValue(byte blockAddr, int32_t value);
	StatusCode PCD_NTAG216_AUTH(byte *passWord, byte pACK[]);
	
	/////////////////////////////////////////////////////////////////////////////////////
	// Support functions
	/////////////////////////////////////////////////////////////////////////////////////
	StatusCode PCD_MIFARE_Transceive(byte *sendData, byte sendLen, bool acceptTimeout = false);
	// old function used too much memory, now name moved to flash; if you need char, copy from flash to memory
	//const char *GetStatusCodeName(byte code);
	static const __FlashStringHelper *GetStatusCodeName(StatusCode code);
	static PICC_Type PICC_GetType(byte sak);
	// old function used too much memory, now name moved to flash; if you need char, copy from flash to memory
	//const char *PICC_GetTypeName(byte type);
	static const __FlashStringHelper *PICC_GetTypeName(PICC_Type type);
	
	// Support functions for debuging
	void PCD_DumpVersionToSerial();
	void PICC_DumpToSerial(Uid *uid);
	void PICC_DumpDetailsToSerial(Uid *uid);
	void PICC_DumpMifareClassicToSerial(Uid *uid, PICC_Type piccType, MIFARE_Key *key);
	void PICC_DumpMifareClassicSectorToSerial(Uid *uid, MIFARE_Key *key, byte sector);
	void PICC_DumpMifareUltralightToSerial();
	
	// Advanced functions for MIFARE
	DEPRECATED_MSG("name will change in next version")
	void MIFARE_SetAccessBits(byte *accessBitBuffer, byte g0, byte g1, byte g2, byte g3);
	DEPRECATED_MSG("will move to extra class in next version")
	bool MIFARE_OpenUidBackdoor(bool logErrors);
	DEPRECATED_MSG("will move to extra class in next version")
	bool MIFARE_SetUid(byte *newUid, byte uidSize, bool logErrors);
	DEPRECATED_MSG("will move to extra class in next version")
	bool MIFARE_UnbrickUidSector(bool logErrors);
	
	/////////////////////////////////////////////////////////////////////////////////////
	// Convenience functions - does not add extra functionality
	/////////////////////////////////////////////////////////////////////////////////////
	virtual bool PICC_IsNewCardPresent();
	virtual bool PICC_ReadCardSerial();