Prvé kolo - História úprav

Sebastian: /* Touch senzor */

2026-08-02T11:21:34Z

Touch senzor

← Staršia verzia		Verzia z 11:21, 2. august 2026
Riadok 144:		Riadok 144:

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

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

	~~<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> 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 ===		=== Robotické rameno ===

Sebastian: /* Joystick */

2026-08-02T11:08:10Z

Joystick

← Staršia verzia		Verzia z 11:08, 2. august 2026
Riadok 144:		Riadok 144:

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

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

	~~<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> 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 ===

Sebastian: /* Line senzor + multiplexer */

2026-08-01T13:28:53Z

Line senzor + multiplexer

Zobraziť rozdiely

Sebastian: /* Gyroskop BNO055 */

2026-07-26T14:39:49Z

Gyroskop BNO055

Zobraziť rozdiely

Sebastian: /* VL53L0X senzor */

2026-07-26T14:37:23Z

VL53L0X senzor

← Staršia verzia		Verzia z 14:37, 26. júl 2026
Riadok 137:		Riadok 137:

	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.		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~~
	\|}


	~~''' Kód '''~~

	~~<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> 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].~~

	~~<!--{{Note\|Na rozdiel od HC-SR04, VL53L0X vracia vzdialenosť priamo v '''milimetroch''' – nie je potrebný žiadny prepočet.}}-->~~

	<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> 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]]~~

	<span style="background:#FF9900">'''Bonus:'''</span> 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.

	<!--{{Note\|Nápoveda: Každý I2C senzor má svoju adresu. Ak zapojíte viac rovnakých senzorov, budú mať rovnakú adresu a budú si navzájom prekážať. VL53L0X umožňuje adresu zmeniť cez pin XSHUT – skúste vyhľadať ako na to.}}-->

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

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

	----		----

Sebastian: /* Servo motorček */

2026-07-26T13:02:14Z

Servo motorček

