Projekty mikrokontrolerowe często potrzebują dokonywać pomiarów sygnałów analogowych. Niestety same rozumieją tylko ciągi cyfrowe, które mogą przybrać tylko dwa stany. Najczęściej jest to poziom masy oraz zasilania. Aby zmierzyć wartość analogową należy użyć przetwornika analogowo cyfrowego – w skrócie ADC. Praktycznie każdy współczesny mikrokontroler jest w taki przetwornik wyposażony. STM32 oczywiście też.

ADC w STM32

Układ przetwornika analogowo cyfrowego w mikrokontrolerach STM32 jest dosyć rozbudowany. Niektóre z MCU mają nawet dwa, a nawet więcej takich przetworników. Do głównych cech wbudowanych ADC należą:

• Konfigurowalna rozdzielczość do 12 bitów
• Mnogość przerwań np. od zakończenia konwersji zwykłej, wstrzykiwanej lub od analogowego watchdoga
• Tryb konwersji pojedynczy, lub ciągły
• Automatyczne skanowanie kanałów
• Programowalny czas próbkowania
• Generowanie żądania odczytu przez DMA

To tylko najważniejsze rzeczy, które wybrałem z dokumentacji. Ok, ale jak działa taki przetwornik?

Próbkowanie

Sygnał analogowy może przybierać różne wartości napięcia. Do tego jest on ciągły w czasie. Próbkowanie polega na wyznaczeniu momentów pomiarowych sygnału analogowego, który podawany jest na wejście ADC. W efekcie próbkowania dostajemy pojedyncze punkty, które należą do wykresu ciągłego.

Bardzo ważne jest tutaj twierdzenie o próbkowaniu (Kotielnikowa-Shannona). Mówi ono o tym, że aby w zadowalający sposób móc odtworzyć ze spróbkowanego sygnału cyfrowego oryginalny sygnał analogowy, należy próbkować z częstotliwością co najmniej dwukrotnie większą od najwyższej częstotliwości składowej sygnału.

Krótko mówiąc – próbkując sygnał sinusoidalny 1 kHz, powinieneś robić to, co najmniej z częstotliwością 2 kHz. Przykład bliższy życiu – podstawowe próbkowanie dźwięku wykonuje się z częstotliwością 44,1 kHz, ponieważ przyjmuje się, że sygnał mowy ma najwyższą częstotliwość składową około 20 kHz.

Kwantowanie

Jest to tzw. cyfrowy pomiar. Próbkowana wielkość przedstawiana jest w postaci najbliższej wartości cyfrowej. Kwantowanie jest silnie uzależnione od rozdzielczości przetwornika. Mierzona wartość wyrażona jest bowiem w liczbie kwantów, czyli liczbie najmniejszych części, na które można podzielić pełny zakres napięciowy przetwornika.

Mając 12-bitowy przetwornik, jego rozdzielczość wynosi 4096 i tyle mamy tych kwantów. Dajmy na to, że napięcie referencyjne, czyli to, wobec którego porównujemy nasz sygnał wynosi 3,3 V. Zmierzona wartość 4095 odpowiada temu napięciu. Podając 1 V na wejście ADC, próbka będzie miała wartość 1/3,3 * 4095 = 1240,909. Jak widzisz wartość ta nie wypada idealnie na równym kwancie, więc przetwornik przyporządkuje ją do 1241. Na tym polega kwantyzacja 🙂

Metoda, jakiej używa przetwornik jest nieco inna niż takie mnożenie napięć. Przetwornik nie zna wartości napięcia odniesienia. Może na przykład porównywać sygnał analogowy z narastającym sygnałem schodkowym w zakresie napięcia odniesienia, a następnie zapamiętanie liczby tych schodków. Pamiętaj, że po tym etapie dostajemy liczbę kwantów, a nie wartość napięcia.

Kodowanie

Ostatni etap to dostosowanie zmierzonej liczby kwantów do kodowania użytego w aplikacji. W mikrokontrolerach najczęściej jest to jednak zapis binarny liczby kwantów. W ustawieniach ADC można na przykład wyrównać tę wartość do lewej lub prawej w 16-bitowym rejestrze wyjściowym ADC.

Odczyt sygnału joysticka na STM32

Skoro już wiesz z grubsza jak działa ADC, możemy przejść do jego użycia. Joystick taki to nic innego jak dwa potencjometry działające na zasadzie dzielnika rezystancyjnego. Dwie skrajne nóżki potencjometrów są podłączone do + i – zasilania. Środkowa nóżka wyprowadzona jest na zewnątrz i napięcie na niej odwzorowuje pozycję drążka.

