Bezdrátová komunikace pro Fretku

S jednoduchým robůtkem ze stavebnice m-BITBEAM jsme vás seznámili již v článku 3D tisk + Arduino = (nejen) robotika zajímavě a levně. Jeho představení vyvolalo řadu vašich reakcí, a to jak kladných, tak záporných. Jedna z výtek byla směřována k omezené možnosti rozšíření o další moduly a čidla nějakým jednoduchým a „korektním“ způsobem. Tím, že jsme se snažili sestavit funkčního robota skutečně v minimalistické podobě, museli jsme také přistoupit na řadu omezení. Jednou takovou věcí bylo např. využití určitých netypických pinů, které se žákům „dobře zapojovaly“, ale tradičně se pro dané zařízení nepoužívají (např. pro zapojení kontinuálních servomotorů). Jako zásadní omezení se řadě z vás jevila také nevyřešená problematika napájení dalších rozšiřujících modulů, které bychom chtěli do budoucna k robotovi připojit, což v původním článku přiznáváme a vysvětlujeme (napájení modulů z digitálních pinů Arduina skutečně není optimální řešení).

Někteří stavitelé Fretky si problém s rozšiřováním vyřešili po svém pomocí páječky a několika drátků. Jiní se dali slyšet, že by chtěli nějaké řešení přímo od nás. Jedno vám tedy přinášíme a rovnou si k Fretce připojíme bluetooth modul tak, abychom mohli robota ovládat z chytrého telefonu či tabletu a zahrát si s ním třeba hokej.

1. Co budeme potřebovat?

K rozšíření o BT modul budeme mimo vlastní modul potřebovat ještě pár dalších věcí:

2. Finální zapojení

Hned na úvod tu máme finální zapojení naší rozšířené Fretky (obr.1). V rámci rozšíření napájecí části nám zůstanou pro případný další modul/čidlo k dispozici ještě dvě dvojice rezervních pinů (5V, GND).

3. Řešení napájení

Možností řešení napájení více modulů a čidel je samozřejmě celá řada. Protože neplánujeme navýšit odběr více než o několik desítek mA (použité RobotDyn Arduino NANO nám poskytne max. 800 mA, takže s dvěma malými servomotory a jedním IR čidlem pro sledování čáry máme ještě dostatečnou rezervu), zapojili jsme si napájení přímo z pinů Arduina (5V a GND). K tomu budeme potřebovat dva kusy hřebínkové/kolíkové DuPont lišty 1×6 pinů a dva kusy napájecího kablíku (je vhodné použít červený pro 5V a černý pro GND, obr. 2). Kablík odizolujeme tak, abychom ho mohli následně připájet po celé délce lišty (obr. 3). Správnou délku si zkontrolujeme přiložením (obr. 4).

Aby bylo připájení snazší, naneseme si nejdříve větší množství pájky na odizolovanou část (obr. 5). Poté si zarovnáme obě části (např. pomocí „třetí ruky“, obr. 6). Odizolovanou část připájíme tak, aby byl každý kolík dobře vodivě spojen s kablíkem (obr. 7).

Na druhou stranu kablíku chceme nakrimpovat odpovídající konektor. Opět si malý kousek odizolujeme (ponecháme odizolované 4–5 mm). Můžeme použít krimpovací kleště (obr. 8), nebo nouzově i obyčejné malé ploché kleště. Protože jsme pro rozvod napájení záměrně použili silnější průřez vodiče, bude celý konektor nakrimpován na odizolované části (obr. 9), i když by měl být správně uchycen také na izolaci vodiče. Po nasazení krytek nakrimpovaných konektorů (obr. 10) nám ještě zbývá poslední krok. Tím je přilepení napájecích lišt na bok krabičky pro Arduino NANO (obr. 11). K rychlému přilepení můžeme použít vteřinové lepidlo. Pak už jen připojíme odpovídající konektory k pinům 5V a GND (obr. 12).

