Prvé kolo

2026-05-21T15:43:44Z

Admin:

=== 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 <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.
* Pociťujeme nárast umelej inteligencie, preto vás prosíme aby ste používali rozumne umelú inteligenciu. Tolerujeme vyhladávanie alebo opravovanie pravopisu pomocou AI (ako nástroj). Ak ale použijete AI na vygenerovanie riešenia, vypomáhanie alebo len nájdenie riešenia, tak prosíme aby ste napísali, že ste využili takúto službu. Budeme na to brať ohľad. Zakázať vám to používať nemôžeme, len sa snažíme dovŕšiť to aby ste na riešenie prišli sami a naučili sa niečo nové a zábavné.

== 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).

Mikrokontrolér RP2350-Zero je "mozog" celej stavebnice. Obsahuje procesor, pamäť a GPIO piny cez ktoré komunikuje so všetkými komponentmi – senzormi, motorčekmi aj LED diódami. Napájanie komponentov je 3.3V.

[[Image:RP2040-Zero-Pinout.jpg|400px]]
[[Image:RP2040-Zero-Board.jpg|400px]]

=== 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"'''.
# 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 2''') 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]]

=== 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. Pred začatím odporúčame prezrieť si [[Základy programovania | prehľad premenných a operátorov]].

<syntaxhighlight lang="C">
void setup() {
Serial.begin(9600);
}
int i = 0;
void loop() {
Serial.print("Ahoj ");
Serial.println(i++);
delay(1000);
}
</syntaxhighlight>

'''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'':

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

== 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 '''

