3D liga wiki - Posledné úpravy [sk]

Príprava elektroniky - hardware setup

Sebastian — Sun, 02 Aug 2026 11:25:17 GMT

Ostatné / pomocné obvody

@@ Riadok 54: / Riadok 54: @@
 |-
 | [[Analogovy joystick - manual|Analógový joystick]] || Manuálne ovládanie (vstup)
 |}

Dotykovy senzor - manual

Sebastian — Sun, 02 Aug 2026 11:24:35 GMT

Vytvorená stránka „=== Touch senzor === Touch senzor detekuje dotyk prsta pomocou zmeny kapacitancie. Keď sa dotknete senzora, váš prst zmení elektrické pole okolo elektródy – senzor to zaznamená a vyšle digitálny signál. ''' Zapojenie ''' {| class="wikitable" |- ! Pin senzora !! Pin na RP2350-Zero |- | '''VCC''' || 3.3V |- | '''GND''' || GND |- | '''SIG''' || GP7 |} ''' Kód ''' '''Vyskúšaj toto:''' Skopíruj a spusti nasled…“

Nová stránka

=== Touch senzor ===

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

''' Zapojenie '''

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

''' Kód '''

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

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

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

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

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

delay(100);
}
</syntaxhighlight>

----

Multiplexor 74HC4051 - manual

Sebastian — Sun, 02 Aug 2026 11:22:22 GMT

Nová stránka

Prvé kolo

Sebastian — Sun, 02 Aug 2026 11:21:34 GMT

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

Analogovy joystick - manual

Sebastian — Sun, 02 Aug 2026 11:09:41 GMT

Vytvorená stránka „=== 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) ||…“

Nová stránka

=== Joystick ===

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

''' Zapojenie '''

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

''' Kód '''

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

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

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

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

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

delay(100);
}
</syntaxhighlight>

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

Prvé kolo

Sebastian — Sun, 02 Aug 2026 11:08:10 GMT

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

Ciarovy senzor QRT-8A a multiplexer - manual

Sebastian — Sat, 01 Aug 2026 13:35:14 GMT

Line senzor + multiplexer

← Staršia verzia		Verzia z 13:35, 1. august 2026
Riadok 42:		Riadok 42:
	''' Kód '''		''' Kód '''

	<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> Skopíruj a spusti nasledujúci program. Otvor sériový monitor (115200 baud) a pomaly pohybuj senzorom nad čiernou čiarou na bielom podklade.		<span style="background:#CCFFCC">'''Vyskúšaj toto:'''</span> Skopíruj a spusti nasledujúci program. Otvor sériový monitor (115200 baud) a pomaly pohybuj senzorom '''3mm''' nad čiernou čiarou na bielom podklade.

	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">

Ciarovy senzor QRT-8A a multiplexer - manual

Sebastian — Sat, 01 Aug 2026 13:33:59 GMT

Vytvorená stránka „=== Line senzor + multiplexer === Dostali ste modul zložený z '''QTR-8A''' line senzora a '''74HC4051''' multiplexera. QTR-8A obsahuje 8 infračervených snímačov odrazivosti – každý meria koľko infračerveného svetla sa odrazí od povrchu. Tmavá čiara odráža menej ako svetlý podklad. Senzor nemá indikačnú LED, takže navonok nevidno či dostáva napájanie. Pre najlepší účinok IR senzorov ich treba zapojiť do 5V (IR pin). ''' Prečo pot…“

Nová stránka

=== Line senzor + multiplexer ===

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

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

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

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

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

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

''' Zapojenie '''

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

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

''' Kód '''

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

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

const uint8_t SENSOR_COUNT = 8;
const int THRESHOLD = 400;

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

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

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

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

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

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

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

Príprava elektroniky - hardware setup

Sebastian — Sat, 01 Aug 2026 13:29:42 GMT

Senzory

← Staršia verzia		Verzia z 13:29, 1. august 2026
Riadok 33:		Riadok 33:
	\| [[Gyroskop BNO055 - manual\|Gyroskop BNO055]] \|\| Meranie orientácie a pohybu		\| [[Gyroskop BNO055 - manual\|Gyroskop BNO055]] \|\| Meranie orientácie a pohybu
	\|-		\|-
	\| [[Ciarovy senzor QRT-8A - manual\|Čiarový senzor QRT-8A]] \|\| Detekcia čiary pre line-following		\| [[Ciarovy senzor QRT-8A a multiplexer - manual\|Čiarový senzor QRT-8A + multiplexer]] \|\| Detekcia čiary pre line-following
	\|}		\|}

Prvé kolo

Sebastian — Sat, 01 Aug 2026 13:28:53 GMT

Line senzor + multiplexer

Zobraziť rozdiely

I2C protokol

Sebastian — Sun, 26 Jul 2026 14:50:20 GMT

Vytvorená stránka „=== I2C === Späť k zoznamu Viacero súčiastok v stavebnici (napr. senzor vzdialenosti VL53L0X, gyroskop BNO055) komunikuje s mikrokontrolérom cez zbernicu '''I2C'''. Táto stránka vysvetľuje, ako I2C funguje, aby ste vždy vedeli, prečo zapájame práve tieto piny a čo znamená "adresa" zariadenia. ==== Ako I2C funguje ==== I2C (Inter-Integrated Circuit) je spôsob komunikácie, kde môže na '''jednej dvojici vo…“

Nová stránka

=== I2C ===
[[Príprava elektroniky - hardware setup|Späť k zoznamu]]

Viacero súčiastok v stavebnici (napr. senzor vzdialenosti VL53L0X, gyroskop BNO055) komunikuje s mikrokontrolérom cez zbernicu '''I2C'''. Táto stránka vysvetľuje, ako I2C funguje, aby ste vždy vedeli, prečo zapájame práve tieto piny a čo znamená "adresa" zariadenia.

==== Ako I2C funguje ====
I2C (Inter-Integrated Circuit) je spôsob komunikácie, kde môže na '''jednej dvojici vodičov''' komunikovať viacero zariadení naraz:
* '''SDA''' (Serial Data) – vodič, po ktorom sa prenášajú samotné dáta
* '''SCL''' (Serial Clock) – vodič s hodinovým signálom, ktorý synchronizuje, kedy sa dáta čítajú

