Trenażer kodu Morse’a (CW) na ESP32 z ekranem dotykowym 2.8″ – Projekt DIY

Telegrafia (CW) to dla każdego krótkofalowca absolutny fundament i piękna tradycja. Choć na pasmach królują dziś nowoczesne emisje cyfrowe, nic nie zastąpi satysfakcji z płynnego odbioru i nadawania kluczem. Aby stale szlifować swoje umiejętności, postanowiłem zbudować własny, autonomiczny trenażer kodu Morse’a.

Po wcześniejszych eksperymentach z minikomputerami (takimi jak Raspberry Pi), tym razem postawiłem na stworzenie urządzenia w pełni niezależnego, kompaktowego i błyskawicznie uruchamiającego się. Wybór padł na wydajny mikrokontroler ESP32 oraz duży, czytelny wyświetlacz TFT 2.8 cala z panelem dotykowym. Taki zestaw idealnie sprawdzi się zarówno na stałe w radioshacku, jak i w warunkach mobilnych.

W tym artykule przeprowadzę Was krok po kroku przez proces budowy – od podłączenia pierwszych przewodów na stole, przez kodowanie, aż po zamknięcie wszystkiego w dedykowanej obudowie.

Zaleca się przeczytanie całego tekstu poradnika wraz z opisem zmian w części z paczkami .zip poniewasz są tam podane dodadkowe biblioteki do wgrania w Arduino 🙂 wynika to z tego , że projekt sie rozwijał i dochodziły nowe funkcje wymagające dodadkowych bibliotek .

Ten trenażer to projekt typu Open Source. Udostępniam go całkowicie za darmo dla całej braci krótkofalarskiej oraz osób uczących się telegrafii. Chcę, aby służył do nauki, treningu i rozwijania naszej pięknej pasji. Szczegóły licencji na dole strony.

Projekt jest w fazie ciągłego rozwoju i jest przeze mnie stale testowany w warunkach polowych. Oprogramowanie ma charakter rozwojowy – mogą pojawiać się aktualizacje i poprawki. Zachęcam do zaglądania na stronę co jakiś czas, aby sprawdzić, czy dostępna jest nowsza wersja.

Co będzie nam potrzebne? (Lista komponentów)

Sercem projektu są powszechnie dostępne i niedrogie moduły elektroniczne. Do budowy trenażera przygotowałem:

1. Płytka ESP32 (wygodna, 38-pinowa wersja, która oferuje dużą liczbę łatwo dostępnych wyprowadzeń GPIO).
2. Wyświetlacz TFT 2.8″ SPI ze sterownikiem ILI9341 (wyposażony w rezystancyjny panel dotykowy). Upewnij się , że masz wersje z dotykiem !
3. Moduł wzmacniacza audio PAM8403 z potencjometrem (zapewni czysty ton i wygodną, płynną regulację głośności za pomocą fizycznego pokrętła).
4. Przewody połączeniowe Dupont (żeńsko-żeńskie) do spięcia układu testowego.
5. Obudowa (zaprojektowana i wydrukowana na drukarce 3D).
6. Gniazdo mini Jack
7. Głośniczek 8 ohm (ja wykorzystałem ze starej nawigacji)

Krok 1: Podłączenie wyświetlacza TFT (Magistrala SPI)

Prace montażowe zawsze warto podzielić na etapy. Zaczynamy od uruchomienia samej matrycy wyświetlacza „na pająka” na biurku, bez montowania jej w obudowie. Pozwoli to na szybkie wyłapanie ewentualnych błędów w połączeniach. Na tym etapie sekcję dotykową (T_CLK, T_CS itd.) zostawiamy jeszcze niepodłączoną.

Do uruchomienia ekranu potrzebujemy dokładnie 9 kolorowych przewodów Dupont. Bardzo ważną kwestią jest zasilanie: wyświetlacz wymaga osobnego zasilania logiki układu (VCC) oraz zasilania podświetlenia ekranu (LED). Aby nie przeciążać wewnętrznego stabilizatora 3.3V w ESP32, linię VCC podpinamy pod pin VIN (5V z USB), natomiast podświetlenie LED pod pin 3V3.

Poniższa tabela przedstawia precyzyjne mapowanie pinów pomiędzy wyświetlaczem a ESP32:

Rozmieszczenie przewodów na wyświetlaczu .

Skoro wyświetlacz ma już wpięte kable według kolorów, połowa pracy za nami. Teraz bierzemy do ręki czarną płytkę ESP32.

Szukaj na niej małych, białych nadruków przy nóżkach. Różne wersje ESP32 mają lekko inne oznaczenia (czasem jest napisane D15, czasem samo 15, a czasem G15), ale układ zazwyczaj jest ten sam.

Wpinaj drugie końce kabli po kolei:

Lewa strona płytki (patrząc od góry do dołu):

• Pomarańczowy (LED) ➔ Wepnij w 3V3 (sam lewy górny róg, pierwsza nóżka).
• Czerwony (VCC) ➔ Wepnij w V5 (sam lewy dolny róg, ostatnia nóżka).

Prawa strona płytki (od góry do dołu):

• Czarny/Brązowy (GND) ➔ Wepnij w GND (sam prawy górny róg, pierwsza nóżka).
• Niebieski (MOSI) ➔ Wepnij w G23 (zaraz pod GND, druga nóżka od góry).
• Szary (MISO) ➔ Wepnij w G19 (ósma nóżka od góry).
• Fioletowy (SCK) ➔ Wepnij w G18 (dziewiąta nóżka od góry, tuż pod G19).

Prawa strona płytki (od dołu do góry):

• Zielony (CS) ➔ Wepnij w G15 (czwarta nóżka od dołu).
• Żółty (DC) ➔ Wepnij w G2 (piąta nóżka od dołu, tuż nad G15).
• Biały (RESET) ➔ Wepnij w G4 (siódma nóżka od dołu).

Jak tylko powpinasz te przewody w odpowiednie „G-piny” i w „V5”, ten etap fizyczny mamy zamknięty.

Krok 2: Oprogramowanie i pierwszy test ekranu (Windows)

