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í
 
(82 medziľahlých úprav od 2 ďalších používateľov nie je zobrazených)
Riadok 1: Riadok 1:
=== Prva stavebnica ===


==== 3. RGB LED modul ====
=== Vitajte v prvom kole 3D ligy! ===


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


[[Image:Rgb-led-module.jpg|300px]]
==== Pravidlá prípravy ====


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.
Pre začiatok na setupnutie si vlastnej stavebnice budeme musiet si pripravit:


Modul má '''4 piny''':
- Hadrver
- Softver


{| class="wikitable"
== Príprava hardvéru ==  
|-
! 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 =====
 
<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> 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]]


<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.
[[Príprava elektroniky - hardware setup | Celkový setup elektorniky a HW súčiastok]]


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


Čo sme sa naučili?
== Príprava arduino rozhrania==
* 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>.


==== 4. Bzučiak (Buzzer) ====
[[Príprava programovacieho prostredia - sofrware setup | Arduino IDE setup]]


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


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


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


===== Zapojenie =====
''' Prehľad dielikov '''


{| class="wikitable"
{| class="wikitable"
|-
|-
! Kábel !! Pin na RP2350-Zero
! Farba !! Typ dielikov !! Popis
|-
| Čierny || GND
|-
|-
| Červený || GP4
| <span style="background:#e8e8e8; padding:2px 8px;">'''Biela'''</span> || 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)
|}
 
[[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);
}
 
// 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
| <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.
|-
|-
| '''Frekvencia''' || Počet kmitov za sekundu, udáva sa v Hz. Vyššia frekvencia = vyšší tón.
| <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
|-
|-
| '''Perióda''' || Čas jedného celého kmitu (zapnutie + vypnutie). Perióda = 1 000 000 / frekvencia µs.
| <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).
|-
|-
| '''Polovica periódy''' || Čas, ktorý pin strávi v stave HIGH (alebo LOW). Vypočítame ju ako 500 000 / frekvencia.
| <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.
|-
| <code>delayMicroseconds()</code> || Rovnaké ako <code>delay()</code>, ale čaká v '''mikrosekundách''' namiesto milisekúnd.
|}
|}


Napríklad pre tón 1000 Hz:
''' Inšpirácia '''
* 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'''.
Pozri si tieto dva modely a nechaj sa inšpirovať – čo všetko sa dá z dielikov poskladať:


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
| [[Image:Model1.png|300px]] || [[Image:Model2.png|300px]]
|}
|}


Citlivosť mikrofónu sa dá nastaviť '''otočnou skrutkou''' na modrej krabičke priamo na module.
A tu je príklad toho, čo dokázali poskladať iní účastníci – srdce len zo základných dielikov:


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


{| class="wikitable"
[[Gallery | Galéria súčiastok a ich zapojenie]]
|-
! Pin modulu !! Pin na RP2350-Zero
|-
| '''VCC''' || 3.3V
|-
| '''GND''' || GND
|-
| '''D0''' (digitálny výstup) || GP5
|-
| '''A0''' (analógový výstup) || GP26 (ADC0)
|}


{{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.}}
''' Zadanie '''


[[Image:ky038.png|350px]]
<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!


===== Časť 1 – Čítanie hodnôt z mikrofónu =====
Hotovú konštrukciu '''odfotografujte''' a foto odošlite.


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


<syntaxhighlight lang="C">
== Prva stavebnica ==
const int MIC_DIGITAL = 5;  // digitálny výstup D0
const int MIC_ANALOG  = 26;  // analógový výstup A0 (ADC)


void setup() {
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ť.
  pinMode(MIC_DIGITAL, INPUT);
  Serial.begin(9600);
}


void loop() {
Budeme sa zaoberať:
  int digitalVal = digitalRead(MIC_DIGITAL);  // 0 alebo 1
* '''RGB LED''' – farebná dióda na vizuálnu signalizáciu
  int analogVal  = analogRead(MIC_ANALOG);    // 0 až 4095
* '''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


  Serial.print("Digitálny: ");
Na konci prvej stavebnice poskladáte autíčko ktoré sa samo vyhýba prekážkam – prvého autonómneho robota!
  Serial.print(digitalVal);
  Serial.print("  |  Analógový: ");
  Serial.println(analogVal);


  delay(50);
