Programowanie STM32F4 (9)

GPS jest systemem nawigacji satelitarnej zbudowanym i utrzymywanym przez Departament Obrony USA. Obejmuje on swoim zasięgiem całą kulę ziemską. Jego działanie polega na pomiarze czasu propagacji sygnału radiowego nadawanego przez satelity i odbieranego w dowolnym punkcie na Ziemi. Znając prędkość propagacji fal elektromagnetycznych, czas, w jakim sygnał został nadany oraz pozycje co najmniej czterech nadajników, można ustalić położenie odbiornika. Sygnał nadawany z satelitów GPS zawiera almanach oraz efemerydę – informacje o położeniu i torze lotu satelitów na orbicie oraz dokładny czas odmierzany przez zegary atomowe – cezowe i rubidowe umieszczone w satelitach. Satelity nadają swój sygnał w paśmie mikrofal, równocześnie na dwóch częstotliwościach nośnych – 1575,42 MHz oraz 1227,6 MHz, stosując modulację CDMA – nadając dla sygnału jedynki i zera kod rozpraszający, unikalny dla pojedynczej satelity i ortogonalny względem pozostałych kodów, aby nadajnik mógł rozróżnić sygnały nadawane przez inne satelity i jednocześnie nasłuchiwać na tylko jednej (lub dwóch) częstotliwościach.

Moduł GPS

Wykorzystany moduł GPS produkcji WaveShare (rysunek 1), bazuje na układzie odbiornika uBlox NEO-6M, ma wbudowaną antenę ceramiczną oraz pozwala na przyłączenie innej, zewnętrznej anteny, ze złączem u.FL. Ponadto moduł zawiera zegar czasu rzeczywistego, którego praca podtrzymywana jest baterią, na stałe zamontowaną na płytce. Możemy go zasilać napięciem z zakresu 2,7…5,0 V. Maksymalny pobór prądu to 80 mA. Komunikacja z układem odbywa się poprzez interfejs UART w standardzie NMEA-0183, z domyślnie ustawioną szybkością transmisji – 9600 b/s. Wartość tę możemy również zmienić na: 4800, 19200, 38400, 57600, 115200 lub 230400 b/s. Dane, w postaci serii różnych ramek NMEA, nadawane są przez moduł domyślnie co 1 sekundę, choć wartość tę można zmienić – na maksymalnie 5 ramek na sekundę.

Pojedyncza seria ramek standardu NMEA składa się z maksymalnie 480 znaków ASCII, a długość każdej ramki ograniczona jest do 82 znaków. Każda ramka przesyłana jest w osobnej linii, rozpoczyna się znakiem „$” i kończy znakiem przejścia do nowej linii („rn”, „r” lub „n”). Na początku każdej ramki znajduje się pięcioznakowy identyfikator jej typu. Te opisane w standardzie rozpoczynają się od prefiksu – dwóch znaków ASCII: „GP”, dodatkowe, dodane przez producenta układu i zawierające niestandardowe dane – zaczynają się od innych prefiksów, zależnych od producenta. Dane w ramkach przesyłane są w postaci ciągów znaków ASCII – liczby stała i zmiennoprzecinkowe, a także inne identyfikatory. Poszczególne pola danych rozdzielone są przecinkami. Na końcu każdej ramki, może, choć nie musi, znajdować się suma kontrolna. Rozpoczyna się ona znakiem gwiazdki („*”) i zawiera po sobie dwa znaki heksadecymalne.

Poniższa lista typów ramek zdefiniowana została w standardzie NMEA-0183:

- AAM – Waypoint Arrival Alarm,
- ALM – Almanac data,
- APA – Auto Pilot A sentence,
- APB – Auto Pilot B sentence,
- BOD – Bearing Origin to Destination,
- BWC – Bearing using Great Circle route,
- DTM – Datum being used,
- GGA – Fix information,
- GLL – Lat/Lon data,
- GSA – Overall Satellite data,
- GSV – Detailed Satellite data,
- MSK – Send control for a beacon receiver,
- MSS – Beacon receiver status information,
- RMA – Recommended Loran data,
- RMB – Recommended navigation data for gps,
- RMC – Recommended minimum data for gps,
- RTE – Route message,
- VTG – Vector track an Speed over the Ground,
- WCV – Waypoint closure velocity (Velocity Made Good),
- WPL – Waypoint information,
- XTC – Cross track error,
- XTE – Measured cross track error,
- ZTG – Zulu (UTC) time and time to go (to destination),
- ZDA – Date and Time.

Nie wszystkie z wymienionych typów ramek są wysyłane przez nasz moduł, a większość tych nadawanych zawiera redundantne – dublujące się informacje. Do odczytania podstawowych informacji potrzebujemy interpretować jedynie część z nich. Na listingu 1 znajduje się przykładowa seria ramek nadawana przez moduł uBlox NEO-6M. Ramka GPRMC zawiera kolejno następujące wartości:

- aktualny czas UTC (12:55:23),
- pole statusu (A – Aktywny, V – Nieaktywny),
- szerokość geograficzną (2 pola – „1234.56789,N”),
- długość geograficzną (2 pola – „01234.56789,E”),
- prędkość poruszania się, w węzłach, obliczoną na podstawie zmian pozycji,
- kąt kierunku, w jakim porusza się obiekt (w stopniach),
- aktualną datę (16.04.2017),
- odchylenie magnetyczne Ziemi,
- sumę kontrolną.

Ramka GPVTG zawiera:

- ścieżkę poruszania się w stopniach, na podstawie odczytów pozycji (2 pola – "-brak odczytu-,T”),
- ścieżkę poruszania się w stopniach, na podstawie współrzędnych magnetycznych (2 pola – "-brak odczytu-,M”),
- prędkość w węzłach (2 pola – „1.395,N”),
- prędkość w kilometrach na godzinę (2 pola – „2.583,K”),
- sumę kontrolną.

Ramka GPGGA zawiera:

- aktualny czas UTC,
- szerokość i długość geograficzną,
- jakość pomiaru (0 – brak odczytu, 1 – pozycja określona na podstawie GPS),
- liczbę śledzonych satelitów,
- HDOP – dokładność pozycji w poziomie,
- wysokość w metrach nad poziomem morza,
- czas od ostatniego uaktualnienia ze wspomagającej stacji naziemnej,
- numer ID wspomagającej stacji naziemnej,
-sumę kontrolną.

Ramka GPGSA zawiera:

- flagę i sposób ustalania pozycji (2 pola) – A/M – automatyczny/manualny, 1/2/3 – brak pozycji/pozycja 2D/pozycja 3D,
- numery satelitów użytych do ustalenia pozycji (12 pól),
- DOP – dokładność ustalonej pozycji,
- HDOP – dokładność pozycji w poziomie,
- VDOP – dokładność pozycji w pionie,
- sumę kontrolną.

Ramka GPGLL zawiera:

- szerokość i długość geograficzną (4 pola),
- aktualny czas,
- status (A/V),
- sumę kontrolną.

W przedstawionej sekwencji pojawiają się również ramki GPGSV. Pierwsze pole każdej z tych ramek zawiera ich liczbę w sekwencji, drugie to identyfikator kolejnej ramki (tutaj 4 ramki, z identyfikatorami od 1 do 4). Dalej w każdej ramce znajduje się liczba widocznych satelitów i sekwencje po 4 pola dotyczące poszczególnych satelitów, składające się z numeru satelity, wyniesienia satelity nad poziomem równika, w stopniach, azymutu satelity, również w stopniach, oraz poziomu odbieranego sygnału (SNR).

Tworzymy projekt

Spróbujemy teraz utworzyć projekt odbierający od modułu GPS dane dotyczące:

- aktualnej daty i godziny,
- współrzędnych geograficznych,
- wysokości nad poziomem morza,
- prędkości poruszania się, w węzłach oraz kilometrach na godzinę,
- liczby satelitów, z których odbierane są dane,

oraz dokładności z jaką ustalone zostało położenie.

W przykładowym projekcie utworzymy uniwersalną bibliotekę współpracującą z modułami GPS różnych firm, odbierzemy za jej pomocą ww. dane, a następnie wyślemy je poprzez drugi interfejs UART (przyłączony do wbudowanego programatora) do komputera, w czytelnej dla człowieka formie. Biblioteka ta może zostać wykorzystana w urządzeniu logującym swoje pozycje na karcie pamięci lub w pamięci EEPROM czy Flash, trackerze GPS, przesyłającym informacje o położeniu dane poprzez radio lub sieć komórkową na serwer, czy też w roli zegara czasu rzeczywistego, zsynchronizowanego z zegarem atomowym znajdującym się na orbicie.

Uruchamiamy program STM32CubeMX i tworzymy w nim nowy projekt. W kreatorze wyboru mikrokontrolera wybieramy posiadany przez nas układ. Dla przypomnienia – na używanej podczas tworzenia kursu płytce rozwojowej Kamami KA-NUCLEO-F411 znajduje się układ STM32F411CEU6.

Na pierwszej planszy generatora konfiguracji STM32CubeMX definiujemy interfejsy i piny, z których będzie korzystał nasz program. Jeśli do posiadanego przez nas układu podłączony jest zewnętrzny oscylator kwarcowy, tak jak na płytce Kamami KA-NUCLEO-F411, z listy po lewej stronie okna rozwijamy zakładkę RCC i z pola „High Speed Clock (HSE)” wybieramy pozycję „Crystal/Ceramic Resonator”.

Układ STM32F411CEU6 ma 3 interfejsy USART (USART1, USART2 i USART3), które możemy uruchomić na wyprowadzeniach procesora o identyfikatorach: peryferial USART1 – PA10 (pin RX)/PA9 (pin TX), PB7/PB6 lub PB3/PA15, USART2 – PA3/PA2 oraz USART6 – PA12/PA11. W omawianym przykładzie, na potrzeby komunikacji z modułem GPS, wybrany został peryferial USART1, na pinach PA10/PA9, odpowiadających wyprowadzeniom kompatybilnym z Arduino – D2/D8. Do tych wyprowadzeń przyłączamy nasz moduł GPS – do pinu D2 (odbiorczego po stronie mikrokontrolera) przyłączamy pin nadawczy (TX) modułu, do pinu nadawczego, ze strony mikrokontrolera (TX), możemy opcjonalnie podłączyć pin odbiorczy odbiornika GPS (w przedstawionym przykładzie nie potrzebujemy transmitować do modułu żadnych danych). Nie możemy też oczywiście zapomnieć o zasileniu modułu GPS – pin VCC (zasilanie układu) przyłączamy do pinu 3V3 płytki KA-NUCLEO-F411, a GND (masę) do pinu GND po stronie płytki. Schemat ideowy połączeń pokazano na rysunku 2.

Po podłączeniu modułu GPS włączamy wybrany powyżej interfejs UART. W tym celu, z listy po lewej stronie, rozwijamy pozycję „USART2” i z pola Mode wybieramy pozycję „Asynchonous”. Dokładny opis konfiguracji i działania interfejsu UART zawarty został w czwartej części tego kursu.

W projekcie skorzystamy także z interfejsu UART, przyłączonego na płytce KA-NUCLEO (poprzez wyprowadzenia układu – PA2 (TX) i PA3 (RX)) do programatora, który umożliwi nam przekazania odczytów do komputera. Interfejs ten uruchamiany w sposób identyczny jak opisany powyżej. Konfigurację wyprowadzeń w programie STM32CubeMX pokazano na rysunku 3.

Po skonfigurowaniu wyprowadzeń przechodzimy do zakładki „Clock Configuration” i w identyczny sposób, jak w poprzednich częściach, konfigurujemy sygnał taktujący rozchodzący się po układzie. Jeśli do układu mikrokontrolera podłączony jest zewnętrzny oscylator kwarcowy, z pola „PLL Source MUX” wybieramy pozycję „HSE” i w polu „Input frequency” wpisujemy częstotliwość (w MHz) sygnału generowanego przez oscylator (na płytce Kamami KA-Nucleo jest to wartość 8 MHz). Dalej, w polu „System Clock MUX”, wybieramy pozycję „PLLCLK”. Następnie, w polu „HCLK (MHz)”, wpisujemy częstotliwość taktowania całego układu po przejściu przez pętlę PLL. Wpisujemy tutaj maksymalną dozwoloną wartość – 100 MHz. Opis znaczenia tych parametrów zawarty został w pierwszej części kursu (rysunek 4).

Teraz możemy już przejść do trzeciej zakładki – „Configuration” i ustawić parametry pracy obu wykorzystywanych peryferiali. W tym celu klikamy kolejno na przyciski USART1 i po zakończeniu konfiguracji pierwszego peryferialu – USART2. W przypadku interfejsu przyłączonego do modułu GSM, w pole Baud Rate wpisujemy wartość 9600 Bits/s, pozostałych wartości nie zmieniamy. Dla interfejsu przyłączonego do komputera szybkość transmisji powinna wynosić 115200 Bits/s. Konfiguracja obu interfejsów została przedstawiona na zrzutach ekranu na rysunkach 5 i 6.

Dla interfejsu przyłączonego do odbiornika GPS potrzebujemy jeszcze włączyć przerwanie wywoływane w momencie otrzymania od GPS nowych danych. W tym celu ponownie przechodzimy do konfiguracji interfejsu USART1, tym razem jednak, z paska na górze okna konfiguracyjnego, wybieramy zakładkę NVIC Settings i zaznaczamy tam jedyną opcję – „USART1 global interrupt” (rysunek 8, rysunek 9).

Nie pozostaje nam już nic innego, jak wygenerować projekt i zaimportować go w środowisku IDE. Będąc jeszcze w programie STM32CubeMX, klikamy ikonę zębatki znajdującą się na pasku narzędziowym. W nowym oknie wybieramy nazwę projektu (pole „Project Name”), ścieżkę dostępu do miejsca, w którym ma on zostać zapisany („Project Location”), z pola „Toolchain/IDE” wybieramy używane przez nas środowisko – „SW4STM32”, w zakładce „Code Generation” zaznaczamy opcję „Generate peripheral initialization as a pair of ‚.c/.h’ files per pepipheral” i klikamy przycisk „OK” (rysunek 10, rysunek 11).

Uruchamiamy program System Workbench for STM32, zamykamy planszę powitalną, w ramce „Project Explorer” klikamy prawym przyciskiem myszy i z menu kontekstowego wybieramy kolejno: „Import” –> „Existing Projects into Workspace”, podajemy ścieżkę dostępu, wybieramy nowo utworzony projekt i zatwierdzamy import przyciskiem „Finish”.

Aby możliwe było korzystanie z wartości zmiennoprzecinkowych, w funkcjach printf(), sprintf(), scanf() oraz sscanf(), konieczne jest dodanie parametrów „-u _printf_float” oraz „-u _scanf_float” do linii polecenia linkera. Robimy to, klikając prawym przyciskiem myszy na nazwę nowego projektu, z menu kontekstowego wybierając pozycję „Properties” oraz nawigując do „C/C++ Build” –> „Settings” –> „Miscellaneous” i dopisując do pola „Linker flags” wartość: „ -u _printf_float -u _scanf_float” (rysunek 12).

Modyfikujemy kod źródłowy pliku „Src/main.c” zgodnie z listingiem 2 oraz tworzymy dwa nowe pliki – „gps.h”, w podfolderze „Inc” oraz „gps.c”, w „Src”, wypełniając je zawartością listingów 3 i 4. Aby to zrobić, w panelu Project Explorer, znajdującym się z lewej strony głównego okna środowiska, klikamy prawym przyciskiem myszy na nazwę podfolderu („Inc” i „Src”), a następnie, z menu kontekstowego wybieramy kolejno: „New”, „File”, podajemy jego nazwę i zatwierdzamy, klikając „Finish” (rysunek 13).

Po dokonaniu modyfikacji zapisujemy zmiany w plikach, kompilujemy, wgrywamy i uruchamiamy program na mikrokontrolerze – klikamy ikony młotka i robaka, znajdujące się na pasku narzędziowym. Gdy program zostanie już uruchomiony, włączamy program PuTTY, wybieramy w jego ustawianiach typ połączenia – „Serial”, jego szybkość – 115200 kbps, nazwę portu szeregowego – tę możemy sprawdzić w Menadżerze Urządzeń bądź dmesg-u i klikamy przycisk OK (rysunek 14, rysunek 15).

Do pliku main.c dodaliśmy zmienną „volatile uint8_t recv_char” oraz funkcję „void HAL_UART_RxCpltCallback(UART_HandleTypeDef * uart)”, a na samym początku sekcji „USER CODE 2” wywołujemy funkcję „HAL_UART_Receive_IT(&huart1, &recv_char, 1)”. Powoduje to włączenie obsługi przerwania interfejsu UART. Po odebraniu pojedynczego znaku od modułu GPS znak ten trafia do zmiennej „recv_char”, a następnie wywoływana jest funkcja obsługi przerwania – „HAL_UART_RxCpltCallback()”. W funkcji tej wywołujemy funkcję „gps_recv_char(&gps_handle, recv_char);”, zapisującą kolejne znaki do bufora biblioteki „gps.h/gps.c”.

Zmienna „volatile struct gps_state gps_handle” przechowuje bufory i liczniki znaków, a także aktualne dane odebrane z GPS. Implementuje ona strukturę danych „struct gps_state” z pliku „gps.h”. Jest tworzona i wypełniana zerowymi wartościami przez funkcję „gps_init()” z „gps.c”, wywoływaną na początku sekcji „USER CODE 2”.

Funkcja „gps_recv_char()” z biblioteki „gps.h/gps.c” oczekuje na odebranie znaku „$”. Następnie, wszystkie kolejne znaki, aż do odebrania znaku nowej linii – „n” lub „r”, zapisuje na kolejnych pozycjach bufora „line_buffer” i inkrementuje licznik „writer_position”. Po odebraniu znaku „n” lub „r” jest wywoływana funkcja „gps_process_line()”, która korzystając z funkcji pomocniczej „gps_read_field()” odczytującej pola do znaku przecinka lub końca ciągu („null"), odczytuje typ ramki danych i wywołuje odpowiednią funkcję ją przetwarzającą – „gps_process_gprmc()”, „gps_process_gpvtg()”, „gps_process_gpgga()” lub „gps_process_gpgsa()”. Funkcje te odczytują kolejne pola, parsują ich zawartość za pomocą funkcji „scanf()” i zapisują ją do zmiennych w strukturze „gps_state”.

Aleksander Kurczyk

(Uwaga: pozostałe rysunki i pełny tekst artykułu są dostępne po pobraniu pliku PDF)