Skoro mamy już fizycznie połączonego „pająka”, czas tchnąć w niego życie. Środowiskiem, w którym napiszemy i wgramy kod do naszego mikrokontrolera, jest popularne i darmowe Arduino IDE. W tej sekcji przejdziemy przez konfigurację krok po kroku na systemie Windows.

1. Pobranie Arduino IDE i dodanie ESP32

Zaczynamy od pobrania najnowszego środowiska Arduino IDE (wersja 2.x) z oficjalnej strony arduino.cc. Po standardowej instalacji uruchamiamy program. Podczas pierwszego uruchamiania Arduino IDE program pyta, czy zainstalować sterowniki , zainstaluj je wszystkie.

W górnym menu wybierz Plik (File) ➔ Preferencje (Preferences) i zmień język na polski, jeśli tego potrzebujesz.

Czyste Arduino IDE jest przystosowane do małych płytek i nie posiada wbudowanej obsługi potężniejszych procesorów ESP32. Musimy ją dodać:

Z lewego menu wybieramy ikonę Menadżer płytek , wyszukujemy i instalujemy paczkę o nazwie esp32 by Espressif Systems.

W górnym menu wchodzimy w Plik ➔ Preferencje.

W polu Dodatkowe adresy URL menedżera płytek wklejamy poniższy link przygotowany przez producenta układu: https://espressif.github.io/arduino-esp32/package_esp32_index.json

Zapisujemy klikając OK.

2. Wykrycie portu COM

Teraz podłączamy naszą płytkę ESP32 kablem USB do komputera. Aby wgrać kod, komputer musi wiedzieć, po jakim „kanale” (porcie) ma komunikować się z układem.

1. Klikamy przycisk Start w systemie Windows, wpisujemy i otwieramy Menedżer urządzeń.
2. Rozwijamy sekcję Porty (COM i LPT).
3. Szukamy urządzenia o nazwie Silicon Labs CP210x USB to UART Bridge. Na końcu tej nazwy będzie znajdował się przydzielony port, np. (COM5). Zapamiętujemy ten numer.
4. W razie problemów ze sterownikami tutaj możesz je pobrać CP210x Universal Windows Driver

W Arduino IDE przypisujemy te dane. Wybieramy naszą płytkę: Narzędzia ➔ Płytka ➔ DOIT ESP32 DEVKIT V1 (lub ESP32 Dev Module)

oraz nasz port: Narzędzia ➔ Port ➔ COM…

3. Instalacja i konfiguracja biblioteki TFT_eSPI

Obsługa ekranów graficznych wymaga bardzo szybkiego i zoptymalizowanego kodu. Najlepszym silnikiem do tego zadania jest biblioteka TFT_eSPI.

1. W Arduino IDE otwieramy Menedżer Bibliotek (ikona z książkami w lewym menu).
2. W wyszukiwarkę wpisujemy TFT_eSPI, odnajdujemy wersję, której autorem jest Bodmer i klikamy Zainstaluj.

Bardzo ważny krok: Ta biblioteka ze względu na szybkość działania wymaga fizycznej edycji pliku konfiguracyjnego na dysku naszego komputera. Otwieramy w systemie Windows folder: Dokumenty\Arduino\libraries\TFT_eSPI i edytujemy w Notatniku plik o nazwie User_Setup.h.

Zróbmy to najprościej i najszybciej jak się da, bez ręcznego szukania linijek. Przygotowałem dla Ciebie kompletny, gotowy plik z ustawioną bezpieczną prędkością 27 MHz.

Oto co musisz zrobić:

Otwórz w notatniku plik User_Setup.h

Wciśnij Ctrl + A (żeby zaznaczyć wszystko).

Wciśnij Delete (żeby zrobić całkowicie pustą stronę).

skopiuj cały poniższy kod i wklej go do notatnika na tą pustą strone i nie zapomnij zapisać .

//                            USER DEFINED SETTINGS
#define USER_SETUP_INFO "User_Setup"

// ##################################################################################
// Section 1. Call up the right driver file and any options for it
// ##################################################################################

#define ILI9341_DRIVER       // Generic driver for common displays

// ##################################################################################
// Section 2. Define the pins that are used to interface with the display here
// ##################################################################################

#define TFT_MISO 19
#define TFT_MOSI 23
#define TFT_SCLK 18
#define TFT_CS   15  // Chip select control pin
#define TFT_DC    2  // Data Command control pin
#define TFT_RST   4  // Reset pin (could connect to RST pin)

// ##################################################################################
// Section 3. Define the fonts that are to be used here
// ##################################################################################

#define LOAD_GLCD   // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2  // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4  // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6  // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7  // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:-.
#define LOAD_FONT8  // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
#define LOAD_GFXFF  // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts
#define SMOOTH_FONT

// ##################################################################################
// Section 4. Other options
// ##################################################################################

// Tutaj ustawiona jest niższa, bezpieczna prędkość 27 MHz dla kabli na biurku:
#define SPI_FREQUENCY  27000000

#define SPI_READ_FREQUENCY  20000000
#define SPI_TOUCH_FREQUENCY  2500000

//                            USER DEFINED SETTINGS
#define USER_SETUP_INFO "User_Setup"

// ##################################################################################
// Section 1. Call up the right driver file and any options for it
// ##################################################################################

#define ILI9341_DRIVER       // Generic driver for common displays

// ##################################################################################
// Section 2. Define the pins that are used to interface with the display here
// ##################################################################################

#define TFT_MISO 19
#define TFT_MOSI 23
#define TFT_SCLK 18
#define TFT_CS   15  // Chip select control pin
#define TFT_DC    2  // Data Command control pin
#define TFT_RST   4  // Reset pin (could connect to RST pin)

// ##################################################################################
// Section 3. Define the fonts that are to be used here
// ##################################################################################

#define LOAD_GLCD   // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2  // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4  // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6  // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7  // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:-.
#define LOAD_FONT8  // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
#define LOAD_GFXFF  // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts
#define SMOOTH_FONT

// ##################################################################################
// Section 4. Other options
// ##################################################################################

