Prvé kolo

Vitajte v prvom kole 3D ligy!

V tomto kole sa zoznámite so súčiastkami, programovacím prostredím a samotnou konštrukciou stavebnice. Zvládnutie základov je kľúčové – bez nich by sme nedokázali stavať zložitejšie a zaujímavejšie roboty. Komplexnejším projektom sa budeme venovať v 2. kole.

Pravidlá kola

• Počas kola budete dostávať jednoduché zadania, ktoré budete musieť zdokumentovať (odfotiť alebo natočiť) a odovzdať na mail insert mail.
• Každý tím má k dispozícii určitý počet bodov, ktoré môže využiť na nápovedy.
• Nápovedy môžu mať formu priameho kódu alebo vás nasmerujú správnym smerom.
• Hodnotiť sa bude: insert conditions
• Za každú použitú nápovedu sa príslušný počet bodov odpočíta. Na konci kola sa prihliada aj na celkový zostatok bodov.

Postup bude nasledovný:

1. Nastavenie Arduino IDE
2. Zoznámenie sa s komponentmi:
   • RP2350-zero
   • Vytlačenou stavebnicou
   • Servo motorčekmi
   • Senzormi
3. Medzitým si zložíme:
   • Jednoduché ovládajúce sa auto
   • Stopára
   • Sednoduché robotické rameno

Arduino IDE

Na programovanie stavebnice 3D Ligy budeme používať vývojové prostredie Arduino IDE 2.

Stiahnuť ho môžete na oficiálnej stránke Arduina. Vyberte verziu zodpovedajúcu vášmu operačnému systému (Windows, macOS alebo Linux).

Mikrokontrolér

Ako riadiaci čip stavebnice používame Waveshare RP2350-Zero. Aby s ním Arduino IDE vedelo komunikovať, je potrebné doinštalovať príslušnú knižnicu (board package).

Inštalácia knižnice

1. Otvorte Arduino IDE a prejdite do File → Preferences.
2. Do poľa "Additional boards manager URLs" pridajte nasledujúci odkaz:

https://github.com/earlephilhower/arduino-pico/releases/download/4.5.2/package_rp2040_index.json

1. Potvrďte tlačidlom OK.
2. Otvorte Tools → Board → Boards Manager a vyhľadajte "Raspberry Pi Pico/RP2040" (obsahuje aj RP2350).
3. Nainštalujte knižnicu od autora Earle F. Philhower, III.

Výber dosky a portu

Po inštalácii knižnice je nutné zvoliť správnu dosku a port – bez toho počítač nerozpozná pripojený mikrokontrolér.

1. V menu Tools → Board vyhľadajte a vyberte "Raspberry Pi Pico".
2. Pripojte mikrokontrolér k počítaču pomocou USB kábla.
3. V menu Tools → Port vyberte port, na ktorom sa zariadenie objavilo (napr. COM3 na Windows alebo /dev/ttyACM0 na Linuxe).

Mikrokontrolér očakáva program vo formáte .uf2. Existujú dva spôsoby, ako ho získať:

• Priamo z Arduino IDE: Použite Sketch → Export Compiled Binary (alebo skratku Ctrl+Alt+S). Arduino IDE skompiluje kód a uloží súbor .uf2 do priečinka projektu.
• Drag & drop: Skompilovaný súbor .uf2 jednoducho presuňte myšou na jednotku RP2350. Po nahratí sa mikrokontrolér automaticky reštartuje a program sa spustí.

Pre vizualizáciu tu je Youtune video (fyzický postup je rovnaký pre RP2040 a RP2350)

Prvé pripojenie – režim BOOTSEL

Pri úplne prvom nahrávaní, alebo keď mikrokontrolér neodpovedá, je potrebné ho prepnúť do režimu BOOTSEL:

1. Stlačte a podržte tlačidlo BOOT na doske RP2350-Zero.
2. Počas držania tlačidla zapojte USB kábel do počítača.
3. Tlačidlo uvoľnite.

Na počítači sa objaví nová jednotka (ako USB flash disk) s názvom RP2350 alebo RPI-RP2. Do tejto jednotky môžete priamo pretiahnuť (drag & drop) súbor s programom.

