SAMSUNG_092021 Advertisement SAMSUNG_092021 Advertisement SAMSUNG_092021 Advertisement

IoT a robotika: Ovládanie zariadenia s mikrokontrolérom ESP32 mobilnou apkou I.

0

V sérii článkov názorne ukážeme ako ovládať zariadenie s mikrokontrolérom ESP32 pomocou mobilnej aplikácie, ktorá komunikuje s ESP 32 cez bluetooth.  Vývojové dosky s touto mikrokontrolérovou platformou sú lacné (typicky 8 – 15 eur) a už priamo na čipe je vyriešená komunikácia cez bluetooth aj WiFi, takže sa jedná o plnohodnotnú IoT platformu.

Video (je spoločné pre viac dielov) ukazuje jednoduchý, ale kompletný príklad ovládania ESP32 mobilnou apkou

ESP 32 má dvojjadrový procesor s 32 bitovými jadrami Xtensa LX6 taktovanými na 160 MHz. Jedno jadro rieši WiFi komunikáciu a druhé máte k dispozícii pre svoj program. Jadrá sa dajú pretaktovať až na 240 MHz. K dispozícii je až 36 GPIO pinov. Kapacita pamäti Flash je 4 MB a RAM je tvorená tromi blokmi s celkovou kapacitou 520 kB. Používateľ má k dispozícii približne 400 kB RAM. Zavádzací program je v ROM s kapacitou 448 kB. Príklad môžete realizovať na akejkoľvek vývojovej doske s ESP32,

napríklad aj na Mbits ESP32, ktorá má zbernicu kompatibilnú s Microbitom.

Postup ovládania zariadenia s ESP 32 pomocou mobilnej aplikácie ukážeme krok po kroku, takže tento miniseriál je vhodný aj pre začiatočníkov, alebo čerstvých migrantov na ESP32. V prvom príklade budeme ovládať dve rôznofarebné LED diódy. Na ovládanie použijeme hotovú aplikáciu Serial Bluetooth Terminal. Neskôr ukážeme vytvorenie vlastnej jednoduchej Android aplikácie na posielanie príkazov pre ESP32

Konfigurácia vývojového prostredia

Najskôr vyriešime sériovú komunikáciu s vývojovou doskou ESP32 cez USB. Ak Windows 10 dosku nerozpoznal, nainštalujte vhodný ovládač, napríklad zo stránky.

Následne je potrebné inštalovať do vývojového prostredia Arduino IDE podporu pre ESP32. V menu aktivujte položku File > Preferences (v slovenskej verzii Súbor > Vlastnosti). Adresu rozšírenia pre prídavnú dosku v našom prípade pre ESP32:

https://dl.espressif.com/dl/package_esp32_index.json

skopírujte do poľa  Additional Board Manager URLs (v slovenskej verzii Manažér prídavných dosiek URL).

Teraz aktivujte menu Tools > Board menu (alebo v slovenskej verzii Nástroje > Manažér Dosiek). Do poľa pre vyhľadávanie zadajte ESP32 a nainštalujte najnovšiu verziu doplnkov pre dosky ESP32. V menu  Nástroje -> Doska a vyberte dosku, ktorú budete používať, v našom prípade ESP32 Dev Module. Následne pomocou menu Nástroje -> Port nastavte port, ku ktorému je vaša doska pripojená.

Pri zavádzaní programu z Arduino IDE je na niektorých vývojových doskách s ESP32 potrebné po začiatku zavádzania na chvíľu pridržať tlačidlo Enable/Reset.

Krok1: Programové ovládanie LED

Začneme najjednoduchším príkladom „blinky“, ktorý bude v sekundových intervaloch blikať LED diódami pripojenými na porty GPIO32 (červená) a GPIO33 (modrá). Zatiaľ neriešime, že výkonný procesor v pauze medzi prepínaním stavu LED nič nerobí. LED sú zapojené tak, že anóda je cer obmedzovací rezistor pripojená na + 3,3 V a katóda na GPIO port. Svietiť teda bude vtedy ak na porte bude úroveň LOW.

Príklad ako zapojiť LED a tlačidlo. Porty sú len ilustračné, použite také, ktoré sú na vývojovej doske vyvedené na piny.

Rozmiestnenia pinov pre dosku ktorú sme použili v príklade

const int ledRed = 32;
const int ledBlue = 33;
 
void setup()
{
    pinMode(ledRed, OUTPUT);
    pinMode(ledBlue, OUTPUT);
}
 
void loop()
{
    digitalWrite(ledRed,HIGH);
    digitalWrite(ledBlue,LOW);
    delay(1000);
    digitalWrite(ledRed,LOW);
    digitalWrite(ledBlue,HIGH);
    delay(1000);
}

