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í
Bez shrnutí editace
Sebastian (diskusia | príspevky)
248 editací
 
(73 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.


[[LED begin| program]]
[[Príprava elektroniky - hardware setup | Celkový setup elektorniky a HW súčiastok]]


''' 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:
== Príprava arduino rozhrania==


[[Image:RGB palete.jpg|350px]]  
[[Príprava programovacieho prostredia - sofrware setup | Arduino IDE setup]]


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


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


Čo sme sa naučili?
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í.
* 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) ====
''' Prehľad dielikov '''
 
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"
{| class="wikitable"
|-
|-
! Kábel !! Pin na RP2350-Zero
! Farba !! Typ dielikov !! Popis
|-
|-
| Čierny || GND
| <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)
|-
|-
| Červený || GP4
| <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.  
|}
 
[[Image:buzzer.png|250px]]
 
 
<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> V nasledujúcom linku sa nachádza program. Tento 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ť! Sleduj sériový monitor – vidíš ako sa mení frekvencia? Počuješ ako zvuk stúpa nahor?
 
[[Buzzer begin|Kód na bzučáka ]]
 
''' Klúčové pojmi '''
 
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:#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
| <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
|-
|-
| '''Digitálny (D0)''' || Vysiela iba 0 alebo 1 – buď zvuk zachytil, alebo nie
| <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).
|-
|-
| '''Analógový (A0)''' || Vysiela hodnotu podľa hlasitosti a frekvencie zvuku – čím hlasnejší zvuk, tým vyššia hodnota
| <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.
|}
|}


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


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


{| class="wikitable"
{|
|-
! Pin modulu !! Pin na RP2350-Zero
|-
|-
| '''VCC''' || 3.3V
| [[Image:Model1.png|300px]] || [[Image:Model2.png|300px]]
|-
| '''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.}}
A tu je príklad toho, čo dokázali poskladať iní účastníci – srdce len zo základných dielikov:


[[Image:ky038.png|350px]]
[[Image:srdce.jpg|300px]]


===== Časť 1 – Čítanie hodnôt z mikrofónu =====
[[Gallery | Galéria súčiastok a ich zapojenie]]


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


<syntaxhighlight lang="C">
<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!
const int MIC_DIGITAL = 5;  // digitálny výstup D0
const int MIC_ANALOG  = 26;  // analógový výstup A0 (ADC)


void setup() {
Hotovú konštrukciu '''odfotografujte''' a foto odošlite.
  pinMode(MIC_DIGITAL, INPUT);
  Serial.begin(9600);
}


void loop() {
Čo sme sa naučili?
  int digitalVal = digitalRead(MIC_DIGITAL);  // 0 alebo 1
* Spoznali sme jednotlivé typy dielikov stavebnice a ich farebné označenie.
  int analogVal  = analogRead(MIC_ANALOG);    // 0 až 4095
* 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.
  Serial.print("Digitálny: ");
  Serial.print(digitalVal);
  Serial.print("  |  Analógový: ");
  Serial.println(analogVal);
 
  delay(50);
}
</syntaxhighlight>
 
{| class="wikitable"
|-
! Funkcia !! Vysvetlenie
|-
| <code>digitalRead(pin)</code> || Prečíta stav pinu – vráti buď <code>0</code> (ticho) alebo <code>1</code> (zvuk zachytený)
|-
| <code>analogRead(pin)</code> || Prečíta analógovú hodnotu pinu – vráti číslo od <code>0</code> do <code>4095</code>
|-
| <code>delay(50)</code> || Čakáme 50 ms medzi meraniami – aby sériový monitor nescrolloval príliš rýchlo
|}
 
{{Note|Ak digitálny výstup nereaguje na zvuk, skús nastaviť citlivosť otočnou skrutkou na module. Otáčaj pomaly a sleduj zmeny v sériovom monitore.}}
 
<span style="background:#FFFFA0">'''VAŠA ÚLOHA 1:'''</span> Zapojte mikrofón spolu s bzučiakom a RGB LED zo sekcií 3 a 4. Napíšte program, ktorý bude fungovať ako '''zvukový spínač''':
 
* Keď mikrofón zachytí hlasný zvuk (napríklad tliesknutie), program '''zapne''' sirénu a blikanie LED
* Keď zachytí druhé tliesknutie, program ich '''vypne'''
* Stav (zapnuté/vypnuté) si musí program '''pamätať''' medzi tliesknutiami
 
<syntaxhighlight lang="C">
const int MIC_DIGITAL = 5;
const int BUZZER = 4;
const int PIN_R = 0;
const int PIN_G = 1;
const int PIN_B = 2;
 
