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í
 
(87 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].
Pre začiatok na setupnutie si vlastnej stavebnice budeme musiet si pripravit:
Vyberte verziu zodpovedajúcu vášmu operačnému systému (Windows, macOS alebo Linux).


[[Image:Arduino Download.png|400px]]
- Hadrver
- Softver


=== Mikrokontrolér ===
== Príprava hardvéru ==  


Ako riadiaci čip stavebnice používame '''Waveshare RP2350-Zero'''.
[[Príprava elektroniky - hardware setup | Celkový setup elektorniky a HW súčiastok]]
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'''.
== Príprava arduino rozhrania==
# 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]]
[[Príprava programovacieho prostredia - sofrware setup | Arduino IDE setup]]


==== Výber dosky a portu ====
Pred začatím odporúčame prezrieť si [[Základy programovania | prehľad premenných a operátorov]].


Po inštalácii knižnice je nutné zvoliť správnu dosku a port – bez toho počítač nerozpozná pripojený mikrokontrolér.
== Vytlačená stavebnica ==
 
# V menu '''Tools → Board''' vyhľadajte a vyberte '''"Raspberry Pi Pico"'''.
# 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ť:
 
* '''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.
* '''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)
 
==== Prvé pripojenie – režim BOOTSEL ====
 
Pri úplne prvom nahrávaní, alebo keď mikrokontrolér neodpovedá, je potrebné ho prepnúť do režimu BOOTSEL:
 
# Stlačte a '''podržte tlačidlo BOOT''' na doske RP2350-Zero.
# 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'''.
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''')
 
[[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 ====
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ť.


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ň.
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


[[Image:Rgb-led-module.jpg|300px]]
Na konci prvej stavebnice poskladáte autíčko ktoré sa samo vyhýba prekážkam – prvého autonómneho robota!


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.
----
 
Modul má '''4 piny''':
 
{| 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é
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).


void setup() {
Rameno pozostáva z niekoľkých servo motorčekov ktoré ovládajú jednotlivé kĺby – podobne ako ľudská ruka.
  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) {
Postavte rameno podľa návodu:
  // --- sem skopírujte funkciu z predchádzajúcej úlohy ---
}


void setColor(int r, int g, int b) {
[[Manual |  Návod na skladanie ramena]]
  // --- sem skopírujte funkciu z predchádzajúcej úlohy ---
}


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


  if (aktivny) {
<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> Naprogramujte ovládanie ramena joystickom:
    // --- 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>}}
* 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


Hotový program '''nahrajte do mikrokontroléra''', natočte video a odošlite na <code>insert mail</code>.
[[Arm structure | Štruktúra]]


===== Časť 2 – Mikrofón a bzučiak spolu =====
<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á.


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á.
Hotové rameno '''natočte pri práci''' a video odošlite.
 
'''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};
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);
  }
}
</syntaxhighlight>
 
Oproti predchádzajúcemu kódu pribúdajú nové koncepty:
 
{| class="wikitable"
|-
! 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.
 
==== 6. Ultrasonicky senzor ====
 
Dostali ste ultrazvukovy senzor HC-SR04. Dve ulohy dozadu sme robili ako generovat zvuk rychlim zapinanim a vypinanim reprodukra. V tejto ulohe budete musiet generovat ultrazvuk na detekovanie objektov. Na senzore mame reproduktor a mikrofon, jedna generuje ultrazvuk, je napojena
 
=== 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“