sobota, 3 lutego 2018

[4] STM32F429I - Moduł RFID 13,56MHz MF RC522

W tym poście chciałbym przedstawić sposób odczytu karty Mifare za pomocą modułu MF RC522.

Znalezione obrazy dla zapytania mfrc522
[Źródło: http://propix.com.pl/pl/p/Czytnik-RFID-RC522-brelok-karta/630]

Dokumentacje do układu można pobrać pod tym linkiem.

Projekt przygotowałem na płytce STM32F429I, natomiast można go bardzo łatwo przenieść na inny mikrokontroler z tej serii. Należy tylko odpowiednio zmodyfikować wyprowadzenia czy prędkości poszczególnych linii.

Podłączenie do STM32:


Do podłączenia układu wykorzystałem następujące wyprowadzenia:

  • CS(SDA) - PG2
  • SCK - PE2
  • MISO - PE6
  • MOSI - PE5
  • GND - GND
  • VCC - 3.3V
  • RST - 3.3V

Inicjalizacja SPI:


Tutaj wykorzystywane będą dwie funkcje jedna uruchamiająca SPI, druga odpowiedzialna za przesyłanie danych.

Przy przygotowywaniu kodu opierałem się na materiałach udostępnionych na serwisie GitHub dla Arduino.

Zacznę od uruchomienia układu SPI. Wykorzystałem SPI4 na pinach PE6, PE5 oraz PE2. Linia CS jest jednym z wyprowadzeń.

  1. void enableSPI4ForMfrc522()
  2. {
  3.   GPIO_InitTypeDef  GPIO_InitStructure;
  4.   SPI_InitTypeDef  SPI_InitStructure;
  6.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI4, ENABLE);
  8.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);
  10.   GPIO_PinAFConfig(GPIOE, GPIO_PinSource6, GPIO_AF_SPI4);
  11.   GPIO_PinAFConfig(GPIOE, GPIO_PinSource5, GPIO_AF_SPI4);
  12.   GPIO_PinAFConfig(GPIOE, GPIO_PinSource2, GPIO_AF_SPI4);
  14.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  15.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  16.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  17.   GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
  19.   /* SCK pin */
  20.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  21.   GPIO_Init(GPIOE, &GPIO_InitStructure);
  22.    
  23.   /* MOSI pin */
  24.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
  25.   GPIO_Init(GPIOE, &GPIO_InitStructure);
  26.    
  27.   /* MISO pin */
  28.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  29.   GPIO_Init(GPIOE, &GPIO_InitStructure);
  31.   /* Configurate SPI */
  32.   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  33.   SPI_InitStructure.SPI_Mode            = SPI_Mode_Master;
  34.   SPI_InitStructure.SPI_DataSize    = SPI_DataSize_8b;
  35.    
  36.   SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  37.   SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  38.    
  39.   SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  40.   SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
  42.   SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  44.   SPI_InitStructure.SPI_CRCPolynomial = 7;
  46.   SPI4->CR1 &= ~SPI_CR1_SPE;
  47.    
  48.   SPI_Init(SPI4, &SPI_InitStructure);
  50.   SPI4->CR1 |= SPI_CR1_SPE;
  51. }

Funkcja przesyłająca dane:

  1. #define CHECK_SPI_FREE(SPIx)            (((SPIx)->SR & (SPI_SR_TXE | SPI_SR_RXNE)) == 0 || ((SPIx)->SR & SPI_SR_BSY))
  3. uint8_t spiSendData(SPI_TypeDef* SPIx, uint8_t dataToSend)
  4. {
  5.     /* Check if SPI is enabled */
  6.     if (!((SPIx)->CR1 & SPI_CR1_SPE))
  7.     {
  8.         return 0;
  9.     }
  11.     /* wait for previus transmission to finish */
  12.     while (CHECK_SPI_FREE(SPIx));
  13.    
  14.     SPIx->DR = dataToSend;  /* Write data to buffer */
  15.    
  16.     /* Wait for transmission to complete */
  17.     while(CHECK_SPI_FREE(SPIx))
  18.    
  19.     /* Return receove data */
  20.     return SPIx->DR;
  21. }

Programowanie modułu:


Najpierw procedura uruchamiająca układ:

  1. void mfrc522_Initialization(void)
  2. {
  3.     mfrc522_InitCSPin();        /* Enable CS pin */
  4.     enableSPI4ForMfrc522();     /* Enable SPI4 */
  6.     mfrc522_Reset();    /* Reset device */
  8.     mfrc522_WriteRegister(MFRC522_TX_MODE_REGISTER, 0x00);      /* Define internal timer settings */
  9.     mfrc522_WriteRegister(MFRC522_RX_MODE_REGISTER, 0x00);      /* Lower 8 bits of TPrescaler value, 4 high bits are in tModeReg */
  10.     mfrc522_WriteRegister(MFRC522_MOD_WIDTH_REGISTER, 0x26);       
  11.    
  12.     mfrc522_WriteRegister(MFRC522_T_MODE_REGISTER, 0x80);       /* Define internal timer settings */
  13.     mfrc522_WriteRegister(MFRC522_T_PRESCALER_REGISTER, 0xA9);  /* Lower 8 bits of TPrescaler value, 4 high bits are in tModeReg */
  14.     mfrc522_WriteRegister(MFRC522_T_RELOAD_H_REGISTER, 0x03);   /* Define timer reload value */
  15.     mfrc522_WriteRegister(MFRC522_T_RELOAD_L_REGISTER, 0xE8);          
  17.     mfrc522_WriteRegister(MFRC522_RF_CFG_REGISTER, RF_CFG_GAIN_48dB);  /* Set maximum gain 48db */
  18.    
  19.     mfrc522_WriteRegister(MFRC522_TX_AUTO_REGISTER, 0x40);  /* ASK modulation */
  20.     mfrc522_WriteRegister(MFRC522_MODE_REGISTER, 0x3D);     /* Set the preset value for the CRC coprocessor */
  22.     mfrc522_AntenaOn();         /* Enable antenna pins */
  23. }

Tutaj na początku ustawiane są potrzebne piny w tym CS, następnie wpisywane są odpowiednie wartości do rejestrów. Na końcu uruchamiana jest antena.

Ustawienie pinu CS:

  1. static void mrfc522_InitCSPin(void)
  2. {
  3.     GPIO_InitTypeDef GPIO_InitStruct;
  4.    
  5.     RCC_AHB1PeriphClockCmd(MFRC522_CS_RCC, ENABLE);
  7.     GPIO_InitStruct.GPIO_Pin = MFRC522_CS_PIN;
  8.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  9.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
  10.     GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
  11.     GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
  13.     GPIO_Init(MFRC522_CS_PORT, &GPIO_InitStruct);  
  15.     MFRC522_CS_HIGH;                /* Set pin to High */
  16. }

Reset układu wygląda następująco:

  1. static void mrfc522_ClearRegisterBitMask(void)
  2. {
  3.     mfrc522_WriteRegister(MFRC522_COMMAND_REGISTER1, PCD_SOFTRESET);
  4.    
  5.     while(mfrc522_ReadRegister(MFRC522_COMMAND_REGISTER) & (1<<4))
  6.     {}
  7. }

Tutaj należy posłużyć się pewnym opóźnieniem. Ponieważ nie jest zdefiniowane ile czasu będzie trwało czyszczenie danych. Sprawdzanie następuje poprzez odczytanie bitu PowerDown z rejestru Command. Jeśli bit jest wyczyszczony to można przejść do dalszych operacji.

Teraz dwie funkcje odpowiedzialne za uruchomienie oraz wyłączenie pinów od anteny.

  1. static void mrfc522_AntenaOff(void)
  2. {
  3.     mfrc522_ClearRegisterBitMask(MFRC522_TX_CONTROL_REGISTER, 0x03);
  4. }
  6. static void mrfc522_AntenaOn(void)
  7. {
  8.     uint8_t val = mfrc522_ReadRegister(MFRC522_TX_CONTROL_REGISTER);
  9.    
  10.     if (!(val & 0x03))
  11.     {
  12.         mfrc522_SetRegisterBitMask(MFRC522_TX_CONTROL_REGISTER, 0x03);
  13.     }
  14. }

Kolejne dwie funkcje odpowiadają za programowe wyłączenie oraz uruchomienie układu:

  1. static void mrfc522_SoftPowerDown(void)
  2. {
  3.     uint8_t value = mfrc522_ReadRegister(MFRC522_COMMAND_REGISTER);
  4.     value |= (1<<4);    /* Set power down bit to 1 */
  5.    
  6.     mfrc522_WriteRegister(MFRC522_COMMAND_REGISTER, value);
  7. }
  9. static void mrfc522_SoftPowerUp(void)
  10. {
  11.     uint8_t value = mrfc522_ReadRegister(MFRC522_COMMAND_REGISTER);
  12.     value &= ~(1<<4);   /* clear power down bit */
  13.    
  14.     mfrc522_WriteRegister(MFRC522_COMMAND_REGISTER, value);
  16.     uint16_t timeout = 0;
  17.    
  18.     while(timeout <= 1000)
  19.     {
  20.         value = mfrc522_ReadRegister(MFRC522_COMMAND_REGISTER);
  21.         if(!(value & (1<<4)))   /* Check if wake up finished */
  22.         {
  23.             break;
  24.         }
  25.         timeout++;
  26.     }
  27. }

