Prvé kolo: Rozdiel medzi revíziami

Zo stránky 3D liga wiki
Prejsť na navigáciu Prejsť na vyhľadávanie
← Predchádzajúca úprava
Sebastian (diskusia | príspevky)
248 editací
Sebastian (diskusia | príspevky)
248 editací
Sebastian (diskusia | príspevky)
248 editací
 
(84 medziľahlých úprav od 2 ďalších používateľov nie je zobrazených)
Riadok 1: Riadok 1:
=== Vitajte v prvom kole 3D ligy! ===
=== Vitajte v prvom kole 3D ligy! ===


Riadok 5: Riadok 6:
Komplexnejším projektom sa budeme venovať v 2. kole.
Komplexnejším projektom sa budeme venovať v 2. kole.


==== Pravidlá kola ====
==== Pravidlá prípravy ====
 
* Počas kola budete dostávať jednoduché zadania, ktoré budete musieť zdokumentovať (odfotiť alebo natočiť) a odovzdať na mail <code>insert mail</code>.
* 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: <code>insert conditions</code>
* 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ý: ====
 
# Nastavenie Arduino IDE
# Zoznámenie sa s komponentmi:
#* RP2350-zero
#* Vytlačenou stavebnicou
#* Servo motorčekmi
#* Senzormi
#  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 [https://www.arduino.cc/en/software/ stránke Arduina].
Vyberte verziu zodpovedajúcu vášmu operačnému systému (Windows, macOS alebo Linux).
 
[[Image:Arduino Download.png|400px]]
 
=== 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 ====
 
# Otvorte Arduino IDE a prejdite do '''File → Preferences'''.
# Do poľa "'''Additional boards manager URLs'''" pridajte nasledujúci odkaz:
<nowiki>https://github.com/earlephilhower/arduino-pico/releases/download/4.5.2/package_rp2040_index.json</nowiki>
# Potvrďte tlačidlom OK.
# Otvorte '''Tools → Board → Boards Manager''' a vyhľadajte '''"Raspberry Pi Pico/RP2040"''' (obsahuje aj '''RP2350''').
# Nainštalujte knižnicu od autora '''Earle F. Philhower, III'''.
 
[[Image:Pico Get Start 06.png|300px]]
 
==== 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.


# V menu '''Tools → Board''' vyhľadajte a vyberte '''"Raspberry Pi Pico"'''.
Pre začiatok na setupnutie si vlastnej stavebnice budeme musiet si pripravit:
# Pripojte mikrokontrolér k počítaču pomocou USB kábla.
# V menu '''Tools → Port''' vyberte port, na ktorom sa zariadenie objavilo (napr. <code>COM3</code> na Windows alebo <code>/dev/ttyACM0</code> na Linuxe).


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


