czwartek, 24 sierpnia 2017

[20] STM32F7 - Wiegand

W tym poście chciałbym przedstawić implementację interfejsu Wiegand. Do tego celu wykorzystam płytkę z Discovery z mikrokontrolerem STM32F746VG oraz biblioteki HAL'a.

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

Wiegand


Jest to trój-przewodowym interfejsem komunikacyjny, z czego jedno z wyprowadzeń jest wspólną masą. Pozostałe dwa przewody to data0 (D0) oraz data1 (D1). Linia D0 służy do informowania o wystąpieniu bitu o wartości 0. Linia D1 odwrotnie.

Najczęściej wykorzystywany jest w systemach RFID do przesyłania informacji pomiędzy urządzeniami.

Działanie protokołu jest dosyć proste, wygląda następująco:

Jeśli nie są przesyłane żadne dane to na obu liniach utrzymywany jest stan wysoki. Gdy wysyłana jest jedynka to linia D0 jest w stanie wysoki, natomiast linia D1 w stanie niskim. W przypadku przesłania 0 działanie jest odwrotne, czyli na linii D1 utrzymywany jest stan wysoki, natomiast D0 otrzymuje stan niski.

W celu zabezpieczenia danych wykorzystywana jest kontrola parzystości oraz kontrola nieparzystości.Obie metody sprawdzają ilości jedynek jakie występują w określonej części wiadomości.

Odbieranie danych można rozwiązać na dwa sposoby, albo następuje odliczanie zadanej ilości bitów do odebrania lub należy odczekać określony czas i po jego przeminięciu przerwać transmisję i sprawdzić odebraną ramkę.

Jeśli odlicza się czas pomiędzy impulsami należy przyjąć, że czas impulsu nie będzie przekraczał 100us, natomiast czas pomiędzy impulsami nie będzie dłuższy niż 50 - 100 ms. Wszystko zależy od rodzaju urządzenia jakie się wykorzystuje.

Standard card po przesyłanych danych przez wiegand wyglądają następująco:

Karta RFID 26 bitów:

Ramka danych wygląda następująco:

P FFFF FFFF CCCC CCCC CCCC CCCC O

Pierwszy bit P oznacza bit kontroli parzystości dla bitów na pozycjach od 1 do 12(czyli FFFF FFFF CCCC). Ostatni bit O odnosi się do kontroli nieparzystości bitów na pozycjach od 13 do 24 (czyli CCCC CCCC CCCC).

Bity oznaczone jako FFFF FFFF oznaczją tzw. Facility Code, który może przyjmować wartości od 0 do 255. Bity z numerem karty oznaczone są jako C. Mogą przyjmować dane z zakresu od 0 do 65535.

Poniżej przykładowy przebieg odczytu takiej karty zarejestrowany na analizatorze stanów logicznych:


Czas wygenerowania impulsu:


Jak widać na obrazku powyżej impuls generowany jest na około 40us.

Czas przerwy pomiędzy przesłaniem kolejnych bitów danych:


W tym przypadku czas przerwy wynosi ponad 2ms. 

 Karta RFID 37 bitów:

Jest to podobny format co w przypadku 26 bitów, natomiast pozwala on na przechowywanie znacznie większych ilości danych.

Ramka danych wygląda następująco:

P FFFF FFFF FFFF FFFF CCC CCCC CCCC CCCC CCCC O

Jak widać na początku i na końcu występują bity parzystości oraz nieparzystości. Facility code może przyjmować wartości z zakresu od 0 do 65535 natomiast numer karty od 0 do 524287.

Poniżej przykładowy przebieg odczytu takiej karty zarejestrowany na analizatorze stanów logicznych:





Można też spotkać standardy 32, 34, 37 bitów w przypadku odczytu kart bądź w przypadku obsługiwania klawiatur formaty 4 czy 8 bitowe.


Program:


Kod został przygotowany w oparciu o przerwania na dwóch pinach transmitujących dane oraz z obsługa przekroczenia czasu odliczoną na timerze. Program odbiera wszystkie dane od wieganda, i wyświetla je na ekranie (jeśli został również uruchomiony usart).

