Kurs "Język C dla Mikrokontrolerów" wraca na jesień

Już jesenią wraca pełen program "Język C dla Mikrokontrolerów".

Jest to rozwinięcie i szczegółowe opracowanie zagadnień z języka C, które poruszane są w darmowym newsletterze.

Zapisując się na listę oczekujących jako pierwszy dostaniesz informacje kiedy dokładnie ruszamy!

Pełna agenda kursu

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

Język C jest podstawą w świecie mikrokontrolerów

Rozwój mikrokomputerów jak Raspberry Pi, oraz platformy Arduino spowodował, że programowanie elektroniki ewoluowało w ciągu ostatnich lat. Możemy pisać dosłownie w dowolnym języku programowania: C, C++, Python, Rust, czy nawet widziałem Javę zaprzęgniętą dla mikrokontrolerów.

O ile np. popularność C++ czy Pythona rośnie i jest to świetny język, tak król nadal jest tylko jeden.

Jest nim klasyczny język C.

W języku tym tworzy się bardzo wydajne oprogramowanie. Ta wydajność jest bardzo ważna w mikrokontrolerach. Mimo że te układy są bardzo mocne, to nadal nie na tyle, aby pisać długo wykonujący się kod. Tym bardziej taki, który musi być interpretowany, czyli np. w języku Python.

Czym się różni C dla mikrokontrolerów od C "ogólnego"?

Język C, to nadal język C. Jednak podczas programowania mikrokontrolerów bardzo intensywnie korzystamy z niektórych komponentów języka C.

Są to na przykład operacje bitowe. Ustawianie i kasowanie pojedynczego bitu w całym bajcie. Maskowanie części bajtu, czy przesunięcia bitowe. To chleb powszedni programisty embedded.

Oczywiście nie możemy zapominać o wskaźnikach. Ten temat jest niesamowicie trudny dla osób początkujących. Doskonale wiem ile to sprawia trudności, bo podczas mojej pierwszej styczności z C o mało co nie pożegnałem się ze studiami. Serio!

W programowaniu mikrokontrolerów często również używamy dyrektyw preprocesora. Definicje, kompilacja warunkowa. Te rzeczy ułatwiają nam organizację w naszym kodzie.

Poznaj swojego instruktora

Aktualnie zapisy do kursu są zamknięte. Nie przegap kolejnego otwarcia i zapisz się na listę oczekujących.

Najbliższy planowany termin otwarcia: I Kwartał 2023

.