* '''Priamo z Arduino IDE:''' Použite '''Sketch → Export Compiled Binary''' (alebo skratku <code>Ctrl+Alt+S</code>). Arduino IDE skompiluje kód a uloží súbor <code>.uf2</code> do priečinka projektu.
== Príprava hardvéru ==
* '''Drag & drop:''' Skompilovaný súbor <code>.uf2</code> 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 [https://www.youtube.com/watch?v=Vx-Y7pCRSJY Youtune video] (fyzický postup je rovnaký pre RP2040 a RP2350)
[[Príprava elektroniky - hardware setup | Celkový setup elektorniky a HW súčiastok]]


==== Prvé pripojenie – režim BOOTSEL ====


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


# Stlačte a '''podržte tlačidlo BOOT''' na doske RP2350-Zero.
[[Príprava programovacieho prostredia - sofrware setup | Arduino IDE setup]]
# Počas držania tlačidla '''zapojte USB kábel''' do počítača.
# Tlačidlo '''uvoľnite'''.


Na počítači sa objaví nová jednotka (ako USB flash disk) s názvom '''RP2350''' alebo '''RPI-RP2'''.
Pred začatím odporúčame prezrieť si [[Základy programovania | prehľad premenných a operátorov]].
Do tejto jednotky môžete priamo pretiahnuť (drag & drop) súbor s programom.


==== Ďalsie nahrávanie ====
== Vytlačená stavebnica ==
 
Ď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''')
 
[[Image:RP2350 port.png|300px]]
 
== Úlohy ==
 
===1. Hello World! ===
 
<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> 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.
 
<syntaxhighlight lang="C">
void setup() {
  Serial.begin(9600);
}
int i = 0;
void loop() {
  Serial.print("Ahoj ");
  Serial.println(i++);
  delay(1000);
}
</syntaxhighlight>
 
<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> 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'':
 
<syntaxhighlight lang="C">
if (podmienka)
{
    príkazy, ktoré sa vykonajú keď je podmienka splnená
}
</syntaxhighlight>
 
Všimni si, ako je v kóde vyššie definovaná premenná <i>i</i> typu <i>int</i>. Možno budeš chcieť definovať ďalšiu premennú.
 
[[Image:RP2040-Zero-Pinout.jpg|400px]]
[[Image:RP2040-Zero-Board.jpg|400px]]
 
Č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í.
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 ====
''' Prehľad dielikov '''


{| class="wikitable"
{| class="wikitable"
Riadok 137: Riadok 38:
| <span style="background:#ffd401; padding:2px 8px;">'''Žltá'''</span> || Základné doskly || Ploché dosky s dierami pre skrutky M3 (8mm od seba) vo veľkostiach 3×N a 4×N dier.  
| <span style="background:#ffd401; padding:2px 8px;">'''Žltá'''</span> || Základné doskly || Ploché dosky s dierami pre skrutky M3 (8mm od seba) vo veľkostiach 3×N a 4×N dier.  
|-
|-
| <span style="background:#ffcccc; padding:2px 8px;">'''Červená'''</span> || Moduly pre senzory a joystick || Držiaky elektronických komponentov – napájajú sa priamo na biele časti
| <span style="background:#ffcccc; padding:2px 8px;">'''Červená'''</span> || Moduly pre senzory a joystick a držiaky na káble || Držiaky elektronických komponentov – napájajú sa priamo na biele časti
|-
|-
| <span style="background:#cce0ff; padding:2px 8px;">'''Modrá'''</span> || Moduly pre servo motorčeky || Niektoré majú diery pre M3 matice, ktoré spolu so skrutkou spájajú modul s bielou časťou
| <span style="background:#cccccc; padding:2px 8px;">'''Čierna'''</span> || 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).
|-
|-
| <span style="background:#cccccc; padding:2px 8px;">'''Čierna'''</span> || 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).
| <span style="background:#cce0ff; padding:2px 8px;">'''Modrá'''</span> || Moduly a ramienka pre servo motorčeky || Niektoré majú diery pre M3 matice, ktoré spolu so skrutkou spájajú modul s bielimi/žltími/čiernymi súčiastkami.
|}
|}


==== Inšpirácia ====
''' Inšpirácia '''


Pozri si tieto dva modely a nechaj sa inšpirovať – čo všetko sa dá z dielikov poskladať:
Pozri si tieto dva modely a nechaj sa inšpirovať – čo všetko sa dá z dielikov poskladať:
Riadok 157: Riadok 58:
[[Image:srdce.jpg|300px]]
[[Image:srdce.jpg|300px]]


==== Zadanie ====
[[Gallery | Galéria súčiastok a ich zapojenie]]
 
''' Zadanie '''


<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> 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!
<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> 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 <code>insert mail</code>.
Hotovú konštrukciu '''odfotografujte''' a foto odošlite.


Čo sme sa naučili?
Čo sme sa naučili?
Riadok 168: Riadok 71:
* Zistili sme, že zo stavebnice sa dá poskladať prakticky čokoľvek – od robotov až po dekorácie.
* Zistili sme, že zo stavebnice sa dá poskladať prakticky čokoľvek – od robotov až po dekorácie.


=== Prva stavebnica ===
== 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: <span style="color:#cc0000">'''červenú (R)'''</span>, <span style="color:#007700">'''zelenú (G)'''</span> a <span style="color:#0000cc">'''modrú (B)'''</span>. Miešaním intenzity týchto troch farieb vieme dosiahnuť akýkoľvek odtieň.


[[Image:Rgb-led-module.jpg|300px]]
V prvej stavebnici sa zoznámite so základnými elektronickými modulmi. Niektoré z nich sa vám budú hodiť pri ladení zložitejších robotov – napríklad LED vám vie ukázať v akom stave sa robot nachádza, bzučiak vás upozorní keď sa niečo stane. Iné moduly sú dôležité pre pochopenie základov, na ktorých budeme neskôr stavať.


Používame modul [https://techfun.sk/produkt/led-rgb-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.
Budeme sa zaoberať:
* '''RGB LED''' – farebná dióda na vizuálnu signalizáciu
* '''Bzučiak''' – jednoduchý reproduktor na zvukovú signalizáciu
* '''Mikrofón''' – zachytávanie zvuku z okolia
* '''Ultrazvukový senzor''' – meranie vzdialenosti
* '''Servo motorček''' – presné ovládanie pohybu


Modul má '''4 piny''':
Na konci prvej stavebnice poskladáte autíčko ktoré sa samo vyhýba prekážkam – prvého autonómneho robota!


{| class="wikitable"
----
|-
! 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)
=== Roomba ===


===== Kód =====
Naučili ste sa ako narábať s hlavnými komponentmi stavebnice. Teraz využijete všetky znalosti dokopy a postavíte si robotického vysavača – '''Roombu'''.


<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> Nasledujúci program rozsvieti RGB LED na bielo a zhasne.
Autíčko bude skúmať terén pred sebou. Keď narazí na prekážku, pozrie sa doprava a doľava, nájde voľný smer a pokračuje ďalej. Konštrukciu auta môžete nechať z predchádzajúcej úlohy – stačí pridať '''180° servo''' s ultrazvukovým senzorom na otáčanie hlavy.


<syntaxhighlight lang="C">
Použijete:
// Definujeme čísla pinov
* 2× 360° servo (kolesá)
const int PIN_R = 0;
* 1× 180° servo (otáčanie senzora)
const int PIN_G = 1;
* 1× HC-SR04
const int PIN_B = 2;
* 1× RGB LED modul (voliteľné)
* 1× bzučiak (voliteľné)


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


void loop() {
Roomba má v každom momente nejaký '''stav''' – a podľa neho sa rozhoduje čo urobiť:
  digitalWrite(PIN_R, HIGH);
  digitalWrite(PIN_G, HIGH);
  digitalWrite(PIN_B, HIGH);
  delay(1000);


  digitalWrite(PIN_R, LOW);
# Ide rovno – ak je pred ňou voľno (> 20 cm)
  digitalWrite(PIN_G, LOW);
# Narazila na prekážku – otočí senzor doprava a zmeria
  digitalWrite(PIN_B, LOW);
# Ak je doprava voľno – otočí sa doprava a pokračuje
  delay(1000);
# Ak nie – otočí senzor doľava a zmeria
}
# Ak je doľava voľno – otočí sa doľava a pokračuje
</syntaxhighlight>
# Ak je všade prekážka – cúvne a zopakuje skenovanie


===== Princíp =====
LED a bzučiak sú voliteľné – ale môžu pekne znázorniť jednotlivé stavy (napr. zelená = ide, červená = prekážka, pípnutie pri otočení).


Princíp je rovnaký ako pri jednofarebnej LED – <code>HIGH</code> = farba svieti, <code>LOW</code> = farba nesvieti. Kombináciou troch pinov vieme získať rôzne farby:
<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> Zostrojte Roombu a naprogramujte algoritmus podľa opisu vyššie. Dostávate štruktúru na doplnenie:


[[Image:RGB palete.jpg|350px]]  
[[Roomba structure | Štruktúra]]


<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> 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.
<span style="background:#FF9900">'''Bonus:'''</span> Roomba si môže '''pamätať históriu otočení''' – ak sa viackrát za sebou otočila doprava, skúsi to doľava a naopak. Tak sa vyhne zaseknutiu v rohu.


Hotový program '''nahrajte do mikrokontroléra''', zaznamenajte blikajúcu LED a odošlite na <code>insert mail</code>.
Hotový program '''nahrajte do mikrokontroléra''', natočte krátke demonštračňé video a odošlite.


Čo sme sa naučili?
Čo sme sa naučili?
* RGB LED modul kombinuje tri farebné diódy – miešaním HIGH/LOW vieme dosiahnuť ľubovoľnú farbu.
* Komplexnejšie správanie robota sa dá rozložiť na jednoduché stavy a prechody medzi nimi.
* Modul s napájkovanými rezistormi zjednodušuje zapojenie – žiadne externé súčiastky nie sú potrebné.
* 180° servo vie presne namieriť senzor na konkrétny uhol – využili sme ho ako "hlavu" robota.
* Každý GPIO pin ovládame samostatne pomocou <code>digitalWrite()</code>.
* Kombináciou všetkých komponentov vieme postaviť autonómneho robota schopného orientovať sa v priestore.


==== 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.
== Druhá stavebnica ==


Fóliu rozkmitáme malým elektromagnetom. Aby sa elektromagnet zapol, potrebuje elektrický prúd, ktorý mu dodá mikrokontrolér RP2350.
V druhej stavebnici prídete do kontaktu s presnejšími a výkonnejšími senzormi. Oproti prvej stavebnici tu pracujeme s modernými komunikačnými protokolmi – '''I2C''' zbernicou a '''12-bitovými analógovými prevodníkmi''', ktoré nám dávajú oveľa presnejšie merania.


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á.
Budeme sa zaoberať:
* '''VL53L0X''' – laserový senzor vzdialenosti (Time of Flight), presnejší ako ultrazvuk
* '''BNO055''' – gyroskop ktorý meria orientáciu a rotáciu robota v priestore
* '''QTR-8A + 74HC4051''' – line senzor s multiplexerom na sledovanie čiary


===== Zapojenie =====
Ku každému komponentu si postavíme jednoduché autíčko ktoré využíva jeho schopnosti – až kým na konci nebudete mať robota ktorý sleduje čiaru, vyhýba sa prekážkam a vie kde sa nachádza.
----


{| class="wikitable"
== Tretia stavebnica ==
|-
! Kábel !! Pin na RP2350-Zero
|-
| Čierny || GND
|-
| Červený || GP4
|}


[[Image:buzzer.png|250px]]
Najľahšie nakoniec! Túto stavebnicu sme navrhli ako oddych od programovania – aby ste si užili skladanie podľa návodu. Najprv sa zoznámime s dvoma novými ale jednoduchými elektronickými komponentmi: '''joystickom''' a '''touch senzorom'''. Po zoznámení sa s nimi sa vrhneme do stavby jednoduchého robotického ramena.


===== Kód =====
Ak nájdete chyby v návode, prosíme napíšte nám ich pri odovzdávaní výsledkov.


Nasledujúci program prechádza rozsahom tónov od 500 Hz do 2500 Hz. Funkcia <code>playNote()</code> je zatiaľ prázdna – to je tvoja úloha ju doplniť!
=== Robotické rameno ===
 
<syntaxhighlight lang="C">
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);
  }
}
</syntaxhighlight>
 
===== Vysvetlenie kódu =====
 
Kľúčom je funkcia <code>playNote()</code>. Zvuk vzniká pravidelným striedaním HIGH a LOW na pine bzučiaka:
 
{| class="wikitable"
|-
! 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.
|-
| <code>delayMicroseconds()</code> || Rovnaké ako <code>delay()</code>, 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
 
<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> Skopíruj kód, doplň funkciu <code>playNote()</code> 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?
 
<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> 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):
 
<syntaxhighlight lang="C">
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 ---
}
</syntaxhighlight>
 
{{Note|Nápoveda: Siréna sanitky sa skladá z dvoch tónov, ktoré sa pravidelne striedajú. Každý tón trvá niekoľko stoviek kmitov – použite cyklus <code>for</code> vo funkcii <code>loop()</code> alebo si vytvorte vlastnú funkciu <code>playAlarm()</code>.}}
 
Hotový program '''nahrajte do mikrokontroléra''', natočte video so zvukom a odošlite na <code>insert mail</code>.
 
Č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 <code>delayMicroseconds()</code> 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:
 
{| class="wikitable"
|-
! 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 =====
 
{| class="wikitable"
|-
! Pin modulu !! Pin na RP2350-Zero
|-
| '''VCC''' || 3.3V
|-
| '''GND''' || GND
|-
| '''D0''' (digitálny výstup) || GP5
|-
| '''A0''' (analógový výstup) || GP26 (ADC0)
|}
 
{{Note|Pin GP26 je jeden z mála pinov na RP2350-Zero, ktorý podporuje analógové čítanie (ADC). Pre digitálny výstup môžeme použiť akýkoľvek GPIO pin.}}
 
[[Image:ky038.png|350px]]
 
===== Časť 1 – Čítanie hodnôt z mikrofónu =====
 
<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> 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.
 
<syntaxhighlight lang="C">
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);
}
</syntaxhighlight>
 
{| class="wikitable"
|-
! Funkcia !! Vysvetlenie
|-
| <code>digitalRead(pin)</code> || Prečíta stav pinu – vráti buď <code>0</code> (ticho) alebo <code>1</code> (zvuk zachytený)
|-
| <code>analogRead(pin)</code> || Prečíta analógovú hodnotu pinu – vráti číslo od <code>0</code> do <code>4095</code>
|-
| <code>delay(50)</code> || Čakáme 50 ms medzi meraniami – aby sériový monitor nescrolloval príliš rýchlo
|}
 
{{Note|Ak digitálny výstup nereaguje na zvuk, skús nastaviť citlivosť otočnou skrutkou na module. Otáčaj pomaly a sleduj zmeny v sériovom monitore.}}
 
<span style="background:#FFFFA0">'''VAŠA ÚLOHA 1:'''</span> 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
 
<syntaxhighlight lang="C">
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 ---
  }
}
</syntaxhighlight>
 
{{Note|Nápoveda: Na zapamätanie stavu (zapnuté/vypnuté) použite premennú typu <code>bool</code>. Prepínanie medzi hodnotami <code>true</code> a <code>false</code> sa robí pomocou operátora <code>!</code> – napríklad <code>aktivny = !aktivny;</code>}}
 
Hotový program '''nahrajte do mikrokontroléra''', natočte video a odošlite na <code>insert mail</code>.
 
===== Č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.
 
[[Image:buzzer_mic_assembly.png|400px]]
 
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.
 
<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> 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.
 
<syntaxhighlight lang="C">
const int BUZZER    = 4;
const int MIC_ANALOG = 26;


int frekvencie[] = {500, 800, 1000, 1500, 2000};
Teraz keď poznáte joystick a touch senzor, postavíte si robotické rameno ovládané joystickom. Touch senzor bude slúžiť ako tlačidlo pre uchopenie objektu (napr. otvoriť/zatvoriť kliešte).
int pocetFrekvencii = 5;


void playNote(int note) {
Rameno pozostáva z niekoľkých servo motorčekov ktoré ovládajú jednotlivé kĺby – podobne ako ľudská ruka.
  // --- sem skopírujte funkciu z predchádzajúcej úlohy ---
}


void setup() {
Postavte rameno podľa návodu:
  pinMode(BUZZER, OUTPUT);
  Serial.begin(9600);
}


void playAndListen(int frekvencia, int trvanie) {
[[Manual |  Návod na skladanie ramena]]
  int halfPeriod = 500000 / frekvencia;
  long startTime = millis();


  while (millis() - startTime < trvanie) {
''' Vaša úloha '''
    playTone(halfPeriod);


    static long lastRead = 0;
<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> Naprogramujte ovládanie ramena joystickom:
    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);
* Os '''X''' joysticku otáča rameno doľava/doprava
  Serial.println("--- ticho ---");
* Os '''Y''' joysticku pohybuje ramenom nahor/nadol
  delay(500);
* '''Stlačenie''' joysticku (SW) otvára/zatvára kliešte
}
* '''Dotyk''' touch senzory pohybujú ramenom dopredu/dozadu


void loop() {
[[Arm structure | Štruktúra]]
  for (int i = 0; i < pocetFrekvencii; i++) {
    playAndListen(frekvencie[i], 1000);
  }
}
</syntaxhighlight>


Oproti predchádzajúcemu kódu pribúdajú nové koncepty:
<span style="background:#FF9900">'''Bonus:'''</span> Pridajte '''pamäť pohybov''' – rameno si zapamätá sekvenciu pohybov a bude ju opakovať. Každé stlačenie joysticku uloží aktuálnu pozíciu všetkých serv do poľa. Po stlačení touch senzora rameno sekvencию prehrá.


{| class="wikitable"
Hotové rameno '''natočte pri práci''' a video odošlite.
|-
! Novinka !! Vysvetlenie
|-
| <code>millis()</code> || Vráti počet milisekúnd od spustenia programu. Používame ho namiesto <code>delay()</code>, aby sme mohli zároveň hrať aj merať.
|-
| <code>static long lastRead</code> || Premenná s kľúčovým slovom <code>static</code> si zachováva svoju hodnotu medzi volaniami funkcie – neresetuje sa na 0 pri každom zavolaní.
|-
| <code>while (millis() - startTime < trvanie)</code> || Cyklus beží dovtedy, kým neuplynie požadovaný čas – počas neho stihneme robiť aj kmity bzučiaka aj čítanie mikrofónu.
|-
| <code>int frekvencie[]</code> || '''Pole''' – zoznam hodnôt rovnakého typu uložených za sebou. Pristupujeme k nim cez index: <code>frekvencie[0]</code> = 500, <code>frekvencie[1]</code> = 800, atď.
|}
 
<span style="background:#FFFFA0">'''VAŠA ÚLOHA 2:'''</span> Upravte program a otestujte mikrofón pri rôznych nastaveniach citlivosti:
 
# Spustite program a sledujte hodnoty v sériovom monitore
# Otočnou skrutkou '''nastavte citlivosť''' tak, aby mikrofón spoľahlivo zachytával všetky tóny
# Do poľa <code>frekvencie[]</code> '''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?
# 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 <code>insert mail</code>.
 
{{Note|Nápoveda: Ak sú hodnoty z mikrofónu stále rovnaké (napr. 0 alebo 4095), skontrolujte zapojenie pinu A0 na GP26 a skúste otočiť skrutkou citlivosti na module.}}


Čo sme sa naučili?
Č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.
* Joystick kombinuje dva potenciometre a tlačidlo – os X a Y dávajú analógovú hodnotu 0–4095.
* Funkcia <code>millis()</code> umožňuje merať čas bez blokovania programu – na rozdiel od <code>delay()</code>.
* Touch senzor detekuje dotyk bez mechanického tlačidla – využíva zmenu kapacitancie.
* Pole (<code>int frekvencie[]</code>) je užitočný spôsob ako uložiť viacero hodnôt a prechádzať cez ne cyklom.
* Robotické rameno kombinuje všetky doterajšie znalosti – servo motorčeky, joystick aj touch senzor.
* 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:
 
{| class="wikitable"
|-
! 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'''.
 
{{Note|Ak servo pri pohybe spôsobuje reštart mikrokontroléra, je odberané priveľa prúdu. V takom prípade napájajte servo samostatne a spojte iba GND.}}
 
<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> 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?
 
<syntaxhighlight lang="C">
#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);
}
</syntaxhighlight>
 
{| class="wikitable"
|-
! Novinka !! Vysvetlenie
|-
| <code>#include <Servo.h></code> || Načítame knižnicu pre ovládanie serva – bez nej by sme museli impulzy generovať ručne
|-
| <code>servo.attach(pin, 500, 2500)</code> || Pripojíme servo na pin a definujeme rozsah impulzov (500–2500 µs)
|-
| <code>servo.write(uhol)</code> || Nastavíme servo na požadovaný uhol (0–180°)
|-
| <code>inputString.toInt()</code> || Prevedie textový reťazec na celé číslo – napr. <code>"120"</code> → <code>120</code>
|}
 
<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> 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:
 
{| class="wikitable"
|-
! 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
|}
 
<syntaxhighlight lang="C">
#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);
}
</syntaxhighlight>
 
{{Note|Nápoveda: Keďže ľavé a pravé koleso sú namontované oproti sebe, musia sa otáčať '''opačným smerom''' aby autíčko išlo rovno. Ak jedno servo ide na hodnotu 70, druhé musí ísť na 110.}}
 
<span style="background:#FF9900">'''Bonus:'''</span> 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 <code>map()</code>:
 
<syntaxhighlight lang="C">
// Príklad: prevedie vzdialenosť 30-100cm na hodnotu serva 90-180
int rychlost = map(vzdialenost, 30, 100, 90, 180);
</syntaxhighlight>
 
Hotový program '''nahrajte do mikrokontroléra''', natočte video a odošlite na <code>insert mail</code>.
 
Čo sme sa naučili?
* Servo motorček ovládame pomocou knižnice <code>Servo.h</code> a funkcie <code>servo.write()</code>.
* 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 <code>map()</code> 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:
 
{| class="wikitable"
|-
! 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'''.
 
{{Note|Ak servo pri pohybe spôsobuje reštart mikrokontroléra, je odberané priveľa prúdu. V takom prípade napájajte servo samostatne a spojte iba GND.}}
 
<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> 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?
 
<syntaxhighlight lang="C">
#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);
}
</syntaxhighlight>
 
{| class="wikitable"
|-
! Novinka !! Vysvetlenie
|-
| <code>#include <Servo.h></code> || Načítame knižnicu pre ovládanie serva – bez nej by sme museli impulzy generovať ručne
|-
| <code>servo.attach(pin, 500, 2500)</code> || Pripojíme servo na pin a definujeme rozsah impulzov (500–2500 µs)
|-
| <code>servo.write(uhol)</code> || Nastavíme servo na požadovaný uhol (0–180°)
|-
| <code>inputString.toInt()</code> || Prevedie textový reťazec na celé číslo – napr. <code>"120"</code> → <code>120</code>
|}
 
<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> 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:
 
{| class="wikitable"
|-
! 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
|}
 
<syntaxhighlight lang="C">
#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);
}
</syntaxhighlight>
 