Možná si říkáte, proč jsme nepoužili namísto kolíků (M, samec) lištu s otvory (F, samice), když pro rozvod napájení by bylo bezpečnější právě použití otvorů. Svým způsobem je na vině původní set pro stavbu robota Fretky, který nyní rozšiřujeme. Tam jsou totiž pro připojení čidel kablíky F-F (samice-samice) a protože jsme je s žáky chtěli použít i po rozšíření Fretky, zvolili jsme pro rozvod napájení kolíkovou lištu. Pokud budete chtít, můžete použít lištu s otvory a namísto propojovacích kablíků F-F pak použít kablíky F-M.

V tuto chvíli si můžeme přepojit všechny napájecí vodiče IR čidla pro sledování čáry a motorů (5V, GND) do našich nových napájecích lišt (schéma obr. 1, obr. 13).

4. Bluetooth modul

Pro bezdrátovou komunikaci využijeme levný bluetooth modul prodávaný pod označením HC-06. Náš modul HC-06 (obr. 14) nemá zapojené piny EN a STATE, což nevadí, protože tyto piny stejně nevyužijeme.

BT modul si sice můžeme konfigurovat pomocí AT příkazů, ale pro naše použití s robotem Fretka to není třeba. Přednastavená rychlost komunikace (baud rate), 9600 bps, je pro nás dostačující, stejně jako ostatní přednastavené parametry. Jediný parametr, který má smysl měnit, je jméno (NAME). V případě, že chcete jméno změnit, můžete použít následující kód (kód si zkopírujete tlačítkem Copy v pravém horním rohu):

// Nastaveni BT modulu HC-06 a HC- 05

// Potrebujeme knihovnu SoftwareSerial!
#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 3); // RX, TX

String command = ""; // ulozeni "odpovedi" HC-06 bluetooth modulu

void setup() {
  // otevreni seriove komunikace
  Serial.begin(9600);
  Serial.println("Napis AT prikaz...");
  
  // SW serial s BT module - otevreni komunikace
    // modul HC-06 je podle dokumentace prednasatveny na 9600 (AT+BAUD4).
    mySerial.begin(9600); // seriovy monitor pro HC-06 - bez CR a LF (!)
    // modul HC-05 je podle dokumentace prednasatveny na 38400 (AT+BAUD4).
    //mySerial.begin(38400);  // seriovy monitor pro HC-05 - konec radku CR (! - oficialne potrebuje CR+LF)
  
  // Pro HC-06
  // AT+BAUD4 (nastaveni na 9600 – prednastavena hodnota)
  // AT+NAMEFRETKA01 (zmena jmena na FRETKA01)
  // AT+PIN1234 (kod/pin pro sparovani - 1234 - prednastavena hodnota)
    
  // Pro HC-05
  // AT+UART=9600,0,0\r\n (nastaveni na 9600)
  // AT+NAME=FRETKA01\r\n (zmena jmena na FRETKA01)
  // AT+PSWD="1234" (kod/pin pro sparovani - 1234)

  //AT prikaz muzeme poslat jiz zde v casti setup
  //delay(10); //chvili musime pockat!
  //mySerial.write("AT+NAMEFRETKA01"); //posleme prikaz pro HC-06
}

void loop() {
  // Kdyz je spojeni s BT modulem k dispozici, cteme jeho seriovy vystup...
  if (mySerial.available()) {
    while(mySerial.available()) { // Dokud mame co cist, tak cteme...
      command += (char)mySerial.read();
    }
    
    Serial.println(command); // vypiseme "odpoved" modulu - prikaz/hlaseni
    command = ""; // po vypsani nastavime prazdny retezec
  }
  
  // Kdyz je k dispozici seriove spojeni a nejaky vstup uzivatele (zadani AT prikazu pres seriovy monitor).
  if (Serial.available()){
    delay(10); //chvili musime pockat!
    mySerial.write(Serial.read()); //posleme BT modulu nas AT prikaz
  }
}