----
}
</syntaxhighlight>


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


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


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á.
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é)


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


[[Image:buzzer_mic_assembly.png|400px]]
Roomba má v každom momente nejaký '''stav''' – a podľa neho sa rozhoduje čo urobiť:


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


<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.
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í).
 
<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:
<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> Zostrojte Roombu a naprogramujte algoritmus podľa opisu vyššie. Dostávate štruktúru na doplnenie:


# Spustite program a sledujte hodnoty v sériovom monitore
[[Roomba structure | Štruktúra]]
# 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>.
<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.


{{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.}}
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?
* 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.
* Komplexnejšie správanie robota sa dá rozložiť na jednoduché stavy a prechody medzi nimi.
* Funkcia <code>millis()</code> umožňuje merať čas bez blokovania programu – na rozdiel od <code>delay()</code>.
* 180° servo vie presne namieriť senzor na konkrétny uhol – využili sme ho ako "hlavu" robota.
* Pole (<code>int frekvencie[]</code>) je užitočný spôsob ako uložiť viacero hodnôt a prechádzať cez ne cyklom.
* Kombináciou všetkých komponentov vieme postaviť autonómneho robota schopného orientovať sa v priestore.
* 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() {
== Druhá stavebnica ==
  Serial.begin(115200);
  servo.attach(SERVO_PIN, 500, 2500);
  servo.write(position);
  Serial.println("Zadajte uhol (0-180) a stlačte Enter:");
}


void loop() {
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.
  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">
Budeme sa zaoberať:
#include <Servo.h>
* '''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


const int TRIG      = 6;
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.
const int ECHO      = 7;
----
#define SERVO_LAVY  12
#define SERVO_PRAVY  13


Servo servoLavy;
== Tretia stavebnica ==
Servo servoPravy;


void setup() {
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.
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  servoLavy.attach(SERVO_LAVY, 500, 2500);
  servoPravy.attach(SERVO_PRAVY, 500, 2500);
  stoj();
  Serial.begin(9600);
}


long measurePulse() {
Ak nájdete chyby v návode, prosíme napíšte nám ich pri odovzdávaní výsledkov.
  // --- skopírujte z predchádzajúcej úlohy ---
}


void stoj() {
=== Robotické rameno ===
  servoLavy.write(90);
  servoPravy.write(90);
}


void vpred() {
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).
  // --- doplňte ---
  // Nápoveda: ľavé a pravé koleso sú zrkadlovo otočené!
}


void vzad() {
Rameno pozostáva z niekoľkých servo motorčekov ktoré ovládajú jednotlivé kĺby – podobne ako ľudská ruka.
  // --- doplňte ---
}


void loop() {
Postavte rameno podľa návodu:
  long trvanie = measurePulse();
  float vzdialenost = 0; // --- doplňte výpočet ---


  Serial.print("Vzdialenosť: ");
[[Manual |  Návod na skladanie ramena]]
  Serial.print(vzdialenost);
  Serial.println(" cm");


  if (vzdialenost > 30) {
''' Vaša úloha '''
    // --- doplňte ---
  } else if (vzdialenost > 10) {
    // --- doplňte ---
  } else {
    // --- doplňte ---
  }


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


<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>:
[[Arm structure | Štruktúra]]


<syntaxhighlight lang="C">
<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á.
// 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>.
Hotové rameno '''natočte pri práci''' a video odošlite.


Čo sme sa naučili?
Čo sme sa naučili?
* Servo motorček ovládame pomocou knižnice <code>Servo.h</code> a funkcie <code>servo.write()</code>.
* Joystick kombinuje dva potenciometre a tlačidlo – os X a Y dávajú analógovú hodnotu 0–4095.
* 180° servo nastavuje presnú polohu, 360° servo ovláda smer a rýchlosť otáčania.
* Touch senzor detekuje dotyk bez mechanického tlačidla – využíva zmenu kapacitancie.
* Pri dvoch kolesách namontovaných oproti sebe musia servá ísť opačnými smermi aby sa autíčko pohybovalo rovno.
* Robotické rameno kombinuje všetky doterajšie znalosti – servo motorčeky, joystick aj touch senzor.
* Funkcia <code>map()</code> umožňuje previesť hodnotu z jedného rozsahu do druhého.

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“