Ďalsie nahrávanie

Ďalšie nahrávania programov budú prirodzenejšie.

• Zapojí sa doska do počítača.
• Vyberie sa doska (Raspberry Pi Pico) a port.
• Ak sa port našiel, potvrďte talčidlom OK
• Váš kód nahrajete cez tlačidlo -> v ľavom hornom rohu. (skratka: Ctrl+U)

Úlohy

1. Hello World!

Vyskúšaj toto: Test sériovej komunikácie. Skopíruj a spusti nasledujúci program. Sleduj sériový monitor. Uisti sa, že máš v okne sériového monitora zvolených 9600 baudov.

void setup() {
  Serial.begin(9600);
}
int i = 0;
void loop() {
  Serial.print("Ahoj ");
  Serial.println(i++);
  delay(1000);
}

VAŠA ÚLOHA: Uprav program tak, aby po dosiahnutí čísla 100 začal počítať v opačnom poradí – až do 0, a potom znova do 100, atď. Použi operátor dekrementovania (i--) a podmienku if:

if (podmienka)
{
    príkazy, ktoré sa vykonajú keď je podmienka splnená
}

Všimni si, ako je v kóde vyššie definovaná premenná i typu int. Možno budeš chcieť definovať ďalšiu premennú.

Čo sme sa naučili?

• Využívať sériový výstup na výpis informácií do sériového monitora, čo je veľmi užitočné pri ladení (debugovaní) programov.

2. Vytlačená stavebnica

Súčasťou vašej sady je aj 3D tlačená stavebnica – podobne ako Merkur, skladá sa z rôznych dielikov, ktoré sa dajú spájať skrutkami M3 do ľubovoľných tvarov a konštrukcií.

Prehľad dielikov

Farba	Typ dielikov	Popis
Biela	Základné stavebné prvky	Nosné diely s dierami pre skrutky M3 (8mm od seba) vo veľkostiach 1×N dier, ohnuté spoje (90° vertikálne aj horizontálne)
Žltá	Základné doskly	Ploché dosky s dierami pre skrutky M3 (8mm od seba) vo veľkostiach 3×N a 4×N dier.
Červená	Moduly pre senzory a joystick	Držiaky elektronických komponentov – napájajú sa priamo na biele časti
Modrá	Moduly pre servo motorčeky	Niektoré majú diery pre M3 matice, ktoré spolu so skrutkou spájajú modul s bielou časťou
Čierna	Elektronické krabičky a ohnuté dosky	Krabička pre napájanie (batérie), modul pre mikrokontrolér RP2350-Zero a ohnuté dosky M×N dier v tvare U s odierkovanými bočnými hranami na skrutky M3 (8mm od seba).

Inšpirácia

Pozri si tieto dva modely a nechaj sa inšpirovať – čo všetko sa dá z dielikov poskladať:

A tu je príklad toho, čo dokázali poskladať iní účastníci – srdce len zo základných dielikov:

Zadanie

VAŠA ÚLOHA: Poskladajte si z dielikov čokoľvek, čo vás napadne. Nemusí to byť funkčný robot – pokojne to môže byť zviera, písmeno, stavba alebo čokoľvek iné. Použite svoju fantáziu!

Hotovú konštrukciu odfotografujte a foto odošlite na insert mail.

Čo sme sa naučili?

• Spoznali sme jednotlivé typy dielikov stavebnice a ich farebné označenie.
• Vyskúšali sme si, ako sa dieliky spájajú pomocou skrutiek M3.
• Zistili sme, že zo stavebnice sa dá poskladať prakticky čokoľvek – od robotov až po dekorácie.

Prva stavebnica

3. RGB LED modul

RGB LED je súčiastka, ktorá dokáže svietiť v ľubovoľnej farbe – kombinuje totiž tri farebné diódy v jednom puzdre: červenú (R), zelenú (G) a modrú (B). Miešaním intenzity týchto troch farieb vieme dosiahnuť akýkoľvek odtieň.

Používame modul LED RGB modul od Techfun.sk, ktorý má výhodou oproti holej LED dióde – rezistory sú už napájkované priamo na module, takže nie je potrebné zapojiť žiadne externé rezistory.

Modul má 4 piny:

Pin	Popis	Zapojenie v RP2350-zero
-	GND	GND
R	Červená farba	GP0
G	Zelená farba	GP1
B	Modrá farba	GP2

(Keďže modul má rezistory zabudované, zapájame ho priamo – pin "-" na GND, a piny R/G/B na GPIO piny mikrokontroléra)

Kód

Vyskúšaj toto: Nasledujúci program rozsvieti RGB LED na bielo a zhasne.

// Definujeme čísla pinov
const int PIN_R = 0;
const int PIN_G = 1;
const int PIN_B = 2;

void setup() {
  pinMode(PIN_R, OUTPUT);
  pinMode(PIN_G, OUTPUT);
  pinMode(PIN_B, OUTPUT);
}

void loop() {
  digitalWrite(PIN_R, HIGH);
  digitalWrite(PIN_G, HIGH);
  digitalWrite(PIN_B, HIGH);
  delay(1000);

  digitalWrite(PIN_R, LOW);
  digitalWrite(PIN_G, LOW);
  digitalWrite(PIN_B, LOW);
  delay(1000);
}

Princíp

Princíp je rovnaký ako pri jednofarebnej LED – HIGH = farba svieti, LOW = farba nesvieti. Kombináciou troch pinov vieme získať rôzne farby:

VAŠA ÚLOHA: Doplňte program tak, aby LED postupne prechádzala všetkými farbami z palety vyššie, vždy s pauzou 1 sekundu medzi každou farbou.

Hotový program nahrajte do mikrokontroléra, zaznamenajte blikajúcu LED a odošlite na insert mail.

Čo sme sa naučili?

• RGB LED modul kombinuje tri farebné diódy – miešaním HIGH/LOW vieme dosiahnuť ľubovoľnú farbu.
• Modul s napájkovanými rezistormi zjednodušuje zapojenie – žiadne externé súčiastky nie sú potrebné.
• Každý GPIO pin ovládame samostatne pomocou digitalWrite().

4. Bzučiak (Buzzer)

Bzučiak, ktorý ste dostali, je jednoduchý reproduktor. Reproduktory vydávajú zvuk tak, že rýchlo rozkmitajú tenkú fóliu vo vnútri. Toto kmitanie stláča a rozťahuje vzduch okolo – a práve tieto tlakové vlny vnímame ako zvuk.

Fóliu rozkmitáme malým elektromagnetom. Aby sa elektromagnet zapol, potrebuje elektrický prúd, ktorý mu dodá mikrokontrolér RP2350.

Jeden kmit dosiahneme logickým zapnutím a následným vypnutím pinu. Zvuk je v skutočnosti niekoľko stoviek až tisíc takýchto kmitov za sekundu – čiže zapínanie a vypínanie musí prebiehať každých niekoľko mikrosekúnd. Čím rýchlejšie kmitáme, tým vyšší tón vzniká.

Zapojenie

Kábel	Pin na RP2350-Zero
Čierny	GND
Červený	GP4

Kód

Nasledujúci program prechádza rozsahom tónov od 500 Hz do 2500 Hz. Funkcia playNote() je zatiaľ prázdna – to je tvoja úloha ju doplniť!

const int BUZZER = 4;

void setup() {
  pinMode(BUZZER, OUTPUT);
  Serial.begin(9600);
}

// Funkcia zahrá jeden tón o frekvencii 'note' Hz
// Trvanie tónu je pevne stanovené na 10 kmitov
void playNote(int note)
{
  // Vypočítame polovicu periódy v mikrosekundách
  // Perióda = 1 000 000 / frekvencia (us)
  // Polovica periódy = 500 000 / frekvencia (us)
  int halfPeriod = 500000 / note;

  for (int i = 0; i < 10; i++) {
    digitalWrite(BUZZER, HIGH);   // zapni bzučiak
    delayMicroseconds(halfPeriod); // počkaj pol periódy
    digitalWrite(BUZZER, LOW);    // vypni bzučiak
    delayMicroseconds(halfPeriod); // počkaj pol periódy
  }
}

void loop() {
  for (int i = 500; i < 2500; i++) {
    playNote(i);
    Serial.print("Hrám notu: ");
    Serial.println(i);
  }
}