V ďalšom príklade pridáme ďalšiu LED diódu, v našom prípade zelenú, ktorú budeme rozsvecovať a stmievať pomocou PWM, čiže pulzno-šírkovej modulácie. Cykly pre rozsvecovanie a stmievanie vložíme namiesto príkazov delay(1000),  takže červená a modrá LED budú periodicky blikať a medzi periódou prepnutia sa bude zelená LED rozsvecovať a stmievať. Pomocou PWM môžeme ovládať nielen jas LED diód, ale aj otáčky jednosmerných motorčekov a podobne. To si ukážeme neskôr v ďalšej časti seriálu.  

const int ledRed = 32;
const int ledBlue = 33;
const int ledPWM = 23;
 
// parametre pre PWM
const int freq = 7000;
const int ledChannel = 0;
const int resolution = 8;
 
void setup()
{
    pinMode(ledRed, OUTPUT);
    pinMode(ledBlue, OUTPUT);
 
  // konfigurácia LED PWM
    ledcSetup(ledChannel, freq, resolution);
    ledcAttachPin(ledPWM, ledChannel);
}
 
void loop() {
    digitalWrite(ledRed,HIGH);
    digitalWrite(ledBlue,LOW);
 
    //cyklus pre PWM rozsvecovanie
    for(int dutyCycle = 100; dutyCycle <= 230; dutyCycle++){  
       ledcWrite(ledChannel, dutyCycle);
       delay(12);
    }
   
    digitalWrite(ledRed,LOW);
    digitalWrite(ledBlue,HIGH);
  
    //cyklus pre PWM stmievanie
    for(int dutyCycle = 230; dutyCycle >= 100; dutyCycle--){
       ledcWrite(ledChannel, dutyCycle);  
       delay(12);
    }
}

Krok2: Zisťovanie stavu tlačidiel

Ovládanie tlačidiel je s príkladom zdanlivo nesúvisiaca téma, predsa chceme zariadenie ovládať mobilnou aplikáciou. Aby sme boli presní AJ mobilnou aplikáciou. Väčšina zariadení má aj vlastné ovládacie prvky aby sa dali plnohodnotne ovládať aj bez aplikácie.

V nasledujúcom príklade budeme monitorovať stav tlačidiel, ktoré sú v našom testovacom zapojení pripojené na porty GPIO 18, GPIO3 a GPIO5. Stav tlačidiel budeme posielať cez sériový kanál a vypisovať vo vývojovom prostredí Arduino IDE v okne monitora sériového portu

//tlačidlá
const int button1 = 18;
const int button2 = 4;
const int button3 = 5;
 
 
void setup()
{
    //seriová komunikácia
    Serial.begin(115200);
    delay(1000);
 
   //Tlacidlá
    pinMode(button1, INPUT);
    pinMode(button2, INPUT);
    pinMode(button3, INPUT); 
}
 
void loop() {
    int buttonstate1 = digitalRead(button1);
    int buttonstate2 = digitalRead(button2);
    int buttonstate3 = digitalRead(button3);
   
    //ladiaci výstup na sériový kanál
    Serial.println(buttonstate1);
    Serial.println(buttonstate2);
    Serial.println(buttonstate3); 
    Serial.println("=====");
    delay(1000);
}

V ďalšom príklade spojíme obsluhu tlačidiel a LED. Tlačidlom button1 na porte GPIO18 budeme prepínať stav červenej LED na porte GPIO 32 a tlačidlom button2 na porte GPIO4 stav  modrej LED na porte GPIO33  

const int ledRed = 32;
const int ledBlue = 33;
const int button1 = 18;
const int button2 = 4;
 
int buttonNew1, buttonNew2;
int buttonOld1=1, buttonOld2=1;
int dt=100;
int LedStavRed=HIGH;
int LedStavBlue=HIGH;
 
void setup()
{
    pinMode(ledRed, OUTPUT); //LED
    pinMode(ledBlue, OUTPUT);
    pinMode(button1, INPUT); //Tlacidlá
    pinMode(button2, INPUT);
}
 
void loop() {
  buttonNew1=digitalRead(button1);
  if(buttonOld1==0 && buttonNew1==1){
    LedStavRed = !LedStavRed;
    digitalWrite(ledRed,LedStavRed);
  }
  buttonOld1=buttonNew1;
  delay(dt);
 
  buttonNew2=digitalRead(button2);
  if(buttonOld2==0 && buttonNew1==1){
    LedStavBlue = !LedStavBlue;
    digitalWrite(ledBlue,LedStavBlue);
  }
  buttonOld2=buttonNew2;
  delay(dt);
}

Krok3: Ovládanie LED príkazmi cez sériový port

Tento príklad nie vôbec samoúčelný príklad, pretože ak budete chcieť ovládať nejaké zariadenie cez bluetooth mobilnou aplikáciou, v konečnom dôsledku to bude sériová komunikácia. Červenú LED budeme ovládať príkazmi cez sériový port. Príkazom „Z“ sa LED rozsvieti a príkazom „V“ zhasne. Príkaz potvrdíme klávesom ENTER.

const int ledRed = 32;
 