Dane odnośnie odebranych informacji przechowywane są w strukturze:

  1.  enum wiegandReceiveDataNumber {
  2.         wiegandNoData = 0,
  3.         wiegandWrongFrame = 1,
  4.         wiegand37Bit = 2,
  5.         wiegand26Bit = 3,
  6.         wiegand32Bit = 4
  7. };
  9.  /* @brief: structure for wiegand data */
  10. typedef struct wiegandDataStruct {
  11.     volatile uint8_t wiegandDat[kWiegandData];          /* receive data, one field one bit */
  12.     volatile uint8_t wiegandDataPosition;               /* number of receive data */
  13.     uint32_t readCardNumber;                   /* card number read from receive data */
  14.     uint32_t facilityCode;                     /* facility code read from receive data*/
  15.     uint32_t oldReadCardNumber;                /* Old card number, it contain previous card, reset after timeout */
  16.     volatile uint16_t wiegandTimeout;                   /* calculate timeout for receiving data */
  17.     enum wiegandReceiveDataNumber wiegandDataType;      /* type of receive data, if receive 26 or 37 itp */
  18.     volatile uint8_t wiegandStartReceive:2;             /* set when first interrupt came, inform timer interrupt to start counting */
  19. } wiegandData_t;

Inicjalizacja pinów:

  1. void wiegandInitPins(uint8_t channel)
  2. {
  3.     GPIO_InitTypeDef   GPIO_InitStruct;
  5.     if(channel == 1)
  6.     {
  7.         kData0ClockCh1;
  8.         kData1ClockCh1;
  10.         GPIO_InitStruct.Pin = kData0PinCh1;
  11.         GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  12.         GPIO_InitStruct.Pull = GPIO_NOPULL;
  13.         GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
  14.         HAL_GPIO_Init(kData0PortCh1, &GPIO_InitStruct);
  16.         GPIO_InitStruct.Pin = kData1PinCh1;
  17.         GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  18.         GPIO_InitStruct.Pull = GPIO_NOPULL;
  19.         GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
  20.         HAL_GPIO_Init(kData1PortCh1, &GPIO_InitStruct);
  22.         // NVIC config
  23.         HAL_NVIC_SetPriority(kData0IrqnCh1, 0, 0);
  24.         HAL_NVIC_EnableIRQ(kData0IrqnCh1);
  26.         HAL_NVIC_SetPriority(kData1IrqnCh1, 0, 0);
  27.         HAL_NVIC_EnableIRQ(kData1IrqnCh1);
  28.     }
  29.     else if(channel == 2)
  30.     {
  31.         kData0ClockCh2;
  32.         kData1ClockCh2;
  34.         GPIO_InitStruct.Pin = kData0PinCh2;
  35.         GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  36.         GPIO_InitStruct.Pull = GPIO_NOPULL;
  37.         GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
  38.         HAL_GPIO_Init(kData0PortCh2, &GPIO_InitStruct);
  40.         GPIO_InitStruct.Pin = kData1PinCh2;
  41.         GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  42.         GPIO_InitStruct.Pull = GPIO_NOPULL;
  43.         GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
  44.         HAL_GPIO_Init(kData1PortCh2, &GPIO_InitStruct);
  46.         // NVIC config
  47.         HAL_NVIC_SetPriority(kData0IrqnCh2, 0, 0);
  48.         HAL_NVIC_EnableIRQ(kData0IrqnCh2);
  50.         HAL_NVIC_SetPriority(kData1IrqnCh2, 0, 0);
  51.         HAL_NVIC_EnableIRQ(kData1IrqnCh2);
  52.     }
  53. }

Biblioteka obsługuje dwa kanały wieganda. W związku z tym znajduje się w funkcji osobne włączenie dla każdego z nich. Domyślne pinu to:

  1. /* @brief: Definition of pins for wiegand CH1 */
  2. #define kData0PortCh1       GPIOA
  3. #define kData0PinCh1        GPIO_PIN_8
  4. #define kData0ClockCh1      __GPIOA_CLK_ENABLE()
  5. #define kData0IrqnCh1       EXTI9_5_IRQn
  7. #define kData1PortCh1       GPIOB
  8. #define kData1PinCh1        GPIO_PIN_15
  9. #define kData1ClockCh1      __GPIOB_CLK_ENABLE()
  10. #define kData1IrqnCh1       EXTI15_10_IRQn
  12. /* @brief: Definition of pins for wiegand CH2 */
  13. #define kData0PortCh2       GPIOB
  14. #define kData0PinCh2        GPIO_PIN_8
  15. #define kData0ClockCh2      __GPIOA_CLK_ENABLE()
  16. #define kData0IrqnCh2       EXTI9_5_IRQn
  18. #define kData1PortCh2       GPIOB
  19. #define kData1PinCh2        GPIO_PIN_9
  20. #define kData1ClockCh2      __GPIOB_CLK_ENABLE()
  21. #define kData1IrqnCh2       EXTI9_5_IRQn