Jako że mamy dwie osie to takie potencjometry są dwa. Jak możesz się domyślić, będziemy mierzyć dwa niezależne sygnały. Jeden dla pozycji w osi X, drugi w osi Y.

Dzisiaj działam na Nucleo F411RE razem z STM32CubeIDE oraz bibliotekami HAL F4 w wersji 1.24.1.

Schemat

Joystick podłączyłem pod kanały 6 i 7 przetwornika analogowo cyfrowego.

Kod odczytu ADC – Polling

W pierwszej kolejności pokażę Ci najprostszy sposób na odczyt z ADC, czyli “ręczne” zlecanie konwersji ADC oraz odczyt wartości.

Przejdźmy do Cube’a. Utwórz projekt dla płytki Nucleo F411RE. Zaakceptuj domyślną konfigurację peryferiów na płytce. Przyśpiesza to nieco konfigurację – UART jest już z bańki i HCLK jest ustawione na dosyć wysoką wartość 84 MHz.

Napisałem, że podłączyłem się do kanałów IN6 i IN7, dlatego zaznacz je w konfiguracji ADC1.

Zauważysz, że piny na modelu obok się podświetlą. Teraz można przejść do ustawień ADC. Możesz ustawić preskaler zegara jak Ci się podoba. Ja mam ustawione na dzielenie przez 4. Upewnij się, że masz 12-bitową rozdzielczość, choć oczywiście z mniejszą również będzie działać poprawnie. Reszta domyślna tak jak na poniższym screenie.

I to tyle z konfiguracji. Można wygenerować kod i przejść do edytora.

Polling jak wspominałem wcześniej jest to “ręczne” odpytywanie ADC. W takim wypadku trzeba:

1. Jeżeli trzeba włączy ADC
2. Zlecić konwersję, czyli pobranie próbki, kwantyzację oraz kodowania
3. Poczekać na zakończenie konwersji
4. Odczytać zmierzoną wartość

Pierwszy i drugi punkt robi funkcja

HAL_StatusTypeDef HAL_ADC_Start(ADC_HandleTypeDef* hadc)

Trzeci punkt zrealizujesz za pomocą

HAL_StatusTypeDef HAL_ADC_PollForConversion(ADC_HandleTypeDef* hadc, uint32_t Timeout)

Ostatni to już tylko odczytanie z rejestru. Jest na to oczywiście funkcja

uint32_t HAL_ADC_GetValue(ADC_HandleTypeDef* hadc)

W celu pobrania kolejnej próbki czynność powtórzyć. Dobra, dobra! Nie wiem, czy wiesz, ale ADC może konwertować tylko jeden kanał na raz. Oznacza to, że musi mieć gdzieś wskazane, którym ma się zająć. Domyślnie jest to pierwszy zaznaczony, czyli w naszym wypadku IN6. Dla oczytu innych kanałów przed zleceniem konwersji należy wskazać, z którego kanału ma skorzystać.

Napisałem to tego prostą funkcję opierając się na kodzie inicjalizującym ADC który wygenerował Cube.

void ADC_SetActiveChannel(ADC_HandleTypeDef *hadc, uint32_t AdcChannel)
{
  ADC_ChannelConfTypeDef sConfig = {0};
  sConfig.Channel = AdcChannel;
  sConfig.Rank = 1;
  sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
  if (HAL_ADC_ConfigChannel(hadc, &sConfig) != HAL_OK)
  {
   Error_Handler();
  }
}

Kod standardowo jest w czwartej sekcji użytkownika.

Ostatecznie odczytanie dwóch kanałów i przesłanie ich na UART2 wygląda tak:

/* USER CODE BEGIN 2 */
  HAL_ADC_Start(&hadc1); // You have to start ADC
/* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
  while (1)
  {
    if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
    {
      Joystick[0] = HAL_ADC_GetValue(&hadc1); // Get X value
      ADC_SetActiveChannel(&hadc1, ADC_CHANNEL_7);
      HAL_ADC_Start(&hadc1);
    }

    if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
    {
      Joystick[1] = HAL_ADC_GetValue(&hadc1); // Get Y value
      ADC_SetActiveChannel(&hadc1, ADC_CHANNEL_6);
      HAL_ADC_Start(&hadc1);
    }

    sprintf((char*)UartMessage, "X: %d, Y: %d\n\r", Joystick[0], Joystick[1]);
    UART2_Print(UartMessage);
/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */
}

