Pavouk Hiwonder

[luger]

Logické to je, ale na UNO je nasazený shield který ovládá celého pavouka, takže to fakt nepoznám jak je to pozapojované.

[kiRRow]

Propípat multimetrem, nebo zkoumat schéma zapojení ( i když tomu se věřiti dost často nedá )

[luger]

Potřeboval bych částečně ovládat pavoučka zvukem. Např. když tlesknu - udělej toto a toto.
Moduly zvukových senzorů za 50 kč reagují max. na půl metru a to ještě kus od kusu.
Napadlo mě použít "chytrou žárovku" reagující na tlesknutí:
https://vuci.cz/p/led-usporna-zarovka-n ... gJ_WfD_BwE

Myslíte, že by se to dalo nějak překopat k použití pro arduino ?

[luger]

Na žárovku žádná reakce ?
Pořád se potýkám s kontrolou zvuku a reakcí na něj. Interrupt bohužel nefunguje protože je zabírají knihovny (alespoň si to myslím)
Při tom jsem zjistil, že mám těžké nedostatky v pochopení běhu podmínky IF ELSE IF ELSE.
Jaký je mezi nima rozdíl ? :

1. varianta:

if (...) {
....
}

else if (....) {
...
}

else if (.....) {
....
}

else {
...
}

2. varianta:

if (...) {
....

if (....) {
...
}

if (.....) {
....
}

else {
...
}
}

Cituji z netu vysvětlení:
Řekněme použijeme-li pravidlo vrabce a drátu, máme sérii 4 ifů - tzn se budou testovat určitě všechny 4 podmínky v závorkách. A teď znovu v bleděmodrém - série if a 3 else if - pokud bude splněna jakákoliv z podmínek, ty za ní se již testovat nebudou
Je to pravda ?

[kiRRow]

Ano. Něco jako switch/case ... pokud bude splněna první podmínka ostatní se testovat nebudou

[luger]

Ok, a co když ty podmínky prokombinuji šíleným způsobem, např.:
if (...) {
....
}

else if (....) {
...
}

if (.....) {
....
}
else if (....) {
...
}
if (....) {
...
}
else if (....) {
...
}

else {
...
}

atd............ To je guláš , co ??

A proč se ptám ? - tovární program k ovládání pavoučka je ještě 100x složitější ! Potřebuji ho mírně upravit a dokud nepochopím podmínky tak se to určitě nepodaří.

[kiRRow]

pořád to samé ... jakmile program najde if a splní se jedno else if, tak na ostatní elseify bude kašlat až do dalšího ifu ...

[luger]

díky moc, v žádném manuálu pro arduino jsem to nenašel. Asi je to tajné
jsou to drobnosti, ale zásadně to ovlivňuje běh programu .
Když už jsme nakousli switch/case, měl bych zase takovou záludnou otázku:
jaký je rozdíl mezi ? Napřiklad - dva mírně odlišné zápisy a mě by zajímalo jestli se první skočí na step_ a následující příkaz "timer = millis() + 500;" se provede bůhví kdy a nebo se provedou všechny příkazy až do break ? Zajímá mě odlišné pořadí step a timer = ..... zvýrazněno tučným písmem

1. zápis:
case 1:

zmerit_vzdalenost ();

if (vzdalenost < 38 && vzdalenost > 0) {
// Pokud je naměřená vzdálenost menší než specifikovaná vzdálenost pro vyhnutí se překážce (380 mm)
// zastavte všechny akční skupiny a přejděte ke kroku 2.
Controller.stopActionGroup(); // zastavit
step_ = 2; // skočit na step 2
timer = millis() + 500; // původní hodnota 500
}
break; // ukončení kroku 1
-----------------------------------------------------------------------------------------------------------------------------------------------
2. zápis:
case 2: // step 1

zmerit_vzdalenost ();

if (vzdalenost < 38 && vzdalenost > 0) {
// Pokud je naměřená vzdálenost menší než specifikovaná vzdálenost pro vyhnutí se překážce (380 mm)
// zastavte všechny akční skupiny a přejděte ke kroku 2.
Controller.stopActionGroup(); // zastavit
timer = millis() + 500; // původní hodnota 500
step_ = 2; // skočit na step 2
}
break; // ukončení kroku 2

[gilhad]

Není to tajné, ten princip je všude stejný:

buď máš konstrukci if (podminka) {blokA}, nebo konstrukci if (podminka) {blokA} else {blokB}

else se páruje s nejbližším předcházejím if, který ještě nemá připárované else a může toto else použít

Když si to správně odsadíš, tak je to vidět, pokud navíc používáš všude bloky ve složených závorkách (i tam, kde nejsou nezbytné), je to vidět ještě líp. A když si to třeba i okomentuješ, tak ten guláš je celkem přehledný:

Kód: Vybrat vše