{{Note|Nápoveda: Keďže ľavé a pravé koleso sú namontované oproti sebe, musia sa otáčať '''opačným smerom''' aby autíčko išlo rovno. Ak jedno servo ide na hodnotu 70, druhé musí ísť na 110.}}
 
<span style="background:#FF9900">'''Bonus:'''</span> 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 <code>map()</code>:
 
<syntaxhighlight lang="C">
// Príklad: prevedie vzdialenosť 30-100cm na hodnotu serva 90-180
int rychlost = map(vzdialenost, 30, 100, 90, 180);
</syntaxhighlight>
 
Hotový program '''nahrajte do mikrokontroléra''', natočte video a odošlite na <code>insert mail</code>.
 
Čo sme sa naučili?
* Servo motorček ovládame pomocou knižnice <code>Servo.h</code> a funkcie <code>servo.write()</code>.
* 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 <code>map()</code> umožňuje previesť hodnotu z jedného rozsahu do druhého.
 
=== Druhá stavebnica ===
 
=== Robotické rameno ===

Aktuálna revízia z 11:21, 2. august 2026

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á prípravy

Pre začiatok na setupnutie si vlastnej stavebnice budeme musiet si pripravit:

- Hadrver - Softver

Príprava hardvéru

Celkový setup elektorniky a HW súčiastok