// Tutaj ustawiona jest niższa, bezpieczna prędkość 27 MHz dla kabli na biurku:
#define SPI_FREQUENCY  27000000

#define SPI_READ_FREQUENCY  20000000
#define SPI_TOUCH_FREQUENCY  2500000

Zapisz plik wciskając Ctrl + S i zamknij Notatnik.

4. Testowy kod ekranu

Zanim klikniemy „Wgraj”, musimy podać naszemu mikrokontrolerowi program do wykonania, który sprawdzi, czy poprawnie skonfigurowaliśmy piny z poprzedniego kroku.

1. W Arduino IDE w górnym menu wybierz Plik ➔ Nowy Szkic (File ➔ New Sketch).
2. W oknie edytora pojawi się domyślny, krótki kod. Kliknij wewnątrz okna, wciśnij Ctrl + A (aby zaznaczyć wszystko) i wciśnij Delete (aby całkowicie wyczyścić ekran).
3. Skopiuj poniższy kod testowy i wklej go do tego pustego okna:

#include <TFT_eSPI.h>
#include <SPI.h>

// Inicjalizacja ekranu
TFT_eSPI tft = TFT_eSPI();

void setup() {
  // Start ekranu i ustawienie orientacji
  tft.init();
  tft.setRotation(1);
  
  // Wypełnienie ekranu czarnym tłem
  tft.fillScreen(TFT_BLACK);
  
  // Ustawienie punktu odniesienia tekstu na środek ekranu
  tft.setTextDatum(MC_DATUM);
  
  // Linia 1
  tft.setTextColor(TFT_WHITE);
  tft.setTextSize(3);
  tft.drawString("Ekran Dziala !", 160, 80);
  
  // Linia 2
  tft.setTextColor(TFT_GREEN);
  tft.setTextSize(3);
  tft.drawString("Dotyk OK !", 160, 130);
  
  // Linia 3
  tft.setTextColor(TFT_SKYBLUE);
  tft.setTextSize(3);
  tft.drawString("SP3UQH 73", 160, 180);
}

void loop() {
  // Pusty loop - ekran tylko wyświetla tekst
}

#include <TFT_eSPI.h>
#include <SPI.h>

// Inicjalizacja ekranu
TFT_eSPI tft = TFT_eSPI();

void setup() {
  // Start ekranu i ustawienie orientacji
  tft.init();
  tft.setRotation(1);
  
  // Wypełnienie ekranu czarnym tłem
  tft.fillScreen(TFT_BLACK);
  
  // Ustawienie punktu odniesienia tekstu na środek ekranu
  tft.setTextDatum(MC_DATUM);
  
  // Linia 1
  tft.setTextColor(TFT_WHITE);
  tft.setTextSize(3);
  tft.drawString("Ekran Dziala !", 160, 80);
  
  // Linia 2
  tft.setTextColor(TFT_GREEN);
  tft.setTextSize(3);
  tft.drawString("Dotyk OK !", 160, 130);
  
  // Linia 3
  tft.setTextColor(TFT_SKYBLUE);
  tft.setTextSize(3);
  tft.drawString("SP3UQH 73", 160, 180);
}

void loop() {
  // Pusty loop - ekran tylko wyświetla tekst
}

4.Wybierz Plik ➔ Zapisz jako… i nazwij swój projekt np. Test_Ekranu.

5.Teraz, mając wklejony kod w Arduino IDE, kliknij przycisk Wgraj (strzałka w prawo).

Ważna uwaga (Problem z połączeniem): Przy wgrywaniu oprogramowania na ESP32 bardzo często pojawia się problem komunikacyjny. Jeśli w dolnej, czarnej konsoli Arduino IDE wyświetli się pomarańczowy napis Connecting... i proces się zatrzyma, oznacza to, że Twoja płytka nie potrafi automatycznie wymusić trybu programowania.

Rozwiązanie: W momencie, gdy zobaczysz napis Connecting..., wciśnij i przytrzymaj przez około 2-3 sekundy fizyczny przycisk BOOT (lub FLASH), który znajduje się na czarnej płytce ESP32 (tuż obok gniazda USB). Gdy tylko w konsoli ruszą procenty oznaczające wgrywanie, puść przycisk.

Jeśli wszystko poszło ok, to Twoim oczom powinno ukazać się to 🙂

Trenażer CW bez dźwięku to tylko świecąca ramka cyfrowa, więc następny w kolejce jest wzmacniacz audio PAM8403 z potencjometrem. Przygotuj moduł wzmacniacza, mały głośniczek i kilka kolejnych kabelków.

Krok 3: Udźwiękowienie trenażera (Wzmacniacz PAM8403)

Trenażer CW bez dźwięku to tylko cyfrowa ramka na zdjęcia. Aby usłyszeć upragnione „pikanie”, musimy wygenerować sygnał z mikrokontrolera i odpowiednio go wzmocnić.

Zamiast budować skomplikowane układy audio, użyjemy gotowego, miniaturowego modułu wzmacniacza w klasie D – PAM8403. Posiada on zintegrowany potencjometr, co w trenażerze jest funkcją kluczową (możemy płynnie ściszyć dźwięk podczas nocnych ćwiczeń, nie budząc domowników). Jako źródło dźwięku wykorzystałem z odzysku stary, ale solidny głośniczek wymontowany z nieużywanej nawigacji samochodowej.

Podłączenie modułu audio

Wzmacniacz PAM8403 jest stereofoniczny (ma kanał lewy i prawy), ale do telegrafii wystarczy nam w zupełności sygnał monofoniczny, więc wykorzystamy tylko jedną stronę (np. lewą).

Podłączamy przewody według poniższego schematu:

Porada praktyczna: Współdzielenie pinów zasilania

„Zauważysz pewnie, że piny V5 i GND na płytce ESP32 są już zajęte przez przewody od wyświetlacza. Najprostszym sposobem na montaż »na pająka« jest rozcięcie przewodów na dwie części, odizolowanie końcówek, skręcenie ich wszystkich razem, zlutowanie i zabezpieczenie koszulką termokurczliwą”.

Gdzie przylutować przewody na wzmacniaczu ?