Oprócz tego przygotowałem także funkcje pozwalającą na inicjalizacje pinów innych niż domyślne, natomiast trzeba do tego przygotować obsługę przerwań.

  1. void wiegandInitPinsCustom(GPIO_TypeDef  *GPIOxD0, uint16_t PinD0, GPIO_TypeDef  *GPIOxD1, uint16_t PinD1)
  2. {
  3.     uint16_t dataPin[2] = {PinD0, PinD1};
  5.     GPIO_InitTypeDef   GPIO_InitStruct;
  7.     PORT_CLOCK_ENABLE(GPIOxD0);
  8.     PORT_CLOCK_ENABLE(GPIOxD1);
  10.     GPIO_InitStruct.Pin = PinD0;
  11.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  12.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  13.     GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
  14.     HAL_GPIO_Init(GPIOxD0, &GPIO_InitStruct);
  16.     GPIO_InitStruct.Pin = PinD1;
  17.     GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  18.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  19.     GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
  20.     HAL_GPIO_Init(GPIOxD1, &GPIO_InitStruct);
  22.     for(uint8_t i = 0; i<2; i++)
  23.     {
  24.         /* Set proper NVIC for pins */
  25.         if(dataPin[i] == GPIO_PIN_0){
  26.             HAL_NVIC_SetPriority(EXTI0_IRQn, 0x01, 0);
  27.             HAL_NVIC_EnableIRQ(EXTI0_IRQn);
  28.         }
  29.         else if(dataPin[i] == GPIO_PIN_1){
  30.             HAL_NVIC_SetPriority(EXTI1_IRQn, 0x01, 0);
  31.             HAL_NVIC_EnableIRQ(EXTI1_IRQn);
  32.         }
  33.         else if(dataPin[i] == GPIO_PIN_2){
  34.             HAL_NVIC_SetPriority(EXTI2_IRQn, 0x01, 0);
  35.             HAL_NVIC_EnableIRQ(EXTI2_IRQn);
  36.         }
  37.         else if(dataPin[i] == GPIO_PIN_3){
  38.             HAL_NVIC_SetPriority(EXTI3_IRQn, 0x01, 0);
  39.             HAL_NVIC_EnableIRQ(EXTI3_IRQn);
  40.         }
  41.         else if(dataPin[i] == GPIO_PIN_4){
  42.             HAL_NVIC_SetPriority(EXTI4_IRQn, 0x01, 0);
  43.             HAL_NVIC_EnableIRQ(EXTI4_IRQn);
  44.         }
  45.         else if((dataPin[i] >= GPIO_PIN_5) && (dataPin[i] <= GPIO_PIN_9)){
  46.             HAL_NVIC_SetPriority(EXTI9_5_IRQn, 0x01, 0);
  47.             HAL_NVIC_EnableIRQ(EXTI9_5_IRQn);
  48.         }
  49.         else if((dataPin[i] >= GPIO_PIN_10) && (dataPin[i] <= GPIO_PIN_15)){
  50.             HAL_NVIC_SetPriority(EXTI15_10_IRQn, 0x01, 0);
  51.             HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
  52.         }
  53.     }
  54. }