void setup()
{
 
    //seriová komunikácia
    Serial.begin(115200);
    delay(1000);
 
   //LED
    pinMode(ledRed, OUTPUT);
   //LED vypnuté
    digitalWrite(ledRed, HIGH); 
}
 
void loop()
{
   if(Serial.available()) // ak dáta prišli
   {
    String command = Serial.readStringUntil('\n'); //reťazec zakončený CRLF (Enter)
 
    if(command == "Z")
    {
      digitalWrite(ledRed, LOW);
      Serial.println("Zapnuté"); //potvrdenie
    }
    else if(command == "V")
    {
      digitalWrite(ledRed, HIGH); 
      Serial.println("Vypnuté");
    }
   }
 }

Teraz príklad rozšírime tak, že budeme ovládať obidve LED, pričom príkazom „C“ sa zmení stav červenej LED a príkazom „M“ stav modrej LED

 const int ledRed = 32;
const int ledBlue = 33;
 
int LedStavRed=HIGH;
int LedStavBlue=HIGH;
 
void setup()
{
    //seriová komunikácia
    Serial.begin(115200);
    delay(1000);
 
   //LED
    pinMode(ledRed, OUTPUT);
    pinMode(ledBlue, OUTPUT);
}
 
void loop() {
   if(Serial.available()) // ak dáta prišli
   {
    String command = Serial.readStringUntil('\n'); //reťazec zakončený CRLF (Enter)
    if(command == "C")
    {
      LedStavRed = !LedStavRed;
       Serial.println("červená");
    }
    else if(command == "M")
    {
      LedStavBlue = !LedStavBlue;
      Serial.println("modrá");
    }
   }
 
   digitalWrite(ledRed, LedStavRed);
   digitalWrite(ledBlue, LedStavBlue);
}

Krok4: Bluetooth komunikácia

V ďalšom príklade ukážeme kód na inicializáciu bluetooth komunikácie. Po jeho spustení je mikrokontrolérová platforma ESP32 pripravená na párovanie. Príklad môžete skopírovať z tohto článku, alebo je aj medzi príkladmi v Arduino IDE po nainštalovaní podpory pre ESP 32. K príkladu sa dostanete cez menu File > Examples > BluetoothSerial > SerialtoSerialBT. Príklad využíva knižnicu BluetoothSerial. V hlavnej slučke program načíta znaky cez bluetooth a vypíše ich cez sériový terminál vývojového prostredia Arduino IDE.

#include "BluetoothSerial.h"
 
BluetoothSerial SerialBT;
 
void setup() {
  Serial.begin(115200);
  SerialBT.begin("ESP32test"); //Bluetooth device name
  Serial.println("Zariadenie môžete párovať cez bluetooth!");
}
 
void loop() {
  if (Serial.available()) {
    SerialBT.write(Serial.read());
  }
  if (SerialBT.available()) {
    Serial.write(SerialBT.read());
  }
  delay(20);
}

Teraz môžete zariadenie spárovať s Android smartfónom. V mobilnej aplikácii Serial Bluetooth Terminal vyberte zariadenie ESP32test. Následne môžete zadávať reťazce znakov. Tie sa následne vypíšu cez sériový terminál vývojového prostredia Arduino IDE.  Príklad výpisu aj s informáciou o inicializácii bluetooth komunikácie

rst:0x1 (POWERON_RESET),boot:0x17 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:1216
ho 0 tail 12 room 4
load:0x40078000,len:10944
load:0x40080400,len:6388
entry 0x400806b4
The device started, now you can pair it with bluetooth!
ahoj
ahoj
ahoj
ahoj

V ďalšom príklade budeme príkazom C zadaným cez mobilnú aplikáciu striedavo rozsvecovať a zhasínať červenú a príkazom M modrú LED

#include "BluetoothSerial.h"
 
BluetoothSerial SerialBT;
const int ledRed = 32;
const int ledBlue = 33;
 
int LedStavRed=HIGH;
int LedStavBlue=HIGH;
 
void setup() {
  Serial.begin(115200);
  SerialBT.begin("ESP32test"); //Bluetooth device name
  Serial.println("Zariadenie je pripravené na párovanie cez bluetooth!");
 
  pinMode(ledRed, OUTPUT); //LED
  pinMode(ledBlue, OUTPUT);
}
 
void loop() {
   if(SerialBT.available()) // ak dáta prišli
   {
      char cc = SerialBT.read();
      Serial.write(cc);
      if(cc == 'C') LedStavRed = !LedStavRed;
      else if(cc == 'M') LedStavBlue = !LedStavBlue;
      digitalWrite(ledRed, LedStavRed);
      digitalWrite(ledBlue, LedStavBlue);
      delay(20);
  }
}

Miniseriál bude pokračovať ovládaním PWM a načítaním analógových hodnôt

Zobrazit Galériu

Luboslav Lacko

Všetky autorove články
ESP32 Android IDE programovanie IoT robotika

Pridať komentár

Mohlo by vás zaujímať

Mohlo by vás zaujímať