Mikrokontrolér je v tejto komunikácii zvyčajne '''master''' (riadi komunikáciu) a jednotlivé senzory sú '''slave''' zariadenia (odpovedajú, keď sú oslovené). Keďže na tých istých dvoch vodičoch môže "počúvať" viacero zariadení, každé z nich má svoju jedinečnú '''I2C adresu''' (napr. VL53L0X má z výroby adresu <code>0x29</code>) – mikrokontrolér ňou určí, s ktorým zariadením práve komunikuje.

''Poznámka:'' ak by ste chceli pripojiť viacero zariadení s '''rovnakou''' adresou (napr. dva rovnaké senzory), musíte ich vedieť od seba odlíšiť – zvyčajne cez extra pin (napr. XSHUT), ktorým jedno zariadenie dočasne vypnete a druhému priradíte inú adresu.

==== Zapojenie ====
Na RP2350-Zero používame v našich manuáloch tieto piny pre I2C:
{| class="wikitable"
|-
! Pin zariadenia !! Pin na RP2350-Zero
|-
| '''VCC''' || 3.3V
|-
| '''GND''' || GND
|-
| '''SDA''' || GP4
|-
| '''SCL''' || GP5
|}

==== Kód – I2C scanner ====
'''Vyskúšaj toto:''' Ak si nie ste istí, či je senzor správne zapojený, alebo neviete jeho presnú adresu, nahrajte tento program. Prejde všetky možné adresy a vypíše, na ktorých našiel odpovedajúce zariadenie.

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

void setup() {
Serial.begin(115200);
Wire.setSDA(4); // GP4
Wire.setSCL(5); // GP5
Wire.begin();
Serial.println("I2C scanner spusteny");
}

void loop() {
byte count = 0;
for (byte address = 1; address < 127; address++) {
Wire.beginTransmission(address);
if (Wire.endTransmission() == 0) {
Serial.print("Zariadenie najdene na adrese 0x");
Serial.println(address, HEX);
count++;
}
}
if (count == 0) {
Serial.println("Ziadne zariadenie nenajdene");
}
delay(2000);
}
</syntaxhighlight>

{| class="wikitable"
|-
! Novinka !! Vysvetlenie
|-
| <code>Wire.beginTransmission(address)</code> || Skúsi začať komunikáciu so zariadením na danej adrese
|-
| <code>Wire.endTransmission()</code> || Ukončí pokus o komunikáciu – vráti <code>0</code>, ak zariadenie na danej adrese odpovedalo
|}

Čo sme sa naučili?
* I2C umožňuje viacerým zariadeniam komunikovať cez rovnaké dva vodiče (SDA, SCL).
* Každé zariadenie na zbernici má svoju jedinečnú adresu, podľa ktorej ho mikrokontrolér oslovuje.
* Pomocou I2C scanneru vieme rýchlo overiť, či je senzor správne zapojený a akú má adresu.

Gyroskop BNO055 - manual

Sebastian — Sun, 26 Jul 2026 14:48:12 GMT

Vytvorená stránka „=== Gyroskop BNO055 === Doteraz sme jazdili rovno bez toho, aby samotné autíčko vedelo, že ide rovno. Na to nám pomôže '''gyroskop''' – senzor ktorý zaznamenáva otáčanie v troch osiach: X, Y a Z. My budeme zatiaľ využívať os '''Z''', ktorá zaznamenáva otáčanie doprava a doľava. Na rozdiel od predchádzajúcich senzorov, gyroskop musíme pred použitím '''skalibrovať''' – teda nechať ho chvíľu v pokoji, aby si zaznamenal svoju počiato…“

Nová stránka

=== Gyroskop BNO055 ===

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

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

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

''' Zapojenie '''

Senzor komunikuje cez zbernicu [[ I2C protokol | '''I2C''' ]] – rovnako ako VL53L0X:

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

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



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

Adafruit_BNO055 bno;
bool active = false;

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

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

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

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

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

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

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

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

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

Čo sme sa naučili?
* Gyroskop BNO055 meria rotáciu v troch osiach – os Z sleduje otáčanie doprava/doľava.
* Eulerove uhly vyjadrujú orientáciu objektu v priestore pomocou troch čísel.

Prvé kolo

Sebastian — Sun, 26 Jul 2026 14:39:49 GMT

Gyroskop BNO055

Zobraziť rozdiely

Laser senzor VL53L0X - manual

Sebastian — Sun, 26 Jul 2026 14:37:07 GMT

Vytvorená stránka „=== VL53L0X senzor manuál === Späť k zoznamu 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…“

Nová stránka

=== VL53L0X senzor manuál ===
[[Príprava elektroniky - hardware setup|Späť k zoznamu]]

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.

<gallery mode="packed" heights="180">
Image:VL53L0X.jpg|VL53L0X senzor
Image:VL53L0X_soldered.jpg|Naspájkovaný VL53L0X senzor
Image:VL53L0X_box.jpg|Vytlačiteľná krabička pre VL53L0X
</gallery>

==== 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 ====
'''Vyskúšaj toto:''' Skopíruj a spusti nasledujúci program. Otvor sériový monitor (115200 baud) a pohybuj rukou pred senzorom.

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

VL53L0X sensor;

void setup() {
Serial.begin(115200);
Wire.setSDA(4); // GP4
Wire.setSCL(5); // GP5
Wire.begin();
if (!sensor.init()) {
Serial.println("Senzor nenájdený!");
while (1); // zastav program
}
sensor.setTimeout(500);
sensor.startContinuous();
Serial.println("VL53L0X OK");
}

void loop() {
int dist = sensor.readRangeContinuousMillimeters();
if (sensor.timeoutOccurred()) {
Serial.println("Timeout!");
} else {
Serial.print("Vzdialenosť: ");
Serial.print(dist);
Serial.println(" mm");
}
delay(100);
}
</syntaxhighlight>

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

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



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

Servo SG90 - manual

Sebastian — Sun, 26 Jul 2026 14:00:10 GMT

Servo motorček - manual