Funkcje odbierające dane w przerwaniach:

  1. void EXTI9_5_IRQHandler(void)
  2. {
  3.   if(__HAL_GPIO_EXTI_GET_IT(kData0PinCh1) != RESET)
  4.   {
  5.     __HAL_GPIO_EXTI_CLEAR_IT(kData0PinCh1);
  7.     if((HAL_GPIO_ReadPin(kData0PortCh1, kData0PinCh1)==GPIO_PIN_RESET) &&
  8.         (HAL_GPIO_ReadPin(kData1PortCh1, kData1PinCh1)==GPIO_PIN_SET))
  9.     {
  10.         if(wiegandData.wiegandDataPosition < (kWiegandCard37Bits - 1))
  11.         {
  12.             wiegandData.wiegandStartReceive = 1;
  13.             wiegandData.wiegandTimeout = 0;
  14.    
  15.             *(wiegandData.wiegandDat + wiegandData.wiegandDataPosition) = 0;
  16.    
  17.             wiegandData.wiegandDataPosition++;
  18.         }
  19.      }
  20.   }
  22.   if(__HAL_GPIO_EXTI_GET_IT(kData0PortCh2) != RESET)
  23.   {
  24.     __HAL_GPIO_EXTI_CLEAR_IT(kData0PortCh2);
  26.     if((HAL_GPIO_ReadPin(kData0PortCh2, kData0PortCh2)==GPIO_PIN_RESET) &&
  27.         (HAL_GPIO_ReadPin(kData1PortCh2, kData1PortCh2)==GPIO_PIN_SET))
  28.     {
  29.         if(wiegandDataCh2.wiegandDataPosition < (kWiegandCard37Bits - 1))
  30.         {
  31.             wiegandDataCh2.wiegandStartReceive = 1;
  32.             wiegandDataCh2.wiegandTimeout = 0;
  33.    
  34.             *(wiegandDataCh2.wiegandDat + wiegandDataCh2.wiegandDataPosition) = 0;
  35.    
  36.             wiegandDataCh2.wiegandDataPosition++;
  37.         }
  38.      }
  39.   }
  41.   if(__HAL_GPIO_EXTI_GET_IT(kData1PortCh2) != RESET)
  42.   {
  43.     __HAL_GPIO_EXTI_CLEAR_IT(kData1PortCh2);
  45.     if((HAL_GPIO_ReadPin(kData1PortCh2, kData1PortCh2)==GPIO_PIN_RESET) &&
  46.         (HAL_GPIO_ReadPin(kData0PortCh2, kData0PortCh2)==GPIO_PIN_SET))
  47.     {
  48.         if(wiegandDataCh2.wiegandDataPosition < (kWiegandCard37Bits - 1))
  49.         {
  50.             wiegandDataCh2.wiegandStartReceive = 1;
  51.             wiegandDataCh2.wiegandTimeout = 0;
  52.    
  53.             *(wiegandDataCh2.wiegandDat + wiegandDataCh2.wiegandDataPosition) = 0;
  55.             wiegandDataCh2.wiegandDataPosition++;
  56.         }
  57.      }
  58.   }
  59. }
  61. void EXTI15_10_IRQHandler(void)
  62. {
  63.   if(__HAL_GPIO_EXTI_GET_IT(kData1PinCh1) != RESET)
  64.   {
  65.     __HAL_GPIO_EXTI_CLEAR_IT(kData1PinCh1);
  67.     if((HAL_GPIO_ReadPin(kData1PortCh1, kData1PinCh1)==GPIO_PIN_RESET) &&
  68.         (HAL_GPIO_ReadPin(kData0PortCh1, kData0PinCh1)==GPIO_PIN_SET))
  69.     {
  70.         if(wiegandData.wiegandDataPosition < (kWiegandCard37Bits - 1))
  71.         {
  72.             wiegandData.wiegandStartReceive = 1;
  73.             wiegandData.wiegandTimeout = 0;
  74.    
  75.             *(wiegandData.wiegandDat + wiegandData.wiegandDataPosition) = 1;
  76.            
  77.             wiegandData.wiegandDataPosition++;
  78.         }
  79.     }
  80.   }
  81. }

Przerwanie odbiera maksymalnie 37 bitów. Wcześniejsze przerwanie programu następuje po przekroczeniu czasu oczekiwania.

Sprawdzanie poprawności transmisji, jeśli w kodzie występują bity parzystości oraz nieparzystości. Na pozycji zerowej sprawdzany jest bit parzystości, ostatnia pozycja sprawdza bit nieparzystości. Należy pamiętać, że przed rozpoczęciem obsługi ramki danych należy wiedzieć jakie ilości danych mogą przyjść od układu do mikrokontrolera. Pozwoli to na bezpieczniejszą obsługę interfejsu, niż obsługiwanie jakiejkolwiek odebranej ramki, której długość będzie nieznana.