{| class="wikitable"
|-
! 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ť:

{|
|-
| [[Image:Model1.png|300px]] || [[Image:Model2.png|300px]]
|}

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

[[Image:srdce.jpg|300px]]

[[Gallery | 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 na <code>insert mail</code>.

Č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!

----

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

[[Image:Rgb-led-module.jpg|300px]]

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)

''' Kód '''

'''Vyskúšaj toto:''' Nasledujúci program rozsvieti RGB LED na bielo a zhasne.
<syntaxhighlight lang="C">
// 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);
}
</syntaxhighlight>

''' Princíp '''

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:

[[Image:RGB palete.jpg|350px]]

'''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 <code>insert mail</code>.

Č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 <code>digitalWrite()</code>.

----

=== 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 '''

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

[[Image:buzzer.png|250px]]

''' Kód '''

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ť!
<syntaxhighlight lang="C">
const int BUZZER = 4;

void setup() {
pinMode(BUZZER, OUTPUT);
Serial.begin(9600);
}
void playNote(int note)
{
int halfPeriod = 500000 / note;

for (int i = 0; i < 10; i++) {
digitalWrite(BUZZER, HIGH);
delayMicroseconds(halfPeriod);
digitalWrite(BUZZER, LOW);
delayMicroseconds(halfPeriod);
}
}

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

''' Princíp '''

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

'''Vyskúšaj toto:''' 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?

'''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):

[[Buzzer structure|Štruktúra]]



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.

----

=== 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)
|}

[[Image:ky038.jpeg|350px]]

----

==== Č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.

<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
|}

'''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

[[Microphone structure| Štruktúra]]

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.

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

<syntaxhighlight lang="C">
const int BUZZER = 4;
const int MIC_ANALOG = 26;

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

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) {
long startTime = millis();

while (millis() - startTime < trvanie) {
playNote(frekvencia); // zahrá jeden "balík" kmitov danej frekvencie
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>long lastRead</code> || Premenná s kľúčovým slovom <code></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ď.
|}

'''VAŠA ÚLOHA 2:''' 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>.



Č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 <code>millis()</code> umožňuje merať čas bez blokovania programu – na rozdiel od <code>delay()</code>.
* Pole (<code>int frekvencie[]</code>) 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.

----

=== Ultrazvukový senzor ===

Dostali ste ultrazvukový senzor '''HC-SR04'''. Pred dvoma úlohami sme sa naučili ako generovať zvuk rýchlym zapínaním a vypínaním bzučiaka. Teraz použijeme rovnaký princíp – ale na iný účel: '''meranie vzdialenosti'''.

Senzor HC-SR04 má na sebe zabudovaný reproduktor aj mikrofón:
* '''Reproduktor''' vyšle krátky ultrazvukový impulz cez pin '''TRIG'''
* Impulz sa odrazí od objektu pred senzorom a vráti sa späť
* '''Mikrofón''' zachytí odrazený signál a vyšle ho cez pin '''ECHO'''

Celý tento proces trvá nejaký čas – a práve z tohto času vieme vypočítať vzdialenosť.



[[Image:HC-SR04-visual.jpg|350px]]

Pozor – nie každý objekt odrazí ultrazvuk spoľahlivo. Mäkké a porézne materiály (napr. látka, molitan) zvuk pohlcujú namiesto odrazu, a senzor ich nemusí detekovať.

''' Zapojenie '''

{| class="wikitable"
|-
! Pin senzora !! Pin na RP2350-Zero
|-
| '''VCC''' || 5V
|-
| '''GND''' || GND
|-
| '''TRIG''' || GP6
|-
| '''ECHO''' || GP7
|}

''' Kód – meranie času impulzu '''

'''Vyskúšaj toto:''' Skopíruj a spusti nasledujúci program. Otvor sériový monitor (9600 baud) a pohybuj rukou pred senzorom. Sleduj ako sa mení nameraná vzdialenosť.

<syntaxhighlight lang="C">
const int TRIG = 6;
const int ECHO = 7;

void setup() {
pinMode(TRIG, OUTPUT);
pinMode(ECHO, INPUT);
Serial.begin(9600);
}

// Funkcia odošle impulz a vráti nameraný čas v mikrosekundách
long measurePulse() {
digitalWrite(TRIG, LOW);
delayMicroseconds(2);

digitalWrite(TRIG, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG, LOW);

return pulseIn(ECHO, HIGH);
}

void loop() {
long trvanie = measurePulse();

Serial.print("Čas: ");
Serial.print(trvanie);

delay(100);
}
</syntaxhighlight>

''' Princíp '''

{| class="wikitable"
|-
! Novinka !! Vysvetlenie
|-
| <code>pulseIn(pin, HIGH)</code> || Čaká kým pin prejde do stavu HIGH, potom meria ako dlho v ňom zostane. Vráti čas v mikrosekundách.
|-
| <code>digitalWrite(TRIG, HIGH)</code> + <code>delayMicroseconds(10)</code> || Odošleme presne 10µs impulz – to je požiadavka senzora HC-SR04 na spustenie merania.
|-
| <code>trvanie * 0.0343 / 2.0</code> || Prepočet: čas (µs) × rýchlosť zvuku (cm/µs) ÷ 2 (tam aj späť) = vzdialenosť v cm.
|-
| <code>float</code> || Dátový typ pre desatinné čísla – na rozdiel od <code>int</code>, ktorý uchováva iba celé čísla.
|}

''' Vaša úloha – Parkovací senzor '''

'''VAŠA ÚLOHA:''' Zapojte k ultrazvukovému senzoru bzučiak a RGB LED. Napíšte program, ktorý bude fungovať ako '''parkovací senzor''':

* Čím je objekt '''bližšie''', tým '''rýchlejšie''' bliká LED a pípá bzučiak
* Na základe vzdialenosti meňte aj '''farbu''' LED:

{| class="wikitable"
|-
! Vzdialenosť !! Farba LED !! Bzučiak
|-
| > 30 cm || Zelená || ticho
|-
| 10 – 30 cm || Žltá || pomalé pípanie
|-
| < 10 cm || Červená || rýchle pípanie
|}

Vzorová štruktúra programu:

[[Ultrasonic sensor structure | Štruktúra]]

'''Bonus:'''
Skúste sa zamyslieť nad tým ako by sme mohli ošetriť situáciu, kedy by signál nepriśiel naspäť. Buť je objekt ďaleko alebo sa zvuk pohltí. Senzor vie nasnímať maximálne do 200cm. Skúste si to prepočítať.

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

Čo sme sa naučili?
* Ultrazvukový senzor HC-SR04 meria vzdialenosť pomocou odrazu zvuku – princíp podobný netopierom alebo parkovacím senzorom áut.
* Funkcia <code>pulseIn()</code> meria čas trvania signálu na pine v mikrosekundách.
* Dátový typ <code>float</code> používame vtedy, keď potrebujeme pracovať s desatinnými číslami.
* Nie každý materiál odráža ultrazvuk rovnako – mäkké povrchy ho môžu pohltiť.

----

=== 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'''.



'''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?

<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>
|}