Mając to zdjęcie przed oczami, oto ostateczna „mapa drogowskazów” dla Twojej lutownicy, punkt po punkcie:

1. Zasilanie (środek płytki, nad srebrnym kondensatorem)

Widzisz tam wyraźny napis + power -.

• Czerwony przewód przylutuj do padu +
• Czarny przewód przylutuj do padu -

2. Wejście dźwięku (lewa strona, obok potencjometru)

Widzisz tam napisy L G R (Left, Ground, Right).

• Żółty przewód przylutuj do padu L
• Czarny przewód przylutuj do padu G

3. Wyjście na głośnik (prawa strona płytki)

Widzisz tam dwie sekcje: - rout + (prawy) oraz - lout + (lewy). Nas interesuje tylko ta lewa (lout). Bierzemy kabelki przylutowane do głośniczka:

• Czerwony kabel od głośnika przylutuj do padu + (w sekcji lout)
• Czarny kabel od głośnika przylutuj do padu - (w sekcji lout)

Gdzie to potem wpiąć w ESP32?

Gdy już pewnie przylutujesz kable z drugiej i trzeciej strony do modułu audio, ich wolne, zakończone wtyczkami końce wpinasz w naszą czarną płytkę:

• Czerwony (power +) ➔ wpinasz w pin V5 (razem z zasilaniem ekranu).
• Oba czarne (power - oraz G) ➔ wpinasz w pin GND (razem z masą ekranu).
• Żółty (L) ➔ wpinasz w wolny pin G25.

Skoro wszystko spięte, to nadchodzi chwila prawdy. Zobaczymy, czy z tego małego głośniczka z nawigacji poleci w eter telegrafia!

Zanim wgramy kod, upewnij się, że zielone pokrętło potencjometru na wzmacniaczu nie jest skręcone do zera. Przekręć je delikatnie w prawo, aż poczujesz charakterystyczny „klik” (włączenie zasilania układu audio) i ustaw je mniej więcej w połowie skali.

Teraz przechodzimy do Arduino IDE, żeby wgrać oprogramowanie generujące dźwięk.

Instrukcja wgrania kodu audio:

1. Wróć do okna Arduino IDE.
2. Kliknij w pole z kodem, wciśnij Ctrl + A (zaznacz wszystko), a następnie Delete (żeby usunąć stary kod i uniknąć błędu z „redefinition”).
3. Skopiuj poniższy kompletny kod i wklej go na czystą stronę:

#include <TFT_eSPI.h>

TFT_eSPI tft = TFT_eSPI();

// Definiujemy pin, z którego wychodzi dźwięk
#define AUDIO_PIN 25
#define TONE_FREQ 700 // Częstotliwość dźwięku w Hz (klasyczny ton CW)

