[5] ESP32 - PN532

Ten post chciałbym poświęcić na przygotowanie programu odpowiedzialnego za czytanie kart mifare. Takim układem będzie PN532. Komunikacja z nim zostanie przeprowadzona za pomocą UART-u.

[Źródło: www.banggood.com]

Układ PN532:

Pozwala na odczytywanie i zapisywanie kart typu Mifare. Komunikacja możliwa jest poprzez interfejs i2c, spi bądź opisywany w tym poście UART. Ostatni z nich jest dosyć prosty w obsłudze, jednak trzeba pamiętać o odpowiedniej kolejności komend. Zła kolejność bądź niedokładność w przesyłaniu danych może powodować brak komunikacji bądź zawieszenie układu PN532.

Ten post będzie zawierał opcje dotyczącą odczytu kart Mifare. Zapis kart polega na wysłaniu odpowiedniej komendy z blokiem.

Struktura ramki danych, podstawowa, wygląda następująco:

0x00 0x00 0xFF LEN LCS TFI PD0 PD1 .... PDn DCS 0x00

Idąc od początku najpierw wysyłana jest 1 bajt zwany PREAMBLE (0x00) po czym przesyłane są dwa bajty oznaczające kod startu (0x00 0xFF). Następnie podana jest ilość przesyłanych bajtów (LEN) od TFI do PDn. Dalej wysyłana jest suma kontrolna liczona z zależności LEN + LCS = 0x00. Kolejny bajt czyli (TFI) oznacza kod komendy bądź kod odpowiedzi. Ten drugi jest kodem komendy powiększonym o jeden. Po nim przesyłane są informacje o długości LEN - 1. Przedostatni bajt jest to druga suma kontrolna liczona z zależności TFI + PD0 + ... + PDn = 0x00. Ostatnim bajtem jest informacja o zakończeniu transmisji czyli POSTAMBLE (0x00). 

Maksymalnie można wysłać 265 bajtów wliczając w to kod komendy. 

Funkcje do obsługi UARTu zostały opisane w jednym z poprzednich postów.

Programowanie:

Główna funkcja komunikująca się z modułem PN532 została przygotowana w oparciu o zadanie z USARTu drugiego.

1. void uart1Task(void)
2. {
3.     const int uart1_num = UART_NUM_1;
4.     Uart1_Init(uart1_num, 115200);
6.     uint8_t *uart1Buffer = (uint8_t*)malloc(BUFFER_SIZE);
7.    
8.     while(1){
9.         int len1 = uart_read_bytes(uart1_num, uart1Buffer, BUFFER_SIZE, 80 / portTICK_RATE_MS);
10.         uart_write_bytes(1, (const char*)uart1Buffer, len1);
11.     }  
12. }  
13. void uart2Task(void)
14. {
15.     static uint8_t PN532_Status = 1;
16.     const int uart2_num = UART_NUM_2;
17.     uint8_t checkStat = 0;
19.     Uart2_Init(uart2_num, 115200);
20.     uint8_t *uart2Buffer = (uint8_t*)malloc(BUFFER_SIZE);
22.     Uart_Send_Data(UART_NUM_1, (uint8_t*)"PN532 Program\r\n");
24.     /* PN532 Initialization */
25.     PN532Initialization();
26.     vTaskDelay(500);
27.     while(1)
28.     {
29.         int len2 = uart_read_bytes(uart2_num, uart2Buffer, BUFFER_SIZE, 80 / portTICK_RATE_MS);
30.         /* Put received buffer to uart 1 */
31.         //uart_write_bytes(1, (const char*)uart2Buffer, len2);
33.         /* Check status, implementation needed when device hang */
34.         checkStat = PN532CheckReceiveBuffer(uart2Buffer, len2, 1000, PN532_Status);
35.         if(checkStat == PN532_STAT_ERROR)
36.         {
37.             PN532_Status = 1;
38.             PN532Initialization();
39.             vTaskDelay(500);
40.         }
42.         if(checkStat == PN532_STAT_OK)
43.         {
44.             if(PN532_Status == 1)
45.             {
46.                 Uart_Send_Data(UART_NUM_1, (uint8_t*)"Initialization OK\r\n");
47.                 /* If initialization OK then change status to read mifare cards */
48.                 PN532_Status = 2;
49.             }
50.         }
51.        
52.         vTaskDelay(100);
53.        
54.         if(PN532_Status == 2)
55.         {
56.             PN532ReadCardPoll();
57.             vTaskDelay(100);
58.         }
60.         /* Clear buffer */
61.         for(uint16_t loop = 0; loop<BUFFER_SIZE; loop++)
62.         {
63.             uart2Buffer[loop] = 0;
64.         }
65.     }
66. }
68. void app_main(void)
69. {
70.     nvs_flash_init();
71.     xTaskCreate(uart1Task, "uart_uart1Task", 1024, NULL, 10, NULL);
72.     xTaskCreate(uart2Task, "uart_uart2Task", 1024, NULL, 10, NULL);
73. }

