Kursy • Poradniki • Inspirujące DIY • Forum
Standardem komunikacyjnym w świecie PC stał się interfejs USB. Można go znaleźć w ogromnej ilości urządzeń takich jak kamery, myszki, pamięci przenośne, czy klawiatury.
Mikrokontrolery nie stanowią tutaj wyjątku i coraz częściej wyposażane są w kontroler USB, którego obsługą zajmiemy się w tym odcinku kursu
Uniwersalna Magistrala Szeregowa (ang. Universal Serial Bus) jest standardem komunikacyjnym definiującym kable, złącza oraz protokół transmisji danych. Magistrala USB umożliwia podłączanie, wymianę danych oraz zasilania pomiędzy komputerami i urządzeniami elektronicznymi.
W komunikacji USB zazwyczaj występują dwa urządzenia - Device oraz Host (kontroler magistrali). Hostem jest np. komputer PC, a urządzeniami typu Device są wszystkie pozostałe urządzenia, które możemy podłączyć bezpośrednio do komputera za pomocą magistrali USB. Z tego powodu nie możemy sobie po prostu połączyć dwóch komputerów kablem USB.
Komunikacja bez urządzenia typu host nie jest możliwa, natomiast połączenie ze sobą dwóch takich urządzeń możliwe jest tylko z użyciem specjalnych układów.
Kontroler USB będący na wyposażeniu naszego mikrokontrolera możne zostać skonfigurowany zarówno jako urządzenie host jak i device.
Komplet elementów Gwarancja pomocy Wysyłka w 24h
Zestaw elementów do przeprowadzenia wszystkich ćwiczeń z kursu STM32 F4 można nabyć u naszego dystrybutora! Zestaw zawiera m.in. płytkę Discovery, wyświetlacz OLED, joystick oraz enkoder.
Zamów w Botland.com.pl »USB znajduje zastosowanie w wielu urządzeniach. Najbardziej popularne są urządzenia pamięci masowej - pendrive'y oraz dyski zewnętrzne. Równie dobrze znane są nam urządzenia wskazujące, takie jak myszki, klawiatury i pady do gier.
Coraz częściej spotykamy także urządzenia audio wyposażone w port USB (radia samochodowe, amplitunery, głośniki komputerowe). Transmisja dźwięku jest w pełni wspierana przez USB.
USB może być również wykorzystywane do transmisji danych
poprzez wirtualny COM port, czym zajmiemy się w tym odcinku kursu.
CDC definiuje klasę urządzenia, za jaką może się podawać kontroler USB. Jest ona używana do transmisji danych w sieciach komputerowych. Jedną z możliwości klasy CDC jest stworzenie wirtualnego portu COM w celu imitacji protokołu RS-232.
Spróbujemy teraz wykorzystać tę właściwość tak, aby przesyłać dane pomiędzy płytką Discovery, a komputerem wykorzystując do tego port USB.
Krok 1. Tworzymy projekt i włączamy pobieranie sygnału zegarowego z zewnętrznego kwarcu.
Krok 2. Konfigurujemy przerwanie od przycisku (GPIO_EXTI0).
Pamiętamy, żeby uruchomić przerwanie
w panelu kontrolera przerwań NVIC.
Krok 3. Uruchamiamy peryferium USB_OTG_FS w trybie Device_Only, ponieważ będziemy łączyć się z komputerem PC "jako urządzenie".
Konfiguracja mikrokontrolera do korzystania z USB.
Krok 4. Konfigurujemy zegary mikrokontrolera. Ponieważ na magistralę USB musi być podany sygnał 48 MHz, pojawiają się pewne ograniczenia dotyczące częstotliwości. Nie możemy przez to ustawić maksymalnej częstotliwości 100 MHz. W tym przykładzie ustawimy tę wartość na 72 MHz.
Konfiguracja zegarów STM32 przy wykorzystaniu USB.
Krok 5. W zakładce Configuration ustawiamy klasę urządzenia na CDC (Communication Device Class). Dzięki temu nasz mikrokontroler będzie widziany w komputerze jako wirtualny port COM.
Warto zauważyć, że USB pojawiło się również w sekcji Middlewares. Oznacza to, że do projektu zostaną dołączone biblioteki wysokopoziomowe (wyżej niż HAL), do obsługi wybranej klasy USB.
Ustawienie trybu CDC w kontrolerze USB.
Krok 6. Generujemy projekt pod nazwą 08_USB.
Na początku musimy się wyposażyć w sterowniki do obsługi wirtualnego portu COM. W tym celu kompilujemy pusty projekt i wgrywamy go na płytkę discovery. Następnie podłączamy ją do komputera za pomocą gniazda USB USER.
Gniazdo USB USER, do którego należy podłączyć kabel micro USB.
Po podłączeniu kabla micro USB prawdopodobnie otrzymamy komunikat o nierozpoznanym urządzeniu. Jeśli jednak system w jakiś sposób sobie z tym poradzi, w menedżerze urządzeń nasza płytka będzie widnieć jako na przykład USB Serial Device.
Kontroler USB wykryty przez system.
Jeśli tak jest, musimy pobrać sterownik do wirtualnego portu COM ze strony ST. Po rozpakowaniu archiwum postępujemy z instrukcją opisaną w pliku readme.
Jeżeli wszystko wykonaliśmy poprawnie, po podłączeniu kabla micro USB nasza płytka powinna zostać rozpoznana jako STMicroelectronics Virtual Com Port. Zapamiętujemy, który numer został przypisany do nowo stworzonego portu COM. W moim wypadku jest to COM16.
Poprawnie wykryty Virtual COM Port widoczny w menedżerze urządzeń.
Obsługa USB różni się nieco od tego, z czym spotkaliśmy się w przypadku poprzednich peryferii. Przyglądając się strukturze projektu zaimportowanego do Workbencha widzimy, że pojawiło się bardzo dużo plików dotyczących USB.
Struktura projektu z USB.
Najbardziej interesujący będzie dla nas plik usbd_cdc_if.c (universal serial bus driver communication device class interface), który stanowi interfejs użytkownika dla klasy CDC kontrolera USB. W nim znajdują się funkcje, z których będziemy korzystać do obsługi USB.
Krok 1. W pliku main dodajemy nagłówek usbd_cdc_if.h zawierający funkcje główne do USB:
|
37 38 39 |
/* USER CODE BEGIN Includes */ #include "usbd_cdc_if.h" // Plik bedacy interfejsem uzytkownika do kontrolera USB /* USER CODE END Includes */ |
Krok 2. Deklarujemy tablicę DataToSend, w której będziemy przechowywać ramkę danych do wysłania. Dodatkowo przydadzą nam się zmienne do zliczania wysłanych wiadomości oraz do ustalania ich rozmiaru:
|
41 42 43 44 45 46 47 48 |
/* Private variables ---------------------------------------------------------*/ /* USER CODE BEGIN PV */ /* Private variables ---------------------------------------------------------*/ uint8_t DataToSend[40]; // Tablica zawierajaca dane do wyslania uint8_t MessageCounter = 0; // Licznik wyslanych wiadomosci uint8_t MessageLength = 0; // Zawiera dlugosc wysylanej wiadomosci /* USER CODE END PV */ |
Krok 3. W pętli głównej sprawdzamy, czy przycisk został wciśnięty i dokonujemy bardzo trywialnej eliminacji efektu drgania styków.
|
83 84 85 86 87 88 89 90 91 92 |
/* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { if (HAL_GPIO_ReadPin(Button_GPIO_Port, Button_Pin) == GPIO_PIN_SET) { HAL_Delay(100); if (HAL_GPIO_ReadPin(Button_GPIO_Port, Button_Pin) == GPIO_PIN_SET) { } } /* USER CODE END WHILE */ |
Krok 4. Jeżeli przycisk faktycznie został wciśnięty, zwiększamy licznik wysłanych wiadomości, tworzymy nową wiadomość i transmitujemy za pomocą funkcji CDC_Transmit_FS. Parametry wywołania tej funkcji, to wskaźnik na tablicę z danymi oraz długość łańcucha do przesłania.
|
83 84 85 86 87 88 89 90 91 92 93 94 95 |
/* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { if (HAL_GPIO_ReadPin(Button_GPIO_Port, Button_Pin) == GPIO_PIN_SET) { HAL_Delay(100); if (HAL_GPIO_ReadPin(Button_GPIO_Port, Button_Pin) == GPIO_PIN_SET) { ++MessageCounter; MessageLength = sprintf(DataToSend, "Wiadomosc nr %d\n\r", MessageCounter); CDC_Transmit_FS(DataToSend, MessageLength); } } /* USER CODE END WHILE */ |
Krok 5. Kompilujemy program i wgrywamy go na płytkę.
Krok 6. Uruchamiamy program RealTerm. Ustawiamy tryb wyświetlania danych na ANSI.
Zmiana trybu wyświetlania danych w programie RealTerm na Ansi.
Port ustawiamy na ten, na którym pojawił się nasz Virtual COM Port. Następnie wybieramy przycisk Change. Nie przejmujemy się wartością Baud.
Zmiana portu w programie RealTerm.
Bardzo często port nie będzie mógł zostać otworzony,
czego skutkiem będzie poniższy komunikat.
Błąd otwierania portu w RealTerm.
Niestety nie wiem co jest przyczyną takiego stanu rzeczy i po wielu dniach prób przy ogromnej ilości konfiguracji nie udało mi się tego rozszyfrować. W moim przypadku błąd ten występuje prawie zawsze, jeżeli program uruchomiony jest w debugerze, co jest mocno uciążliwe. Aby poprawnie otworzyć port należy:
Aczkolwiek zdarza się, że i po tym zabiegu port nie może zostać otworzony... Jeżeli komuś udało się rozwiązać tę zagadkę, będę wdzięczny za wszelkie informacje w komentarzu!
Krok 7. Jeżeli udało nam się otworzyć port COM i mamy nawiązane połączenie, możemy przetestować działanie programu wciskając niebieski przycisk na płytce Discovery. W terminalu powinny się pojawiać kolejne wiadomości.
Wiadomości odbierane w RealTerm.
Świetnie! Umiemy już wysyłać dane z mikrokontrolera za pomocą USB!
Nawiązując do doświadczenia z poprzednich artykułów oczekiwalibyśmy jakiejś funkcji typu USB_Rx_Cplt_Callback(), która wywoływałaby się przy każdym odebraniu danych i moglibyśmy ją sobie sami zaimplementować. Niestety, odbieranie danych jest nieco bardziej skomplikowane. Żeby zrozumieć podstawy działania tego mechanizmu, musimy zajrzeć do pliku usbd_cdc_if.c.
Pierwsza sekcja która będzie nas interesować, to definicje stałych odpowiadających za rozmiar buforów wysyłanych/odbieranych danych.
|
59 60 61 62 63 64 |
/* USER CODE BEGIN PRIVATE_DEFINES */ /* Define size for the receive and transmit buffer over CDC */ /* It's up to user to redefine and/or remove those define */ #define APP_RX_DATA_SIZE 4 #define APP_TX_DATA_SIZE 4 /* USER CODE END PRIVATE_DEFINES */ |
Druga interesująca nas sekcja zawiera deklaracje buforów, do których będą przekazywane dane przed wysłaniem/po odbiorze.
|
82 83 84 85 86 87 88 |
/* Create buffer for reception and transmission */ /* It's up to user to redefine and/or remove those define */ /* Received Data over USB are stored in this buffer */ uint8_t UserRxBufferFS[APP_RX_DATA_SIZE]; /* Send Data over USB CDC are stored in this buffer */ uint8_t UserTxBufferFS[APP_TX_DATA_SIZE]; |
Czytając komentarze dowiadujemy się, że jest to tylko sugerowane rozwiązanie, a użytkownik może postąpić wedle uznania. Aby jednak nie zagłębiać się za bardzo w całą bibliotekę, pozostawimy wszystko tak jak jest, zmieniając jedynie rozmiar buforów na 40.
|
59 60 61 62 63 64 |
/* USER CODE BEGIN PRIVATE_DEFINES */ /* Define size for the receive and transmit buffer over CDC */ /* It's up to user to redefine and/or remove those define */ #define APP_RX_DATA_SIZE 40 #define APP_TX_DATA_SIZE 40 /* USER CODE END PRIVATE_DEFINES */ |
Funkcja będąca naszym Callbackiem zaczyna się w linii 254.
|
254 255 256 257 258 259 260 261 |
static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len) { /* USER CODE BEGIN 6 */ USBD_CDC_SetRxBuffer(hUsbDevice_0, &Buf[0]); USBD_CDC_ReceivePacket(hUsbDevice_0); return (USBD_OK); /* USER CODE END 6 */ } |
Funkcja ta wywoływana jest przy każdym odebraniu danych. W tablicy Buf będzie się znajdował odebrany ciąg znaków, a zmienna Len zawierać będzie informację o ilości odebranych znaków.
Widzimy, że w funkcji znajdują się znaczniki USER CODE BEGIN/END,
w których możemy umieścić nasz kod.
Mamy już ogólny pogląd na to jak można odbierać dane przez USB. Czas na implementację!
Krok 1. W pliku main.c dodajemy dwie nowe zmienne - tablicę do przechowywania odebranych danych oraz flagę informującą o odebraniu danych.
|
42 43 44 45 46 47 48 49 50 |
/* USER CODE BEGIN PV */ /* Private variables ---------------------------------------------------------*/ uint8_t DataToSend[40]; // Tablica zawierajaca dane do wyslania uint8_t MessageCounter = 0; // Licznik wyslanych wiadomosci uint8_t MessageLength = 0; // Zawiera dlugosc wysylanej wiadomosci uint8_t ReceivedData[40]; // Tablica przechowujaca odebrane dane uint8_t ReceivedDataFlag = 0; // Flaga informujaca o odebraniu danych /* USER CODE END PV */ |
Krok 2. W dalszej części pętli głównej dodajemy kolejny warunek. Jeżeli flaga odbioru zostanie ustawiona, odebrane znaki mają zostać przepisane do bufora nadawczego i wysłane z powrotem przez USB do komputera.
|
101 102 103 104 105 106 107 |
// Odeslanie odebranych danych przez USB if(ReceivedDataFlag == 1){ ReceivedDataFlag = 0; MessageLength = sprintf(DataToSend, "Odebrano: %s\n\r", ReceivedData); CDC_Transmit_FS(DataToSend, MessageLength); } |
Krok 3. W funkcji wywoływanej po odebraniu danych ustawiamy flagę ReceivedDataFlag i przepisujemy odebrane dane do naszej tablicy. Wykorzystamy do tego funkcję strlcpy, która jest udoskonaloną wersją strncpy - zabezpiecza przed przepełnieniem buforu i sama dodaje znak końca napisu '\0'.
strncpy (char* strTo, const char* strFrom, size_t size);
Funkcja strncpy kopiuje size znaków z tablicy strFrom do tablicy strTo.
Ponieważ funkcja strlcpy sama dodaje znak '\0' na końcu, należy przekopiować size+1 znaków. Funkcja CDC_Receive_FS z dodanymi liniami kodu będzie wyglądać następująco:
|
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 |
static int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len) { /* USER CODE BEGIN 6 */ USBD_CDC_SetRxBuffer(hUsbDevice_0, &Buf[0]); USBD_CDC_ReceivePacket(hUsbDevice_0); // Zmienne zadeklarowane w pliku main.c extern uint8_t ReceivedData[40]; // Tablica przechowujaca odebrane dane extern uint8_t ReceivedDataFlag; // Flaga informujaca o odebraniu danych // Wyczyszczenie tablicy odebranych danych uint8_t iter; for(iter = 0; iter<40; ++iter){ ReceivedData[iter] = 0; } strlcpy(ReceivedData, Buf, (*Len) + 1); // Przekopiowanie danych do naszej tablicy ReceivedDataFlag = 1; // Ustawienie flagi odebrania danych return (USBD_OK); /* USER CODE END 6 */ } |
Krok 4. Kompilujemy program i wgrywamy na płytkę. Jeżeli wykonaliśmy wszystko poprawnie, po wysłaniu danych przez zakładkę Send powinniśmy otrzymać wiadomość, z dopiskiem "Odebrano:".
Oczywiście wysyłanie wiadomości za pomocą
niebieskiego przycisku dalej będzie działać.
Wysyłanie danych do mikrokontrolera z programu RealTerm.
W dzisiejszym odcinku dowiedzieliśmy się jak korzystać z klasy CDC kontrolera USB będącego na wyposażeniu mikrokontrolera STM32. Umiemy już nadawać i odbierać dane, wykorzystując w tym celu stworzony port COM. W następnym odcinku zajmiemy się wgrywaniem programu do naszego STM'a bez wykorzystania programatora. Jeżeli macie jakiekolwiek pytania, uwagi lub problemy, to piszcie w komentarzach!
Autor kursu: Bartek (Popeye) Kurosz
Redakcja: Damian (Treker) Szymański
Projekt USB (zip, 1 MB)
Projekt tworzony w artykule.
komunikacja, kurs, kursSTM32F4, programowanie, stm32, USB
Dołącz do 20 tysięcy osób, które otrzymują powiadomienia o nowych artykułach! Zapisz się, a otrzymasz PDF-y ze ściągami (m.in. na temat mocy, tranzystorów, diod i schematów) oraz listę inspirujących DIY z Arduino i RPi.
Trwa ładowanie komentarzy...