if (a==1) {
	... // pro a==1
} else { // pro a!=1
	if(b==2) { 
		... // pro a!=1 && b==2
	}; // konec if(b==2)
}; // konec else od if (a==1)

if (c==3) { 
	... // pro c==3 a nic jineho
} else { // pro c!=3
	if (d==4) {
		...  // pro c!=3 && d==4
	}; // konec if d==4
}; // konec else od if c==3

if (e==5) {
	... // pro e==5
} else { // pro e!=5
	if (f==6) {
		... // pro e!=5 && f==6
	} else { // pro e!=5 && f!=6
		...
	}; // konec else od if==6
}; // konec else of if e==5

atd ...

překladač to přeloží postupně tak, že když narazí na if tak vloží kód pro vyhodnocení podmínky a pokud tento kód vrátí false, tak se skočí na příslušný blokB za spárovaným else (pokud tam je), jinak se provede blokA a skoří se za blokB (pokud tam je).

A to je vše. Jen se to zanořuje do sebe.

Z toho je také vidět, kdy se vyhodnocují podmínky u více vložených else if

Kód: Vybrat vše

if (g==7) {
	blokG;
} else { // g!=7
	if (h==8) {
		blokH;
	} else { // g!=7 && h!=8
		if ( i == 9) {
			blokI;
		} else { // g!=7 && h!=8 && i!=9
			if (j == 10) {
				blokJ
			} else {  // g!=7 && h!=8 && i!=9 && j!=10
				blokNotJ;
			};
		};
	};
};

samozřejmě to jde zapsat i jakkoli jinak, ale pak z toho máš ten guláš (například takto)

Kód: Vybrat vše

if (g==7) { blokG } else if (h==8) { blokH } else if ( i == 9) { blokI
} else if (j == 10) { blokJ } else { blokNotJ }

Takže první věc by asi byla si to skutečně odsadit všechno správně a ideálně si tam i doplnit to složené závorky a komentáře, pak to bude mnohem jasnější.

Tady je například vidět, že pokud je g==7, tak se provede blokG a dál se už nic nedělá, tedy ani nevyhodnocuje.
Zatímco pokud je g==1 a h==1 a i==9 tak se postupně vyhodnotí tyhle tři výrazy a provede se blokI

středník je oddělovač příkazů, pokud ho máš za příkazem, tak následuje (prázdný) příkaz (který se přeloží jako žádné instrukce navíc, čili ignoruje), ale je jasné, že už nemůže následovat třeba else
Složená závorka uzavírá do sebe libovolný pořet příkazů (klidně i jeden, nebo žádný), takže se pak chovají jako jeden příkaz. Zase se dá použít pro zpřehlednění, kde co začíná a končí, spousta editorů to dokáže i zvýrazňovat a skákat z otvírací na příslušnou zavírací a nebo zpět.

takže

Kód: Vybrat vše

blokY

a

Kód: Vybrat vše

	{
		blokY; //  tady se něco dělá
	}

je to samé a přeloží se na stejný kód

[gilhad]

Když už jsme nakousli switch/case, měl bych zase takovou záludnou otázku:
jaký je rozdíl mezi ? Napřiklad - dva mírně odlišné zápisy a mě by zajímalo jestli se první skočí na step_ a následující příkaz "timer = millis() + 500;" se provede bůhví kdy a nebo se provedou všechny příkazy až do break ? Zajímá mě odlišné pořadí step a timer = ..... zvýrazněno tučným písmem
....

V obou tučně zvýrazněných blocích se provede to samé - proměnné step_ se přiřadí hodnota 2 a proměnné timer se přiřadí hodnota aktuálního času zvětšená o 500.
V jednom se nejdřív přiřadí proměnná step_ a až pak proměnná timer, v druhém naopak, ani v jednom se nikam neskáče. (Skáče se až příkazem break na konec konstrukce switch a nikam jinam)

Někdy mnohem později, v jiném průchodu loop, se dojde někam, kde se ta promměnná step_ použije a bude mít hodnotu 2 - pokud to níhodou bude příkaz switch(step_), tak se v něm bude poračovat za návěštím case 2:, pokud tam takové bude (jinak za návěštím default a nebude-kli tam, tak se to přeskočí celé), ale to je jiná pohádka.

Hele, já, ty a všichni ostatní sice víme, že proměnná step_ se asi používá k větvení programu v nějakém switch a tak, ale překladač se řídí jen tím, co je napsáno a procesor se řídí jen tím, co mu překladač přeložil, takže nějaké přiřazení do proměnné jen do ní zapíše nějakou hodnotu a nikam neskáče. To dělají až jiné příkazy.

A samozřejmě ten switch(step_) si vyhodnotí výraz step_ když na něj přijde řada (je to hodnota uložená v té proměnné) a tuto hodnotu použije. Ale jestli se ta proměnná pak nějak změní ho už nezajímá, to ho bude zajímat teprve až na něj znova dojde výpočet a on bude znova vyhodnocovat ten výraz.