Poniżej znajdują się funkcje sprawdzające odebraną ramkę danych:

  1. static uint8_t wiegandCheckDataFrame(wiegandData_t * wiegandInfo,
  2.                                         enum wiegandReceiveDataNumber receiveFormat)
  3. {
  4.     if(receiveFormat == wiegand37Bit)
  5.     {
  6.         /* Check data frame */
  7.         if(wiegandCheckEvenParity(wiegandInfo, 0, wiegand37Bit) == 0){
  8.             return 0; /* Error wrong frame */
  9.         }
  11.         if(wiegandCheckOddParity(wiegandInfo, 36, wiegand37Bit) == 0){
  12.             return 0; /* Error wrong frame */
  13.         }
  14.     }
  15.     else if(receiveFormat == wiegand26Bit)
  16.     {
  17.         /* Check data frame */
  18.         if(wiegandCheckEvenParity(wiegandInfo, 0, wiegand26Bit) == 0){
  19.             return 0; /* Error wrong frame */
  20.         }
  22.         if(wiegandCheckOddParity(wiegandInfo, 25, wiegand26Bit) == 0){
  23.             return 0; /* Error wrong frame */
  24.         }
  25.     }
  27.     return 1; /* Frame OK */
  28. }
  29. static uint8_t wiegandCheckEvenParity(wiegandData_t * wiegandInfo, uint8_t evenParityPosition,enum wiegandReceiveDataNumber receiveFormat)
  30. {
  31.     uint8_t number_of_one = 0;
  32.     uint8_t even_parity_bit = 0;
  34.     if(receiveFormat == wiegand37Bit)
  35.     {
  36.         for(uint8_t i=1; i<=18; i++)
  37.         {
  38.             if(wiegandInfo->wiegandDat[i] == 1) { number_of_one++; }
  39.         }
  41.         if(number_of_one % 2 == 0) { even_parity_bit = 0; }
  42.         else                       { even_parity_bit = 1; }
  44.         if(wiegandInfo->wiegandDat[evenParityPosition] == even_parity_bit)
  45.         {
  46.             return 1;
  47.         }
  48.     }
  49.     else if(receiveFormat == wiegand26Bit)
  50.     {
  51.         for(uint8_t i=1; i<=12; i++)
  52.         {
  53.             if(wiegandInfo->wiegandDat[i] == 1) { number_of_one++; }
  54.         }
  56.         if(number_of_one % 2 == 0) { even_parity_bit = 0; }
  57.         else                       { even_parity_bit = 1; }
  59.         if(wiegandInfo->wiegandDat[evenParityPosition] == even_parity_bit)
  60.         {
  61.             return 1;
  62.         }
  63.     }
  64.     return 0; /* Error */
  65. }
  66. static uint8_t wiegandCheckOddParity(wiegandData_t * wiegandInfo, uint8_t oddParityPosition, enum wiegandReceiveDataNumber receiveFormat)
  67. {
  68.     uint8_t number_of_one = 0;
  69.     uint8_t odd_parity_bit = 0;
  71.     if(receiveFormat == wiegand37Bit)
  72.     {
  73.         for(uint8_t i=18; i<=35; i++)
  74.         {
  75.             if(wiegandInfo->wiegandDat[i] == 1) {   number_of_one++;    }
  76.         }
  78.         if(number_of_one % 2 == 0)  {   odd_parity_bit = 1; }
  79.         else                        {   odd_parity_bit = 0; }
  81.         if(wiegandInfo->wiegandDat[oddParityPosition] == odd_parity_bit)
  82.         {
  83.             return 1;
  84.         }
  85.     }
  86.     else if(receiveFormat == wiegand26Bit)
  87.     {
  88.         for(uint8_t i=13; i<=24; i++)
  89.         {
  90.             if(wiegandInfo->wiegandDat[i] == 1) { number_of_one++; }
  91.         }
  93.         if(number_of_one % 2 == 0) { odd_parity_bit = 1; }
  94.         else                       { odd_parity_bit = 0; }
  96.         if(wiegandInfo->wiegandDat[oddParityPosition] == odd_parity_bit)
  97.         {
  98.             return 1;
  99.         }
  100.     }
  102.     return 0; /* Error */
  103. }