Wynikiem tego są wartości ADC na terminalu. Bez ingerencji w gałkę joysticka, znajduje się ona w centralnym położeniu. Połowa z 12-bitowej rozdzielczości to 2048, czyli około tego wyniku powinniśmy się spodziewać.

Jak widać bywa różnie, ale zawsze gdzieś wokół 2048. Niestety pomiar ADC potrafi mocno pływać. Ma na to wpływ mnóstwo czynników, ale to nie jest dzisiejszy temat. Można na przykład zebrać 10 próbek i uśrednić je. Na pewno będzie wtedy mniej pływania.

Myślę, że czasu konwersji nie ma co badać. Wymienię tylko, że na jego długość mają takie czynniki jak:

• Czas próbkowania
• Taktowanie ADC
• Rozdzielczość

Przetworniki mogą być bardzo szybkie. W STM32 niektóre sięgają maksymalnemu samplingowi na poziomie na przykład 5 MSPS(Megasamples per Second) w STM32F303. Zewnętrzne układy potrafią być jeszcze szybsze.

Kod z pollingiem znajdziesz tutaj.

Kod odczytu ADC – Continuous reading DMA

Nie mogło zabraknąć DMA 🙂 Mało tego! Możes uruchomić ADC raz i zapomnieć o nim całkowicie. Umożliwia to Continuous Conversion Mode. Polega on na tym, że ADC zaraz po zakończonym pomiarze startuje kolejny bez naszej ingerencji.

Dodatkowo, gdy chcesz mierzyć więcej niż jeden kanał przyda się Scan Conversion Mode. Dzięki niemu ADC będzie sam przełączał kolejne kanały. Fajnie, co nie?

Do tego dorzućmy DMA, które samodzielnie odczyta pomiary i wpisze je w odpowiednie miejsce w pamięci. Koniec z ręcznym odpytywaniem i czytaniem pomiarów!

Do dzieła. Skonfigurujmy tę magię. Poprawmy też delikatnie wahania odczytów. Tak się prezentuje konfiguracja.

Lećmy od góry. Zwiększyłem preskaler ADC. Będzie działał trochę dłużej, ale powinno poprawić to stabilność odczytu(dłuższy sampling).

Włączyłem Scan Conversion Mode i Continuous Conversion Mode z wiadomych względów.

Włączyłem DMA Continuous Requests. Pozwólmy, aby ADC sam szturchał DMA, że ma już gotowe dane do odczytu.

Upewnij się, że End of Conversion Selection masz ustawione na zakończenie konwersji pojedynczego kanału.

Teraz w sekcji ADC_Regular_ConversionMode ustaw ilość konwersji na 2. Chcemy, aby ADC automatycznie skanowało dwa kanały.

Tutaj jeszcze ustawiłem sampling każdego z kanałów na wartość maksymalna 480 cykli zegara. Wpłynie to na stabilność odczytów.

W zakładce DMA Settings musisz jeszcze ustawić, aby zapis DMA do bufora był cykliczny.

Tak przygotowaną konfigurację możesz wygenerować i przejść do kodu.

Narobiliśmy się, ale co wpisać w kodzie. Otóż cały kod, który będzie nam konwertował sygnał analogowy i pisał do przygotowanych wcześniej zmiennych to, uwaga:

/* USER CODE BEGIN 2 */
  HAL_ADC_Start_DMA(&hadc1, Joystick, 2); // You have to start ADC with DMA
/* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{

  sprintf((char*)UartMessage, "X: %d, Y: %d\n\r", (int)Joystick[0], (int)Joystick[1]);
  UART2_Print(UartMessage);
/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */

Tak! Wystarczy uruchomić ADC w trybie DMA i już odczyty z obu kanałów lecą do wybranej tablicy (u mnie uint16_t Joystick[2]). Warto tutaj wspomnieć, że lecą one z maksymalną możliwą prędkością.

Jak szybko w tej konfiguracji? Sprawdźmy poprzez zmianę stanu pinu testowego podczas każdego zakończonego transferu DMA.

Obydwa kanały odczytywane są co 92 µs, czyli wychodzi jakieś 10,8 kHz. Nie ma szału, ale pamiętaj, że w tej chwili mamy bardzo długi czas samplowania.

Kod z odczytem ciągłym znajdziesz tutaj.

