KURS STM32 DLA POCZĄTKUJĄCYCH
NAJLEPSZY KURS DO NAUKI STM32 W POLSCE!
Co zyskasz dołączając do kursu?
Zbudujesz swoje pierwsze urządzenia
Poznasz kluczowe peryferia mikrokontrolera
Przejdziesz przez cały proces z instrukorem
Otrzymasz 11 modułów szkolenia Online
Nauczysz się współpracować ze sprzętem
Nauczysz się pisać nieblokujący kod
Będziesz pisał własne biblioteki
Nauczysz się optymalizować kod i biblioteki
Poznasz ludzi takich jak Ty!
Kurs zawiera rozszerzenie do najnowszej rodziny STM32G4!
Cały czas wychodzą nowe rodziny mikrokontrolerów STM32.
Dlaczego masz się uczyć tylko tych najstarszych?
Nie ma takiej opcji! W marcu 2023 kurs przeszedł aktualizację do rodziny G4.
Aktualizacja jest w formie suplementu, więc nie tracisz poprzednich materiałów!
Naucz się jednodcześnie rodzin STM32 F4 i G4!
A OPRÓCZ TEGO:
- Dożywotni DOSTĘP DO GRUPY DISCORD "Akademia Embedded"
- Kompletny SPRZĘT do wykonania wszystkich kodów z kursu o wartości 300 PLN (Tylko w wersji ze sprzętem)
W POPRZEDNICH EDYCJACH WZIĘŁO PONAD 800 KURSANTÓW!
OPINIE
Co otrzymasz dołączając do kursu?
- Program Kurs STM32 dla Początkujących (~50h dla STM32F4 i ~13h dla STM32G4 kursu video)
- Cokwartalny LIVE Q&A Na Żywo z Mateuszem + Archiwum
- Dostęp do Bibliotek oraz Pełnych Kodów pisanych w Kursie
- Dożywotni Dostęp do Kursu Oraz Aktualizacji
- Dożywotni Dostęp Do Grupy Discord "Kurs STM32 Dla Początkujących"
- Kompletny sprzęt do wykonania wszystkich kodów z kursu (Wartość 300 PLN) (Tylko w wersji ze sprzętem)
JAK WYGLĄDA DROGA KURSANTA?
Sprzęt do kursu
Możesz kupić Kurs STM32 dla Początkujących razem z kompletnym sprzętem, który umożliwi Ci wykonywanie ćwiczeń. W zestawie znajdziesz wszystko* z czego korzystam w lekcjach. Obok każdej pozycji znajdują się linki do konkretnych produktów w sklepie. W skład hardware'u wchodzi:
- Nucleo-G474RE (LINK)
- Wyświetlacz OLED 0.96 I2C niebieski (LINK)
- Wyświetlacz TFT 2.4" SPI z panelem dotykowym na SPI (LINK)
- Czujnik BMP280 na I2C (LINK)
- Czytnik kart microSD na SPI i SDIO w jednym (LINK)
- Dioda LED 4 szt. (LINK)
- Rezystor do diody 4 szt. (LINK)
- Przyciski 4 szt. (LINK)
- Potencjometr 10k (LINK)
- Joystick (LINK)
- Mikrofon analogowy (LINK)
- Przejściówka micro USB na goldpin (LINK)
- Przejściówka USB A na goldpin (LINK)
- Przewód USB micro do Nucleo i do ćwiczeń na USB (LINK)
- Płytka stykowa 830 pól (LINK)
- Przewody żeńsko-żeńskie 40 szt. (LINK)
- Przewody męsko-żeńskie 40 szt. (LINK)
- Przewody męsko-męskie 40 szt. (LINK)
Masz inne Nucleo? Sprawdź, czy podejdzie do kursu TUTAJ!
*Karta micro SD oraz Pendrive USB nie są na wyposażeniu zestawu
TWÓJ INSTRUKTOR
Mateusz Salamon
Na co dzień programista embedded. Z wykształcenia automatyk, robotyk i elektronik.
Od ponad 10 lat programuje mikrokontrolery. Pierwsze kroki stawiał na mikrokontrolerach 8051 pisząc w asemblerze, później przechodząc na AVR posiadł umiejętność pisania w języku C. Od wielu lat skupia się na programowaniu mikrokontrolerów STM32.
Momentem przełomowym była chęć zmiany pracy, kiedy to postanowił samemu nauczyć się nowej architektury, która aktualnie króluje w embedded. Wtedy wykorzystując swoją wiedzę na temat mikrokontrolerów AVR, nauczył się architektury ARM - głównie STM32.
Wtedy nie było w polskim Internecie zbyt wiele materiałów do nauki. Po wielomiesięcznej samodzielnej nauce postanowił stworzyć przyjazne miejsce początkującym programistom STM32.
W taki sposób od ponad dwóch lat chętnie dzieli się swoją wiedzą na temat programowania STM32 prowadząc bloga msalamon.pl, którego odwiedza miesięcznie kilka tysięcy czytelników.
Zawartość programu
| Lekcja 1: Powitanie |
| Lekcja 2: Plan Gry |
| Lekcja 3: Efekt Końcowy |
| Lekcja 4: Wymagania |
| Lekcja 5: Jak Studiować? |
| Lekcja 6: Platforma Nucleo |
| Lekcja 7: Aktualizacja kursu do NUCLEO-G474RE |
| Lekcja 8: Zadanie Domowe |
| Lekcja 1: Powitanie |
| Lekcja 2: Sprzęt do kursu |
| Lekcja 2 G4: NUCLEO-G474RE |
| 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 22 G4: GPIO Input/Output/Alternate |
| 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 26-28 G4: Miganie diodą – Kod |
| Lekcja 29: Czytanie wejścia - Kod |
| Lekcja 29 G4: Czytanie wejścia – Kod |
| Lekcja 30: Miganie wieloma diodami - Timer programowy |
| Lekcja 31: Timery programowy - Kod |
| Lekcja 31 G4: 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 35 G4: Prosta maszyna stanów – Kod |
| Lekcja 36: Dokładanie stanów - Teoria |
| Lekcja 37: Dokładanie stanów - Kod |
| Lekcja 37 G4: Dokładanie stanów – Kod |
| Lekcja 38: Zadanie domowe |
| Bonus 1: Kopiowanie projektów CubeIDE |
| 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 9 G4: Przerwania, NVIC, priorytety |
| Lekcja 10: Przerwania i EXTI w dokumentacji |
| Lekcja 10 G4: 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 14 G4: Obsługa przerwania EXTI – Kod |
| Lekcja 15: Debugowanie przerwania |
| Lekcja 16: UART - Teoria |
| Lekcja 16 G4: UART / LPUART |
| Lekcja 17: Port szeregowy na PC |
| Lekcja 18: UART - Polling teoria |
| Lekcja 19: UART - Transfer blokujący |
| Lekcja 19 G4: UART – Transfer blokujący |
| Lekcja 20: UART - Odbiór blokujący |
| Lekcja 20 G4: 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 23 G4: 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 29 G4: 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 31 G4: Parsowanie komend – Proste |
| 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 32 G4: Parsowanie komend – Złożone |
| 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 33 G4: DMA |
| 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 38 G4: UART – Transfer DMA |
| Lekcja 39 G4: UART – Odbiór DMA |
| Lekcja 40: Zadanie domowe |
| Bonus 1: UART - Odbiór DMA na rejestrach |
| Bonus 2: UART - Transfer DMA na rejestrach |
| Lekcja 1: Powitanie |
| Lekcja 2: Potrzebne narzędzia w tym tygodniu |
| Lekcja 3: Timery: Teoria |
| Lekcja 4: Tryby Timerów |
| Lekcja 4 G4: Nowe rodzaje timerów, różnice w G4 |
| Lekcja 5: SysTick Timer |
| Lekcja 6: Tryb Normal: Teoria |
| Lekcja 7: Tryb Normal: Kod |
| Lekcja 7 G4: Tryb Normal: Kod |
| Lekcja 8: Tryb Input Capture: Teoria |
| Lekcja 9: Tryb Input Capture: Kod |
| Lekcja 9 G4: Tryb Input Capture: Kod |
| Lekcja 10: Tryb Output Compare: Teoria |
| Lekcja 11: Tryb Output Compare: Kod |
| Lekcja 11 G4: 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 15 G4: Tryb PWM: Kod |
| Lekcja 16: Slave w Timerach: Teoria |
| Lekcja 17: Slave: Reset Mode |
| Lekcja 17 G4: Slave: Reset Mode |
| Lekcja 18: Slave: Gated Mode |
| Lekcja 18 G4: Slave: Gated Mode |
| Lekcja 19: Tryb One-pulse Mode: Teoria |
| Lekcja 20: Tryb One-pulse Mode: Kod |
| Lekcja 20 G4: Tryb One-Pulse: Kod |
| Lekcja 20a G4: Tryb One-Pulse, ręczne wyzwalanie: Kod |
| Lekcja 21: Watchdog: Teoria |
| Lekcja 21 G4: Watchdog: Teoria |
| Lekcja 22: Watchdog: IWDG Kod |
| Lekcja 22 G4: Watchdog: IWGD Kod |
| Lekcja 23: Watchdog: WWDG Kod |
| Lekcja 23 G4: Watchdog: WWDG Kod |
| Lekcja 24: RTC: Teoria |
| Lekcja 24 G4: RTC: Teoria |
| Lekcja 25: RTC: Czas i Kalendarz |
| Lekcja 25 G4: RTC: Czas i Kalendarz |
| Lekcja 26: RTC: Podtrzymanie |
| Lekcja 26 G4: RTC: Podtrzymanie |
| Lekcja 27: RTC: Alarmy |
| Lekcja 27 G4: RTC: Alarmy |
| Lekcja 28: RTC: Wake-up |
| Lekcja 28 G4: RTC: Wake-up |
| Lekcja 29: RTC: Time Stamp |
| Lekcja 29 G4: RTC: Time Stamp |
| Lekcja 30: RTC: Tamper |
| Lekcja 30 G4: RTC: Tamper |
| Lekcja 31: Zadanie domowe |
| Lekcja 1: Czujnik HC-SR04 |
| Lekcja 2: Czujnik HC-SR04 – Sposób blokujący |
| Lekcja 3: Czujnik HC-SR04 – Sposób blokujący – Kod |
| Lekcja 4: Czujnik HC-SR04 – Nieblokujący odczyt |
| Lekcja 5: Czujnik HC-SR04 – Nieblokujący odczyt – Kod |
| Lekcja 6: Czujnik HC-SR04 – Pomiar autonomiczny |
| Lekcja 7: Czujnik HC-SR04 – Pomiar autonomiczny – Kod |
| Lekcja 8: Czujnik HC-SR04 – Sprzątanie i podsumowanie |
| Lekcja 1: Powitanie |
| Lekcja 2: Potrzebne narzędzia w tym tygodniu |
| Lekcja 3: Czy jest ADC? |
| Lekcja 4: Jak działa ADC? |
| Lekcja 4 G4: Najważniejsze funkcje ADC dla F4 i G4 |
| Lekcja 5: Przegląd opcji ADC w CubeMX |
| Lekcja 6: Tryb Single Channel: Teoria |
| Lekcja 7: Tryb Single Channel: Kod, Polling |
| Lekcja 7 G4: Tryb Single Channel – Kod – Polling |
| Lekcja 8: Tryb Single Channel: Kod, Przerwania |
| Lekcja 8 G4: Tryb Single Channel – Kod – Przerwania |
| Lekcja 9: Tryb Single Channel: Kod, DMA |
| Lekcja 9 G4: Tryb Single Channel – Kod – DMA |
| Lekcja 10: Tryb Multi Channel: Teoria |
| Lekcja 11: Tryb Multi Channel: Kod, Polling |
| Lekcja 11 G4: Tryb Multi Channel – Kod – Polling |
| Lekcja 12: Tryb Multi Channel: Kod, Przerwania |
| Lekcja 13: Tryb Multi Channel: Kod, DMA |
| Lekcja 13 G4: Tryb Multi Channel – Kod – DMA |
| Lekcja 14: Watchdog analogowy: Teoria |
| Lekcja 15: Watchdog analogowy: Kod |
| Lekcja 15 G4: Watchdog analogowy – Kod |
| Lekcja 16: Potencjometr + LED PWM: Teoria |
| Lekcja 17: Potencjometr + LED PWM: Kod, Polling |
| Lekcja 17 G4: Potencjometr + LED PWM – Kod – Polling |
| Lekcja 18: Potencjometr + LED PWM: Kod, Przerwania |
| Lekcja 18 G4: Potencjometr + LED PWM – Kod – Przerwania |
| Lekcja 19: Potencjometr + LED PWM: Kod, DMA |
| Lekcja 19 G4: Potencjometr + LED PWM – Kod – DMA |
| Lekcja 20: Automatyczna konwersja z Timerem: Teoria |
| Lekcja 21: Automatyczna konwersja z Timerem: Kod |
| Lekcja 21 G4: Automatyczna konwersja z Timerem – Kod |
| Lekcja 22: Tryb Injected Mode: Teoria |
| Lekcja 23: Tryb Injected Mode: Kod |
| Lekcja 23 G4: Tryb Injected Mode – Kod |
| Lekcja 24: Tryb Injected Mode + Regular: Kod |
| Lekcja 24 G4: Tryb Injected Mode + Regular – Kod |
| Lekcja 25: Odczyt z mikrofonu przy okazji innych konwersji: Teoria |
| Lekcja 26: Odczyt z mikrofonu przy okazji innych konwersji: Kod |
| Lekcja 26 G4: Odczyt z mikrofonu przy okazji innych konwersji – Kod |
| Lekcja 27: Czy działa ten mikrofon? |
| Lekcja 27 G4: Czy działa ten mikrofon? |
| Lekcja 28: DSP: FFT mikrofonu, Teoria |
| Lekcja 29: DSP: FFT mikrofonu, Kod |
| Lekcja 29 G4: DSP – FFT mikrofonu, Kod |
| Lekcja 30: Zadanie domowe |
| 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 4 G4: Pozostałe ficzery i różnice I2C dla G4 |
| Lekcja 5: I2C: Czy potrzebny jest translator napięć? |
| Lekcja 6: BMP280: Teoria |
| Lekcja 7: BMP280: Dokumentacja |
| Lekcja 8: Skaner I2C |
| Lekcja 8 G4: 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 10 G4: BMP280, uruchomienie na G4 |
| 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 15-21 G4: OLED, uruchomienie na G4 |
| Lekcja 22: Wyświetlenie danych z BMP280 |
| Lekcja 23: Podkręcenie I2C + DMA |
| Lekcja 22-23 G4: Wyświetlenie danych z BMP280 |
| Lekcja 24: Wyświetlenie FFT mikrofonu |
| Lekcja 24 G4: Wyświetlenie FFT mikrofonu |
| 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 4 G4: Pozostałe ficzery i różnice SPI dla G4 |
| 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 30 G4: Uruchomienie TFT + Touch na G4 |
| Lekcja 31: TFT + Touch Panel: Paint |
| Lekcja 31 G4: TFT + Touch Panel: Paint |
| Lekcja 32: Zadanie domowe |
| 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 5 G4: Karta SD na G4 |
| 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 8-10 G4: Dostosowanie FatFS do SPI na G4 |
| Lekcja 11: Karta pamięci na SPI: Obraz z SD na TFT |
| Lekcja 11 G4: Obrazy z SD na TFT na G4 |
| 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 16 G4: SDLIBJPEG na G4 |
| Lekcja 17: Biblioteka LIBJPEG: Kod - Debug |
| Lekcja 18: Pokaz slajdów na TFT z użyciej JPEGów |
| Lekcja 18 G4: Pokaz slajdów na TFT na G4 |
| Lekcja 19: Zadanie domowe |
| Lekcja 1: Powitanie |
| Lekcja 2: Potrzebne narzędzia w tym tygodniu |
| Lekcja 3: USB: Teoria |
| Lekcja 3 G4: USB w G4 |
| Lekcja 4: USB: Zegary w STM32 |
| Lekcja 5: USB VCOM / CDC: Teoria |
| Lekcja 6: USB VCOM / CDC: Kod - nadawanie |
| Lekcja 6 G4: USB VCOM / CDC: Kod – nadawanie |
| Lekcja 7: USB VCOM / CDC: Kod - odbiór |
| Lekcja 7 G4: USB VCOM / CDC: Kod – odbiór |
| Lekcja 8: USB MSC Device: Teoria |
| Lekcja 9: USB MSC Device: Kod, pendrive z STM32 |
| Lekcja 9 G4: USB MSC Device: Kod, pendrive z STM32 |
| Lekcja 10: USB HID Device: Teoria |
| Lekcja 11: USB HID Device: Kod, myszka |
| Lekcja 11 G4: USB HID Device: Kod, myszka |
| Lekcja 12: USB HID Device: Kod, myszka + joystick |
| Lekcja 12 G4: USB HID Device: Kod, klawiatura |
| 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 |
| BONUS 1 – USB Composite Device |
| 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 |
| Lekcja 16 G4: Low Power w G4 |
| Lekcja 17 G4: Sleep Mode G4 |
| Lekcja 18 G4: Low-Power Run G4 |
| Lekcja 19 G4: Low-Power Sleep Mode G4 |
| Lekcja 20 G4: Stop 0 / Stop 1 Mode G4 |
| Lekcja 21 G4: Standby Mode G4 |
| Lekcja 22 G4: Shutdown Mode G4 |
| 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 |
Przykładowe lekcje w kursie
GWARANCJA
SATYSFAKCJI
Przygotowałem materiały tak, aby dały Ci 10x więcej wartości niż oczekujesz. Jeżeli z jakiegoś powodu kurs jednak nie będzie dla Ciebie odpowiedni, to wystarczy, że napiszesz na adres mateusz@msalamon.pl i zwrócę Ci 100% Twojej wpłaty. Masz na to 14 dni od daty zakupu.
Moim celem jest danie Ci jak najwięcej wartości i pokazanie Ci, że ten program nauki pozwoli Ci na samodzielne programowanie mikrokontrolerów STM32. Z tymi umiejętnościami będziesz również łatwiej mógł znaleźć pierwszą pracę w embedded. Gdy Ty wygrywasz, to i ja wygrywam. Zależy mi na Twoim sukcesie.
W poprzednich edycjach kursu wzięło udział ponad 800 osób!
Zamówienia spływają co kilka minut, a pakiety ze sprzętem szybko się rozchodzą! Nie warto zwlekać, bo może okazać się za późno!
Ile za to wszystko?
W tej edycji kurs dostępny jest w jednym z trzech pakietów.
Do wyboru wersje ze sprzętem lub sam kurs.
Możesz jednocześnie przystąpić do innych moich kursów w lepszej cenie:
Kurs STM32
dla Początkujących
+
Zestaw sprzętu
2197 zł
Najniższa cena z ostatnich 30 dni przed obniżką: 4297 zł
Kurs STM32 dla Początkujących
+
Kurs FreeRTOS
+
Kurs Język C dla Mikrokontrolerów
+
Zestaw sprzętu
3397 zł
Najniższa cena z ostatnich 30 dni przed obniżką: 8291 zł
Kurs STM32dla Początkujących
1897 zł
Najniższa cena z ostatnich 30 dni przed obniżką: 3997 zł
Kurs STM32 dla Początkujących
+
Kurs FreeRTOS
+
Kurs Język C dla Mikrokontrolerów
3097 zł
Najniższa cena z ostatnich 30 dni przed obniżką: 7991 zł
Możliwość zakupu na Raty 0%!
Od pewnego czasu daję możliwość rozłożenia płatności na raty! 🥳
Są to Raty 0%, czyli nie płacisz nic więcej!
W tej opcji dostępne jest rozbicie na 3, 4, 5, 10 lub nawet 20 rat 0%.
Jeśli jesteś zainteresowany zakupem na Raty 0%, napisz do mnie na mateusz@msalamon.pl
Co zawierają pozostałe kursy dostępne w pakietach?
Kliknij na logo kursu, aby wejść na stronę z jego opisem
Oferta dla Firm
Wiem, że w firmach proces zamawiania szkoleń jest nieco wydłużony. Z tego względu przygotowałem ofertę dedykowaną dla firm. Co w niej znajdziesz?
- Zgłoś chęć przystąpienia grupowego do końca terminu sprzedażowego (17.05.2024 godz. 23:59:59)
- Do każdych 10-ciu zakupionych dostępów - jeden gratis!
- Faktura Proforma + Faktura VAT po opłaceniu
- Zakończenie rozliczenia na spokojnie po zamknięciu sprzedaży 17.05.2024
- Dostęp dla pracowników w formie kodów -100% ceny na zakup kursu
- Kontakt i zamówienia mailowo: mateusz@msalamon.pl
Podeślij swojemu szefowi poniższą broszurę :)
Najczęściej zadawane pytania
1. Kiedy rusza kurs?
Dostęp do kursu dostaniesz zaraz po zakupie. Zostaniesz automatycznie dodany od razu po opłaceniu zamówienia. Kurs jest już gotowy i czeka na Ciebie.
2. Kurs będzie na HALu czy na rejestrach?
Kurs opieram na bibliotekach HAL.
3. Kiedy otrzymam sprzęt?
Sprzęt wysyłam na drugi dzień od opłacenia zamówienia.
4. Założyłem konto w sklepie, ale nie mam hasła?
Cierpliwości. Pierwsze automatycznie wygenerowane hasło przyjdzie w ciągu kilku chwil. Hasło możesz, a nawet powinieneś zmienić.
5. W jakiej formie jest kurs?
Jest to kurs video. Zarówno teoria (przy tablicy) jak i praktyka (przy komputerze) realizowana jest w formie wideo.
6. Jak długie są filmy?
Na ogół nie przekraczają 30 minut na lekcję. Te długie są to filmy z pracą z kodem. Bardzo długie projekty zostały podzielone tematycznie na mniejsze lekcje.
7. Czy będzie dostęp offline?
Nie. Platforma kursu nie umożliwia takiej formy nauki.
8. Czy można pobrać filmy?
Nie. Platforma kursu nie umożliwia takiej formy nauki.
9. Jaki dokładniej sprzęt będzie użyty w kursie?
Dodałem linki prowadzące do produktów w sklepie. Są to dokładnie te elementy, które użyłem w kursie.
10. Jaki typ kart microSD jest preferowany?
Prawie dowolna. Zauważyłem, że karty powyżej 4 GB czasem mają problem z działaniem Jest na to sposób - utworzenie partycji 4GB na takiej większej karcie.
11. Czy potrzebuję coś już wiedzieć przed rozpoczęciem?
Tak. Zakładam, że potrafisz się już poruszać po języku C. Może to być doświadczenie np. z Arduino. Oczywiście przyda się również język angielski.
12. Od kiedy liczona jest gwarancja zwrotu?
Gwarancja zwrotu obejmuje 14 dni od daty zakupu kursu.
13. Z jakich bibliotek będziemy korzystać w kursie?
Kurs opieram na bibliotekach HAL od ST. Uważam, że programowanie przy pomocy HALa jest bardzo dobrym pomysłem jeśli chodzi o wdrażanie się w świat mikrokontrolerów STM32. Skupiamy się na szybkich efektach jednocześnie nie porzucając wiedzy o sprzęcie.
14. W czym będziemy pisać projekty?
Skorzystamy z dostarczanego przez ST pakietu STM32CubeIDE. Znajduje się w nim wszystko to, czego potrzebujemy do pracy z STM32.
15. Czy udostępniasz kody?
Tak. Wszyscy kursanci mają dostęp do omawianych w kursie kodów i bibliotek.
16. Czy będę potrzebował jeszcze w coś zainwestować?
Będziesz potrzebował dodatkowo kartę microSD oraz pendrive USB. Myślę, że każdy ma taki sprzęt w domu.
17. Ile trwa program?
Kurs zaplanowany jest na 11 modułów. Jednak materiału jest na tyle dużo, że wielu kursantów przerabia materiał nieco dłużej jak np. pół roku.
18. Kiedy dostanę dostęp do poszczególnych modułów?
Kurs jest dostępny dla Ciebie w całości od razu. Zalecam jednak przechodzenie go po kolei, bo wiedza z modułów wcześniejszych wykorzystywana jest w kolejnych.
19. Jak wyglądają LIVE Q&A?
Odbywają się przy pomocy Google Meet i dzielą się na 2 części. Najpierw przedstawiam opracowania na zadawane wcześniej przez formularz pytania. Później swobodnie dyskutujemy na tematy związane z elektroniką i programowaniem.
20. Czy planujesz aktualizacje?
Tak. Wszystkie przyszłe aktualizacje oraz dodatkowe moduły będziesz miał za darmo! Zarówno te małe, jak i te duże!
21. Czy termin 17.05.2024 godz. 23:59 jest ostateczny?
Tak. Jest to termin składania zamówienia. Natomiast od zakończenia sprzedaży masz kolejne 7 dni na opłacenie. Później zamówienie jest anulowane bez możliwości wznowienia.
22. Kiedy następna edycja?
Zastanawiam się :)
23. Czy wystawiasz faktury VAT?
Tak, wystawiam faktury VAT. Po opłaceniu zamówienia otrzymasz automatycznie fakturę wygenerowaną przez mój system zakupowy.
24 Jeśli mam dodatkowe pytania?
Napisz do mnie na adres e-mail: mateusz@msalamon.pl
Odpowiadam na każdego maila