← Staršia verzia		Verzia z 13:02, 26. júl 2026
Riadok 85:		Riadok 85:

	----		----

	~~=== Servo motorček ===~~

	~~Dostali ste dva druhy servo motorčekov: '''180°''' a '''360°'''. Oba fungujú na rovnakom princípe ovládania, ale majú rozdielne vlastnosti:~~

	~~{\| class="wikitable"~~
	\|-
	~~! Typ !! Správanie~~
	\|-
	~~\| '''180° servo''' \|\| Nastaví sa na presnú pozíciu (napr. 0°, 90°, 180°) a tam zostane~~
	\|-
	~~\| '''360° servo''' \|\| Namiesto pozície ovládate '''smer a rýchlosť''' otáčania – hodnota 90° = stoj, pod 90° = jedna strana, nad 90° = druhá strana~~
	\|}

	~~Servo dostáva riadiace impulzy v rozsahu '''500–2500 µs''', ktoré dekóduje ako požadovanú pozíciu alebo smer otáčania. Zapojte servo na pin '''GP12'''.~~

	~~<!--{{Note\|Ak servo pri pohybe spôsobuje reštart mikrokontroléra, je odberané priveľa prúdu. V takom prípade napájajte servo samostatne a spojte iba GND.}}-->~~

	<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> Nahrajte nasledujúci program. Otvorte sériový monitor (115200 baud), zadajte číslo od 0 do 180 a stlačte Enter. Vyskúšajte si to najprv s 180° servom, potom s 360°. Čo si všimnete?

	~~<syntaxhighlight lang="C">~~
	~~#include <Servo.h>~~

	~~#define SERVO_PIN 12~~

	~~Servo servo;~~
	~~String inputString = "";~~
	~~int position = 90;~~

	~~void setup() {~~
	~~Serial.begin(115200);~~
	~~servo.attach(SERVO_PIN, 500, 2500);~~
	~~servo.write(position);~~
	~~Serial.println("Zadajte uhol (0-180) a stlačte Enter:");~~
	}

	~~void loop() {~~
	~~while (Serial.available()) {~~
	~~char c = Serial.read();~~
	~~if (c == '\n') {~~
	~~position = inputString.toInt();~~
	~~if (position >= 0 && position <= 180) {~~
	~~servo.write(position);~~
	~~Serial.print("Servo nastavené na uhol: ");~~
	~~Serial.println(servo.read());~~
	~~} else {~~
	~~Serial.println("Neplatná pozícia – zadajte číslo od 0 do 180");~~
	}
	~~inputString = "";~~
	~~} else {~~
	~~inputString += c;~~
	}
	}
	~~delay(50);~~
	}
	~~</syntaxhighlight>~~

	~~{\| class="wikitable"~~
	\|-
	~~! Novinka !! Vysvetlenie~~
	\|-
	~~\| <code>#include <Servo.h></code> \|\| Načítame knižnicu pre ovládanie serva – bez nej by sme museli impulzy generovať ručne~~
	\|-
	~~\| <code>servo.attach(pin, 500, 2500)</code> \|\| Pripojíme servo na pin a definujeme rozsah impulzov (500–2500 µs)~~
	\|-
	~~\| <code>servo.write(uhol)</code> \|\| Nastavíme servo na požadovaný uhol (0–180°)~~
	\|-
	~~\| <code>inputString.toInt()</code> \|\| Prevedie textový reťazec na celé číslo – napr. <code>"120"</code> → <code>120</code>~~
	\|}

	<span style="background:#FFFFA0">'''VAŠA ÚLOHA:'''</span> Zostrojte autíčko z dvoch '''360° servo motorčekov''', guličky (ako tretie koleso) a ultrazvukového senzora. Ultrazvuk upevnite na predok. Naprogramujte '''poslušného psíčka''' – autíčko sleduje objekt pred sebou:

	~~{\| class="wikitable"~~
	\|-
	~~! Vzdialenosť !! Správanie~~
	\|-
	~~\| > 30 cm \|\| Ide vpred – ide za páničkom~~
	\|-
	~~\| 10 – 30 cm \|\| Stojí – páničko je na ideálnej vzdialenosti~~
	\|-
	~~\| < 10 cm \|\| Ide vzad – páničko je príliš blízko~~
	\|}

	~~[[Servo structure \| Štruktúra]]~~

	<!--{{Note\|Nápoveda: Keďže ľavé a pravé koleso sú namontované oproti sebe, musia sa otáčať '''opačným smerom''' aby autíčko išlo rovno. Ak jedno servo ide na hodnotu 70, druhé musí ísť na 110.}}-->

	<span style="background:#FF9900">'''Bonus:'''</span> Upravte program tak, aby sa psíček pohyboval '''proporcionálne''' – čím ďalej je objekt, tým rýchlejšie autíčko ide. Na škálovanie hodnôt sa vám môže hodiť funkcia [//docs.arduino.cc/language-reference/en/functions/math/map/ <code>map()</code>]


	~~Hotový program '''nahrajte do mikrokontroléra''', natočte video a odošlite.~~

	~~Č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 ===		=== Roomba ===

Sebastian: /* Ultrazvukový senzor */

2026-07-26T12:53:49Z

Ultrazvukový senzor

← Staršia verzia		Verzia z 12:53, 26. júl 2026
Riadok 83:		Riadok 83:

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

	~~----~~

	~~=== 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''' \|\| 5V~~
	\|-
	~~\| '''GND''' \|\| GND~~
	\|-
	~~\| '''TRIG''' \|\| GP6~~
	\|-
	~~\| '''ECHO''' \|\| GP7~~
	\|}

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

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

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

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

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

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

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

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

	----		----

Sebastian: /* Mikrofón */

2026-07-26T12:48:20Z

Mikrofón

Zobraziť rozdiely

Sebastian: /* Bzučiak (Buzzer) */

2026-07-26T09:05:12Z

Bzučiak (Buzzer)

← Staršia verzia		Verzia z 09:05, 26. júl 2026
Riadok 83:		Riadok 83:

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

	~~----~~

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

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

	~~[[Buzzer structure\|Štruktúra]]~~

	<!--{{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 krátke video so zvukom a ukážte.~~

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

	----		----

Sebastian: /* RGB LED modul */

2026-07-25T11:33:48Z

RGB LED modul

← Staršia verzia		Verzia z 11:33, 25. júl 2026
Riadok 83:		Riadok 83:

	Na konci prvej stavebnice poskladáte autíčko ktoré sa samo vyhýba prekážkam – prvého autonómneho robota!		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: <span style="color:#cc0000">'''červenú (R)'''</span>, <span style="color:#007700">'''zelenú (G)'''</span> a <span style="color:#0000cc">'''modrú (B)'''</span>. Miešaním intenzity týchto troch farieb vieme dosiahnuť akýkoľvek odtieň.

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

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

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

	~~Hotový program '''nahrajte do mikrokontroléra''', zaznamenajte blikajúcu LED a ukážte.~~

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

	----		----