Wypisanie odebranych danych na ekranie:

  1. static void wiegandDecode37BitNumber(wiegandData_t *wiegandInfo)
  2. {
  3.     #if DEBUG_USART == 1
  4.     char data[50] = {0};
  5.     #endif
  7.     /* Get facility code */
  8.     for(uint8_t i=1; i<=16; i++)
  9.     {
  10.         if(*(wiegandInfo->wiegandDat + i) == 1){
  11.             wiegandInfo->facilityCode = wiegandInfo->facilityCode << 1;
  12.             wiegandInfo->facilityCode = wiegandInfo->facilityCode + 0x01;
  13.         }
  14.         else{
  15.             wiegandInfo->facilityCode = wiegandInfo->facilityCode << 1;
  16.         }
  17.     }
  19.     /* Get card number */
  20.     for(uint8_t i=17; i<=35; i++)
  21.     {
  22.         if(*(wiegandInfo->wiegandDat + i) == 1){
  23.             wiegandInfo->readCardNumber = wiegandInfo->readCardNumber << 1;
  24.             wiegandInfo->readCardNumber = wiegandInfo->readCardNumber + 0x01;
  25.         }
  26.         else{
  27.             wiegandInfo->readCardNumber = wiegandInfo->readCardNumber << 1;
  28.         }
  29.     }
  31.     #if DEBUG_USART == 1
  32.     sprintf(data, "FacilityCode %lu", wiegandInfo->facilityCode);
  33.     DebugMsg(data);
  34.     sprintf(data, "CardNumber %lu", wiegandInfo->readCardNumber);
  35.     DebugMsg(data);
  36.     #endif
  37. }
  38. static void wiegandDecode26BitNumber(wiegandData_t *wiegandInfo)
  39. {
  40.     #if DEBUG_USART == 1
  41.     char data[50] = {0};
  42.     #endif
  44.     /* Get facility code */
  45.     for(uint8_t i=1; i<=12; i++)
  46.     {
  47.         if(*(wiegandInfo->wiegandDat + i) == 1){
  48.             wiegandInfo->facilityCode = wiegandInfo->facilityCode << 1;
  49.             wiegandInfo->facilityCode = wiegandInfo->facilityCode + 0x01;
  50.         }
  51.         else{
  52.             wiegandInfo->facilityCode = wiegandInfo->facilityCode << 1;
  53.         }
  54.     }
  56.     /* Get card number */
  57.     for(uint8_t i=13; i<=24; i++)
  58.     {
  59.         if(*(wiegandInfo->wiegandDat + i) == 1){
  60.             wiegandInfo->readCardNumber = wiegandInfo->facilityCode << 1;
  61.             wiegandInfo->readCardNumber = wiegandInfo->facilityCode + 0x01;
  62.         }
  63.         else{
  64.             wiegandInfo->readCardNumber = wiegandInfo->facilityCode << 1;
  65.         }
  66.     }
  68.     #if DEBUG_USART == 1
  69.     sprintf(data, "FacilityCode %lu", wiegandInfo->facilityCode);
  70.     DebugMsg(data);
  72.     sprintf(data, "cardNumber %lu", wiegandInfo->facilityCode);
  73.     DebugMsg(data);
  74.     #endif
  75. }

Główna funkcja programu którą należy wywoływać w pętli while wygląda następująco:

  1. void wiegandMainFunction(void)
  2. {
  3.     uint8_t returnValue = 0xFF;
  4.     returnValue = wiegandCheckReceiveDataFormat(&wiegandData);
  6.     /* Check first channel */
  7.     switch(returnValue) {
  8.         case wiegand37Bit:  /* card 37 bits */
  9.             wiegandDecode37BitNumber(&wiegandData);
  10.         break;
  11.         case wiegand26Bit: /* card 26 bits */
  12.             wiegandDecode26BitNumber(&wiegandData);
  13.         break;
  14.         default:
  15.             /* wrong card number */
  16.         break;
  17.     }
  19.     /* Check second channel */
  20.     returnValue = wiegandCheckReceiveDataFormat(&wiegandDataCh2);
  21.     switch(returnValue) {
  22.         case wiegandNoData:
  23.             return; /* No data  */
  24.         break;
  25.         case wiegandWrongFrame:
  26.             return;/* wiegandWrongFrame */
  27.         break;
  28.         case wiegand37Bit:  /* card 37 bits */
  29.             wiegandDecode37BitNumber(&wiegandDataCh2);
  30.         break;
  31.         case wiegand26Bit: /* card 26 bits */
  32.             wiegandDecode26BitNumber(&wiegandDataCh2);
  33.         break;
  34.         default:
  35.             /* wrong card number */
  36.         break;
  37.     }
  38.     ClearStructureData();
  39. }