← Staršia verzia		Verzia z 14:00, 26. júl 2026
Riadok 1:		Riadok 1:
	=== Servo motorček - manual ===		=== Servo motorček - manual ===

			[[Príprava elektroniky - hardware setup \| Späť k zoznamu]]

	Dostali ste dva druhy servo motorčekov: '''180°''' a '''360°'''. Oba vyzerajú takmer rovnako a ovládajú sa rovnakým spôsobom, ale výsledné správanie je odlišné.		Dostali ste dva druhy servo motorčekov: '''180°''' a '''360°'''. Oba vyzerajú takmer rovnako a ovládajú sa rovnakým spôsobom, ale výsledné správanie je odlišné.

	<gallery mode="packed" heights="180">		<gallery mode="packed" heights="180">
	Image:Servo-180-model.jpg\|Servo motorček 180°		Image:Servo-180-model.jpg\|Servo motorček 180°/360°
	Image:Servo-~~360~~-model.jpg\|~~Servo motorček 360°~~		Image:Servo-drziaky-model.jpg\|Vytlačiteľné držiaky pre servo
	Image:Servo-~~drziak~~.jpg\|~~Vytlačiteľný držiak~~ pre servo		Image:Servo-boxe.jpg\|Vytlačiteľné boxe pre servo
	</gallery>		</gallery>

Servo SG90 - manual

Sebastian — Sun, 26 Jul 2026 13:57:53 GMT

Vytvorená stránka „=== Servo motorček - manual === Dostali ste dva druhy servo motorčekov: '''180°''' a '''360°'''. Oba vyzerajú takmer rovnako a ovládajú sa rovnakým spôsobom, ale výsledné správanie je odlišné. <gallery mode="packed" heights="180"> Image:Servo-180-model.jpg|Servo motorček 180° Image:Servo-360-model.jpg|Servo motorček 360° Image:Servo-drziak.jpg|Vytlačiteľný držiak pre servo </gallery> ==== Ako servo funguje ==== Servo motorček neriadime pria…“

Nová stránka

=== Servo motorček - manual ===
Dostali ste dva druhy servo motorčekov: '''180°''' a '''360°'''. Oba vyzerajú takmer rovnako a ovládajú sa rovnakým spôsobom, ale výsledné správanie je odlišné.

<gallery mode="packed" heights="180">
Image:Servo-180-model.jpg|Servo motorček 180°
Image:Servo-360-model.jpg|Servo motorček 360°
Image:Servo-drziak.jpg|Vytlačiteľný držiak pre servo
</gallery>

==== Ako servo funguje ====
Servo motorček neriadime priamo napätím ako obyčajný motorček, ale sériou opakovaných '''elektrických impulzov'''. Každých približne 20 ms príde jeden krátky impulz, ktorého '''dĺžka (v mikrosekundách)''' hovorí servu, čo má urobiť:
* Impulz okolo '''1500 µs''' zodpovedá strednej pozícii (90°).
* Kratší impulz (bližšie k '''500 µs''') posunie servo k jednému kraju.
* Dlhší impulz (bližšie k '''2500 µs''') posunie servo k druhému kraju.

Vnútri serva je malý riadiaci obvod, ktorý dĺžku impulzu neustále porovnáva so skutočnou polohou hriadeľa (tú sníma potenciometer) a podľa výsledku dobieha motorček do správnej polohy. Práve toto priebežné porovnávanie je dôvod, prečo servo dokáže polohu aj '''držať''' – ak ho niekto rukou pohne, samo sa vráti späť.

Rozdiel medzi typmi je v tom, čo sa vo vnútri serva deje s týmto signálom:
{| class="wikitable"
|-
! Typ !! Správanie
|-
| '''180° servo''' || Riadiaci obvod polohu skutočne obmedzuje – servo sa nastaví na presnú pozíciu (napr. 0°, 90°, 180°) a tam zostane
|-
| '''360° servo''' || Obmedzenie polohy je odstránené – servo namiesto pozície interpretuje signál ako '''smer a rýchlosť''' otáčania: hodnota 90° = stoj, pod 90° = točenie na jednu stranu, nad 90° = točenie na druhú stranu (čím ďalej od 90°, tým rýchlejšie)
|}

Servo dostáva riadiace impulzy v rozsahu '''500–2500 µs'''. Zapojte servo na pin '''GP12'''.



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

<syntaxhighlight lang="C">
#include <Servo.h>
#define SERVO_PIN 12

Servo servo;
int position = 90;
//int impulz = 1500;

void setup() {
Serial.begin(115200);
servo.attach(SERVO_PIN, 500, 2500);
servo.write(position);
//servo.writeMicroseconds(impulz);
Serial.print("Motor je na pozicii: ");
Serial.println(servo.read(SERVO_PIN));
}

void loop() {
}
</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>servo.writeMicroseconds(impulz)</code> || Alternatíva k <code>write()</code> – dĺžku impulzu (v µs) nastavíme priamo, bez prepočtu na uhol. Riadok je v kóde zakomentovaný, môžete si ho vyskúšať namiesto <code>servo.write()</code>

|}

Čo sme sa naučili?
* Servo motorček ovládame pomocou knižnice <code>Servo.h</code> a funkcií <code>servo.write()</code> a <code>servo.writeMicroseconds()</code>.
* Poloha serva je zakódovaná v dĺžke opakovaného impulzu (500–2500 µs).
* 180° servo nastavuje presnú polohu, 360° servo ovláda smer a rýchlosť otáčania.
* <code>servo.read(SERVO_PIN)</code> zistí, aký smer/pozíciu má servo.

Prvé kolo

Sebastian — Sun, 26 Jul 2026 13:02:14 GMT

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

Pasivny bzuciak - manual

Sebastian — Sun, 26 Jul 2026 13:00:50 GMT

Bzučiak (Buzzer)

← Staršia verzia		Verzia z 13:00, 26. júl 2026
Riadok 1:		Riadok 1:
	=== Bzučiak (Buzzer) ===		=== Bzučiak (Buzzer) ===

			[[Príprava elektroniky - hardware setup \| Späť k zoznamu]]

	Bzučiak 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.		Bzučiak 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.

LED - manual

Sebastian — Sun, 26 Jul 2026 13:00:33 GMT

RGB LED modul

← Staršia verzia		Verzia z 13:00, 26. júl 2026
Riadok 1:		Riadok 1:
	=== RGB LED modul ===		=== RGB LED modul ===

			[[Príprava elektroniky - hardware setup \| Späť k zoznamu]]

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

Mikrofon KY-53 - manual

Sebastian — Sun, 26 Jul 2026 13:00:05 GMT

Mikrofón