Teraz czas na dwie funkcje odpowiedzialne za komunikację. Jedna wysyła dane do układu, druga je odbiera.

  1. static void mrfc522_WriteRegister(uint8_t devAddress, uint8_t valueToWrite)
  2. {
  3.     MFRC522_CS_LOW;                                        
  4.    
  5.     spiSendData(MFRC522_SPI, (devAddress << 1) & 0x7E);
  6.     spiSendData(MFRC522_SPI, valueToWrite);
  7.    
  8.     MFRC522_CS_HIGH;           
  9. }
  11. static uint8_t mfrc522_ReadRegister(uint8_t devAddress)
  12. {
  13.     uint8_t value = 0;
  14.     MFRC522_CS_LOW;                                
  16.     spiSendData(MFRC522_SPI, ((devAddress << 1) & 0x7E) | 0x80);   
  17.     value = spiSendData(MFRC522_SPI, MFRC522_DUMMY);
  19.     MFRC522_CS_HIGH;                                   
  21.     return value;  
  22. }

Ustawienie oraz wyczyszczenie poszczególnych bitów w rejestrze:

  1. static void mrfc522_SetRegisterBitMask(uint8_t regToSet, uint8_t bitMask)
  2. {
  3.     uint8_t tmpDat = mfrc522_ReadRegister(regToSet);
  4.     mfrc522_WriteRegister(regToSet, tmpDat | bitMask);
  5. }
  7. static void mfrc522_ClearRegisterBitMask(uint8_t regToClear, uint8_t bitMask)
  8. {
  9.     uint8_t tmpDat = mfrc522_ReadRegister(regToClear);
  10.     mfrc522_WriteRegister(regToClear, tmpDat & (~bitMask));
  11. }

Ustawienie układu w stan wstrzymania, uśpienia:

  1. static void mfrc522_HaltA(void)
  2. {
  3.     uint16_t numBytesToWrite= 0;
  4.     uint8_t buff[4] = {0};
  5.     uint8_t operationStatus = 0;
  6.    
  7.     buff[0] = PICC_HALTA;
  8.     buff[1] = 0;
  9.    
  10.     operationStatus = mfrc522_CRC(buff, 2, &buff[2]);
  11.    
  12.     if(operationStatus != 0)
  13.     {
  14.         return; /* Error */
  15.     }
  16.    
  17.   operationStatus = mfrc522_TransmitData(PCD_TRANSCEIVE, buff, 4, buff, &numBytesToWrite);
  18.    
  19.     if(operationStatus != 0)
  20.     {
  21.         return; /* Error */
  22.     }
  23. }

Najpierw przygotowywana jest komenda, obliczenie CRC oraz sprawdzenie statusu operacji, następnie przesłanie danych.

Funkcja odpowiedzialna za przesyłanie komendy Request. Przygotowuje ona układ do przejście w stan gotowości. Przygotowuje go do odbierania ramek anty kolizji (anticollision) czy wyboru (select). Ta ostatnia wybiera rodzaj karty pomiędzy mifare classic a ultralight.

  1. static uint8_t mfrc522_Request(uint8_t requestPICC, uint8_t* cardNumberPoint)
  2. {
  3.     uint8_t operationStatus = 2;  
  4.     uint16_t retBits = 0;
  6.     mfrc522_WriteRegister(MFRC522_BIT_FRAMING_REGISTER, 0x07);
  8.     cardNumberPoint[0] = requestPICC;
  9.     operationStatus = mfrc522_TransmitData(PCD_TRANSCEIVE, cardNumberPoint, 1, cardNumberPoint, &retBits);
  11.     if ((operationStatus != 0) || (retBits != 0x10))
  12.     {    
  13.         operationStatus = 2;
  14.     }
  16.     return operationStatus;
  17. }

Teraz procedura przesłania danych do procedury antykolizji:

  1. static uint8_t mfrc522_Anticollision(uint8_t* serNum)
  2. {
  3.     uint8_t operationStatus = 2;
  4.     uint8_t loop = 0;
  5.     uint8_t serNumCheck = 0;
  6.     uint16_t unLen;
  8.     mfrc522_ClearRegisterBitMask(MFRC522_STATUS2_REGISTER, 0x08);
  9.     mfrc522_ClearRegisterBitMask(MFRC522_COLL_REGISTER,0x80);
  10.     mfrc522_WriteRegister(MFRC522_BIT_FRAMING_REGISTER, 0x00);
  12.     serNum[0] = PICC_ANTICOLLISION;
  13.     serNum[1] = 0x20;
  14.    
  15.     operationStatus = mfrc522_TransmitData(PCD_TRANSCEIVE, serNum, 2, serNum, &unLen);
  17.     if (operationStatus == 0)
  18.     {
  19.         serNumCheck = serNum[0] ^ serNum[1] ^ serNum[2] ^ serNum[3];
  20.     }
  21.    
  22.     if (serNumCheck != serNum[4])
  23.     {  
  24.         operationStatus = 2;    
  25.     }
  26.    
  27.     return operationStatus;
  28. }

