[31] STM32F7 - Czytnik linii papilarnych TFSD400

Ten post chciałbym poświęcić na opisanie obsługi czytnika linii papilarnych TFSD400 z mikrokontrolerem STM32F205 32-bit. Komunikacja z układem odbywa się poprzez port UART.

[Źródło: http://www.st.com/en/evaluation-tools/32f746gdiscovery.html]

Program:

Poniżej przedstawię wykaz funkcji z biblioteki, po nim opiszę niektóre ważniejsze funkcje, oraz przedstawię przykładowy sposób użycia.

Poniżej przejdę przez funkcję zawarte w bibliotece. Co do funkcjonalności czytnika może się ona różnić w zależności od wgranego oprogramowania. Dodatkowo datasheet jest nie za bardzo dokładny, co oznacza, że najlepszym sposobem na sprawdzanie komend będzie wyszukiwanie ich w kodach źródłowych dla aplikacji komputerowej napisanej w C++, które zostały udostępnione przez producenta. Dane dla układu zostały zdefiniowane w plikach CommTestDlg.cpp oraz CmdHead.h.

Plik z kodem dla mikrokontrolera STM udostępnione od producenta są bardziej poglądowe niż stanowią dokładne informacje jakie zostały umieszczone.

Procedura inicjalizacji modułu opiera się na podłączeniu układu pod mikrokontroler oraz ustawieniu parametrów komunikacyjnych dla UART'a. Na płytce STM32F7 Discovery wykorzystałem UART7 z z prędkością 19200 baudrate. Pozostałe ustawienia bez zmian.

1. void Init_Uart7(uint32_t baudRate)
2. {
3.     GPIO_InitTypeDef gpio_init_structure;
5.     PORT_CLOCK_ENABLE(USART7_GPIOF);
6.     Uart_Usart_Initialize_Clock(UART7);
8.     gpio_init_structure.Pin         = USART7_TX2;
9.     gpio_init_structure.Mode        = GPIO_MODE_AF_PP;
10.     gpio_init_structure.Speed       = GPIO_SPEED_FAST;
11.     gpio_init_structure.Pull        = GPIO_PULLUP;
12.     gpio_init_structure.Alternate   = GPIO_AF8_UART7;
13.     HAL_GPIO_Init(USART7_GPIOF, &gpio_init_structure);
15.     // GPIO RX
16.     gpio_init_structure.Pin         = USART7_RX2;
17.     gpio_init_structure.Mode        = GPIO_MODE_AF_PP;
18.     gpio_init_structure.Pull        = GPIO_PULLUP;
19.     gpio_init_structure.Alternate   = GPIO_AF8_UART7;
20.     HAL_GPIO_Init(USART7_GPIOF, &gpio_init_structure);
22.     UART_Handle7.Instance                       = UART7;
23.     UART_Handle7.Init.BaudRate                  = baudRate;
24.     UART_Handle7.Init.WordLength                = UART_WORDLENGTH_8B;
25.     UART_Handle7.Init.StopBits                  = UART_STOPBITS_1;
26.     UART_Handle7.Init.Parity                    = UART_PARITY_NONE;
27.     UART_Handle7.Init.HwFlowCtl                 = UART_HWCONTROL_NONE;
28.     UART_Handle7.Init.Mode                      = UART_MODE_TX_RX;
29.     UART_Handle7.Init.OverSampling              = UART_OVERSAMPLING_16;
30.     UART_Handle7.Init.OneBitSampling            = UART_ONEBIT_SAMPLING_DISABLED;
31.     UART_Handle7.AdvancedInit.AdvFeatureInit    = UART_ADVFEATURE_NO_INIT;
33.     HAL_UART_Init(&UART_Handle7);
35.     HAL_NVIC_DisableIRQ(UART7_IRQn);
36.     HAL_NVIC_SetPriority(UART7_IRQn, 0, 1);
37.     HAL_NVIC_EnableIRQ(UART7_IRQn);
38.     HAL_NVIC_ClearPendingIRQ(UART7_IRQn);
40.     __HAL_UART_ENABLE_IT(&UART_Handle7, UART_IT_RXNE);
42.     UART7->CR1 |= USART_CR1_RXNEIE;
43. }

Przerwania zostały utworzone tylko dla odbierania danych od modułu. Transmisja danych odbywa się w pollingu.

Po tej operacji należy sprawdzić komunikację z modułem. Wykonuje się to przez przesłanie komendy testowej:

1. TFSD400_OperStat_StatusTypeDef TFSD400_TestCommWithModule(void){
2.     uint8_t testCommFrame[] = { TFSD400_CMD_TEST_COMM_WITH_MODULE, 0x00, 0x00, 0x00 };
4.     p_TFSD400_ClearReceiveUartBuffer();
5.     TFSD400_WriteCommand(testCommFrame);
7.     return testResponseFrame_BlockingExample(UartDataStruct.Buffer, testCommFrame, sizeof(testCommFrame));
8. }

Jest to podstawowa operacja, dzięki której można określić czy posiadamy jakąś komunikację czyli czy kable są podłączone poprawnie, moduł jest skonfigurowany pod ustawione prędkości itp.

Cała procedura jest dosyć prosta na początku przygotowujemy ramkę testową, która bezie przesyłana do układu TFSD400. Taka sama ramka będzie przesłana w odpowiedzi od czytnika.

W celu zmiany baudrat'a można posłużyć się następującą komendą:

1. TFSD400_OperStat_StatusTypeDef TFSD400_ChangeBaudRate(TFSD400_BaudRateTypeDef selectedBaudrate){
2.     uint8_t baudarateFrameToSend[]  = { TFSD400_CMD_BAUD, 0x00, 0x00, selectedBaudrate };
3.     uint8_t baudrateFrameToReceive[] = { TFSD400_CMD_BAUD, 0x00, 0x00 };
5.     p_TFSD400_ClearReceiveUartBuffer();
6.     TFSD400_WriteCommand(baudarateFrameToSend);
8.     return testResponseFrame_BlockingExample(UartDataStruct.Buffer, baudrateFrameToReceive, 3);
9. }

Do wyboru są następujące prędkości:

• 9600 - wartość parametru 0x01,
• 19200 - wartość parametru 0x02,
• 38400 - wartość parametru 0x03,
• 57600 - wartość parametru 0x04,
• 115200 - wartość parametru 0x05.

Uśpienie układu możliwe jest przez następującą komendę:

1. TFSD400_OperStat_StatusTypeDef TFSD400_SleepDevice(void){
2.     uint8_t sendFrame[] = { TFSD400_CMD_SLEEP, 0x00, 0x00, 0x00 };
3.     uint8_t responseFrame[] = { TFSD400_CMD_SLEEP, 0x00, 0x00 };
5.     p_TFSD400_ClearReceiveUartBuffer();
6.     TFSD400_WriteCommand(sendFrame);
8.     return testResponseFrame_BlockingExample(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
9. }

Niestety nie ma możliwości wybudzenia go odpowiednim rozkazem. Co oznacza, że w celu wybudzenia należy wykonać sterowanie pinem reset układu TFSD400.

Kolejna z dostępnych funkcji pozwala na usunięcie wszystkich użytkowników z  bazy danych pamięci układu.

1. TFSD400_OperStat_StatusTypeDef TFSD400_DeleteAllUsers(){
2.     uint8_t sendFrame[]     = { TFSD400_CMD_DEL_ALL, 0x00, 0x00, 0x00 };
3.     uint8_t responseFrame[] = { TFSD400_CMD_DEL_ALL, 0x00, 0x00 };
5.     p_TFSD400_ClearReceiveUartBuffer();
6.     TFSD400_WriteCommand(sendFrame);
8.     return testResponseFrame_BlockingExample(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
9. }

Usunięcie pojedynczego użytkownika z bazy danych przebiega w następujący sposób:

1. TFSD400_OperStat_StatusTypeDef TFSD400_DeleteAllUsers(){
2.     uint8_t sendFrame[]     = { TFSD400_CMD_DEL_ALL, 0x00, 0x00, 0x00 };
3.     uint8_t responseFrame[] = { TFSD400_CMD_DEL_ALL, 0x00, 0x00 };
5.     p_TFSD400_ClearReceiveUartBuffer();
6.     TFSD400_WriteCommand(sendFrame);
8.     return testResponseFrame_BlockingExample(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
9. }

Każdy z zapisanych użytkowników dostaje osobny numer ID 16 bitowy. Po tym numerze możemy usunąć z pamięci użytkownika. Przesłanie go w ramce danych podając najpierw wyższy bajt, następnie w kolejnej wartości niższą cześć.

Sprawdzenie wersji oprogramowania umieszczonego w czytniku:

1. TFSD400_OperStat_StatusTypeDef TFSD400_GetSoftwareVersion(uint8_t *firmawareVersionPtr)
2. {
3.     uint8_t sendFrame[]     = { TFSD400_CMD_DSP_VER, 0x00, 0x00, 0x00 };
4.     uint8_t responseFrame[] = { TFSD400_CMD_DSP_VER };
6.     p_TFSD400_ClearReceiveUartBuffer();
7.     TFSD400_WriteCommand(sendFrame);
9.     int8_t positionInBuffer = testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
11.     if(positionInBuffer == -1)
12.     {
13.         return TFSD400_ERROR;
14.     }
16.     *(firmawareVersionPtr + 0) = UartDataStruct.Buffer[positionInBuffer + 1];
17.     *(firmawareVersionPtr + 1) = UartDataStruct.Buffer[positionInBuffer + 2];
19.     return TFSD400_OK;
20. }

Pobrana wersja oprogramowania składa się z dwóch bajtów danych, które są wpisywane do wskaźnika na tablicę przechowującą wynik.

Ustawienie oraz pobranie intensywności podświetlenia:

1. TFSD400_OperStat_StatusTypeDef TFSD400_SetLumAdjust(uint8_t backLightIntensity){
2.     uint8_t sendFrame[] = { TFSD400_CMD_SET_LUM, 0x00, 0x00, backLightIntensity  };
3.     uint8_t responseFrame[] = { TFSD400_CMD_SET_LUM };
5.     p_TFSD400_ClearReceiveUartBuffer();
7.     TFSD400_WriteCommand(sendFrame);
9.     return testResponseFrame_SearchPosition_BlockingExample(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame), 3);
10. }

Funkcja nie jest wspomniana w dokumentacji, natomiast można ją znaleźć w projekcie C++. Niestety nie wykonuje ona żadnych operacji na module. Prawdopodobnie w tej wersji oprogramowania, którą posiadam nie jest ona zdefiniowana. Możliwe że w wersjach z nowszym softem bądź innym modułem od tej firmy będzie ona działać bez problemów.

Odczytanie ustawionej intensywności podświetlenia:

1. uint8_t TFSD400_GetLumAdjust(uint8_t *pointerToLumDataArray){
2.     uint8_t sendFrame[]     = { TFSD400_CMD_GET_LUM, 0x00, 0x00, 0x00 };
3.     uint8_t responseFrame[] = { TFSD400_CMD_GET_LUM };
5.     p_TFSD400_ClearReceiveUartBuffer();
6.     TFSD400_WriteCommand(sendFrame);
8.     volatile int8_t positionInBuffer = testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
10.     if(positionInBuffer == (-1))
11.     {
12.         return TFSD400_ERROR;
13.     }
15.     *(pointerToLumDataArray + 0) = UartDataStruct.Buffer[positionInBuffer + 3];
16.     *(pointerToLumDataArray + 1) = UartDataStruct.Buffer[positionInBuffer + 4];
17.     *(pointerToLumDataArray + 2) = UartDataStruct.Buffer[positionInBuffer + 5];
19.     return positionInBuffer;
20. }

Ustaw czas potrzebny na odczytanie stanu przycisku:

1. TFSD400_OperStat_StatusTypeDef TFSD400_SetCaptureTimeout(uint8_t timeoutToSet){
2.     uint8_t sendFrame[] = { TFSD400_CMD_TIMEOUT, 0x00, timeoutToSet, 0x00 };
3.     uint8_t responseFrame[] = { TFSD400_CMD_TIMEOUT, 0x00 };
5.     p_TFSD400_ClearReceiveUartBuffer();
6.     TFSD400_WriteCommand(sendFrame);
8.     return testResponseFrame_SearchPosition_BlockingExample(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame), 3);
9. }

Tą funkcję można bezproblemowemu znaleźć w dokumentacji do układu czytnika palca. Wartość oczekiwania na odczyt palca może być wybierany z przedziału od 0 do 255. Gdzie ilość czasu obliczana jest ze wzoru:

Czas = (Przesłana Wartość) * 0,3;

W przypadku ustawienia tego parametru na 0. Czujnik będzie oczekiwał aż uda się odczytać numer dane.

Odczytanie ustawionej wartości czasu oczekiwania na przyłożenie palca:

1. uint8_t TFSD400_ReadCaptureTimeout(){
2.     uint8_t sendFrame[]     = { TFSD400_CMD_TIMEOUT, 0x00, 0x00, 0x01 };
3.     uint8_t responseFrame[] = { TFSD400_CMD_TIMEOUT, 0x00 };
5.     p_TFSD400_ClearReceiveUartBuffer();
7.     TFSD400_WriteCommand(sendFrame);
9.     int8_t positionInBuffer = testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
11.     if(positionInBuffer == (-1) || UartDataStruct.Buffer[positionInBuffer + 3] != TFSD400_OK)
12.     {
13.         return retTFSD400Code(UartDataStruct.Buffer[positionInBuffer + 3]);
14.     }
16.     return UartDataStruct.Buffer[positionInBuffer + 2];
17. }

Ustawienie poziomu porównywania odcisku palca z wprowadzonym wzorcem:

1. TFSD400_OperStat_StatusTypeDef TFSD400_SetCompairisionLevel(uint8_t level){
2.     if(level > 9) {
3.         return TFSD400_FAIL;
4.     }
5.    
6.     uint8_t sendFrame[] = { TFSD400_CMD_CMP_LVL, 0x00, level, 0x00 };
7.     uint8_t responseFrame[] = { TFSD400_CMD_CMP_LVL, 0x00 };
9.     p_TFSD400_ClearReceiveUartBuffer();
11.     TFSD400_WriteCommand(sendFrame);
13.     return testResponseFrame_SearchPosition_BlockingExample(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame), 3);
14. }

W przypadku przekroczenia dopuszczalnego poziomu zwracany jest błąd bez przesyłania ramki danych do czytnika.

Odczytywanie poziomu porównywania odcisku palca:

1. uint8_t TFSD400_ReadCompairisionLevel(){
2.     uint8_t sendFrame[] = { TFSD400_CMD_CMP_LVL, 0x00, 0x00, 0x01 };
3.     uint8_t responseFrame[] = { TFSD400_CMD_CMP_LVL, 0x00 };
5.     p_TFSD400_ClearReceiveUartBuffer();
7.     TFSD400_WriteCommand(sendFrame);
9.     int8_t positionInBuffer = testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
11.     if(positionInBuffer == (-1) || UartDataStruct.Buffer[positionInBuffer + 3] != TFSD400_OK)
12.     {
13.         return TFSD400_ERROR;
14.     }
16.     return UartDataStruct.Buffer[positionInBuffer + 2];
17. }

Odczytanie ustawionego trybu dodawania palca (repeat mode / prohibit repeat mode). W drugiej funkcji możliwe jest tylko dodawanie pojedynczego użytkowania do pamięci. W przypadku ustawiania drugiego użytkownika zostanie zwrócona wartość błędu.

1. uint8_t TFSD400_ReadFingerprintAddMode(){
2.     uint8_t sendFrame[] = { TFSD400_CMD_MODE, 0x00, 0x00, 0x01 };
3.     uint8_t responseFrame[] = { TFSD400_CMD_MODE, 0x00 };
5.     p_TFSD400_ClearReceiveUartBuffer();
7.     TFSD400_WriteCommand(sendFrame);
9.     int8_t positionInBuffer = testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
11.     if(positionInBuffer == (-1) || UartDataStruct.Buffer[positionInBuffer + 3] != TFSD400_OK)
12.     {
13.         return TFSD400_ERROR;
14.     }
16.     return UartDataStruct.Buffer[positionInBuffer + 2];
17. }

Gdy funkcja zwróci wartość 1 to ustawiono tryb prohibit repeat mode, 0 gdy wybrano repeat mode. W przypadku błędu zwrócona zostanie wartość 0xFF.

Ustawienie trybu dodawania palca:

1. TFSD400_OperStat_StatusTypeDef TFSD400_SetFingerprintAddMode(uint8_t mode){
2.     if(mode != 0x00 && mode != 0x01) { return 0xFF; }
3.    
4.     uint8_t sendFrame[]     =   { TFSD400_CMD_MODE, 0x00, mode, 0x00 };
5.     uint8_t responseFrame[] =   { TFSD400_CMD_MODE, 0x00 };
7.     p_TFSD400_ClearReceiveUartBuffer();
9.     TFSD400_WriteCommand(sendFrame);
11.     int8_t positionInBuffer = testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
13.     if(positionInBuffer == (-1) || UartDataStruct.Buffer[positionInBuffer + 3] != TFSD400_OK)
14.     {
15.         return TFSD400_ERROR;
16.     }
18.     return retTFSD400Code( UartDataStruct.Buffer[positionInBuffer + 3] );
19. }

Podobnie jak poprzednio wybieramy parametr z odpowiednim trybem i przesyłamy do urządzenia.

Pobranie liczby użytkowników zapisanych w pamięci urządzenia:

1. TFSD400_OperStat_StatusTypeDef TFSD400_GetNumberOfRegUserId(uint8_t *numberOfUserPtr){
2.     uint8_t sendFrame[]     = { TFSD400_CMD_USER_SUM_DB, 0x00, 0x00, 0x00 };
3.     uint8_t responseFrame[] = { TFSD400_CMD_USER_SUM_DB };
5.     p_TFSD400_ClearReceiveUartBuffer();
6.     TFSD400_WriteCommand(sendFrame);
8.     int8_t positionInBuffer = testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
10.     if(positionInBuffer == (-1) || UartDataStruct.Buffer[positionInBuffer + 3] != TFSD400_OK)
11.     {
12.         return TFSD400_ERROR;
13.     }
14.    
15.     *(numberOfUserPtr + 0) = (UartDataStruct.Buffer[positionInBuffer + 1] << 8);
16.     *(numberOfUserPtr + 1) = (UartDataStruct.Buffer[positionInBuffer + 2]);
18.     return TFSD400_OK;
19. }

Pobranie informacji o wgranych użytkownikach oraz ich uprawnieniach:

1. uint32_t TFSD400_CompareFingerWithDatabase(){
2.     uint8_t sendFrame[]     = { TFSD400_CMD_MATCH, 0x00, 0x00, 0x00 };
3.     uint8_t responseFrame[] = { TFSD400_CMD_MATCH   };
5.     p_TFSD400_ClearReceiveUartBuffer();
6.     TFSD400_WriteCommand(sendFrame);
8.     int8_t positionInBuffer = testResponseFrame_ReturnBufferPosition_ReadFingerTimeout(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
10.     if(positionInBuffer == (-1))
11.     {
12.         return 0xFFFFFFFF;;
13.     }
15.     if( (UartDataStruct.Buffer[positionInBuffer + 1] == 0x00) &
16.             (UartDataStruct.Buffer[positionInBuffer + 2] == 0x00) &
17.             (UartDataStruct.Buffer[positionInBuffer + 3] != 0x00))
18.     {
19.         return 0xFFFFFFFF;
20.     }
22.     return UartDataStruct.Buffer[positionInBuffer + 1] << 16 | UartDataStruct.Buffer[positionInBuffer + 2] << 8 |UartDataStruct.Buffer[positionInBuffer + 3];
23. }

Wykonanie porównania przyłożonego palca z konkretnym użytkownikiem zapisanym w pamięci modułu odczytu linii papilarnych:

1. TFSD400_OperStat_StatusTypeDef TFSD400_CompareUserWithFinger(uint16_t user){
2.     uint8_t sendFrame[]     = { TFSD400_CMD_USER_CMP, user >> 8, user, 0x00 };
3.     uint8_t responseFrame[] = { TFSD400_CMD_USER_CMP, 0x00, 0x00 };
5.     p_TFSD400_ClearReceiveUartBuffer();
6.    
7.     TFSD400_WriteCommand(sendFrame);
9.     return testResponseFrame_SearchPosition_BlockingExample(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame), 3);
10. }

Dodawanie użytkownika wraz z uprawnieniem. Jako argument podawana jest wartość ID oraz poziom uprawnień dla danego użytkownika. Znaczenie tego ostatniego jest definiowane przez użytkownika.

1. TFSD400_OperStat_StatusTypeDef TFSD400_AddFingerprint(uint16_t userId, uint8_t userPrivilage){
2.     if(userId < 0x01 || userId > 0xFFF) { return TFSD400_ERROR; }
3.     if(userPrivilage < 1 || userPrivilage > 3){ return TFSD400_ERROR; }
5.     uint8_t sendFrame[] = { TFSD400_CMD_ADD_1, userId >> 8, userId, userPrivilage };
6.     uint8_t responseFrame[] = { TFSD400_CMD_ADD_1, 0x00, 0x00 };
8.     p_TFSD400_ClearReceiveUartBuffer();
10.     //Send first Add Command
11.     p_TFSD400_ClearReceiveUartBuffer();
12.     TFSD400_WriteCommand(sendFrame);
14.     volatile int8_t positionInBuffer = testResponseFrame_ReturnBufferPosition_ReadFingerTimeout(UartDataStruct.Buffer, responseFrame,sizeof(responseFrame));
16.     if(positionInBuffer == (-1)) {
17.         return TFSD400_ERROR;
18.     }
20.     if(retTFSD400Code(UartDataStruct.Buffer[positionInBuffer + 3]) != TFSD400_OK )
21.     {
22.         return retTFSD400Code( UartDataStruct.Buffer[positionInBuffer + 3] );
23.     }
25.     //Send second command
26.     sendFrame[0] = TFSD400_CMD_ADD_2;
27.     responseFrame[0] = TFSD400_CMD_ADD_2;
29.     p_TFSD400_ClearReceiveUartBuffer();
30.     TFSD400_WriteCommand(sendFrame);
32.     positionInBuffer = testResponseFrame_ReturnBufferPosition_ReadFingerTimeout(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
34.     if(positionInBuffer == (-1)) {
35.         return TFSD400_ERROR;
36.     }
38.     if(retTFSD400Code(UartDataStruct.Buffer[positionInBuffer + 3]) != TFSD400_OK )
39.     {
40.         return retTFSD400Code( UartDataStruct.Buffer[positionInBuffer + 3] );
41.     }
43.     //Send third command
44.     sendFrame[0] = TFSD400_CMD_ADD_3;
45.     responseFrame[0] = TFSD400_CMD_ADD_3;
47.     p_TFSD400_ClearReceiveUartBuffer();
48.     TFSD400_WriteCommand(sendFrame);
50.     positionInBuffer = testResponseFrame_ReturnBufferPosition_ReadFingerTimeout(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
52.     if(positionInBuffer == (-1)) {
53.         return TFSD400_ERROR;
54.     }
56.     if(retTFSD400Code(UartDataStruct.Buffer[positionInBuffer + 3]) != TFSD400_OK )
57.     {
58.         return retTFSD400Code(UartDataStruct.Buffer[positionInBuffer + 3]);
59.     }
61.     return TFSD400_OK;
62. }

Numery użytkowników możliwe są z zakresu od 0 do 0xFFF. Uprawnienia dla użytkownika od 1 do 3. Pozostałe wartości są pomijalne. W przypadku gdy użytkownik istnieje to wywołanie funkcji spowoduje zwrócenie kodu o numerze 6.

Pobranie odcisku palca dla użytkownika. Tworzy nowego użytkownika wraz z nowym numerem ID:

1. TFSD400_OperStat_StatusTypeDef TFSD400_DownloadEigenSaveAsUser(uint8_t* fingerBuffer, uint16_t buffer_len, uint16_t user, uint8_t priv){
2.     uint16_t len = 0;
3.     uint8_t sendFrame[] = { TFSD400_CMD_DOWN_SAVEUSR, user >> 8, user, priv, [197]=0 };
4.     uint8_t responseFrame[] = { TFSD400_CMD_DOWN_SAVEUSR };
6.     p_TFSD400_ClearReceiveUartBuffer();
8.     if(buffer_len > 192) { len = 192; }
9.     else                 { len = buffer_len; }
11.     //Prepare frame
12.     for(uint8_t i=0; i<len; i++) { sendFrame[4+i] = *(fingerBuffer + i); }
13.    
14.     writeCommandFrame(sendFrame, 197);
16.     return testResponseFrame_SearchPosition_BlockingExample(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame), 3);
17. }

Wgrywanie danych dla użytkownika:

1. TFSD400_OperStat_StatusTypeDef TFSD400_UploadImagesAndEigenvalues(uint8_t* outputDataBuffer, uint16_t bufferSize){
3.     uint8_t sendFrame[]     = { TFSD400_CMD_UP_IMG_EIGVAL, 0x00, 0x00, 0x00 };
4.     uint8_t responseFrame[] = { TFSD400_CMD_UP_IMG_EIGVAL };
5.     uint8_t endFrame[]      = { TFSD400_CMD_TAIL, 0xFF };
6.     uint16_t len = 0;
8.     if(bufferSize > 192) { len = 192;        }
9.     else                 { len = bufferSize; }
11.     p_TFSD400_ClearReceiveUartBuffer();
12.     TFSD400_WriteCommand(sendFrame);
14.     //wait for start response frame:
15.     int8_t positionInBuffer = testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
17.     if(positionInBuffer == (-1)) { return TFSD400_ERROR; }
19.     //Delay to receive full frame from TFSD400
20.     HAL_Delay(50);
22.     //Search for frame and for end of transfer
23.     positionInBuffer = testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, endFrame, sizeof(endFrame));
25.     //Check if operation was ok
26.     if(UartDataStruct.Buffer[positionInBuffer + 3] != TFSD400_OK) {
27.         return retTFSD400Code(UartDataStruct.Buffer[positionInBuffer + 3]);
28.     }
30.     for( uint8_t i=0; i<len; i++ ) {
31.         *(outputDataBuffer+i) = UartDataStruct.Buffer[positionInBuffer + i + 11];
32.     }
34.     return TFSD400_OK;
35. }

Przesłanie danych z odciskiem do modułu wraz z porównaniem z danymi wejściowymi:

1. TFSD400_OperStat_StatusTypeDef TFSD400_DownloadEigenAcqFingerComp(uint8_t* fingerBuffer, uint16_t bufferSize){
2.     uint16_t dataLength = 0;
3.     uint8_t sendFrame[] = { TFSD400_CMD_DOWN_EIGVAL, [197]=0 };
4.     uint8_t responseFrame[] = { TFSD400_CMD_DOWN_EIGVAL, 0x00, 0x00};
5.     uint8_t tailFrame[] = { TFSD400_CMD_TAIL, 0xFF, 0xFF};
6.    
7.     //Buffer Length is too low
8.     if(bufferSize < 192) { return TFSD400_ERROR; }
9.    
10.     if(bufferSize > 192) { dataLength = 192;            }
11.     else                 { dataLength = bufferSize;     }
12.    
13.     p_TFSD400_ClearReceiveUartBuffer();
15.     for(uint8_t i=0; i<dataLength; i++) { sendFrame[4+i] = *(fingerBuffer + i); }
16.    
17.     writeCommandFrame(sendFrame, 197);
18.    
19.     //wait for start response frame:
20.     int8_t positionInBuffer = testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
21.    
22.     if(positionInBuffer == (-1)) { return TFSD400_ERROR; }
23.    
24.     if(testResponseFrame_SearchPosition_BlockingExample(UartDataStruct.Buffer, tailFrame, sizeof(tailFrame), 3) == TFSD400_OP_ERROR)
25.     {
26.         return TFSD400_ERROR;
27.     }
28.    
29.     return retTFSD400Code(UartDataStruct.Buffer[positionInBuffer + 3]);
30. }

Przesłanie danych z odciskiem palca do modułu w celu porównania ich z konkretnym użytkownikiem podanym w argumencie funkcji:

1. TFSD400_OperStat_StatusTypeDef TFSD400_DownloadFingerprinyEigenCompWithUser(uint8_t* fingerBuffer,
2.                                                    uint16_t userData, uint16_t bufferSize)
3. {
4.     uint8_t sendFrame[] = { TFSD400_CMD_DOWN_COMP11, userData>>8, userData, [197]=0 };
5.     uint8_t responseFrame[] = { TFSD400_CMD_DOWN_COMP11, 0x00, 0x00};
6.     uint16_t dataLength = bufferSize;
8.     if(bufferSize < 192) { return TFSD400_ERROR; }
9.     if(bufferSize > 192) { dataLength = 192; }
11.     for(uint8_t i=0; i<dataLength; i++) {
12.         sendFrame[4+i] = *(fingerBuffer + i);
13.     }
15.     p_TFSD400_ClearReceiveUartBuffer();
16.     writeCommandFrame(sendFrame, 197);
18.     int8_t positionInBuffer =
19.             testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
21.     if(positionInBuffer == -1){ return TFSD400_TIMEOUT; }
23.     return retTFSD400Code(UartDataStruct.Buffer[positionInBuffer + 3]);
24. }

Przesłanie do czytnika odczytów z odcisku palca i porównanie ich z wszystkimi danymi przechowywanymi w bazie danych. Funkcja zwraca Id użytkownika oraz rodzaj uprawnień jakie zostały do niego przypisane:

1. uint16_t TFSD400_DownloadFingerprintEigenComp1NDatabase(uint8_t* fingerBuffer, uint16_t bufferSize,
2.                                                                                 uint8_t* receiveData){
3.     uint8_t sendFrame[] = { TFSD400_CMD_DOWN_COMP1N, [197]=0 };
4.     uint8_t responseFrame[] = { TFSD400_CMD_DOWN_COMP1N };
6.     uint16_t dataLength = bufferSize;
8.     //Buffer Length is too low
9.     if(bufferSize < 192) { return TFSD400_ERROR; }
11.     if(bufferSize > 192) { dataLength = 192; }
13.     for(uint8_t i=0; i<dataLength; i++) { sendFrame[4+i] = *(fingerBuffer + i); }
15.     p_TFSD400_ClearReceiveUartBuffer();
16.     writeCommandFrame(sendFrame, 197);
18.     int8_t positionInBuffer =
19.             testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseFrame, sizeof(responseFrame));
21.     if(UartDataStruct.Buffer[dataLength + 3] == TFSD400_ACK_NO_USER)
22.     {
23.         return 0xFFFF;
24.     }
26.     *(receiveData + 0) = UartDataStruct.Buffer[positionInBuffer + 1]; //UserId
27.     *(receiveData + 1) = UartDataStruct.Buffer[positionInBuffer + 2]; //UserId
28.     *(receiveData + 2) = UartDataStruct.Buffer[positionInBuffer + 3]; //User privilege
30.     return UartDataStruct.Buffer[dataLength + 1] << 8 | UartDataStruct.Buffer[dataLength + 2];
31. }