bool aktivny = false;  // pamätáme si stav – zapnuté alebo vypnuté
 
void setup() {
  pinMode(MIC_DIGITAL, INPUT);
  pinMode(BUZZER, OUTPUT);
  pinMode(PIN_R, OUTPUT);
  pinMode(PIN_G, OUTPUT);
  pinMode(PIN_B, OUTPUT);
  Serial.begin(9600);
}
 
void playNote(int note) {
  // --- sem skopírujte funkciu z predchádzajúcej úlohy ---
}
 
void setColor(int r, int g, int b) {
  // --- sem skopírujte funkciu z predchádzajúcej úlohy ---
}
 
void loop() {
  // --- doplňte: ak mikrofón zachytí zvuk, prepnite stav 'aktivny' ---
 
  if (aktivny) {
    // --- doplňte: spustite sirénu a blikanie LED ---
  } else {
    // --- doplňte: vypnite bzučiak aj LED ---
  }
}
</syntaxhighlight>
 
{{Note|Nápoveda: Na zapamätanie stavu (zapnuté/vypnuté) použite premennú typu <code>bool</code>. Prepínanie medzi hodnotami <code>true</code> a <code>false</code> sa robí pomocou operátora <code>!</code> – napríklad <code>aktivny = !aktivny;</code>}}
 
Hotový program '''nahrajte do mikrokontroléra''', natočte video a odošlite na <code>insert mail</code>.
 
===== Časť 2 – Mikrofón a bzučiak spolu =====
 
Teraz si vyskúšame niečo zaujímavejšie – bzučiak a mikrofón zapojíme '''spolu''' a mikrofón bude počúvať čo bzučiak hrá.


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


[[Image:buzzer_mic_assembly.png|400px]]
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ť.


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


<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.
Na konci prvej stavebnice poskladáte autíčko ktoré sa samo vyhýba prekážkam – prvého autonómneho robota!


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


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


void playNote(int note) {
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'''.
  // --- sem skopírujte funkciu z predchádzajúcej úlohy ---
}


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


void playAndListen(int frekvencia, int trvanie) {
Použijete:
  int halfPeriod = 500000 / frekvencia;
* 2× 360° servo (kolesá)
  long startTime = millis();
* 1× 180° servo (otáčanie senzora)
* 1× HC-SR04
* 1× RGB LED modul (voliteľné)
* 1× bzučiak (voliteľné)


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


    static long lastRead = 0;
Roomba má v každom momente nejaký '''stav''' – a podľa neho sa rozhoduje čo urobiť:
    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);
# Ide rovno – ak je pred ňou voľno (> 20 cm)
  Serial.println("--- ticho ---");
# Narazila na prekážku – otočí senzor doprava a zmeria
  delay(500);
# 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


void loop() {
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í).
  for (int i = 0; i < pocetFrekvencii; i++) {
    playAndListen(frekvencie[i], 1000);
  }
}
</syntaxhighlight>


Oproti predchádzajúcemu kódu pribúdajú nové koncepty:
<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> Zostrojte Roombu a naprogramujte algoritmus podľa opisu vyššie. Dostávate štruktúru na doplnenie:


{| class="wikitable"
[[Roomba structure | Štruktúra]]
|-
! 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
<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.
# 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>.
Hotový program '''nahrajte do mikrokontroléra''', natočte krátke demonštračňé video a odošlite.
 
{{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?
* 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.
 
==== 6. 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ť.
{{Note|Rýchlosť zvuku vo vzduchu je približne '''343 metrov za sekundu''' (alebo 0,0343 cm/µs). Keďže zvuk musí prejsť vzdialenosť dvakrát (tam aj späť), výsledok delíme 2.}}
[[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''' || 3.3V
|-
| '''GND''' || GND
|-
| '''TRIG''' || GP6
|-
| '''ECHO''' || GP7
|}
[[Image:hcsr04_wiring.png|400px]]
===== Kód – meranie vzdialenosti =====
<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> 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>
===== Vysvetlenie kódu =====
{| 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 =====
<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> 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 || <span style="color:#007700">Zelená</span> || ticho
|-
| 10 – 30 cm || <span style="color:#cc6600">Žltá</span> || pomalé pípanie
|-
| < 10 cm || <span style="color:#cc0000">Červená</span> || rýchle pípanie
|}
Vzorová štruktúra programu:
<syntaxhighlight lang="C">
const int TRIG  = 6;
const int ECHO  = 7;
const int BUZZER = 4;
const int PIN_R = 0;
const int PIN_G = 1;
const int PIN_B = 2;
void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  pinMode(BUZZER, OUTPUT);
  pinMode(PIN_R, OUTPUT);
  pinMode(PIN_G, OUTPUT);
  pinMode(PIN_B, OUTPUT);
  Serial.begin(9600);
}
long measurePulse() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  return pulseIn(ECHO, HIGH);
}
void setColor(int r, int g, int b) {
  // --- sem skopírujte funkciu z predchádzajúcej úlohy ---
}
void playNote(int note) {
  // --- sem skopírujte funkciu z predchádzajúcej úlohy ---
}
void loop() {
  long trvanie = measurePulse();
  // Vzdialenosť = (čas * rýchlosť zvuku) / 2
  float vzdialenost = 0; //doplň
  Serial.print("Vzdialenosť: ");
  if (vzdialenost > 30) {
    // --- doplňte: zelená, ticho ---
  } else if (vzdialenost > 10) {
    // --- doplňte: žltá, pomalé pípanie ---
  } else {
    // --- doplňte: červená, rýchle pípanie ---
  }
}
</syntaxhighlight>
<span style="background:#FF9900">'''Bonus:'''</span>
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ť.
{{Note|Nápoveda: Rýchlosť pípania môžete ovládať hodnotou v <code>delay()</code> alebo počtom opakovaní vo funkcii <code>playNote()</code>. Čím menšia hodnota delay, tým rýchlejšie pípanie.}}
Hotový program '''nahrajte do mikrokontroléra''', natočte video a odošlite na <code>insert mail</code>.