Uvedený kód si nahrajeme do Arduina s připojeným BT modulem (obr. 1) a buďto zadáme AT příkaz ze „Sériového monitoru“ v Arduino IDE (Dole v nastavení Serial monitoru je pro HC-06 třeba zvolit „No line ending“ [Jednoduchý test, zda vše funguje, je poslat ze sériového monitoru příkaz AT, na který by měla přijít odpověď OK.]. Pomocí AT příkazu AT+NAMEFRETKA-01 přejmenujeme modul tak, že se bude hlásit jako „FRETKA-01“ (obr. 17)), nebo si kód upravíme tak, aby se AT příkaz odeslal již při spuštění programu (odstraníme „zakomentování“ řádku 32 a 33, zaměníme textový řetězec FRETKA01 za námi požadovaný). Podobně můžeme změnit například pin (přednastavený je „1234“) pro spárování s naším mobilním zařízením.

Abychom mohli k Fretce BT modul snadno přidělat, vytiskneme si krabičku. Modely ve formátu STL najdete v našem m-BITBEAM Ferretbot repozitáři na GitHubu (STL – tělo, víčko, obr. 15). Modul volně vložíme do těla krabičky a zacvakneme krycí víčko. Z jedné strany je dobře viditelný popis jednotlivých pinů (obr. 16).

Upozornění: Vzhledem k variabilitě čínské výroby je možné, že vámi zakoupený bluetooth HC-06 modul nemusí přesně sedět do našich 3D modelů a krabičku budete muset lehce upravit. I to je ale velice dobrá zkušenost a můžete jí ve výuce náležitě využít!

5. Montáž a připojení BT modulu

K montáži modulu potřebujeme pouze jeden šroubek M4×30 s matičkou (obr. 18). Jedno z vhodných míst pro montáž je pravý horní výstupek krabičky Arduina (obr. 19). Při přišroubování (obr. 20) na tomto místě je z vnější strany dobře vidět popis pinů BT modulu, což žákům usnadňuje zapojení a jeho kontrolu.

Připojení vodičů k BT modulu a Arduinu provedeme podle schématu (obr. 1). Protože je potřeba BT modul někdy odpojit, osvědčilo se slepení 4 konektorů pomocí izolepy (obr. 21). Pak je odpojení a připojení možné bez přemýšlení, kam která „barva“ vede, stačí si zapamatovat orientaci konektoru (např. žlutá je nahoře, obr. 22). Pokud máte 4pinový konektor, můžete ho použít místo 4 1pinových, které jsou součástí kablíků (výměna je, především pro mladší žáky, dosti problematický úkon :-)). Tím je náš upgrade Fretky po hardwarové stránce hotov (obr. 23, obr. 24, obr. 25, obr. 26).

6. Programujeme rozšířenou Fretku

Hlavním cílem rozšíření Fretky o bluetooth modul je možnost bezdrátové interakce s robotem. Jako první se nabízí dálkové ovládání Fretky s využitím mobilního zařízení. Co by měl náš nový „program“ pro Fretku poskytovat? Nejdříve si nadefinujeme určité stavové „módy“, které budou později určovat, jak se bude robot chovat. Určitě chceme zachovat možnost autonomního sledování čáry. V této části je totiž stále co vylepšovat. Dále bychom chtěli ovládat robota z mobilní aplikace a hrát s ním třeba týmový „robotický hokej“. Žáci posléze přišli ještě s dalšími stavovými módy, a to sice rychlá rotace na místě vlevo a vpravo. Asi tušíte, že to bylo právě z důvodu onoho hokeje. Tím pádem tu máme módy:

1. Ovládání pohybu pomocí e-joysticku v mobilní aplikaci (stavový mód: 0)
2. Autonomní sledování čáry (stavový mód: 1)
3. Rychlá rotace vlevo (stavový mód: 2)
4. Rychlá rotace vpravo (stavový mód: 3)

K přepínání jednotlivých módů budeme používat mobilní aplikaci. Otázkou je, kde vzít vhodnou mobilní aplikaci? Mohli bychom si ji naprogramovat, ale to by vydalo na další článek a současně by to zbytečně „brzdilo“ ty, kteří se z nějakého důvodu do programování aplikací pro mobilní zařízení zrovna nehrnou. Použijeme tedy osvědčenou aplikaci Dabble (od STEMpedia), která je k dispozici v GooglePlay i App Store. Dabble (Dabble: One App for Sensing & Control = Jedna aplikace pro snímání a ovládání) je zdarma a umožňuje celu řadu „hrátek“ a určitě se k ní ještě v nějakém dalším článku vrátíme. Tentokrát použijeme pouze jednu část, a to sice herní ovladač GamePad. Důležité pro nás je, že k Arduinu máme k dispozici přímo od tvůrců Dabble potřebné knihovny a jejich dokumentaci i s příklady (dokumentace části GamePad, příklady najdeme jak pro Arduino, tak pro ESP32).