Vysvetlenie kódu

Kľúčom je funkcia playNote(). Zvuk vzniká pravidelným striedaním HIGH a LOW na pine bzučiaka:

Pojem	Vysvetlenie
Frekvencia	Počet kmitov za sekundu, udáva sa v Hz. Vyššia frekvencia = vyšší tón.
Perióda	Čas jedného celého kmitu (zapnutie + vypnutie). Perióda = 1 000 000 / frekvencia µs.
Polovica periódy	Čas, ktorý pin strávi v stave HIGH (alebo LOW). Vypočítame ju ako 500 000 / frekvencia.
delayMicroseconds()	Rovnaké ako delay(), ale čaká v mikrosekundách namiesto milisekúnd.

Napríklad pre tón 1000 Hz:

• Perióda = 1 000 000 / 1000 = 1000 µs
• Polovica periódy = 500 µs
• Pin bude HIGH 500 µs, potom LOW 500 µs – a to 10-krát za sebou

Vyskúšaj toto: Skopíruj kód, doplň funkciu playNote() podľa vysvetlenia vyššie a nahraj ho do mikrokontroléra. Sleduj sériový monitor – vidíš ako sa mení frekvencia? Počuješ ako zvuk stúpa nahor?

VAŠA ÚLOHA: Zapojte k bzučiaku aj RGB LED (podľa zapojenia zo sekcie 3) a napíšte program, ktorý bude simulovať sanitku:

• Bzučiak bude striedavo hrať dva tóny (napr. 800 Hz a 1200 Hz) podobne ako siréna
• RGB LED bude blikať striedavo modrou a červenou farbou v rytme sirény

Vzorová štruktúra programu (doplňte chýbajúce časti):

const int BUZZER = 4;
const int PIN_R = 0;
const int PIN_G = 1;
const int PIN_B = 2;

void setup() {
  pinMode(BUZZER, OUTPUT);
  pinMode(PIN_R, OUTPUT);
  pinMode(PIN_G, OUTPUT);
  pinMode(PIN_B, OUTPUT);
}

void playNote(int note) {
  // --- sem doplňte kód z predchádzajúcej úlohy ---
}

void setColor(int r, int g, int b) {
  // --- doplňte: nastavte farbu LED pomocou digitalWrite ---
}

void loop() {
  // --- doplňte: siréna tón 1 + modrá farba ---

  // --- doplňte: siréna tón 2 + červená farba ---
}

Hotový program nahrajte do mikrokontroléra, natočte video so zvukom a odošlite na insert mail.

Čo sme sa naučili?

• Bzučiak generuje zvuk rýchlym striedaním HIGH/LOW – čím rýchlejšie, tým vyšší tón.
• Funkcia delayMicroseconds() umožňuje pracovať s časovými intervalmi v mikrosekundách.
• Kombináciou viacerých komponentov (bzučiak + LED) vieme simulovať reálne zariadenia.

5. Mikrofón

Vieme ako zvuk generovať – teraz ho ideme aj zachytiť. Pomôže nám modul KY-038.

Mikrofón funguje presne opačne ako reproduktor. Kým reproduktor premieňa elektrický signál na kmitanie fólie (zvuk), mikrofón zachytí kmitanie vzduchu a premení ho späť na elektrický signál.

Modul KY-038 má dva výstupy:

Výstup	Popis
Digitálny (D0)	Vysiela iba 0 alebo 1 – buď zvuk zachytil, alebo nie
Analógový (A0)	Vysiela hodnotu podľa hlasitosti a frekvencie zvuku – čím hlasnejší zvuk, tým vyššia hodnota

Citlivosť mikrofónu sa dá nastaviť otočnou skrutkou na modrej krabičke priamo na module.

Zapojenie

Pin modulu	Pin na RP2350-Zero
VCC	3.3V
GND	GND
D0 (digitálny výstup)	GP5
A0 (analógový výstup)	GP26 (ADC0)

Súbor:Ky038.png

Časť 1 – Čítanie hodnôt z mikrofónu

Vyskúšaj toto: Skopíruj a spusti nasledujúci program. Otvor sériový monitor (9600 baud) a skús hovoriť, tlieskať alebo pískať pred mikrofón. Sleduj ako sa menia hodnoty.