Na samym początku funkcja uruchamia UART po czym wysyłane są rozkazy inicjalizujące do modułu PN532 w celu sprawdzenia połączenia. Jeśli się ono powiodło to następuje wysłanie danych do odbioru numeru karty. W przeciwnym przypadku wysyłane są podstawowe komendy do układu do momentu uzyskania połączenia.

Część instrukcji sprawdza czy wystąpił błąd podczas odbierania ramki danych. W takim wypadku układ ulega zawieszeniu i nie otrzymuje się poprawnych ramek. Nie ma możliwości odczytu karty bez ponownego resetu. Dlatego dodałem jedną pętlę sprawdzającą tą sytuacje. Jeśli ona wystąpi następuje ponowna inicjalizacja układu a po niej ponowne sprawdzenie otrzymanego bufora.

Procedura uruchomienia układu wygląda następująco:

1. void PN532Initialization(void)
2. {
3.     uint8_t sendFrame[] = { 0x02, 0x00 };
5.     PN532_ClearDataToSendBuffer();  /* Clear buffer with data */
6.     PN532_ACKCommand();             /* Send ACK */
7.     PN532_WakeCommand();            /* Send wake frame */
9.     vTaskDelay(20);
11.     PN532_ACKCommand();     /* Send ACK */
12.     PN532_CommandFrame(pn532_DataToSendBuffer, sendFrame, 2);   /* Send Command frame */
13. }

Ważne jest wysyłanie dodatkowych komend ACK. Układ PN532 może wysyłać ramki danych zawierające wcześniejsze informacje z komend. Przesłanie ACK powoduje wyczyszczenie bufora z danymi znajdującego się w układzie. Dzięki temu ramka danych będzie wysyłana bez przesunięcia.

Sprawdzenie poprawności odebranych danych:

1. PN532_Status_t PN532CheckReceiveBuffer(uint8_t * rxPassBuffer, int bufferLength, uint8_t status)
2. {
3.     uint8_t responseFrame[] = {PN532_PN532TOHOST, 0x02 + 1};
4.     uint8_t checkStat = 0; 
6.     if(status == 1)
7.     {
8.         if(PN532_CmdAcknowledge(rxPassBuffer) != PN532_STAT_OK)
9.         {
10.             return PN532_STAT_ERROR;
11.         }
12.         if(PN532_SearchForFrame(rxPassBuffer, responseFrame, 2) == 0xFF)
13.         {
14.            return PN532_STAT_ERROR;
15.         }
16.     }
17.     /* Initialization went ok, check card number data */
18.     else if(status == 2)
19.     {
20.         checkStat = PN532_CheckReadMifare(rxPassBuffer, bufferLength);
21.         if(checkStat == MIFARE_STAT_OK)
22.         {
23.             PN532_GetReceiveCardNumber(rxPassBuffer, bufferLength);
24.         }
25.         else if(checkStat == MIFARE_STAT_ERROR)
26.         {
27.             return PN532_STAT_ERROR;
28.         }
29.     }
30.     return PN532_STAT_OK;
31. }

Pierwsza część dotyczy sprawdzenia danych dla procesu uruchomienia układu. Druga część bloku sprawdzenia odebranych danych z numeru karty.