No dobra, ale jeśli chciałbym uzyskać 44,1 kHz to po prostu skracam sampling i próbuję tym sposobem wcelować w 44,1 kHz? Zmniejszyć czas samplowania tak, ale czy celować na ślepo tak, aby to była pełna prędkość ADC? Niekoniecznie. Jest lepsza metoda!

Kod odczytu ADC – Timer triggering conversion

Możesz zaprzęgnąć któryś z Timerów, aby w równych odstępach czasu zlecał konwersję sygnału analogowego. Dzięki temu ustawiając Timer na 44,1 kHz będziemy pewni, że kolejne próbki będą pobierane w odpowiednim czasie. Let’s do this!

Ja zostawię czas konwersji tak jak był. Spróbujmy wycelować Timerem w 200 Hz regularnego samplingu. To będzie wystarczające dla działania z joystickiem. Takie urządzenie nie wymaga częstego czytania. Przejdźmy do Cube’a. Najpierw ADC.

Jak widzisz wyłączyłem Continuous Conversion Mode. Tym razem to nie ADC będzie decydowało o tym, kiedy wystartować konwersję.

W sekcji ADC_Regular_ConversionMode jest takie ustawienie jak External Trogger Conversion Source. Do wyboru masz kilka Timerów oraz rodzaj triggera. Albo jest to Capture Compare Event albo Out Event. Ustaw Timer 2 Trigger Out Event. Będzie on występował po przepełnieniu licznika TIM2.

Teraz przejdź do ustawień TIM2.

Clock Source ustaw na Internal Clock. Taktowanie dostarczone, teraz konfiguracja przepełnienia.

Chcemy uzyskać 200 Hz, czyli każde przepełnienie powinno wystąpić dokładnie co 5 ms. W pierwszej kolejności ustawmy Preskaler. Częstotliwość “główna” to 84 MHz. Dzieląc przez 84, uzyskasz tick na poziomie 1 µs. Dzielny dalej. Podział na 8400 da już 0,1 ms. Może być, co? Wpisz 8400-1 lub 8399.

Teraz ustaw okres zliczania na 49, aby uzyskać 5 ms na przepełnieniu licznika.

Ważne, abyś ustawił TRGO, które jest wyzwalaczem dla ADC. Trigger Event Selection ustaw na Update Event, aby przekazywać odpowiednie zdarzenie dla ADC. Teraz przejdźmy do kodu.

Kod jest bardzo podobny do tego, który obsługuje ADC + DMA w trybie ciągłym.

/* USER CODE BEGIN 2 */
  HAL_TIM_Base_Start(&htim2);
  HAL_ADC_Start_DMA(&hadc1, (uint32_t*)Joystick, 2); // You have to start ADC with DMA
/* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{

  sprintf((char*)UartMessage, "X: %d, Y: %d\n\r", (int)Joystick[0], (int)Joystick[1]);
  UART2_Print(UartMessage);
/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */

Jedyną różnicą jest wystartowanie Timera przed uruchomieniem ADC. Teraz samplowanie powinno odbywać się co 5 ms.

Wyszło 4,93 ms, czyli około 202,8 Hz, więc bardzo blisko. Można by się zastanowić, dlaczego nierówne 5. Ustawiając przepełnienie na 50 uzyskałem według analizatora 5,03 ms, a więc trochę lepiej. Pytanie jak bardzo dokładny mam analizator. Podejrzewam, że nie jest to sprzęt wysokiej klasy 🙂

Spróbuj uzyskać samplowanie Audio, czyli 44,1 kHz. Kod z triggerowaniem timerem znajdziesz tutaj.

Podsumowanie

Jak widzisz wbudowane w STM32 przetworniki analogowo cyfrowe mają ogromne możliwości. Ich konfiguracja jest naprawdę rozbudowana, a jednocześnie prosta mając Cube’a. Przy dobrym skonfigurowaniu, użycie ADC może sprowadzić się jedynie do jego wystartowania, co jest mega udogodnieniem. W Arduino tego nie ma 😉

Co myślisz o ADC w STM32? Podziel się swoją opinią w komentarzu.

Pełny projekt wraz z biblioteką znajdziesz jak zwykle na moim GitHubie: link

Jeśli zauważyłeś jakiś błąd, nie zgadzasz się z czymś, chciałbyś coś dodać istotnego lub po prostu uważasz, że chciałbyś podyskutować na ten temat, napisz komentarz. Pamiętaj, że dyskusja ma być kulturalna i zgodna z zasadami języka polskiego.