Príprava arduino rozhrania

Arduino IDE setup

Pred začatím odporúčame prezrieť si prehľad premenných a operátorov.

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 a držiaky na káble Držiaky elektronických komponentov – napájajú sa priamo na biele časti
Č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).
Modrá Moduly a ramienka pre servo motorčeky Niektoré majú diery pre M3 matice, ktoré spolu so skrutkou spájajú modul s bielimi/žltími/čiernymi súčiastkami.

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:

Galéria súčiastok a ich zapojenie

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.

Č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

V prvej stavebnici sa zoznámite so základnými elektronickými modulmi. Niektoré z nich sa vám budú hodiť pri ladení zložitejších robotov – napríklad LED vám vie ukázať v akom stave sa robot nachádza, bzučiak vás upozorní keď sa niečo stane. Iné moduly sú dôležité pre pochopenie základov, na ktorých budeme neskôr stavať.

Budeme sa zaoberať:

  • RGB LED – farebná dióda na vizuálnu signalizáciu
  • Bzučiak – jednoduchý reproduktor na zvukovú signalizáciu
  • Mikrofón – zachytávanie zvuku z okolia
  • Ultrazvukový senzor – meranie vzdialenosti
  • Servo motorček – presné ovládanie pohybu

Na konci prvej stavebnice poskladáte autíčko ktoré sa samo vyhýba prekážkam – prvého autonómneho robota!