1. static Mifare_Status_t PN532_CheckReadMifare(uint8_t * rxDataBuffer, uint16_t bufferLength)
2. {
3.     volatile uint8_t len = 0;
4.     uint8_t dataTable[255] = {0};
6.     if(PN532_InAutoPoll(dataTable, rxDataBuffer, bufferLength) != PN532_STAT_OK)
7.     {
8.         return MIFARE_STAT_ERROR; /* */
9.     }
11.     if(*dataTable == 0x00)
12.     {
13.         return MIFARE_STAT_NOCARD; /* No card in field */
14.     }
15.     else if(*dataTable == 0x01)
16.     {
17.         /* Check whether Mifare card is detected */
18.         if( *(dataTable+1) != 0x10 )
19.         {
20.             return MIFARE_STAT_OTHER_CARD;
21.         }
23.         len = *(dataTable+7) + 1;
24.        
25.         if(len > bufferLength)
26.         {
27.             len = bufferLength;
28.         }
30.         for(uint8_t i=0; i<len; i++)
31.         {
32.             *(rxDataBuffer + i) = *(dataTable + 7 + i);
33.         }
34.     }
35.     else if(*dataTable == 0x02)
36.     {
37.         if(*(dataTable+1) == 0x10)
38.         {
39.             len = *(dataTable+7)+1;
40.            
41.             if(len > bufferLength)
42.             {
43.                 len = bufferLength;
44.             }
45.            
47.             for(uint8_t i=0; i<len; i++)
48.             {
49.                 *(rxDataBuffer + i) = *(dataTable + 7 + i);
51.                 if((*(dataTable+7) + 1) > bufferLength)
52.                 {
53.                     return MIFARE_STAT_OK; /* Stat Ok */
54.                 }
55.             }
57.             if(*(dataTable + 3 + *(dataTable+2)) == 0x10)
58.             {
59.                 uint8_t lenExt = *(dataTable + 7  + *(dataTable+2)) + 1;
60.                
61.                 if(len > (bufferLength - len))
62.                 {
63.                      lenExt=(bufferLength - len);
64.                 }
65.                
66.                 for(uint8_t i=len; i<(len+lenExt); i++)
67.                 {
68.                     *(rxDataBuffer + i) = *(dataTable + 9  + *(dataTable+2) + i - 5);
69.                 }
70.             }
71.         }
72.     }
74.     return MIFARE_STAT_OK; /* Stat Ok */
75. }

Wyciągnięcie numeru karty:

1. static uint8_t PN532_GetReceiveCardNumber(uint8_t *buffer, uint16_t length)
2. {
3.     uint32_t decodeCardNumber = 0;
4.     static uint32_t prevCardNumber = 0;
5.     char dataBuffer[40] = {0};
6.     if(*(buffer) == 0x04)
7.     {
8.         decodeCardNumber = *(buffer + 3);
9.         decodeCardNumber = (decodeCardNumber << 8) + *(buffer + 2);
10.         decodeCardNumber = (decodeCardNumber << 8) + *(buffer + 1);
12.         if(prevCardNumber != decodeCardNumber)
13.         {
14.             prevCardNumber = decodeCardNumber;
15.             sprintf(dataBuffer, "Nr K:%u\r\n", decodeCardNumber);
16.             Uart_Send_Data(1, (uint8_t*)&dataBuffer);
17.         }
18.     }
19.     return 1;
20. }

Numer karty jest wyciągany z bufora po czym jest on zamieniany na zmienną 32 bitową. Następuje sprawdzenie czy jest on inny od poprzednio odczytanego numeru. Jeśli tak to porównywany jest numer z poprzednio przyłożoną kartą. W tym przypadku karty należy przykładać na przemian. Nie może wystąpić ciągłe przyłożenie. Aby było możliwe przykładanie jednej karty należy uruchomić licznik i co określony interwał czasowy np 1-2 sekundy czyści bufor z poprzedniego odczytu. Pozwoli to na blokowanie spamowania odczytanym numer oraz będzie można jedną kartę odczytać ciągle po przyłożeniu.