← Staršia verzia		Verzia z 13:00, 26. júl 2026
Riadok 1:		Riadok 1:
	=== Mikrofón ===		=== Mikrofón ===

			[[Príprava elektroniky - hardware setup \| Späť k zoznamu]]

	Vieme ako zvuk generovať – teraz ho ideme aj zachytiť. Pomôže nám modul '''KY-038'''.		Vieme ako zvuk generovať – teraz ho ideme aj zachytiť. Pomôže nám modul '''KY-038'''.

Ultrazvukovy senzor HC-SR04 - manual

Sebastian — Sun, 26 Jul 2026 12:59:45 GMT

Ultrazvukový senzor

← Staršia verzia		Verzia z 12:59, 26. júl 2026
Riadok 1:		Riadok 1:
	=== Ultrazvukový senzor ===		=== Ultrazvukový senzor ===

			[[Príprava elektroniky - hardware setup \| Späť k zoznamu]]

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

Ultrazvukovy senzor HC-SR04 - manual

Sebastian — Sun, 26 Jul 2026 12:58:20 GMT

Vytvorená stránka „=== 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ä…“

Nová stránka

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



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

''' Zapojenie '''

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

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

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

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

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

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

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

return pulseIn(ECHO, HIGH);
}

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

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

delay(100);
}
</syntaxhighlight>

''' Princíp '''

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

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

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

Prvé kolo

Sebastian — Sun, 26 Jul 2026 12:53:49 GMT

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

	----		----

Mikrofon KY-53 - manual

Sebastian — Sun, 26 Jul 2026 12:51:35 GMT

