[18] STM32F7 - Odczyt kart RFID Unique za pomocą układu EM4095

W tym poście chciałbym przedstawić sposób obsługi układu EM4095 za pomocą mikrokontrolera STM32F7.

[Źródło: http://www.priority1design.com.au/em4095_rfid_ic.html]

Parametry układu:

• Modulacja AM OOK
• Zakres częstotliwości fali nośnej 100 do 150 kHz
• Pobór prądu w czasie uśpienia wynosi 1uA
• Czas potrzebny na wybudzenie to 25ms
• Napięcie zasilania od 4.1V do 5.5V
• Zakres temperatury pracy wynosi od -40 st. C do 85 st. C

Układ ten zawiera modulator oraz demodulator.

Wykorzystywał będę tylko dwa piny układu podłączane do F7:

SHD - pozwala na włączenie bądź wyłączenie układu bądź na wykonanie resetu. Procedury te wykonuje się poprzez wygenerowanie zbocza opadającego. Dla normalnej pracy należy go utrzymywać w stanie wysokim.

DMOD - jest to wyjście zawierające zdemodulowany sygnał odebrany z karty unique. To wyjście z układu zawiera sygnał

Pozostałe obsługują następujące funkcje:

ANT - podłączenie anteny do układu.
RDY/CLK - na nim dostępny jest sygnał w przebiegu prostokątnym jaki jest nadawany przez antenę.
MOD - jest to pin wyjściowy za pomocą którego można modulować nadawany przez antenę sygnał.

Pin RDY/CLK zostawiam niepodłączony, natomiast pin MOD zostaje zwarty do masy.

Układ EM pozwala na odczytanie takich kart jak:

Unique - jest to jeden z pierwszych standardów kart, obecnie najprostszy z nich. Częstotliwość odczytu wynosi 125 kHz. Numer przechowywany jest na karcie na 40 bitach. Jest on nadawany podczas jej produkcji.

Q5 - są to karty komunikujące się na tej samej zasadzie co Unique. Dodatkiem do nich jest pamięć EEPROM. Te karty można także programować i zmieniać ich numer wielokrotnie.

Kodowanie danych odbywa się za pomocą kodu Manchester. Sygnał przyjmuje stan odpowiadający jego wartość binarną. W środku czasu trwania transmisji następuje zmiana sygnału na przeciwny. Dla zera będzie to stan niski, dla jedynki będzie to stan wysoki. [Wikipedia].

Czyli jeśli będą nadawane te same bity to czas wystąpienia kolejnego zbocza będzie zawsze wynosił połowę okresu sygnału. Natomiast jeśli nastąpi zmiana stanu to ten czas zostanie wydłużony do pełnego okresu.

Ramka danych prezentuje się następująco:

[Źródło: elektroda]

Transmisja danych rozpoczyna się od 9 bitów startu oznaczonych jako 1. Potem od D00 do D07 wprowadzony jest kod producenta karty. Od D08 do D39 umieszczony jest numer karty. Bity P0 do P9 są to bity parzystości dla każdych 4 bitów. Jeśli zawierają one nieparzystą ilość jedynek to bit parzystości wynosi 1. Bity od CP0 do CP3 są to bity parzystości każdych 10 bitów umieszczonych w kolumnach. Transmisja jest kończona bitem S0, który zawsze wynosi 1. 

CubeMx:

Aby można było tego dokonać to należy uruchomić licznik z obsługą trybu Input Capture. Ja wybrałem Timer 2. Dla jego poprawnej pracy należy go skonfigurować w następujący sposób:

Timer 2 jest taktowany z linii APB1 więc jego częstotliwość wynosi 1kHz. Ustawienia timera są wykonywane w funkcji EM4095_Init(). Więc ustawienia pobrane z CubeMx zostaną nadpisane. W przypadku korzystania z innego zegara lub mikrokontrolera należy zmodyfikować tą funkcję.

Ustawienie zegarów wygląda następująco:

Konfiguracje należy dokończyć przez dodanie pozostałych ustawień.

Program:

Osobna procedura inicjalizacyjna wygląda następująco:

1. void EM4095_Init(void)
2. {
3.     GPIO_InitTypeDef GPIO_InitStruct;
4.     TIM_ClockConfigTypeDef sClockSourceConfig;
5.     TIM_SlaveConfigTypeDef sSlaveConfig;
6.     TIM_MasterConfigTypeDef sMasterConfig;
7.     TIM_IC_InitTypeDef sConfigIC;
8.     /* Define PI2 pin as output with pullUp */
9.     __HAL_RCC_GPIOA_CLK_ENABLE();
10.     __HAL_RCC_GPIOI_CLK_ENABLE();
11.     GPIO_InitStruct.Pin = GPIO_PIN_2;
12.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
13.     GPIO_InitStruct.Pull = GPIO_PULLUP;
14.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
15.     HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);
16. 
    
17.     HAL_GPIO_WritePin(GPIOI, GPIO_PIN_2, GPIO_PIN_RESET);   /* SHD set for LOW */
18.     HAL_Delay(1000);                                        /* small delay */
19.     HAL_GPIO_WritePin(GPIOI, GPIO_PIN_2, GPIO_PIN_SET);     /* SHD set for HIGH */
20.     TIM2MspInit(&htim2);
21.     /* Init Timer 2 in Capture mode*/
22.     htim2.Instance = TIM2;
23.     htim2.Init.Prescaler = 99;
24.     htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
25.     htim2.Init.Period = 99999;
26.     htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
27.     htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
28.     if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
29.     {
30.       _Error_Handler(__FILE__, __LINE__);
31.     }
32.     sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
33.     if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
34.     {
35.       _Error_Handler(__FILE__, __LINE__);
36.     }
37.     if (HAL_TIM_IC_Init(&htim2) != HAL_OK)
38.     {
39.       _Error_Handler(__FILE__, __LINE__);
40.     }
41.     sSlaveConfig.SlaveMode = TIM_SLAVEMODE_RESET;
42.     sSlaveConfig.InputTrigger = TIM_TS_TI1FP1;
43.     sSlaveConfig.TriggerPolarity = TIM_INPUTCHANNELPOLARITY_BOTHEDGE;
44.     sSlaveConfig.TriggerFilter = 0;
45.     if (HAL_TIM_SlaveConfigSynchronization(&htim2, &sSlaveConfig) != HAL_OK)
46.     {
47.       _Error_Handler(__FILE__, __LINE__);
48.     }
49.     sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
50.     sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
51.     if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
52.     {
53.       _Error_Handler(__FILE__, __LINE__);
54.     }
55.     sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_BOTHEDGE;
56.     sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
57.     sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
58.     sConfigIC.ICFilter = 0;
59.     if (HAL_TIM_IC_ConfigChannel(&htim2, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
60.     {
61.       _Error_Handler(__FILE__, __LINE__);
62.     }
63.     /* TIM2 interrupt ON */
64.     HAL_NVIC_SetPriority(TIM2_IRQn, 1, 0);
65.     HAL_NVIC_EnableIRQ(TIM2_IRQn);
66. }

1. static void TIM2MspInit(TIM_HandleTypeDef* htim_base)
2. {
3.     GPIO_InitTypeDef GPIO_InitStruct;
4.     if(htim_base->Instance==TIM2)
5.     {
6.         __HAL_RCC_GPIOA_CLK_ENABLE();
7.         __HAL_RCC_TIM2_CLK_ENABLE();
8.         /**TIM2 GPIO Configuration
9.         PA0     ------> TIM2_CH1
10.         */
11.         GPIO_InitStruct.Pin = GPIO_PIN_15;
12.         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
13.         GPIO_InitStruct.Pull = GPIO_NOPULL;
14.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
15.         GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
16.         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
17.         /* TIM2 interrupt Init */
18.         HAL_NVIC_SetPriority(TIM2_IRQn, 0, 0);
19.         HAL_NVIC_EnableIRQ(TIM2_IRQn);
20.     }
21. }

1. static void TIM2MspDeInit(TIM_HandleTypeDef* htim_base)
2. {
3.     if(htim_base->Instance==TIM2)
4.     {
5.         /* Peripheral clock disable */
6.         __HAL_RCC_TIM2_CLK_DISABLE();
7.  
8.         HAL_GPIO_DeInit(GPIOA, GPIO_PIN_15);
9.         /* TIM2 interrupt DeInit */
10.         HAL_NVIC_DisableIRQ(TIM2_IRQn);
11.     }
12. }

Podczas niej uruchomiony zostaje pin SHD na którym do działania układu musi być wystawiony sygnał wysoki. Układ można wyłączać poprzez podanie na ten pin stanu niskiego.

Funkcja znajdująca nagłówek, czyli 9 jedynek:

1. static uint8_t FindHeader(em4095_unique_t * unique_card) {
2.     uint8_t bitsToCheck;
3.     /* Check all bits */
4.     for (uint8_t i = 0; i < 64; i++)
5.     {
6.         /* if header is in the beginning of data frame */
7.         if ((unique_card->data_frame & START_HEADER_MASK) == START_HEADER_MASK) { return 1; /* OK */ }
8.         else
9.         {
10.             bitsToCheck = unique_card->data_frame & MSB_BIT_MASK ? 1 : 0;
11.             unique_card->data_frame <<= 1;
12.             if (bitsToCheck)
13.             {
14.                 unique_card->data_frame |= LSB_BIT_MASK;
15.             }
16.         }
17.     }
18.     if ((unique_card->data_frame & START_HEADER_MASK) == START_HEADER_MASK) {
19.         return 1; /* OK */
20.     }
21.     return 0; /* error */
22. }

Funkcje obliczające parzystości:

1. static uint8_t RowParity(uint8_t dat)
2. {
3.     uint8_t count = 0;
4.     for (uint8_t i = 0; i < 4; i++)
5.     {
6.         if(dat & (1 << i))
7.         {
8.             count++;
9.         }
10.     }
11.     return count % 2 ? 1 : 0;
12. }
13. //-------------------------------------------------------------------------
14. static uint8_t HorizontalParity(uint64_t data_frame)
15. {
16.     for (uint8_t i = 1; i < 11; i++)
17.     {
18.         uint8_t byte = (data_frame >> (i * 5 + 1)) & 0xF;
19.         if (RowParity(byte) != ((data_frame >> (i * 5)) & 0x1))
20.         {
21.             return 0; /* error */
22.         }
23.     }
24.     return 1; /* OK */
25. }
26. //-------------------------------------------------------------------------
27. static uint8_t VerticalParity(uint64_t data_frame)
28. {
29.     for (uint8_t i = 1; i < 5; i++)
30.     {
31.         uint8_t parity = 0;
32.         for (uint8_t j = 1; j <= 10; j++)
33.         {
34.             parity ^= (data_frame >> (j * 5 + i)) & 0x1;
35.         }
36.        
37.         if (parity != ((data_frame >> i) & 0x1))
38.         {
39.             return 0; /* error */
40.         }
41.     }
42.     return 1; /* OK */
43. }

Pierwsza funkcja od góry sprawdza parzystość czterech bitów w jednym rzędzie po podaniu do niej czterech bitów. Kolejna pozwala na weryfikację 10 bitów w kolumnie. Ostatnia sprawdza bity parzystości dla pojedynczej linii. Obie funkcje operują na całej ramce odebranych danych.

Przygotowanie danych odbywa się w następującej funkcji:

1. static void GetDataForCard(em4095_unique_t * unique_card, uint8_t * resultData) {
2.     uint64_t std_card_nr = 0;
3.     char value[10];
4.     for (uint8_t i = 0; i < 10; i++) {
5.         value[9 - i] = (unique_card->data_frame >> (5 * (i + 1) + 1)) & 0xf;
6.     }
7.     for (uint8_t i = 0; i < 10; i++) {
8.         std_card_nr += value[i] * FactorialCalculate(16, (9 - i));
9.     }
10.     std_card_nr &= 0xFFFFFF;
11.     for (uint8_t i = 0; i < 4; i++) {
12.         resultData[i] = (std_card_nr >> i * 8) & 0xFF;
13.     }
14. }

W niej następuje wprowadzenie danych do głównego bufora zawierającego dane z odczytanym numerem karty.

Procedura obsługi przerwania wygląda następująco:

1. void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
2. {
3.     if((htim->Instance==TIM2) && (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1))
4.     {
5.         static uint8_t edgeCountCheck;
6.         static uint8_t readBitValue;
7.         static uint8_t countBits;
8.         if(!em4095_unique_data.is_processed) { return; }
9.         /* If decode proces reset */
10.         if (edgeCountCheck==0)
11.         {
12.             /* Reset all counters */
13.             countBits = 0;
14.             readBitValue = 1;
15.             em4095_unique_data.result = 0;
16.         }
17.         /* Get Capture value, then reset counter */
18.         pulse_length = HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_1);
19.         /* Clear counter */
20.         __HAL_TIM_SetCounter(&htim2, 0);
21.         /* Check pulse length */
22.         if ((pulse_length < EM4095_SHORT_PULSE_MIN) || (pulse_length > EM4095_LONG_PULSE_MAX)) {
23.             edgeCountCheck = 0;
24.         }
25.         else if (pulse_length >= EM4095_SHORT_PULSE_MIN && pulse_length <= EM4095_SHORT_PULSE_MAX)
26.         {
27.             /* Check edge parity, if edge positive*/
28.             if ((edgeCountCheck % 2) == 0)
29.             {
30.                 em4095_unique_data.result <<= 1;
31.                 em4095_unique_data.result |= (uint64_t)readBitValue;
32.                 countBits++;
33.             }
34.             /* Add next value to edge counter */
35.             edgeCountCheck++;
36.         }
37.         else
38.         {
39.             /* Change bit value */
40.             readBitValue ^= 0x01;
41.             em4095_unique_data.result <<= 1;
42.             em4095_unique_data.result |= (uint64_t)readBitValue;
43.             countBits++;
44.             edgeCountCheck += 2;
45.         }
46.         /* Check if receive all 64 bits of data */
47.         if (countBits > 64)
48.         {
49.             edgeCountCheck = 0;
50.             /* Set flag for data ready to process*/
51.             em4095_unique_data.is_frame_ready = true;
52.             /* If wrong data */
53.             if (!em4095_unique_data.data_frame)
54.             {
55.                 /* Disable interrupts */
56.                 TIM2MspDeInit(&htim2);
57.                 em4095_unique_data.data_frame = em4095_unique_data.result;
58.                 em4095_unique_data.is_processed = false;
59.             }
60.         }
61.     }
62. }

W przerwaniu od timera sprawdzane są długości poszczególnych impulsów, tak aby można było zweryfikować jaki impuls został odebrany długi czy krótki. W przypadku zastosowania innej częstotliwości licznika należy zmodyfikować czas impulsu długiego, krótkiego oraz tolerancji.

Teraz funkcja główna, której wywołanie następuje w pętli while:

1. void EM4095_Main_Function(void)
2. {
3.     /* If data is ready */
4.     if (em4095_unique_data.is_frame_ready)
5.     {
6.         /* refresh counter so the card will not be read again when still present in field */
7.         card_reset_timer = CARD_RESET_TIMER;
8.         counter_started = true;
9.         if (FindHeader(&em4095_unique_data))    /* Check if header is ok */
10.         {
11.             /* Check parity */
12.             if (HorizontalParity(em4095_unique_data.data_frame) && VerticalParity(em4095_unique_data.data_frame))
13.             {
14.   memset(em4095_unique_data.card_number, 0, sizeof(em4095_unique_data.card_number));
15.                     GetDataForCard(&em4095_unique_data, em4095_unique_data.card_number);
16.                 /* Check if there is different number */
17.                 if (!((em4095_unique_data.old_card_number[0] == em4095_unique_data.card_number[0]) &&
18.                       (em4095_unique_data.old_card_number[1] == em4095_unique_data.card_number[1]) &&
19.                       (em4095_unique_data.old_card_number[2] == em4095_unique_data.card_number[2]) &&
20.                       (em4095_unique_data.old_card_number[3] == em4095_unique_data.card_number[3])))
21.                 {
22.                     for(uint8_t i = 0; i<4; i++){
23.                         em4095_unique_data.old_card_number[i] = em4095_unique_data.card_number[i];
24.                     }
25.                     /* Print rejestration on the screen */
26.                     DisplayRegistrationOnTFTDisplay(&em4095_unique_data.card_number);
27.                 }
28.             }
29.             else
30.             {
31.                 em4095_unique_data.data_frame = 0;
32.                 em4095_unique_data.is_frame_ready = false;
33.             }
34.         }
35.         else
36.         {
37.             em4095_unique_data.data_frame = 0;
38.             em4095_unique_data.is_frame_ready = false;
39.         }
40.         TIM2MspInit(&htim2);
41.         em4095_unique_data.is_processed = true;
42.         em4095_unique_data.data_frame = 0;
43.         em4095_unique_data.is_frame_ready = false;
44.     }
45.     else if ((card_reset_timer == 0) && (counter_started == true))
46.     {
47.         /*
48.          *  counter will reset both stored card numbers after set time, and after card
49.          *  is taken from the field
50.          */
51.         counter_started = false;
52.         allow_send = true;
53.         for(uint8_t i = 0; i<4; i++)
54.         {
55.             em4095_unique_data.old_card_number[i] = 0;
56.             em4095_unique_data.card_number[i] = 0;
57.         }
58.     }
59.  }

Aby uśpić układ to należy ściągnąć pin SHD do masy. Spowoduje to wyłączenie wszystkich jego peryferiów. W celu jego wybudzenia należy podać na pin stan wysoki.

W celu wywołania programu w głównej funkcji programu należy umieścić dwie funkcje:

1. int main(void)
2. {
3.     //...
4.     //...
5.     EM4095_Init();
6.     //...
7.     //...
8.     while(1) {
9.     //...
10.     //...
11.     EM4095_Main_Function();
12.     //...
13.     //...
14.     }
15. }

Biblioteka dla tego układu jest do pobrania pod tym linkiem.