Instalaci knihoven provedeme v Arduino IDE standardně pomocí Library Manageru (obr. 27, obr. 28). Pokud byste chtěli experimentovat, najdete po nainstalování knihovny také řadu příkladů (obr. 29).

Do robota si nyní můžeme nahrát následující kód (kód si zkopírujeme tlačítkem Copy v pravém horním rohu):

// ********* Ferretbot - Fretka *********
//    robot ze stavebnice m-BITBEAM 
//   https://www.e-mole.cz/diy/m-bitbeam 
// **************************************
//  Program pro sledování čáry pomocí
//  IR čidla sledování čáry (použitý 
//  digitální výstup čidla D0 - D7)
//  a použití aplikace Dabble 
//  https://play.google.com/store/apps/details?id=io.dabbleapp
//  https://apps.apple.com/us/app/dabble-bluetooth-controller/id1472734455?ls=1
//  pro kontrolu robota pomocí GamePadu (Joystick Mode)
// **************************************

// zahrneme knihovnu Servo
#include <Servo.h>

// zahrneme Dabble pro ovladani pres BT
/*  Arduino Uno/Nano knihovny používají SoftwareSerial,
 *  pin 2 a pin 3 jsou použity jako 
 *  RX and TX piny:
 *  UNO  - BLUETOOTH MODULE
 *  2    - TX
 *  3    - RX
 *  Pro Uno/Nano ponechte bluetooth Baudrate pod 38400!
*/
    
#define CUSTOM_SETTINGS
#define INCLUDE_GAMEPAD_MODULE
#include <Dabble.h>

//#define DEBUG_MODE // odkomentovat pro ladění (výpis do serial monitoru)

const int line_sensor_digital_pin = 7; // pin pro D0 výstup IR senzoru sledování čáry

int line_sensor_state = 0; // stav senzoru pro sledování čáry
int line_sensor_value = 0; // počáteční hodnota "sledování čáry"

const int black = 0;  // definice konstanty pro „stav“ čidla nad černou čárou

int GLOBAL_MODE = 0;  // definice pro „stavový mód“ robota (0 = joystick, 1 = sledovac cary, 2 = rotace vlevo, 3 = rotace vpravo)

const int left_wheel_pin = 5;  // piny řízení servomotorů
const int right_wheel_pin = 11;

Servo left_wheel; // připojení servomotorů
Servo right_wheel; 

// proměnné pro pohyb robota
const int servo_stop = 1500;         //zastaveni serva
const int servo_speed = 150;         //relativni rychlost
const int servo_brake_factor = 150;  //čím více se bude brzdit, tím menší oblouk bude robot dělat
const int servo_bt_joystick_factor = 5;  //čím větší, tím pomaleji se bude robot pohybovat (optimální mezi 5-10)

const int r_fast_speed = servo_stop + servo_speed; // vyšší rychlost pravého kola
const int r_slow_speed = servo_stop + (servo_speed/servo_brake_factor);  // nižší rychlost pravého kola

const int l_fast_speed = servo_stop - servo_speed; // vyšší rychlost levého kola
const int l_slow_speed = servo_stop - (servo_speed/servo_brake_factor);  // nižší rychlost levého kola

int l_servo_speed = servo_stop; // aktuální rychlost levého kola = zastavím
int r_servo_speed = servo_stop; // aktuální rychlost pravého kola = zastavím