Najpierw czyszczone są rejestry statusu oraz bit informujący o wystąpieniu kolizji. Dalej przesyłane są dane do układu z kodem antykolizji. Do wskaźnika podawanego do funkcji zostanie wprowadzony odczytany numer z karty Mifare. Po tym następuje sprawdzenie czy dane sprawdzane są różne od ostatniego bajtu danych. Jeśli tak to zgłaszany jest błąd.

Obliczenie CRC:

  1. static uint8_t mfrc522_CRC(uint8_t*  pointIntputData, uint8_t dataLength, uint8_t* pointOutputData)
  2. {
  3.     uint8_t count = 0;
  4.     uint8_t readedData = 0;
  5.    
  6.     mfrc522_WriteRegister(MFRC522_COMMAND_REGISTER1, PCD_IDLE);             //Stop then active command
  7.     mfrc522_ClearRegisterBitMask(MFRC522_DIV_IRQ_REGISTER, 0x04);           //Clear the CRC Interrupt tequest bit
  8.     mfrc522_SetRegisterBitMask(MFRC522_FIFO_LEVEL_REGISTER, 0x80);      //Fifo initialization
  10.     //Write data to the Fifo
  11.     for (count = 0; count < dataLength; count++) {  
  12.         mfrc522_WriteRegister(MFRC522_FIFO_DATA_REGISTER, *(pointIntputData+count));  
  13.     }
  14.    
  15.     mfrc522_WriteRegister(MFRC522_COMMAND_REGISTER1, PCD_CALCCRC);      //Start calculation
  17.     //Wait for CRC calculation to complete
  18.     count = 0x11FF;
  19.     do {
  20.         readedData = mfrc522_ReadRegister(MFRC522_DIV_IRQ_REGISTER);
  21.         count--;
  22.        
  23.         if(!(readedData&0x04))  //Check if bit CRCIRq is clear.
  24.         {
  25.                 mfrc522_WriteRegister(MFRC522_COMMAND_REGISTER, PCD_IDLE);  //Stop calculationg CRC
  26.                 //Transfer result to buffer
  27.                 pointOutputData[0] = mfrc522_ReadRegister(MFRC522_CRC_RESULT_L_REGISTER);
  28.                 pointOutputData[1] = mfrc522_ReadRegister(MFRC522_CRC_RESULT_M_REGISTER);
  29.                 return 0;
  30.         }
  31.     } while(count!=0);  //Works when CRCIRQ = 1
  32.    
  33.     return 2;
  34. }

Najpierw przesyłana jest komenda startu oraz aktywacji. Następnie czyszczony jest bit CRCIrq, który informuje o zakończeniu obliczania CRC. Kolejna komenda inicjalizuje stos FIFO. Dalej w pętli for wprowadzane są dane wejściowe, po niej następuje rozpoczęcie obliczania oraz oczekiwanie na wynik. Gdy bit CRCIrq zostanie wyczyszczony to następuje odczytanie danych i wpisanie ich do wskaźnika na dane wyjściowe.

Odczytanie danych z bloku:

  1. uint8_t mfrc522_Read(uint8_t blockAddr, uint8_t* receiveData, uint8_t bufferSize)
  2. {
  3.     uint8_t operationStatus = 2;
  4.     uint16_t retLength;
  6.     //Check pointer data
  7.     if(receiveData == NULL || bufferSize < 18)
  8.     {
  9.         return 1;
  10.     }
  11.    
  12.     //Build buffer
  13.     receiveData[0] = PICC_READ;
  14.     receiveData[1] = blockAddr;
  15.    
  16.     mfrc522_CRC(receiveData, 2, &receiveData[2]);
  17.    
  18.     //Send data
  19.     operationStatus = mfrc522_TransmitData(PCD_TRANSCEIVE, receiveData, 4, receiveData, &retLength);
  21.     //Check operation status
  22.     if ((operationStatus != 0) || (retLength != 0x90))
  23.     {
  24.         operationStatus = 2;
  25.     }
  27.     return operationStatus;
  28. }

