[23] STM32F4 - Obsługa enkodera inkrementalnego

W tym poście chciałbym opisać w jaki sposób obsłużyć enkoder inkrementalny. W przykładzie wykorzystałem enkoder, który można znaleźć pod tym linkiem oraz drugi dla jakiego sprawdzałem czyli ten. Oba mają po 24 kroki na pełny obrót.

Podłączenie

Spotkałem się z czterema metodami podłączenia enkodera do mikrokontrolera.

Pierwsze podłączenie dotyczy podpięcia dwóch rezystorów o wartości 10k do stanu wysokiego. Często jest on stosowany w dokumentacji od enkodera z różnymi rezystorami 10k lub 5k.

Drugi sposób dodatkowo zawiera kondensatory o wartości 100nF, Jest to najprostszy rekomendowany sposób. Natomiast mogą wystąpić pewne problemy dotyczące czasu narostu zboczy oraz poziomu tego sygnału.

Czas na trzeci sposób który zaobserwowałem na blogu Atnel. W nim zmienione są wartości kondensatorów na 10nF oraz dodano rezystory wpięte szeregowo w układ. Ja korzystałem z takiej konfiguracji przy jednym z projektów:

Poniżej jeszcze jeden sposób dotyczący podłączenia, tym razem zaczerpnięty z dokumentacji producenta wykorzystywanych enkoderów. Jest to właściwie niewielka modyfikacja powyższego schematu:

Programowanie

Aby poprawnie obsłużyć enkoder wykorzystałem dwa piny mikrokontrolera, z czego jeden z nich generuje przerwania.

Na początku rozpocznę od pliku nagłówkowego, w którym została zdefiniowana potrzebna struktury dla danych z enkodera oraz deklaracje funkcji:

1. typedef struct {
2.     int16_t Rotation_Value;
3.     uint8_t Last_Pin_A_Status;
4.     int16_t Encoder_Counter;
5.     GPIO_TypeDef* GPIO_A;
6.     GPIO_TypeDef* GPIO_B;
7.     uint16_t GPIO_PIN_A;
8.     uint16_t GPIO_PIN_B;
9. }ENCODER_t;

Poniżej prototypy trzech funkcji:

1. void Set_Basic_Data_Struct(ENCODER_t* Encoder_t)
2. void Encoder_Init_Module(ENCODER_t* Encoder_t);
3. void Encoder_Get_Rotation_Value(ENCODER_t* Encoder_t));

Pierwsza funkcja ustawia domyślne wartości dla struktury, druga natomiast pozwala na włączenie EXTI oraz GPIO. Trzecia jest obsługiwana w przerwaniu, sprawdza stan przycisku i określa kierunek obrotu.

1. void Set_Basic_Data_Struct(ENCODER_t* Encoder_t)
2. {
3.     //Wprowadz dane do struktury
4.     Encoder_t->GPIO_A = GPIOD;
5.     Encoder_t->GPIO_B = GPIOD;
6.     Encoder_t->GPIO_PIN_A = GPIO_Pin_0;
7.     Encoder_t->GPIO_PIN_B = GPIO_Pin_1;
8.    
9.     Encoder_t->Encoder_Counter = 0;
10.     Encoder_t->Rotation_Value = 0;
11.     Encoder_t->Last_Pin_A_Status = 1;
12. }

Następnie wspomniane wcześniej funkcja włącza piny, przypisuje jednemu z nich przerwanie, drugi natomiast jest ustawiony jako wejście. Nie ma sensu ustawiania przerwania na obu zboczach, ponieważ i tak podczas pracy z enkoderem oba zostaną wyzwolone, bez względu na to w którą stronę nastąpi obrót.

Pierwsza funkcja ma za zadanie włączenie enkodera, czyli jego wyprowadzeń, oraz zegarów. Układ został podłączony do pinów PD0 oraz PD1. 

