„Kurs FreeRTOS na STM32 dla początkujących” został dodany do koszyka. Zobacz koszyk
Język C dla Mikrokontrolerów
Język C dla Mikrokontrolerów
Kurs Języka C dla Mikrokontrolerów to praktyczne wprowadzenie do programowania w C. Nauczysz się wskaźników, operacji bitowych, struktur i optymalizacji kodu. Wszystkie lekcje to nagrania wideo, które przerabiasz we własnym tempie. Masz 2 lata dostępu do kursu, aktualizacji i Discorda. Po tym czasie możesz przedłużyć dostęp za 10% ceny kursu. 🚀
Zdobądź solidne podstawy języka C i naucz się programować mikrokontrolery od podstaw!
Jeśli chcesz opanować język C z myślą o pracy z mikrokontrolerami, ten kurs jest dla Ciebie. Bez zbędnej teorii, tylko praktyczne podejście, które od razu pozwoli Ci pisać wydajny i dobrze zorganizowany kod. To idealna ścieżka zarówno dla początkujących, jak i tych, którzy chcą ugruntować swoją wiedzę i lepiej zrozumieć programowanie embedded.
Zobacz krótkie wprowadzające video
📚 Co zyskasz, dołączając do kursu?
✅ Napiszesz swoje pierwsze programy w C – bez konieczności instalowania skomplikowanego oprogramowania, na gotowych przykładach. ✅ Zrozumiesz podstawowe elementy języka C – zmienne, tablice, struktury, operacje bitowe i wskaźniki (bez tajemnic!). ✅ Nauczysz się dobrych praktyk programistycznych – zamiast uczyć się na błędach, od razu zaczniesz pisać kod w optymalny sposób. ✅ Poznasz podejście obiektowe w języku C – choć C nie jest językiem obiektowym, pokażę Ci, jak stosować pseudoobiektowość. ✅ Podzielisz kod na moduły i warstwy – koniec z chaotycznym kodem, nauczysz się organizować projekty jak profesjonalista. ✅ Weźmiesz udział w sesjach LIVE – raz na jakiś czas masz możliwość zadania pytań na godzinnym Q&A z instruktorem. ✅ Dołączysz do zamkniętej społeczności kursantów – wymieniaj się doświadczeniami i ucz się szybciej dzięki wsparciu innych. ✅ Otrzymasz dostęp do 8 modułów szkoleniowych – w każdym nawet 50 lekcji wideo, które przeprowadzą Cię od podstaw do zaawansowanych tematów.
📚 Czego nauczysz się w kursie?
Kurs Języka C dla Mikrokontrolerów to nie tylko podstawowa składnia, ale także praktyczne podejście do programowania w embedded. Po ukończeniu kursu będziesz potrafił pisać wydajny, dobrze zorganizowany i skalowalny kod, a także zrozumiesz, jak język C działa w kontekście mikrokontrolerów.
Zawartośc kursu obejmuje wszystkie kluczowe zagadnienia, które są niezbędne do skutecznego programowania w C – zarówno w aplikacjach ogólnych, jak i w systemach embedded. Podzieliłem cały materiał na najważniejsze składowe języka, aby nauka była logiczna i uporządkowana.
🔹 1. Podstawy języka C
✅ Deklaracja, definicja i inicjalizacja zmiennych – czym się różnią i jak ich używać? ✅ Typy danych i ich rozmiary – jak przechowywane są zmienne w pamięci? ✅ Operatory arytmetyczne, logiczne i bitowe – podstawowe operacje w C. ✅ Łączność i kolejność operatorów – jak poprawnie interpretować działania matematyczne? ✅ Instrukcje sterujące (if, switch) – podejmowanie decyzji w programie. ✅ Pętle (for, while, do-while) – sterowanie powtarzalnością kodu. ✅ Instrukcje break i continue – jak efektywnie sterować pętlami?
🔹 2. Zarządzanie pamięcią i operacje na danych
✅ Ile miejsca w pamięci zajmuje struktura? – optymalizacja kodu pod kątem oszczędności RAM. ✅ Rzutowanie typów danych – konwersja i przekształcanie wartości w kodzie. ✅ Struktury i unie – jak przechowywać złożone dane? ✅ Maskowanie bitów i operacje bitowe – zarządzanie rejestrami i flagami systemowymi. ✅ Przesunięcia bitowe (<<, >>) – jak wykorzystywać je do optymalizacji? ✅ Wyboru pojedynczych bitów do operacji – efektywne manipulowanie danymi.
🔹 3. Wskaźniki i dynamiczna alokacja pamięci
✅ Czym jest wskaźnik? – fundamentalne pojęcie w C. ✅ Wskaźniki w argumentach funkcji – jak przekazywać zmienne bez ich kopiowania? ✅ Wskaźnik na funkcję – dynamiczne przypisywanie funkcji, wykorzystywane w systemach embedded. ✅ Wskaźniki typu void* – praca z nieokreślonymi danymi. ✅ Dynamiczna alokacja pamięci (malloc, calloc, free) – zarządzanie pamięcią w aplikacjach embedded.
🔹 4. Funkcje i organizacja kodu
✅ Tworzenie funkcji w C – jak zbudować efektywne funkcje? ✅ Przekazywanie argumentów do funkcji – wartość vs. wskaźnik. ✅ Funkcje rekurencyjne – kiedy i jak je stosować? ✅ Extern i pliki nagłówkowe (.h) – zarządzanie wieloplikowymi projektami. ✅ Funkcje inline i optymalizacja kompilatora – jak pisać szybki kod? ✅ Funkcje weak – jak umożliwić modyfikację kodu bez ingerencji w główne funkcje programu?
🔹 5. Programowanie modułowe i optymalizacja
✅ Podział kodu na pliki (.c i .h) – jak organizować duże projekty? ✅ Pseudoobiektowość w C – jak stosować zasady programowania obiektowego? ✅ Zarządzanie warstwami kodu – jak budować skalowalne aplikacje? ✅ Kompilacja i linkowanie – jak działa proces kompilacji w C? ✅ Optymalizacja kodu i debugowanie – eliminowanie błędów i poprawa wydajności programu.
🔹 6. C w embedded – praktyczne zastosowanie
✅ Tworzenie projektu w STM32CubeIDE – od zera do gotowego programu. ✅ Podstawy obsługi rejestrów – jak manipulować sprzętem na niskim poziomie? ✅ GPIO i miganie diodą – pierwszy program na mikrokontrolerze. ✅ Uruchomienie programu na STM32 ✅ 3 różne podejścia do biblioteki BMP280 – ile programistów, tyle podejść. Muszisz znać podstawowe z nich i potrafić się do nich dostosować.
🖥️ Z jakiego oprogramowania korzystamy w kursie i dlaczego?
Podczas kursu korzystamy z narzędzi, które są standardem w świecie programowania C i mikrokontrolerów. Dzięki nim możesz uczyć się w sposób praktyczny i wygodny, bez konieczności instalowania skomplikowanego środowiska na samym początku.
🔹 Kompilator online – szybki start bez konfiguracji
Na początkowych etapach kursu korzystamy z kompilatora online, który umożliwia pisanie i uruchamianie kodu bez potrzeby instalowania dodatkowego oprogramowania. To najprostszy sposób na naukę podstaw języka C, zanim przejdziemy do pracy z mikrokontrolerami.
🔹 STM32CubeIDE – profesjonalne środowisko dla embedded
W części kursu związanej z mikrokontrolerami przechodzimy na STM32CubeIDE, oficjalne środowisko programistyczne firmy STMicroelectronics. Jest to zintegrowane narzędzie, które pozwala na: ✔️ Pisanie kodu w C dla mikrokontrolerów STM32 ✔️ Kompilację i debugowanie programów ✔️ Konfigurację sprzętu za pomocą graficznego narzędzia STM32CubeMX ✔️ Obsługę przerwań, pamięci i rejestrów mikrokontrolera
STM32CubeIDE to profesjonalne narzędzie wykorzystywane w rzeczywistych projektach embedded, dlatego jego znajomość jest niezbędna dla każdego, kto chce rozwijać się w tej branży.
🔹 Discord – wsparcie społeczności
Kursanci mają dostęp do serwera Discord, gdzie mogą wymieniać się doświadczeniami, zadawać pytania i otrzymywać wsparcie od instruktora i innych uczestników kursu.
🔹 Google Meet – spotkania LIVE Q&A
Raz na jakiś czas organizujemy sesje na żywo, podczas których można zadawać pytania, rozwiewać wątpliwości i omawiać zaawansowane zagadnienia związane z językiem C i programowaniem mikrokontrolerów. Sesje organizuję dla wszystkich kursantów moich kursów gdy do ankiety Q&A wpadnie wystarczająca ilość nowych pytań, które mogę opracować i zaprezentować na spotkaniu.
💡 Dlaczego takie podejście? 🔸 Stopniowe przechodzenie od teorii do praktyki – zaczynamy od kompilatora online, aby skupić się na składni i logice języka C, a następnie przechodzimy do realnych aplikacji embedded na mikrokontrolery STM32. 🔸 Nauka na profesjonalnym narzędziu – STM32CubeIDE to jedno z najczęściej używanych środowisk w świecie programowania embedded, dlatego jego znajomość otwiera drzwi do prawdziwych projektów. 🔸 Wsparcie społeczności i instruktora – dostęp do Discorda i spotkań na żywo sprawia, że nie uczysz się sam, a każda Twoja wątpliwość może być szybko rozwiązana.
🚀 Dzięki temu zestawowi narzędzi nauka języka C będzie nie tylko efektywna, ale także maksymalnie praktyczna!
🗂️ Agenda kursu – Moduły szkoleniowe
Kurs Język C dla Mikrokontrolerów składa się z 8 modułów, które krok po kroku wprowadzą Cię w świat języka C z naciskiem na rzeczy przydatne w programowaniu mikrokontrolerów. Każdy moduł zawiera teorię i praktyczne lekcje wideo, które pozwolą Ci zdobyć konkretne umiejętności i od razu wykorzystać je w realnych projektach.
🔹 Moduł 1 – Zaczynamy – podstawowe informacje o języku C, pierwsze linie kodu, konfiguracja środowiska. 🔹 Moduł 2 – Pierwsze kroki – typy danych, operatory, pierwsze funkcje i instrukcje warunkowe. 🔹 Moduł 3 – Najważniejsze instrukcje – pętle, instrukcje sterujące i zarządzanie pamięcią. 🔹 Moduł 4 – Wchodzimy głębiej – wskaźniki, operacje bitowe, zarządzanie tablicami i strukturami. 🔹 Moduł 5 – Wskaźniki – jak działają, jak ich używać i dlaczego są tak ważne w programowaniu embedded. 🔹 Moduł 6 – Prowadzenie projektu – podział kodu na moduły, organizacja projektu i dobre praktyki. 🔹 Moduł 7 – Ćwiczenia na mikrokontrolerze – pierwsze programy na STM32, komunikacja z peryferiami, operacje na pamięci. 🔹 Moduł 8 – Co dalej? – dalsza ścieżka nauki, jak rozwijać umiejętności i budować własne projekty.
Każdy moduł zawiera kilkadziesiąt lekcji wideo, ćwiczenia praktyczne oraz przykłady kodu, które pozwolą Ci na skuteczną naukę.
Poniżej znajdziesz rozpiskę co do pojedynczej lekcji w postaci zwijanego menu 👇
Lekcja 1: Wstęp Lekcja 2: Czym jest ten kurs? Lekcja 3: Zawartość kursu Lekcja 4: Jak studiować Lekcja 5: Zaplanuj naukę Lekcja 6: Certyfikat ukończenia kursu Lekcja 7: Nauka programowania Lekcja 8: Język angielski Lekcja 9: Podsumowanie Lekcja 10: Zadanie domowe
Lekcja 1: Powitanie Lekcja 2: Język kompilowalny Lekcja 3: Podstawowe zasady składni w C Lekcja 4: Etapy kompilacji Lekcja 5: Dyrektywy preprocesora Lekcja 6: Flagi kompilatora Lekcja 7: Optymalizacja kompilatora Lekcja 8: Błędy kompilatora Lekcja 9: Zmienne Lekcja 10: Typy zmiennych Lekcja 11: W czym pisać kod? Nasza platforma. Lekcja 12: Szkielet programu Lekcja 13: printf – Teoria Lekcja 14: printf – Praktyka Lekcja 15: Definicja, deklaracja, inicjalizacja Lekcja 16: #define – Teoria Lekcja 17: #define – Praktyka Lekcja 18: Ile bajtów ma użyta zmienna? Lekcja 19: sizeof – Praktyka Lekcja 20: Operatory – Teoria Lekcja 21: Operatory arytmetyczne – Teoria Lekcja 22: Operatory – łączność i kolejność Lekcja 23: Operatory arytmetyczne – Praktyka Lekcja 24: Inkrementacja i pochodne – Teoria Lekcja 25: Inkrementacja i pochodne – Praktyka Lekcja 26: Komentarze – Teoria Lekcja 27: Komentarze – praktyka Lekcja 28: Styl pisania, standardy Lekcja 29: Podsumowanie Lekcja 30: Test Lekcja 31: BONUS: Etapy kompilacji w praktyce
Lekcja 1: Powitanie Lekcja 2: Zasięg zmiennych i wartość początkowa- Teoria Lekcja 3: Zasięg zmiennych i wartość początkowa – Praktyla Lekcja 4: Operatowy relacyjne – Teoria Lekcja 5: Instrukcja warunkowa if – Teoria Lekcja 6: Instrukcja warunkowa if – Praktyka Lekcja 7: Instrukcja warunkowa if – else – Teoria Lekcja 8: Instrukcja warunkowa if – else – Praktyka Lekcja 9: Instrukcja warunkowa if – zagnieżdżania – Teoria Lekcja 10: Instrukcja warunkowa if – zagnieżdżania – Praktyka Lekcja 11: Operator ? – Teoria Lekcja 12: Operator ? – Praktyka Lekcja 13: Operatory logiczne – Teoria Lekcja 14: Operatory logiczne – Praktyka Lekcja 15: If i operatory logiczne – Teoria Lekcja 16: If i operatory logiczne – Praktyka Lekcja 17: Pętle – Teoria Lekcja 18: Pętla while – Teoria Lekcja 19: Iteratory – teoria Lekcja 20: Pętla while – Praktyka Lekcja 21: Pętla do…while – Teoria Lekcja 22: Pętla do…while – Praktyka Lekcja 23: Pętla for – Teoria Lekcja 24: Pętla for – Praktyka Lekcja 25: Instrukcja wyboru switch – Teoria Lekcja 26: Instrukcja wyboru switch – Praktyka Lekcja 27: Tablice jednowymiarowe – Teoria Lekcja 28: Tablice jednowymiarowe – Praktyka Lekcja 29: Tablice wielowymiarowe – Teoria Lekcja 30: Tablice wielowymiarowe – Praktyka Lekcja 31: Tablice, wartość początkowa – Teoria Lekcja 32: Tablice, wartość początkowa – Praktyka Lekcja 33: Instrukcje break i continue – Teoria Lekcja 34: Instrukcje break i continue – Praktyka Lekcja 35: Podsumowanie Lekcja 36: Test
Lekcja 1: Powitanie Lekcja 2: Reprezentacja bitowa – Teoria Lekcja 3: Reprezentacja bitowa – Praktyka Lekcja 4: Operatory bitowe – Teoria Lekcja 5: Operatory bitowe – Praktyka Lekcja 6: Przesunięcia bitowe – Teoria Lekcja 7: Przesunięcia bitowe – Praktyka Lekcja 8: Wybór pojedynczych bitów – Teoria Lekcja 9: Wybór pojedynczych bitów – Praktyka Lekcja 10: Manipulacja bitami w zmiennej – Teoria Lekcja 11: Manipulacja bitami w zmiennej – Praktyka Lekcja 12: Maskowanie – Teoria Lekcja 13: Maskowanie – Praktyka – Odczytanie bitów z rejestru Lekcja 14: Maskowanie – Praktyka – zmiana bitu w rejestrze układu zewnętrznego Lekcja 15: Czy dany bit jest ustawiony? – Teoria Lekcja 16: Czy dany bit jest ustawiony? – Praktyka Lekcja 17: Definicje bitów w rejestrach mikrokontrolera Lekcja 18: Funkcje – Budowa Lekcja 19: Funkcje – Definiowanie Lekcja 20: Funkcje – Używanie Lekcja 21: Przekazywanie argumentów do funkcji przez wartość Lekcja 22: Funkcje – Praktyka, pierwsza funkcja Lekcja 23: Funkcje – Pratyka, modyfikacja argumentu Lekcja 24: Funkcje – Praktyka, prototyp Lekcja 25: Funkcje – Praktyka, wiele returnów Lekcja 26: Funkcje – Praktyka, funkcja w funkcji Lekcja 27: Makra preprocesora – Teoria Lekcja 28: Pułapki makr – Teoria Lekcja 29: Makra preprocesora – Praktyka, inkrementacja Lekcja 30: Makra preprocesora – Praktyka, do while Lekcja 31: Makro vs funkcja Lekcja 32: Predefiniowane makra Lekcja 33: Własny typ zmiennej – typedef – Teoria Lekcja 34: Własny typ zmiennej – typedef – Praktyka Lekcja 35: Typ wyliczeniowy – enum – Teoria Lekcja 36: Typ wyliczeniowy – enum – Praktyka Lekcja 37: Typ złożony – Struktura – Teoria Lekcja 38: Typ złożony – Struktura – Praktyka Lekcja 39: Ile bajtów zajmuje struktura? Lekcja 40: Endianness – kolejność bajtów Lekcja 41: Rozbijanie danych w praktyce Lekcja 42: Typ złożony – Unia – Teoria Lekcja 43: Typ złożony – Unia – Praktyka Lekcja 44: Typ złożony – Unia – Konwerter Lekcja 45: Pola bitowe – Teoria Lekcja 46: Pola bitowe – Praktyka ogólna Lekcja 47: Pola bitowe – Praktyka z unią Lekcja 48: Pola bitowe – Jak to wygląda pod spodem? Lekcja 49: Typy złożone i tablice Lekcja 50: Przekręcenie zmiennej Lekcja 51: Podsumowanie Lekcja 52: Test
Lekcja 1: Powitanie Lekcja 2: Czym jest wskaźnik? Lekcja 3: Jak wskazuje wskaźnik? Lekcja 4: Wyłuskanie adresu ze zmiennej Lekcja 5: Adres, a wartość spod adresu Lekcja 6: Wskaźniki – Pierwsze użycie Lekcja 7: Operacje na wskaźnikach Lekcja 8: Operacje na wskaźnikach – Praktyka Lekcja 9: Wskaźnik w argumencie funkcji Lekcja 10: Wskaźnik w argumencie funkcji – Praktyka Lekcja 11: Wskaźnik i tablice Lekcja 12: Wskaźnik i tablice – Praktyka Lekcja 13: Wskaźnik i struktury Lekcja 14: Wskaźnik i struktury – Praktyka Lekcja 15: Wskaźnik i struktury – Padding Lekcja 16: Gdy funkcja zwraca wskaźnik Lekcja 17: Wskaźnik na funkcję Lekcja 18: NULL Lekcja 19: Wskaźnik na funkcję – Praktyka Lekcja 20: Wskaźnik typu void Lekcja 21: Wskaźnik typu void – Praktyka Lekcja 22: Rzutowanie typów Lekcja 23: Rzutowanie wskaźników Lekcja 24: Rzutowanie typów – Wartości Lekcja 25: Rzutowanie typów – Wskaźniki Lekcja 26: Rzutowanie typów – Funkcja z void* Lekcja 27: Transfer pojedynczymi bajtami – Praktyka Lekcja 28: Transfer pojedynczymi bajtami – Struktury Lekcja 29: Deszyfracja zapisów deklaracji Lekcja 30: Tablica wielowymiarowa a wskaźnik Lekcja 31: Tablica wielowymiarowa a wskaźnik- Praktyka Lekcja 32: typedef i wskaźniki Lekcja 33: typedef i wskaźniki – Praktyka Lekcja 34: Stringi – Teoria Lekcja 35: Biblioteka do stringów Lekcja 36: sprintf, snprintf Lekcja 37: sprintf, snprintf – Praktyka Lekcja 38: strlen Lekcja 39: strlen – Praktyka Lekcja 40: strcpy, strncpy Lekcja 41: strcpy, strncpy – Praktyka Lekcja 42: strcmp, stricmp, strncmp Lekcja 43: strcmp, stricmp, strncmp – Praktyka Lekcja 44: strcat, strncat Lekcja 45: strcat, strncat – Praktyka Lekcja 46: strstok Lekcja 47: strstok- Praktyka Lekcja 48: strchr, strrchr Lekcja 49: strchr, strrchr – Praktyka Lekcja 50: strpbrk, strcspn, strspn Lekcja 51: strpbrk, strcspn, strspn – Praktyka Lekcja 52: strstr Lekcja 53: strstr – Praktyka Lekcja 54: Funkcje związane z pamięcią Lekcja 55: Funkcje związane z pamięcią – Praktyka Lekcja 56: Podsumowanie Lekcja 57: Test
Lekcja 1: Powitanie Lekcja 2: Podział na pliki Lekcja 3: Biblioteki Lekcja 4: Budowanie projektu wieloplikowego – wstęp Lekcja 5: Jak napisać Makefile? Lekcja 6: Pierwszy podział – praktyka Lekcja 7: extern Lekcja 8: extern – praktyka Lekcja 9: static Lekcja 10: static – zmienna globalna Lekcja 11: static – zmienna lokalna Lekcja 12: static – funkcja Lekcja 13: Wymuszanie błędów kompilatora i linkera Lekcja 14: const Lekcja 15: const – praktyka Lekcja 16: volatile Lekcja 17: volatile – praktyka Lekcja 18: Funkcja inline Lekcja 19: Makra vs inline Lekcja 20: Pamięci w MCU Lekcja 21: Obszary pamięci RAM i sekcje programu Lekcja 22: Dynamiczna alokacja pamięci Lekcja 23: Dynamiczna alokacja pamięci – praktyka malloc Lekcja 24: Dynamiczna alokacja pamięci – praktyka calloc Lekcja 25: Dynamiczne alokowanie – czy warto? Lekcja 26: Sterowanie kompilacją #if Lekcja 27: #if – Praktyka Lekcja 28: Kod spaghetti z #if – przykłady Lekcja 29: Include Guard – przykłady Lekcja 30: Warstwy oprogramowania Lekcja 31: Unikanie zmiennych globalnych Lekcja 32: Unikanie zmiennych globalnych – praktyka Lekcja 33: Callbacki Lekcja 34: Wskaźniki i callbacki Lekcja 35: Callback na wskaźniku – praktyka Lekcja 36: Funkcje __weak Lekcja 37: __weak – praktyka Lekcja 38: Callback poprzez __weak Lekcja 39: __weak i callbacki – praktyka Lekcja 40: Interfejs w bibliotece Lekcja 41: Biblioteka – jeden plik Lekcja 42: Biblioteka – oddzielny plik na interfejs Lekcja 43: Biblioteka – oddzielny driver jako tablica wskaźników Lekcja 44: „Obiektowość” w C Lekcja 45: Biblioteka obiektowa – jeden plik Lekcja 46: Biblioteka obiektowa – oddzielny plik na interfejs Lekcja 47: Biblioteka obiektowa – oddzielny driver jako tablica wskaźników Lekcja 48: Co obiektowe, a co nie? Lekcja 49: Podsumowanie Lekcja 50: Test
Lekcja 1: Powitanie Lekcja 2: Bare Metal, czy Framework? Lekcja 3: Tworzenie projektu na STM32 – z Nucleo Lekcja 4: Tworzenie projektu na STM32 – z MCU Lekcja 5: STM32CubeMX – zakładka mikrokontrolera Lekcja 6: STM32CubeMX – zakładka zegarów Lekcja 7: STM32CubeMX – zakładka project manager Lekcja 8: STM32CubeIDE – wstępna konfiguracja, kolory Lekcja 9: STM32CubeIDE – Omówienie Layotu Lekcja 10: STM32CubeIDE – Górny pasek i menu Lekcja 11: STM32CubeIDE – Skróty Lekcja 12: Pętla nieskończona Lekcja 13: Debugowanie – podstawy Lekcja 14: Miganie diodą w HALu Lekcja 15: Debug i Release build – praktyka Lekcja 16: Kopiowanie HALa Lekcja 17: Kopiowanie HALa – Przykład GPIO Lekcja 18: __weak callback w HALu Lekcja 19: volatile w praktyce Lekcja 20: const na mikrokontrolerze Lekcja 21: callback i wysypanie się przy NULLu Lekcja 22: Konfiguracja standardowego printf pod mikrokontroler Lekcja 23: printf dla mikrokontrolerów Lekcja 24: Uruchamianie BMP280 – jeden plik Lekcja 25: Uruchamianie BMP280 – oddzielny plik na interfejs Lekcja 26: Uruchamianie BMP280 – oddzielny driver jako tablica wskaźników Lekcja 27: Uruchamianie obiektowo – jeden plik Lekcja 28: Uruchamianie obiektowo – oddzielny plik na interfejs Lekcja 29: Uruchamianie obiektowo – oddzielny driver jako tablica wskaźników Lekcja 30: Dodatkowe szlify w bibliotece Lekcja 31: Podsumowanie Lekcja 32: Test
Lekcja 1: To dopiero początek Lekcja 2: Co robić, gdy coś nie idzie? Lekcja 3: Projekty, projekty, projekty Lekcja 4: Pierwsza praca? Lekcja 5: Czego uczyć się obok języka C? Lekcja 6: Osoby do śledzenia Lekcja 7: Certyfikat Lekcja 8: Podsumowanie i zadanie domowe
👨🏫 Twój instruktor – Mateusz Salamon
Cześć! Nazywam się Mateusz Salamon i będę Twoim instruktorem w kursie STM32 dla Początkujących. Od ponad 10 lat programuję mikrokontrolery STM32, a moją misją jest pomaganie innym w nauce embedded w sposób przejrzysty, praktyczny i skuteczny.
Moja przygoda z mikrokontrolerami zaczęła się od programowania w asemblerze na układach 8051, później przeszedłem na AVR, aż w końcu trafiłem na STM32 i architekturę ARM, które stały się moją główną specjalizacją. Wiem, jak trudna może być nauka bez dobrych materiałów i wsparcia – dlatego postanowiłem stworzyć kurs, który krok po kroku przeprowadzi Cię przez cały proces programowania mikrokontrolerów.
Prowadzę bloga msalamon.pl, którego miesięcznie odwiedzają tysiące osób szukających rzetelnej wiedzy o STM32. Tworzę także kursy online, w których pokazuję nie tylko teorię, ale przede wszystkim realne, praktyczne zastosowania, pomagając kursantom pisać wydajny i dobrze zoptymalizowany kod.
W kursie nie zostawiam Cię samego z materiałami – będę z Tobą na każdym etapie nauki, a także na regularnych spotkaniach LIVE, gdzie odpowiem na Twoje pytania i pomogę rozwiązać problemy. Możesz też liczyć na wsparcie w zamkniętej społeczności kursantów.
Chcę, żebyś nauczył się STM32 raz, a dobrze, unikając błędów, które ja kiedyś popełniałem. Jeśli chcesz wejść w świat mikrokontrolerów i nauczyć się programować w praktyczny sposób – ten kurs jest dla Ciebie! 🚀
Do zobaczenia na lekcjach! 😊
🎬 Lekcje DEMO – Sprawdź kurs przed zakupem
Nie musisz kupować kursu w ciemno – przygotowałem dla Ciebie darmowe lekcje demonstracyjne, które pozwolą Ci sprawdzić, jak wygląda nauka języka C w moim kursie. Dzięki nim zobaczysz, w jaki sposób tłumaczę kluczowe zagadnienia i czy ten styl nauki Ci odpowiada.
✅ Czym jest deklaracja, definicja i inicjalizacja?(7 minut – kluczowe pojęcia dla każdego programisty C)
✅ Ile bajtów zajmuje zmienna w pamięci?(3 minuty – analiza rozmiaru różnych typów danych)
✅ Łączność i kolejność operatorów w C(9 minut – jak poprawnie interpretować wyrażenia w kodzie?)
✅ Jak działa iterator i iterowanie?(10 minut – podstawy pracy ze strukturami iteracyjnymi w C)
✅ Jak wybierać pojedyncze bity do operacji?(10 minut – praktyczna praca z operacjami bitowymi w mikrokontrolerach)
✅ Ile miejsca zajmuje struktura w pamięci?(19 minut – optymalizacja i analiza pamięci w języku C)
✅ Konwerter zmiennych przy pomocy unii(6 minut – jak efektywnie przekształcać dane?)
✅ Czym są wskaźniki i jak ich używać?(16 minut – jedno z najważniejszych zagadnień w C, wyjaśnione od podstaw)
✅ Jak używać wskaźnika w argumentach funkcji?(12 minut praktyki – przekazywanie danych przez wskaźniki)
✅ Wskaźnik na funkcję – jak to działa?(18 minut – dynamiczne przypisywanie funkcji w kodzie C)
✅ Czym jest extern w języku C?(7 minut – kluczowy mechanizm do pracy z wieloma plikami w projekcie)
✅ Funkcje typu weak – jak je stosować?(9 minut – elastyczność kodu w zaawansowanych projektach embedded)
✅ Praktyczne użycie funkcji weak(4 minuty – jak wykorzystać je w rzeczywistych aplikacjach?)
⏳ Jak długo będziesz mieć dostęp do kursu?
Kupując kurs Języka C dla Mikrokontrolerów, otrzymujesz dostęp do wszystkich materiałów na 2 lata. W tym czasie możesz swobodnie przerabiać lekcje we własnym tempie, wracać do nagrań, a także korzystać z wsparcia społeczności na Discordzie.
Dodatkowo, przez cały okres dostępu otrzymujesz wszystkie aktualizacje kursu – jeśli pojawią się nowe lekcje, dodatkowe materiały czy poprawki, masz do nich automatyczny dostęp bez dodatkowych opłat.
Po 2 latach masz możliwość przedłużenia dostępu na kolejne 2 lata za 10% ceny kursu, dzięki czemu możesz nadal korzystać z materiałów, aktualizacji i społeczności wsparcia.
🚀 Ucz się we własnym tempie i miej pewność, że zawsze masz dostęp do najnowszych materiałów!
📦 Co otrzymasz, kupując kurs?
✔️ Dostęp do kursu C dla Mikrokontrolerów – ~40 godzin nagrań wideo na platformie online. ✔️ Dostęp do kursu 24/7 – ucz się w swoim tempie, kiedy tylko masz czas. ✔️ Cykliczny LIVE Q&A z instruktorem + dostęp do nagrań archiwalnych. ✔️ Dostęp do wszystkich prezentacji i kodów źródłowych z kursu. ✔️ Dwuletni dostęp do kursu i wszystkich przyszłych aktualizacji. ✔️ Dwuletni dostęp do serwera Discord „Akademia Embedded” – wsparcie społeczności i instruktora. ✔️ Certyfikat ukończenia kursu – świetny dodatek do Twojego CV.
❓ Najczęściej zadawane pytania (FAQ)
❓ Kiedy rusza kurs? ✔️ Dostęp do kursu otrzymujesz natychmiast po zakupie.
❓ Jakiego środowiska IDE używamy? ✔️ Na początku pracujemy na kompilatorze online, a w części mikrokontrolerowej używamy STM32CubeIDE.
❓ Czy kurs jest nagrany, czy odbywa się na żywo? ✔️ Kurs to materiały wideo, które możesz przerabiać w dowolnym czasie, plus sesje LIVE Q&A.
❓ Jak długo mam dostęp do kursu? ✔️ Dostęp do wszystkich materiałów i przyszłych aktualizacji dostajesz na 2 lata. Po 2 latach istnieje możliwość przedłużenia na kolejne 2 lata za 10% ceny kursu.
❓ Czy mogę zwrócić kurs? ✔️ Tak! Masz 14 dni na zwrot bez podawania przyczyny.
Wysyłka w dniu zamówienia
Złożyłeś zamówienie? Machina ruszyła! Czekamy na zaksięgowanie płatności, a później… Pakujemy, adresujemy i wysyłamy.
Wysyłka 24h
Jeśli zapłacisz do godziny 14:00, przesyłka zostanie dostarczona w przeciągu 24 H (w dni robocze). Przesyłka zamówiona po godzinie 14:00 zostanie wysłana w kolejnym dniu roboczym.
Do czasu wysyłki należy doliczyć czas doręczenia deklarowany przez wybranego przewoźnika.
Program darmowej dostawy!
Wiemy, że koszt wysyłki zawsze boli… Dlatego wprowadziliśmy program Darmowej Dostawy dla Paczkomatów do zamówień przedpłaconych. Darmowa Dostawa w sklepie msalamon dzieli się na dwie kategorie:
Kategoria 1
Darmowa Dostawa Paczkomatem dla wszystkich klientów w przypadku dokonania zakupów o wartości produktów fizycznych (bez Kursów Online) powyżej 400 zł.
Kategoria 2
Program Darmowej Dostawy dla stałych klientów. Aby skorzystać z programu Darmowej Dostawy dla stałych klientów należy spełnić poniższe warunki:
3️⃣Każdorazowo posiadać w koszyku produkty fizyczne (bez Kursów Online) o łącznej wartości co najmniej 100 zł.
Metody dostaw objęte promocją
Paczkomaty Inpost (przedpłata)
Żabka (przedpłata)
Orlen Paczka (przedpłata)
Pamiętaj, aby potwierdzić zapis do newslettera
*Promocja ważna jest od 15.02.2024 do odwołania
Ważne – poczekaj na potwierdzenie
Przyznanie darmowej wysyłki zawsze potwierdzone jest mailem. Poczekaj kilka minut, aby nasze systemy zdążyły się porozumieć i przyznać Ci obniżony próg Darmowej Dostawy. Zwykle trwa to chwilę, maksymalnie 30 minut.