Zapis danych do bloku:

  1. uint8_t mfrc522_Write(uint8_t blockAddr, uint8_t* writeData, uint8_t writeDataSize)
  2. {
  3.     uint8_t operationStatus = 2; //Default error
  4.     uint16_t receiveBits = 0;
  5.     uint8_t loop = 0;
  6.     uint8_t dataBuffer[18];
  8.     dataBuffer[0] = PICC_WRITE;
  9.     dataBuffer[1] = blockAddr;
  10.     mfrc522_CRC(dataBuffer, 2, &dataBuffer[2]);
  11.    
  12.     operationStatus = mfrc522_TransmitData(PCD_TRANSCEIVE, dataBuffer, 4, dataBuffer, &receiveBits);
  14.     if ((operationStatus != 0) ||
  15.             (receiveBits != 4) ||
  16.             ((dataBuffer[0] & 0x0F) != 0x0A))
  17.     {  
  18.         operationStatus = 2;  
  19.     }
  21.     if (operationStatus == 0)
  22.     {
  23.         //Data to the FIFO write 16Byte
  24.         for (loop = 0; loop < 16; loop++)
  25.         {
  26.             dataBuffer[loop] = *(writeData+loop);  
  27.         }
  28.         mfrc522_CRC(dataBuffer, 16, &dataBuffer[16]);
  29.         operationStatus = mfrc522_TransmitData(PCD_TRANSCEIVE, dataBuffer, 18, dataBuffer, &receiveBits);
  31.         if ((operationStatus != 0) ||
  32.                 (receiveBits != 4) ||
  33.                 ((dataBuffer[0] & 0x0F) != 0x0A))
  34.         {  
  35.             operationStatus = 2;  
  36.         }
  37.     }
  39.     return operationStatus;
  40. }

Zapis danych do bloku odbywa się poprzez wybranie komendy do wprowadzenia danych oraz adres bloku. Następnie obliczane jest CRC po którym następuje transmisja danych. Dalej sprawdzany jest status operacji oraz przesłanie całego bloku do zapisu.

Proces transmisji musi zakończyć się zwróceniem czterech bajtów ACK, dlatego sprawdzana jest ilość bajtów przed ustawieniem statusu operacji.

Kolejna funkcja służy do uwierzytelnienia transmisji przez podanie odpowiedniego klucza dostępu do określonego bloku danych:

  1. uint8_t mfrc522_Authentication( uint8_t command, uint8_t blockAddr, uint8_t* sectorKey, uint8_t* serialNumber)
  2. {
  3.     uint8_t operationStatus = 0;
  4.     uint16_t receiveData = 0;
  5.     uint8_t loop = 0;
  6.     uint8_t dataBuffer[12] = {0};
  8.     dataBuffer[0] = command;
  9.     dataBuffer[1] = blockAddr;
  10.    
  11.     //6 bytes key
  12.     for (loop = 0; loop < 6; loop++)
  13.     {    
  14.         dataBuffer[loop+2] = *(sectorKey+loop);  
  15.     }
  16.    
  17.     //4 bytes uid
  18.     for (loop=0; loop<4; loop++)
  19.     {    
  20.         dataBuffer[loop+8] = *(serialNumber+loop);  
  21.     }
  22.    
  23.     operationStatus = mfrc522_TransmitData(PCD_AUTHENT, dataBuffer, 12, dataBuffer, &receiveData);
  25.     //Check status
  26.     if ((operationStatus != 0) ||
  27.             (!(mfrc522_ReadRegister(MFRC522_STATUS2_REGISTER) & 0x08)))
  28.     {  
  29.         operationStatus = 2;  
  30.     }
  32.     return operationStatus;
  33. }

Najpierw przygotowanie komendy. Można podawać jako parametr dwie komendy jedna to PICC_AUTHENTICATION_KEY_A druga to PICC_AUTHENTICATION_KEY_B. Następnie do bufora wprowadzany jest klucz dostępu (6 bajtów), oraz UID 4 bajty. Dalej przygotowana ramka zostaje przesłana i sprawdzany jest status odbioru.

Następna funkcja dokonuje sprawdzenia czy została przyłożona karta do układu:

  1. uint8_t mfrc522_Check(uint8_t* cardNumberPointer)
  2. {
  3.     uint8_t operationStatus = 2;    //By default write 2 as error
  4.    
  5.     mfrc522_AntenaOn();     //Turn on antenna pins
  7.     operationStatus = mfrc522_Request(PICC_REQ_IDLE_STATE_REQA, cardNumberPointer); //Find cards, return card type
  8.    
  9.     if (operationStatus == 0)       //If there is a card
  10.     {
  11.         operationStatus = mfrc522_Anticollision(cardNumberPointer);//Get card number
  12.     }
  13.     mfrc522_HaltA();    //Command card into hibernation
  14.     mfrc522_AntenaOff();//Turn off antena
  15.    
  16.     return operationStatus;
  17. }