const int MIC_DIGITAL = 5;   // digitálny výstup D0
const int MIC_ANALOG  = 26;  // analógový výstup A0 (ADC)

void setup() {
  pinMode(MIC_DIGITAL, INPUT);
  Serial.begin(9600);
}

void loop() {
  int digitalVal = digitalRead(MIC_DIGITAL);  // 0 alebo 1
  int analogVal  = analogRead(MIC_ANALOG);    // 0 až 4095

  Serial.print("Digitálny: ");
  Serial.print(digitalVal);
  Serial.print("  |  Analógový: ");
  Serial.println(analogVal);

  delay(50);
}

Funkcia	Vysvetlenie
digitalRead(pin)	Prečíta stav pinu – vráti buď 0 (ticho) alebo 1 (zvuk zachytený)
analogRead(pin)	Prečíta analógovú hodnotu pinu – vráti číslo od 0 do 4095
delay(50)	Čakáme 50 ms medzi meraniami – aby sériový monitor nescrolloval príliš rýchlo

VAŠA ÚLOHA 1: Zapojte mikrofón spolu s bzučiakom a RGB LED zo sekcií 3 a 4. Napíšte program, ktorý bude fungovať ako zvukový spínač:

• Keď mikrofón zachytí hlasný zvuk (napríklad tliesknutie), program zapne sirénu a blikanie LED
• Keď zachytí druhé tliesknutie, program ich vypne
• Stav (zapnuté/vypnuté) si musí program pamätať medzi tliesknutiami

const int MIC_DIGITAL = 5;
const int BUZZER = 4;
const int PIN_R = 0;
const int PIN_G = 1;
const int PIN_B = 2;

bool aktivny = false;  // pamätáme si stav – zapnuté alebo vypnuté

void setup() {
  pinMode(MIC_DIGITAL, INPUT);
  pinMode(BUZZER, OUTPUT);
  pinMode(PIN_R, OUTPUT);
  pinMode(PIN_G, OUTPUT);
  pinMode(PIN_B, OUTPUT);
  Serial.begin(9600);
}

void playNote(int note) {
  // --- sem skopírujte funkciu z predchádzajúcej úlohy ---
}

void setColor(int r, int g, int b) {
  // --- sem skopírujte funkciu z predchádzajúcej úlohy ---
}

void loop() {
  // --- doplňte: ak mikrofón zachytí zvuk, prepnite stav 'aktivny' ---

  if (aktivny) {
    // --- doplňte: spustite sirénu a blikanie LED ---
  } else {
    // --- doplňte: vypnite bzučiak aj LED ---
  }
}

Hotový program nahrajte do mikrokontroléra, natočte video a odošlite na insert mail.

Časť 2 – Mikrofón a bzučiak spolu

Teraz si vyskúšame niečo zaujímavejšie – bzučiak a mikrofón zapojíme spolu a mikrofón bude počúvať čo bzučiak hrá.

Montáž: Upevnite bzučiak aj mikrofón do červených modulov stavebnice a priskrutkujte ich podľa obrázka. Snažte sa ich umiestniť oproti sebe – mikrofón by mal smerovať priamo k bzučiaku.

Súbor:Buzzer mic assembly.png

Pre túto úlohu odpojte RGB LED a použite iba bzučiak a mikrofón. Zapojenie zostáva rovnaké ako vyššie, pin A0 mikrofónu na GP26.

Vyskúšaj toto: Nasledujúci program hrá na bzučiaku niekoľko tónov za sebou a zároveň číta analógovú hodnotu z mikrofónu. Výsledky sleduj v sériovom monitore.

const int BUZZER     = 4;
const int MIC_ANALOG = 26;

int frekvencie[] = {500, 800, 1000, 1500, 2000};
int pocetFrekvencii = 5;

void playNote(int note) {
  // --- sem skopírujte funkciu z predchádzajúcej úlohy ---
}

void setup() {
  pinMode(BUZZER, OUTPUT);
  Serial.begin(9600);
}