Čo sme sa naučili?
Čo sme sa naučili?
* Ultrazvukový senzor HC-SR04 meria vzdialenosť pomocou odrazu zvuku – princíp podobný netopierom alebo parkovacím senzorom áut.
* Komplexnejšie správanie robota sa dá rozložiť na jednoduché stavy a prechody medzi nimi.
* Funkcia <code>pulseIn()</code> meria čas trvania signálu na pine v mikrosekundách.
* 180° servo vie presne namieriť senzor na konkrétny uhol – využili sme ho ako "hlavu" robota.
* Dátový typ <code>float</code> používame vtedy, keď potrebujeme pracovať s desatinnými číslami.
* Kombináciou všetkých komponentov vieme postaviť autonómneho robota schopného orientovať sa v priestore.
* Nie každý materiál odráža ultrazvuk rovnako – mäkké povrchy ho môžu pohltiť.
 
 
==== 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.}}
== Druhá stavebnica ==


<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?
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.
 
<syntaxhighlight lang="C">
#include <Servo.h>
 
#define SERVO_PIN 12
 
Servo servo;
String inputString = "";
int position = 90;
 
void setup() {
  Serial.begin(115200);
  servo.attach(SERVO_PIN, 500, 2500);
  servo.write(position);
  Serial.println("Zadajte uhol (0-180) a stlačte Enter:");
}
 
void loop() {
  while (Serial.available()) {
    char c = Serial.read();
    if (c == '\n') {
      position = inputString.toInt();
      if (position >= 0 && position <= 180) {
        servo.write(position);
        Serial.print("Servo nastavené na uhol: ");
        Serial.println(servo.read());
      } else {
        Serial.println("Neplatná pozícia – zadajte číslo od 0 do 180");
      }
      inputString = "";
    } else {
      inputString += c;
    }
  }
  delay(50);
}
</syntaxhighlight>
 
{| class="wikitable"
|-
! Novinka !! Vysvetlenie
|-
| <code>#include <Servo.h></code> || Načítame knižnicu pre ovládanie serva – bez nej by sme museli impulzy generovať ručne
|-
| <code>servo.attach(pin, 500, 2500)</code> || Pripojíme servo na pin a definujeme rozsah impulzov (500–2500 µs)
|-
| <code>servo.write(uhol)</code> || Nastavíme servo na požadovaný uhol (0–180°)
|-
| <code>inputString.toInt()</code> || Prevedie textový reťazec na celé číslo – napr. <code>"120"</code> → <code>120</code>
|}
 
<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> Zostrojte autíčko z dvoch '''360° servo motorčekov''', guličky (ako tretie koleso) a ultrazvukového senzora. Ultrazvuk upevnite na predok. Naprogramujte '''poslušného psíčka''' – autíčko sleduje objekt pred sebou:
 
{| class="wikitable"
|-
! Vzdialenosť !! Správanie
|-
| > 30 cm || Ide vpred – ide za páničkom
|-
| 10 – 30 cm || Stojí – páničko je na ideálnej vzdialenosti
|-
| < 10 cm || Ide vzad – páničko je príliš blízko
|}


<syntaxhighlight lang="C">
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“