W funkcji powyżej najpierw następuje włączenie anteny, dalej przesyłana jest komenda REQUEST typ A. Ma ona za zadanie zmianę stanu z IDLE na READY oraz przygotowanie układu na komendę ANTICOLLISION. Po sprawdzeniu czy karta została odczytana przesyłana jest komenda HALT. Ostatnim krokiem jest wyłączenie pinów od anteny.

Funkcja przesłania danych do układu:

  1. static uint8_t mfrc522_TransmitDataToFifo(uint8_t commandToExecute, uint8_t* dataToSendPoint, uint8_t sendDataLength,
  2.                                                                                     uint8_t* returnDataPoint, uint16_t* returnDataLenPoint)
  3. {
  4.     uint8_t operationStatus = 2;
  5.     uint8_t interruptStatus = 0x00;
  6.     uint8_t interruptWait = 0x00;
  7.     uint8_t transmitLastBits = 0;
  8.     uint8_t readedData = 0;
  9.     uint16_t loop = 0;
  11.     switch (commandToExecute)
  12.     {
  13.         case PCD_AUTHENT:
  14.         {
  15.             interruptStatus = 0x12;
  16.             interruptWait = 0x10;
  17.             break;
  18.         }
  19.         case PCD_TRANSCEIVE:
  20.         {
  21.             interruptStatus = 0x77;
  22.             interruptWait = 0x30;
  23.             break;
  24.         }
  25.         default:
  26.         {
  27.             operationStatus = 2;
  28.             return operationStatus;
  29.         }
  30.     }
  31.    
  32.     mfrc522_WriteRegister(MFRC522_COMMAND_REGISTER, interruptStatus | 0x80);        //Allow interrupt request
  33.     mfrc522_ClearRegisterBitMask(MFRC522_COMM_IRQ_REGISTER, 0x80);                          //Clear interrupt request bit
  34.     mfrc522_SetRegisterBitMask(MFRC522_FIFO_LEVEL_REGISTER, 0x80);                          //Initialize fifo
  36.     mfrc522_WriteRegister(MFRC522_COMMAND_REGISTER1, PCD_IDLE);
  37.    
  38.     for (loop = 0; loop < sendDataLength; loop++)                                                           //Write DataToFifo
  39.     {  
  40.         mfrc522_WriteRegister(MFRC522_FIFO_DATA_REGISTER, dataToSendPoint[loop]);    
  41.     }
  43.     mfrc522_WriteRegister(MFRC522_COMMAND_REGISTER1, commandToExecute);
  44.    
  45.     if (commandToExecute == PCD_TRANSCEIVE)
  46.     {    
  47.         mfrc522_SetRegisterBitMask(MFRC522_BIT_FRAMING_REGISTER, 0x80);     //StartSend = 1,transmission of data starts  
  48.     }  
  49.    
  50.     loop = 4000;
  51.     do
  52.     {
  53.         readedData = mfrc522_ReadRegister(MFRC522_COMM_IRQ_REGISTER);
  54.         loop--;
  55.     } while ((loop != 0) && !(readedData & 0x01) && !(readedData & interruptWait));
  56.    
  57.     if (loop != 0)  
  58.     {
  59.         uint8_t readStatus = mfrc522_ReadRegister(MFRC522_ERROR_REGISTER);          //Check if there is any error
  60.        
  61.         if (!(readStatus & 0x1B))
  62.         {
  63.             operationStatus = 0;
  64.        
  65.             if (commandToExecute == PCD_TRANSCEIVE)
  66.             {
  67.                 readedData = mfrc522_ReadRegister(MFRC522_FIFO_LEVEL_REGISTER);
  68.                 transmitLastBits = mfrc522_ReadRegister(MFRC522_CONTROL_REGISTER) & 0x07;
  69.                
  70.                 if (transmitLastBits)
  71.                 {  
  72.                     *returnDataLenPoint = transmitLastBits + ((readedData - 1) * 8);  
  73.                 }
  74.                 else
  75.                 {  
  76.                     *returnDataLenPoint = (readedData * 8);  
  77.                 }
  79.                 if (readedData == 0)
  80.                 {  
  81.                     readedData = 1;    
  82.                 }
  83.                
  84.                 if (readedData > MFRC522_MAX_LEN)
  85.                 {  
  86.                     readedData = MFRC522_MAX_LEN;  
  87.                 }
  89.                 //Reading the received data in FIFO
  90.                 for (loop = 0; loop < readedData; loop++)
  91.                 {  
  92.                     returnDataPoint[loop] = mfrc522_ReadRegister(MFRC522_FIFO_DATA_REGISTER);    
  93.                 }
  94.             }
  95.         }
  96.         else
  97.         {          
  98.             operationStatus = 2;  
  99.         }
  100.     }
  101.     return operationStatus;
  102. }

