Tak, zapisuję się na listę oczekujących.

Chciałbyś nauczyć się programować układy, które są na topie?

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.

Chciałbyś zdobyć pierwszą pracę w branży embedded?

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ć.

Podnieś kwalifikacje swojego zespołu

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.

Kim jestem?

Co otrzymasz w programie?

Zbudujesz swoje pierwsze urządzenia

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ą.

Poznasz kluczowe peryferia mikrokontrolera

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?

Przejdziesz przec cały proces z instruktorem

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.

Otrzymasz 11 modułów szkolenia online

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.

Nauczysz się współpracować ze sprzętem

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.

Nauczysz się pisać nieblokujący kod

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.

Będziesz pisał własne biblioteki

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ę.

Optymalizacja kodu

Nauczysz się optymalizować kod i biblioteki. Twój program będzie działał szybciej i będziesz wiedział dlaczego.

Poznasz ludzi takich jak Ty!

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.

Agenda programu

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: 2 Kwietnia 2025

Zapisuję się na listę oczekujących

Jeżeli masz dodatkowe pytania - pisz do mnie na mateusz@msalamon.pl