????️ Kurs Języka C dla systemów embedded

Name: Język C dla Mikrokontrolerów - Sklep msalamon
SKU: KURS_C_DP
Price: 1497.00 PLN
Availability: InStock

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.