void setup() {
  // nastavení, spustí se pouze jednou na začátku programu:
  
  pinMode(line_sensor_digital_pin, INPUT);
  
  left_wheel.attach(left_wheel_pin);  // připojíme levé kolo
  right_wheel.attach(right_wheel_pin);  // připojíme pravé kolo
   
  left_wheel.writeMicroseconds(servo_stop);  // zastavíme kola...
  right_wheel.writeMicroseconds(servo_stop);

  delay(1000);  // ...počkáme 1s  

#ifdef DEBUG_MODE // pouze při aktivním ladění

  Serial.begin(9600);       // pozor (!) na nastavení stejného baudrate v okne sériového monitoru

#endif
  
  Dabble.begin(9600);  // pozor (!) na to, jak je nastaven váš BT modul

  delay(1000);  // ...počkáme 1s
}

void loop() {
  // hlavní kód, probíhá stále dokola:
  
  Dabble.processInput();  // tato funkce se používá k aktualizaci dat získaných ze smartphonu. Proto je volání této funkce povinné, aby bylo možné správně získat data z vašeho mobilního telefonu.

#ifdef DEBUG_MODE
  debug_dabble();
#endif

  // následující kód je funkční pouze s GamePad v Joystick módu(!)
  // nastavení stavového módu robota:
  // ruční ovládání joystickem
  if (GamePad.isCrossPressed()) // stisknutí "křížku"
  {
    GLOBAL_MODE = 0;
  }
  // sledování čáry / linefollower mode
  if (GamePad.isTrianglePressed()) // stisknutí "trojúhelníku"
  {
    GLOBAL_MODE = 1;
  }
  // otáčka vlevo / rotate left
  if (GamePad.isSquarePressed()) // stisknutí "čtverečku"
  {
     GLOBAL_MODE = 2;
  }
  // otáčka vpravo / rotate right
  if (GamePad.isCirclePressed()) // stisknutí "kolečka"
  {
    GLOBAL_MODE = 3;
  }
  
  if (GLOBAL_MODE == 0) { //joystick
    // načtení hodnot joysticku
    int angle = GamePad.getAngle(); // 0 - 360
    int strength = GamePad.getRadius(); // 0 - 7   
      // ovládání pohybu robota
      
      if (angle < 180) { // jedu dopredu
        if (angle < 90) { // zatacim doprava
          l_servo_speed = strength * 255 / servo_bt_joystick_factor;
          r_servo_speed = strength * (angle * 255 / 90) / servo_bt_joystick_factor;
        } else if (angle > 90) { // zatacim doleva
          l_servo_speed = strength * ((180 - angle) * 255 / 90) / servo_bt_joystick_factor;
          r_servo_speed = strength * 255 / servo_bt_joystick_factor;
        } else { // jedu rovne
          l_servo_speed = strength * 255 / servo_bt_joystick_factor;
          r_servo_speed = strength * 255 / servo_bt_joystick_factor;
        }
    
        //nastavení rychlosti kol
        right_wheel.writeMicroseconds(servo_stop + r_servo_speed); 
        left_wheel.writeMicroseconds(servo_stop - l_servo_speed);
      
      } else if (angle > 180) { // jedu dozadu
        if (angle > 270){ // zatacim doprava
          l_servo_speed = strength * 255 / servo_bt_joystick_factor;
          r_servo_speed = strength * ((360 - angle) * 255 / 90) / servo_bt_joystick_factor;
        } else if (angle < 270) { // zatacim doleva
          l_servo_speed = strength * ((90 - (270 - angle)) * 255 / 90) / servo_bt_joystick_factor;
          r_servo_speed = strength * 255 / servo_bt_joystick_factor;
        } else { // jedu rovne
          l_servo_speed = strength * 255 / servo_bt_joystick_factor;
          r_servo_speed = strength * 255 / servo_bt_joystick_factor;
        }
        
        //nastavení rychlosti kol
        right_wheel.writeMicroseconds(servo_stop - r_servo_speed); 
        left_wheel.writeMicroseconds(servo_stop + l_servo_speed);
              
      }  
  } else if (GLOBAL_MODE == 1) { // sledování čáry / linefollower

      line_sensor_state = digitalRead(line_sensor_digital_pin); //  zjistíme hodnotu z čidla
      
      if (line_sensor_state == black)  //  pokud jsem nad černou čárou
      {
        left_wheel.writeMicroseconds(l_slow_speed); //  zatáčím doleva
        right_wheel.writeMicroseconds(r_fast_speed);
      }
      else                             //  pokud jsme nad bílou plochou papíru
      {
        left_wheel.writeMicroseconds(l_fast_speed); //  zatáčím doprava
        right_wheel.writeMicroseconds(r_slow_speed);     
      }    
      delay(20);
      
  } else if (GLOBAL_MODE == 2) { // rychlá otočka vlevo / rotate left
     
     right_wheel.writeMicroseconds(servo_stop + (2 * servo_speed)); 
     left_wheel.writeMicroseconds(servo_stop + (2 * servo_speed));
     
  } else if (GLOBAL_MODE == 3) { // rychlá otočka vpravo / rotate right
     
     right_wheel.writeMicroseconds(servo_stop - (2 * servo_speed)); 
     left_wheel.writeMicroseconds(servo_stop - (2 * servo_speed)); 
  }
}