Vytvorená stránka „=== Mikrofón === Vieme ako zvuk generovať – teraz ho ideme aj zachytiť. Pomôže nám modul '''KY-038'''. Mikrofón funguje presne opačne ako reproduktor. Kým reproduktor premieňa elektrický signál na kmitanie fólie (zvuk), mikrofón zachytí kmitanie vzduchu a premení ho späť na elektrický signál. Modul KY-038 má dva výstupy: {| class="wikitable" |- ! Výstup !! Popis |- | '''Digitálny (D0)''' || Vysiela iba 0 alebo 1 – buď zvuk zachytil,…“

Nová stránka

=== Mikrofón ===

Vieme ako zvuk generovať – teraz ho ideme aj zachytiť. Pomôže nám modul '''KY-038'''.

Mikrofón funguje presne opačne ako reproduktor. Kým reproduktor premieňa elektrický signál na kmitanie fólie (zvuk), mikrofón zachytí kmitanie vzduchu a premení ho späť na elektrický signál.

Modul KY-038 má dva výstupy:

{| class="wikitable"
|-
! Výstup !! Popis
|-
| '''Digitálny (D0)''' || Vysiela iba 0 alebo 1 – buď zvuk zachytil, alebo nie
|-
| '''Analógový (A0)''' || Vysiela hodnotu podľa hlasitosti a frekvencie zvuku – čím hlasnejší zvuk, tým vyššia hodnota
|}

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

''' Zapojenie '''

{| class="wikitable"
|-
! Pin modulu !! Pin na RP2350-Zero
|-
| '''VCC''' || 3.3V
|-
| '''GND''' || GND
|-
| '''D0''' (digitálny výstup) || GP5
|-
| '''A0''' (analógový výstup) || GP26 (ADC0)
|}

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

==== Čítanie hodnôt z mikrofónu ====

'''Vyskúšaj toto:''' Skopíruj a spusti nasledujúci program. Otvor sériový monitor (9600 baud) a skús hovoriť, tlieskať alebo pískať pred mikrofón. Sleduj ako sa menia hodnoty.

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

void setup() {
pinMode(MIC_DIGITAL, INPUT);
Serial.begin(9600);
}

void loop() {
int digitalVal = digitalRead(MIC_DIGITAL); // 0 alebo 1
int analogVal = analogRead(MIC_ANALOG); // 0 až 4095

Serial.print("Digitálny: ");
Serial.print(digitalVal);
Serial.print(" | Analógový: ");
Serial.println(analogVal);

delay(50);
}
</syntaxhighlight>

{| class="wikitable"
|-
! Funkcia !! Vysvetlenie
|-
| <code>digitalRead(pin)</code> || Prečíta stav pinu – vráti buď <code>0</code> (ticho) alebo <code>1</code> (zvuk zachytený)
|-
| <code>analogRead(pin)</code> || Prečíta analógovú hodnotu pinu – vráti číslo od <code>0</code> do <code>4095</code>
|-
| <code>delay(50)</code> || Čakáme 50 ms medzi meraniami – aby sériový monitor nescrolloval príliš rýchlo
|}

Prvé kolo

Sebastian — Sun, 26 Jul 2026 12:48:20 GMT

Mikrofón

Zobraziť rozdiely

Pasivny bzuciak - manual

Sebastian — Sun, 26 Jul 2026 12:47:47 GMT

← Staršia verzia		Verzia z 12:47, 26. júl 2026
Riadok 78:		Riadok 78:
	* Pin bude HIGH 500 µs, potom LOW 500 µs – a to 10-krát za sebou		* Pin bude HIGH 500 µs, potom LOW 500 µs – a to 10-krát za sebou

	[[Buzzer structure\|Štruktúra]]		<!-- [[Buzzer structure\|Štruktúra]] -->

	Čo sme sa naučili?		Čo sme sa naučili?

Pasivny bzuciak - manual

Sebastian — Sun, 26 Jul 2026 09:18:15 GMT

Vytvorená stránka „=== Bzučiak (Buzzer) === Bzučiak 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 j…“

Nová stránka

=== Bzučiak (Buzzer) ===

Bzučiak 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á.

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

''' Zapojenie '''

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

'''Vyskúšaj toto:''' Skopíruj kód nižšie, doplň funkciu <code>playNote()</code> podľa vysvetlenia vyššie a nahraj ho do mikrokontroléra. Sleduj sériový monitor.

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

[[Buzzer structure|Štruktúra]]

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

Prvé kolo

Sebastian — Sun, 26 Jul 2026 09:05:12 GMT

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.

	----		----

LED - manual

Sebastian — Sat, 25 Jul 2026 11:38:09 GMT

Vytvorená stránka „=== RGB LED modul === RGB LED je súčiastka, ktorá dokáže svietiť v ľubovoľnej farbe – kombinuje totiž tri farebné diódy v jednom puzdre: '''červenú (R)''', '''zelenú (G)''' a '''modrú (B)'''. Miešaním intenzity týchto troch farieb vieme dosiahnuť akýkoľvek odtieň. 300px Používame modul [https://techfun.sk…“

Nová stránka

=== RGB LED modul ===

RGB LED je súčiastka, ktorá dokáže svietiť v ľubovoľnej farbe – kombinuje totiž tri farebné diódy v jednom puzdre: '''červenú (R)''', '''zelenú (G)''' a '''modrú (B)'''. Miešaním intenzity týchto troch farieb vieme dosiahnuť akýkoľvek odtieň.

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

Používame modul [https://techfun.sk/produkt/led-rgb-modul/ LED RGB modul od Techfun.sk], ktorý má výhodou oproti holej LED dióde – '''rezistory sú už napájkované priamo na module''', takže nie je potrebné zapojiť žiadne externé rezistory.

Modul má '''4 piny''':

{| class="wikitable"
|-
! Pin !! Popis !! Zapojenie v RP2350-zero
|-
| '''-''' || GND || GND
|-
| '''R''' || Červená farba || GP0
|-
| '''G''' || Zelená farba || GP1
|-
| '''B''' || Modrá farba || GP2
|}

(Keďže modul má rezistory zabudované, zapájame ho priamo – pin '''"-"''' na GND, a piny R/G/B na GPIO piny mikrokontroléra)

''' Kód '''

'''Skušobný kód:''' 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]]

Prvé kolo

Sebastian — Sat, 25 Jul 2026 11:33:48 GMT

RGB LED modul

@@ Riadok 6: / Riadok 6: @@
 Komplexnejším projektom sa budeme venovať v 2. kole.
-==== Pravidlá kola ====
+==== Pravidlá prípravy ====
-* Počas kola budete dostávať jednoduché zadania, ktoré budete musieť zdokumentovať (odfotiť alebo natočiť) a odovzdať.
+Pre začiatok na setupnutie si vlastnej stavebnice budeme musiet si pripravit:
-* Každý tím má k dispozícii určitý počet bodov, ktoré môže využiť na nápovedy.
-* Nápovedy môžu mať formu priameho kódu alebo vás nasmerujú správnym smerom.
+- Hadrver
-* Hodnotiť sa bude: <code>insert conditions</code>
+- Softver
 == Príprava hardvéru ==
@@ Riadok 85: / Riadok 83: @@
 Na konci prvej stavebnice poskladáte autíčko ktoré sa samo vyhýba prekážkam – prvého autonómneho robota!
 ----

Manual

Sebastian — Sun, 19 Jul 2026 20:02:34 GMT

Manuál skladania robotického ramena

← Staršia verzia		Verzia z 20:02, 19. júl 2026
Riadok 7:		Riadok 7:
	! Typ matice !! Použitie !! Utiahnutie		! Typ matice !! Použitie !! Utiahnutie
	\|-		\|-
	\| '''Plastová''' \|\| Kĺby ktoré sa majú ohýbať \|\| '''Neutiahnuť na doraz''' – skrutka sa ~~zarýže~~ do plastu a drží, ale kĺb musí zostať pohyblivý		\| '''Plastová''' \|\| Kĺby ktoré sa majú ohýbať \|\| '''Neutiahnuť na doraz''' – skrutka sa zaryje do plastu a drží, ale kĺb musí zostať pohyblivý
	\|-		\|-
	\| '''Kovová''' \|\| Pevné spoje \|\| Utiahnuť, ale '''nie nasilu''' – môžete poškodiť súčiastky		\| '''Kovová''' \|\| Pevné spoje \|\| Utiahnuť, ale '''nie nasilu''' – môžete poškodiť súčiastky

Príprava elektroniky - hardware setup

Sebastian — Sun, 19 Jul 2026 17:25:08 GMT

Vytvorená stránka „== Zoznam elektro súčiastok == Hlavnou súčasťou našej stavebnice sú elektronické súčiastky. Skladá sa z hlavnej riadiacej jednotky (RP2350-Zero), senzorov, akčných členov (motorčeky, LED diódy) a pomocných obvodov. Táto stránka slúži ako '''hlavný rozcestník''' – kedykoľvek sa sem môžeš vrátiť a cez odkazy nájsť manuál ku konkrétnej súčiastke. Každý manuál obsahuje: * stručné vysvetlenie, ako súčiastka funguje, * ako ju…“

Nová stránka

== Zoznam elektro súčiastok ==
Hlavnou súčasťou našej stavebnice sú elektronické súčiastky. Skladá sa z hlavnej riadiacej jednotky (RP2350-Zero), senzorov, akčných členov (motorčeky, LED diódy) a pomocných obvodov.

Táto stránka slúži ako '''hlavný rozcestník''' – kedykoľvek sa sem môžeš vrátiť a cez odkazy nájsť manuál ku konkrétnej súčiastke. Každý manuál obsahuje:
* stručné vysvetlenie, ako súčiastka funguje,
* ako ju pripraviť (t. j. naspájkovať),
* do akého držiaka/uchytenia patrí,
* skúšobný kód a odkazy na potrebné knižnice.

Všetky elektronické súčiastky majú svoje vlastné vytlačiteľné krabičky/držiaky, do ktorých sa dajú osadiť. Tieto krabičky/držiaky sú navyše kompatibilné s ostatnými vytlačiteľnými súčiastkami stavebnice.

=== Riadiaca jednotka ===
{| class="wikitable"
|-
! Súčiastka !! Popis
|-
| [[RP2350 - manual|RP2350-Zero]] || Mikrokontrolér – "mozog" celej stavebnice
|}

=== Senzory ===
{| class="wikitable"
|-
! Súčiastka !! Popis
|-
| [[Ultrazvukovy senzor HC-SR04 - manual|Ultrazvukový senzor HC-SR04]] || Meranie vzdialenosti ultrazvukom
|-
| [[Laser senzor VL53L0X - manual|Laserový ToF senzor vzdialenosti VL53L0X]] || Meranie vzdialenosti laserom (Time-of-Flight)
|-
| [[Dotykovy senzor - manual|Dotykový senzor]] || Detekcia dotyku
|-
| [[Mikrofon KY-53 - manual|Mikrofón KY-53]] || Snímanie zvuku/hlasitosti okolia
|-
| [[Gyroskop BNO055 - manual|Gyroskop BNO055]] || Meranie orientácie a pohybu
|-
| [[Ciarovy senzor QRT-8A - manual|Čiarový senzor QRT-8A]] || Detekcia čiary pre line-following
|}

=== Akčné členy a výstupy ===
{| class="wikitable"
|-
! Súčiastka !! Popis
|-
| [[LED - manual|LED modul]] || Svetelný výstup
|-
| [[Servo SG90 - manual|Servo SG90]] || Riadenie natočenia (servomotor)
|-
| [[Pasivny bzuciak - manual|Bzuciak]] || Zvukový výstup
|}

=== Ovládacie prvky ===
{| class="wikitable"
|-
! Súčiastka !! Popis
|-
| [[Analogovy joystick - manual|Analógový joystick]] || Manuálne ovládanie (vstup)
|}

=== Ostatné / pomocné obvody ===
{| class="wikitable"
|-
! Súčiastka !! Popis
|-
| [[Multiplexor 74HC4051 - manual|Multiplexor 74HC4051]] || Prepínanie viacerých vstupov/výstupov cez menej pinov
|}

Príprava programovacieho prostredia - sofrware setup

Sebastian — Sun, 19 Jul 2026 10:13:18 GMT

← Staršia verzia		Verzia z 10:13, 19. júl 2026
Riadok 35:		Riadok 35:
	[[Image:BNO055_install.png\|300px]]		[[Image:BNO055_install.png\|300px]]

	=== ~~Výber dosky a portu~~ ===		=== Prvé nahratie programu – režim BOOTSEL ===
	~~Po inštalácii knižníc je potrebné zvoliť správnu dosku a port – bez toho počítač pripojený mikrokontrolér nerozpozná.~~		Mikrokontrolér očakáva program vo formáte '''.uf2'''. Pri úplne prvom nahrávaní ešte doska odmieta s počítačom komunikovať – preto ani Arduino IDE zatiaľ nevie zistiť, o aký čip ide (napr. funkcia "Get Board Info" nič nevráti). Riešením je dosku "zobudiť" prepnutím do špeciálneho režimu '''BOOTSEL''', v ktorom sa hlási ako obyčajný USB disk a dá sa na ňu nahrať program priamo.
	~~# V menu~~ '''~~Tools → Board''' vyhľadaj a vyber '''"Generic RP2350"~~'''.
	~~# Pripoj mikrokontrolér k počítaču pomocou USB kábla.~~
	~~# V menu '''Tools → Port''' vyber port~~, ~~na ktorom sa zariadenie objavilo~~ (napr. ~~<code>COM3</code> na Windows alebo <code>/dev/ttyACM0</code> na Linuxe~~).

	~~Mikrokontrolér očakáva program vo formáte~~ '''~~.uf2~~'''~~. Existujú dva spôsoby~~, ako ~~ho nahrať:~~
	* '''Manuálny export a ~~drag & drop''' – zvyčajne~~ sa ~~používa pri prvom pripojení dosky.~~
	* '''Automatický upload''' – priamo ~~z Arduino IDE po prvotnom nastavení.~~

	~~Pre lepšiu predstavu si pozri [https://www.youtube.com/watch?v=Vx-Y7pCRSJY toto video] (fyzický postup je rovnaký pre RP2040 aj RP2350)~~.

	~~=== Manuálny upload – režim BOOTSEL ===~~
	~~Pri úplne prvom nahrávaní programu doska ešte nemá nahratý firmware, ktorý by ju predstavil počítaču ako Arduino zariadenie, preto ju treba prepnúť do špeciálneho režimu '''BOOTSEL''':~~
	# Stlač a '''podrž tlačidlo BOOT''' na doske RP2350-Zero.		# Stlač a '''podrž tlačidlo BOOT''' na doske RP2350-Zero.
	# Počas držania tlačidla '''zapoj USB kábel''' do počítača.		# Počas držania tlačidla '''zapoj USB kábel''' do počítača.
	# '''Uvoľni tlačidlo BOOT'''.		# '''Uvoľni tlačidlo BOOT'''.

	Na počítači sa objaví nová jednotka (podobne ako USB flash disk) s názvom '''RP2350'''~~. Do tejto jednotky môžeš priamo pretiahnuť (drag & drop) súbor s programom~~.		Na počítači sa objaví nová jednotka (podobne ako USB flash disk) s názvom '''RP2350'''.

	Skopíruj si tento jednoduchý kód do svojho prvého projektu:		Skopíruj si tento jednoduchý kód do svojho prvého projektu:
Riadok 63:		Riadok 52:
	</syntaxhighlight>		</syntaxhighlight>

	Použi '''Sketch → Export Compiled Binary''' (alebo skratku <code>Ctrl+Alt+S</code>). Arduino IDE kód skompiluje a uloží súbor <code>.uf2</code> do priečinka projektu.		Použi '''Sketch → Export Compiled Binary''' (alebo skratku <code>Ctrl+Alt+S</code>). Arduino IDE kód skompiluje a uloží súbor <code>.uf2</code> '''do priečinka projektu'''.

			Následne súbor '''.uf2''' pretiahni (drag & drop) do jednotky '''RP2350''' – po nahratí sa doska automaticky reštartuje, program sa spustí a doska sa už bude počítaču hlásiť ako sériové zariadenie.

	~~Následne súbor~~ '''~~.uf2~~''' ~~pretiahni (drag & drop) do pripojenej jednotky~~ '''RP2350''' ~~– po nahratí~~ sa ~~doska automaticky reštartuje a program sa spustí~~.		[https://www.youtube.com/watch?v=Vx-Y7pCRSJY Video s ukážkou celého postupu] (fyzický postup je rovnaký pre RP2040 aj RP2350).

			=== Výber dosky a portu ===
			Keďže doska už komunikuje s počítačom z predchádzajúceho kroku, objaví sa v Arduino IDE ako sériový port. Teraz je potrebné v IDE zvoliť správnu dosku a port, aby sa dali nahrávať ďalšie programy:
			# V menu '''Tools → Board''' vyhľadaj a vyber '''"Generic RP2350"'''.
			# V menu '''Tools → Port''' vyber port, na ktorom sa zariadenie objavilo (napr. <code>COM3</code> na Windows alebo <code>/dev/ttyACM0</code> na Linuxe).

	=== Automatický upload ===		=== Automatický upload ===
	Po prvom manuálnom nahratí firmvéru už môžeš ďalšie programy nahrávať priamo z Arduino IDE, bez potreby prepínania do BOOTSEL režimu:		Po prvom manuálnom nahratí firmvéru už môžeš ďalšie programy nahrávať priamo z Arduino IDE, bez potreby prepínania do BOOTSEL režimu:
	# Zapoj dosku do počítača ~~(mal by sa objaviť úložný priestor '''RP2350''')~~.		# Zapoj dosku do počítača.
	# ~~V menu~~ '''Tools''' ~~vyber~~ dosku ('''Generic RP2350''') a ~~príslušný~~ port.		# Over, že máš v '''Tools''' vybranú dosku ('''Generic RP2350''') a správny port (pozri predchádzajúcu sekciu).
	~~# Ak sa port správne našiel, potvrď tlačidlom '''OK'''~~.
	# Kód nahráš kliknutím na tlačidlo '''→''' (šípka) v ľavom hornom rohu, alebo klávesovou skratkou '''Ctrl+U'''.		# Kód nahráš kliknutím na tlačidlo '''→''' (šípka) v ľavom hornom rohu, alebo klávesovou skratkou '''Ctrl+U'''.

	[[Image:~~RP2350 port~~.png\|300px]]		[[Image:generic_2350_port.png\|300px]]

Súbor:Generic 2350 port.png

Sebastian — Sun, 19 Jul 2026 10:12:36 GMT

Sebastian pridal Súbor:Generic 2350 port.png

Nová stránka

Prvé kolo

Sebastian — Sat, 18 Jul 2026 18:45:59 GMT

Príprava arduino rozhrania

← Staršia verzia		Verzia z 18:45, 18. júl 2026
Riadok 24:		Riadok 24:
	[[Príprava programovacieho prostredia - sofrware setup \| Arduino IDE setup]]		[[Príprava programovacieho prostredia - sofrware setup \| Arduino IDE setup]]

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


	== Vytlačená stavebnica ==		== Vytlačená stavebnica ==

Príprava programovacieho prostredia - sofrware setup

Sebastian — Sat, 18 Jul 2026 18:44:12 GMT

Zobraziť rozdiely

Súbor:BNO055 install.png

Sebastian — Sat, 18 Jul 2026 17:09:27 GMT

Sebastian pridal Súbor:BNO055 install.png

Nová stránka

Príprava programovacieho prostredia - sofrware setup

Sebastian — Sat, 18 Jul 2026 17:06:44 GMT

← Staršia verzia		Verzia z 17:06, 18. júl 2026
Riadok 18:		Riadok 18:
	[[Image:RP2040-Zero-Board.jpg\|400px]]		[[Image:RP2040-Zero-Board.jpg\|400px]]

	=== Inštalácia ~~knižnice~~ ===		=== Inštalácia knižníc ===

	# Otvorte Arduino IDE a prejdite do '''File → Preferences'''.		# Otvorte Arduino IDE a prejdite do '''File → Preferences'''.
Riadok 28:		Riadok 28:

	[[Image:Pico Get Start 06.png\|300px]]		[[Image:Pico Get Start 06.png\|300px]]

			# V Arduino IDE otvorte '''Tools → Manage Libraries''' (alebo na ľavej lište otvorte stredné okno)
			# Vyhľadajte '''"VL53L0X"''' a nainštalujte knižnicu od autora '''Pololu'''

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

			# Ďalej vyhľadajte '''"Adafruit BNO055"''' a nainštalujte knižnicu
			# Nainštalujte aj všetky závislosti od '''"Adafruit"''' ak sa zobrazí výzva


			[[Image:adafruit_BNO055_install.png\|300px]]


	=== Výber dosky a portu ===		=== Výber dosky a portu ===

Prvé kolo

Sebastian — Sat, 18 Jul 2026 11:01:54 GMT

Gyroskop BNO055

← Staršia verzia		Verzia z 11:01, 18. júl 2026
(Jedna medziľahlá úprava od rovnakého používateľa nie je zobrazená.)
Riadok 727:		Riadok 727:
	\|}		\|}

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

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

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

	''' Kód '''		''' Kód '''
Riadok 835:		Riadok 829:
	\| '''SCL''' \|\| GP5		\| '''SCL''' \|\| GP5
	\|}		\|}

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

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

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