Pobranie wgranego odcisku palca wykonuje się za pomocą następującej funkcji:

1. TFSD400_OperStat_StatusTypeDef TFSD400_UploadUsersFingerprintSpecifiedUserEigenvalue(uint8_t* fingerBuffer,
2.                                     uint8_t user, uint8_t *responseCodes){
3.     uint8_t sendFrame[] = { TFSD400_CMD_UP_U_EIGVAL, user >> 8, user, 0x00};
4.     uint8_t responseStartFrame[] = { TFSD400_CMD_UP_U_EIGVAL};
5.     uint8_t responseTailFrame[] = { TFSD400_CMD_TAIL, 0xFF };
6.     uint8_t dataFrame[] = { 0xF5, user >> 8, user};
8.     p_TFSD400_ClearReceiveUartBuffer();
9.     TFSD400_WriteCommand(sendFrame);
11.     volatile int8_t startPosition =
12.             testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseStartFrame, sizeof(responseStartFrame));
13.     volatile int16_t endPosition = -1;
15.     if(startPosition == -1){
16.         return TFSD400_ERROR;
17.     }
19.     endPosition = testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseTailFrame, sizeof(responseTailFrame));
21.     if(endPosition == -1){
22.         return TFSD400_ERROR;
23.     }
25.     if(retTFSD400Code(UartDataStruct.Buffer[startPosition + 3]) != TFSD400_OK )
26.     {
27.         return retTFSD400Code(UartDataStruct.Buffer[startPosition + 3]);
28.     }
30.     startPosition = -1;
31.     endPosition = -1;
33.     startPosition = testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, dataFrame, sizeof(dataFrame));
35.     if(startPosition == -1){
36.         return TFSD400_ERROR;
37.     }
39.     endPosition = (uint8_t)testResponseFrame_ReturnBufferPosition(UartDataStruct.Buffer, responseTailFrame, sizeof(responseTailFrame));
41.     if(endPosition == -1) {
42.         return TFSD400_ERROR;
43.     }
45.     *(responseCodes + 0) = UartDataStruct.Buffer[startPosition + 1];   //UserId
46.     *(responseCodes + 1) = UartDataStruct.Buffer[startPosition + 2];   //UserId
47.     *(responseCodes + 2) = UartDataStruct.Buffer[startPosition + 3];   //User privilege
49.     for(uint8_t i=0; i<193; i++) {
50.         *(fingerBuffer+i) = UartDataStruct.Buffer[startPosition + i + 4];
51.     }
53.     return TFSD400_OK;
54. }

W odpowiedzi (dla istniejącego użytkownika) moduł zwróci dwie ramki. Jedna z nich będzie zawierała informację o poprawnym znalezieniu danych dla wybranego użytkownika. Druga ramka będzie zawierała znaleziony numer użytkownika, poziom uprawnień oraz dane z odciskiem palca. W przypadku niepoprawnego ID użytkownika zostanie zwrócona  informacja o błędzie.

Aby zapisać odcisk palca w pamięci urządzenia należy wykorzystać opisaną wcześniej komendę TFSD400_AddFingerprint().

W celu załadowania odcisku do modułu należy przyłożyć trzykrotnie palec do modułu. Czas oczekiwania na przyłożenie został zdefiniowany w zmiennej

Ustawienie modułu do odczytu odcisku palca można wykonać za pomocą komendy TFSD400_CompareFingerWithDatabase(). Sprawdza ona czy przyłożony w zadanym czasie palec pasuje do jednego z odcisków zdefiniowanych w bazie danych.

Biblioteki można pobrać z dysku Google pod tym linkiem.