void setup() {
  Serial.begin(115200);
  
  // Konfiguracja ekranu
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  
  tft.drawRect(5, 5, 310, 230, TFT_GOLD);
  tft.drawRect(6, 6, 308, 228, TFT_GOLD);
  
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(3);
  tft.setCursor(20, 40);
  tft.println("TRENAZER CW");
  
  tft.setTextColor(TFT_GREEN, TFT_BLACK);
  tft.setTextSize(5);
  tft.setCursor(65, 100);
  tft.println("SP3UQH");
  
  tft.setTextColor(TFT_BLUE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(40, 180);
  tft.println("Test dzwieku: CQ...");

  // Konfiguracja pinu audio
  pinMode(AUDIO_PIN, OUTPUT);
}

// Funkcje pomocnicze do generowania kropek i kresek
void dot() {
  tone(AUDIO_PIN, TONE_FREQ);
  delay(100); // Długość kropki
  noTone(AUDIO_PIN);
  delay(100); // Przerwa między znakami w jednej literze
}

void dash() {
  tone(AUDIO_PIN, TONE_FREQ);
  delay(300); // Długość kreski (standardowo 3x kropka)
  noTone(AUDIO_PIN);
  delay(100);
}

void loop() {
  // Nadajemy literę C (-.-.)
  dash(); dot(); dash(); dot();
  
  delay(200); // Przerwa między literami
  
  // Nadajemy literę Q (--.-)
  dash(); dash(); dot(); dash();
  
  delay(2000); // Dłuższa przerwa przed kolejnym zapętleniem wywołania
}

#include <TFT_eSPI.h>

TFT_eSPI tft = TFT_eSPI();

// Definiujemy pin, z którego wychodzi dźwięk
#define AUDIO_PIN 25
#define TONE_FREQ 700 // Częstotliwość dźwięku w Hz (klasyczny ton CW)

void setup() {
  Serial.begin(115200);
  
  // Konfiguracja ekranu
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  
  tft.drawRect(5, 5, 310, 230, TFT_GOLD);
  tft.drawRect(6, 6, 308, 228, TFT_GOLD);
  
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(3);
  tft.setCursor(20, 40);
  tft.println("TRENAZER CW");
  
  tft.setTextColor(TFT_GREEN, TFT_BLACK);
  tft.setTextSize(5);
  tft.setCursor(65, 100);
  tft.println("SP3UQH");
  
  tft.setTextColor(TFT_BLUE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(40, 180);
  tft.println("Test dzwieku: CQ...");

  // Konfiguracja pinu audio
  pinMode(AUDIO_PIN, OUTPUT);
}

// Funkcje pomocnicze do generowania kropek i kresek
void dot() {
  tone(AUDIO_PIN, TONE_FREQ);
  delay(100); // Długość kropki
  noTone(AUDIO_PIN);
  delay(100); // Przerwa między znakami w jednej literze
}

void dash() {
  tone(AUDIO_PIN, TONE_FREQ);
  delay(300); // Długość kreski (standardowo 3x kropka)
  noTone(AUDIO_PIN);
  delay(100);
}

void loop() {
  // Nadajemy literę C (-.-.)
  dash(); dot(); dash(); dot();
  
  delay(200); // Przerwa między literami
  
  // Nadajemy literę Q (--.-)
  dash(); dash(); dot(); dash();
  
  delay(2000); // Dłuższa przerwa przed kolejnym zapętleniem wywołania
}

4. Kliknij przycisk Wgraj (strzałka w prawo w lewym górnym rogu).

Po pomyślnym wgraniu kodu wyświetlacz pokaże nowy napis („Test dzwieku: CQ…”), a z głośnika powinno rozlec się głośne i wyraźne wywołanie ogólne w kodzie Morse’a, powtarzane w pętli. Jeśli będzie za głośno, od razu przetestuj płynność działania potencjometru.

Krok 4: Podłączenie gniazda dla klucza (Paddle)

Nasz układ potrafi już generować dźwięk i wyświetlać obraz, więc czas dać mu możliwość odbierania naszych komend. W tym projekcie skupiamy się na obsłudze klucza dwudźwigniowego (zwanego potocznie paddle), co wymusza na naszym mikrokontrolerze ESP32 pełnienie funkcji elektronicznego klucza (tzw. iambic keyer).

Aby podłączyć klucz elegancko i trwale, zastosowałem standardowe gniazdo panelowe Jack (stereo), które docelowo zamontuję w obudowie. Klucz dwudźwigniowy działa jak dwa oddzielne przełączniki, dlatego potrzebujemy trzech przewodów. Aby uniknąć pomyłek, zastosowałem nową kolorystykę kabli:

1. Masa (Sleeve) – wspólna dla obu dźwigni. Lutujemy do niej przewód Czarny.
2. Kropka / Dit (Tip) – lewa dźwignia. Lutujemy do niej przewód Niebieski.
3. Kreska / Dah (Ring) – prawa dźwignia. Lutujemy do niej przewód Zielony.

Jak rozpoznać nóżki w gnieździe Jack?

Zazwyczaj najdłuższa blaszka (lub ta połączona bezpośrednio z gwintowaną obudową gniazda) to nasza Masa. Dwie pozostałe, mniejsze blaszki to kanał lewy i prawy. Przylutuj do nich przewód niebieski i zielony.

 Porada praktyczna: Odwrócone kropki i kreski? Jeśli po zlutowaniu gniazda i podłączeniu klucza okaże się, że lewa łopatka nadaje kreski, a prawa kropki (czyli odwrotnie niż jesteś przyzwyczajony) – absolutnie nic nie przelutowuj! Wystarczy, że na płytce ESP32 zamienisz miejscami wtyczki przewodu niebieskiego i zielonego.

Gdzie wpiąć kable do ESP32?

Wybieramy dwa wolne piny na płytce ESP32, które posiadają wbudowane wewnętrzne rezystory podciągające (pull-up). Dzięki temu nie musimy lutować żadnych dodatkowych oporników na biurku – wystarczy zwarcie pinu do masy, aby układ poprawnie wykrył naciśnięcie dźwigni!

Zdecydowałem się na piny G32 oraz G33, które znajdują się na lewej krawędzi płytki, tuż nad naszym pinem audio (G25).

1. Zielony przewód (Kreski) ➔ Wpinamy w pin G33.
2. Czarny przewód (Masa) ➔ Wpinamy w dowolny wolny pin GND na ESP32 (możesz go też skręcić z naszą główną masą).
3. Niebieski przewód (Kropki) ➔ Wpinamy w pin G32.

Kod testowy – Pierwsze kluczowanie

Teraz musimy zaprogramować ESP32 tak, aby reagował na zwieranie tych pinów do masy. W poniższym kodzie testowym zaimplementowałem podstawową logikę elektronicznego klucza. Zdefiniowałem prędkość na około 20 WPM (słów na minutę), co daje nam kropkę trwającą równe 60 milisekund, a kreskę 180 milisekund (proporcja 1:3).

Teraz przygotuj kable od swojego klucza. Jeśli ma on wtyk Jack (duży lub mały), najłatwiej będzie użyć żeńskiego gniazda z przylutowanymi kabelkami, albo połączyć to na szybko za pomocą przewodów z krokodylkami.

Podepnij wszystko według tego schematu:

• Masa klucza ➔ GND
• Kropki (DIT) ➔ G32
• Kreski (DAH) ➔ G33

Gdy to zrobisz, skopiuj poniższy kod, usuń wszystko z Arduino IDE (Ctrl+A, Delete) i wgraj nowy program:

#include <TFT_eSPI.h>

TFT_eSPI tft = TFT_eSPI();

#define AUDIO_PIN 25
#define DIT_PIN 32
#define DAH_PIN 33
#define TONE_FREQ 700

// Prędkość kluczowania (około 20 WPM)
int ditTime = 60; // Czas trwania kropki w milisekundach

void setup() {
  Serial.begin(115200);
  
  // Konfiguracja ekranu
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  tft.drawRect(5, 5, 310, 230, TFT_GOLD);
  tft.drawRect(6, 6, 308, 228, TFT_GOLD);
  
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(3);
  tft.setCursor(20, 40);
  tft.println("TRENAZER CW");
  
  tft.setTextColor(TFT_GREEN, TFT_BLACK);
  tft.setTextSize(5);
  tft.setCursor(65, 100);
  tft.println("SP3UQH");
  
  tft.setTextColor(TFT_BLUE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(40, 180);
  tft.println("Test klucza (Paddle)");

  // Konfiguracja pinów
  pinMode(AUDIO_PIN, OUTPUT);
  
  // INPUT_PULLUP włącza wewnętrzne rezystory, pin jest domyślnie w stanie HIGH (3.3V)
  // Zwarcie do masy zmienia stan na LOW
  pinMode(DIT_PIN, INPUT_PULLUP);
  pinMode(DAH_PIN, INPUT_PULLUP);
}

void playTone(int duration) {
  tone(AUDIO_PIN, TONE_FREQ);
  delay(duration);
  noTone(AUDIO_PIN);
  delay(ditTime); // Standardowa przerwa po każdym znaku (równa długości kropki)
}

void loop() {
  // Sprawdzamy, czy lewa dźwignia (Kropka) jest wciśnięta (stan LOW)
  if (digitalRead(DIT_PIN) == LOW) {
    playTone(ditTime);
  }
  
  // Sprawdzamy, czy prawa dźwignia (Kreska) jest wciśnięta (stan LOW)
  if (digitalRead(DAH_PIN) == LOW) {
    playTone(ditTime * 3); // Kreska jest 3 razy dłuższa niż kropka
  }
}

#include <TFT_eSPI.h>

TFT_eSPI tft = TFT_eSPI();

#define AUDIO_PIN 25
#define DIT_PIN 32
#define DAH_PIN 33
#define TONE_FREQ 700

// Prędkość kluczowania (około 20 WPM)
int ditTime = 60; // Czas trwania kropki w milisekundach

void setup() {
  Serial.begin(115200);
  
  // Konfiguracja ekranu
  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  tft.drawRect(5, 5, 310, 230, TFT_GOLD);
  tft.drawRect(6, 6, 308, 228, TFT_GOLD);
  
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(3);
  tft.setCursor(20, 40);
  tft.println("TRENAZER CW");
  
  tft.setTextColor(TFT_GREEN, TFT_BLACK);
  tft.setTextSize(5);
  tft.setCursor(65, 100);
  tft.println("SP3UQH");
  
  tft.setTextColor(TFT_BLUE, TFT_BLACK);
  tft.setTextSize(2);
  tft.setCursor(40, 180);
  tft.println("Test klucza (Paddle)");

  // Konfiguracja pinów
  pinMode(AUDIO_PIN, OUTPUT);
  
  // INPUT_PULLUP włącza wewnętrzne rezystory, pin jest domyślnie w stanie HIGH (3.3V)
  // Zwarcie do masy zmienia stan na LOW
  pinMode(DIT_PIN, INPUT_PULLUP);
  pinMode(DAH_PIN, INPUT_PULLUP);
}

void playTone(int duration) {
  tone(AUDIO_PIN, TONE_FREQ);
  delay(duration);
  noTone(AUDIO_PIN);
  delay(ditTime); // Standardowa przerwa po każdym znaku (równa długości kropki)
}

void loop() {
  // Sprawdzamy, czy lewa dźwignia (Kropka) jest wciśnięta (stan LOW)
  if (digitalRead(DIT_PIN) == LOW) {
    playTone(ditTime);
  }
  
  // Sprawdzamy, czy prawa dźwignia (Kreska) jest wciśnięta (stan LOW)
  if (digitalRead(DAH_PIN) == LOW) {
    playTone(ditTime * 3); // Kreska jest 3 razy dłuższa niż kropka
  }
}

Efekt końcowy powinien być taki 🙂

Podłączenie panelu dotykowego (Touchscreen)

Skoro mamy już obraz i dźwięk, czas na interakcję. Ostateczna wersja oprogramowania trenażera opiera się w pełni na nawigacji dotykowej. Ekran dotykowy korzysta z tej samej magistrali komunikacyjnej (SPI) co sam wyświetlacz, ale posiada własny układ sterujący (najczęściej XPT2046) i wymaga podpięcia dodatkowych pinów.

Niektóre przewody musimy połączyć z tymi, które już wcześniej podpięliśmy (współdzielą linię danych), a inne trafiają na zupełnie nowe piny ESP32.

Oto schemat podłączenia pozostałych pinów z wyświetlacza:

Aby to zadziałało w programie, musimy zainstalować jeszcze jedną bibliotekę. W Arduino IDE wchodzimy w Menedżer Bibliotek (ikona książek), wpisujemy XPT2046_Touchscreen i instalujemy wersję, której autorem jest Paul Stoffregen.

Test panelu dotykowego

Skoro dodaliśmy nowe przewody i zainstalowaliśmy bibliotekę, zachowajmy naszą żelazną zasadę: testujemy sprzęt od razu! Zanim przejdziemy do wgrywania wielkiego, docelowego oprogramowania trenażera, sprawdźmy, czy dotyk w ogóle reaguje.

Przygotowałem bardzo prosty kod testowy. Zamienia on nasz wyświetlacz w prymitywny program do rysowania. Jeśli po wgraniu tego kodu dotkniesz ekranu, w miejscu styku powinna pojawić się czerwona kropka.

Wróć do Arduino IDE, usuń wszystko co tam masz (Ctrl + A, następnie Delete), wklej poniższy kod i kliknij Wgraj:

#include <TFT_eSPI.h>
#include <SPI.h>
#include <XPT2046_Touchscreen.h>

#define TOUCH_CS 5
#define TOUCH_IRQ 34
#define BACKLIGHT_PIN 21 // To ten pin odpowiada za włączenie "żarówki" ekranu!

XPT2046_Touchscreen ts(TOUCH_CS, TOUCH_IRQ);
TFT_eSPI tft = TFT_eSPI();

void setup() {
  // WŁĄCZENIE PODŚWIETLENIA EKRANU (To naprawia czarny ekran)
  pinMode(BACKLIGHT_PIN, OUTPUT);
  digitalWrite(BACKLIGHT_PIN, HIGH); 

  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  
  ts.begin();
  ts.setRotation(1);
  
  tft.setTextColor(TFT_WHITE);
  tft.setTextSize(2);
  tft.setCursor(10, 10);
  tft.print("Dotknij ekranu!");
}

void loop() {
  if (ts.touched()) {
    TS_Point p = ts.getPoint();
    
    // Zmapowanie fizycznego dotyku na rozdzielczość ekranu 320x240
    int x = map(p.x, 200, 3800, 0, 320);
    int y = map(p.y, 200, 3800, 0, 240);
    
    // Rysujemy czerwoną kropkę w miejscu dotyku
    tft.fillCircle(x, y, 3, TFT_RED);
    delay(5);
  }
}

#include <TFT_eSPI.h>
#include <SPI.h>
#include <XPT2046_Touchscreen.h>

#define TOUCH_CS 5
#define TOUCH_IRQ 34
#define BACKLIGHT_PIN 21 // To ten pin odpowiada za włączenie "żarówki" ekranu!

XPT2046_Touchscreen ts(TOUCH_CS, TOUCH_IRQ);
TFT_eSPI tft = TFT_eSPI();

void setup() {
  // WŁĄCZENIE PODŚWIETLENIA EKRANU (To naprawia czarny ekran)
  pinMode(BACKLIGHT_PIN, OUTPUT);
  digitalWrite(BACKLIGHT_PIN, HIGH); 

  tft.init();
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  
  ts.begin();
  ts.setRotation(1);
  
  tft.setTextColor(TFT_WHITE);
  tft.setTextSize(2);
  tft.setCursor(10, 10);
  tft.print("Dotknij ekranu!");
}

void loop() {
  if (ts.touched()) {
    TS_Point p = ts.getPoint();
    
    // Zmapowanie fizycznego dotyku na rozdzielczość ekranu 320x240
    int x = map(p.x, 200, 3800, 0, 320);
    int y = map(p.y, 200, 3800, 0, 240);
    
    // Rysujemy czerwoną kropkę w miejscu dotyku
    tft.fillCircle(x, y, 3, TFT_RED);
    delay(5);
  }
}

Jeśli możesz palcem (lub rysikiem) mazać po ekranie na czerwono, to znaczy, że układ zmontowany jest perfekcyjnie i jesteś gotowy na instalację docelowego oprogramowania!

Pierwsze testy sprzętowe już za nami, czas więc zaprogramować pełną funkcjonalność urządzenia. Na początek przygotowałem własne logo – wita nas ono na ekranie powitalnym tuż po uruchomieniu, a w chwilach bezczynności świetnie sprawdza się jako wygaszacz.

Uwaga! Aby trenażer mógł płynnie regulować jasność ekranu i wygaszać go w czasie bezczynności, musimy przepiąć podświetlenie z zasilania na stałe na pin sterujący. Odłącz pomarańczowy przewód (LED) od pinu 3V3 na ESP32 i wepnij go w pin D21 (lub G21). Funkcja ta zostala dodana w nowszej wersji oprogramowania v3.3.

Krok 5: Przygotowanie kodu w Arduino IDE i wgrywanie oprogramowania

Nasz sprzęt jest już w 100% gotowy pod względem elektronicznym, a ekran dotykowy jest prawidłowo podłączony. Przyszedł czas na najważniejszy moment – wgranie ostatecznej, pełnej wersji oprogramowania, która uruchomi zaawansowany Trenażer CW z systemem Kocha, wyborem języka (Polski/Angielski) oraz symulacjami QSB i QRM.

Nasze oprogramowanie składa się z dwóch części: głównego programu oraz osobnego pliku z zakodowaną grafiką ekranu startowego (logo.h).

Przejdźmy przez proces przygotowania czystego projektu krok po kroku:

1. Czyszczenie i wklejanie głównego kodu

Ważna uwaga dotycząca optymalizacji strony: główny kod „Trenazer_CW_v2_0.ino” i „plik logo.h” zawiera potężną tablicę danych (ponad 41 000 linii kodu hex!). Wklejenie tak gigantycznego bloku tekstu bezpośrednio do tego artykułu sprawiłoby, że strona ładowałaby się potwornie wolno, szczególnie na smartfonach. Szanując Wasz czas i transfer, nie wklejam tego kodu bezpośrednio na stronie. Cały gotowy kod głowny i plik graficzny znajduje się w kompletnej paczce ZIP, którą możecie pobrać na dole tego wpisu.

1. W Arduino IDE kliknij Plik ➔ Nowy Szkic (File ➔ New Sketch).
2. Zobaczysz, że program automatycznie wygenerował kilka domyślnych linijek tekstu (szablon z void setup() i void loop()). Musimy się ich pozbyć!
3. Kliknij wewnątrz okna edytora tekstu i wciśnij kombinację klawiszy Ctrl + A (aby zaznaczyć absolutnie cały tekst w dokumencie).
4. Wciśnij klawisz Delete (lub Backspace), aby karta była całkowicie pusta.
5. Skopiuj pełny kod ostatecznej wersji trenażera (znajdziesz go w pliku .zip , którego możesz pobrać na dole strony i otwórz plik „Trenazer_CW_v2_0.ino” w Ntatniku , zaznacz całość , skupiuj i wklej go w to puste miejsce (Ctrl + V).

Krok 2. Dodanie pliku graficznego (logo.h) i tworzenie zakładki w Arduino IDE

Główny kod programu zawiera na samym początku linijkę #include "logo.h". Oznacza to, że mikrokontroler do poprawnego uruchomienia potrzebuje dodatkowego pliku z grafiką startową, która wyświetla się na ekranie TFT zaraz po włączeniu zasilania.

1. W prawym górnym rogu edytora kodu Arduino IDE (na wysokości paska, gdzie widać nazwę głównego pliku programu) kliknij ikonę trzech pionowych kropek lub małą strzałkę w dół (w zależności od wersji środowiska).
2. Z rozwijanego menu wybierz opcję Nowa zakładka (New Tab). Możesz też użyć szybkiego skrótu klawiszowego: Ctrl + Shift + N.
3. Na dole edytora pojawi się małe pole tekstowe. Wpisz tam dokładnie nazwę pliku: logo.h i zatwierdź klikając OK.
4. W Twoim projekcie pojawi się nowa, czysta karta o nazwie logo.h.
5. Teraz z pobranej paczki .zip z dołu mojej strony, otwórz plik „logo.h” w zwykłym systemowym Notatniku, skopiuj całą jego zawartość (Ctrl + A, a następnie Ctrl + C) i wklej ją do nowo utworzonej zakładki w Arduino IDE.

Ostateczne uruchomienie i wgranie

Gdy obie zakładki są gotowe, kliknij myszką z powrotem na pierwszą kartę z głównym kodem programu.

1. Upewnij się, że w menu Narzędzia masz nadal wybraną swoją płytkę ESP32 oraz właściwy port COM.
2. Kliknij okrągły przycisk Wgraj (strzałka w prawo w lewym górnym rogu).
3. Przypomnienie: Jeśli podczas pierwszego testu w Kroku 2 Twoja płytka wymagała ręcznego wejścia w tryb programowania, w momencie pojawienia się napisu Connecting... w dolnej konsoli, wciśnij i przytrzymaj przez 2 sekundy przycisk BOOT na płytce ESP32.

Po pomyślnym zakończeniu wgrywania trenażer automatycznie się zresetuje, z głośnika usłyszysz melodyjny sygnał powitalny, a na ekranie dotykowym pojawi się gotowe menu główne. Urządzenie jest gotowe do pierwszego treningu!

Krok 6: Efekt końcowy i podsumowanie projektu

Wszystkie kable zostały ukryte, a płytki bezpiecznie zamontowane w obudowie wydrukowanej na drukarce 3D. Tak prezentuje się gotowy, w pełni autonomiczny Trenażer CW SP3UQH w swojej ostatecznej formie. Jest zwarty, przenośny i od razu po podłączeniu zasilania (np. z powerbanka lub ładowarki telefonu) jest gotowy do treningu.

A jak to wszystko działa w praktyce? Nagrałem krótki film, na którym pokazuję płynność działania ekranu dotykowego, nawigację po menu oraz próbkę możliwości samego trenażera podczas nauki i swobodnego „klepania” w trybie dekodera:

Pobierz wszystkie pliki (Paczka Projektowa ZIP)

Chcesz zbudować ten trenażer u siebie? Aby maksymalnie ułatwić Ci pracę, zebrałem wszystkie niezbędne pliki w jedną wygodną paczkę do pobrania. Znajdziesz w niej:

• Kompletny kod źródłowy oprogramowania dla Arduino IDE
• Gotowy plik logo.h z grafiką powitalną.
• Pliki .STL obudowy, gotowe do załadowania do Twojego slicera i wydrukowania na drukarce 3D.
• Plik konfiguracyjny User_Setup.h do szybkiej podmiany dla biblioteki ekranu.

⚠️ WAŻNE: Instrukcja instalacji biblioteki Wi-Fi dla wersji 3.4

Wersja 3.4 trenażera wprowadza nowe funkcje sieciowe. Aby kompilacja kodu przebiegła pomyślnie i bez błędów (np. brakującego pliku WiFiManager.h), należy jednorazowo zainstalować odpowiednią bibliotekę w środowisku Arduino IDE.

Krok po kroku:

1. Otwórz Menedżer Bibliotek w Arduino IDE (użyj skrótu klawiszowego Ctrl+Shift+I lub wybierz z górnego menu: Szkic -> Dołącz bibliotekę -> Zarządzaj bibliotekami…).
2. W polu wyszukiwania na górze wpisz: WiFiManager
3. Na liście wyszukaj bibliotekę o nazwie WiFiManager (autorzy: tzapu, tablatronix) i kliknij przycisk Zainstaluj (najlepiej najnowszą wersję).
4. Zamknij menedżer. Teraz możesz kliknąć „Weryfikuj” lub „Wgraj” – kod skompiluje się bez problemu.

🛠️ Uwaga techniczna – „Błąd ludzki”

Projekt tego trenażera to moja pasja, którą rozwijam po godzinach. Choć instrukcję starałem się przygotować jak najbardziej precyzyjnie, jestem tylko człowiekiem i przy takiej ilości technicznych szczegółów (kabelki, piny, biblioteki) mogłem gdzieś popełnić drobny błąd lub coś niejasno opisać.

Jeśli podczas budowy natkniesz się na jakąś nieścisłość, coś nie chce zadziałać albo po prostu masz sugestię, jak usprawnić ten opis – koniecznie daj mi znać! Napisz do mnie maila, wpadnij do księgi gości i zostaw komentarz. Nie zostawię Cię z tym problemem – chętnie pomogę Ci wszystko uruchomić, a przy okazji poprawię instrukcję, by inni nie musieli błądzić. Wspólnie dopracujemy ten projekt do perfekcji!

Dziękuję za śledzenie tego projektu. Mam nadzieję, że budowa tego urządzenia przyniesie Ci równie dużo satysfakcji, co mi, a sam trenażer pomoże wyszlifować perfekcyjny timing na kluczu. Do usłyszenia w eterze, 73!

Jak wspomniałem wcześniej projekt jest w fazie ciągłego rozwoju i jest przeze mnie stale testowany w warunkach polowych. Zachęcam do zaglądania na stronę co jakiś czas, aby sprawdzić, czy dostępna jest nowsza wersja.

Licencja i zasady korzystania z projektu (CC BY-NC-SA 4.0)

Ten trenażer to projekt typu Open Source. Udostępniam go całkowicie za darmo dla całej braci krótkofalarskiej oraz osób uczących się telegrafii. Chcę, aby służył do nauki, treningu i rozwijania naszej pięknej pasji.

Całość projektu (kod oprogramowania, schematy podłączenia oraz pliki obudowy 3D) objęta jest licencją Creative Commons: Uznanie autorstwa – Użycie niekomercyjne – Na tych samych warunkach 4.0 Międzynarodowe.

Co to oznacza w praktyce dla Ciebie?

• Dziel się i kopiuj: Możesz swobodnie pobierać, powielać i udostępniać ten projekt innym, pod warunkiem że wskażesz mnie jako autora (Marcin SP3UQH) i podasz link do tej strony internetowej.
• Zakaz komercji (Zysk = NIE): Projekt ma charakter wyłącznie edukacyjny i hobbystyczny. Kategorycznie zabraniam wykorzystywania go do celów zarobkowych oraz komercyjnej sprzedaży gotowych urządzeń. Zbuduj go dla siebie, pomóż polutować koledze z klubu (po kosztach części), ale nie rób z tego biznesu na portalach aukcyjnych.
• Na tych samych warunkach: Jeśli zmodyfikujesz mój kod (np. dodając nowe funkcje) lub zaprojektujesz inną obudowę, masz prawo udostępnić swoją wersję w sieci, ale musisz to zrobić na dokładnie tej samej, otwartej i darmowej licencji. Nie możesz zamknąć zmodyfikowanego kodu.
• Bądźmy fair i szanujmy swoją pracę. Udanej budowy i do usłyszenia na paśmie!
• Jeśli podoba ci sie ten projekt i zbudowałeś lub zbudowałaś to urzadzenie daj mi o tym znac np. w księdze gości – będzie mi bardzo miło .