Jeżeli nie miałeś nigdy styczności z C, albo czujesz, że masz braki u podstaw, to jesteś w świetnym miejscu! Pomogę Ci poznać C od zera.
Poznaj elementy języka C. Zobacz jak się je wykorzystuje w mikrokontrolerach.
Okiełznaj operacje bitowe, oraz maskowanie.
Wskaźniki? To zmora osób początkujących. Poznaj je tak, aby nie były dla Ciebie problemem.
Przygotowałem serię maili, które wprowadzą Cię w świat programowania w języku C.
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!
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 |
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.
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.
Jestem autorem bloga msalamon.pl
Programuję STM32 zawodowo oraz hobbystycznie. Moje umiejętności wystarczyły mi, aby zdobyć pracę w jednej z największych firm świata. Od lat pomagam osobom początkującym wchodzić w świat programowania embedded. Zauważyłem, że wiele osób ma braki w podstawach z języka C. Dlatego przychodzę z pomocą.
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