void playAndListen(int frekvencia, int trvanie) {
  int halfPeriod = 500000 / frekvencia;
  long startTime = millis();

  while (millis() - startTime < trvanie) {
    playTone(halfPeriod);

    static long lastRead = 0;
    if (millis() - lastRead > 5) {
      int val = analogRead(MIC_ANALOG);
      Serial.print("Frekvencia: ");
      Serial.print(frekvencia);
      Serial.print(" Hz  |  Mikrofón: ");
      Serial.println(val);
      lastRead = millis();
    }
  }

  digitalWrite(BUZZER, LOW);
  Serial.println("--- ticho ---");
  delay(500);
}

void loop() {
  for (int i = 0; i < pocetFrekvencii; i++) {
    playAndListen(frekvencie[i], 1000);
  }
}

Oproti predchádzajúcemu kódu pribúdajú nové koncepty:

Novinka	Vysvetlenie
millis()	Vráti počet milisekúnd od spustenia programu. Používame ho namiesto delay(), aby sme mohli zároveň hrať aj merať.
static long lastRead	Premenná s kľúčovým slovom static si zachováva svoju hodnotu medzi volaniami funkcie – neresetuje sa na 0 pri každom zavolaní.
while (millis() - startTime < trvanie)	Cyklus beží dovtedy, kým neuplynie požadovaný čas – počas neho stihneme robiť aj kmity bzučiaka aj čítanie mikrofónu.
int frekvencie[]	Pole – zoznam hodnôt rovnakého typu uložených za sebou. Pristupujeme k nim cez index: frekvencie[0] = 500, frekvencie[1] = 800, atď.

VAŠA ÚLOHA 2: Upravte program a otestujte mikrofón pri rôznych nastaveniach citlivosti:

1. Spustite program a sledujte hodnoty v sériovom monitore
2. Otočnou skrutkou nastavte citlivosť tak, aby mikrofón spoľahlivo zachytával všetky tóny
3. Do poľa frekvencie[] pridajte vlastné frekvencie – skúste veľmi nízke (200 Hz) aj veľmi vysoké (3000 Hz). Zachytáva mikrofón všetky rovnako dobre?
4. Skúste bzučiak a mikrofón od seba vzdialiť – pri akej vzdialenosti prestane mikrofón zachytávať signál?

Zaznamenajte vaše pozorovania a odošlite spolu s upraveným kódom na insert mail.

Čo sme sa naučili?

• Mikrofón KY-038 má digitálny aj analógový výstup – digitálny slúži na detekciu zvuku, analógový na meranie jeho intenzity.
• Funkcia millis() umožňuje merať čas bez blokovania programu – na rozdiel od delay().
• Pole (int frekvencie[]) je užitočný spôsob ako uložiť viacero hodnôt a prechádzať cez ne cyklom.
• Mikrofón nezachytáva všetky frekvencie rovnako – jeho citlivosť závisí od vzdialenosti, nastavenia aj samotnej frekvencie zvuku.

7. Servo motorček

Dostali ste dva druhy servo motorčekov: 180° a 360°. Oba fungujú na rovnakom princípe ovládania, ale majú rozdielne vlastnosti:

Typ	Správanie
180° servo	Nastaví sa na presnú pozíciu (napr. 0°, 90°, 180°) a tam zostane
360° servo	Namiesto pozície ovládate smer a rýchlosť otáčania – hodnota 90° = stoj, pod 90° = jedna strana, nad 90° = druhá strana

Servo dostáva riadiace impulzy v rozsahu 500–2500 µs, ktoré dekóduje ako požadovanú pozíciu alebo smer otáčania. Zapojte servo na pin GP12.

Vyskúšaj toto: Nahrajte nasledujúci program. Otvorte sériový monitor (115200 baud), zadajte číslo od 0 do 180 a stlačte Enter. Vyskúšajte si to najprv s 180° servom, potom s 360°. Čo si všimnete?

#include <Servo.h>

#define SERVO_PIN 12

Servo servo;
String inputString = "";
int position = 90;

void setup() {
  Serial.begin(115200);
  servo.attach(SERVO_PIN, 500, 2500);
  servo.write(position);
  Serial.println("Zadajte uhol (0-180) a stlačte Enter:");
}