Príprava programovacieho prostredia - sofrware setup

Sebastian — Sat, 18 Jul 2026 10:22:57 GMT

Výber dosky a portu

← Staršia verzia		Verzia z 10:22, 18. júl 2026
Riadok 33:		Riadok 33:
	Po inštalácii knižnice je nutné zvoliť správnu dosku a port – bez toho počítač nerozpozná pripojený mikrokontrolér.		Po inštalácii knižnice je nutné zvoliť správnu dosku a port – bez toho počítač nerozpozná pripojený mikrokontrolér.

	# V menu '''Tools → Board''' vyhľadajte a vyberte '''"~~Raspberry Pi Pico~~"'''.		# V menu '''Tools → Board''' vyhľadajte a vyberte '''"Generic RP2350"'''.
	# Pripojte mikrokontrolér k počítaču pomocou USB kábla.		# Pripojte mikrokontrolér k počítaču pomocou USB kábla.
	# V menu '''Tools → Port''' vyberte port, na ktorom sa zariadenie objavilo (napr. <code>COM3</code> na Windows alebo <code>/dev/ttyACM0</code> na Linuxe).		# V menu '''Tools → Port''' vyberte port, na ktorom sa zariadenie objavilo (napr. <code>COM3</code> na Windows alebo <code>/dev/ttyACM0</code> na Linuxe).