Roomba

Naučili ste sa ako narábať s hlavnými komponentmi stavebnice. Teraz využijete všetky znalosti dokopy a postavíte si robotického vysavača – Roombu.

Autíčko bude skúmať terén pred sebou. Keď narazí na prekážku, pozrie sa doprava a doľava, nájde voľný smer a pokračuje ďalej. Konštrukciu auta môžete nechať z predchádzajúcej úlohy – stačí pridať 180° servo s ultrazvukovým senzorom na otáčanie hlavy.

Použijete:

  • 2× 360° servo (kolesá)
  • 1× 180° servo (otáčanie senzora)
  • 1× HC-SR04
  • 1× RGB LED modul (voliteľné)
  • 1× bzučiak (voliteľné)

Algoritmus

Roomba má v každom momente nejaký stav – a podľa neho sa rozhoduje čo urobiť:

  1. Ide rovno – ak je pred ňou voľno (> 20 cm)
  2. Narazila na prekážku – otočí senzor doprava a zmeria
  3. Ak je doprava voľno – otočí sa doprava a pokračuje
  4. Ak nie – otočí senzor doľava a zmeria
  5. Ak je doľava voľno – otočí sa doľava a pokračuje
  6. Ak je všade prekážka – cúvne a zopakuje skenovanie