Funkcja powyżej ma za zadanie dodanie przesyłanych danych do kolejki FIFO układu. Najpierw rozpoczyna się od uruchomienia przerwań, oraz iniciajlizacji FIFO. Następnie wpisuje się dane do rejestru. Dalsza część dotyczy sprawdzenia przeprowadzonych operacji.

Przygotowałem dwa programy testowe. Pierwsza z nich odczytuje numer zapisany na karcie:

  1. void mfrc522_Process_CardNumberOnly(void)
  2. {
  3.     /* Recognized card ID */
  4.     uint8_t cardNumber[5];
  5.     char buffer[30] = {0};
  6.    
  7.     if (mfrc522_CheckIfCardPresent(cardNumber) == 0)
  8.     {
  9.         Prep_Font_DrawString(10,10,(uint8_t*)"Card detected", &Arial_7x10,RGB_COL_WHITE,RGB_COL_RED);
  10.         sprintf(buffer, "0x%02x\n0x%02x\n0x%02x\n0x%02x\n0x%02x", cardNumber[0], cardNumber[1], cardNumber[2], cardNumber[3], cardNumber[4]);
  11.         Prep_Font_DrawString(10,20,(uint8_t*)buffer, &Arial_7x10, RGB_COL_WHITE,RGB_COL_RED);
  12.     }
  13. }