Kolejna z wykorzystywanych funkcji odpowiada za przeszukiwanie odebranego bufora danych w poszukiwaniu ramki danych:

1. static uint8_t PN532_SearchForFrame(uint8_t * dataBuffer, uint8_t *dataFrame, uint16_t dataFrameLength)
2. {
3.     uint8_t *ptr = dataBuffer;
5.     for(int i = 0; i<(PN532_MAX_FRAME_LENGTH - dataFrameLength); i++)
6.     {
7.         if(memcmp(ptr,dataFrame,dataFrameLength * sizeof(uint8_t)) == 0){
8.             return i;
9.         }
10.         p++;
11.     }
12.     return 0xFF;
13. }

Do funkcji podawana jest odebrana ramka danych, szukana ramka oraz ilość danych jakie należy sprawdzić.

Komenda ACK wysyłana jest po przez użycie następującej komendy:

1. static void PN532_ACKCommand(void)
2. {
3.     Uart_SendArray(PN532_UART_PORT, (uint8_t*)&pn532_frame_ACK, 6);
4. }

Wybudzenie układu dokonuje się poprzez przesłanie komendy wybudzającej:

1. static void PN532_WakeCommand(void)
2. {
3.     uint8_t pn532_frame_WAKE[]  = { 0x55, 0x55, 0x00, 0x00, 0x00,
4.                                     0x00, 0x00, 0x00, 0x00, 0x00,
5.                                     0x00, 0x00, 0x00, 0x00, 0x00,
6.                                     0x00, 0x00, 0xff, 0x03, 0xfd,
7.                                     0xd4, 0x14, 0x01, 0x17, 0x00  };
9.     Uart_SendArray(PN532_UART_PORT, (uint8_t*)&pn532_frame_WAKE, 24);
10. }

Wysłanie komendy przygotowanej wcześniej wygląda następująco:

1. static void PN532_CommandFrame(uint8_t *buffer, uint8_t * cmd, uint8_t cmdlen)
2. {
3.     uint16_t checksum = 0;
4.     uint8_t len = 8;
6.     PN532_ClearDataToSendBuffer();
8.     pn532_DataToSendBuffer[0] = PN532_PREAMBLE;
9.     pn532_DataToSendBuffer[1] = PN532_STARTCODE1;
10.     pn532_DataToSendBuffer[2] = PN532_STARTCODE2;
11.     pn532_DataToSendBuffer[3] = cmdlen + 1;
12.     pn532_DataToSendBuffer[4] = ~cmdlen;
13.     pn532_DataToSendBuffer[5] = PN532_TOPN532;
14.     checksum += PN532_TOPN532;
16.     for(uint8_t i = 6; i < (6 + cmdlen); i++){
17.         pn532_DataToSendBuffer[i] = (*cmd);
18.         checksum += (*cmd);
19.         cmd++;
20.     }
22.     len += cmdlen;
24.     pn532_DataToSendBuffer[6+cmdlen] = (~checksum+1);
25.     pn532_DataToSendBuffer[6+cmdlen+1] = PN532_POSTAMBLE;
27.     Uart_SendArray(PN532_UART_PORT, (uint8_t*)&pn532_DataToSendBuffer, len);
28. }

W funkcji powyżej przygotowywana jest ramka danych do przesłania. Wprowadzana jest ona do podanego bufora. Ostania linijka przekazuje wskaźnik do tablicy do przesłania.

Sprawdzenie wersji oprogramowania odpowiedzialne jest poprzez funkcje:

1. static void PN532_GetFirmware(void)
2. {
3.     uint8_t pn532_frame_FIRMWARE[] = { 0x00, 0x00, 0xFF, 0x02, 0xFE, 0xD4, 0x02, 0x2A, 0x00 };
5.     Uart_SendArray(PN532_UART_PORT, pn532_frame_FIRMWARE, 9);
6. }

Przesyła ona odpowiedni rozkaz do układu.

Odczytanie karty może być wykonane w oparciu o dwa rozkazy. Pierwszy z nich pozwala na proste odczytanie. Czyli przesyłany jest rozkaz podania numeru karty, jeśli karta jest w polu to przesyłana jest odpowiedź:

