„Kurs STM32 dla początkujących” został dodany do koszyka. Zobacz koszyk

Język C dla Mikrokontrolerów

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

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

1 497,00 zł z VAT

Cena netto: 1 217,07 zł

Korzyści

30 dni na zwrot
Od 300 zł wysyłka gratis
Wysyłka z Polski w 24h
Wsparcie inżyniera

Pytanie do produktu

Dodaj do Schowka

Dobierz dodatki

Kurs FreeRTOS na STM32 dla początkujących
997,00 zł z VAT / szt.

Ilość:

Płatność & Wysyłka

Kategoria: Kursy

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

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:

1️⃣Posiadać aktywne konto w sklepie. Założyć możesz np. tutaj: w https://sklep.msalamon.pl/moje-konto

2️⃣Dołączyć do newslettera sklepowego z nowościami i promocjami. Wysyłka regularnie co poniedziałek. https://sklep.msalamon.pl/newsletter

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.