38 |
39 |
40 |
52 |
53 | {% if site.google_analytics %}
54 | {% endif %}
64 |
65 |
66 |
67 |
68 |
69 |
70 |
--------------------------------------------------------------------------------
/assets/css/style.scss:
--------------------------------------------------------------------------------
1 | ---
2 | ---
3 |
4 | @import "{{ site.theme }}";
5 |
6 | img, video { width: 100%; }
7 |
8 | .nohover:hover {
9 | text-decoration: none;
10 | }
11 |
12 | #header_wrap .inner {
13 | padding: 20px;
14 | }
15 |
16 |
--------------------------------------------------------------------------------
/automaticke_blikace/P1360301.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/automaticke_blikace/P1360301.JPG
--------------------------------------------------------------------------------
/automaticke_blikace/automaticke_blikace.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # Programované blikače
4 | Rozšířená verze ručních blikačů, jen už budeme programovat. Jednoduché vrstvení příkazů za sebou (sekvence), osahání si Arduino IDE, nahrávání programu do Arduina. Napájení Arduina z USB nebo z baterie.
5 |
6 | Různá zapojení automatických blikačů. Základní struktura programu (nastavení v `setup()` a dokola opakovaný kód v `loop()`). Časování pomocí `delay()`, příkazy `digitalWrite()`, `pinMode()`, `HIGH`, `LOW`.
7 |
8 | Vysvětlení, co je to `GND`, `VCC`, jaké typy napětí kde na Arduinu najdeme.
9 |
10 | ## Co je potřeba umět
11 | [Základy zapojování LED](../rucni_blikace/rucni_blikace.md)
12 |
13 | ## Foto
14 | Fotografie nezobrazuje přesně typ automatického blikače, který je dále popsán kódem.
15 |
16 | 
17 |
18 | ## Hardware
19 | * dostatek různě barevných LED, některé se asi spálí
20 | * rezistory 220 Ω - 330 Ω
21 | * volitelně spínače
22 |
23 | ## Blikač 1
24 | ### Schéma zapojení
25 | [blikac.fzz](blikac.fzz)
26 |
27 | [](blikac.png)
28 |
29 | ### Program
30 | [blikac.ino](blikac.ino) - kód je napsán osmiletým dítětem
31 | ``` c++
32 | {% include_relative blikac.ino %}
33 | ```
34 | ## Blikač 2
35 | ### Schéma zapojení
36 | [blikac2.fzz](blikac2.fzz)
37 |
38 | [](blikac2.png)
39 |
40 | ### Program
41 | [blikac2.ino](blikac2.ino) - kód je napsán osmiletým dítětem
42 | ``` c++
43 | {% include_relative blikac2.ino %}
44 | ```
45 |
46 | ## Možná vylepšení
47 | * Nejrůznější variace blikačů, světla železničního přejezdu, nebo [semafor](../semafor/semafor.md) či [Knight rider](../knight_rider/knight_rider.md).
48 |
49 | ## Poznatky
50 | V prvních chvílích není ani tak důležité, aby děti rozuměly všemu, co se v kódu píše, ale aby to blikalo. Časem si osahají jednotlivé příkazy a konstrukce, případně i cykly.
51 |
52 |
--------------------------------------------------------------------------------
/automaticke_blikace/blikac.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/automaticke_blikace/blikac.fzz
--------------------------------------------------------------------------------
/automaticke_blikace/blikac.ino:
--------------------------------------------------------------------------------
1 | // jak dlouho ma pockat
2 | const int cas = 100;
3 |
4 | void setup() {
5 | pinMode(8, OUTPUT);
6 | pinMode(9, OUTPUT);
7 | pinMode(12, OUTPUT);
8 | pinMode(13, OUTPUT);
9 | }
10 |
11 | void loop() {
12 | // rozsvit
13 | digitalWrite(9, HIGH);
14 | digitalWrite(13, HIGH);
15 | // cekej
16 | delay(cas);
17 | // zhasni
18 | digitalWrite(9, LOW);
19 | digitalWrite(13, LOW);
20 | // cekej
21 | delay(cas);
22 | // rozsvit
23 | digitalWrite(8, HIGH);
24 | digitalWrite(12, HIGH);
25 | // cekej
26 | delay(cas);
27 | // zhasni
28 | digitalWrite(8, LOW);
29 | digitalWrite(12, LOW);
30 | // cekej
31 | delay(cas);
32 | }
33 |
--------------------------------------------------------------------------------
/automaticke_blikace/blikac2.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/automaticke_blikace/blikac2.fzz
--------------------------------------------------------------------------------
/automaticke_blikace/blikac2.ino:
--------------------------------------------------------------------------------
1 | // nastavi delku cekani
2 | const int cekani = 100;
3 | const int cekanimezi = 50;
4 |
5 | // nastavi cisla pinu pro led
6 | const int red1 = 11;
7 | const int red2 = 10;
8 | const int red3 = 9;
9 | const int red4 = 8;
10 |
11 | // reknu mu ze na nej budu psat
12 | void setup() {
13 | pinMode(red1, OUTPUT);
14 | pinMode(red2, OUTPUT);
15 | pinMode(red3, OUTPUT);
16 | pinMode(red4, OUTPUT);
17 | }
18 |
19 | // udelam blok blikni
20 | void blikni(int led) {
21 | digitalWrite(led, HIGH);
22 | delay(cekani);
23 | digitalWrite(led, LOW);
24 | }
25 |
26 | // udelam blok vsechny
27 | void blikniVsechny() {
28 | digitalWrite(red1, HIGH);
29 | digitalWrite(red2, HIGH);
30 | digitalWrite(red3, HIGH);
31 | digitalWrite(red4, HIGH);
32 | delay(cekani);
33 | digitalWrite(red1, LOW);
34 | digitalWrite(red2, LOW);
35 | digitalWrite(red3, LOW);
36 | digitalWrite(red4, LOW);
37 | delay(cekanimezi);
38 | }
39 |
40 | void loop() {
41 | blikni(red1);
42 | blikni(red2);
43 | blikni(red3);
44 | blikni(red4);
45 | blikni(red3);
46 | blikni(red2);
47 | blikni(red1);
48 | blikniVsechny();
49 | blikniVsechny();
50 | }
51 |
--------------------------------------------------------------------------------
/automaticke_blikace/blikac2_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/automaticke_blikace/blikac2_bb.png
--------------------------------------------------------------------------------
/automaticke_blikace/blikac_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/automaticke_blikace/blikac_bb.png
--------------------------------------------------------------------------------
/index.md:
--------------------------------------------------------------------------------
1 | # Naše Arduino projekty
2 | **Rozhodl jsem se sepsat projekty, které provádím se svými dětmi a elektronikou.** Úkoly jsou různě obtížné, začali jsme někdy v 5 letech, postupně se prokousáváme dále, jak věkem, tak obsahem.
3 |
4 | [Literatury k Arduinu](https://arduino.cz/tag/ebook/) je všude dost, ale konkrétních příkladů co zkoušet s dětmi, už je podstatně méně. Nejsem žádný expert na elektroniku, ale snažím se ji nabídnout i těm nejmenším dětem tak, aby je to bavilo.
5 |
6 | Jde o rodinné zápisky, které slouží primárně proto, aby se mé děti mohly k úlohám vracet, respektive je sdílet se svými kamarády a podobně.
7 |
8 | > **Pozor, zápisky stále s dětmi doplňujeme!**
9 |
10 | 
11 |
12 | ## Licence
13 |
14 | Toto dílo podléhá licenci [Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)](https://creativecommons.org/licenses/by-sa/4.0/deed.cs).
15 |
16 | ## Obecné
17 | Všechny nápady se týkají Arduina, což nutně nemusí být Uno R3, ale klidně i Pro mini a podobné. Pokud jsme použili jiný mikrokontroler, uvádím to. Součátky je možné nakupovat v ČR i v zahraničí (obvykle levněji). SW programujeme v [Arduino IDE](https://www.arduino.cc/en/main/software). Pro kreslení schémat využíváme [Fritzing](http://fritzing.org).
18 |
19 | Ve všech projektech popisuji seznam součástek, ale Arduino board mezi nimi chybí, nechtěl jsem to jen neustále opakovat - prakticky všechny jsou za využití Arduina. Stejně tak neuvádím, že potřebujeme k projektu vodiče, nepájivé pole či napájení. Potřebujeme vždy.
20 |
21 | ## Řešené potíže
22 | Sem si zapisujeme, co nás kde potkalo. Převážně jde o potíže s operačním systémem a HW počítače.
23 |
24 | ### "Permission denied" při pokusu nahrát program do Arduina na Linuxu
25 | Uživatel musí být členem skupiny `dialout`.
26 | ``` bash
27 | $ sudo usermod -aG dialout
28 | ```
29 |
30 | ## Hraní s LEDkami
31 | * [Ruční blikače](rucni_blikace/rucni_blikace.md)
32 | * [Automatické blikače](automaticke_blikace/automaticke_blikace.md)
33 | * [Semafor](semafor/semafor.md)
34 | * [Knight rider](knight_rider/knight_rider.md)
35 | * Žížala
36 | * RGB LED
37 |
38 | ## Ovládnutí displejů
39 | * [Znakový LCD displej](lcd/lcd.md)
40 | * [OLED](oled/oled.md)
41 |
42 | ## Infra
43 | * Zmapování domácích vysílačů
44 | * Infra a LED
45 |
46 | ## Čidla
47 | * [Teploměr se 7 segmentovým LED](teplomer/teplomer.md)
48 | * [Ultrazvukové měření vzdálenosti s OLED](meric_vzdalenosti/meric_vzdalenosti.md)
49 | * [Čidlo hladiny vody ve stojanu na vánoční stromek](meric_stromku/meric_stromku.md)
50 | * Vlhkost půdy
51 | * Vlhkost vzduchu, teplota, nadmořská výška
52 |
53 | ## Ovládání
54 | * [Joystick](joystick/joystick.md)
55 |
56 | ## Hry a hraní
57 | * [Zkoušení matematiky](infra_matika/infra_matika.md) (dálkovým ovladačem od rádia ovládáme a na displeji počítáme)
58 | * [Touchduino](touchduino/touchduino.md) (hrajeme si s uzavřeným obvodem a propojujeme se modelínou)
59 | * [Nepřibližuj se!](nepriblizuj_se/nepriblizuj_se.md) (ultrazvukový senzor, reprák a mp3 přehrávač)
60 |
61 | ## [Maplebot](maplebot/maplebot.md)
62 |
63 | ## Plánujeme
64 | _(jinými slovy máme rozmyšleno, součástky jsou na cestě a nebo zrovna děláme něco jiného)_
65 | * Domovní zvonek na střídavých 20 V se dvěma melodiemi
66 | * Čidlo vlhkosti a teploty do koupelny se zvukovou signalizací pro zavření větracího okna
67 | * Světelná infra závora pro blbnutí na zahradě
68 | * Měření spotřeby vody v domě v reálném čase
69 |
--------------------------------------------------------------------------------
/infra_matika/IR-Receiver-AX-1838HS.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/IR-Receiver-AX-1838HS.pdf
--------------------------------------------------------------------------------
/infra_matika/P1370611.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/P1370611.JPG
--------------------------------------------------------------------------------
/infra_matika/P1370961.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/P1370961.JPG
--------------------------------------------------------------------------------
/infra_matika/P1370963.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/P1370963.JPG
--------------------------------------------------------------------------------
/infra_matika/P1370967.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/P1370967.JPG
--------------------------------------------------------------------------------
/infra_matika/P1370968.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/P1370968.JPG
--------------------------------------------------------------------------------
/infra_matika/P1370969.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/P1370969.JPG
--------------------------------------------------------------------------------
/infra_matika/P1370970.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/P1370970.JPG
--------------------------------------------------------------------------------
/infra_matika/P1370972.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/P1370972.JPG
--------------------------------------------------------------------------------
/infra_matika/P1370973.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/P1370973.JPG
--------------------------------------------------------------------------------
/infra_matika/aiwa_infra.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/aiwa_infra.fzz
--------------------------------------------------------------------------------
/infra_matika/aiwa_infra.ino:
--------------------------------------------------------------------------------
1 | /*
2 | * IRremote: IRrecvDump - dump details of IR codes with IRrecv
3 | * An IR detector/demodulator must be connected to the input RECV_PIN.
4 | * Version 0.1 July, 2009
5 | * Copyright 2009 Ken Shirriff
6 | * http://arcfn.com
7 | * JVC and Panasonic protocol added by Kristian Lauszus (Thanks to zenwheel and
8 | * other people at the original blog post)
9 | * LG added by Darryl Smith (based on the JVC protocol)
10 | */
11 | #include
12 |
13 | // pin, na kterém je připojen infra sensor
14 | int RECV_PIN = 13;
15 |
16 | // nastartovani IR knihovny
17 | IRrecv irrecv(RECV_PIN);
18 | decode_results results;
19 |
20 | void setup() {
21 | Serial.begin(9600); // konzole, kam se pisou vysledky
22 | irrecv.enableIRIn(); // nastartovani IR prijimace
23 | }
24 |
25 | void dump(decode_results *results) {
26 | // Dumps out the decode_results structure.
27 | // Call this after IRrecv::decode()
28 | int count = results->rawlen;
29 | if (results->decode_type == UNKNOWN) {
30 | Serial.print("Unknown encoding: ");
31 | } else if (results->decode_type == NEC) {
32 | Serial.print("Decoded NEC: ");
33 |
34 | } else if (results->decode_type == SONY) {
35 | Serial.print("Decoded SONY: ");
36 | } else if (results->decode_type == RC5) {
37 | Serial.print("Decoded RC5: ");
38 | } else if (results->decode_type == RC6) {
39 | Serial.print("Decoded RC6: ");
40 | } else if (results->decode_type == PANASONIC) {
41 | Serial.print("Decoded PANASONIC - Address: ");
42 | Serial.print(results->address, HEX);
43 | Serial.print(" Value: ");
44 | } else if (results->decode_type == LG) {
45 | Serial.print("Decoded LG: ");
46 | } else if (results->decode_type == JVC) {
47 | Serial.print("Decoded JVC: ");
48 | } else if (results->decode_type == AIWA_RC_T501) {
49 | Serial.print("Decoded AIWA RC T501: ");
50 | } else if (results->decode_type == WHYNTER) {
51 | Serial.print("Decoded Whynter: ");
52 | }
53 | Serial.print(results->value, HEX);
54 | Serial.print(" (");
55 | Serial.print(results->bits, DEC);
56 | Serial.println(" bits)");
57 | Serial.print("Raw (");
58 | Serial.print(count, DEC);
59 | Serial.print("): ");
60 |
61 | for (int i = 1; i < count; i++) {
62 | if (i & 1) {
63 | Serial.print(results->rawbuf[i] * USECPERTICK, DEC);
64 | } else {
65 | Serial.write('-');
66 | Serial.print((unsigned long)results->rawbuf[i] * USECPERTICK, DEC);
67 | }
68 | Serial.print(" ");
69 | }
70 | Serial.println();
71 | }
72 |
73 | void loop() {
74 | if (irrecv.decode(&results)) {
75 | Serial.println(results.value, HEX);
76 | // vypis, co jsi prijal, co jsi rozpoznal
77 | dump(&results);
78 |
79 | // tady jsme si zapisovali nase kody z dalkoveho ovladace k mikrovezi Aiwa
80 | switch (results.value) {
81 | case 0x76044FD4:
82 | Serial.println("NULA");
83 | break;
84 | case 0x76044FE0:
85 | Serial.println("JEDNICKA");
86 | break;
87 | case 0x76044FD0:
88 | Serial.println("DVOJKA");
89 | break;
90 | case 0x76044FF0:
91 | Serial.println("TROJKA");
92 | break;
93 | case 0x76044FC8:
94 | Serial.println("CTYRKA");
95 | break;
96 | case 0x76044FE8:
97 | Serial.println("PETKA");
98 | break;
99 | case 0x76044FD8:
100 | Serial.println("SESTKA");
101 | break;
102 | case 0x76044FF8:
103 | Serial.println("SEDMICKA");
104 | break;
105 | case 0x76044FC4:
106 | Serial.println("OSMICKA");
107 | break;
108 | case 0x76044FE4:
109 | Serial.println("DEVITKA");
110 | break;
111 | case 0x76044FC7:
112 | Serial.println("DESITKA");
113 | break;
114 | case 0x76044FDE:
115 | case 0x76044FF4:
116 | Serial.println("ENTER");
117 | break;
118 | case 0x76044FFE:
119 | Serial.println("DELETE");
120 | break;
121 | }
122 | irrecv.resume(); // prijmi dalsi hodnotu
123 | }
124 | }
125 |
--------------------------------------------------------------------------------
/infra_matika/aiwa_infra_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/aiwa_infra_bb.png
--------------------------------------------------------------------------------
/infra_matika/infra_matika.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/infra_matika.fzz
--------------------------------------------------------------------------------
/infra_matika/infra_matika.ino:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | // inicializace LCD
5 | // 1. parametr = pin Arduina, na ktery je pripojen RS pin LCD
6 | // 2. parametr = pin Arduina, na ktery je pripojen enable pin LCD
7 | // 3. - 6. parametr = piny Arduina, na ktere jsou pripojeny datove piny d4 - d7 z LCD
8 | LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
9 |
10 | // pin, na kterem prijimame infra signal
11 | const int RECV_PIN = 13;
12 | // pin pro cervenou LED
13 | const int LED_CHYBA = 9;
14 | // pin pro zelenou LED
15 | const int LED_OK = 10;
16 |
17 | // pocitadlo bodu
18 | int body = 0;
19 |
20 | // inicializace infracervene knihovny
21 | IRrecv irrecv(RECV_PIN);
22 | decode_results results;
23 |
24 | // do kolika vymysli priklady
25 | int max = 0;
26 |
27 | void setup() {
28 | // testovaci konzole
29 | // Serial.begin(9600);
30 | randomSeed(analogRead(0));
31 | irrecv.enableIRIn(); // nastartuj IR prijimac
32 | // nastartovani LCD displeje, pocet radek, pocet sloupcu
33 | lcd.begin(16, 2);
34 |
35 | // zeptame se, do kolika budeme generovat priklady
36 | lcd.print("Do kolika?");
37 | max = ctiDalkac(0, 1);
38 | lcd.clear();
39 |
40 | // pokud je to vice nez, tak to zarizneme
41 | if (max > 100) {
42 | lcd.print("To je moc,");
43 | lcd.setCursor(0, 1);
44 | lcd.print("jedeme do 100");
45 | max = 100;
46 | delay(3000);
47 | lcd.clear();
48 | }
49 |
50 | //text pro pocitani
51 | lcd.print("Vypocitej");
52 | }
53 |
54 | // precte hodnotu z dalkoveho ovladace Aiwa
55 | // x = pozice x na displeji
56 | // y = pozice y na displeji
57 | // vraci cislo, ktere nacetl, ocekava na konci enter, podporuje backspace pro mazani znaku
58 | int ctiDalkac(int x, int y) {
59 | bool enter = false;
60 | int vysledek = 0;
61 | int cisloDalkac = 0;
62 | int cislic = 0;
63 | lcd.setCursor(x, y);
64 | do {
65 | bool backspace = false;
66 | if (irrecv.decode(&results)) {
67 | switch (results.value) {
68 | case 0x76044FD4:
69 | cisloDalkac = 0;
70 | break;
71 | case 0x76044FE0:
72 | cisloDalkac = 1;
73 | break;
74 | case 0x76044FD0:
75 | cisloDalkac = 2;
76 | break;
77 | case 0x76044FF0:
78 | cisloDalkac = 3;
79 | break;
80 | case 0x76044FC8:
81 | cisloDalkac = 4;
82 | break;
83 | case 0x76044FE8:
84 | cisloDalkac = 5;
85 | break;
86 | case 0x76044FD8:
87 | cisloDalkac = 6;
88 | break;
89 | case 0x76044FF8:
90 | cisloDalkac = 7;
91 | break;
92 | case 0x76044FC4:
93 | cisloDalkac = 8;
94 | break;
95 | case 0x76044FE4:
96 | cisloDalkac = 9;
97 | break;
98 | case 0x76044FC7:
99 | cisloDalkac = 10;
100 | break;
101 | // backspace
102 | case 0x76044FFE: {
103 | if ((x > 0) && (cislic > 0)) {
104 | backspace = true;
105 | vysledek = vysledek / 10;
106 | x = x - 1;
107 | cislic = cislic - 1;
108 | lcd.setCursor(x, y);
109 | lcd.print(" ");
110 | lcd.setCursor(x, y);
111 | }
112 | break;
113 | }
114 | // enter
115 | case 0x76044FDE:
116 | case 0x76044FF4:
117 | enter = true;
118 | }
119 | if (!enter && !backspace && (cislic < 4)) {
120 | lcd.print(cisloDalkac);
121 | x = x + 1; // posun kurzor doprava
122 | vysledek = vysledek * 10 + cisloDalkac;
123 | cislic = cislic + 1;
124 | }
125 | irrecv.resume(); // nacti dalsi hodnotu
126 | }
127 | } while (!enter); // dokud jsi nedostal enter
128 | return vysledek; //vrat, co jsi nacetl (cislo)
129 | }
130 |
131 | // porovna zadane cislo se spravnym vysledkem
132 | // spravnyVysledek = kolik to melo byt
133 | // x = pozice na LCD
134 | void porovnej(int spravnyVysledek, int x) {
135 | int vysledek = ctiDalkac(x, 1);
136 | // Serial.println(vysledek);
137 | // Serial.println(spravnyVysledek);
138 | // Serial.println("----");
139 | lcd.setCursor(0, 1);
140 | lcd.print(" ");
141 | lcd.setCursor(0, 1);
142 | if (spravnyVysledek != vysledek) {
143 | lcd.print("CH Y B A !!!");
144 | digitalWrite(LED_CHYBA, HIGH);
145 | body = body - 1;
146 | } else {
147 | lcd.print("SPRAVNE");
148 | digitalWrite(LED_OK, HIGH);
149 | body = body + 1;
150 | }
151 | // chvilku pockej
152 | delay(800);
153 | digitalWrite(LED_CHYBA, LOW);
154 | digitalWrite(LED_OK, LOW);
155 | }
156 |
157 | // vypis body
158 | void vypisBody() {
159 | lcd.setCursor(12, 0);
160 | lcd.print(" ");
161 | lcd.setCursor(12, 0);
162 | lcd.print(body);
163 | }
164 |
165 | // vypis priklad
166 | String vypisPriklad(int a, int b, String znak) {
167 | lcd.setCursor(0, 1);
168 | String text = "";
169 | text = text + a;
170 | text = text + znak;
171 | text = text + b;
172 | text = text + "=";
173 | lcd.print(text);
174 | return text;
175 | }
176 |
177 | void scitani() {
178 | int scitanec1 = random(max + 1);
179 | int scitanec2 = random(max + 1 - scitanec1);
180 | int soucet = scitanec1 + scitanec2;
181 | vypisBody();
182 | String text = vypisPriklad(scitanec1, scitanec2, "+");
183 | porovnej(soucet, text.length());
184 | }
185 |
186 | void odcitani() {
187 | int mensenec = random(max + 1);
188 | int mensitel = random(mensenec + 1);
189 | int rozdil = mensenec - mensitel;
190 | vypisBody();
191 | String text = vypisPriklad(mensenec, mensitel, "-");
192 | porovnej(rozdil, text.length());
193 | }
194 |
195 | // hlavni smycka
196 | void loop() {
197 | // vymysli si nahodne, co budes zkouset, zda priklad na scitani nebo odcitani
198 | int co = random(2);
199 | if (co == 0) {
200 | scitani();
201 | } else {
202 | odcitani();
203 | }
204 | // vymazani casti displeje
205 | lcd.setCursor(0, 1);
206 | lcd.print(" ");
207 | }
208 |
--------------------------------------------------------------------------------
/infra_matika/infra_matika.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # Zkoušení matematiky pomocí infra
4 | Program, který zkouší děti ze sčítání a odčítání v předem zvoleném rozsahu. Příklady se generují náhodně, program dokonce počítá body. Při dobrém výsledku rozsvítí zelenou LED, při chybě červenou (a odečte bod). Je možné mít i záporné body. Výstup přes LCD, vstupem je infračervený dálkový ovladač.
5 |
6 | Tento projekt vám **nebude** fungovat ihned po zapojení a nahrátí programu. Je potřeba si jej upravit na svůj vlastní dálkový infra ovladač. My jsme vzali ten, který si nejlépe rozuměl s naším přijímačem, sepsali jsme si kódy, kterými jsme chtěli hru ovládat. Budete muset postupovat stejně, nepředpokládám, že byste doma našli náš dálkový ovladač od 20 let staré mikrověže Aiwa :-) Program pro zjištění kódů ovladače přikládám.
7 |
8 | ## Co je potřeba umět
9 | Tento projekt je z velké části postaven na pokusech s [LCD](../lcd/lcd.md) a [infra](TODO), tedy je dobré mít nějaké zkušenosti s displejem i s příjmem infra signálu. Z pohledu programování jde taktéž trochu o pokročilejší úlohu, ale dospělý může obtížná místa pomoci dítěti překonat.
10 |
11 | ## Foto
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | 
20 | 
21 |
22 | ## Hardware
23 | * LCD, my jsme použili Qapass 1602A, 16 znaků × 2 řádky ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170325123003&SearchText=1602a), [specifikace](../lcd/eone-1602a1.pdf))
24 | * infračervený sensor, my jsme použili AX-1838HS ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170326120050&SearchText=HX1838+), [specifikace](IR-Receiver-AX-1838HS.pdf))
25 | * 10 kΩ potenciometr
26 | * 3× 330 Ω rezistor
27 | * červená a zelená LED
28 | * jako vysílač signálu jsme využili dálkový ovladač k mikrověži Aiwa, ale lze využít prakticky cokoliv
29 |
30 | ## Schéma zapojení pro detekci kódů ovladače
31 | [aiwa_infra.fzz](aiwa_infra.fzz)
32 |
33 | [](aiwa_infra_bb.png)
34 |
35 | ## Program pro detekci kódů ovladače
36 | Program slouží k detekci jednotlivých kódů. Je založen na demo programu [IRrecvDump.ino](https://github.com/z3t0/Arduino-IRremote/blob/master/examples/IRrecvDump/IRrecvDump.ino), který vypisuje hodnoty, které detekuje na infrasenzoru. Tímto způsobem je možné zjistit, jaké kódy vysílá váš ovladač, zapsat si je a dále je využít pro ovládání vašich projektů. V případě dálkových ovladačů k zařízením jako je televize nebo rádio je dobré vybírat tlačítka, která je nespustí, aby pak šlo ovládat Arduino v jejich přítomnosti a nezapínat u toho televizi.
37 |
38 | [aiwa_infra.ino](aiwa_infra.ino)
39 | ``` c++
40 | {% include_relative aiwa_infra.ino %}
41 | ```
42 |
43 | ## Schéma zapojení infra matematiky
44 | [infra_matika.fzz](infra_matika.fzz)
45 |
46 | [](infra_matika_bb.png)
47 |
48 | ## Program infra matematiky
49 | [infra_matika.ino](infra_matika.ino)
50 | ``` c++
51 | {% include_relative infra_matika.ino %}
52 | ```
53 | ## Možná vylepšení
54 | * Další typy příkladů, např. násobení a dělení.
55 |
56 | ## Poznatky
57 | Velmi oblíběný projekt, který rozvíjel dále nápady, co by se dalo ještě vylepšit. Od samého počátku to byla dobrodružná akce, když jsme vybírali infra ovladač, kterým budeme hru ovládat, následně zapisovali kódy. Na přání dětí jsme přidali červenou a zelenou LED a mnoho vylepšení do kódu (např. ošetření maximálního počtu na otázku do kolika se budou příklady generovat). Výsledek sloužil opravdu k procvičování matematiky a to po dlouhé týdny, kdy to děti odmítaly rozebrat.
58 |
--------------------------------------------------------------------------------
/infra_matika/infra_matika_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/infra_matika/infra_matika_bb.png
--------------------------------------------------------------------------------
/joystick/P1130790.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/joystick/P1130790.JPG
--------------------------------------------------------------------------------
/joystick/P1130791.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/joystick/P1130791.JPG
--------------------------------------------------------------------------------
/joystick/P1130792.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/joystick/P1130792.JPG
--------------------------------------------------------------------------------
/joystick/P1130793.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/joystick/P1130793.JPG
--------------------------------------------------------------------------------
/joystick/P1130796.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/joystick/P1130796.JPG
--------------------------------------------------------------------------------
/joystick/joystick.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/joystick/joystick.fzz
--------------------------------------------------------------------------------
/joystick/joystick.ino:
--------------------------------------------------------------------------------
1 | #include "U8glib.h"
2 |
3 | // inicializace OLED
4 | U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE);
5 | // nastaveni pinu joysticku
6 | const int vy_pin = A0;
7 | const int vx_pin = A1;
8 | const int switch_pin = 7;
9 |
10 | const int sirka_displeje = 128;
11 | const int vyska_displeje = 64;
12 |
13 | const int mala_rychlost = 1;
14 | const int velka_rychlost = 5;
15 |
16 | // zobrazuje se pozdrav?
17 | int pozdrav = 0;
18 |
19 | // aktualni souradnice puntiku
20 | int x = 0;
21 | int y = 0;
22 | // nove souradnice punitku
23 | int nx = 0;
24 | int ny = 0;
25 |
26 | void setup() {
27 | // Serial.begin(9600);
28 | pinMode(vx_pin, INPUT);
29 | pinMode(vy_pin, INPUT);
30 | pinMode(switch_pin, INPUT);
31 | // zatim nevim proc
32 | digitalWrite(switch_pin, HIGH);
33 | }
34 |
35 | void vykresli(int x, int y) {
36 | u8g.setColorIndex(1);
37 | u8g.drawPixel(x, y);
38 | }
39 |
40 | void smaz(int x, int y) {
41 | u8g.setColorIndex(0);
42 | u8g.drawPixel(x, y);
43 | }
44 |
45 | int dejRychlost(int joystick) {
46 | if (joystick > 850) {
47 | return velka_rychlost;
48 | } else if (joystick > 650) {
49 | return mala_rychlost;
50 | } else if (joystick < 150) {
51 | return -velka_rychlost;
52 | } else if (joystick < 350) {
53 | return -mala_rychlost;
54 | }
55 | return 0;
56 | }
57 |
58 | void loop() {
59 | // precti stav joysticku
60 | int vx = analogRead(vx_pin);
61 | int vy = analogRead(vy_pin);
62 | int sw = digitalRead(switch_pin);
63 | // Serial.println(sw);
64 |
65 | // detekce, zda je stisknuty spinac, stisknuto = LOW
66 | if (sw == LOW) {
67 | if (pozdrav == 0) {
68 | pozdrav = 1;
69 | } else {
70 | pozdrav = 0;
71 | }
72 | }
73 |
74 | // zobraz pozdrav
75 | if (pozdrav == 1) {
76 | u8g.setFont(u8g_font_osb18);
77 | // vykresli napis
78 | u8g.firstPage();
79 | do {
80 | u8g.drawStr(20, 25, "A H O J");
81 | u8g.drawStr(55, 55, ":-)");
82 | } while (u8g.nextPage());
83 | } else {
84 | // spocitej posun
85 | nx = x + dejRychlost(vx);
86 | ny = y + dejRychlost(vy);
87 | // ohraniceni displejem, kontrola rozsahu, aby to nepodlezlo
88 | if (nx < 0) {
89 | nx = 0;
90 | }
91 | if (ny < 0) {
92 | ny = 0;
93 | }
94 | if (nx >= sirka_displeje) {
95 | nx = sirka_displeje - 1;
96 | }
97 | if (ny >= vyska_displeje) {
98 | ny = vyska_displeje - 1;
99 | }
100 | // pokud se nekam pohnul, tak smaz stary bodik
101 | if ((nx != x) || (ny != y)) {
102 | smaz(x, y);
103 | }
104 | // vykresli novy
105 | u8g.firstPage();
106 | do {
107 | vykresli(nx, ny);
108 | } while (u8g.nextPage());
109 | x = nx;
110 | y = ny;
111 | }
112 | delay(5);
113 | }
114 |
--------------------------------------------------------------------------------
/joystick/joystick.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # Joystick
4 | Testování analogového joystickového ovladače, který umožňuje pohyb do všech směrů včetně stisku tlačítka. Zkusili jsme naprogramovat ovládání jednopixelového puntíku, analogový signál z joysticku převádíme na 2 rychlosti (pomalu a rychle) a na stisk tlačítka se zobrazí pozdrav. Jenom jednoduché cvičení, které se může hodit pro další úlohy.
5 |
6 | ## Co je potřeba umět
7 | Ovládání [OLED](../oled/oled.md) displeje.
8 |
9 | ## Foto
10 | 
11 | 
12 | 
13 | 
14 | 
15 |
16 | ## Video
17 |
18 |
19 |
23 |
24 |
25 | ## Hardware
26 | * OLED displej, my použili SSD1306 ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170322115850&SearchText=OLED+0.96))
27 | * joystick ([Aliexpress](https://www.aliexpress.com/wholesale?ltype=wholesale&d=y&origin=y&isViewCP=y&catId=0&initiative_id=SB_20170429111439&SearchText=arduino+joystick&blanktest=0&tc=af))
28 |
29 | ## Jak to funguje
30 | Joystick dává na pinech `vx` a `vy` analogový signál, takže připojujeme na analogové piny Arduina. `A4` a `A5` máme rezervované pro I2C z OLED, tak si vybereme jiné 2. Pin `switch` pak dává digitální hodnotu, zda je tlačítko stisknuto.
31 |
32 | ## Schéma zapojení
33 | [joystick.fzz](joystick.fzz)
34 |
35 | [](joystick_bb.png)
36 |
37 | ## Program
38 | [joystick.ino](joystick.ino)
39 | ```c++
40 | {% include_relative joystick.ino %}
41 | ```
42 | ## Možná vylepšení
43 | * Plynulejší přenášení rychlosti joysticku: je možné se seznámit s mapovací funkcí [map()](https://www.arduino.cc/en/reference/map), která umí automaticky přepočítávat hodnoty mezi rozsahy (např. hodnotu z rozsahu analogového pinu 0 až 1023 na rozsah -10 až 10, tedy počet pixelů, o který se bude puňta posouvat).
44 |
45 | ## Poznatky
46 | * Opět překvápko, myslel jsem si, že to bude celkem nezáživná věc prohánět po pidispleji 1 pixel, ale děti to bavilo hodně. Radost z prvního posunutí (byť s chybami) byla ohromná.
47 | * Zatím nevím, proč se v sekci `setup()` musí do digitálního pinu tlačítka zapsat `HIGH` (a následně detekujeme stisk tlačítka na tomto pinu jako `LOW`). Ale bez tohoto fíglu nám to nejelo.
48 | * K tomu, abychom mohli např. po stisku tlačítka malovat, by bylo potřeba si pamatovat vše, co jsme kam namalovali (videopaměť), displej sám si nic nepamatuje a je potřeba ho neustále obnovovat, tedy v každou chvíli je nutné vědět, co se má vykreslit. Displej má rozlišení 128×64, což je celkem 8192 pixelů, není tedy možné si jen tak vyseknout dvourozměrné pole v SRAM paměti Arduina, protože [ta má pouhé 2KiB](https://www.arduino.cc/en/tutorial/memory), je potřeba informace uchovávat po bitech, ale i pak nám bude zabírat naše malá videopaměť celou polovinu SRAM (8192 / 8 = 1024). Vyzkoušíme někdy příště.
49 |
--------------------------------------------------------------------------------
/joystick/joystick.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/joystick/joystick.mp4
--------------------------------------------------------------------------------
/joystick/joystick_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/joystick/joystick_bb.png
--------------------------------------------------------------------------------
/knight_rider/P1130683.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/knight_rider/P1130683.JPG
--------------------------------------------------------------------------------
/knight_rider/P1130684.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/knight_rider/P1130684.JPG
--------------------------------------------------------------------------------
/knight_rider/P1130685.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/knight_rider/P1130685.JPG
--------------------------------------------------------------------------------
/knight_rider/P1130686.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/knight_rider/P1130686.JPG
--------------------------------------------------------------------------------
/knight_rider/P1130687.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/knight_rider/P1130687.JPG
--------------------------------------------------------------------------------
/knight_rider/knight_rider.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/knight_rider/knight_rider.fzz
--------------------------------------------------------------------------------
/knight_rider/knight_rider.ino:
--------------------------------------------------------------------------------
1 | void setup() {
2 | // nastaveni pinu pro zapis
3 | pinMode(2, OUTPUT);
4 | pinMode(3, OUTPUT);
5 | pinMode(4, OUTPUT);
6 | pinMode(5, OUTPUT);
7 | pinMode(6, OUTPUT);
8 | }
9 |
10 | void loop() {
11 | // problikni LED na pinech 2 az 6
12 | for (int i = 2; i < 7; i++) {
13 | digitalWrite(i, HIGH);
14 | delay(50);
15 | digitalWrite(i, LOW);
16 | delay(50);
17 | }
18 | // problikni LED na pinech 5 az 3
19 | for (int i = 5; i > 2; i--) {
20 | digitalWrite(i, HIGH);
21 | delay(50);
22 | digitalWrite(i, LOW);
23 | delay(50);
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/knight_rider/knight_rider.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # K.I.T.T. Knight rider
4 | Blikání LED podobné [K.I.T.T. ovi](https://www.google.com/search?q=k.i.t.t.&client=firefox-b&source=lnms&tbm=isch&sa=X&ved=0ahUKEwiKlIyOs-fSAhUDOpoKHY5WBcAQ_AUICCgB&biw=1600&bih=793) Lze naprogramovat i bez cyklů, jen je potřeba u toho více psát.
5 |
6 | ## Co je potřeba umět
7 | Základy zapojování LED. Základní programové konstrukce pro ovládání digitálních pinů Arduina. Cykly jsou výhodou.
8 |
9 | ## Foto
10 | 
11 | 
12 | 
13 | 
14 | 
15 |
16 | ## Video
17 |
18 |
19 |
23 |
24 |
25 |
26 | ## Hardware
27 | * dostatek různě barevných LED, některé se asi spálí
28 | * rezistory 220 Ω - 330 Ω
29 |
30 | ## Schéma zapojení
31 | [knight_rider.fzz](knight_rider.fzz)
32 |
33 | [](knight_rider_bb.png)
34 |
35 | ## Program
36 | [knight_rider.ino](knight_rider.ino)
37 | ```c++
38 | {% include_relative knight_rider.ino %}
39 | ```
40 | ## Možná vylepšení
41 |
42 | ## Poznatky
43 | Pokud jsou pro děti cykly obtížné (a to často jsou), ničemu nevadí, když kopírují hromady kódu. Časem je to přestává bavit a samy se začínají ptát, zda se to nedá udělat nějak lépe, aby se to pořád nemusel kopírovat. Výše uvedený program s Knight riderem v této podobě dítě do 8 let nenapíše. V prvních chvílích není ani tak důležité, aby děti rozuměly všemu, vo se v kódu píše, ale aby to blikalo.
44 |
--------------------------------------------------------------------------------
/knight_rider/knight_rider.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/knight_rider/knight_rider.mp4
--------------------------------------------------------------------------------
/knight_rider/knight_rider_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/knight_rider/knight_rider_bb.png
--------------------------------------------------------------------------------
/lcd/P1130017.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/lcd/P1130017.JPG
--------------------------------------------------------------------------------
/lcd/P1130018_crop_.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/lcd/P1130018_crop_.jpg
--------------------------------------------------------------------------------
/lcd/P1360312.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/lcd/P1360312.JPG
--------------------------------------------------------------------------------
/lcd/P1370937.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/lcd/P1370937.JPG
--------------------------------------------------------------------------------
/lcd/P1370954.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/lcd/P1370954.JPG
--------------------------------------------------------------------------------
/lcd/eone-1602a1.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/lcd/eone-1602a1.pdf
--------------------------------------------------------------------------------
/lcd/lcd.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/lcd/lcd.fzz
--------------------------------------------------------------------------------
/lcd/lcd.ino:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | // inicializace LCD
4 | // 1. parametr = pin Arduina, na ktery je pripojen RS pin LCD
5 | // 2. parametr = pin Arduina, na ktery je pripojen enable pin LCD
6 | // 3. - 6. parametr = piny Arduina, na ktere jsou pripojeny datove piny d4 - d7 z LCD
7 | LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
8 |
9 | void setup() {
10 | // nastartuj LCD(pocet_sloupcu, pocet_radek)
11 | lcd.begin(16, 2);
12 | lcd.print("Jsme frajeri!");
13 | }
14 |
15 | void loop() {
16 | // zatim nic
17 | }
18 |
--------------------------------------------------------------------------------
/lcd/lcd.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # LCD displej
4 | Já vím, já vím, je to stejné, jako psát CD disk, přičemž zkratka CD už sama o sobě obsahuje slovo disk (Compact disc), tak i LCD znamená Liquid crystal display, tedy displej s tekutými krystaly. Nicméně mezi neodbornou veřejností je to zkratka označující typ displeje.
5 |
6 | Tato úloha slouží pouze k osahání displeje jako takového. K řádnému připojení, vyzkoušení, že vše funguje a až ho budeme někde potřebovat, tak už to budeme umět.
7 |
8 | ## Co je potřeba umět
9 | Displej je obvykle s "dírkami" místo pinů. Ty jsou dobré k pájení obvodů, ale už podstatně méně se hodí k prototypování, tedy rozebíratelnému spojování obvodů na zkoušku. Je tedy dobré ho nejdříve opatřit "hřebenem". Na tom může dítě nacvičit pájení. Spoje se samozřejmě nesmí nikde dotýkat.
10 |
11 | ## Foto
12 |
13 | 
14 | 
15 | 
16 | 
17 | 
18 |
19 | ## Hardware
20 | * LCD, my jsme použili Qapass 1602A, 16 znaků × 2 řádky ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170325123003&SearchText=1602a), [specifikace](eone-1602a1.pdf))
21 | * 10 kΩ potenciometr
22 | * 330 Ω rezistor
23 |
24 | ## Jak to funguje
25 | Zapojení vychází z [jednoduchého příkladu](https://www.arduino.cc/en/Tutorial/HelloWorld) a využívá programově knihovnu [LiquidCrystal](https://www.arduino.cc/en/Reference/LiquidCrystal). Potenciometr slouží k regulaci intenzity podsvětlení displeje.
26 |
27 | ## Schéma zapojení
28 | [lcd.fzz](lcd.fzz)
29 |
30 | [](lcd_bb.png)
31 |
32 | ## Program
33 | [lcd.ino](lcd.ino)
34 | ``` c++
35 | {% include_relative lcd.ino %}
36 | ```
37 | ## Možná vylepšení
38 | * Libovolný jiný text :-)
39 | * Vyzkoušení dalších možností knihovny [LiquidCrystal](https://www.arduino.cc/en/Reference/LiquidCrystal), jako pozicování kurzoru, posouvání textu, jiné znaky apod.
40 |
41 | ## Poznatky
42 | Pájení není vůbec lehký úkol, ale trénuje to motoriku a rozhodně patří pro děti k těm zajímavým :-) Radost z vlastních textů na displeji je samozřejmě také nefalšovaná.
--------------------------------------------------------------------------------
/lcd/lcd_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/lcd/lcd_bb.png
--------------------------------------------------------------------------------
/maplebot/maplebot.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # Maplebot
4 | Pokus o vytvoření jezdícího robota reagujícího na příkazy předáváné bezdrátově, nejlépe přímo pomocí dětského programovacího jazyka. Maplebot je stále projekt _"s dětmi"_ ne jen _"pro děti"_.
5 |
6 | ---
7 | ## Robopixle
8 | Robopixle byla náš první projekt, kde se něco pohybuje a současně, kde jsme museli vzít vrtačku. Původní verze měla být dokonce ovládaná pro jednoduchost přes infra. Ale infra jsem omylem upálil, takže další v pořadí v krabičce bylo Bluetooth. Cíl je někde na Wifi/MQTT, ale na to jsme také neměli v šuplíku vybavení. To jsou plány na další verze.
9 |
10 |
11 | [Robopixle - ovládání přes Bluetooth z Python konzole](robopixle_bt/robopixle_bt.md)
12 |
13 | ---
14 |
15 | ## Maplebot verze 2
16 | 1. [Flash Micropythonu do NodeMCU](nodemcu_flash_micropython/nodemcu_flash.md)
17 | 1. [Konzole REPL, WebREPL AP, WebREPL klient](nodemcu_repl_webrepl/nodemcu_repl_webrepl.md)
18 |
19 | TODO
20 | * Základní postřehy k vývoji v Micropythonu na NodeMCU
21 | * Sestavení podvozku robota, základní pohyb
22 | * PID regulace pohybu
23 | * Signalizace (ne)připojení na Wifi
24 | * MQTT
25 | * Scratch extension + local proxy
26 | * Server pro propojení robota a Scratch
27 | * Čidla (vzdálenost, barva, pohyb?)
28 | * Displej?
29 |
--------------------------------------------------------------------------------
/maplebot/nodemcu_flash_micropython/P1210247.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/nodemcu_flash_micropython/P1210247.JPG
--------------------------------------------------------------------------------
/maplebot/nodemcu_flash_micropython/P1210248.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/nodemcu_flash_micropython/P1210248.JPG
--------------------------------------------------------------------------------
/maplebot/nodemcu_flash_micropython/device_manager.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/nodemcu_flash_micropython/device_manager.png
--------------------------------------------------------------------------------
/maplebot/nodemcu_flash_micropython/nodemcu_flash.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../../index.md)
2 |
3 | [← zpět na Maplebot](../maplebot.md)
4 |
5 | # Flash firmware Micropythonu do NodeMCU (ESP8266)
6 | _Tuto sekci jsem prováděl bez dětí. Flashování firmware není zrovna záživná záležitost. Nicméně jednou se k ní děti třeba vrátí, až si budou chtít přeflashovat svoje NodeMCU :-)_
7 |
8 | * obsah
9 | {:toc}
10 | {::options toc_levels="2..4" /}
11 |
12 | Pořídil jsem několik [NodeMCU devkitů](https://github.com/nodemcu/nodemcu-devkit-v1.0) šlapajících na ESP8266. Tyto čipy díky svému výkonu (v základu 80 MHz, [lze zvýšit až na 160 MHz](http://www.instructables.com/id/ESP8266-NodeMCU-CPU-Speed-Test/) - což i výkon zvýší asi dvojnásobně) zvládají nejen Wifi, ale i interpretované jazyky. Obvykle se nabízí ke koupi s předchystaným interpretem jazyka [Lua](https://www.lua.org/) (vlastně spíš [eLua](http://www.eluaproject.net/)), ale je možné jej vyměnit i za [Micropython](https://micropython.org/) nebo Arduino (programujeme pak v jazyce Wiring, který je velmi podobný C/C++).
13 |
14 | 
15 | 
16 |
17 | Zvolil jsem nakonec Micropython. Nechtělo se mi učit jazyk Lua a C++ je zase trochu nemotorné pro výuku dětí. Má to své [výkonové dopady](http://esp8266freq.blogspot.cz/2016/12/esp-speed-compare-in-lua-micropython.html) (Lua je zhruba 20× pomalejší než C++, Micropython asi 10×), ale jsem s tím srozuměn a jdeme to zkusit. Vždy můžeme flashovat něco jiného.
18 |
19 | > Tohle je návod, jak nahrát nový firmware právě do NodeMCU. Vlastní flash firmware jsem prováděl na Windows i Linux, návod popisuje obě platformy.
20 |
21 | ## Co je potřeba umět
22 | * Trochu se orientovat v příkazové řádce
23 |
24 | ## Hardware
25 | * NodeMCU devkit (ESP8266), použil jsem od výrobce Lolin ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170926132515&SearchText=nodemcu))
26 | * microUSB kabel
27 |
28 | ## Software
29 | Aneb někdy taky toolchain. SW nářadí, které bude potřeba.
30 | * [Driver NodeMCU](https://github.com/nodemcu/nodemcu-devkit/tree/master/Drivers)
31 | * [Python](https://www.python.org/downloads/) (na Linuxu nejspíš už máte)
32 | * [Esptool](https://github.com/espressif/esptool)
33 | * [Micropython firmware](http://micropython.org/download#esp8266)
34 |
35 | ## Postup
36 | ### 1. Stáhnout a nainstalovat NodeMCU driver
37 | aby ho rozpoznal operační systém. [NodeMCU driver najdeme zde](https://github.com/nodemcu/nodemcu-devkit/tree/master/Drivers).
38 |
39 | ### 2. Připojit NodeMCU k počítači přes microUSB kabel
40 |
41 | ### 3. Zjistit, na jakém portu se objevil
42 | **Windows** (nemám bohužel českou verzi)
43 | * Control panels/Device manager
44 | * Pod záložkou Ports (COM & LPT) najít, kde ho máme
45 |
46 | 
47 |
48 | **Linux**
49 | ``` shell
50 | ls -l /dev/tty*
51 | ```
52 | nebo ještě lépe
53 | ``` shell
54 | dmesg | tail
55 | ```
56 |
57 | ### 4. Nainstalovat Python
58 | [Brát verzi 3.x](https://www.python.org/downloads/), na Linuxu velmi pravděpodobně už Python je.
59 |
60 | ### 5. Získat Esptool
61 | Nástroj napsaný v pythonu pro flashování ESP8266 z příkazové řádky. Lze ho stáhnout přímo z [Githubu](https://github.com/espressif/esptool) a nebo je možné ho samozřejmě nainstalovat přímo přes pip:
62 | ``` shell
63 | pip install esptool
64 | ```
65 |
66 | ### 6. Zjistit typ čipu
67 | Pokud jsme zvědaví, můžeme zjistit typ čipu.
68 | ``` shell
69 | python esptool.py --port flash_id
70 | ```
71 | Kde `` je náš port, kde se NodeMCU zrovna nachází. Pro Windows tedy nějak takto:
72 | ``` shell
73 | python esptool.py --port COM28 flash_id
74 | ```
75 | Pro Linux pak třeba takto:
76 | ``` shell
77 | python esptool.py --port /dev/ttyUSB0 flash_id
78 | ```
79 | A dostaneme nějakou podobnou odpověď
80 | ``` shell
81 | esptool.py v2.2-dev
82 | Connecting....
83 | Detecting chip type... ESP8266
84 | Chip is ESP8266EX
85 | Uploading stub...
86 | Running stub...
87 | Stub running...
88 | Manufacturer: c8
89 | Device: 4016
90 | Detected flash size: 4MB
91 | Hard resetting...
92 | ```
93 |
94 | ### 7. Zjistit MAC adresu
95 | Můžeme si nechat prozradit i MAC adresu zařízení.
96 | ``` shell
97 | python esptool.py --port read_mac
98 | ```
99 | ``` shell
100 | esptool.py v2.2-dev
101 | Connecting....
102 | Detecting chip type... ESP8266
103 | Chip is ESP8266EX
104 | Uploading stub...
105 | Running stub...
106 | Stub running...
107 | MAC: 70:01:88:20:22:21
108 | Hard resetting...
109 | ```
110 |
111 | ### 8. Stáhnout Micropython firmware pro ESP8266
112 | Stahujeme [bin soubor](http://micropython.org/download#esp8266).
113 |
114 | * Pokud bychom chtěli flashnout (zpátky) [inpterpret Lua](https://github.com/nodemcu/nodemcu-firmware), je nutné si soubor sestavit ve vlastní režii ze zdrojáků a nebo si ho nechat sestavit on demand službou [NodeMCU custom builds](https://nodemcu-build.com/) - a vybrat si jen moduly, které potřebujeme.
115 | * Můžeme také [NodeMCU programovat jako Arduino](https://github.com/esp8266/Arduino/) v jazyce Wiring (pak je možné ho programovat i v Arduino IDE). Board manager v Arduino IDE se pak postará o to, že sestaví pokaždé celý firmware ESP8266 SDK spolu s naším programem a flashuje vše do NodeMCU. To znamená, že jednoduchý program na bliknutí LED pak může mít i 250 KiB.
116 |
117 | ### 9. Přepnout NodeMCU do flash režimu
118 | Některé návody uvádí, že je potřeba vždy uvést čip do flash režimu pomocí tlačítek Flash a Reset. Jiné pak doplňují, že je to hodně hardwarově závislé a pokud má deska USB konektor, USB-serial konvertor a DTR + RTS piny, tak že si to [vše obstará sama bez naší asistence](https://docs.micropython.org/en/latest/esp8266/esp8266/tutorial/intro.html#deploying-the-firmware).
119 |
120 | [NodeMCU se umí samo přepnout do flash režimu](https://nodemcu.readthedocs.io/en/master/en/flash/#putting-device-into-flash-mode). Tento krok tedy uvádím jen pro úplnost. Netřeba nic dělat.
121 |
122 | ### 10. Smazat obsah flash
123 | Některé návody se o tom nezmiňují, jiné [píší o tom](https://docs.micropython.org/en/latest/esp8266/esp8266/tutorial/intro.html#deploying-the-firmware), že mnoho potíží je zapřičiněno tím, že předchozí firmware není řádně vymazán. Proto doporučuji nejdříve flash smazat.
124 | ``` shell
125 | python esptool.py --port erase_flash
126 | ```
127 | ``` shell
128 | esptool.py v2.2-dev
129 | Connecting....
130 | Detecting chip type... ESP8266
131 | Chip is ESP8266EX
132 | Uploading stub...
133 | Running stub...
134 | Stub running...
135 | Erasing flash (this may take a while)...
136 | Chip erase completed successfully in 5.3s
137 | Hard resetting...
138 | ```
139 |
140 | ### 11. Zapsat nový firmware do NodeMCU
141 | ``` shell
142 | python esptool.py --baud 115200 --port write_flash --flash_mode dio 0x00000 .bin
143 | ```
144 | kde
145 | * `baud` = rychlost zápisu (počet bitů za sekundu), raději neměnit, nekterá zařízení to nemají ráda
146 | * `port` = náš port, kde je NodeMCU
147 | * `write_flash` = příkaz pro zápis firmware do flash
148 | * `flash_mode` = pro NodeMCU **nutně `dio`**, na několika místech jsem se dočetl, že většina desek přežije parametr `qio`, pak že dochází k automatické detekci pro flash > 4 MB, ale stálo mě to více než 2h, než jsem přišel na to, že pro NodeMCU v3 je nutné tento parametr uvést
149 | * 0x00000 = adresa, od které se začíná flashovat - pokud se sestavuje firmware ze zdrojáků, [jsou to obvykle 2 soubory a každý jde od jiné adresy](https://nodemcu.readthedocs.io/en/master/en/flash/#which-files-to-flash)
150 | * `micropython_esp_firmware` = firmware, který tlačíme do NodeMCU
151 |
152 | Případné další parametry lze nastudovat v [dokumentaci esptool](https://github.com/espressif/esptool).
153 |
154 | > Celá operace chvíli trvá (zhruba do minuty).
155 |
156 | ``` shell
157 | esptool.py v2.2-dev
158 | Connecting....
159 | Detecting chip type... ESP8266
160 | Chip is ESP8266EX
161 | Uploading stub...
162 | Running stub...
163 | Stub running...
164 | Configuring flash size...
165 | Auto-detected Flash size: 4MB
166 | Flash params set to 0x0240
167 | Compressed 601136 bytes to 392067...
168 | Wrote 601136 bytes (392067 compressed) at 0x00000000 in 34.6 seconds (effective 138.8 kbit/s)...
169 | Hash of data verified.
170 | Leaving...
171 | Hard resetting...
172 | ```
173 |
174 | ### 12. Test
175 | Je dobré udělat test. Prvních několik flashů se mi nepovedlo (nenastavil jsem `--flash-mode`) a nikdo neprotestoval (ani NodeMCU, ani `esptool`).
176 |
177 | Flash Micropythonu se nejlépe ověří přihlášením do konzole Micropythonu. Jsou v zásadě 3 způsoby, REPL, WebREPL AP a WebREPL klient.
178 |
179 | [Jak rozběhat Micropython REPL/WebREPL](../nodemcu_repl_webrepl/nodemcu_repl_webrepl.md)
180 |
--------------------------------------------------------------------------------
/maplebot/nodemcu_repl_webrepl/nodemcu_repl_webrepl.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../../index.md)
2 |
3 | [← zpět na Maplebot](../maplebot.md)
4 |
5 | # Jak rozchodit konzoli Micropythonu
6 | * obsah
7 | {:toc}
8 | {::options toc_levels="2..4" /}
9 |
10 | Poté, co [zdárně nahrajeme Micropython do NodeMCU](../nodemcu_flash_micropython/nodemcu_flash.md), bychom se potřebovali nejlépe nějak přihlásit k NodeMCU do Python konzole. V zásadě existují 3 způsoby: REPL, WebREPL AP, WebREPL klient. REPL je zkratka pro Read Evaluate Print Loop a v zásadě to pro nás znamená tu vzdálenou konzoli.
11 |
12 | ## REPL
13 | Do REPL NodeMCU se dostaneme přes USB kabel libovolným sériovým terminálem.
14 |
15 | **Windows**
16 | Oblíbený terminál [putty](http://www.putty.org/) s parametry:
17 | * typ připojení: serial
18 | * port: náš port, přes který je NodeMCU připojen na USB
19 | * rychlost 115200
20 | * data bits 8, stop bits 1, no parity, no flow
21 |
22 | 
23 |
24 | Po připojení je někdy potřeba stisknout tlačítko `Reset` na NodeMCU. Prvních zmatených znaků si nevšímáme a do konzole píšeme:
25 | ```python
26 | >>> print("Hura, zije to!")
27 | ```
28 | 
29 |
30 | Další informace bychom získali třeba
31 | ```python
32 | >>> help()
33 | ```
34 |
35 | 
36 |
37 | **Linux**
38 | * Lze použít např. terminál [screen](https://www.gnu.org/software/screen/manual/screen.html) či třeba [picocom](http://manpages.ubuntu.com/manpages/zesty/man8/picocom.8.html).
39 | ```shell
40 | screen /dev/ttyUSB0 115200
41 | ```
42 | ```shell
43 | picocom -b 115200 /dev/ttyUSB0
44 | ```
45 |
46 | 
47 |
48 | ## WebREPL AP
49 | Přihlásit se do Micropython konzole lze samozřejmě i vzduchem. Micropython nastartuje automaticky svoje Wifi AP, pokud si nepřejeme něco jiného. Připojení do takového AP je praktické např. v případech, kdy není na blízku router, jsme v neznámém prostředí (na robosoutěži, na přednášce, na konferenci) a chceme se připojit do WebREPL konzole.
50 |
51 | 
52 |
53 | Pokud se přihlásíme do sítě NodeMCU, můžeme se tak dostat pomocí WebREPL do konzole Micropythonu. WebREPL je speciální Javascript app, kterou si můžeme [stáhnout lokálně](https://github.com/micropython/webrepl), ale která běží i [hostovaná online](http://micropython.org/webrepl/).
54 |
55 | Nejdříve je však potřeba WebREPL povolit, jelikož výchozí nastavení je vypnuto.
56 |
57 | 1. NodeMCU připojit přes USB kabel.
58 | 1. Přihlásit se seriovým terminálem do [REPL](#repl)
59 | 1. Z konzole spustit:
60 | ```python
61 | import webrepl_setup
62 | ```
63 | 4. Povolíme WebREPL a nastavíme heslo do WebREPL konzole.
64 | 1. Odpojit NodeMCU od počítače. Vyhledat jiný zdroj napájení pro NodeMCU, třeba USB adaptér nebo baterie.
65 | 1. Přihlásíme se do wifi sítě NodeMCU - [heslo do Micropython wifi je](http://docs.micropython.org/en/latest/esp8266/esp8266/tutorial/intro.html#wifi) `micropythoN` (pozor, připojením ztratíme internet - budeme v síti NodeMCU).
66 | 1. Jdeme do WebREPL konzole, IP adresa našeho malého NodeMCU AP je `192.168.4.1`. Connect.
67 | 1. Zadat naše heslo a jsme tam.
68 |
69 | 
70 |
71 | ## WebREPL klient
72 | Mnohem praktičtější a asi běžnější je pro vývoj připojení NodeMCU do lokální Wifi sítě k našemu routeru. Chová se pak jako standardní WiFi klient a my můžeme přistupovat současně na NodeMCU i na internet.
73 |
74 | 1. Připojit se do NodeMCU (přes [REPL](#repl), ne přes WebREPL, protože nastavení způsobí změnu WiFi).
75 | 1. Přímo v REPL konzoli nakonfigurujeme Micropython tak, aby se připojil automaticky k naší WiFi:
76 | ``` python
77 | import network
78 | wlan = network.WLAN(network.STA_IF)
79 | wlan.active(True)
80 | wlan.connect('ssid', 'password') # dopln si sve SSID a heslo
81 | ```
82 | 3. Po chvíli se NodeMCU připojí k WiFi. Výsledek můžeme zkontrolovat pomocí:
83 | ``` python
84 | wlan.ifconfig()
85 | ```
86 | 4. Můžeme vidět, že běží 2 rozhraní:
87 | ``` python
88 | import webrepl
89 | webrepl.start()
90 | ```
91 | //TODO: obrázek
92 |
93 | 5. Otevřeme WebREPL a připojíme se na IP adresu, kterou NodeMCU dostalo v naší síti.
94 |
95 | //TODO: obrázek
96 |
97 | ## Vypnutí debug výstupu
98 | NodeMCU si pamatuje vždy poslední WiFi, ke které se připojoval a bude se k ní připojovat vždy po startu. Ne žádnou předchozí, takže při změně na jinou WiFi a zpět na původní je potřeba vždy znovu konfigurovat.
99 |
100 | Je proto velmi praktické vypnout debug výstup - pokud přeneseme NodeMCU mimo dosah sítě, bude se pokoušet připojit a bude sypat debug hlášení o tom, že to nejde. Tato hlášení mohou zabránit přístupu k REPL konzoli, protože ta neočekává tenhle debug výstup.
101 | ``` python
102 | import esp
103 | esp.osdebug(None)
104 | ```
105 | Tyto příkazy bychom ale museli psát pokaždé, co NodeMCU nabootuje, takže je dobré je strčit rovnou do souboru `boot.py`, který se volá pokaždé, když zařízení bootuje (s Micropythonem).
106 |
107 | K tomu budeme potřebovat python program [Ampy](https://github.com/adafruit/ampy), který slouží pro přenos souborů tam i zpět. Pozor: přístup přes `ampy` není možné využívat souběžně s REPL konzolí.
108 |
109 | 1. Instalace Ampy:
110 | ``` shell
111 | pip install adafruit-ampy
112 | ```
113 | 2. stažení aktuálního `boot.py` z NodeMCU:
114 | ``` shell
115 | ampy --port get boot.py > boot.py
116 | ```
117 | 3. do souboru `boot.py` přidáme na konec:
118 | ``` python
119 | import esp
120 | esp.osdebug(None)
121 | ```
122 | 4. nahrajeme zpět do NodeMCU:
123 | ``` shell
124 | ampy --port put boot.py
125 | ```
126 |
127 | Více příkazů `ampy` je možné získat pomocí:
128 | ``` shell
129 | ampy --help
130 | ```
131 |
132 | Alternativně je možné provést stažení a nahrátí souboru pomocí experimentálního rozhraní pro přenos souborů v konzoli WebREPL.
133 |
134 |
135 | //TODO: obrázek
136 |
--------------------------------------------------------------------------------
/maplebot/nodemcu_repl_webrepl/putty_config.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/nodemcu_repl_webrepl/putty_config.png
--------------------------------------------------------------------------------
/maplebot/nodemcu_repl_webrepl/putty_help.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/nodemcu_repl_webrepl/putty_help.png
--------------------------------------------------------------------------------
/maplebot/nodemcu_repl_webrepl/putty_hura.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/nodemcu_repl_webrepl/putty_hura.png
--------------------------------------------------------------------------------
/maplebot/nodemcu_repl_webrepl/screen_ubuntu.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/nodemcu_repl_webrepl/screen_ubuntu.png
--------------------------------------------------------------------------------
/maplebot/nodemcu_repl_webrepl/web_repl.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/nodemcu_repl_webrepl/web_repl.png
--------------------------------------------------------------------------------
/maplebot/nodemcu_repl_webrepl/wifi.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/nodemcu_repl_webrepl/wifi.png
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/L298_Data_Sheet.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/L298_Data_Sheet.pdf
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/P1120583.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/P1120583.JPG
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/P1120584.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/P1120584.JPG
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/P1120585.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/P1120585.JPG
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/P1120586.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/P1120586.JPG
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/P1120587.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/P1120587.JPG
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/P1120591.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/P1120591.JPG
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/P1120592.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/P1120592.JPG
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/P1120594.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/P1120594.JPG
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/P1120597.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/P1120597.JPG
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/P1130150.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/P1130150.JPG
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/blueman01.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/blueman01.png
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/blueman02.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/blueman02.png
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/blueman03.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/blueman03.png
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/hc_hc-05-user-instructions-bluetooth.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/hc_hc-05-user-instructions-bluetooth.pdf
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/robopixle_bt.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/robopixle_bt.fzz
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/robopixle_bt.ino:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | // piny pro software serial
4 | const int rxpin = 2;
5 | const int txpin = 3;
6 | // inicializace software serial
7 | SoftwareSerial bluetooth(rxpin, txpin);
8 | char ch = 'A';
9 |
10 | // pripojeni pinu motoru
11 | // motor A
12 | const int enA = 6;
13 | const int in1 = 5;
14 | const int in2 = 4;
15 | // motor B
16 | const int enB = 9;
17 | const int in3 = 7;
18 | const int in4 = 8;
19 |
20 | // maximalne 255
21 | const int rychlost = 100;
22 | const int rychlostOtocka = 90;
23 | const int delkaOtocka = 280;
24 | const int delkaKrok = 1000;
25 |
26 | void setup() {
27 | pinMode(enA, OUTPUT);
28 | pinMode(enB, OUTPUT);
29 | pinMode(in1, OUTPUT);
30 | pinMode(in2, OUTPUT);
31 | pinMode(in3, OUTPUT);
32 | pinMode(in4, OUTPUT);
33 |
34 | //inicializace konzole
35 | Serial.begin(9600);
36 | Serial.println("Serial ready");
37 |
38 | // inicializace bluetooth
39 | bluetooth.begin(9600);
40 | bluetooth.println("Bluetooth ready");
41 | }
42 |
43 | // pusti oba motory
44 | // vpred = true, pokud ma jet vpred
45 | // cas = pocet ms, jak dlouho pojede
46 | void obaMotory(bool vpred, int cas) {
47 | if (vpred) {
48 | // motor A
49 | digitalWrite(in1, LOW);
50 | digitalWrite(in2, HIGH);
51 | // motor B
52 | digitalWrite(in3, LOW);
53 | digitalWrite(in4, HIGH);
54 | } else {
55 | // motor A
56 | digitalWrite(in1, HIGH);
57 | digitalWrite(in2, LOW);
58 | // motor B
59 | digitalWrite(in3, HIGH);
60 | digitalWrite(in4, LOW);
61 | }
62 | // motor A
63 | if (vpred) {
64 | // drobna korekce nerovnomerneho navrtani motoru v pixli
65 | analogWrite(enA, rychlost + 10);
66 | } else {
67 | analogWrite(enA, rychlost);
68 | }
69 | // motor B
70 | analogWrite(enB, rychlost);
71 | delay(cas);
72 | zastavOba();
73 | }
74 |
75 | // pokus o otocku vlevo o 90 stupnu
76 | void zahniVlevo() {
77 | // motor A
78 | digitalWrite(in1, LOW);
79 | digitalWrite(in2, HIGH);
80 | // motor B
81 | digitalWrite(in3, HIGH);
82 | digitalWrite(in4, LOW);
83 | // motor A
84 | analogWrite(enA, rychlostOtocka);
85 | // motor B
86 | analogWrite(enB, rychlostOtocka);
87 | delay(delkaOtocka + 30);
88 | zastavOba();
89 | }
90 |
91 | // pokus o otocku vpravo o 90 stupnu
92 | void zahniVpravo() {
93 | // motor A
94 | digitalWrite(in1, HIGH);
95 | digitalWrite(in2, LOW);
96 | // motor B
97 | digitalWrite(in3, LOW);
98 | digitalWrite(in4, HIGH);
99 | // motor A
100 | analogWrite(enA, rychlostOtocka);
101 | // motor B
102 | analogWrite(enB, rychlostOtocka);
103 | delay(delkaOtocka + 30);
104 | zastavOba();
105 | }
106 |
107 | // zastaveni obou motoru
108 | void zastavOba() {
109 | digitalWrite(in1, LOW);
110 | digitalWrite(in2, LOW);
111 | digitalWrite(in3, LOW);
112 | digitalWrite(in4, LOW);
113 | }
114 |
115 | void loop() {
116 | if(bluetooth.available()){
117 | // nacti znak z bluetooth
118 | ch = bluetooth.read();
119 | // vypis na konzoli
120 | Serial.println(ch);
121 |
122 | if (ch == 'F') {
123 | Serial.println("Forward");
124 | obaMotory(true, delkaKrok);
125 | } else if (ch == 'B') {
126 | Serial.println("Backward");
127 | obaMotory(false, delkaKrok);
128 | } else if (ch == 'R') {
129 | Serial.println("Right");
130 | zahniVpravo();
131 | } else if (ch == 'L') {
132 | Serial.println("Left");
133 | zahniVlevo();
134 | }
135 | }
136 | delay(10);
137 | }
138 |
139 |
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/robopixle_bt.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../../index.md)
2 |
3 | [← zpět na Maplebot](../maplebot.md)
4 |
5 | # Robopixle ovládaná pomocí Bluetooth z Python konzole
6 | * obsah
7 | {:toc}
8 | {::options toc_levels="2..4" /}
9 |
10 | První verze dálkově ovládaného robota, který běhá po zemi. Zatím jen ovládaná pomocí Bluetooth a Python konzole. Do budoucna snad předěláme na něco jiného.
11 |
12 | ## Co je potřeba umět
13 | * Vrtat vrtačkou do krabice :-)
14 |
15 | ## Foto
16 | 
17 | 
18 | 
19 | 
20 | 
21 | 
22 | 
23 | 
24 | 
25 |
26 |
35 |
36 | ## Hardware
37 | * Kovová krabička od čaje (nebo jakákoliv jiná, plastová bude taky dobrá a navíc přes ni projde signál)
38 | * 2 motory, použili jsme TT motor ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=&SearchText=tt+motor))
39 | * 2 kola ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170328123120&SearchText=arduino+wheel))
40 | * Dual motor driver L298N ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170328123156&SearchText=L298N), [specifikace](L298_Data_Sheet.pdf))
41 | * Bluetooth modul, my jsme použili modul HC-06 ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170328123826&SearchText=HC-06), [specifikace](hc_hc-05-user-instructions-bluetooth.pdf))
42 | * Bateriové napájení, my jsme použili 2× Lion 18650 s držákem, který má i vypínač ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170328124149&SearchText=18650+box+switch))
43 | * Pro zabránění zkratu v pixli jsme použili korkovou podložku pod sklenici
44 | * Tento projekt nevyžaduje nepájivé pole, obešli jsme se bez něj (nejspíš by se do pixle nevešlo)
45 |
46 | ## Jak to funguje
47 | ### Bluetooth
48 | Jak už jsem zmínil, Bluetooth byla nouzová bezdrátová technologie, protože cílem bylo do večera daného dne zprovoznit bezdrátově Robopixli a poslední infra sensor jsem nešťastnou náhodou upálil. Wifi modul ani jiné bezdrátové technologie nebyly zrovna po ruce. Současně to ale byla i zajímavá příležitost si Bluetooth modul vyzkoušet, protože jsme s ním nikdy ještě nic nedělali.
49 |
50 | #### Bluetooth a Linux
51 | Nejdříve je potřeba zařízení napárovat s počítačem, který ho bude ovládat. Párovali jsme s Linuxem, tedy jsme pro snadnější práci se zařízeními doinstalovali program [Bluetooth manager](https://apps.ubuntu.com/cat/applications/precise/blueman/).
52 | ``` bash
53 | sudo apt-get update
54 | sudo apt-get upgrade
55 | sudo apt-get install blueman
56 | ```
57 |
58 | 
59 |
60 | Tlačítkem search dáme vyhledat zařízení, Robopixle musí být zapnutá, Bluetooth modul modře bliká.
61 |
62 | 
63 |
64 | Pravé tlačítko na nalzezeném HC-06, vybrat volbu `pair` (spárovat) a vyplnit pin `1234`.
65 |
66 | 
67 |
68 | #### Bluetooth a Python
69 | Pro práci s Bluetooth v Pythonu je potřeba nainstalovat knihovnu [PyBluez](https://github.com/karulis/pybluez).
70 | ``` python
71 | pip install pybluez
72 | ```
73 | Python Program pro ovládání Robopixle [viz níže](#python).
74 |
75 | #### Bluetooth a Arduino
76 | Používáme knihovnu [SoftwareSerial](https://www.arduino.cc/en/Reference/softwareSerial) - to proto, aby nebylo nutné při nahrávání kódu do Arduina odpojovat Bluetooth modul - ten totiž blokuje TX/RX piny a hádá se to. [SoftwareSerial](https://www.arduino.cc/en/Reference/softwareSerial) umožňuje Bluetooth připojit na jiné piny Arduina a provozovat sériovou komunikaci tam, je pak možné vše provozovat pohodlně najednou.
77 |
78 | Jen taková nápověda: RX pin Bluetooth modulu přijde zapojit na TX Arduina a TX Bluetooth na RX Arduina. Trochu nás to potrápilo, ale smysl to dává :-)
79 |
80 | 
81 |
82 | ### L298N dual motor driver
83 | Dvoumotorový řadič, který si poradí i s vyšším napětím. Umožňuje jednoduše ovládat 2 motory nezásvisle oběma směry. Pomocí PWM je možné ovlivňovat i rychlost motorů.
84 |
85 | Parametry:
86 | * vstupní napětí: 5 V - 46 V
87 | * špičkový proud: 2 A
88 | * maximální výkon: 25 W
89 | * pracovní teplota: -25 ℃ - +130 ℃
90 |
91 | V našem případě z jeho vstupních svorek přivádíme napětí do Arduina, jelikož to eliminuje nepájivé pole v pixli (a pájení). A to se hodí hlavně z hlediska prostoru.
92 |
93 | ### Napájení
94 | Krabice pro Robopixli není na výšku dostatečně vysoká, aby mohlo mít Arduino napájení přes konektor (ať už USB nebo jack). Bylo potřeba [prozkoumat jiné možnosti napájení přímo přes piny Arduina](https://www.arduino.cc/en/main/arduinoBoardUno). `-` z baterie jde tedy do `GND` a `+` jde do `Vin` pinu.
95 |
96 | ## Schéma zapojení
97 | [robopixle_bt.fzz](robopixle_bt.fzz)
98 |
99 | [](robopixle_bt_bb.png)
100 |
101 | ## Program pro Robopixli
102 | [robopixle_bt.ino](robopixle_bt.ino)
103 | ``` c++
104 | {% include_relative robopixle_bt.ino %}
105 | ```
106 |
107 | ## Program pro ovládací Python konzoli
108 | Program pro ovládání je velmi jednoduchý, páruje se automaticky na první zařízení, které na Bluetooth síti nalezne, vůbec neinteraguje s uživatelem, že by mu dával na výběr. Že je spárováno je možné poznat jak na displeji počítače (objeví se výzva k zadávání pohybových příkazů), tak na Robopixli, kde přestane blikat modrá LED Bluetooth modulu a začne trvale svítit.
109 |
110 | Ovládání Robopixle probíhá pomocí jednoduchých příkazů sestávajících ze 4 písmen:
111 | * `F` = forward (dopředu), pixle popojede kousek dopředu
112 | * `B` = backward (dozadu), pixle popojede kousek dozadu
113 | * `L` = left (vlevo), pixle se otočí asi o 90° vlevo
114 | * `R` = right (vpravo), pixle se otočí asi o 90° vpravo
115 | * Enter = odeslání sestavy příkazů Robopixli, ta je začne obratem provádět (připravte si místo na podlaze!)
116 | * Program se přerušuje pomocí `Ctrl+C`.
117 |
118 | [robopixle_bt.py](robopixle_bt.py)
119 | ``` c++
120 | {% include_relative robopixle_bt.py %}
121 | ```
122 |
123 | ## Možná vylepšení
124 | Možných vylepšení je mnoho a [chystáme je](../maplebot.md).
125 |
126 | ## Poznatky
127 | * Jak je nakonec z fotek vidět, je dobré si dopředu vše proměřit, zda se do krabice robopixle vejde. Nám to vyšlo tak tak. Uno je velké, motory také a o driveru motorů s velkým chladičem ani nemluvě.
128 | * Kovová krabice je odolná, ale mistr Farraday se nám smál, když jsme se snažili chytit nějaký signál. Bylo potřeba vyvrtat díru pro Bluetooth modul, aby mohla anténa čouhat ven.
129 | * Motory jsou silné a je potřeba je pomocí PWM trochu brzdit.
130 | * Kola nejsou přímo naproti sobě, takže to mírně zanáší, to lze trochu korigovat rozdílnou rychlostí kol.
131 | * Motory nejsou krokové, takže lze zapomenout na přesný pohyb (robot neoběhne čtverec tak, aby se vrátil do původního místa). Kdyby byly krokové, byly by významně dražší a pomalejší, takže si musíme vybrat. Ukázalo se, že to asi nebude nikomu vadit, robot bude řešit jiný typ úloh.
132 | * Napájení pomocí 2× Lion 18650 dá v plně nabitém stavu asi 8,4 V, po nějakém větším trápení dětmi napětí rychle klesá k 7 V, z toho si ještě odeberou motory, takže na Arduino zbývá už málo. [Pod 7 V je Arduino Uno nestabilní](https://www.arduino.cc/en/main/arduinoBoardUno) (a v reálu se to projevuje tak, že to dělá blbiny, neposlouchá, neslyší a nechce slyšet). Možná vyzkoušíme ještě napájení 9 V Lion.
133 |
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/robopixle_bt.py:
--------------------------------------------------------------------------------
1 | # pybluez
2 | import bluetooth
3 |
4 | # hledame zarizeni
5 | print "Hledam zarizeni..."
6 | print ""
7 | nearby_devices = bluetooth.discover_devices()
8 |
9 | # vyber prvni zarizeni ze seznamu
10 | selection = 0
11 | bd_addr = nearby_devices[selection]
12 |
13 | port = 1
14 | sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
15 |
16 | # odpojeni
17 | def disconnect():
18 | sock.close()
19 |
20 | # posilani dat
21 | def send(data):
22 | sock.send(data)
23 |
24 | # pripoj se k zarizeni
25 | sock.connect((bd_addr, port))
26 | print 'Spojeno.'
27 | print 'Cekam na prikazy pro Robopixli. Mozne prikazy jsou: F = dopredu, B = dozadu, L = vlevo, R = vpravo.'
28 |
29 | # nekonecne opakovani, prerusi se Ctrl+C
30 | while True:
31 | # nacti znak ze vstupu z klavesnice
32 | ch = raw_input();
33 | # posli pres BT
34 | send(ch)
35 | disconnect()
--------------------------------------------------------------------------------
/maplebot/robopixle_bt/robopixle_bt_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/maplebot/robopixle_bt/robopixle_bt_bb.png
--------------------------------------------------------------------------------
/meric_stromku/P1220839.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_stromku/P1220839.JPG
--------------------------------------------------------------------------------
/meric_stromku/P1220841.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_stromku/P1220841.JPG
--------------------------------------------------------------------------------
/meric_stromku/P1230008.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_stromku/P1230008.JPG
--------------------------------------------------------------------------------
/meric_stromku/P1230064.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_stromku/P1230064.JPG
--------------------------------------------------------------------------------
/meric_stromku/P1230102.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_stromku/P1230102.JPG
--------------------------------------------------------------------------------
/meric_stromku/P1230103.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_stromku/P1230103.JPG
--------------------------------------------------------------------------------
/meric_stromku/P1230132.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_stromku/P1230132.JPG
--------------------------------------------------------------------------------
/meric_stromku/P1230151.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_stromku/P1230151.JPG
--------------------------------------------------------------------------------
/meric_stromku/meric_stromku.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_stromku/meric_stromku.fzz
--------------------------------------------------------------------------------
/meric_stromku/meric_stromku.ino:
--------------------------------------------------------------------------------
1 | int sensorValue = 0;
2 |
3 | void setup() {
4 | Serial.begin(9600);
5 | //zelena
6 | pinMode(8, OUTPUT);
7 | //cervena
8 | pinMode(9, OUTPUT);
9 | //merak
10 | pinMode(10, OUTPUT);
11 | //cteni meraku
12 | pinMode(A0, INPUT);
13 | }
14 |
15 | void loop() {
16 | digitalWrite(10, HIGH);
17 | delay(1000);
18 | sensorValue = analogRead(A0);
19 | digitalWrite(10, LOW);
20 | Serial.print("sensor = ");
21 | Serial.println(sensorValue);
22 | delay(2 * 1000);
23 | if (sensorValue >= 200) {
24 | digitalWrite(8, HIGH);
25 | digitalWrite(9, LOW);
26 | delay(60 * 30 * 1000L);
27 | } else {
28 | digitalWrite(8, LOW);
29 | digitalWrite(9, HIGH);
30 | delay(1000);
31 | digitalWrite(9, LOW);
32 | }
33 | }
34 |
35 |
--------------------------------------------------------------------------------
/meric_stromku/meric_stromku.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # Měření hladiny vody ve stojanu na vánoční stromek
4 | * obsah
5 | {:toc}
6 | {::options toc_levels="2..4" /}
7 |
8 | Máte-li doma živý vánoční stromek, je dobré, aby měl dostatek vody. Proč je to dobré, to vám vysvětlí tohle pěkné instruktážní video:
9 |
10 |
11 |
12 | Rozhodli jsme se tedy postavit čidlo hladiny vody ve stojanu na vánoční stromek. Projekt prováděl syn (9) zcela sám, pouze jsem dohlížel na obtížné části.
13 |
14 | ## Co je potřeba umět
15 | * Trochu pájet, pokud nestačí délka kabelů
16 |
17 | ## Foto
18 | 
19 |
20 | Prototyp
21 | 
22 |
23 | Kabely k čidlu bylo potřeba prodloužit
24 | 
25 |
26 | Obestavěno v papírové krabici
27 | 
28 |
29 | Instalace čidla ve stojanu
30 | 
31 | 
32 | 
33 |
34 | Napájení Arduina je přes USB
35 | 
36 |
37 | ## Hardware
38 | * Několik barevných LED
39 | * 2 rezistory 220 Ω
40 | * čidlo půdní vlhkosti, ale je možné ho nahradit i napěťovým děličem, který jsme použili v [hraní si s vodivostí](../touchduino/touchduino.md)
41 |
42 | ## Jak to funguje
43 | Protože by čidlo vlhkosti mohlo při trvalém napětí rychle reznout, program měří vodu ve stojanu pouze jednou za půl hodiny, po zbytek času je čidlo odpojeno. Ve chvíli, kdy zjistí, že je na suchu, bliká červenými LED a měří zhruba co sekundu. To je dobré, protože je pak okamžitá reakce při zalévání stojanu.
44 |
45 | ## Schéma zapojení
46 | _(maloval syn (9) sám, celý návrh zapojení je jeho)_
47 |
48 | [meric_stromku.fzz](meric_stromku.fzz)
49 |
50 | [](meric_stromku_bb.png)
51 |
52 | ## Program
53 | [meric_stromku.ino](meric_stromku.ino)
54 | ``` c++
55 | {% include_relative meric_stromku.ino %}
56 | ```
57 |
58 | ## Možná vylepšení
59 | Siréna :-)
60 |
61 | ## Poznatky
62 | * Zjistili jsme, že náš stromek (jedle, asi 2,2 m) vypije denně při okolní teplotě kolem 22°C asi **3 l vody**, což je více než volný objem stojanu. Je proto nutné dolévat i vícekrát za den.
63 | * Nepájivé pole je dobré pro prototyp, ale v krabičce se z něj drátky uvolňují, nedrží dobře a dochází k různým studeným spojům. Musíme se vybavit nějakými šikovnými [pájivými poli](https://www.aliexpress.com/wholesale?ltype=wholesale&d=y&origin=y&blanktest=0&jump=afs&SearchText=soldering+board&tc=af&initiative_id=SB_20171225054222&isViewCP=y&catId=0).
64 |
65 |
--------------------------------------------------------------------------------
/meric_stromku/meric_stromku_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_stromku/meric_stromku_bb.png
--------------------------------------------------------------------------------
/meric_vlhkosti_pudy/meric_vlhkosti_pudy.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_vlhkosti_pudy/meric_vlhkosti_pudy.fzz
--------------------------------------------------------------------------------
/meric_vlhkosti_pudy/meric_vlhkosti_pudy.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # Měření půdní vlhkosti
4 | Hrátky s čidlem, které měří odpor. Je tvarem uzpůsobeno pro zastrčení do půdy.
5 |
6 | ## Co je potřeba umět
7 | * Ovládat OLED displej
8 |
9 | ## Foto
10 | ![]()
11 |
12 | ## Hardware
13 | * OLED displej s I2C, např. SSD1306 ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170322115850&SearchText=OLED+0.96))
14 | * čidlo půdní vlhkosti
15 |
16 | ## Jak to funguje
17 | ### Čidlo vlhkosti
18 | Čidlo je jednoduchý snímač odporu. Hodnoty je však potřeba kalibrovat, tedy např. ho zapíchnout do různých materiálů, zjistit přibližný rozsah hodnot a dle toho dál zpracovávat výstup.
19 | * voda
20 | * hodně vlhká půda
21 | * mírně vlhká půda
22 | * vzduch
23 |
24 | Dále je třeba spínat napětí snímače jen ve chvíli, kdy chceme měřit, protože jinak pokud ho udržujeme pod napětím stále, jeho elektrody [velmi rychle zkorodují](http://www.homautomation.org/2014/06/20/measure-soil-moisture-with-arduino-gardening/). Pro dlouhodobější měření je tedy dobré upravit řízení programem Arduina.
25 |
26 | ### OLED
27 | Pro ovládání displeje mrkněte na [OLED](../oled/oled.md).
28 |
29 | ## Schéma zapojení
30 | [meric_vlhkosti_pudy.fzz](meric_vlhkosti_pudy.fzz)
31 |
32 | [](meric_vlhkosti_pudy_bb.png)
33 |
34 | ## Program
35 |
36 | ## Možná vylepšení
37 | * Lze vyzkoušet i jako jednoduchý detektor lži :-)
38 | * S měřičem lze např. kontrolovat i výši hladiny v misce Vánočního stromku.
39 |
40 | ## Poznatky
41 | Zvláště ta část s korozí dětem potrápila hlavu. Jak zabránit tomu, aby to bylo do měsíce zkorodované. A pak kalibrace. Kytky si užily svoje.
--------------------------------------------------------------------------------
/meric_vlhkosti_pudy/meric_vlhkosti_pudy_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_vlhkosti_pudy/meric_vlhkosti_pudy_bb.png
--------------------------------------------------------------------------------
/meric_vzdalenosti/HCSR04.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_vzdalenosti/HCSR04.pdf
--------------------------------------------------------------------------------
/meric_vzdalenosti/P1120530.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_vzdalenosti/P1120530.JPG
--------------------------------------------------------------------------------
/meric_vzdalenosti/P1120533.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_vzdalenosti/P1120533.JPG
--------------------------------------------------------------------------------
/meric_vzdalenosti/P1120534.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_vzdalenosti/P1120534.JPG
--------------------------------------------------------------------------------
/meric_vzdalenosti/meric_vzdalenosti.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_vzdalenosti/meric_vzdalenosti.fzz
--------------------------------------------------------------------------------
/meric_vzdalenosti/meric_vzdalenosti.ino:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "U8glib.h"
4 |
5 | // nastaveni pinu
6 | #define trigPin 13
7 | #define echoPin 12
8 |
9 | // inicializace OLED
10 | U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE);
11 |
12 | void setup() {
13 | // seriova konzole pro testy
14 | // Serial.begin (9600);
15 | pinMode(trigPin, OUTPUT);
16 | pinMode(echoPin, INPUT);
17 | }
18 |
19 | // vypise vysledek na displeji
20 | void vypis(int vzdalenost) {
21 | if (vzdalenost > 400) {
22 | u8g.setFont(u8g_font_fur20);
23 | u8g.drawStr(10, 40, "Daleko");
24 | } else {
25 | u8g.setFont(u8g_font_fub25n);
26 | char buf[4];
27 | sprintf(buf, "%03i", vzdalenost);
28 | u8g.drawStr(40, 30, buf);
29 | u8g.setFont(u8g_font_unifont);
30 | u8g.drawStr(45, 50, "cm");
31 | }
32 | }
33 |
34 | void loop() {
35 | long doba, vzdalenost;
36 | // PULSE ___|---|___
37 | // vycisti trigger pin
38 | digitalWrite(trigPin, LOW);
39 | delayMicroseconds(2);
40 | // posli 8 cyklu za 10 mikrosekund
41 | digitalWrite(trigPin, HIGH);
42 | delayMicroseconds(10);
43 | // vypni posilani
44 | digitalWrite(trigPin, LOW);
45 |
46 | // precteme echo pin
47 | doba = pulseIn(echoPin, HIGH);
48 | //prepocet na vzdalenost
49 | //-----------------------------
50 | // rychlost zvuku = 340 m/s = 0,034 cm/us (mikrosekund)
51 | // t = s/v => s = t * v
52 | // s = cas * 0,034
53 | // na konci musime vzdalenost vydelit 2, protoze zvuk leti tam a zpet
54 | vzdalenost = (doba * 0.034) / 2;
55 |
56 | u8g.firstPage();
57 | do {
58 | vypis(vzdalenost);
59 | } while (u8g.nextPage());
60 |
61 | // Serial.println(distance);
62 | delay(500);
63 | }
64 |
--------------------------------------------------------------------------------
/meric_vzdalenosti/meric_vzdalenosti.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # Ultrazvukové měření vzdálenosti
4 | Jednoduchý ultrazvukový měřič vzdálenosti se zobrazováním hodnot na OLED displeji.
5 |
6 | ## Co je potřeba umět
7 | * ovládání [OLED displeje](../oled/oled.md)
8 |
9 | ## Foto
10 | 
11 | 
12 | 
13 |
14 | ## Hardware
15 | * OLED displej s I2C, např. SSD1306 ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170322115850&SearchText=OLED+0.96))
16 | * ultrazvukové čidlo HC-SR04 ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170322115709&SearchText=hc-sr04), [specifikace](HCSR04.pdf))
17 |
18 | ## Jak to funguje
19 | ### Měření vzdálenosti ultrazvukem
20 | Sensor HC-SR04 má tyto parametry:
21 | * Napájení: +5 V DC
22 | * Klidový proud: < 2 mA
23 | * Pracovní proud: 15 mA
24 | * Pracovní frekvence: 40 kHz
25 | * Měřící rozsah: 2 cm – 400 cm
26 | * Rozlišení : 0,3 cm
27 | * Měřící úhel: 15°
28 |
29 | 2 piny sensoru jsou napájení (VCC, GND), jeden je vstupní (Trigger) a jeden výstupní (Echo).
30 |
31 | Rychlost zvuku je asi 340 m/s = 34 000 cm/s = 34 cm/ms = **0,034 cm/µs** (0,034 cm za mikrosekundu).
32 |
33 | Na trigger pin sensoru nastavíme na 10 µs 5 V, čímž vypustíme 8 ultrazvukových 40 kHz vln, následně nám echo pin prozradí, kolik mikrosekund čekal na jejich odraz. Výsledná vzdálenost v cm se následně spočítá
34 | ```
35 | s = t * v
36 | s = t * 0,034
37 | ```
38 | **Nesmíme ji ale zapomenout vydělit 2**, protože zvuk letěl samozřejmě k překážce a zpět.
39 |
40 | ### OLED
41 | Pro ovládání displeje mrkněte na [OLED](../oled/oled.md).
42 |
43 | ## Schéma zapojení
44 | [meric_vzdalenosti.fzz](meric_vzdalenosti.fzz)
45 |
46 | [](meric_vzdalenosti_bb.png)
47 |
48 | ## Program
49 | [meric_vzdalenosti.ino](meric_vzdalenosti.ino)
50 | ``` c++
51 | {% include_relative meric_vzdalenosti.ino %}
52 | ```
53 | ## Možná vylepšení
54 | * Při hodnotě vyšší než 4 m zobrazit hlášení, že jsme mimo rozsah.
55 | * Při vzdálenosti nad 1 m zobrazovat hodnotu v metrech.
56 |
57 | ## Poznatky
58 | Měření nám fungovalo celkem spolehlivě do jednoho metru, hodně záleží, od čeho se ultrazvuk odráží. Pokud se zapojení udělá rozumně kompaktní, může s ním dítě oběhnout celý dům.
59 |
60 |
--------------------------------------------------------------------------------
/meric_vzdalenosti/meric_vzdalenosti_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/meric_vzdalenosti/meric_vzdalenosti_bb.png
--------------------------------------------------------------------------------
/nepriblizuj_se/01-bez_pryc.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/nepriblizuj_se/01-bez_pryc.mp3
--------------------------------------------------------------------------------
/nepriblizuj_se/02-nedotykej_se_ me.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/nepriblizuj_se/02-nedotykej_se_ me.mp3
--------------------------------------------------------------------------------
/nepriblizuj_se/03-ksc_ksc.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/nepriblizuj_se/03-ksc_ksc.mp3
--------------------------------------------------------------------------------
/nepriblizuj_se/HCSR04.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/nepriblizuj_se/HCSR04.pdf
--------------------------------------------------------------------------------
/nepriblizuj_se/P1000613.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/nepriblizuj_se/P1000613.JPG
--------------------------------------------------------------------------------
/nepriblizuj_se/P1000615.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/nepriblizuj_se/P1000615.JPG
--------------------------------------------------------------------------------
/nepriblizuj_se/P1000618.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/nepriblizuj_se/P1000618.JPG
--------------------------------------------------------------------------------
/nepriblizuj_se/P1000620.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/nepriblizuj_se/P1000620.JPG
--------------------------------------------------------------------------------
/nepriblizuj_se/nedotykej_se.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/nepriblizuj_se/nedotykej_se.mp4
--------------------------------------------------------------------------------
/nepriblizuj_se/nepriblizuj_se.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/nepriblizuj_se/nepriblizuj_se.fzz
--------------------------------------------------------------------------------
/nepriblizuj_se/nepriblizuj_se.ino:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "DFRobotDFPlayerMini.h"
4 | #include "SoftwareSerial.h"
5 |
6 | // nastaveni pinu pro ultrazvuk
7 | #define trigPin 13
8 | #define echoPin 12
9 | // nastaveni pinu pro mp3
10 | #define rxMp3 10
11 | #define txMp3 11
12 |
13 | // software serial pro mp3
14 | SoftwareSerial mySoftwareSerial(rxMp3, txMp3);
15 | DFRobotDFPlayerMini myDFPlayer;
16 |
17 | void setup() {
18 | // seriova konzole pro testy
19 | Serial.begin (9600);
20 | // nastaveni pinu pro ultrazvuk
21 | pinMode(trigPin, OUTPUT);
22 | pinMode(echoPin, INPUT);
23 | // inicializace software serial
24 | mySoftwareSerial.begin(9600);
25 | Serial.println();
26 | Serial.println(F("DFRobot DFPlayer Mini Demo"));
27 | Serial.println(F("Initializing DFPlayer ... (May take 3~5 seconds)"));
28 | if (!myDFPlayer.begin(mySoftwareSerial)) { //Use softwareSerial to communicate with mp3.
29 | Serial.println(F("Unable to begin:"));
30 | Serial.println(F("1.Please recheck the connection!"));
31 | Serial.println(F("2.Please insert the SD card!"));
32 | while (true);
33 | }
34 | Serial.println(F("DFPlayer Mini online."));
35 | //nastav hlasitost prehravace (0-30)
36 | myDFPlayer.volume(25);
37 | // normalni equalizer
38 | myDFPlayer.EQ(DFPLAYER_EQ_NORMAL);
39 | // prehravame z SD karty
40 | myDFPlayer.outputDevice(DFPLAYER_DEVICE_SD);
41 | }
42 |
43 | long zmerVzdalenost() {
44 | long doba, vzdalenost;
45 | // PULSE ___|---|___
46 | // vycisti trigger pin
47 | digitalWrite(trigPin, LOW);
48 | delayMicroseconds(2);
49 | // posli 8 cyklu za 10 mikrosekund
50 | digitalWrite(trigPin, HIGH);
51 | delayMicroseconds(10);
52 | // vypni posilani
53 | digitalWrite(trigPin, LOW);
54 |
55 | // precteme echo pin
56 | doba = pulseIn(echoPin, HIGH);
57 | //prepocet na vzdalenost
58 | //-----------------------------
59 | // rychlost zvuku = 340 m/s = 0,034 cm/us (mikrosekund)
60 | // t = s/v => s = t * v
61 | // s = cas * 0,034
62 | // na konci musime vzdalenost vydelit 2, protoze zvuk leti tam a zpet
63 | vzdalenost = (doba * 0.034) / 2;
64 | return vzdalenost;
65 | }
66 |
67 | void loop() {
68 | long vzdalenost = zmerVzdalenost();
69 | Serial.print("Vzdalenost: ")
70 | Serial.println(vzdalenost);
71 | // je treba pockat nez se prehraje zvuk, odhadujeme 2s
72 | int pockej = 2000;
73 | if ((vzdalenost < 150) && (vzdalenost >= 100)) { // 100 - 150cm
74 | myDFPlayer.play(1);
75 | delay(pockej);
76 | } else if ((vzdalenost < 100) && (vzdalenost >= 50)) { // 50 - 100 cm
77 | myDFPlayer.play(2);
78 | delay(pockej);
79 | } else if (vzdalenost < 50) { // pod 50cm
80 | myDFPlayer.play(3);
81 | delay(pockej);
82 | }
83 | // pokud je zde mene nez 200ms, ultrazvuk zacina zlobit
84 | delay(300);
85 | }
86 |
--------------------------------------------------------------------------------
/nepriblizuj_se/nepriblizuj_se.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # Nepřibližuj se!
4 | * obsah
5 | {:toc}
6 | {::options toc_levels="2..4" /}
7 |
8 | Po úspěchu [ultrazvukového měření vzdálenosti](../meric_vzdalenosti/meric_vzdalenosti.md) jsme se rozhodli to trochu vylepšit o zvuky :-). Jakmile se k pokladu někdo začne přibližovat, poklad narušitele zvukově odhání.
9 |
10 | ## Co je potřeba umět
11 | * Projekt zvládne i menší dítě, pokud se smíříme s tím, že nebude rozumět každému slovu v kódu. Nicméně sestavení podmínek pro jednotlivé úrovně vzdáleností už dítě může programovat samo.
12 | * Jde v zásadě o jednoduché propojení [ultrazvukového měření vzdálenosti](../meric_vzdalenosti/meric_vzdalenosti.md) a [demo příkladu na mp3 přehrávač](https://www.dfrobot.com/wiki/index.php/DFPlayer_Mini_SKU:DFR0299).
13 |
14 | ## Foto
15 | 
16 | 
17 | 
18 | 
19 |
20 | ## Video
21 |
22 |
23 |
27 |
28 |
29 | ## Hardware
30 | * ultrazvukové čidlo HC-SR04 ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170322115709&SearchText=hc-sr04), [specifikace](HCSR04.pdf))
31 | * mp3 přehrávač ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20180318111806&SearchText=mini+mp3+player+arduino), [specifikace](https://www.dfrobot.com/wiki/index.php/DFPlayer_Mini_SKU:DFR0299))
32 | * malý reproduktor ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20180318112256&SearchText=mini+amplifier+speaker+horn))
33 | * resistor 1 kΩ
34 | * microSD karta pro přehrávač
35 |
36 | ## Software
37 | * něco pro nahrávání zvuku, např. [Audacity](https://www.audacityteam.org/)
38 |
39 | ## Jak to funguje
40 | Ultrazvukové čidlo měří vzdálenost a podle toho pouští jednotlivé skladby na mp3 přehrávači.
41 |
42 | ## Schéma zapojení
43 |
44 | _(malovala dcera (7) sama)_
45 |
46 | [nepriblizuj_se_bb.fzz](nepriblizuj_se_bb.fzz)
47 |
48 | [](nepriblizuj_se_bb.png)
49 |
50 | ## Program
51 | [nepriblizuj_se.ino](nepriblizuj_se.ino)
52 | ``` c++
53 | {% include_relative nepriblizuj_se.ino %}
54 | ```
55 |
56 | ## Možná vylepšení
57 | * Zapojení by šlo předělat např. na zvukový sonar, kdy bude lidským hlasem oznamovat vzdálenost od překážky (např. "dva a půl metru")
58 | * Různé druhy sirén, kdy dojde k detekci překážky
59 | * Zobrazování dalších hodnot či vzkazů na [OLED displeji](../meric_vzdalenosti/meric_vzdalenosti.md)
60 |
61 | ## Poznatky
62 | * Zatím jsme nepřišli na to, jak zjistit z přehrávače, že přehrává skladbu (nebo že ji dopřehrával), tedy dáváme za puštění skladby vždy tvrdé prodlevy `delay()`.
63 | * Pokud jsme detekovali ultrazvukem vzdálenost rychleji 5× za sekundu (pauza menší než 200 ms), tak docházelo k významným měřícím chybám, vracela se čísla > 3000 cm (sonar měří asi do 4 m) a současně pak přicházela chybná měření např. < 50 cm, aniž byla nějaká překážka v dosahu. Nastavení prodlevy na 200 ms sice zpomalí reakci sonaru, ale vyřešilo to problém.
64 |
--------------------------------------------------------------------------------
/nepriblizuj_se/nepriblizuj_se_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/nepriblizuj_se/nepriblizuj_se_bb.png
--------------------------------------------------------------------------------
/oled/Image2Code.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/oled/Image2Code.png
--------------------------------------------------------------------------------
/oled/P1130377.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/oled/P1130377.JPG
--------------------------------------------------------------------------------
/oled/P1130378_.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/oled/P1130378_.JPG
--------------------------------------------------------------------------------
/oled/P1130379.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/oled/P1130379.JPG
--------------------------------------------------------------------------------
/oled/P1130381.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/oled/P1130381.JPG
--------------------------------------------------------------------------------
/oled/P1130382.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/oled/P1130382.JPG
--------------------------------------------------------------------------------
/oled/P1130719.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/oled/P1130719.JPG
--------------------------------------------------------------------------------
/oled/P1130726.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/oled/P1130726.JPG
--------------------------------------------------------------------------------
/oled/gimp_smajl.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/oled/gimp_smajl.png
--------------------------------------------------------------------------------
/oled/oled.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/oled/oled.fzz
--------------------------------------------------------------------------------
/oled/oled.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # OLED
4 | Naše první pokusy s OLED displejem. Já vím, zkratka OLED už sama o sobě v sobě obsahuje slovo displej, ale stejně tomu tak všichni říkají :-) OLED mají nízkou spotřebu a dobrý zobrazovací kontrast (svítí jen to, co svítit musí). Tak jsme taky nějaké chtěli vyzkoušet.
5 |
6 | ## Co je potřeba umět
7 | Rozhodně se hodí vědět, jaký přesně displej vlastně držím v ruce. To usnadní jeho ovládání :-) Jinak nejsou potřeba asi žádné speciální znalosti.
8 |
9 | ## Hardware
10 | * OLED displej s I2C, např. SSD1306 ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170322115850&SearchText=OLED+0.96))
11 |
12 | ## Jak to funguje
13 | OLED displej, který jsme využili, má úhlopříčku 0,96" a rozlišení 128×64 pixelů. Připojili jsme ho přes rozhraní [I2C](https://learn.sparkfun.com/tutorials/i2c). To komunikuje na 2 pinech `SDA` (data) a `SCL/SCK` (clock). Tyto má Arduino Uno schováno na analogových pinech `A4 (SDA)` a `A5 (SCL/SCK)` ([zdroj](https://www.arduino.cc/en/reference/wire)).
14 |
15 | 
16 |
17 | K ovládání displeje se dále hodí knihovna [u8g](https://github.com/olikraus/u8glib/wiki/userreference). Asi nejtěžším úkolem bylo zjistit, co přesně máme za displej a jakým konstruktorem knihovnu inicializovat. Nutno říci, že na displeji samotném jsme příliš vodítek nenašli.
18 |
19 | 
20 | 
21 |
22 | Někdy můžete natrefit na displej, který je dvoubarevný. Nejde většinou o plnohodnotnou dvoubarevnost, ale jistá část displeje se zobrazuje vždy pevně jednou barvou a zbytek druhou. Barvu tak nenastavujete při vykreslování jako parametr, ale volíte ji umístěním na displeji.
23 |
24 | 
25 |
26 | Texty se na displeji vypisují metodou [drawStr](https://github.com/olikraus/u8glib/wiki/userreference#drawstr). Fonty se nastavují metodou [setFont](https://github.com/olikraus/u8glib/wiki/userreference#setfont) a je [z čeho vybírat](https://github.com/olikraus/u8glib/wiki/fontsize).
27 |
28 | Následně děti projevily velký zájem zobrazovat na displej i něco jiného než jen texty různých velikostí. Postup je následující:
29 | 1. Namalovat obrázek ve svém oblíbeném grafickém programu. Je dobré si nastavit velikost papíru na rozlišení displeje (např. 128×64), abychom se pak vešli. Pokud je displej jednobarevný či falešně dvoubarevný, je dobré kreslit pouze černou na bílem podkladu. Výsledný obrázek ořezat na minimální velikost.
30 | 
31 | 1. Pomocí programu pro převod bitmapy do kódu převést obrázek. Převod je vlastně pouhý převod černých pixelů na zápis v šestnáctkové soustavě (hexa) do zdrojového kódu tak, aby bylo možné ho nahrát do displeje.
32 | 1. K převodu jsme využili program [Image2Code](https://github.com/ehubin/Adafruit-GFX-Library/tree/master/Img2Code) napsaný v Javě (stačí pouze soubor [Image2Code.jar](https://github.com/ehubin/Adafruit-GFX-Library/blob/master/Img2Code/Image2Code.jar), neinstaluje se, stačí spustit). Pokud Javu na počítači zatím nemáte, je potřeba doinstalovat. Pro Linux třeba takto:
33 | ``` bash
34 | sudo apt-get install default-jre
35 | ```
36 | Program se pak spouští z příkazové řádky
37 | ``` bash
38 | java -jar Image2Code.jar
39 | ```
40 | 
41 |
42 | Ale je samozřejmě možné využít i jakýkoli jiný program, např. [LCD image converter](http://www.riuson.com/lcd-image-converter), který běhá na Windows, ale je možné ho zkompilovat i pro Linux - a celkově vypadá vymazleně.
43 |
44 | Výsledný hexa kód nakopírovat do zdrojového souboru pro Arduino.
45 | ``` c++
46 | const uint8_t veselySmajl[] PROGMEM = {
47 | 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x80,
48 | ...
49 | ...
50 | ...
51 | };
52 | ```
53 |
54 | Klíčové slovo `PROGMEM` zde zařídí, že celá bitmapa nebude uložena v operační paměti Arduina - té máme totiž obvykle velmi málo (Uno R3 = 2 KiB), ale protože se nebude v programu měnit (je konstantní), může být umístěna do tzv. flash paměti, kde leží i náš program (Uno R3 = 32 KiB). Více o rozdělení a druzích pamětí si lze [přečíst zde](https://www.arduino.cc/en/tutorial/memory), práce s PROGMEM je [vysvětlena zde](https://www.arduino.cc/en/Reference/PROGMEM).
55 |
56 | Ještě potřebujeme vědět, jaké má obrázek rozměry. Šířku vydělíme osmi a zaokrouhlíme nahoru (= počet bajtů, které jsou na řádku), výšku pak necháme, jak je. Pro vykreslení slouží funkce [drawBitmapP()](https://github.com/olikraus/u8glib/wiki/userreference#drawbitmapp).
57 | ``` c++
58 | //sirka obrazku = 65 -> 9 bajtu na radek
59 | // vyska obrazku = 57
60 | drawBitmapP(5, 5, 9, 57, veselySmajl);
61 | ```
62 |
63 | Možná někoho napadne, proč není potřeba následně ve volání `drawBitmapP` kopírovat data bitmapy z flash paměti do operační (pomocí nějaké z metod rozhraní [pgmspace](http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html)), když to návody u klíčového slova `PROGMEM` [ukazují](https://www.arduino.cc/en/Reference/PROGMEM). Je to proto, že knihovna [u8g](https://github.com/olikraus/u8glib/wiki/userreference) již [předpokládá](https://github.com/olikraus/u8glib/blob/e2d100959ca067bd0800ddb39f8043cefc5df8b8/csrc/u8g_bitmap.c#L68), že bitmapu ve flash paměti máme.
64 |
65 | Ukázka z kódu knihovny v těle `drawBitmapP`
66 | ``` c++
67 | u8g_Draw8Pixel(u8g, x, y, 0, u8g_pgm_read(bitmap));
68 | ```
69 |
70 | Knihovna [u8g](https://github.com/olikraus/u8glib/wiki/userreference) využívá koncept redraw - je potřeba neustále obnovovat stav displeje [opakovaným překreslováním](https://github.com/olikraus/u8glib/wiki/tpictureloop).
71 | ``` c++
72 | void loop(void) {
73 | u8g.firstPage();
74 | do {
75 | draw();
76 | } while(u8g.nextPage());
77 |
78 | // po nejake dobe prekresli displej
79 | delay(1000);
80 | }
81 | ```
82 |
83 | 
84 |
85 | ## Schéma zapojení
86 | [oled.fzz](oled.fzz)
87 |
88 | [](oled_bb.png)
89 |
90 | ## Program s textem
91 | [oled_txt.ino](oled_txt.ino)
92 | ``` c++
93 | {% include_relative oled_txt.ino %}
94 | ```
95 |
96 | ## Program s obrázkem
97 | [oled_pic.ino](oled_pic.ino)
98 | ``` c++
99 | {% include_relative oled_pic.ino %}
100 | ```
101 |
102 | 
103 | 
104 |
105 | ## Možná vylepšení
106 | * Jakékoliv hrátky s displejem. Kombinace s [ručními blikači](../rucni_blikace/rucni_blikace.md), [automatickými blikači](../automaticke_blikace/automaticke_blikace.md), apod.
107 | * Je možné vytvořit jednoduché hry, přeci jen OLED displej dává poněkud sofistikovanější zobrazovací možnosti. Spolu s tlačítky je pak možné vyhodnocovat odpovědi hráče nebo hru přímo ovládat.
108 |
109 | ## Poznatky
110 | * Nejvíce nás potrápila detekce displeje, pak správný konstruktor, nakonec zapojení na SDA/SCK na Arduinu (nevěděl jsem, že jsou na pinech A4/A5). Ovládání přes knihovnu [u8g](https://github.com/olikraus/u8glib/wiki/userreference) bylo naopak už docela lehké. Pak jsem se potrápil při vysvětlování `PROGMEM`, ale je to zase hezká příležitost jak objasnit dětem trochu paměťové uspořádání Arduina.
111 | * Náš OLED displej je sice maličký, ale je to displej a to dává všem projektům úplně jiný rozměr.
112 | * Rozhraní `I2C` není zrovna nejrychlejší (400 kHz), chtělo by to `SPI` (až 20 MHz), ale to náš konkrétní displej zdá se neumí. Takže rychlé animace asi nebudou.
--------------------------------------------------------------------------------
/oled/oled_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/oled/oled_bb.png
--------------------------------------------------------------------------------
/oled/oled_pic.ino:
--------------------------------------------------------------------------------
1 | #include "U8glib.h"
2 |
3 | // inicializace OLED
4 | U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE);
5 |
6 | const uint8_t vesely[] PROGMEM = {
7 | 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
8 | 0x0,0x0,0x0,0x7f,0xff,0x80,0x0,0x0,0x0,
9 | 0x0,0x0,0x7,0xff,0xff,0xf8,0x0,0x0,0x0,
10 | 0x0,0x0,0x1f,0x80,0x0,0x7e,0x0,0x0,0x0,
11 | 0x0,0x0,0x7c,0x0,0x0,0xf,0x80,0x0,0x0,
12 | 0x0,0x1,0xe0,0x0,0x0,0x1,0xe0,0x0,0x0,
13 | 0x0,0x3,0x80,0x0,0x0,0x0,0x70,0x0,0x0,
14 | 0x0,0xf,0x0,0x0,0x0,0x0,0x3c,0x0,0x0,
15 | 0x0,0x1c,0x0,0x0,0x0,0x0,0xe,0x0,0x0,
16 | 0x0,0x38,0x0,0x0,0x0,0x0,0x7,0x0,0x0,
17 | 0x0,0x70,0x0,0x0,0x0,0x0,0x3,0x80,0x0,
18 | 0x0,0xe0,0x0,0x0,0x0,0x0,0x1,0xc0,0x0,
19 | 0x1,0xc0,0x0,0x0,0x0,0x0,0x0,0xe0,0x0,
20 | 0x3,0x80,0x0,0x0,0x0,0x0,0x0,0x70,0x0,
21 | 0x3,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,
22 | 0x6,0x0,0x7,0x80,0x0,0x3c,0x0,0x18,0x0,
23 | 0x6,0x0,0x1f,0xe0,0x0,0xff,0x0,0x18,0x0,
24 | 0xc,0x0,0x3f,0xf0,0x1,0xff,0x80,0xc,0x0,
25 | 0xc,0x0,0x70,0x38,0x3,0x81,0xc0,0xc,0x0,
26 | 0x18,0x0,0xe0,0x1c,0x7,0x0,0xe0,0x6,0x0,
27 | 0x18,0x0,0xe0,0x1c,0x7,0x0,0xe0,0x6,0x0,
28 | 0x18,0x0,0xe3,0x1c,0x7,0x18,0xe0,0x6,0x0,
29 | 0x30,0x0,0xe7,0x9c,0x7,0x3c,0xe0,0x3,0x0,
30 | 0x30,0x0,0xe7,0x9c,0x7,0x3c,0xe0,0x3,0x0,
31 | 0x30,0x0,0xe7,0x9c,0x7,0x3c,0xe0,0x3,0x0,
32 | 0x30,0x0,0xe3,0x1c,0x7,0x18,0xe0,0x3,0x0,
33 | 0x30,0x0,0xe0,0x1c,0x7,0x0,0xe0,0x3,0x0,
34 | 0x30,0x0,0xe0,0x1c,0x7,0x0,0xe0,0x3,0x0,
35 | 0x30,0x0,0x70,0x38,0x3,0x81,0xc0,0x3,0x0,
36 | 0x30,0x0,0x3f,0xf0,0x1,0xff,0x80,0x3,0x0,
37 | 0x30,0x10,0x1f,0xe0,0x0,0xff,0x0,0x3,0x0,
38 | 0x30,0x18,0x7,0x80,0x0,0x3c,0x0,0x3,0x0,
39 | 0x30,0x18,0x0,0x0,0x0,0x0,0x0,0x3,0x0,
40 | 0x30,0x1c,0x0,0x0,0x0,0x0,0x0,0x3,0x0,
41 | 0x30,0x1c,0x0,0x0,0x0,0x0,0x0,0x3,0x0,
42 | 0x18,0xe,0x0,0x0,0x0,0x0,0x0,0x6,0x0,
43 | 0x18,0xf,0x0,0x0,0x0,0x0,0x0,0x6,0x0,
44 | 0x18,0x7,0x80,0x0,0x0,0x0,0x0,0x6,0x0,
45 | 0xc,0x3,0xc0,0x0,0x0,0x0,0x70,0xc,0x0,
46 | 0xc,0x1,0xe0,0x0,0x0,0x0,0xf0,0xc,0x0,
47 | 0x6,0x0,0xf8,0x0,0x0,0x1,0xe0,0x18,0x0,
48 | 0x6,0x0,0x7f,0x0,0x0,0x3,0xc0,0x18,0x0,
49 | 0x3,0x0,0x1f,0x80,0x0,0x7,0x80,0x30,0x0,
50 | 0x3,0x80,0x7,0xe0,0x0,0x1f,0x0,0x70,0x0,
51 | 0x1,0xc0,0x1,0xfc,0x0,0xfe,0x0,0xe0,0x0,
52 | 0x0,0xe0,0x0,0x7f,0xff,0xf8,0x1,0xc0,0x0,
53 | 0x0,0x70,0x0,0x1f,0xff,0xe0,0x3,0x80,0x0,
54 | 0x0,0x38,0x0,0x0,0xfe,0x0,0x7,0x0,0x0,
55 | 0x0,0x1c,0x0,0x0,0x0,0x0,0xe,0x0,0x0,
56 | 0x0,0xf,0x0,0x0,0x0,0x0,0x3c,0x0,0x0,
57 | 0x0,0x3,0x80,0x0,0x0,0x0,0x70,0x0,0x0,
58 | 0x0,0x1,0xe0,0x0,0x0,0x1,0xe0,0x0,0x0,
59 | 0x0,0x0,0x7c,0x0,0x0,0xf,0x80,0x0,0x0,
60 | 0x0,0x0,0x1f,0x80,0x0,0x7e,0x0,0x0,0x0,
61 | 0x0,0x0,0x7,0xff,0xff,0xf8,0x0,0x0,0x0,
62 | 0x0,0x0,0x0,0x7f,0xff,0x80,0x0,0x0,0x0,
63 | 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
64 | };
65 |
66 | int sirka_displeje = 128;
67 | int vyska_displeje = 64;
68 |
69 | int sirka_obrazku = 65;
70 | int vyska_obrazku = 57;
71 |
72 | // vycentrovane souradnice pro obrazek
73 | int x = (sirka_displeje - sirka_obrazku) / 2;
74 | int y = (vyska_displeje - vyska_obrazku) / 2;
75 |
76 | void setup() {
77 | // nic
78 | }
79 |
80 | // vypise vysledek na displeji
81 | void vykresli() {
82 | //x = x souradnice, kde zacne kreslit obrazek (0;0 - levy horni roh)
83 | //y = y souradnice, kde zacne kreslit obrazek (0;0 - levy horni roh)
84 | //pocet bajtu na sirku obrazku
85 | //vyska obrazku
86 | //obrazek
87 | int pocet_bajtu_sirka_obrazku = (int)(sirka_obrazku / 8.0 + 0.5);
88 | u8g.drawBitmapP(x, y, pocet_bajtu_sirka_obrazku, vyska_obrazku, vesely);
89 | }
90 |
91 | void loop() {
92 | u8g.firstPage();
93 | do {
94 | vykresli();
95 | } while (u8g.nextPage());
96 |
97 | delay(1000);
98 | }
99 |
--------------------------------------------------------------------------------
/oled/oled_txt.ino:
--------------------------------------------------------------------------------
1 | #include "U8glib.h"
2 |
3 | // inicializace OLED
4 | U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE);
5 |
6 | void setup() {
7 | // nic
8 | }
9 |
10 | // vypise vysledek na displeji
11 | void vypis() {
12 | u8g.setFont(u8g_font_fub25n);
13 | u8g.drawStr(40, 30, "BAF!");
14 | u8g.setFont(u8g_font_unifont);
15 | u8g.drawStr(45, 50, "strasidlo");
16 | }
17 |
18 | void loop() {
19 | u8g.firstPage();
20 | do {
21 | vypis();
22 | } while (u8g.nextPage());
23 |
24 | delay(1000);
25 | }
26 |
--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
1 | Statické zápisky o našich domácích dětských projektech v Arduinu, které si můžete prohlédnout na [arduino.zausima.cz](http://arduino.zausima.cz).
--------------------------------------------------------------------------------
/rucni_blikace/P1120575.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/rucni_blikace/P1120575.JPG
--------------------------------------------------------------------------------
/rucni_blikace/P1370943.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/rucni_blikace/P1370943.JPG
--------------------------------------------------------------------------------
/rucni_blikace/led_cervena.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/rucni_blikace/led_cervena.jpg
--------------------------------------------------------------------------------
/rucni_blikace/rucni_blikac.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/rucni_blikace/rucni_blikac.fzz
--------------------------------------------------------------------------------
/rucni_blikace/rucni_blikac_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/rucni_blikace/rucni_blikac_bb.png
--------------------------------------------------------------------------------
/rucni_blikace/rucni_blikace.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # Ruční blikače
4 | Základní osahání součástek. Osahání LEDek. Anoda, katoda. Mnemotechnické pomůcky pro rozlišení nožiček:
5 | * "ANOda", kde ANO = kladné přitakání, tedy plus
6 | * ta delší nožička, což znamená "více", tedy plus
7 |
8 | 
9 |
10 | * při pohledu shora nebo zespodu může být jedna strana seříznutá, tedy "mínus"
11 |
12 | 
13 |
14 | No a pokud se netrefíte, tak se zase tolik nestane. LED nebude svítit, protože je dioda zavřená.
15 |
16 | [Připojení LED přes rezistor](https://arduino.cz/proc-musim-u-led-pouzit-rezistor/) (pozor, ať se neusmaží i samotné Arduino, [max proudové zatížení digitálního pinu je 40 mA](http://playground.arduino.cc/Main/ArduinoPinCurrentLimitations), LED často vydrží i více). Osahání si prototypovacího nepájivého pole, vysvětlení vnitřního zapojení pole (koleje s `+` a `-` u velkého, rozdíly u malého), doporučené barvy u vodičů.
17 |
18 | Spínače. Úlohy na rozsvícení 1 LED spínačem. 2 LED 1 spínačem, každou zvlášť svým spínačem apod.
19 |
20 | Základní kreslení schémat (tužka, papír).
21 | ## Co je potřeba umět
22 | Prakticky nic. Začínáme. Neprogramujeme, jen zapojujeme.
23 |
24 | ## Foto
25 | 
26 | 
27 |
28 | ## Hardware
29 | * _Tady nepotřebujeme nutně Arduino, jen je pak potřeba vymyslet nějak jinak napájení pole_
30 | * Dostatek různě barevných LED, některé se asi spálí
31 | * Rezistory 220 Ω - 330 Ω
32 | * Spínače
33 |
34 | ## Schéma zapojení
35 | [rucni_blikac.fzz](rucni_blikac.fzz)
36 |
37 | [](rucni_blikac_bb.png)
38 |
39 | ## Program
40 | Není potřeba. Arduino slouží nejvýše jako zdroj napájení pro pole.
41 |
42 | ## Možná vylepšení
43 | * Pro rozsvícení LED potřebuji stisknout více spínačů najednou.
44 | * Při hraní se součástkami je možné přihodit i multimetr a proměřit baterii, proměřit, kde je a kde není napětí v poli, které části vedou a které ne.
45 |
46 | ## Poznatky
47 | Pro děti je to podstatně větší zábava než bych očekával a to i pro starší (8-9 let). Úlohy s paralelním/sériovým zapojením LED a spínačů už jsou pro mladší děti (6 let) už docela těžké.
--------------------------------------------------------------------------------
/rucni_blikace/seriznuto.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/rucni_blikace/seriznuto.png
--------------------------------------------------------------------------------
/semafor/P1360409.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/semafor/P1360409.JPG
--------------------------------------------------------------------------------
/semafor/P1360414.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/semafor/P1360414.JPG
--------------------------------------------------------------------------------
/semafor/P1360415.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/semafor/P1360415.JPG
--------------------------------------------------------------------------------
/semafor/P1360416.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/semafor/P1360416.JPG
--------------------------------------------------------------------------------
/semafor/P1360417.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/semafor/P1360417.JPG
--------------------------------------------------------------------------------
/semafor/P1360423.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/semafor/P1360423.JPG
--------------------------------------------------------------------------------
/semafor/P1360427.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/semafor/P1360427.JPG
--------------------------------------------------------------------------------
/semafor/semafor.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/semafor/semafor.fzz
--------------------------------------------------------------------------------
/semafor/semafor.ino:
--------------------------------------------------------------------------------
1 | // jak dlouho ma pockat
2 | const int sekunda = 1000;
3 |
4 | int casC = 15 * sekunda;
5 | int casOC = 1 * sekunda;
6 | int casO = 2 * sekunda;
7 | int casZ = 12 * sekunda;
8 | int casBlik = 300;
9 | int casCHC = 3 * sekunda;
10 | int pinC = 10;
11 | int pinZ = 8;
12 | int pinO = 9;
13 | int pinCHZ = 12;
14 | int pinCHC = 11;
15 |
16 | void setup() {
17 | pinMode(pinZ, OUTPUT); // zelena
18 | pinMode(pinO, OUTPUT); // oranzova
19 | pinMode(pinC, OUTPUT); // cervena
20 | pinMode(pinCHC, OUTPUT); // chodec cervena
21 | pinMode(pinCHZ, OUTPUT); // chodec zelena
22 | }
23 |
24 | void loop() {
25 | // rozsvit c ch z
26 | digitalWrite(pinC, HIGH);
27 | digitalWrite(pinCHZ, HIGH);
28 | // cekej
29 | delay(casC);
30 | // rozsvit z blik
31 | for (int i = 0; i < 3; i++) {
32 | digitalWrite(pinCHZ, HIGH);
33 | delay(casBlik);
34 | digitalWrite(pinCHZ, LOW);
35 | delay(casBlik);
36 | } // rozsvit ch c
37 | digitalWrite(pinCHC, HIGH);
38 | digitalWrite(pinC, HIGH);
39 | delay(casCHC);
40 |
41 | digitalWrite(pinO, HIGH);
42 | // cekej
43 | delay(casOC);
44 | // zhasni c o
45 | digitalWrite(pinC, LOW);
46 | digitalWrite(pinO, LOW);
47 | // rozsvit z
48 | digitalWrite(pinZ, HIGH);
49 | // cekej
50 | delay(casZ);
51 | // zhasni z
52 | digitalWrite(pinZ, LOW);
53 | // rosvit o
54 | digitalWrite(pinO, HIGH);
55 | delay(casO);
56 | digitalWrite(pinO, LOW);
57 | // blikani
58 | delay(casBlik);
59 | for (int i = 0; i < 5; i++) {
60 | digitalWrite(pinO, HIGH);
61 | delay(casBlik);
62 | digitalWrite(pinO, LOW);
63 | delay(casBlik);
64 | }
65 | digitalWrite(pinCHC, HIGH);
66 | digitalWrite(pinC, HIGH);
67 | delay(casCHC);
68 | digitalWrite(pinCHC, LOW);
69 | }
70 |
--------------------------------------------------------------------------------
/semafor/semafor.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # Semafor
4 | Pokročilejší úloha s využitím LED, samostatně vytvořit semafor. Míru samostatnosti lze regulovat (od zapojení HW přes napsání celého SW apod.) Abychom mohli snadno měnit intervaly pro jednotlivé barvy, zavedli jsme proměnné (v roli konstant). Pro lepší orientaci v kódu využíváme hojně komentáře.
5 |
6 | ## Co je potřeba umět
7 | * zapojení, ovládání LED
8 | * základní programové konstrukce (podmínky, hodí se i opakování), `HIGH`, `LOW`, `delay()` apod.
9 |
10 | ## Foto
11 | 
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 |
19 | ## Video
20 |
21 |
22 |
26 |
27 |
28 | ## Hardware
29 | * Zelené, žluté, červené LED
30 | * Rezistory 220 Ω - 330 Ω
31 |
32 | ## Schéma zapojení
33 | [semafor.fzz](semafor.fzz)
34 |
35 | [](semafor_bb.png)
36 |
37 | ## Program
38 | [semafor.ino](semafor.ino) - kód je napsán osmiletým dítětem, obsahuje různá vylepšení standardního semaforu viz níže
39 | ``` c++
40 | {% include_relative semafor.ino %}
41 | ```
42 | ## Možná vylepšení
43 | * Doplnění klasického auto-semaforu ještě o semafor pro chodce.
44 | * Doplnění klasického auto-semaforu ještě o semafor pro chodce s přihlašovacím tlačítkem.
45 | * Doplnění semaforu(ů) o bezpečnostní chvíle, kdy svítí všude červená (pro přeběhlíky).
46 | * Doplnění semaforu(ů) o blikání před koncem zelené (upozornění, že brzy skočí červená).
47 | * Pro železniční nadšence je možné vyrobit např. nějaké [návěstidlo](https://www.google.com/search?q=odjezdov%C3%A9+n%C3%A1v%C4%9Bstidlo&client=firefox-b&source=lnms&tbm=isch&sa=X&ved=0ahUKEwjeoaqExufSAhVlIpoKHaayDeIQ_AUICCgB&biw=1600&bih=793#tbm=isch&q=odjezdov%C3%A9+n%C3%A1v%C4%9Bstidlo+barvy&*&imgrc=).
48 | * Pro formulové nadšence je možné vyrobit [startovací světla](https://www.google.com/search?q=odjezdov%C3%A9+n%C3%A1v%C4%9Bstidlo&client=firefox-b&source=lnms&tbm=isch&sa=X&ved=0ahUKEwjeoaqExufSAhVlIpoKHaayDeIQ_AUICCgB&biw=1600&bih=793#tbm=isch&q=formula+start+lights&*).
49 |
50 | ## Poznatky
51 | Zajímavá úloha pro procvičení samostatnosti, protože jak funguje semafor ví každé dítě, takže zadání není třeba příliš vysvětlovat. S výsledkem si lze navíc i vyhrát, pokud se využije malé nepájivé pole a nacpe se do krabičky od zápalek, je celé řešení celkem kompaktní. Mladší děti končí u standardního semaforu, starší ho šperkují.
52 |
--------------------------------------------------------------------------------
/semafor/semafor.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/semafor/semafor.mp4
--------------------------------------------------------------------------------
/semafor/semafor_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/semafor/semafor_bb.png
--------------------------------------------------------------------------------
/teplomer/595_pin_diagram.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/595_pin_diagram.png
--------------------------------------------------------------------------------
/teplomer/LD3361BS.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/LD3361BS.pdf
--------------------------------------------------------------------------------
/teplomer/P1360358.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/P1360358.JPG
--------------------------------------------------------------------------------
/teplomer/P1360359.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/P1360359.JPG
--------------------------------------------------------------------------------
/teplomer/P1360360.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/P1360360.JPG
--------------------------------------------------------------------------------
/teplomer/P1360362.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/P1360362.JPG
--------------------------------------------------------------------------------
/teplomer/P1360363.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/P1360363.JPG
--------------------------------------------------------------------------------
/teplomer/P1360373.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/P1360373.JPG
--------------------------------------------------------------------------------
/teplomer/SN74HC595.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/SN74HC595.pdf
--------------------------------------------------------------------------------
/teplomer/lm35.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/lm35.pdf
--------------------------------------------------------------------------------
/teplomer/teplomer.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/teplomer.fzz
--------------------------------------------------------------------------------
/teplomer/teplomer.ino:
--------------------------------------------------------------------------------
1 | const int digitPins[4] = {4, 5, 6, 7};
2 | const int clockPin = 10; // 74HC595 Pin 11
3 | const int latchPin = 11; // 74HC595 Pin 12
4 | const int dataPin = 12; // 74HC595 Pin 14
5 | const int tempPin = A0; // datovy pin teplomeru
6 | const byte digits[10] = // cislice zakodovane jako jednotlive LED 7segmentoveho
7 | // displeje
8 | {
9 | /*
10 | A
11 | +--+
12 | F |G | B
13 | +--+
14 | E | | C
15 | +--+
16 | D
17 | */
18 | // ABCDEFG. (posledni je tecka)
19 | B11111100, // 0
20 | B01100000, // 1
21 | B11011010, // 2
22 | B11110010, // 3
23 | B01100110, // 4
24 | B10110110, // 5
25 | B10111110, // 6
26 | B11100000, // 7
27 | B11111110, // 8
28 | B11110110 // 9
29 | };
30 |
31 | // jen na zkousku, pozdrav
32 | const byte letters[4] = {
33 | // ABCDEFG.
34 | B11101110, // A
35 | B01101110, // H
36 | B11111100, // O
37 | B01111000 // J
38 | };
39 |
40 | void setup() {
41 | for (byte i = 0; i < 4; i++) {
42 | pinMode(digitPins[i], OUTPUT);
43 | }
44 | pinMode(latchPin, OUTPUT);
45 | pinMode(clockPin, OUTPUT);
46 | pinMode(dataPin, OUTPUT);
47 | // pin pro teplotu
48 | pinMode(tempPin, INPUT);
49 |
50 | // analogReference(INTERNAL);
51 |
52 | // testovaci konzole
53 | // Serial.begin(9600);
54 |
55 | // zobraz pozdrav
56 | for (byte i = 0; i < 200; i++) {
57 | displayLetter(3, 0);
58 | displayLetter(2, 1);
59 | displayLetter(1, 2);
60 | displayLetter(0, 3);
61 | }
62 | }
63 |
64 | // zobrazi pismeno
65 | // digit = pozice na displeji (zleva, od 0)
66 | // letter = poradi pismene v poli letters
67 | void displayLetter(byte digit, byte letter) {
68 | // pred posouvanim bitu je potreba vypnout displej
69 | displayOff();
70 | // zavora dolu
71 | digitalWrite(latchPin, LOW);
72 | // napln shit registr daty o pismenu
73 | // ~ = bitova negace https://www.arduino.cc/en/Reference/BitwiseXorNot
74 | // protoze je displej se spolecnou anodou, privadime na anodu +5V z pinu, ktery vybira cislici
75 | // na katodu je pak potreba privest LOW, aby LED svitila, HIGH, aby nesvitila
76 | // toho docilime tak, ze prevratime 1 z pole letters/digits na 0 a obracene
77 | shiftOut(dataPin, clockPin, LSBFIRST, ~letters[letter]);
78 | // zavora nahoru -> odesilame na vystupni piny shift registru
79 | digitalWrite(latchPin, HIGH);
80 | // pust HIGH do vybrane cislice displeje
81 | digitalWrite(digitPins[digit], HIGH);
82 | // pockame chvilku na POV (persistence of vision)
83 | delay(3);
84 | }
85 |
86 | // zobrazi cislici na vybrane pozici displeje, automaticky osetruje desetinnou
87 | // tecku za druhou cislici
88 | // digit = pozice, na ktere chceme cislici zobrazit
89 | // number = cislice, kterou chceme zobrazit
90 | void displayDigit(byte digit, byte number) {
91 | // pred posouvanim bitu je potreba vypnout displej
92 | displayOff();
93 | // zavora dolu
94 | digitalWrite(latchPin, LOW);
95 | // pokud piseme treti cislici (pocitano od 0), tak rozsvitime i desetinnou
96 | // tecku
97 | //
98 | // ~ = bitova negace https://www.arduino.cc/en/Reference/BitwiseXorNot
99 | // protoze je displej se spolecnou anodou, privadime na anodu +5V z pinu, ktery vybira cislici
100 | // na katodu je pak potreba privest LOW, aby LED svitila, HIGH, aby nesvitila
101 | // toho docilime tak, ze prevratime 1 z pole letters/digits na 0 a obracene
102 | if (digit == 2) {
103 | // desetina tecka je bitove posledni, provedeme bitovy OR
104 | shiftOut(dataPin, clockPin, LSBFIRST, ~(digits[number] | B00000001));
105 | } else {
106 | // normalni zapis do shift registru
107 | shiftOut(dataPin, clockPin, LSBFIRST, ~digits[number]);
108 | }
109 | // zavora nahoru -> odesilame na vystupni piny shift registru
110 | digitalWrite(latchPin, HIGH);
111 | // pust HIGH do vybrane cislice displeje
112 | digitalWrite(digitPins[digit], HIGH);
113 | // pockame chvilku na POV (persistence of vision)
114 | delay(3);
115 | }
116 |
117 | // zhasni vsechny LED
118 | void displayOff() {
119 | for (byte i = 0; i < 4; i++) {
120 | digitalWrite(digitPins[i], LOW);
121 | }
122 | }
123 |
124 | // aktualizuj displej
125 | void updateDisplay(float number) {
126 | byte digitBuffer[4] = {0};
127 | // orizni na 2 desetiny
128 | number = int(number * 100);
129 | // setiny
130 | digitBuffer[3] = int(number) / 1000;
131 | // desetiny
132 | digitBuffer[2] = (int(number) % 1000) / 100;
133 | // jednotky
134 | digitBuffer[1] = (int(number) % 100) / 10;
135 | // desitky
136 | digitBuffer[0] = (int(number) % 100) % 10;
137 |
138 | for (byte i = 0; i < 50; i++) {
139 | for (byte digit = 0; digit < 4; digit++) {
140 | // zobraz po sobe vsechny cislice hodnoty
141 | displayDigit(digit, digitBuffer[digit]);
142 | }
143 | }
144 | }
145 |
146 | void loop() {
147 | // precti hodnotu teplomeru
148 | int reading = analogRead(tempPin);
149 | // prepocitame hodnotu na stupne
150 | // rozsah hodnot analogoveho vystupu je 0-1024, (0-5V)
151 | // teplomer vraci 10mV/stupen C
152 | // 5 V / 1024 = 4,8828 mV
153 | // teplota = (5 * hodnota * 100) / 1024
154 | float tempC = (5 * reading * 100.0) / 1024.0;
155 |
156 | // pokud bychom chteli vyssi presnost, muzeme nastavit jine referencni napeti
157 | // pro analogovy vstup
158 | // odpoznamkovat v setup() analogReference(INTERNAL);
159 | // to nastavi misto 5V referencni napeti 1.1V
160 | // zmenou referencniho napeti na 1.1 se zmeni rozsah LM35 na 0-110 stupnu C
161 | // tempC = (1.1 * reading * 100.0) / 1024.0;
162 |
163 | // Serial.print(tempC);
164 | // Serial.println(" C");
165 | for (int i = 0; i < 10; i++) {
166 | updateDisplay(tempC);
167 | }
168 | }
169 |
--------------------------------------------------------------------------------
/teplomer/teplomer.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # Teploměr
4 | Teploměr pro měření teploty vzduchu se zobrazováním hodnoty na segmentovém displeji. Celkem náročnější úloha, záleží, kolik nových věcí najednou se dítě učí. Pokud je vše nové, tak to může být opravdu těžké (segmentový displej, posuvný registr, teploměr). Je možné provést jednoduchou variantu pouze s teploměrem, který vypisuje hodnoty např. na konzoli. A nebo kombinovat s jiným typem displeje (jednodušší ovládání).
5 |
6 | ## Co je potřeba umět
7 | * Násobení, dělení.
8 | * HW: Základní zapojování LED, rezistorů.
9 | * SW: Je dobré rozumět cyklům, hodí se znát operátor pro zbytek po dělení (modulo), rozumět polím, procedury.
10 |
11 | ## Foto
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 |
19 | ## Hardware
20 | * teploměr LM35 ([Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170323042709&SearchText=LM35), [specifikace](lm35.pdf))
21 | * 4 číslicový 7 segmentový displej (použili jsme 3461BS, [Aliexpress](https://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20170323042741&SearchText=3461BS), [specifikace](LD3361BS.pdf))
22 | * Posuvný registr 74HC595 ([Aliexpres](https://www.aliexpress.com/wholesale?catId=0&initiative_id=&SearchText=74HC595), [specifikace](SN74HC595.pdf))
23 | * 8 rezistorů 220 Ω - 330 Ω
24 |
25 | ## Jak to funguje
26 |
27 | ### Teploměr LM35
28 | Parametry:
29 | * rozsah od −55° C do 150 °C
30 | * přesnost 0,5 °C (při 25 °C)
31 | * vstupní napětí od 4 V do 30 V
32 | * nízké sebezahřívání (0,08 °C, pokud se tedy nezapojí obráceně ;-) )
33 |
34 | Teploměr má 3 nožičky, napájení po stranách (`+Vs`, `GND`) a výstupní hodnotu na `Vout`. Ve specifikaci jsem napoprvé nějak přehlédl popisek k rozložení nožiček a zapojil jsem obráceně polaritu. Naštěstí jen na chvíli.
35 |
36 | 
37 |
38 | Při pohledu _zespodu_ je `+Vs` vlevo a `GND` vpravo :-) Hodnota `Vout` pak uprostřed.
39 |
40 | Teploměr vrací 10 mV/°C, rozsah analogového vstupu Arduina je 0-5V, vzorkovaných do 1024 hodnot. Z analogového pinu přečteme hodnotu, tu je nejdříve potřeba přepočítat na napětí, které vrací teploměr.
41 | ```
42 | napětí na výstupu teploměru = analogový pin vrací /1024 * 5.0
43 | ```
44 | protože teploměr vrací 10 mV na 1 °C, převedeme dále
45 | ```
46 | teplota = napětí na výstupu teploměru / 0,01
47 | ```
48 | výsledný přepočet je pak
49 | ```
50 | teplota = (analogový pin vrací /1024 * 5.0) / 0,01
51 | ```
52 | nebo také [podstatně slavnější rovnice](http://playground.arduino.cc/Main/LM35HigherResolution)
53 | ```
54 | teplota = (5.0 * analogový pin vrací * 100.0) / 1024;
55 | ```
56 | Pokud bychom chtěli zvýšit trochu přesnost teploměru, snížíme referenční napětí z 5 V na 1,1 V. Teploměr tak bude měřit pouze v rosahu 0-110 °C, ale s přesností na desetinky - tedy v rámci možností, protože sám LM35 má přesnost 0,5 °C. Výpočet pak vypadá takto:
57 | ```
58 | teplota = (1.1 * analogový pin vrací * 100.0) / 1024;
59 | ```
60 | V kódu je pak potřeba v metodě `setup()` nastavit `analogReference(INTERNAL)`.
61 |
62 | ### Segmentový displej
63 | Jde o hromadu LED, které jsou uspořádány do nějakého obrazce. Obvykle hovoříme o 7 segmentovém displeji (ale vlastně je 8 segmentový, protože máme tečky). Obvykle má displej kromě napájení piny, kterými vybíráme, kterou číslici chceme zrovna napájet. Tady se displeje dělí na 2 druhy - se společnou katodou a společnou anodou. Tedy je nejdříve potřeba zjistit, jaký displej držíme v ruce, podle toho pak bude zapojení a programování vypadat.
64 |
65 | 3461BS je segmentovka se společnou anodou (ve [specifikaci](LD3361BS.pdf) je to strana 39). To znamená, že výběrový pin přivádí `HIGH` a na druhý konec vybraných LED potřebujeme přivést `LOW`, aby se rozsvítily respektive `HIGH`, aby ne (u displeje se společnou katodou je to právě naopak). Protože Arduino nemá tolik pinů, využijeme posuvný registr, který vždy nejdříve nakrmíme všemi nulami a jedničkami pro jednotlivé LED a následně ho necháme, aby je pro nás rozsvítil.
66 |
67 | Tady jen poznámka ke kódu níže - v konstantě pro jednotlivé číslice máme, že hodnota 1 = LED svítí, ale výše jsem uvedl, že aby svítila, musí mít na anodě `HIGH` a na katodě `LOW`. A protože naše LED už `HIGH` na svou anodu "dostaly", musíme jim pro rozsvícení dodat `LOW` na katodu. Tedy nulu do posuvného registru tam, kde mají svítit. Proto se v kódu objevuje [binární negace](https://www.arduino.cc/en/Reference/BitwiseXorNot) v podobě `~`, která nám přehodí všechny 0 na 1 a obráceně. Pro displeje se společnou katodou to není potřeba, tam posíláme pro rozsvícení na anodu jedničky.
68 |
69 | **Pozor i 7/8 segmentový displej vyžaduje zapojení přes rezistory!**
70 |
71 | ### Posuvný registr 74HC595
72 | Posuvný registr nám dovoluje obsluhovat např. více LED než máme na Arduinu pinů. Zjednodušeně do něj nacpeme seriově potřebné informace a pak mu dáme signál, že to má najednou (paralelně) přenést na své datové výstupy (LED).
73 |
74 | 
75 |
76 | Podrobněji: na vstupu máme 3 nožičky:
77 | * data (pin 14) - data, tudy posuvný registru předáváme informace
78 | * clock (pin 11) - časování, tady se posuvný registr dozví, že by měl číst z datového pinu, po každém čtení si informaci zapamatuje
79 | * latch (pin 12) - závora, která při přechodu na z `LOW` → `HIGH` přepíše paměť registru na výstupní datové piny registru
80 |
81 | Na výstupu pak máme 8 datových nožiček (pin 1-7 + 15), na které se přenáší paměť registru při zvednuté závoře. Napájení jsou piny `GND` + `OE` → `GND`, `Vcc` + `MR` → +5 V.
82 |
83 | Pro vlastní plnění posuvného registru využíváme metodu Arduina [shiftOut](https://www.arduino.cc/en/Reference/ShiftOut). Té předáváme datový pin, kudy tlačíme data, clock pin, kde bude Arduino posuvný registru "tikat", aby veděl, kdy má data číst, jestli začínáme nejméně významným bitem nebo nejvíce významným bitem a vlastní přenášenou hodnotu.
84 |
85 | Jen malé upozornění pro další pokusy s posuvným registrem, najednou z něj lze tahat asi maximálně 70 mA. Více se dá dočíst v pěkném [povídání v angličtině](https://www.arduino.cc/en/Tutorial/ShiftOut).
86 |
87 | ## Schéma zapojení
88 | [teplomer.fzz](teplomer.fzz)
89 | Zapojení kreslilo 7 leté dítě :-)
90 |
91 | [](teplomer_bb.png)
92 |
93 | ## Program
94 | [teplomer.ino](teplomer.ino)
95 | ``` c++
96 | {% include_relative teplomer.ino %}
97 | ```
98 | ## Možná vylepšení
99 | * Zvýšení přesnosti teploměru změnou referenčního napětí z 5 V → 1,1 V.
100 | * Přidávání dalších informací, které by se na segmentovém displeji mohly zobrazovat (písmenka).
101 | * Protože ovládání segmentového displeje je celkem komplikované, je možné zkusit jiný typ displeje, např. LCD nebo OLED.
102 |
103 | ## Poznatky
104 | Nejvíce asi zabralo vysvětlování toho, jak jsou ty LED uspořádány uvnitř segmentového displeje. Pak samozřejmě posuvný registr a nějak se poprat s bitovými operacemi (ale ty se dají obejít tím, že uděláme bitový zápis v kódu a nepřevádíme mezi soustavami). A pak samozřejmě ta nehoda s teploměrem... ;-) Celkově je to náročnější úloha, která se nemusí stihnout ani za jedno odpoledne, pokud jsou všechny ty věci nové.
105 |
--------------------------------------------------------------------------------
/teplomer/teplomer_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/teplomer_bb.png
--------------------------------------------------------------------------------
/teplomer/teplomer_nozicky.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/teplomer/teplomer_nozicky.png
--------------------------------------------------------------------------------
/touchduino/P1220334.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/touchduino/P1220334.JPG
--------------------------------------------------------------------------------
/touchduino/P1220335.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/touchduino/P1220335.JPG
--------------------------------------------------------------------------------
/touchduino/P1220506.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/touchduino/P1220506.JPG
--------------------------------------------------------------------------------
/touchduino/P1220507.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/touchduino/P1220507.JPG
--------------------------------------------------------------------------------
/touchduino/P1220515.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/touchduino/P1220515.JPG
--------------------------------------------------------------------------------
/touchduino/P1220532.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/touchduino/P1220532.JPG
--------------------------------------------------------------------------------
/touchduino/arduino_keyboard.py:
--------------------------------------------------------------------------------
1 | import sys
2 | import serial
3 | from pykeyboard import PyKeyboard
4 |
5 | keyboard = PyKeyboard()
6 |
7 | KEYS = {
8 | b"KEY_UP\n": keyboard.up_key,
9 | b"KEY_DOWN\n": keyboard.down_key,
10 | b"KEY_RIGHT\n": keyboard.right_key,
11 | b"KEY_LEFT\n": keyboard.left_key,
12 | b"KEY_SPACE\n": keyboard.space_key,
13 | #b"KEY_ENTER\n": keyboard.enter_key,
14 | b"KEY_ENTER\n": 'a',
15 | }
16 |
17 | print("Arduino UNO R3 Keyboard simulator")
18 |
19 | if len(sys.argv) < 2:
20 | print("Schazi port, na kterem mam poslouchat Arduino")
21 | print("priklad Windows: python arduino_keyboard.py COM1")
22 | print("priklad Linux: python arduino_keyboard.py /dev/ttyusb0")
23 | sys.exit(1)
24 |
25 | port = sys.argv[1]
26 | print("Nasloucham na portu: {}".format(port))
27 | print("Pro ukonceni stiskni Ctrl+C\n")
28 |
29 | ser = serial.Serial(port, 9600)
30 | while True:
31 | line = ser.readline()
32 | print("Arduino poslalo: {}".format(line))
33 | for k, v in KEYS.items():
34 | if line == k:
35 | keyboard.tap_key(v)
36 | print('Mackam klavesu: {}'.format(k))
37 | break
38 |
--------------------------------------------------------------------------------
/touchduino/touchduino.fzz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/touchduino/touchduino.fzz
--------------------------------------------------------------------------------
/touchduino/touchduino.ino:
--------------------------------------------------------------------------------
1 | byte pins[6] = {A0, A1, A2, A3, A4, A5};
2 |
3 | void setup() {
4 | // nastartuj seriovo ulinku
5 | Serial.begin(9600);
6 | // budeme cist z analogovych pinu
7 | for (byte i = 0; i < 6; i++) {
8 | pinMode(pins[i], INPUT);
9 | }
10 | }
11 |
12 | // osetri uzavrenou smycku
13 | void handle(byte pin, char* command) {
14 | // posli prikaz na seriovou linku
15 | Serial.print(command);
16 | int value = 0;
17 | // dokud se smycka nerozpoji, tak cekej
18 | while (value < 900) {
19 | value = analogRead(pins[pin]);
20 | delay(10);
21 | }
22 | }
23 |
24 | void loop() {
25 | for (byte i = 0; i < 6; i++) {
26 | int value = analogRead(pins[i]);
27 | // pokud je smycka uzavrena
28 | if (value < 900) {
29 | //Serial.print(value);
30 | //Serial.print("\n");
31 | switch (i) {
32 | case 0: handle(i, "KEY_SPACE\n"); break;
33 | case 1: handle(i, "KEY_LEFT\n"); break;
34 | case 2: handle(i, "KEY_RIGHT\n"); break;
35 | case 3: handle(i, "KEY_UP\n"); break;
36 | case 4: handle(i, "KEY_DOWN\n"); break;
37 | case 5: handle(i, "KEY_ENTER\n"); break;
38 | }
39 | }
40 | }
41 | delay(10);
42 | }
43 |
--------------------------------------------------------------------------------
/touchduino/touchduino.md:
--------------------------------------------------------------------------------
1 | [← zpět na zápisky z Arduino projektů](../index.md)
2 |
3 | # Touchduino
4 | * obsah
5 | {:toc}
6 | {::options toc_levels="2..4" /}
7 |
8 | Tak pojmenovaly tento projekt děti. Naše domácí verze mnohem slavnějšího [Makey Makey](https://www.makeymakey.com/). Jde o jednoduchý obvod s detekcí uzavřené smyčky a generováním kláves v počítači.
9 |
10 | Bohužel, běžná Arduina se nechovají jako `HID` [(Human Interface Device)](https://en.wikipedia.org/wiki/USB_human_interface_device_class), to umí jen méně časté verze jako třeba [Leonardo, Micro či Due](https://www.arduino.cc/en/Reference.MouseKeyboard). Taková se nám doma neválí, tedy jsme si museli nějak poradit.
11 |
12 | ## Co je potřeba umět
13 | Určitě je výhodou se alespoň trochu orientovat v Pythonu, hlavně v instalaci knihoven.
14 |
15 | ## Foto
16 | První pokusy 
17 | 
18 | 
19 | Tady už řádí děti 
20 | 
21 | 
22 |
23 | ## Video
24 |
25 |
29 |
30 |
31 | ## Hardware
32 | * 6× 2 MΩ rezistor (Arduino Uno má 6 analogových pinů)
33 |
34 | ## Jak to funguje
35 | Propojili jsme Arduino Uno (ale lze vzít jakýkoli kontroler, který neumí `HID`) přes seriové rozhraní s počítačem, kde na něj čeká Python skript. Ten následně generuje klávesy v systému, jako by byly stisknuty na klávesnici. Klávesy pak lze zachytit v libovolném programu, např. ve [Scratchi](http://scratch.mit.edu/), ve kterém se děti často učí programovat a mohou si tak vyhrát např. se zvuky. Výsledek jsme otestovali na Windows tak i na Linuxu. Jako "tlačítka" děti použily modelínu.
36 |
37 | ## Schéma zapojení
38 | [touchduino.fzz](touchduino.fzz)
39 |
40 | [](touchduino_bb.png)
41 |
42 | ## Program Arduino
43 | Hodnota `900` pro uzavřenou smyčku byla zjištěna experimentálně.
44 |
45 | [touchduino.ino](touchduino.ino)
46 | ``` c++
47 | {% include_relative touchduino.ino %}
48 | ```
49 |
50 | ## Python simulátor klávesnice
51 | Protože Arduino Uno neumí samo simulovat klávecnici (není [HID](https://en.wikipedia.org/wiki/USB_human_interface_device_class)), napsal jsem jednoduchý skript v jazyce Python, který se připojí na seriovou linku na zadaném portu, čte příkazy poslané Arduinem a následně simuluje stisknuté klávesy.
52 | ### Prerekvizity
53 | 1. Nainstalován [Python 3](https://www.python.org/downloads/)
54 |
55 | Verzi Pythonu lze zjistit
56 | ```shell
57 | python --version
58 | Python 3.6.0
59 | ```
60 | Další podrobnosti k instalaci třeba v [tomto pěkném manuálu](https://tutorial.djangogirls.org/en/python_installation/). Někdy běží souběžně verze 2.x i 3.x, pak je potřeba pouštět python 3 např. jako ; `python3`.
61 | 2. Na **Linuxu** postačí nainstalovat knihovny `PySerial` a `PyUserInput`:
62 |
63 | ``` shell
64 | pip install pyserial
65 | pip install pyuserinput
66 | ```
67 | 3. Na **Windows** je potřeba trochu více, protože knihovna `PyUserInput` pro Windows vyžaduje dále `PyHook` a `PySerial` vyžaduje pro přístup k portům `Pypiwin32`.
68 |
69 | `PyHook` se mi podařilo nainstalovat z [balíčku wheel](https://www.lfd.uci.edu/~gohlke/pythonlibs/#pyhook) (pozor, až budete tento návod číst, může být již novější verze).
70 | ```shell
71 | pip install pyHook-1.5.1-cp27-none-win32.whl
72 | ```
73 | Pypiwin32 pak standardní cestou.
74 | ```shell
75 | pip install pypiwin32
76 | ```
77 | Co se mi však nedařilo pro nekompatibilitu verzí Python, byla instalace samotného `PyUserInput` na Windows, nakonec jsem stáhl [přímo zip](https://github.com/PyUserInput/PyUserInput) (clone or download, download zip) a po rozbalení provedl ruční instalaci.
78 | ```shell
79 | python setup.py install
80 | ```
81 |
82 | ### Program Python simulující stisky kláves
83 | [arduino_keyboard.py](arduino_keyboard.py)
84 | ``` python
85 | {% include_relative arduino_keyboard.py %}
86 | ```
87 |
88 | ### Jak to pustit
89 | Python simulátor klávesnice pustíme z příkazové řádky, očekává jediný parametr a tím je označení portu, na kterém si bude s Arduinem povídat.
90 |
91 | Postup, jak zjistit, na jakém portu se ním Arduino usídlilo, se liší podle operačního systému.
92 |
93 | #### Linux
94 | ``` shell
95 | ls -l /dev/tty*
96 | ```
97 | nebo ještě lépe
98 | ``` shell
99 | dmesg | tail
100 | ```
101 | Vlastní spuštění pak vypadá takto:
102 | ```shell
103 | python arduino_keyboard.py /dev/ttyACM0
104 | ```
105 |
106 | #### Windows
107 | Control panels, Device Manager, Ports (COM & LPT)
108 |
109 | 
110 |
111 | Vlastní spuštění pak vypadá takto:
112 | ```shell
113 | python arduino_keyboard.py COM26
114 | ```
115 |
116 | Skript čte ze zadaného sériového portu, kam mu Arduino posílá příkazy. Co přichází, vypisuje na konzoli, pokud něčemu porozumí, píše, jaké klávesy generuje. Ukončit jej lze např. pomocí `Ctrl+C`.
117 |
118 | > **Pozor**, upravili jsme Python skript tak, aby místo klávesy `Enter` posílal klávesu `a`. Scratch si s klávesou `Enter` neporadí a neumí ji zpracovat.
119 |
120 | ## Program Scratch
121 | Ve chvíli, kdy nám Arduino "generuje" klávesy na počítači, pro zbytek zábavy postačí Scratch, ve kterém si děti už nějaký program samy vymyslí. Čím hlasitější, tím lepší.
122 |
123 | [touchduino.sb2](touchduino.sb2)
124 |
125 | 
126 |
127 | ```blocks
128 | po stisku klávesy [a]
129 | hraj zvuk [chomp] až do konce
130 |
131 | po stisku klávesy [mezerník]
132 | hraj zvuk [pop] až do konce
133 |
134 | po stisku klávesy [šipka vlevo]
135 | hraj zvuk [snap] až do konce
136 |
137 | po stisku klávesy [šipka dolů]
138 | hraj zvuk [meow] až do konce
139 |
140 | po stisku klávesy [šipka vpravo]
141 | hraj zvuk [hand clap] až do konce
142 |
143 | po stisku klávesy [šipka nahoru]
144 | hraj zvuk [boing] až do konce
145 | ```
146 |
147 | ## Možná vylepšení
148 | * Samozřejmě hlavním vylepšením jsou ["krokodýlci"](https://www.aliexpress.com/wholesale?ltype=wholesale&d=y&origin=y&blanktest=0&SearchText=crocodile+wires&tc=af&initiative_id=SB_20171203133207&isViewCP=y&catId=0), které ale zatím doma nemáme, časem.
149 | * Je možné vyzkoušet různé hry, kdy je potřeba na něco či někoho sáhnout.
150 | * Hra na modelínové piano.
151 | * Pokud má váš kontroler více analogových pinů, lze udělat více vstupů.
152 | * Lze si zkusit přidat další vstupy pomocí multiplexeru, např. pěkného 16 kanálového [CD74HC4067](https://www.aliexpress.com/wholesale?ltype=wholesale&d=y&origin=y&blanktest=0&SearchText=CD74HC4067&tc=af&initiative_id=SB_20171203131846&isViewCP=y&catId=0).
153 |
154 | ## Poznatky
155 | * Pokud sedím na zemi, jsem více uzemněn a může se tak stát, že k tomu, aby Arduino detekovalo uzavřenou smyčku, nebude potřebovat své `GND`, postačí mu má sedací plocha.
156 | * Notebook napájený ze sítě je více uzemněn než notebook provozovaný na baterii.
157 | * Experimentovali jsme i s různým ovocem, banány, jablka...
158 |
--------------------------------------------------------------------------------
/touchduino/touchduino.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/touchduino/touchduino.mp4
--------------------------------------------------------------------------------
/touchduino/touchduino.sb2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/touchduino/touchduino.sb2
--------------------------------------------------------------------------------
/touchduino/touchduino_bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/touchduino/touchduino_bb.png
--------------------------------------------------------------------------------
/touchduino/touchduino_device_manager.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/touchduino/touchduino_device_manager.png
--------------------------------------------------------------------------------
/touchduino/touchduino_scratch.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/touchduino/touchduino_scratch.png
--------------------------------------------------------------------------------
/uvod.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/javorekm/arduino-deti/26314ff78992337807bf235fe0f3c2b94b86aa87/uvod.jpg
--------------------------------------------------------------------------------