'''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:

{| 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
|}

[[Servo structure | Štruktúra]]



'''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 [//docs.arduino.cc/language-reference/en/functions/math/map/ <code>map()</code>]

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.

=== 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ť:

# Ide rovno – ak je pred ňou voľno (> 20 cm)
# Narazila na prekážku – otočí senzor doprava a zmeria
# Ak je doprava voľno – otočí sa doprava a pokračuje
# Ak nie – otočí senzor doľava a zmeria
# Ak je doľava voľno – otočí sa doľava a pokračuje
# 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:

[[Roomba structure | Š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 video a odošlite na <code>insert mail</code>.

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

=== VL53L0X senzor ===

Dostali ste malý, ale účinný senzor na meranie vzdialenosti. '''VL53L0X''' funguje na princípe vysielania infračerveného svetla – lúč sa odrazí od objektu a vráti sa späť za rádovo nanosekundy. Zmeria sa čas letu (Time of Flight) a vypočíta sa vzdialenosť.

Táto technológia je výrazne presnejšia a rýchlejšia ako ultrazvukový senzor – pracujeme so svetlom, ktoré je niekoľkonásobne rýchlejšie ako zvuk.

[[Image:VL53L0X.jpg|300px]]

''' Zapojenie '''

Senzor komunikuje cez zbernicu '''I2C''' – potrebuje iba 4 vodiče:

{| class="wikitable"
|-
! Pin senzora !! Pin na RP2350-Zero
|-
| '''VCC''' || 3.3V
|-
| '''GND''' || GND
|-
| '''SDA''' || GP4
|-
| '''SCL''' || GP5
|}

''' Inštalácia knižnice '''

# V Arduino IDE otvorte '''Tools → Manage Libraries'''
# Vyhľadajte '''"VL53L0X"''' a nainštalujte knižnicu od autora '''Pololu'''

[[Image:VL53L0X-lib.png|300px]]

''' Kód '''

'''Vyskúšaj toto:''' Skopíruj a spusti nasledujúci program. Otvor sériový monitor (115200 baud) a pohybuj rukou pred senzorom.

<syntaxhighlight lang="C">
#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
Serial.begin(115200);
Wire.setSDA(4); // GP4
Wire.setSCL(5); // GP5
Wire.begin();

if (!sensor.init()) {
Serial.println("Senzor nenájdený!");
while (1); // zastav program
}

sensor.setTimeout(500);
sensor.startContinuous();
Serial.println("VL53L0X OK");
}

void loop() {
int dist = sensor.readRangeContinuousMillimeters();

if (sensor.timeoutOccurred()) {
Serial.println("Timeout!");
} else {
Serial.print("Vzdialenosť: ");
Serial.print(dist);
Serial.println(" mm");
}

delay(100);
}
</syntaxhighlight>

{| class="wikitable"
|-
! Novinka !! Vysvetlenie
|-
| <code>#include <Wire.h></code> || Knižnica pre I2C zbernicu – spôsob komunikácie medzi mikrokontrolérom a senzorom cez 2 vodiče (SDA, SCL)
|-
| <code>Wire.setSDA(4)</code> / <code>Wire.setSCL(5)</code> || Nastavíme ktoré piny budú použité pre I2C komunikáciu
|-
| <code>sensor.init()</code> || Inicializuje senzor – ak vráti <code>false</code>, senzor nie je správne zapojený
|-
| <code>sensor.startContinuous()</code> || Spustí nepretržité meranie – senzor meria stále bez čakania na príkaz
|-
| <code>sensor.timeoutOccurred()</code> || Vráti <code>true</code> ak senzor neodpovedal včas – objekt je príliš ďaleko alebo senzor nefunguje
|}

Pre hlbšie vysvetlenie ako funguje tento senzor prikladáme [https://learn.adafruit.com/adafruit-vl53l0x-micro-lidar-distance-sensor-breakout/overview článok od Adafruit].



'''VAŠA ÚLOHA:''' Implementujte VL53L0X senzor na svoje prvé autíčko namiesto ultrazvukového senzora. Správanie psíčka zostáva rovnaké – zmeňte iba časť kódu ktorá meria vzdialenosť.

[[Car with lasers | Štruktúra]]

'''Bonus:''' Použite '''3× VL53L0X''' senzory – jeden dopredu, druhý doľava a tretí doprava. Roomba tak bude vidieť do všetkých strán naraz a nebude musieť otáčať hlavou.



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

Čo sme sa naučili?
* VL53L0X meria vzdialenosť pomocou infračerveného svetla (Time of Flight) – presnejšie a rýchlejšie ako ultrazvuk.
* I2C je spôsob komunikácie kde viacero zariadení zdieľa iba 2 vodiče – každé má svoju jedinečnú adresu.
* Knižnica môže za nás vyriešiť celú komunikáciu so senzorom – stačí zavolať správne funkcie.

----

=== Gyroskop BNO055 ===

Doteraz sme jazdili rovno bez toho, aby samotné autíčko vedelo, že ide rovno. Na to nám pomôže '''gyroskop''' – senzor ktorý zaznamenáva otáčanie v troch osiach: X, Y a Z. My budeme zatiaľ využívať os '''Z''', ktorá zaznamenáva otáčanie doprava a doľava.

Na rozdiel od predchádzajúcich senzorov, gyroskop musíme pred použitím '''skalibrovať''' – teda nechať ho chvíľu v pokoji, aby si zaznamenal svoju počiatočnú polohu.

[[Image:BNO055.jpg|250px]]

''' Zapojenie '''

Senzor komunikuje cez zbernicu '''I2C''' – rovnako ako VL53L0X:

{| class="wikitable"
|-
! Pin senzora !! Pin na RP2350-Zero
|-
| '''VCC''' || 3.3V
|-
| '''GND''' || GND
|-
| '''SDA''' || GP4
|-
| '''SCL''' || GP5
|}

''' Inštalácia knižnice '''

# V Arduino IDE otvorte '''Tools → Manage Libraries'''
# Vyhľadajte '''"Adafruit BNO055"''' a nainštalujte knižnicu
# Nainštalujte aj závislosť '''"Adafruit Unified Sensor"''' ak sa zobrazí výzva

''' Kód '''
'''Vyskúšaj toto:''' Skopíruj a spusti nasledujúci program. Otvor sériový monitor (115200 baud) a otáčaj senzorom v rôznych smeroch. Sleduj ako sa menia hodnoty osí X, Y, Z.



<syntaxhighlight lang="C">
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BNO055.h>

Adafruit_BNO055 bno;
bool active = false;

void setup() {
Serial.begin(115200);
Wire.setSDA(4);
Wire.setSCL(5);
Wire.begin();
delay(1000);

// Hľadáme senzor na I2C zbernici
Serial.println("Hľadám I2C zariadenia...");
int adresa = 0;
for (byte addr = 1; addr < 127; addr++) {
Wire.beginTransmission(addr);
if (Wire.endTransmission() == 0) {
Serial.print("Nájdené zariadenie na adrese: 0x");
Serial.println(addr, HEX);
adresa = addr;
}
}

if (adresa > 0) {
bno = Adafruit_BNO055(55, adresa, &Wire);
if (bno.begin()) {
active = true;
Serial.println("BNO055 OK – čakám na kalibráciu...");
} else {
Serial.println("BNO055 begin() zlyhalo");
}
} else {
Serial.println("Žiadny senzor nenájdený!");
}
}

void loop() {
if (!active) {
Serial.println("Senzor nie je pripravený");
delay(1000);
return;
}

// Kontrola kalibrácie – hodnoty 0-3, kde 3 = plne kalibrované
uint8_t system, gyro, accel, mag;
bno.getCalibration(&system, &gyro, &accel, &mag);

if (system < 1) {
Serial.println("Kalibrujem – pohni senzorom...");
delay(100);
return;
}

imu::Vector<3> euler = bno.getVector(Adafruit_BNO055::VECTOR_EULER);
Serial.print("X: "); Serial.print(euler.x());
Serial.print(" Y: "); Serial.print(euler.y());
Serial.print(" Z: "); Serial.println(euler.z());
delay(100);
}
</syntaxhighlight>

Program čaká kým nie je senzor aspoň čiastočne kalibrovaný (<code>system >= 1</code>) pred tým ako začne vypisovať hodnoty. Ak vidíš stále "Kalibrujem", pomaly otáčaj senzorom vo všetkých smeroch – kalibrácia by mala prísť do niekoľkých sekúnd.

{| class="wikitable"
|-
! Novinka !! Vysvetlenie
|-
| <code>Adafruit_BNO055</code> || Objekt reprezentujúci senzor – cez neho voláme všetky funkcie knižnice
|-
| <code>bno.begin()</code> || Inicializuje senzor – ak vráti <code>false</code>, senzor nie je správne zapojený
|-
| <code>bno.getVector(VECTOR_EULER)</code> || Vráti aktuálnu rotáciu vo forme troch uhlov (Eulerove uhly) v stupňoch
|-
| <code>euler.x()</code> / <code>.y()</code> / <code>.z()</code> || Jednotlivé osi rotácie – os Z sleduje otáčanie doprava/doľava
|-
| <code>imu::Vector<3></code> || Dátový typ pre trojrozmerný vektor – obsahuje tri hodnoty naraz
|}

{{Note|Os Z vracia hodnoty 0°–360°. Keď autíčko stojí rovno = 0°, otočenie doprava zvyšuje hodnotu, otočenie doľava ju znižuje (alebo ide k 360°). Toto treba zohľadniť v kóde.}}

'''VAŠA ÚLOHA:''' Pripevnite gyroskop k autíčku '''kolmo na cestu''' (plocho, aby os Z merala otáčanie). Naprogramujte autíčko ktoré:

* Ide '''presne rovno''' – ak gyroskop zaznamená odchýlku, autíčko sa skoriguje
* Na príkaz cez sériový monitor sa otočí presne o '''90° doprava alebo doľava''' – otáča sa dovtedy, kým gyroskop nezaznamená 90°

[[Gyroscope structure | Štruktúra]]

{{Note|Nápoveda: Presné otáčanie na 90° vyžaduje aby ste sledovali '''zmenu uhla''' od momentu keď ste začali otáčanie – nie absolútnu hodnotu. Uložte si počiatočný uhol do premennej a sledujte rozdiel.}}

'''Bonus:''' Použite VL53L0X senzor pripevnený na 180° servo a preskúmajte terén ako [https://cs.wikipedia.org/wiki/Lidar lidar] – servo sa otočí z jednej strany na druhú a senzor zaznamená vzdialenosť v každom uhle. Po preskúmaní sa autíčko otočí smerom k '''najbližšiemu objektu''' a príde za ním (upgrade poslušného psíčka).

[[Lidar structure| Štruktúra]]

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

Čo sme sa naučili?
* Gyroskop BNO055 meria rotáciu v troch osiach – os Z sleduje otáčanie doprava/doľava.
* Eulerove uhly vyjadrujú orientáciu objektu v priestore pomocou troch čísel.
* Kombináciou gyroskopu a serv vieme autíčku dopomôcť k presnému pohybu a otáčaniu.

----

=== Line senzor + multiplexer ===

Dostali ste modul zložený z '''QTR-8A''' line senzora a '''74HC4051''' multiplexera.

QTR-8A obsahuje 8 infračervených snímačov odrazivosti – každý meria koľko infračerveného svetla sa odrazí od povrchu. Tmavá čiara odráža menej ako svetlý podklad.

Senzor nemá indikačnú LED, takže navonok nevidno či dostáva napájanie. Pre najlepší účinok IR senzorov ich treba zapojiť do 5V (IR pin).

''' Prečo potrebujeme multiplexer? '''

RP2350-Zero má iba '''4 analógové vstupy''' (GP26–GP29), ale senzor má '''8 analógových výstupov'''. Na to nám pomôže multiplexer 74HC4051 – prepína 8 analógových kanálov na jeden výstup. Každý kanál má svoju adresu od <code>000</code> po <code>111</code> (binárne), ktorú nastavujeme cez 3 select piny (S0, S1, S2).

Postup čítania všetkých 8 kanálov:
# Nastavíme adresu kanála cez S0, S1, S2
# Počkáme kým sa multiplexer prepne (~10 µs)
# Prečítame hodnotu z výstupu Z
# Opakujeme pre všetky kanály 0–7

''' Zapojenie '''

{| class="wikitable"
|-
! Pin modulu !! Pin na RP2350-Zero
|-
| '''VCC''' || 3.3V
|-
| '''GND''' || GND
|-
| '''IR (QTR-8A)''' || 5V
|-
| '''Z''' (analógový výstup) || GP26 (ADC)
|-
| '''S0''' || GP6
|-
| '''S1''' || GP7
|-
| '''S2''' || GP8
|}

[[Image:QTR-8A-pinout.png|400px]]

''' Kód '''

'''Vyskúšaj toto:''' Skopíruj a spusti nasledujúci program. Otvor sériový monitor (115200 baud) a pomaly pohybuj senzorom nad čiernou čiarou na bielom podklade.

<syntaxhighlight lang="C">
/*
RP2040 74HC4051 QTR-8A
┌──────────┐ ┌──────────────────────────┐ ┌────────┐
| 5V ├─┘ ┌──────────┐ └──┤ IR |
| 3.3V├──────────┤VCC VCC├─────────┤ VCC |
│ GP26├──────────┤Z GND├─────────┤ GND |
│ GP13├──────────┤S2 Y0├─────────┤ D1 |
│ GP14├──────────┤S1 Y1├─────────┤ D2 |
│ GP15├──────────┤S0 Y2├─────────┤ D3 |
│ GND├──────────┤GND Y3├─────────┤ D4 |
└──────────┘ | Y4├─────────┤ D5 |
| Y5├─────────┤ D6 |
| Y6├─────────┤ D7 |
| Y7├─────────┤ D8 |
└──────────┘ └────────┘
*/
const int MUX_Z = 26; // analógový výstup multiplexera
const int MUX_S0 = 6; // select bit 0
const int MUX_S1 = 7; // select bit 1
const int MUX_S2 = 8; // select bit 2

const uint8_t SENSOR_COUNT = 8;
const int THRESHOLD = 400; // prah medzi bielou (~40) a čiernou (~800)

void setup() {
Serial.begin(115200);
analogReadResolution(12); // 12-bitové ADC (0–4095)

pinMode(MUX_S0, OUTPUT);
pinMode(MUX_S1, OUTPUT);
pinMode(MUX_S2, OUTPUT);

Serial.println("QTR-8A + 74HC4051 OK");
}

// Prepne multiplexer na daný kanál (0–7)
void selectChannel(uint8_t channel) {
digitalWrite(MUX_S0, (channel >> 0) & 1);
digitalWrite(MUX_S1, (channel >> 1) & 1);
digitalWrite(MUX_S2, (channel >> 2) & 1);
}

void loop() {
for (uint8_t i = 0; i < SENSOR_COUNT; i++) {
selectChannel(i);
delayMicroseconds(10); // počkáme kým sa multiplexer prepne
int val = analogRead(MUX_Z);
Serial.print(val > THRESHOLD ? "1" : "0");
Serial.print("\t");
}
Serial.println();
delay(100);
}
</syntaxhighlight>

{| class="wikitable"
|-
! Novinka !! Vysvetlenie
|-
| <code>analogReadResolution(12)</code> || Nastaví ADC na 12-bitové čítanie (0–4095) – bez toho by Arduino používalo 10-bitové (0–1023)
|-
| <code>selectChannel(i)</code> || Nastaví adresu kanála cez select piny S0, S1, S2
|-
| <code>(channel >> n) & 1</code> || Bitový posun – vyextrahuje n-tý bit adresy kanála. Napr. kanál 5 = <code>101</code> → S0=1, S1=0, S2=1
|-
| <code>delayMicroseconds(10)</code> || Krátke čakanie kým sa multiplexer fyzicky prepne na nový kanál
|}

{{Note|Typické hodnoty: biely povrch ~40, čierna čiara ~800. Ak sa tvoje hodnoty líšia, uprav konštantu <code>THRESHOLD</code> na hodnotu v strede medzi tvojimi nameranými hodnotami.}}

'''VAŠA ÚLOHA:''' Naprogramujte autíčko ktoré sleduje čiaru. Čiara môže odbáčať, robiť cik-cak, rozvetvovať sa alebo tvoriť slučku. Pripojte aj VL53L0X senzor na detekciu náhodnej prekážky v ceste:

* Ak senzor detekuje prekážku bližšie ako 100 mm – autíčko zastaví a počká kým prekážka nezmizne
* Ak je cesta voľná – autíčko sleduje čiaru ďalej

[[Line sensor structure | Štruktúra]]

'''Bonus:''' Pripevnite aj gyroskop BNO055. Počas jazdy zaznamenávajte čas a uhol otočenia do súboru pomocou '''LittleFS''' – po skončení jazdy pripojíte mikrokontrolér k počítaču a súbor si stiahnete a vizualizujete.

[[Line sensor bonus structure | Štruktúra]]

[[LittleFS into| Úvod do LittleFS (jednoduchý file system)]]

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

Čo sme sa naučili?
* QTR-8A meria odrazivosť povrchu pomocou IR svetla – tmavá čiara odráža menej ako svetlý podklad.
* Multiplexer 74HC4051 nám umožnil čítať 8 analógových kanálov cez jeden ADC pin.
* Adresu kanála nastavujeme cez 3 select piny pomocou binárneho kódovania.
* <code>analogReadResolution(12)</code> nastaví 12-bitové čítanie pre väčšiu presnosť merania.

== 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 to na <code>insert mail</code>.

=== Joystick ===

Joystick ktorý ste dostali má '''2 osi''' (X a Y) a '''1 tlačidlo''' (SW – stlačenie joysticku). Funguje ako dva potenciometre – otočením v smere X alebo Y sa mení odpor a tým aj analógová hodnota na výstupe.

''' Zapojenie '''

{| class="wikitable"
|-
! Pin joysticku !! Pin na RP2350-Zero
|-
| '''VCC''' || 3.3V
|-
| '''GND''' || GND
|-
| '''VRX''' (os X) || GP26 (ADC)
|-
| '''VRY''' (os Y) || GP27 (ADC)
|-
| '''SW''' (tlačidlo) || GP6
|}

''' Kód '''

'''Vyskúšaj toto:''' Skopíruj a spusti nasledujúci program. Otvor sériový monitor (115200 baud) a pohybuj joystickom. Sleduj ako sa menia hodnoty.

<syntaxhighlight lang="C">
const int JOY_X = 26;
const int JOY_Y = 27;
const int JOY_SW = 6;

void setup() {
Serial.begin(115200);
analogReadResolution(12); // 12-bitové ADC (0–4095)
pinMode(JOY_SW, INPUT_PULLUP); // tlačidlo – aktívne LOW
}

void loop() {
int x = analogRead(JOY_X);
int y = analogRead(JOY_Y);
int sw = digitalRead(JOY_SW); // 0 = stlačené, 1 = nestlačené

Serial.print("X: "); Serial.print(x);
Serial.print(" Y: "); Serial.print(y);
Serial.print(" SW: "); Serial.println(sw == LOW ? "stlacene" : "volne");

delay(100);
}
</syntaxhighlight>

{| class="wikitable"
|-
! Novinka !! Vysvetlenie
|-
| <code>INPUT_PULLUP</code> || Aktivuje vnútorný pull-up rezistor – tlačidlo číta <code>LOW</code> keď je stlačené a <code>HIGH</code> keď nie
|-
| <code>sw == LOW</code> || Tlačidlo je aktívne LOW – stlačenie stiahne pin na GND
|}

{{Note|Stred joysticku by mal ukazovať hodnotu okolo 2048 (polovica rozsahu 0–4095). Ak je hodnota iná, joystick je mierne mimo stredu – to je normálne.}}

----

=== Touch senzor ===

Touch senzor detekuje dotyk prsta pomocou zmeny kapacitancie. Keď sa dotknete senzora, váš prst zmení elektrické pole okolo elektródy – senzor to zaznamená a vyšle digitálny signál.

''' Zapojenie '''

{| class="wikitable"
|-
! Pin senzora !! Pin na RP2350-Zero
|-
| '''VCC''' || 3.3V
|-
| '''GND''' || GND
|-
| '''SIG''' || GP7
|}

''' Kód '''

'''Vyskúšaj toto:''' Skopíruj a spusti nasledujúci program. Dotknite sa senzora prstom a sleduj zmenu v sériovom monitore.

<syntaxhighlight lang="C">
const int TOUCH_PIN = 7;

void setup() {
Serial.begin(115200);
pinMode(TOUCH_PIN, INPUT);
}

void loop() {
int val = digitalRead(TOUCH_PIN);

if (val == HIGH) {
Serial.println("Dotyk detekovaný!");
} else {
Serial.println("Žiadny dotyk");
}

delay(100);
}
</syntaxhighlight>

----

=== 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:

[[Manual | 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

[[Arm structure | Š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 na <code>insert mail</code>.

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

__notoc__

3D liga wiki - Príspevky používateľa [sk]

3D liga wiki

3D liga wiki

Prvé kolo

3D liga wiki

MediaWiki:Sidebar

MediaWiki:Sidebar

MediaWiki:Sidebar

MediaWiki:Recentchanges

MediaWiki:Sidebar

MediaWiki:Common.css

MediaWiki:Recentchanges

MediaWiki:Specialpages-url

MediaWiki:Vector.css

MediaWiki:Aboutsite

MediaWiki:About

MediaWiki:Disclaimers

MediaWiki:Privacy

MediaWiki:Mainpage-nstab

MediaWiki:Mainpage-description

MediaWiki:Mainpage