Príprava programovacieho prostredia - sofrware setup

Sebastian — Sat, 18 Jul 2026 10:20:12 GMT

Vytvorená stránka „== Arduino IDE == Na programovanie stavebnice 3D Ligy budeme používať vývojové prostredie '''Arduino IDE 2'''. Stiahnuť ho môžete na oficiálnej [https://www.arduino.cc/en/software/ stránke Arduina]. Vyberte verziu zodpovedajúcu vášmu operačnému systému (Windows, macOS alebo Linux). 400px === Mikrokontrolér === Ako riadiaci čip stavebnice používame '''Waveshare RP2350-Zero'''. Aby s ním Arduino IDE vedelo ko…“

Nová stránka

== Arduino IDE ==

Na programovanie stavebnice 3D Ligy budeme používať vývojové prostredie '''Arduino IDE 2'''.

Stiahnuť ho môžete na oficiálnej [https://www.arduino.cc/en/software/ stránke Arduina].
Vyberte verziu zodpovedajúcu vášmu operačnému systému (Windows, macOS alebo Linux).

[[Image:Arduino Download.png|400px]]

=== Mikrokontrolér ===

Ako riadiaci čip stavebnice používame '''Waveshare RP2350-Zero'''.
Aby s ním Arduino IDE vedelo komunikovať, je potrebné doinštalovať príslušnú knižnicu (board package).

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

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

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

# Otvorte Arduino IDE a prejdite do '''File → Preferences'''.
# Do poľa "'''Additional boards manager URLs'''" pridajte nasledujúci odkaz:
<nowiki>https://github.com/earlephilhower/arduino-pico/releases/download/4.5.2/package_rp2040_index.json</nowiki>
# Potvrďte tlačidlom OK.
# Otvorte '''Tools → Board → Boards Manager''' a vyhľadajte '''"Raspberry Pi Pico/RP2040"''' (obsahuje aj '''RP2350''').
# Nainštalujte knižnicu od autora '''Earle F. Philhower, III'''.

[[Image:Pico Get Start 06.png|300px]]

=== Výber dosky a portu ===

Po inštalácii knižnice je nutné zvoliť správnu dosku a port – bez toho počítač nerozpozná pripojený mikrokontrolér.

# V menu '''Tools → Board''' vyhľadajte a vyberte '''"Raspberry Pi Pico"'''.
# Pripojte mikrokontrolér k počítaču pomocou USB kábla.
# V menu '''Tools → Port''' vyberte port, na ktorom sa zariadenie objavilo (napr. <code>COM3</code> na Windows alebo <code>/dev/ttyACM0</code> na Linuxe).

Mikrokontrolér očakáva program vo formáte '''.uf2'''. Existujú dva spôsoby, ako ho získať:

* '''Priamo z Arduino IDE:''' Použite '''Sketch → Export Compiled Binary''' (alebo skratku <code>Ctrl+Alt+S</code>). Arduino IDE skompiluje kód a uloží súbor <code>.uf2</code> do priečinka projektu.
* '''Drag & drop:''' Skompilovaný súbor <code>.uf2</code> jednoducho presuňte myšou na jednotku RP2350. Po nahratí sa mikrokontrolér automaticky reštartuje a program sa spustí.

Pre vizualizáciu tu je [https://www.youtube.com/watch?v=Vx-Y7pCRSJY Youtune video] (fyzický postup je rovnaký pre RP2040 a RP2350)

=== Prvé pripojenie – režim BOOTSEL ===

Pri úplne prvom nahrávaní, alebo keď mikrokontrolér neodpovedá, je potrebné ho prepnúť do režimu BOOTSEL:

# Stlačte a '''podržte tlačidlo BOOT''' na doske RP2350-Zero.
# Počas držania tlačidla '''zapojte USB kábel''' do počítača.
# Tlačidlo '''uvoľnite'''.

Na počítači sa objaví nová jednotka (ako USB flash disk) s názvom '''RP2350''' alebo '''RPI-RP2'''.
Do tejto jednotky môžete priamo pretiahnuť (drag & drop) súbor s programom.

=== Ďalsie nahrávanie ===

Ďalšie nahrávania programov budú prirodzenejšie.

* Zapojí sa doska do počítača.
* Vyberie sa doska ('''Raspberry Pi Pico 2''') a port.
* Ak sa port našiel, potvrďte talčidlom '''OK'''
* Váš kód nahrajete cez tlačidlo '''->''' v ľavom hornom rohu. (skratka: '''Ctrl+U''')

[[Image:RP2350 port.png|300px]]

=== Hello World! ===

'''Vyskúšaj toto:''' Test sériovej komunikácie. Skopíruj a spusti nasledujúci program. Sleduj sériový monitor. Uisti sa, že máš v okne sériového monitora zvolených 9600 baudov. Pred začatím odporúčame prezrieť si [[Základy programovania | prehľad premenných a operátorov]].

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

'''VAŠA ÚLOHA:''' Uprav program tak, aby po dosiahnutí čísla 100 začal počítať v opačnom poradí – až do 0, a potom znova do 100, atď. Použi operátor dekrementovania (''i--'') a podmienku ''if'':

<syntaxhighlight lang="C">
if (podmienka)
{
príkazy, ktoré sa vykonajú keď je podmienka splnená
}
</syntaxhighlight>

Všimni si, ako je v kóde vyššie definovaná premenná i typu int. Možno budeš chcieť definovať ďalšiu premennú.

Čo sme sa naučili?
* Využívať sériový výstup na výpis informácií do sériového monitora, čo je veľmi užitočné pri ladení (debugovaní) programov.

Prvé kolo

Sebastian — Sat, 18 Jul 2026 10:19:49 GMT

@@ Riadok 15: / Riadok 15: @@
 * Pociťujeme nárast umelej inteligencie, preto vás prosíme aby ste používali rozumne umelú inteligenciu. Tolerujeme vyhladávanie alebo opravovanie pravopisu pomocou AI (ako nástroj). Ak ale použijete AI na vygenerovanie riešenia, vypomáhanie alebo len nájdenie riešenia, tak prosíme aby ste napísali, že ste využili takúto službu. Budeme na to brať ohľad. Zakázať vám to používať nemôžeme, len sa snažíme dovŕšiť to aby ste na riešenie prišli sami a naučili sa niečo nové a zábavné.
-== Arduino IDE ==
+== Príprava hardvéru ==
-Na programovanie stavebnice 3D Ligy budeme používať vývojové prostredie '''Arduino IDE 2'''.
+[[Príprava elektroniky - hardware setup | Celkový setup elektorniky a HW súčiastok]]
-[[Image:Arduino Download.png|400px]]
+== Príprava arduino rozhrania==
-=== Mikrokontrolér ===
+[[Príprava programovacieho prostredia - sofrware setup | Arduino IDE setup]]
 == Vytlačená stavebnica ==