1. static void PN532SimpleCardRead(void)
2. {
3.     uint8_t pn532_frame_GETTAG[11] =    { 0x00, 0x00, 0xFF, 0x04, 0xFC, 0xD4,
4.                                           0x4A, 0x01, 0x00, 0xE1, 0x00};
6.     PN532_ACKCommand();
7.     Uart_SendArray(PN532_UART_PORT, pn532_frame_GETTAG, 11);
8. }

Przesyłana komenda (InListPassiveTarget) odczytuje znajdujące się w polu tagi. Format komendy wygląda następująco:

• [00]: 0x00
• [01]: 0x00
• [02]: 0xFF
• [03]: 0x04
• [04]: 0xFC
• [05]: 0xD4
• [06]: 0x4A - kod komendy
• [07]: 0x01 - maksymalna liczba tagów znajdujących się w polu. PN532 może obsłużyć maksymalnie dwa układy
• [08]: 0x00 - określa prędkość transmisji oraz typ modulacji. Przy wpisaniu 0x00 wybrany jest 106 kbps type A (ISO/IEC14443 Type A);
• [09]: 0xE1 - są to dane odpowiedzialne za inicjalizacje czytnika do odczytu. Wartość tego pola jest dostosowana do podanych wartości prędkości transmisji, trybu odczytu itp. 
• [10]: 0x00 - zakończenie transmisji

Jeśli znajdują się dane w polu to układ odeśle następujące informacje:

• [00]: 0x00
• [01]: 0x00
• [02]: 0xFF
• [03]: 0x0C
• [04]: 0xF4
• [05]: 0xD5
• [06]: 0x4B - kod komendy powiększony o 1;
• [07]: 0x01 - numer odczytanego układu;
• [08]: 0x01 - SENS_RES;
• [09]: 0x00 - SENS_RES;
• [10]: 0x04 - SEL_RES;
• [11]: 0x08 - NFCIDLength; 
• [12]: 0x04 - ilość danych dla numery karty;
• [13]: 0xXX - numer karty;
• [14]: 0xXX - numer karty;
• [15]: 0xXX - numer karty;
• [16]: 0xXX - numer karty;
• [17]: 0x00 - zakończenie transmisji;

Gdy nie ma danych zostanie odesłany kod ACK (0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00) W przypadku błędnego odczytu zostanie przesłana ramka NACK (0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00);

Druga funkcja zawiera obsługę komendy InAutoPoll. Służy ona do odczytu kart o podanym formacie. Jest ona głównie wykorzystywana w programie w pętli:

1. static PN532_Status_t PN532_InAutoPoll(uint8_t *writeDataBuffer, uint8_t *receiveBuffer, uint16_t bufferLen)
2. {
3.     uint8_t Frame[2] = { PN532_PN532TOHOST, PN532_COMMAND_INAUTOPOLL + 1 };
4.     uint8_t endFrame[5] = {0x00, 0xFF, 0x00, 0xFF, 0x00};
6.     /* wait for ack frame */
7.     if(PN532_CmdAcknowledge(receiveBuffer) != PN532_STAT_OK)
8.     {
9.         return PN532_STAT_ERROR;
10.     }
12.     /* Check if there is proper response frame */
13.     if(PN532_SearchForFrame(receiveBuffer, Frame, 2) == 0xFF)
14.     {
15.         return PN532_STAT_ERROR;
16.     }
18.     /* wait for end of transmission */
19.     if(PN532_SearchForFrame(receiveBuffer, endFrame, 5) == 0xFF)
20.     {
21.         return PN532_STAT_ERROR;
22.     }
23.     PN532_ACKCommand();
25.     uint8_t pos = PN532_SearchForFrame(receiveBuffer, Frame, 2);
26.     uint16_t len = *(buffer + pos - 2);
28.     for(uint8_t i = 2; i<len; i++)
29.     {
30.         *(writeDataBuffer + i - 2) = *(receiveBuffer + pos + i);
31.     }
33.     return PN532_STAT_OK;
34. }

Bibliografia:

PN532 - Datasheet;