Zobacz jak rozpocząć swoją przygodę z mikrokontrolerami STM32 i naucz się je programować! Zacznij jak najszybciej i sprawdź jakie to proste.
Aktualnie zapisy do kursu są zamknięte. Nie przegap kolejnego otwarcia i zapisz się na listę oczekujących. W międzyczasie możesz zacząć z e-bookiem, którego dostaniesz zaraz po zapisaniu się.
Najbliższy planowany termin otwarcia: 8 MAJA 2024
To świetnie się składa! Chciałbym Cię nauczyć programować mikrokontrolery, które chętnie wykorzystywane są w profesjonalnych produktach na całym świecie. Nie ważne czy jesteś hobbystą, czy chciałbyś związać swoją przyszłość z programowaniem embedded. Potrzebujesz znać coś, co da Ci możliwość budowania niesamowitych urządzeń oraz zdobycia dobrej pracy.
Aktualnie wiele firm z branży programowania embedded skupia się na nowoczesnych rozwiązaniach. Same mikrokontrolery AVR znane z podstawowych płytek Arduino już nie wystarczają. Świat idzie do przodu. Aktualnie na topie są mikrokontrolery z rdzeniem ARM Cortex-M. Taki rdzeń mają na przykład mikrokontrolery STM32. Warto jest więc nauczyć się ich programowania.
Zdobądź swoją pierwszą pracę właśnie dzięki programowaniu STM32. To jest jedna z lepszych rzeczy, jaką możesz sobie sprawić.
Prowadzisz firmę, w której masz zespół programistów? Podnieś umiejętności programistów.
Kurs STM32 dla Początkujących to nie tylko poznawanie samego mikrokontrolera. Program nauki został ułożony w taki sposób, że nauczysz się dobrych praktyk programisty embedded.
W kursie nauczę Cię jak tworzyć nieblokujący kod, czy pisać własne biblioteki.
Jestem autorem bloga msalamon.pl
Od lat programuję STM32 zawodowo oraz hobbystycznie. Moje umiejętności wystarczyły mi, aby zdobyć pracę w jednej z największych firm świata. Wiem, jak ciężka potrafi być droga, którą należy pokonać, aby nauczyć się programować mikrokontrolery. Chciałbym podzielić się swoją wiedzą, dlatego stworzyłem specjalnie dla Ciebie kurs.
Pokażę Ci jak zbudować coś więcej niż miganie diodą czy wyświetlenie prostego tekstu na ekranie. Połączenie dwóch różnych interfejsów w taki sposób, aby sobie nie przeszkadzały nie będzie dla Ciebie tajemnicą.
Do czego służy Timer? Czy tylko do odmierzania czasu? Jaki wpływ na działanie Twojego programu ma DMA? Jakim interfejsem podłączyć kartę SD. USB nie tylko jako port szeregowy. Dlaczego wyświetlacz TFT tak wolno się odświeża?
Raz na miesiąc spotkamy się na 2-godzinnym LIVE, podczas którego będziesz mógł zadać dowolne pytanie. Instruktor również będzie dostępny na specjalnej grupie Slack, aby odpowiadać na Twoje pytania i pomagać Ci w nauce.
W każdym module czeka Cię nawet 50 nagrań video pokazujących cały proces nauki programowania. Przeprowadzę Cię za rękę od zera, poprzez poznanie różnych interfejsów mikrokontrolera, aż po swoje pierwsze bardziej złożone programy.
Sprytne wykorzystanie posiadanego sprzętu po to, aby Twój projekt chodził jak najlepiej. Poznasz np. "jednorazową" konfigurację DMA i Timerów po to, aby mikrokontroler sam potrafił zrobić masę powtarzalnych czynności. Bez udziału kodu.
Koniec z Delayem! Przestań w końcu używać blokującego kodu. W końcu jest dostępny kurs, który od razu tłumaczy jak poprawnie pisać programy dla mikrokontrolera. Poznasz, w jaki sposób używać timerów programowych, oraz maszyny stanów.
Nie możesz znaleźć biblioteki dla układu? Napiszesz ją sam! Tylko i wyłącznie na podstawie dokumentacji. Nie ma biblioteki dla STM32, ale jest dla Arduino? Bez problemu ją przeportujesz. Pokażę Ci kilka dróg do tego, aby mieć działającą bibliotekę.
Nauczysz się optymalizować kod i biblioteki. Twój program będzie działał szybciej i będziesz wiedział dlaczego.
W grupie poznasz inne początkujące osoby. Będziecie mogli wymieniać się doświadczeniami oraz nawzajem sobie pomagać. Wsparcie innych osób, nie tylko instruktora jest bardzo ważne w procesie nauki.
Moduł 1: PLAN GRY ALekcja 1: Powitanie |
Lekcja 2: Plan Gry |
Lekcja 3: Efekt Końcowy |
Lekcja 4: Wymagania |
Lekcja 5: Jak Studiować? |
Lekcja 6: Platforma Nucleo |
Lekcja 7: Zadanie Domowe |
Moduł 2: Oprogramowanie, RCC, GPIO Lekcja 1: Powitanie |
Lekcja 2: Sprzęt do kursu |
Lekcja 3: Potrzebny sprzęt w tym tygodniu |
Lekcja 4: ST MCU Finder |
Lekcja 5: Programator ST-Link |
Lekcja 6: STM32CubeProgrammer |
Lekcja 7: Biblioteka HAL |
Lekcja 8 : Biblioteka Low Layer |
Lekcja 9: HAL vs rejestry |
Lekcja 10: Nazewnictwo w HALu |
Lekcja 11: Dokumentacja HAL |
Lekcja 12: Dokumentacja mikrokontrolera |
Lekcja 13: STM32CubeMX |
Lekcja 14: STM32CubeIDE |
Lekcja 15: Tworzenie pierwszego projektu - z Nucleo |
Lekcja 16: Tworzenie pierwszego projektu - z MCU |
Lekcja 17: Przegląd biblioteki HAL |
Lekcja 18a: STM32CubeMX - zakładka mikrokontrolera |
Lekcja 18b: STM32CubeMX - zakładka zegarów |
Lekcja 18c: STM32CubeMX - zakładka project manager |
Lekcja 19a: STM32CubeIDE - wstępna konfiguracja, kolory |
Lekcja 19b: STM32CubeIDE - Omówienie Layotu |
Lekcja 19c: STM32CubeIDE - Górny pasek i menu |
Lekcja 19d: STM32CubeIDE - Skróty |
Lekcja 20: GPIO Output - Teoria |
Lekcja 21: GPIO Input - Teoria |
Lekcja 22: Funkcje alternatywne pinów |
Lekcja 23: GPIO w Dokumentacji |
Lekcja 24: GPIO w CubeMX |
Lekcja 25: Miganie diodą - funkcja opóźniająca |
Lekcja 26: Miganie diodą - Kod |
Lekcja 27: Uruchamianie programu |
Lekcja 28: Debugowanie - podstawy |
Lekcja 29: Czytanie wejścia - Kod |
Lekcja 30: Miganie wieloma diodami - Timer programowy |
Lekcja 31: Timery programowy - Kod |
Lekcja 32: Prosta maszyna stanów - Teoria |
Lekcja 33a: Powtórka z C - podział na pliki |
Lekcja 33b: Powtórka z C - struktury |
Lekcja 33c: Powtórka z C - wskaźniki |
Lekcja 33d: Powtórka z C - callbacki |
Lekcja 33e: Powtórka z C - "obiektowość" w C |
Lekcja 34: Prosta maszyna stanów - Elementy maszyny |
Lekcja 35a: Prosta maszyna stanów - Szkielet biblioteki |
Lekcja 35b: Prosta maszyna stanów - Sprawdzenie inicjalizacji |
Lekcja 35c: Prosta maszyna stanów - Pierwsze przejście stanów |
Lekcja 35d: Prosta maszyna stanów - Debounce i wywołanie Callbacka |
Lekcja 35e: Prosta maszyna stanów - Sprawdzenie działania |
Lekcja 35f: Prosta maszyna stanów - Rejestracja Callbacku i użycie |
Lekcja 36: Dokładanie stanów - Teoria |
Lekcja 37: Dokładanie stanów - Kod |
Lekcja 38: Zadanie domowe |
Bonus 1: Kopiowanie projektów CubeIDE |
Moduł 3: Przerwania, UART, DMA Lekcja 1: Powitanie |
Lekcja 2: Potrzebne narzędzia w tym tygodniu |
Lekcja 3: Czym są przerwania? |
Lekcja 4: Kontroler przerwań NVIC i priorytety |
Lekcja 5: Jak działa wywłaszczanie przerwań? |
Lekcja 6: Co się dzieje podczas wejścia do przerwania? |
Lekcja 7: Rodzaje przerwań |
Lekcja 8: Przerwanie vs Event |
Lekcja 9: Przerwanie EXTI |
Lekcja 10: Przerwania i EXTI w dokumentacji |
Lekcja 11: Obsługa przerwania EXTI ogólnie |
Lekcja 12: Obsługa przerwania EXTI w HALu |
Lekcja 13: Obsługa przerwania EXTI - CubeMX |
Lekcja 14: Obsługa przerwania EXTI - Kod |
Lekcja 15: Debugowanie przerwania |
Lekcja 16: UART - Teoria |
Lekcja 17: Port szeregowy na PC |
Lekcja 18: UART - Polling teoria |
Lekcja 19: UART - Transfer blokujący |
Lekcja 20: UART - Odbiór blokujący |
Lekcja 21: UART z przerwaniani - Teoria |
Lekcja 22: Jak działają funkcje komunikacyjne HAL w trybie przerwaniowym |
Lekcja 23: UART - Transfer przerwania |
Lekcja 24a: UART - Odbiór przerwania |
Lekcja 24b: UART - Odbiór przerwania, więcej znaków |
Lekcja 25: UART - Odbiór komunikatów |
Lekcja 26: Ring Buffer - Teoria |
Lekcja 27: Ring Buffer - Elementy |
Lekcja 28a: Ring Buffer - Stworzenie bufora |
Lekcja 28b: Ring Buffer - Funkcja pisząca do bufora |
Lekcja 28c: Ring Buffer - Funkcja czytająca z bufora |
Lekcja 28d: Ring Buffer - Flush |
Lekcja 29: UART - Odbiór różnej długości |
Lekcja 30: Parsowanie komend - Teoria |
Lekcja 31a: Parsowanie komend - Proste - wykrycie pełnej linii |
Lekcja 31b: Parsowanie komend - Proste - główny kod |
Lekcja 31c: Parsowanie komend - Proste - wydzielenie do osobnych plików |
Lekcja 32a: Parsowanie komend - Złożone - LED |
Lekcja 32b: Parsowanie komend - Złożone - ENV |
Lekcja 32c: Parsowanie komend - Złożone - NAME |
Lekcja 33a: DMA - Czym jest? |
Lekcja 33b: DMA - Jak jest zbudowane |
Lekcja 33c: DMA - Ustawienie transferu |
Lekcja 33d: DMA - Żądanie transferu |
Lekcja 33e: DMA - Arbitraż i priorytety |
Lekcja 33f: DMA - Zaawansowane funkcje |
Lekcja 33g: DMA - Przerwania |
Lekcja 33h: DMA - Dokumentacja |
Lekcja 34: UART i DMA |
Lekcja 35: Ustawienia DMA w CubeMX |
Lekcja 36a: UART - Transfer DMA |
Lekcja 36b: UART - Debug callbacka |
Lekcja 37: UART - Odbiór DMA |
Lekcja 37: Zadanie domowe |
Bonus 1: UART - Odbiór DMA na rejestrach |
Bonus 2: UART - Transfer DMA na rejestrach |
Moduł 4: Timery |
Lekcja 1: Powitanie |
Lekcja 2: Potrzebne narzędzia w tym tygodniu |
Lekcja 3: Timery: Teoria |
Lekcja 4: Tryby Timerów |
Lekcja 5: SysTick Timer |
Lekcja 6: Tryb Normal: Teoria |
Lekcja 7: Tryb Normal: Kod |
Lekcja 8: Tryb Input Capture: Teoria |
Lekcja 9: Tryb Input Capture: Kod |
Lekcja 10: Tryb Output Compare: Teoria |
Lekcja 11: Tryb Output Compare: Kod |
Lekcja 12: Tryb Output Compare: Zmiana parametrów w locie |
Lekcja 13: Tryb PWM: Teoria |
Lekcja 14: Tryb PWM: Kod |
Lekcja 15: Tryb PWM: Zmiana parametrów w locie |
Lekcja 16: Slave w Timerach: Teoria |
Lekcja 17: Slave: Reset Mode |
Lekcja 18: Slave: Gated Mode |
Lekcja 19: Tryb One-pulse Mode: Teoria |
Lekcja 20: Tryb One-pulse Mode: Kod |
Lekcja 21: Watchdog: Teoria |
Lekcja 22: Watchdog: IWDG Kod |
Lekcja 23: Watchdog: WWDG Kod |
Lekcja 24: RTC: Teoria |
Lekcja 25: RTC: Czas i Kalendarz |
Lekcja 26: RTC: Podtrzymanie |
Lekcja 27: RTC: Alarmy |
Lekcja 28: RTC: Wake-up |
Lekcja 29: RTC: Time Stamp |
Lekcja 30: RTC: Tamper |
Lekcja 31: Zadanie domowe |
Moduł 5: ADC |
Lekcja 1: Powitanie |
Lekcja 2: Potrzebne narzędzia w tym tygodniu |
Lekcja 3: Czy jest ADC? |
Lekcja 4: Jak działa ADC? |
Lekcja 5: Przegląd opcji ADC w CubeMX |
Lekcja 6: Tryb Single Channel: Teoria |
Lekcja 7: Tryb Single Channel: Kod, Polling |
Lekcja 8: Tryb Single Channel: Kod, Przerwania |
Lekcja 9: Tryb Single Channel: Kod, DMA |
Lekcja 10: Tryb Multi Channel: Teoria |
Lekcja 11: Tryb Multi Channel: Kod, Polling |
Lekcja 12: Tryb Multi Channel: Kod, Przerwania |
Lekcja 13: Tryb Multi Channel: Kod, DMA |
Lekcja 14: Watchdog analogowy: Teoria |
Lekcja 15: Watchdog analogowy: Kod |
Lekcja 16: Potencjometr + LED PWM: Teoria |
Lekcja 17: Potencjometr + LED PWM: Kod, Polling |
Lekcja 18: Potencjometr + LED PWM: Kod, Przerwania |
Lekcja 19: Potencjometr + LED PWM: Kod, DMA |
Lekcja 20: Automatyczna konwersja z Timerem: Teoria |
Lekcja 21: Automatyczna konwersja z Timerem: Kod |
Lekcja 22: Tryb Injected Mode: Teoria |
Lekcja 23: Tryb Injected Mode: Kod |
Lekcja 24: Tryb Injected Mode + Regular: Kod |
Lekcja 25: Odczyt z mikrofonu: Teoria |
Lekcja 26: Odczyt z mikrofonu przy okazji innych konwersji: Teoria |
Lekcja 27: Odczyt z mikrofonu przy okazji innych konwersji: Kod |
Lekcja 28: DSP: FFT mikrofonu, Teoria |
Lekcja 29: DSP: FFT mikrofonu, Kod |
Lekcja 30: Zadanie domowe |
Moduł 6: I2C |
Lekcja 1: Powitanie |
Lekcja 2: Potrzebne narzędzia w tym tygodniu |
Lekcja 3: Czym jest I2C: Teoria |
Lekcja 4: Przegląd opcji I2C w CubeMX |
Lekcja 5: I2C: Czy potrzebny jest translator napięć? |
Lekcja 6: BMP280: Teoria |
Lekcja 7: BMP280: Dokumentacja |
Lekcja 8: Skaner I2C |
Lekcja 9: Jak pisać swoje biblioteki? |
Lekcja 10a: BMP280: Pisanie biblioteki - Zalążek Inicjalizacji |
Lekcja 10b: BMP280: Pisanie biblioteki - Co lata po I2C? Odczyt ID |
Lekcja 10c: BMP280: Pisanie biblioteki - Odczyt rejestrów kalibracyjnych |
Lekcja 10d: BMP280: Pisanie biblioteki - Startujemy pomiary |
Lekcja 10e: BMP280: Pisanie biblioteki - Dokładność pomiarów |
Lekcja 10f: BMP280: Pisanie biblioteki - Odczyt pomiarów |
Lekcja 10g: BMP280: Pisanie biblioteki - Przeliczenie pomiarów i kończenie biblioteki |
Lekcja 11: OLED: Teoria |
Lekcja 12: Buforowanie ekranu w wyświetlaczach |
Lekcja 13: OLED: Dokumentacja kontrolera |
Lekcja 14: OLED: Szukanie gotowej biblioteki w Arduino |
Lekcja 15: OLED: Portowanie biblioteki - Init |
Lekcja 16: OLED: Portowanie biblioteki - Bufor |
Lekcja 17: OLED: Portowanie biblioteki - Piksel |
Lekcja 18: OLED: GFX Figury |
Lekcja 19: Jak rysować czcionki? |
Lekcja 20: OLED: GFX Czcionki |
Lekcja 21: OLED: GFX Bitmapy |
Lekcja 22: Wyświetlenie danych z BMP280 |
Lekcja 23: Podkręcenie I2C + DMA |
Lekcja 24: Wyświetlenie FFT mikrofonu |
Lekcja 25: Zadanie domowe |
Moduł 7: SPI |
Lekcja 1: Powitanie |
Lekcja 2: Potrzebne narzędzia w tym tygodniu |
Lekcja 3: Czym jest SPI? |
Lekcja 3a: Tryb 9-bitowy |
Lekcja 4: Przegląd opcji SPI w CubeMX |
Lekcja 5: TFT: Teoria |
Lekcja 6: TFT: Dokumentacja kontrolera |
Lekcja 7: TFT: TFT: Co z biblioteką? |
Lekcja 8: TFT: Jak ustawić SPI? |
Lekcja 9: TFT: Init |
Lekcja 10: TFT: Analizator logiczny i Init |
Lekcja 11: TFT: Piksel |
Lekcja 12: TFT: Optymalizacja lekka |
Lekcja 13: TFT: Optymalizacja SPI |
Lekcja 14: TFT: Optymalizacja kasowania ekranu |
Lekcja 15: TFT: Kończenie optymalizacji |
Lekcja 16: TFT: GFX Color |
Lekcja 17: TFT: GFX Grafiki |
Lekcja 18: TFT: Obsługa rotacji |
Lekcja 19: Czcionki: Jak lepiej rysować? |
Lekcja 20: Czcionki: Generator |
Lekcja 21a: Czcionki: Implementacja rysowania: Początek |
Lekcja 21b: Czcionki: Implementacja rysowania: Znak |
Lekcja 21c: Czcionki: Implementacja rysowania: String |
Lekcja 21d: Czcionki: Implementacja rysowania: Spacja |
Lekcja 22: Polska czcionka: Teoria |
Lekcja 23: Polska czcionka: Generator i przygotowanie |
Lekcja 24: Polska czcionka: Implementacja |
Lekcja 25: Touch Panel: Teoria |
Lekcja 26: Touch Panel: Dokumentacja |
Lekcja 27: Touch Panel: Kłopotliwe przerwanie |
Lekcja 28: Touch Panel: Konfiguracja Cube |
Lekcja 29: Touch Panel: Wygląd biblioteki |
Lekcja 30a: Touch Panel: Pisanie biblioteki: Odczyt surowych danych z Kontrolera |
Lekcja 30b: Touch Panel: Pisanie biblioteki: Dane kalibracyjne |
Lekcja 30c: Touch Panel: Pisanie biblioteki: Przeliczenie kalibracji |
Lekcja 30d: Touch Panel: Pisanie biblioteki: Zbieranie próbek |
Lekcja 30e: Touch Panel: Pisanie biblioteki: Odczyt wciśniętego punktu |
Lekcja 30f: Touch Panel: Pisanie biblioteki: Procedura kalibracji |
Lekcja 31: TFT + Touch Panel: Paint |
Moduł 8: Karta SD |
Lekcja 1: Powitanie |
Lekcja 2: Potrzebne narzędzia w tym tygodniu |
Lekcja 3: Karta pamięci: Teoria |
Lekcja 4: Karta pamięci: Interfejsy |
Lekcja 5: Karta pamięci: FatFS |
Lekcja 6: Dokumentacja |
Lekcja 7: Przegląd opcji w CubeMX |
Lekcja 8: Karta pamięci na SPI: Kod |
Lekcja 9: Karta pamięci na SPI: FatFS - pisanie do pliku |
Lekcja 10: Karta pamięci na SPI: FatFS - czytanie z pliku |
Lekcja 11: Karta pamięci na SPI: Obraz z SD na TFT |
Lekcja 12: Karta pamięci na SDIO: DMA |
Lekcja 13: Karta pamięci na SDIO: 1 bit |
Lekcja 14: Karta pamięci na SDIO: 4 bit |
Lekcja 15: Biblioteka LIBJPEG: Teoria |
Lekcja 16: Biblioteka LIBJPEG: Kod |
Lekcja 17: Biblioteka LIBJPEG: Kod - Debug |
Lekcja 18: Pokaz slajdów na TFT z użyciej JPEGów |
Lekcja 19: Zadanie domowe |
Moduł 9: USB |
Lekcja 1: Powitanie |
Lekcja 2: Potrzebne narzędzia w tym tygodniu |
Lekcja 3: USB: Teoria |
Lekcja 4: USB: Zegary w STM32 |
Lekcja 5: USB VCOM / CDC: Teoria |
Lekcja 6: USB VCOM / CDC: Kod - nadawanie |
Lekcja 7: USB VCOM / CDC: Kod - odbiór |
Lekcja 8: USB MSC Device: Teoria |
Lekcja 9: USB MSC Device: Kod, pendrive z STM32 |
Lekcja 10: USB HID Device: Teoria |
Lekcja 11: USB HID Device: Kod, myszka |
Lekcja 12: USB HID Device: Kod, myszka + joystick |
Lekcja 13: USB HID Device: Kod, klawiatura |
Lekcja 14: USB MSC Host: Teoria |
Lekcja 15: USB MSC Host: FatFS |
Lekcja 16: USB MSC Host: Kod |
Lekcja 17: Pokaz slajdów na TFT |
Lekcja 18: Zadanie domowe |
Moduł 10: Low Power |
Lekcja 1: Powitanie |
Lekcja 2: Potrzebne narzędzia w tym tygodniu |
Lekcja 3: Low Power: Teoria |
Lekcja 4: Low Power: Tryby |
Lekcja 5: Low Power w dokumentacji |
Lekcja 6: Kalkulator zużycia energii w CubeMX |
Lekcja 7: Sleep Mode: Teoria |
Lekcja 8: Sleep Mode: Dokumentacja |
Lekcja 9: Sleep Mode: Kod |
Lekcja 10: Stop Mode: Teoria |
Lekcja 11: Stop Mode: Dokumentacja |
Lekcja 12: Stop Mode: Kod |
Lekcja 13: Standby Mode: Teoria |
Lekcja 14: Standby Mode: Dokumentacja |
Lekcja 15: Standby Mode: Kod |
Moduł 11: Co dalej? |
Lekcja 1: Powitanie |
Lekcja 2: HAL to dopiero początek |
Lekcja 3: Możliwości innych mikrokontrolerów STM32 |
Lekcja 4: Biblioteki Middleware, Frameworki, Protokoły |
Lekcja 5: Wiedza z zakresu elektroniki |
Lekcja 6: Własne projekty |
Lekcja 7: Przeniesienie projektu na własne PCB |
Lekcja 8: Pierwsza praca w embedded? |
Lekcja 9: Dzielenie się wiedzą |
Lekcja 10: Aktualizacje do kursu |
Lekcja 11: Słowo na zakończenie |
Lekcja 12: Praca domowa |
Moduł 11: Co dalej? |
Lekcja 1: Powitanie |
Lekcja 2: HAL to dopiero początek |
Lekcja 3: Możliwości innych mikrokontrolerów STM32 |
Lekcja 4: Biblioteki Middleware, Frameworki, Protokoły |
Lekcja 5: Wiedza z zakresu elektroniki |
Lekcja 6: Własne projekty |
Lekcja 7: Przeniesienie projektu na własne PCB |
Lekcja 8: Pierwsza praca w embedded? |
Lekcja 9: Dzielenie się wiedzą |
Lekcja 10: Aktualizacje do kursu |
Lekcja 11: Słowo na zakończenie |
Lekcja 12: Praca domowa |
Aktualnie zapisy do kursu są zamknięte. Nie przegap kolejnego otwarcia i zapisz się na listę oczekujących.
Najbliższy planowany termin otwarcia: 8 MAJA 2024
Jeżeli masz dodatkowe pytania - pisz do mnie na mateusz@msalamon.pl