void loop() {
  while (Serial.available()) {
    char c = Serial.read();
    if (c == '\n') {
      position = inputString.toInt();
      if (position >= 0 && position <= 180) {
        servo.write(position);
        Serial.print("Servo nastavené na uhol: ");
        Serial.println(servo.read());
      } else {
        Serial.println("Neplatná pozícia – zadajte číslo od 0 do 180");
      }
      inputString = "";
    } else {
      inputString += c;
    }
  }
  delay(50);
}

Novinka	Vysvetlenie
#include <Servo.h>	Načítame knižnicu pre ovládanie serva – bez nej by sme museli impulzy generovať ručne
servo.attach(pin, 500, 2500)	Pripojíme servo na pin a definujeme rozsah impulzov (500–2500 µs)
servo.write(uhol)	Nastavíme servo na požadovaný uhol (0–180°)
inputString.toInt()	Prevedie textový reťazec na celé číslo – napr. "120" → 120

VAŠA ÚLOHA: Zostrojte autíčko z dvoch 360° servo motorčekov, guličky (ako tretie koleso) a ultrazvukového senzora. Ultrazvuk upevnite na predok. Naprogramujte poslušného psíčka – autíčko sleduje objekt pred sebou:

Vzdialenosť	Správanie
> 30 cm	Ide vpred – ide za páničkom
10 – 30 cm	Stojí – páničko je na ideálnej vzdialenosti
< 10 cm	Ide vzad – páničko je príliš blízko

#include <Servo.h>

const int TRIG       = 6;
const int ECHO       = 7;
#define SERVO_LAVY   12
#define SERVO_PRAVY  13

Servo servoLavy;
Servo servoPravy;

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  servoLavy.attach(SERVO_LAVY, 500, 2500);
  servoPravy.attach(SERVO_PRAVY, 500, 2500);
  stoj();
  Serial.begin(9600);
}

long measurePulse() {
  // --- skopírujte z predchádzajúcej úlohy ---
}

void stoj() {
  servoLavy.write(90);
  servoPravy.write(90);
}

void vpred() {
  // --- doplňte ---
  // Nápoveda: ľavé a pravé koleso sú zrkadlovo otočené!
}

void vzad() {
  // --- doplňte ---
}

void loop() {
  long trvanie = measurePulse();
  float vzdialenost = 0; // --- doplňte výpočet ---

  Serial.print("Vzdialenosť: ");
  Serial.print(vzdialenost);
  Serial.println(" cm");

  if (vzdialenost > 30) {
    // --- doplňte ---
  } else if (vzdialenost > 10) {
    // --- doplňte ---
  } else {
    // --- doplňte ---
  }

  delay(50);
}

Bonus: Upravte program tak, aby sa psíček pohyboval proporcionálne – čím ďalej je objekt, tým rýchlejšie autíčko ide. Na škálovanie hodnôt sa vám môže hodiť funkcia map():

// Príklad: prevedie vzdialenosť 30-100cm na hodnotu serva 90-180
int rychlost = map(vzdialenost, 30, 100, 90, 180);

Hotový program nahrajte do mikrokontroléra, natočte video a odošlite na insert mail.

Čo sme sa naučili?

• Servo motorček ovládame pomocou knižnice Servo.h a funkcie servo.write().
• 180° servo nastavuje presnú polohu, 360° servo ovláda smer a rýchlosť otáčania.
• Pri dvoch kolesách namontovaných oproti sebe musia servá ísť opačnými smermi aby sa autíčko pohybovalo rovno.
• Funkcia map() umožňuje previesť hodnotu z jedného rozsahu do druhého.

7. Servo motorček

Dostali ste dva druhy servo motorčekov: 180° a 360°. Oba fungujú na rovnakom princípe ovládania, ale majú rozdielne vlastnosti:

Typ	Správanie
180° servo	Nastaví sa na presnú pozíciu (napr. 0°, 90°, 180°) a tam zostane
360° servo	Namiesto pozície ovládate smer a rýchlosť otáčania – hodnota 90° = stoj, pod 90° = jedna strana, nad 90° = druhá strana

Servo dostáva riadiace impulzy v rozsahu 500–2500 µs, ktoré dekóduje ako požadovanú pozíciu alebo smer otáčania. Zapojte servo na pin GP12.

