Chciałbyś nauczyć się programować układy, które są na topie?

To świetnie się składa! Chciałbym Cię nauczyć programować mikrokontrolery, które chętnie wykorzystywane są w profesjonalnych produktach na całym świecie. Nie ważne czy jesteś hobbystą, czy chciałbyś związać swoją przyszłość z programowaniem embedded. Potrzebujesz znać coś, co da Ci możliwość budowania niesamowitych urządzeń oraz zdobycia dobrej pracy.

Chciałbyś zdobyć pierwszą pracę w branży embedded?

Aktualnie wiele firm z branży programowania embedded skupia się na nowoczesnych rozwiązaniach. Same mikrokontrolery AVR znane z podstawowych płytek Arduino już nie wystarczają. Świat idzie do przodu. Aktualnie na topie są mikrokontrolery z rdzeniem ARM Cortex-M. Taki rdzeń mają na przykład mikrokontrolery STM32. Warto jest więc nauczyć się ich programowania.

Zdobądź swoją pierwszą pracę właśnie dzięki programowaniu STM32. To jest jedna z lepszych rzeczy, jaką możesz sobie sprawić.

Podnieś kwalifikacje swojego zespołu

Prowadzisz firmę, w której masz zespół programistów? Podnieś umiejętności programistów.

Kurs STM32 dla Początkujących to nie tylko poznawanie samego mikrokontrolera. Program nauki  został ułożony w taki sposób, że nauczysz się dobrych praktyk programisty embedded.

W kursie nauczę Cię jak tworzyć nieblokujący kod, czy pisać własne biblioteki. Pokażę Ci jak korzystać z FreeRTOSa.

Kim jestem?

Co otrzymasz w programie?

Zbudujesz swoje pierwsze urządzenia

Pokażę Ci jak zbudować coś więcej niż miganie diodą czy wyświetlenie prostego tekstu na ekranie. Połączenie dwóch różnych interfejsów w taki sposób, aby sobie nie przeszkadzały nie będzie dla Ciebie tajemnicą.

Poznasz kluczowe peryferia mikrokontrolera

Do czego służy Timer? Czy tylko do odmierzania czasu? Jaki wpływ na działanie Twojego programu ma DMA? Jakim interfejsem podłączyć kartę SD. USB nie tylko jako port szeregowy. Dlaczego wyświetlacz TFT tak wolno się odświeża?

Przejdziesz przec cały proces z instruktorem

Raz na miesiąc spotkamy się na 2-godzinnym LIVE, podczas którego będziesz mógł zadać dowolne pytanie. Instruktor również będzie dostępny na specjalnej grupie Slack, aby odpowiadać na Twoje pytania i pomagać Ci w nauce.

Otrzymasz 12 modułów szkolenia online

W każdym module czeka Cię nawet 50 nagrań video pokazujących cały proces nauki programowania. Przeprowadzę Cię za rękę od zera, poprzez poznanie różnych interfejsów mikrokontrolera, aż po swoje pierwsze bardziej złożone programy.

Nauczysz się współpracować ze sprzętem

Sprytne wykorzystanie posiadanego sprzętu po to, aby Twój projekt chodził jak najlepiej. Poznasz np. "jednorazową" konfigurację DMA i Timerów po to, aby mikrokontroler sam potrafił zrobić masę powtarzalnych czynności. Bez udziału kodu.

Nauczysz się pisać nieblokujący kod

Koniec z Delayem! Przestań w końcu używać blokującego kodu. W końcu jest dostępny kurs, który od razu tłumaczy jak poprawnie pisać programy dla mikrokontrolera. Poznasz, w jaki sposób używać timerów programowych, oraz maszyny stanów.

Będziesz pisał własne biblioteki

Nie możesz znaleźć biblioteki dla układu? Napiszesz ją sam! Tylko i wyłącznie na podstawie dokumentacji. Nie ma biblioteki dla STM32, ale jest dla Arduino? Bez problemu ją przeportujesz. Pokażę Ci kilka dróg do tego, aby mieć działającą bibliotekę.

Optymalizacja kodu

Nauczysz się optymalizować kod i biblioteki. Twój program będzie działał szybciej i będziesz wiedział dlaczego.

Poznasz podstawy pracy z RTOS