#ifdef DEBUG_MODE // pouze při zapnutém ladění
void debug_dabble() {
   if (GamePad.isUpPressed())
  {
    Serial.print("UP");
  }

  if (GamePad.isDownPressed())
  {
    Serial.print("DOWN");
  }

  if (GamePad.isLeftPressed())
  {
    Serial.print("Left");
  }

  if (GamePad.isRightPressed())
  {
    Serial.print("Right");
  }

  if (GamePad.isSquarePressed())
  {
    Serial.print("Square");
  }

  if (GamePad.isCirclePressed())
  {
    Serial.print("Circle");
  }

  if (GamePad.isCrossPressed())
  {
    Serial.print("Cross");
  }

  if (GamePad.isTrianglePressed())
  {
    Serial.print("Triangle");
  }

  if (GamePad.isStartPressed())
  {
    Serial.print("Start");
  }

  if (GamePad.isSelectPressed())
  {
    Serial.print("Select");
  }
  Serial.print('\t');
  
  int a = GamePad.getAngle();
  Serial.print("Angle: ");
  Serial.print(a);
  Serial.print('\t');
  int b = GamePad.getRadius();
  Serial.print("Radius: ");
  Serial.print(b);
  Serial.print('\t');
  float c = GamePad.getx_axis();
  Serial.print("x_axis: ");
  Serial.print(c);
  Serial.print('\t');
  float d = GamePad.gety_axis();
  Serial.print("y_axis: ");
  Serial.println(d);
  Serial.println();
  Serial.print("r_speed");
  Serial.print(l_servo_speed);
  Serial.print('\t');
  Serial.print("l_speed");  
  Serial.print(r_servo_speed);  
  Serial.print('\t');  
  Serial.println();

  delay(150);      
}
#endif

Aplikaci Dabble a její nastavení si můžete prohlédnout na obr. 30, obr. 31 a obr. 32 . Předchozí kód kombinuje výše zmiňovanou funkčnost, a to tak, že pravá část ovladače se čtyřmi tlačítky aktivuje jednotlivé stavové módy robota:

• Křížek = ovládání pohybu pomocí joysticku (vlevo)
• Trojúhelník = autonomní sledování čáry
• Čtvereček = rychlá rotace vlevo
• Kolečko = rychlá rotace vpravo

Tlačítka Select a Start nejsou použita a jsou vám k dispozici k vlastním rozšířením a úpravám.

Indikace připojení k Fretce je na BT modulu HC-06 typicky viditelná pomocí červené stavové diody (ta běžně bliká, po připojení svítí nepřetržitě). Po zdárném připojení Fretky k mobilnímu telefonu/tabletu jako buetooth zařízení již můžeme s Fretkou jezdit a testovat různé „stavové módy“. Ovládání z mobilního telefonu zvládáme a jízda nám nějaký čas s žáky určitě vydrží. A co dál? Můžeme začít pracovat na dalších vylepšeních? Jistě! Nabízí se hned několik směrů. Co třeba použít analogový výstup z IR čidla po sledování čáry a jízdu „po čáře“ výrazně urychlit?

7. Možné problémy