LED a bzučiak sú voliteľné – ale môžu pekne znázorniť jednotlivé stavy (napr. zelená = ide, červená = prekážka, pípnutie pri otočení).

VAŠA ÚLOHA: Zostrojte Roombu a naprogramujte algoritmus podľa opisu vyššie. Dostávate štruktúru na doplnenie:

Štruktúra

Bonus: Roomba si môže pamätať históriu otočení – ak sa viackrát za sebou otočila doprava, skúsi to doľava a naopak. Tak sa vyhne zaseknutiu v rohu.

Hotový program nahrajte do mikrokontroléra, natočte krátke demonštračňé video a odošlite.

Čo sme sa naučili?

  • Komplexnejšie správanie robota sa dá rozložiť na jednoduché stavy a prechody medzi nimi.
  • 180° servo vie presne namieriť senzor na konkrétny uhol – využili sme ho ako "hlavu" robota.
  • Kombináciou všetkých komponentov vieme postaviť autonómneho robota schopného orientovať sa v priestore.

Druhá stavebnica

V druhej stavebnici prídete do kontaktu s presnejšími a výkonnejšími senzormi. Oproti prvej stavebnici tu pracujeme s modernými komunikačnými protokolmi – I2C zbernicou a 12-bitovými analógovými prevodníkmi, ktoré nám dávajú oveľa presnejšie merania.