Funkcja odpowiedzialna za sprawdzenie formatu i zwrócenie odpowiedniej informacji:

  1. static enum wiegandReceiveDataNumber wiegandCheckReceiveDataFormat(wiegandData_t * wiegandInfo)
  2. {
  3.     char data[50] = {0};
  4.  
  5.     /* check number of receive bits and calculate parity */
  6.     if(wiegandInfo->wiegandTimeout == kWiegandTimeoutMs && (wiegandInfo->wiegandStartReceive == 1))
  7.     {
  8.         /* Flag for block operation in HAL_TIM_PeriodElapsedCallback go zero */
  9.         wiegandInfo->wiegandStartReceive = 0;
  10.  
  11.         if(wiegandInfo->wiegandDataPosition == 0)   {
  12.             /* No data in buffer */
  13.         }
  14.         else if(wiegandInfo->wiegandDataPosition == (kWiegandCard37Bits))
  15.         {
  16.             #if DEBUG_USART == 1
  17.             for(uint8_t i=0; i<37; i++)
  18.             {
  19.                 sprintf(data, "[%u]", i);
  20.                 Usart_Uart_SendString(USART1, data, ZERO);
  21.                 Usart_Uart_SendNumber(USART1, (uint32_t)wiegandInfo->wiegandDat[i]);
  22.                 Usart_Uart_SendString(USART1, " ", CR_LF);
  23.             }
  24.             #endif
  25.  
  26.             if(wiegandCheckDataFrame(wiegandInfo, wiegand37Bit) == 1)
  27.             {
  28.                 wiegandInfo->wiegandDataType = wiegand37Bit;
  29.                 return wiegand37Bit;
  30.             }
  31.             wiegandInfo->wiegandDataType = wiegandWrongFrame;
  32.             wiegandInfo->wiegandDataPosition = 0;
  33.             return wiegandWrongFrame;
  34.         }
  35.         else if(wiegandInfo->wiegandDataPosition == kWiegandCard26Bits)
  36.         {
  37.             #if DEBUG_USART == 1
  38.             for(uint8_t i=0; i<26; i++)
  39.             {
  40.                 sprintf(data, "[%u]", i);
  41.                 Usart_Uart_SendString(USART1, data, ZERO);
  42.                 Usart_Uart_SendNumber(USART1, (uint32_t)wiegandInfo->wiegandDat[i]);
  43.                 Usart_Uart_SendString(USART1, " ", CR_LF);
  44.             }
  45.             #endif
  46.  
  47.             if(wiegandCheckDataFrame(wiegandInfo, wiegand26Bit) == 1)
  48.             {
  49.                 wiegandInfo->wiegandDataPosition = wiegand26Bit;
  50.                 return 3;
  51.             }
  52.             wiegandInfo->wiegandDataType = wiegandWrongFrame;
  53.             wiegandInfo->wiegandDataPosition = 0;
  54.             return wiegandWrongFrame;
  55.  
  56.         }
  57.         else
  58.         {
  59.             sprintf(data, "odebrane: %u", wiegandInfo->wiegandDataPosition);
  60.             DebugMsg(data);
  61.  
  62.             for(uint8_t i=0; i<37; i++)
  63.             {
  64.                 sprintf(data, "[%u]", i);
  65.                 Usart_Uart_SendString(USART1, data, ZERO);
  66.                 Usart_Uart_SendNumber(USART1, (uint32_t)wiegandInfo->wiegandDat[i]);
  67.                 Usart_Uart_SendString(USART1, " ", CR_LF);
  68.             }
  69.             wiegandInfo->wiegandDataPosition = 0;
  70.         }
  71.     }
  72.     return 1;
  73. }

Jest ona wywoływana po przekroczeniu czasu oczekiwania na kolejny bit oraz gdy rozpoczęto odbieranie danych.

Pliki z biblioteką do wieganda można pobrać pod tym linkiem.
Autor: o
Etykiety: ,