Vyskúšaj toto: Nahrajte nasledujúci program. Otvorte sériový monitor (115200 baud), zadajte číslo od 0 do 180 a stlačte Enter. Vyskúšajte si to najprv s 180° servom, potom s 360°. Čo si všimnete?

#include <Servo.h>

#define SERVO_PIN 12

Servo servo;
String inputString = "";
int position = 90;

void setup() {
  Serial.begin(115200);
  servo.attach(SERVO_PIN, 500, 2500);
  servo.write(position);
  Serial.println("Zadajte uhol (0-180) a stlačte Enter:");
}

void loop() {
  while (Serial.available()) {
    char c = Serial.read();
    if (c == '\n') {
      position = inputString.toInt();
      if (position >= 0 && position <= 180) {
        servo.write(position);
        Serial.print("Servo nastavené na uhol: ");
        Serial.println(servo.read());
      } else {
        Serial.println("Neplatná pozícia – zadajte číslo od 0 do 180");
      }
      inputString = "";
    } else {
      inputString += c;
    }
  }
  delay(50);
}

Novinka	Vysvetlenie
#include <Servo.h>	Načítame knižnicu pre ovládanie serva – bez nej by sme museli impulzy generovať ručne
servo.attach(pin, 500, 2500)	Pripojíme servo na pin a definujeme rozsah impulzov (500–2500 µs)
servo.write(uhol)	Nastavíme servo na požadovaný uhol (0–180°)
inputString.toInt()	Prevedie textový reťazec na celé číslo – napr. "120" → 120

VAŠA ÚLOHA: Zostrojte autíčko z dvoch 360° servo motorčekov, guličky (ako tretie koleso) a ultrazvukového senzora. Ultrazvuk upevnite na predok. Naprogramujte poslušného psíčka – autíčko sleduje objekt pred sebou:

Vzdialenosť	Správanie
> 30 cm	Ide vpred – ide za páničkom
10 – 30 cm	Stojí – páničko je na ideálnej vzdialenosti
< 10 cm	Ide vzad – páničko je príliš blízko

#include <Servo.h>

const int TRIG       = 6;
const int ECHO       = 7;
#define SERVO_LAVY   12
#define SERVO_PRAVY  13

Servo servoLavy;
Servo servoPravy;

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  servoLavy.attach(SERVO_LAVY, 500, 2500);
  servoPravy.attach(SERVO_PRAVY, 500, 2500);
  stoj();
  Serial.begin(9600);
}

long measurePulse() {
  // --- skopírujte z predchádzajúcej úlohy ---
}

void stoj() {
  servoLavy.write(90);
  servoPravy.write(90);
}

void vpred() {
  // --- doplňte ---
  // Nápoveda: ľavé a pravé koleso sú zrkadlovo otočené!
}

void vzad() {
  // --- doplňte ---
}

void loop() {
  long trvanie = measurePulse();
  float vzdialenost = 0; // --- doplňte výpočet ---

  Serial.print("Vzdialenosť: ");
  Serial.print(vzdialenost);
  Serial.println(" cm");

  if (vzdialenost > 30) {
    // --- doplňte ---
  } else if (vzdialenost > 10) {
    // --- doplňte ---
  } else {
    // --- doplňte ---
  }

  delay(50);
}

Bonus: Upravte program tak, aby sa psíček pohyboval proporcionálne – čím ďalej je objekt, tým rýchlejšie autíčko ide. Na škálovanie hodnôt sa vám môže hodiť funkcia map():

// Príklad: prevedie vzdialenosť 30-100cm na hodnotu serva 90-180
int rychlost = map(vzdialenost, 30, 100, 90, 180);

Hotový program nahrajte do mikrokontroléra, natočte video a odošlite na insert mail.

Čo sme sa naučili?

• Servo motorček ovládame pomocou knižnice Servo.h a funkcie servo.write().
• 180° servo nastavuje presnú polohu, 360° servo ovláda smer a rýchlosť otáčania.
• Pri dvoch kolesách namontovaných oproti sebe musia servá ísť opačnými smermi aby sa autíčko pohybovalo rovno.
• Funkcia map() umožňuje previesť hodnotu z jedného rozsahu do druhého.