Poznaj podstawy działania systemu czasu rzeczywistego. Naucz się go na konkretnych przykładach. Nauka na printach nic nie da! Zobacz jak się tworzy prawdziwy projekt przy użyciu FreeRTOS.

Poznasz ludzi takich jak Ty!

W grupie poznasz inne początkujące osoby. Będziecie mogli wymieniać się doświadczeniami oraz nawzajem sobie pomagać. Wsparcie innych osób, nie tylko instruktora jest bardzo ważne w procesie nauki.

Agenda programu

Moduł 1: PLAN GRY
Lekcja 1: Powitanie
Lekcja 2: Plan Gry
Lekcja 3: Efekt Końcowy
Lekcja 4: Wymagania
Lekcja 5: Jak Studiować?
Lekcja 6: Platforma Nucleo
Lekcja 7: Zadanie Domowe
Moduł 2: Oprogramowanie, RCC, GPIO
Lekcja 1: Powitanie
Lekcja 2: Sprzęt do kursu
Lekcja 3: Potrzebny sprzęt w tym tygodniu
Lekcja 4: ST MCU Finder
Lekcja 5: Programator ST-Link
Lekcja 6: STM32CubeProgrammer
Lekcja 7: Biblioteka HAL
Lekcja 8 : Biblioteka Low Layer
Lekcja 9: HAL vs rejestry
Lekcja 10: Nazewnictwo w HALu
Lekcja 11: Dokumentacja HAL
Lekcja 12: Dokumentacja mikrokontrolera
Lekcja 13: STM32CubeMX
Lekcja 14: STM32CubeIDE
Lekcja 15: Tworzenie pierwszego projektu - z Nucleo
Lekcja 16: Tworzenie pierwszego projektu - z MCU
Lekcja 17: Przegląd biblioteki HAL
Lekcja 18a: STM32CubeMX - zakładka mikrokontrolera
Lekcja 18b: STM32CubeMX - zakładka zegarów
Lekcja 18c: STM32CubeMX - zakładka project manager
Lekcja 19a: STM32CubeIDE - wstępna konfiguracja, kolory
Lekcja 19b: STM32CubeIDE - Omówienie Layotu
Lekcja 19c: STM32CubeIDE - Górny pasek i menu
Lekcja 19d: STM32CubeIDE - Skróty
Lekcja 20: GPIO Output - Teoria
Lekcja 21: GPIO Input - Teoria
Lekcja 22: Funkcje alternatywne pinów
Lekcja 23: GPIO w Dokumentacji
Lekcja 24: GPIO w CubeMX
Lekcja 25: Miganie diodą - funkcja opóźniająca
Lekcja 26: Miganie diodą - Kod
Lekcja 27: Uruchamianie programu
Lekcja 28: Debugowanie - podstawy
Lekcja 29: Czytanie wejścia - Kod
Lekcja 30: Miganie wieloma diodami - Timer programowy
Lekcja 31: Timery programowy - Kod
Lekcja 32: Prosta maszyna stanów - Teoria
Lekcja 33a: Powtórka z C - podział na pliki
Lekcja 33b: Powtórka z C - struktury
Lekcja 33c: Powtórka z C - wskaźniki
Lekcja 33d: Powtórka z C - callbacki
Lekcja 33e: Powtórka z C - "obiektowość" w C
Lekcja 34: Prosta maszyna stanów - Elementy maszyny
Lekcja 35a: Prosta maszyna stanów - Szkielet biblioteki
Lekcja 35b: Prosta maszyna stanów - Sprawdzenie inicjalizacji
Lekcja 35c: Prosta maszyna stanów - Pierwsze przejście stanów
Lekcja 35d: Prosta maszyna stanów - Debounce i wywołanie Callbacka
Lekcja 35e: Prosta maszyna stanów - Sprawdzenie działania
Lekcja 35f: Prosta maszyna stanów - Rejestracja Callbacku i użycie
Lekcja 36: Dokładanie stanów - Teoria
Lekcja 37: Dokładanie stanów - Kod
Lekcja 38: Zadanie domowe
Bonus 1: Kopiowanie projektów CubeIDE
Moduł 3: Przerwania, DMA, UART
Lekcja 1: Powitanie
Lekcja 2: Potrzebne narzędzia w tym tygodniu
Lekcja 3: Przerwania: Teoria
Lekcja 4: NVIC, priorytety
Lekcja 5: Przerwanie na przycisku
Lekcja 6: Prosta obsługa przerwania
Lekcja 7: Debugowanie przerwania
Lekcja 8: DMA: Teoria
Lekcja 9: UART: Teoria
Lekcja 10: Port szeregowy na PC
Lekcja 11: UART: Transfer, polling
Lekcja 12: UART: Odbiór, polling
Lekcja 13: Ringbuffer: Teoria
Lekcja 14: Ringbuffer: Kod
Lekcja 15: UART: Transfer, przerwanie
Lekcja 16: UART: Odbiór, przerwanie
Lekcja 16a: Włączanie przerwań w Cube - uzupełnienie
Lekcja 16b: Przerwania w transmisji, a liczba danych
Lekcja 17: UART: Transfer, DMA
Lekcja 18: UART: Odbiór, DMA
Lekcja 19: Parsowanie komend: Teoria
Lekcja 20: Parsowanie komend: Proste
Lekcja 21: Parsowanie komend: Linia komend z parametrami
Lekcja 22: Zadanie domowe
Moduł 4: Timery
Lekcja 1: Powitanie
Lekcja 2: Potrzebne narzędzia w tym tygodniu
Lekcja 3: Timery: Teoria
Lekcja 4: Tryby Timerów
Lekcja 5: SysTick Timer
Lekcja 6: Tryb Normal: Teoria
Lekcja 7: Tryb Normal: Kod
Lekcja 8: Tryb Input Capture: Teoria
Lekcja 9: Tryb Input Capture: Kod
Lekcja 10: Tryb Output Compare: Teoria
Lekcja 11: Tryb Output Compare: Kod
Lekcja 12: Tryb Output Compare: Zmiana parametrów w locie
Lekcja 13: Tryb PWM: Teoria
Lekcja 14: Tryb PWM: Kod
Lekcja 15: Tryb PWM: Zmiana parametrów w locie
Lekcja 16: Slave w Timerach: Teoria
Lekcja 17: Slave: Reset Mode
Lekcja 18: Slave: Gated Mode
Lekcja 19: Tryb One-pulse Mode: Teoria
Lekcja 20: Tryb One-pulse Mode: Kod
Lekcja 21: Watchdog: Teoria
Lekcja 22: Watchdog: IWDG Kod
Lekcja 23: Watchdog: WWDG Kod
Lekcja 24: RTC: Teoria
Lekcja 25: RTC: Czas i Kalendarz
Lekcja 26: RTC: Podtrzymanie
Lekcja 27: RTC: Alarmy
Lekcja 28: RTC: Wake-up
Lekcja 29: RTC: Time Stamp
Lekcja 30: RTC: Tamper
Lekcja 31: Zadanie domowe
Moduł 5: ADC
Lekcja 1: Powitanie
Lekcja 2: Potrzebne narzędzia w tym tygodniu
Lekcja 3: Czy jest ADC?
Lekcja 4: Jak działa ADC?
Lekcja 5: Przegląd opcji ADC w CubeMX
Lekcja 6: Tryb Single Channel: Teoria
Lekcja 7: Tryb Single Channel: Kod, Polling
Lekcja 8: Tryb Single Channel: Kod, Przerwania
Lekcja 9: Tryb Single Channel: Kod, DMA
Lekcja 10: Tryb Multi Channel: Teoria
Lekcja 11: Tryb Multi Channel: Kod, Polling
Lekcja 12: Tryb Multi Channel: Kod, Przerwania
Lekcja 13: Tryb Multi Channel: Kod, DMA
Lekcja 14: Watchdog analogowy: Teoria
Lekcja 15: Watchdog analogowy: Kod
Lekcja 16: Potencjometr + LED PWM: Teoria
Lekcja 17: Potencjometr + LED PWM: Kod, Polling
Lekcja 18: Potencjometr + LED PWM: Kod, Przerwania
Lekcja 19: Potencjometr + LED PWM: Kod, DMA
Lekcja 20: Automatyczna konwersja z Timerem: Teoria
Lekcja 21: Automatyczna konwersja z Timerem: Kod
Lekcja 22: Tryb Injected Mode: Teoria
Lekcja 23: Tryb Injected Mode: Kod
Lekcja 24: Tryb Injected Mode + Regular: Kod
Lekcja 25: Odczyt z mikrofonu: Teoria
Lekcja 26: Odczyt z mikrofonu przy okazji innych konwersji: Teoria
Lekcja 27: Odczyt z mikrofonu przy okazji innych konwersji: Kod
Lekcja 28: DSP: FFT mikrofonu, Teoria
Lekcja 29: DSP: FFT mikrofonu, Kod
Lekcja 30: Zadanie domowe
Moduł 6: I2C
Lekcja 1: Powitanie
Lekcja 2: Potrzebne narzędzia w tym tygodniu
Lekcja 3: Czym jest I2C: Teoria
Lekcja 4: Przegląd opcji I2C w CubeMX
Lekcja 5: I2C: Czy potrzebny jest translator napięć?
Lekcja 6: BMP280: Teoria
Lekcja 7: BMP280: Dokumentacja
Lekcja 8: Skaner I2C
Lekcja 9: Jak pisać swoje biblioteki?
Lekcja 10a: BMP280: Pisanie biblioteki - Zalążek Inicjalizacji
Lekcja 10b: BMP280: Pisanie biblioteki - Co lata po I2C? Odczyt ID
Lekcja 10c: BMP280: Pisanie biblioteki - Odczyt rejestrów kalibracyjnych
Lekcja 10d: BMP280: Pisanie biblioteki - Startujemy pomiary
Lekcja 10e: BMP280: Pisanie biblioteki - Dokładność pomiarów
Lekcja 10f: BMP280: Pisanie biblioteki - Odczyt pomiarów
Lekcja 10g: BMP280: Pisanie biblioteki - Przeliczenie pomiarów i kończenie biblioteki
Lekcja 11: OLED: Teoria
Lekcja 12: Buforowanie ekranu w wyświetlaczach
Lekcja 13: OLED: Dokumentacja kontrolera
Lekcja 14: OLED: Szukanie gotowej biblioteki w Arduino
Lekcja 15: OLED: Portowanie biblioteki - Init
Lekcja 16: OLED: Portowanie biblioteki - Bufor
Lekcja 17: OLED: Portowanie biblioteki - Piksel
Lekcja 18: OLED: GFX Figury
Lekcja 19: Jak rysować czcionki?
Lekcja 20: OLED: GFX Czcionki
Lekcja 21: OLED: GFX Bitmapy
Lekcja 22: Wyświetlenie danych z BMP280
Lekcja 23: Podkręcenie I2C + DMA
Lekcja 24: Wyświetlenie FFT mikrofonu
Lekcja 25: Zadanie domowe
Moduł 7: SPI
Lekcja 1: Powitanie
Lekcja 2: Potrzebne narzędzia w tym tygodniu
Lekcja 3: Czym jest SPI?
Lekcja 3a: Tryb 9-bitowy
Lekcja 4: Przegląd opcji SPI w CubeMX
Lekcja 5: TFT: Teoria
Lekcja 6: TFT: Dokumentacja kontrolera
Lekcja 7: TFT: TFT: Co z biblioteką?
Lekcja 8: TFT: Jak ustawić SPI?
Lekcja 9: TFT: Init
Lekcja 10: TFT: Analizator logiczny i Init
Lekcja 11: TFT: Piksel
Lekcja 12: TFT: Optymalizacja lekka
Lekcja 13: TFT: Optymalizacja SPI
Lekcja 14: TFT: Optymalizacja kasowania ekranu
Lekcja 15: TFT: Kończenie optymalizacji
Lekcja 16: TFT: GFX Color
Lekcja 17: TFT: GFX Grafiki
Lekcja 18: TFT: Obsługa rotacji
Lekcja 19: Czcionki: Jak lepiej rysować?
Lekcja 20: Czcionki: Generator
Lekcja 21a: Czcionki: Implementacja rysowania: Początek
Lekcja 21b: Czcionki: Implementacja rysowania: Znak
Lekcja 21c: Czcionki: Implementacja rysowania: String
Lekcja 21d: Czcionki: Implementacja rysowania: Spacja
Lekcja 22: Polska czcionka: Teoria
Lekcja 23: Polska czcionka: Generator i przygotowanie
Lekcja 24: Polska czcionka: Implementacja
Lekcja 25: Touch Panel: Teoria
Lekcja 26: Touch Panel: Dokumentacja
Lekcja 27: Touch Panel: Kłopotliwe przerwanie
Lekcja 28: Touch Panel: Konfiguracja Cube
Lekcja 29: Touch Panel: Wygląd biblioteki
Lekcja 30a: Touch Panel: Pisanie biblioteki: Odczyt surowych danych z Kontrolera
Lekcja 30b: Touch Panel: Pisanie biblioteki: Dane kalibracyjne
Lekcja 30c: Touch Panel: Pisanie biblioteki: Przeliczenie kalibracji
Lekcja 30d: Touch Panel: Pisanie biblioteki: Zbieranie próbek
Lekcja 30e: Touch Panel: Pisanie biblioteki: Odczyt wciśniętego punktu
Lekcja 30f: Touch Panel: Pisanie biblioteki: Procedura kalibracji
Lekcja 31: TFT + Touch Panel: Paint
Moduł 8: Karta SD
Lekcja 1: Powitanie
Lekcja 2: Potrzebne narzędzia w tym tygodniu
Lekcja 3: Karta pamięci: Teoria
Lekcja 4: Karta pamięci: Interfejsy
Lekcja 5: Karta pamięci: FatFS
Lekcja 6: Dokumentacja
Lekcja 7: Przegląd opcji w CubeMX
Lekcja 8: Karta pamięci na SPI: Kod
Lekcja 9: Karta pamięci na SPI: FatFS - pisanie do pliku
Lekcja 10: Karta pamięci na SPI: FatFS - czytanie z pliku
Lekcja 11: Karta pamięci na SPI: Obraz z SD na TFT
Lekcja 12: Karta pamięci na SDIO: DMA
Lekcja 13: Karta pamięci na SDIO: 1 bit
Lekcja 14: Karta pamięci na SDIO: 4 bit
Lekcja 15: Biblioteka LIBJPEG: Teoria
Lekcja 16: Biblioteka LIBJPEG: Kod
Lekcja 17: Biblioteka LIBJPEG: Kod - Debug
Lekcja 18: Pokaz slajdów na TFT z użyciej JPEGów
Lekcja 19: Zadanie domowe
Moduł 9: USB
Lekcja 1: Powitanie
Lekcja 2: Potrzebne narzędzia w tym tygodniu
Lekcja 3: USB: Teoria
Lekcja 4: USB: Zegary w STM32
Lekcja 5: USB VCOM / CDC: Teoria
Lekcja 6: USB VCOM / CDC: Kod - nadawanie
Lekcja 7: USB VCOM / CDC: Kod - odbiór
Lekcja 8: USB MSC Device: Teoria
Lekcja 9: USB MSC Device: Kod, pendrive z STM32
Lekcja 10: USB HID Device: Teoria
Lekcja 11: USB HID Device: Kod, myszka
Lekcja 12: USB HID Device: Kod, myszka + joystick
Lekcja 13: USB HID Device: Kod, klawiatura
Lekcja 14: USB MSC Host: Teoria
Lekcja 15: USB MSC Host: FatFS
Lekcja 16: USB MSC Host: Kod
Lekcja 17: Pokaz slajdów na TFT
Lekcja 18: Zadanie domowe
Moduł 10: Low Power
Lekcja 1: Powitanie
Lekcja 2: Potrzebne narzędzia w tym tygodniu
Lekcja 3: Low Power: Teoria
Lekcja 4: Low Power: Tryby
Lekcja 5: Low Power w dokumentacji
Lekcja 6: Kalkulator zużycia energii w CubeMX
Lekcja 7: Sleep Mode: Teoria
Lekcja 8: Sleep Mode: Dokumentacja
Lekcja 9: Sleep Mode: Kod
Lekcja 10: Stop Mode: Teoria
Lekcja 11: Stop Mode: Dokumentacja
Lekcja 12: Stop Mode: Kod
Lekcja 13: Standby Mode: Teoria
Lekcja 14: Standby Mode: Dokumentacja
Lekcja 15: Standby Mode: Kod
Moduł 11: RTOS
Lekcja 1: Powitanie
Lekcja 2: Potrzebne narzędzia w tym tygodniu
Lekcja 3: Czym jest RTOS?
Lekcja 4: Jak działa RTOS: Zadania
Lekcja 5: Jak działa RTOS: Scheduler
Lekcja 6: Jak działa RTOS: Zmiana kontekstu
Lekcja 7: Jak działa RTOS: Wywłaszczanie zadań
Lekcja 8: Pamięć w RTOS
Lekcja 9: Priorytety NVIC i RTOS
Lekcja 10: FreeeRTOS API
Lekcja 11: CMSIS-OS API
Lekcja 12: FreeRTOS w CubeMX
Lekcja 13: Struktura plików
Lekcja 14: Opóźnienia Delay: Teoria
Lekcja 15: Miganie diodami na Delayu
Lekcja 16: printf i sprintf w RTOS
Lekcja 17: printf i sprintf w RTOS: Kod
Lekcja 18: Problem wyścigów, pojęcie poducentów i konsumentów
Lekcja 19: Komunikacja między zadaniami - wskaźnik?
Lekcja 20: Kolejka: Teoria
Lekcja 21: Kolejka: API
Lekcja 22: Kolejka: Kod CMSIS V2 API
Lekcja 23: Kolejka: Kod CMSIS V2 API - przerwanie
Lekcja 24: Kolejka: Kod FreeRTOS API
Lekcja 25: Semafory: Teoria
Lekcja 26: Semafory: API
Lekcja 27: Semafor binarny: Kod CMSIS V2 API
Lekcja 28: Semafor binarny: Kod CMSIS V2 API - przerwanie
Lekcja 29: Semafor binarny: Kod FreeRTOS API
Lekcja 30: Semafory: Odwrócenie priorytetów
Lekcja 31: Semafory: Odwrócenie priorytetów - Kod
Lekcja 32: Semafor zliczający: Kod CMSIS V2 API
Lekcja 32a: Semafor zliczający: Kod CMSIS V2 API - Debug
Lekcja 33: Semafor zliczający: Kod FreeRTOS API
Lekcja 34: Mutex: Teoria
Lekcja 35: Mutex: API
Lekcja 36: Mutex: Kod CMSIS V2 API
Lekcja 37: Mutex: Kod FreeRTOS API
Lekcja 38: Sekcja krytyczna: Teoria
Lekcja 39: Sekcja krytyczna: Kod
Lekcja 40: Task Notification: Teoria
Lekcja 41: Task Notification: API
Lekcja 42: Task Notification: Kod CMSIS V2 API
Lekcja 43: Task Notification: Kod FreeRTOS API
Lekcja 44: Timer Software'owy: Teoria
Lekcja 45: Timer Software'owy: API
Lekcja 46: Timer Software'owy: Kod CMSIS V2 API
Lekcja 47: Timer Software'owy: Kod FreeRTOS API
Lekcja 48: Hooki: Teoria
Lekcja 49: Hooki: Kod Idle Hook
Lekcja 50: Prosty projekt: Założenia
Lekcja 51: Prosty projekt: Kod
Lekcja 52: Prosty projekt: Kolejka zamiast wpółdzielonej pamięci?
Lekcja 53: Prosty projekt: Kolejka Kod
Lekcja 54: Prosty projekt: Szatkowanie OLED: Teoria
Lekcja 55: Prosty projekt: Szatkowanie OLED: Kod
Lekcja 56: Prosty projekt: Dodajmy ADC: Teoria
Lekcja 57a: Prosty projekt: Dodajmy ADC: Kod - konfiguracja wstępna
Lekcja 57b: Prosty projekt: Dodajmy ADC: Kod - piszemy
Lekcja 57c: Prosty projekt: Dodajmy ADC: Kod - debug z Hookami
Lekcja 57d: Prosty projekt: Dodajmy ADC: Kod - wyświetlanie wyniku FFT, zagłodzenie zadania
Lekcja 58: Prosty Projekt: Podsumowane
Moduł 12: Co dalej?
Lekcja 1: Powitanie
Lekcja 2: HAL to dopiero początek
Lekcja 3: Możliwości innych mikrokontrolerów STM32
Lekcja 4: Biblioteki Middleware, Frameworki, Protokoły
Lekcja 5: Wiedza z zakresu elektroniki
Lekcja 6: Własne projekty
Lekcja 7: Przeniesienie projektu na własne PCB
Lekcja 8: Pierwsza praca w embedded?
Lekcja 9: Dzielenie się wiedzą
Lekcja 10: Aktualizacje do kursu
Lekcja 11: Słowo na zakończenie
Lekcja 12: Praca domowa

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

Jeżeli masz dodatkowe pytania - pisz do mnie na mateusz@msalamon.pl

.