Budeme sa zaoberať:

  • VL53L0X – laserový senzor vzdialenosti (Time of Flight), presnejší ako ultrazvuk
  • BNO055 – gyroskop ktorý meria orientáciu a rotáciu robota v priestore
  • QTR-8A + 74HC4051 – line senzor s multiplexerom na sledovanie čiary

Ku každému komponentu si postavíme jednoduché autíčko ktoré využíva jeho schopnosti – až kým na konci nebudete mať robota ktorý sleduje čiaru, vyhýba sa prekážkam a vie kde sa nachádza.

Tretia stavebnica

Najľahšie nakoniec! Túto stavebnicu sme navrhli ako oddych od programovania – aby ste si užili skladanie podľa návodu. Najprv sa zoznámime s dvoma novými ale jednoduchými elektronickými komponentmi: joystickom a touch senzorom. Po zoznámení sa s nimi sa vrhneme do stavby jednoduchého robotického ramena.

Ak nájdete chyby v návode, prosíme napíšte nám ich pri odovzdávaní výsledkov.

Robotické rameno

Teraz keď poznáte joystick a touch senzor, postavíte si robotické rameno ovládané joystickom. Touch senzor bude slúžiť ako tlačidlo pre uchopenie objektu (napr. otvoriť/zatvoriť kliešte).