Druga funkcja testowa odczytuje parametry zapisane na karcie, następnie programuje jeden z sektorów po czym odczytuje zaprogramowane dane:

  1. void mfrc522_Process(void)
  2. {
  3.     uint8_t operationStatus;
  4.     uint8_t receiveDataBuffer[50] = {0};
  5.     uint8_t cardSize = 0;
  6.     uint8_t blockAddr = 0;
  7.     char displayBuffer[50] = {0};
  8.     uint8_t serialNumber[5] = {0};
  9.    
  10.     //Search for a card in a field
  11.     operationStatus = mfrc522_Request(PICC_REQ_IDLE_STATE_REQA, receiveDataBuffer);
  12.    
  13.     if (operationStatus == 0) /* Success */
  14.     {
  15.         sprintf(displayBuffer, "Card found: 0x%x, 0x%x", receiveDataBuffer[0], receiveDataBuffer[1]);
  16.         Prep_Font_DrawString(10,10,(uint8_t*)displayBuffer,&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  17.     }
  18.     else
  19.     {
  20.         return;
  21.     }
  23.     // Anti-collision, return the card's 4-byte serial number
  24.     operationStatus = mfrc522_Anticollision(receiveDataBuffer);
  25.    
  26.     memcpy(serialNumber, receiveDataBuffer, 5);
  27.    
  28.     if (operationStatus == 0)  /* Success */
  29.     {
  30.         sprintf(displayBuffer, "Card Number: %x%x%x%x", serialNumber[0],serialNumber[1],serialNumber[2],serialNumber[3]);
  31.         Prep_Font_DrawString(10,20,(uint8_t*)displayBuffer,&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  32.     }
  33.     else
  34.     {
  35.         Prep_Font_DrawString(10,20,(uint8_t*)"Card size Error",&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  36.         return;
  37.     }
  39.     // Election card, return capacity
  40.     cardSize = mfrc522_SelectTag_CascadeLevel1(serialNumber);
  41.    
  42.     if (cardSize != 0)
  43.     {
  44.         sprintf(displayBuffer, "Card size: %d Kbits", cardSize);
  45.         Prep_Font_DrawString(10,30,(uint8_t*)displayBuffer,&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  46.     }
  47.     else
  48.     {
  49.         Prep_Font_DrawString(10,30,(uint8_t*)"Card size Error",&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  50.         return;
  51.     }
  53.     blockAddr = 6;
  54.     operationStatus = mfrc522_Authentication(PICC_AUTHENTICATION_KEY_A, blockAddr, key, serialNumber);// Authentication
  55.    
  56.     if (operationStatus == 0)  /* Success */
  57.     {
  58.         // Write data
  59.         operationStatus = mfrc522_Write(blockAddr, writeData);
  60.        
  61.         if(operationStatus != 0)
  62.         {
  63.             Prep_Font_DrawString(10,110,(uint8_t*)"Write 1 Error",&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  64.             return;
  65.         }
  66.         else
  67.         {
  68.             Prep_Font_DrawString(10,120,(uint8_t*)"Write 1 OK",&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  69.         }
  70.     }
  71.     else
  72.     {
  73.         Prep_Font_DrawString(10,130,(uint8_t*)"Authentication Error",&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  74.         return;
  75.     }
  76.    
  77.     blockAddr = 6;
  78.     operationStatus = mfrc522_Authentication(PICC_AUTHENTICATION_KEY_A, blockAddr, key, serialNumber);
  79.    
  80.     if (operationStatus == 0)  /* Success */
  81.     {
  82.         // Read data
  83.         blockAddr = 6;
  84.         operationStatus = mfrc522_Read(blockAddr, receiveDataBuffer, sizeof(receiveDataBuffer)/sizeof(receiveDataBuffer[0]));
  85.        
  86.         if (operationStatus == 0)
  87.         {
  88.                 Prep_Font_DrawString(10,140,(uint8_t*)"Read Ok",&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  89.                
  90.                 sprintf(displayBuffer, "[0]%d; [1]%d; [2]%d", receiveDataBuffer[0], receiveDataBuffer[1], receiveDataBuffer[2]);
  91.                 Prep_Font_DrawString(10,155,(uint8_t*)displayBuffer,&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  92.                
  93.                 sprintf(displayBuffer, "[3]%d; [4]%d;", receiveDataBuffer[3], receiveDataBuffer[4]);
  94.                 Prep_Font_DrawString(10,170,(uint8_t*)displayBuffer,&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  95.            
  96.                 sprintf(displayBuffer, "[5]%d; [6]%d; [7]%d", receiveDataBuffer[5], receiveDataBuffer[6], receiveDataBuffer[7]);
  97.                 Prep_Font_DrawString(10,185, (uint8_t*)displayBuffer,&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  98.            
  99.                 sprintf(displayBuffer, "[8]%d; [9]%d; [10]%d;", receiveDataBuffer[8], receiveDataBuffer[9], receiveDataBuffer[10]);
  100.                 Prep_Font_DrawString(10,200,(uint8_t*)displayBuffer,&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  101.                
  102.                 sprintf(displayBuffer, "[11]%d; [12]%d; [13]%d;", receiveDataBuffer[11], receiveDataBuffer[12], receiveDataBuffer[13]);
  103.                 Prep_Font_DrawString(10,215,(uint8_t*)displayBuffer,&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  104.            
  105.                 sprintf(displayBuffer, "[14]%d; [15]%d;", receiveDataBuffer[14], receiveDataBuffer[15]);
  106.                 Prep_Font_DrawString(10,230,(uint8_t*)displayBuffer,&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  107.         }
  108.         else
  109.         {      
  110.             Prep_Font_DrawString(10,150,(uint8_t*)"Read Error",&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  111.             return;
  112.         }
  113.     }
  114.     else
  115.     {
  116.         Prep_Font_DrawString(10,140,(uint8_t*)"Authentication 2 Error",&Arial_7x10,RGB_COL_BLACK,RGB_COL_GREEN);
  117.         return;
  118.     }
  119.     mfrc522_HaltA();
  120. }

Najpierw wysyłana jest komenda Request. W przypadku powodzenia zwraca parametry karty. Dla Mifare Classic 1k wartość ta wynosi 0x04. Dalej przesyłana jest komenda Anticollision, która przesyła odczytany numer seryjny karty. Następnie wybierana jest karta i odczytywany jest jej rozmiar. Kolejnym krokiem jest proces uwierzytelniania przez podanie hasła, po czym rozpoczyna się zapis danych do określonego bloku. Przed odczytem zapisanych danych należy przeprowadzić ponownie proces uwierzytelniania. Po nim następuje odczytanie danych. Gdy ta operacja się powiedzie to nastąpi wyświetlenie danych na ekranie.

Główna pętla programu wygląda następująco:

  1. int main(void)
  2. {
  3.   SystemInit();
  5.   Tft_Display_Initialization();
  6.   Tft_Layer_FullScreenMode();
  7.   Tft_SetLayer_1();
  8.   Tft_FillLayer(RGB_COL_WHITE);
  9.   Tft_SetLayer_2();
  10.   Tft_FillLayer(RGB_COL_GREEN);
  11.    
  12.   mfrc522_Initialization();
  14.   while(1)
  15.   {
  16.         //mfrc522_Process_CardNumberOnly();
  17.         mfrc522_Process();
  18.   }
  19. }

Cały projekt można pobrać z dysku Google pod tym linkiem.
Autor: o
Etykiety: ,