V průběhu používání Fretek s žáky se nám objevilo několik problémů, které mají pravděpodobně společné vysvětlení, a to nestálé napájení. K napájení používáme levnou válcovou powerbanku s jedním Li-Ion 18650 článkem (ceně odpovídá i elektronika step-up měniče pro výstupních 5 V). Bohužel, čas od času se stane (elektronika zapínající výstup v powerbance, špatně zasunutý konektor, značně vybitá „baterie“, …, důležitý je i kvalitní USB kabel!), že patrně zakolísá napětí a začnou se dít nepředvídatelné věci. Je to s podivem, protože klidový odběr Fretky je cca 80 mA, při roztočení obou kol maximální rychlostí jen 180 mA (nárazová špička je pak cca 250 mA). Naše powerbanka má přitom na výstupu teoreticky 1 A (ve skutečnosti 800 mA), takže problém s napájením by tu teoreticky neměl být, ale patrně je. Typickým příkladem je, že po zapnutí (zasunutí USB kabelu) se jedno kolo roztočí, a druhé stojí. V takovém případě stačí kabel vypojit a znovu zapojit. U některých BT HC-06 modulů se nám stává, že je sice možné se k modulu připojit, ale komunikace mezi modulem a Arduinem neprobíhá a robot na ovládání z mobilního telefonu nereaguje. V tomto případě se osvědčilo odpojit BT modul (vytáhnout z něj vodiče) a po pár sekundách je opět připojit. Následně již komunikace funguje tak, jak má. Uvedené problémy jsou hodně závislé na konkrétní Fretce (patrně spíše na konkrétní powerbance), takže u některých se prakticky nevyskytují, u jiných je výskyt problémů sporadický a u některých častější. Dobrá zpráva je, že když se podaří vše „spustit“ a připojit, není pak problém s Fretkou jezdit i několik hodin v kuse. Pro úplnost, při napájení ze stabilizovaného zdroje jsme popsané chování nikdy nepozorovali. Pokud by někdo z vás čtenářů věděl, jak tyto problémy jednoduše eliminovat, dejte nám vědět, budeme rádi za každý tip.

8. Využití ve výuce

Po rozšíření Fretky o bluetooth komunikaci se nám v rámci výuky otevírají nové možnosti. Něco z nich jsme nastínili výše. Významným rozšířením pro žáky je již samotný fakt, že pracují s novým modulem pro bezdrátovou komunikaci. I bezdrátová komunikace si totiž nese svá specifika, takže můžeme testovat dosah signálu a co ho ovlivní (vzdálenost, zdi, nastavený baudrate, stínění alobalem, …). Zpestření výuky může být pro žáky i zmiňovaný hokejový zápas, nejlépe družstev. U hokeje můžeme zapojit i konstrukční dovednosti a soutěžit o vylepšení Fretky pro snazší vedení a manipulaci s pukem (víčkem od minerálky). Podobně se dá řešit robotický fotbal (zvládat kutálející se míček je pro žáky obtížnější úkol). Další věcí, která se přímo nabízí, je „robotická překážková dráha“. Dráha může zahrnovat např. úkol s dopravou předmětu z místa na místo, automatické sledování čáry a na závěr „jízdu do vrchu“, kdy je potřeba vymyslet, jak vyjet co nejvýše na strmou nakloněnou rovinu (nemusí jít pouze o styl a směr jízdy, ale také o různé dovyvážení robota). Protože zde máme 5 hlavní oblastí, kde se mohou žáci uplatnit, nabízí se rozdělení různých rolí, a to i napříč ročníky. Žáci vyšších ročníků mohou být v roli konstruktérů, programátorů a herních stratégů. Žáci nižších ročníků pak hrají roli „pilotů“ a kreativců (týmovému robotovi vtisknou určité nezaměnitelné „stájové“ rysy díky různým doplňkům, mohou také navrhnout a umístit na robota týmové logo apod.). Možností je celá řada a jistě vás už napadají další…

A na závěr pár fotografií z několika akcí, kde jsme Fretky s našimi žáky prezentovali (obr. 33–38).

Autor: Tomáš Feltl, Gymnázium Polička & Časopis e-Mole.cz & Centrum technického vzdělávání při Městské knihovně Polička, 25. 2. 2021