Rameno pozostáva z niekoľkých servo motorčekov ktoré ovládajú jednotlivé kĺby – podobne ako ľudská ruka.

Postavte rameno podľa návodu:

Návod na skladanie ramena

Vaša úloha

VAŠA ÚLOHA: Naprogramujte ovládanie ramena joystickom:

  • Os X joysticku otáča rameno doľava/doprava
  • Os Y joysticku pohybuje ramenom nahor/nadol
  • Stlačenie joysticku (SW) otvára/zatvára kliešte
  • Dotyk touch senzory pohybujú ramenom dopredu/dozadu

Štruktúra

Bonus: Pridajte pamäť pohybov – rameno si zapamätá sekvenciu pohybov a bude ju opakovať. Každé stlačenie joysticku uloží aktuálnu pozíciu všetkých serv do poľa. Po stlačení touch senzora rameno sekvencию prehrá.

Hotové rameno natočte pri práci a video odošlite.

Čo sme sa naučili?

  • Joystick kombinuje dva potenciometre a tlačidlo – os X a Y dávajú analógovú hodnotu 0–4095.
  • Touch senzor detekuje dotyk bez mechanického tlačidla – využíva zmenu kapacitancie.
  • Robotické rameno kombinuje všetky doterajšie znalosti – servo motorčeky, joystick aj touch senzor.
Zdroj: „https://3dliga.robotika.sk/wiki/index.php?title=Prvé_kolo&oldid=268“