1. void Encoder_Init_Module(ENCODER_t* struct_data)
2. {
3.   GPIO_InitTypeDef GPIO_In;
4.   EXTI_InitTypeDef EXTI_In;
5.   NVIC_InitTypeDef NVIC_In;
6.    
7.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
8.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
9.    
10.   //Ustawienie pinu oraz przypisanie przerwania
11.   GPIO_In.GPIO_Mode = GPIO_Mode_IN;
12.   GPIO_In.GPIO_OType = GPIO_OType_PP;
13.   GPIO_In.GPIO_Pin = Encoder_t->GPIO_PIN_A;
14.   GPIO_In.GPIO_PuPd = GPIO_PuPd_UP;
15.   GPIO_In.GPIO_Speed = GPIO_Speed_100MHz;
16.   GPIO_Init(Encoder_t->GPIO_A, &GPIO_In);
17.    
18.   SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOD, EXTI_PinSource0);
20.   EXTI_In.EXTI_Line = EXTI_Line0;
21.   EXTI_In.EXTI_LineCmd = ENABLE;
22.   EXTI_In.EXTI_Mode = EXTI_Mode_Interrupt;
23.   EXTI_In.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
24.   EXTI_Init(&EXTI_In);
26.   NVIC_In.NVIC_IRQChannel = EXTI0_IRQn;
27.   NVIC_In.NVIC_IRQChannelPreemptionPriority = 0x00;
28.   NVIC_In.NVIC_IRQChannelSubPriority = 0x00;
29.   NVIC_In.NVIC_IRQChannelCmd = ENABLE;
30.   NVIC_Init(&NVIC_In);
31.    
32.   //Drugi z pinów jest ustawiany jako wyjscie
33.   GPIO_In.GPIO_Pin = Encoder_t->GPIO_PIN_B;
34.   GPIO_In.GPIO_PuPd = GPIO_PuPd_UP;
35.   GPIO_In.GPIO_OType = GPIO_OType_PP;
36.   GPIO_In.GPIO_Mode = GPIO_Mode_IN;
37.   GPIO_In.GPIO_Speed = GPIO_Speed_25MHz;
38.   GPIO_Init(Encoder_t->GPIO_B, &GPIO_In);
39. }

Poniższa funkcja ma za zadanie sprawdzenie wartości na enkoderze. Na samym początku do zmiennych wprowadzane są stany z obu pinów. Następnie sprawdzane jest czy stan na przycisku pierwszym się zmienił. jeśli tak na następuje sprawdzenie warunków na podstawie nowej wartości ostatniego stany przycisku. W instrukcjach warunkowych można zmienić wartości maksymalnego odczytu z enkodera, w tym momencie jest on ustawiony na wartość 24, czyli po pełnym obrocie enkodera jest on zerowany.

1. void Encoder_Get_Rotation_Value(ENCODER_t* struct_data)
2. {
3.     uint8_t actual_a;
4.     uint8_t actual_b;
5.    
6.     //Odczytaj dane
7.     actual_a = (((struct_data->GPIO_A)->IDR & (struct_data->GPIO_PIN_A)) == 0 ? 0 : 1);
8.     actual_b = (((struct_data->GPIO_B)->IDR & (struct_data->GPIO_PIN_B)) == 0 ? 0 : 1);
9.    
10.     //Sprawdzenie stanu, czy inna wartosc na linii
11.     if (actual_a != struct_data->Last_Pin_A_Status)
12.     {
13.         //Jesli tak to przypisz nowa
14.         struct_data->Last_Pin_A_Status = actual_a;
15.         if (struct_data->Last_Pin_A_Status == 0)
16.         {
17.             if (actual_b == 1)
18.                 {
19.                     if(struct_data->Encoder_Counter == 24)
20.                     {
21.                         struct_data->Encoder_Counter= 24;
22.                     }
23.                     else
24.                     {
25.                         struct_data->Encoder_Counter++;
26.                     }
27.                 }
28.             }
29.             else
30.             {
31.                 if (actual_b == 1)
32.                 {
33.                     if(struct_data->Encoder_Counter== 0)
34.                     {
35.                         struct_data->Encoder_Counter= 0;
36.                     }
37.                     else
38.                     {
39.                         struct_data->Encoder_Counter--;
40.                     }
41.                 }
42.         }
43.     }
44. }

Teraz czas na obsługę przerwania:

1. void EXTI0_IRQHandler()
2. {
3.     if (EXTI_GetITStatus(EXTI_Line0) != RESET)
4.     {
5.         EXTI_ClearITPendingBit(EXTI_Line0);
6.         Encoder_Get_Rotation_Value(&Encoder_t);
7.     }
8. }

Poniżej wklejam jeszcze część do włączenia UART-u funkcję main dla programu:

1. struct __FILE {
2.     int parametr;
3. };
4. //Stworzenie zmiennej z struktury FILE
5. //Parametr musi miec taka nazwe
6. FILE __stdout;
8. void USART_Initialize(void)
9. {
10.      //Inicjalizacja kontrolera przerwan
11.      NVIC_InitTypeDef NVIC_InitStruct;
12.    
13.      //konfiguracja ukladu USART
14.      USART_InitTypeDef USART_InitStructure;
15.      
16.      //Ustawienie kanalu IRQ
17.      NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
18.    
19.      //Wlaczenie zegara dla USART1
20.      RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
21.      
22.      //Ustawienie predkosci transmisji 9600bps
23.      USART_InitStructure.USART_BaudRate = 9600;
24.      //Dlugosc wysylanego slowa
25.      USART_InitStructure.USART_WordLength = USART_WordLength_8b;
26.      //Ustawienie jednego bitu stopu
27.      USART_InitStructure.USART_StopBits = USART_StopBits_1;
28.      //Kontrola parzystosci wylaczona
29.      USART_InitStructure.USART_Parity = USART_Parity_No;
30.      //Wylaczenie kontroli przeplywu danych
31.      USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
32.      //Tryb pracy linii odpowiednio odbior i nadawanie
33.      USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
34.      
35.      //Konfiguracja ukladu
36.      USART_Init(USART1, &USART_InitStructure);
37.      //Wlaczenie USART1
38.      USART_Cmd(USART1, ENABLE);
39.      
40.      //Wlaczenie przerwania na RX1
41.      USART1->CR1 |= USART_CR1_RXNEIE;
42.    
43.      //Wprowadzenie ustawien do przerwan
44.      NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
45.      NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
46.      NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
47.      NVIC_Init(&NVIC_InitStruct);
48. }
49. void GPIO_Initialize(void)
50. {
51.      //konfigurowanie portow GPIO
52.      GPIO_InitTypeDef  GPIO_In;
53.      RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
54.      
55.      //TX dla pinu PB6
56.      GPIO_In.GPIO_Pin = GPIO_Pin_6;
57.      GPIO_In.GPIO_PuPd = GPIO_PuPd_UP;
58.      GPIO_In.GPIO_OType = GPIO_OType_PP;
59.      GPIO_In.GPIO_Mode = GPIO_Mode_AF;
60.      GPIO_In.GPIO_Speed = GPIO_Speed_100MHz;
61.      GPIO_Init(GPIOB, &GPIO_In);
62.      
63.      //RX dla pinu PB7
64.      GPIO_In.GPIO_Pin = GPIO_Pin_7;
65.      GPIO_In.GPIO_Mode = GPIO_Mode_AF;
66.      GPIO_In.GPIO_PuPd = GPIO_PuPd_UP;
67.      GPIO_In.GPIO_OType = GPIO_OType_PP;
68.      GPIO_In.GPIO_Speed = GPIO_Speed_100MHz;
69.      GPIO_Init(GPIOB, &GPIO_In);
70.      
71.      //Wlaczenie transmisji na podanych pinach
72.      GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_USART1);
73.      GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_USART1);
74. }
75. void USART_Send(volatile char *c)
76. {
77.      //Petla dziala do puki bedzie jakis znak do wyslania
78.      while(*c)
79.      {
80.         //Sprawdza czy rejestr danych zostal oprózniony
81.         while( !(USART1->SR & 0x00000040) );
82.         //Przeslij dane,
83.         USART_SendData(USART1, *c);
84.         *c++;
85.      }
86. }
87. //Funkcja wysylajaca dane do strumienia
88. //Jej nazwy nie mozna zmieniac
89. int fputc(int ch, FILE *f)
90. {
91.     volatile char c = ch;
92.    
93.       //Wyslanie danych
94.         USART1->DR = (uint16_t)(c & 0x01FF);
95.         //Odczekanie az bufor zostanie oprozniony
96.       while (!((USART1)->SR & USART_FLAG_TXE))
97.         {}
98.        
99.     return ch;
100. }
101. void Send_Charc(volatile char c)
102. {
103.      while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
104.      USART_SendData(USART1, c);
105. }

1. int main(void) {
3.     SystemInit();
4.     //UART
5.     GPIO_Initialize();
6.     USART_Initialize();
8.     //Enkoder
9.     Set_Basic_Data_Struct(&Encoder_t);
10.     Encoder_Init_Module(&Encoder_t);
12.     while (1)
13.     {
14.         printf("War: %d\r\n", ENCODER_t.Rotation_Value);
15.         delay_ms(1000);
16.     }
17. }

Na koniec chciałbym jeszcze dodać, że im droższy enkoder tym prawdopodobnie mniej czasu zajmie odpowiednie przygotowanie oprogramowania. Dodatkowo przyjemność z użytkowania będzie znacznie wyższa.

Głównie chodzi o występujący "klik" pomiędzy przejściami na kolejny krok. Dla enkodera wspomnianego na początku kliknięcia pomiędzy pozycjami są dosyć mocno zaznaczone. Dla drugiego enkodera który testowałem(czyli tego) można wyczuć co drugi krok. Czyli zmiana stanu odbywa się na nim co pół kroku. No ale coś za coś pierwszy kosztuje około 18 zł, drugi około 5 zł.