Noha ebben az időszakban már rég nem foglalkoztam aktívan mikrovezérlőkkel, olyan sokszor szembe jött, és annyira tetszetős volt, hogy nem tudtam ellenállni a kíváncsiságomnak, és egy nagyobb rendelés keretében rendeltem egy ilyet is.

Az árak a pár évvel ezelőtti néhány dollárról jócskán felmentek, a Temu viszony nyomja lefelé, és így jött ki a nagyjából 10$-nak megfelelő összeg.

Beüzemelése

Arduino IDE

A következő lépéseket hajtsuk végre:

Töltsük le és telepítsük a CH340 meghajtót (https://learn.sparkfun.com/tutorials/how-to-install-ch340-drivers/all).
Töltsük le és telepítsük az Arduino IDE-t (https://www.arduino.cc/en/software/).
Az Arduino IDE-ben File → Preferences… → Additional board manager URLs: https://dl.espressif.com/dl/package_esp32_index.json (tehát az ESP32-nél megszokott).
Tools → Board → Boards Manager… → a keresőbe írjuk be: esp32, válasszuk ki és telepítsük ezt: "esp32 by Espressif Systems". (Ha nem megy, ld. lent.)
Tools → Board → esp32 → ESP32 Dev Module.
Sketch → Include Library → Manage Libraries… → keresőbe: U8g2 → "U8g2 by oliver" feltelepítése.
Kössük össze a számítógépet az eszközzel egy USB kábel segítségével. Ügyeljünk arra, hogy a kábel ne csak töltőkábel legyen, hanem adatkábel is.
File → Examples → U8g2 (legalul) → fullbuffer → HelloWorld (vagy másik példa választása).
Az első pár száz sor ki van kommentezve. Ezek közül az egyik elől ki kell venni a kommentet. Én ezt használtam: U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
Tools → Port → COM3. (Ezt ki kell választani még akkor is, ha csak ez az egy lehetőség adott. A többi beállítás nálam működött alapértelmezett értékeken.)
Felül az Upload ikonra kell kattintani (második ikon, jobbra nyíl).
A fordítás és a felötlés eltart egy darabig. Ha minden jól ment, megjelenik a "Hello World!" felirat.

A nettó kód sallang nélkül:

#include <Arduino.h>
#include <U8g2lib.h>
 
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE);
 
void setup(void) {
  u8g2.begin();
}
 
void loop(void) {
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_ncenB08_tr);
  u8g2.drawStr(0, 10, "Hello world!");
  u8g2.sendBuffer();
  delay(1000);  
}

Ha nem megy a telepítés, akkor a következőket tedd:

Zárd be az Arduino IDE-t.
A %LocalAppData%\Arduino15\staging\packages mappából töröld a fájlokat.
A %LocalAppData%\Arduino15\packages könyvtáron belül hozd létre ezt a könyvtárstruktúrát: esp32\hardware\esp32\
Töltsd le ezt: https://github.com/espressif/arduino-esp32/releases → Source code (zip)
Csomagold ki a fenti könyvtárban úgy, hogy a tools stb. közvetlenül a fent létrehozott alá kerüljenek (tehát a zip főkönyvtára ne jelenjen meg).
A tools\get.exe-t futtasd rendszergazdaként.
Nyisd meg az Arduino IDE-t.

PlatformIO

A következő lépéseket hajtsuk végre:

Töltsük le és telepítsük a CH340 meghajtót (https://learn.sparkfun.com/tutorials/how-to-install-ch340-drivers/all).
Töltsük le és telepítsük fel a Visual Studio Code-ot (https://code.visualstudio.com/).
Visual Studio Code-on belül Extensions → keressünk ár erre és telepítsük fel: PlatformIO IDE
Telepítés után megjelenik egy kis hangya ikon, arra kattintsunk rá.
PIO Home → Open
New Project → Name: tetszőleges; Board: Espressif ESP32 Dev Module; Framework: Arduino; Use default location → Finish (először hosszú)
Bal oldalon Explorer ikon → platformio.ini, módosítsuk a következőre

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

lib_deps =
    olikraus/U8g2 @ ^2.35.30

src/main.cpp: a fenti példa (kicsit módosítva a feliratot)
Fordítás: alul a pipa ikon (PlatformIO: Build)
Feltöltés: alul a jobbra nyíl ikon (PlatformIO: Upload)

Példák

Interaktív példa

Az alábbi példa a következőket csinálja:

Kiírja és folyamatosan aktualizálja az üzemidőt.
Számolja a felső (BOOT) nyomógomb lenyomásait, és kiírja azok számát.
Amikor le van nyomva a nyomógomb, akkor bekapcsolja a kék LED-et.

#include <Arduino.h>
#include <U8g2lib.h>
 
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE);
 
const int LED_PIN = 2;
const int BUTTON_PIN = 0;
 
volatile int gombSzamlalo = 0;
volatile bool frissiteniKell = true;
unsigned long utolsoGombIdo = 0;
 
void IRAM_ATTR gombMegszakitas() {
  unsigned long most = millis();
  if (most - utolsoGombIdo > 200) {
    gombSzamlalo++;
    frissiteniKell = true;
    utolsoGombIdo = most;
  }
}
 
void setup(void) {
  u8g2.begin();
 
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  attachInterrupt(BUTTON_PIN, gombMegszakitas, FALLING);
}
 
void loop(void) {
  digitalWrite(LED_PIN, !digitalRead(BUTTON_PIN));
 
  static unsigned long utolsoFrissites = 0;
  if (frissiteniKell || (millis() - utolsoFrissites > 1000)) {
    u8g2.clearBuffer();
 
    u8g2.setFont(u8g2_font_6x10_tf); 
    u8g2.drawStr(10, 12, "INTERAKTIV TESZT");
    u8g2.drawHLine(0, 15, 128);
 
    u8g2.setFont(u8g2_font_ncenB14_tr);
    u8g2.setCursor(5, 45);
    u8g2.print("Nr: ");
    u8g2.print(gombSzamlalo);
 
    u8g2.setFont(u8g2_font_5x7_tr);
    u8g2.setCursor(10, 60);
    u8g2.print("Uzemido: ");
    u8g2.print(millis()/1000);
    u8g2.print("s");
 
    u8g2.sendBuffer();
 
    frissiteniKell = false;
    utolsoFrissites = millis();
  }
}

Hosszú távú memória

A fenti alkalmazást úgy módosítjuk, hogy lesz egy globális és egy lokális számláló. A globális számláló értékét elmentjük egy tartós memóriába, és újraindítás után kiolvassuk.

#include <Arduino.h>
#include <U8g2lib.h>
#include <Preferences.h> // Ez a könyvtár felel a memóriáért
 
// Kijelző beállítása (a te bevált szoftveres I2C módod)
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE);
 
// Pinek
const int LED_PIN = 2;
const int BUTTON_PIN = 0;
 
// Számlálók
volatile int localCounter = 0;    // Ez nullázódik indításkor
unsigned int globalCounter = 0;   // Ez megmarad a memóriában
 
// Segédváltozók a megszakításhoz
volatile bool buttonPressed = false;
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 200;
 
// Memória objektum létrehozása
Preferences preferences;
 
// Megszakítás függvény (gyors gombnyomás érzékelés)
void IRAM_ATTR handleButton() {
  unsigned long currentTime = millis();
  if (currentTime - lastDebounceTime > debounceDelay) {
    buttonPressed = true;
    lastDebounceTime = currentTime;
  }
}
 
void setup() {
  u8g2.begin();
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  attachInterrupt(BUTTON_PIN, handleButton, FALLING);
 
  // Memória megnyitása "tarolo" néven (false = írható/olvasható)
  preferences.begin("tarolo", false);
 
  // Globális számláló betöltése (ha még nincs ilyen, az alapérték 0)
  globalCounter = preferences.getUInt("osszes", 0);
}
 
void loop() {
  // LED állapot követése (gombnyomás alatt világít)
  digitalWrite(LED_PIN, !digitalRead(BUTTON_PIN));
 
  // Ha történt gombnyomás
  if (buttonPressed) {
    localCounter++;
    globalCounter++;
 
    // Mentés az állandó memóriába
    preferences.putUInt("osszes", globalCounter);
 
    buttonPressed = false; // Flag törlése
  }
 
  // Kijelző frissítése (kb. másodpercenként egyszer, vagy gombnyomásra)
  static unsigned long lastUpdate = 0;
  if (millis() - lastUpdate > 500) {
    u8g2.clearBuffer();
 
    u8g2.setFont(u8g2_font_6x10_tf);
    u8g2.drawStr(5, 12, "SZAMLALO STATISZTIKA");
    u8g2.drawHLine(0, 15, 128);
 
    // Lokális számláló (Nr L)
    u8g2.setFont(u8g2_font_ncenB10_tr);
    u8g2.setCursor(5, 35);
    u8g2.print("Aktualis: ");
    u8g2.print(localCounter);
 
    // Globális számláló (Nr G)
    u8g2.setCursor(5, 55);
    u8g2.print("Osszesen: ");
    u8g2.print(globalCounter);
 
    u8g2.sendBuffer();
    lastUpdate = millis();
  }
}

A hosszú távú memória törlése: preferences.clear();.

Mágneses érzékelő

Az eszközbe be van építve egy mágneses érzékelő. Az alábbi program megjeleníti a mért értéket. Közelítsünk egy mágnest az eszköz tetejéhez.

#include <Arduino.h>
#include <U8g2lib.h>
 
// A te bevált kijelző beállításod
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE);
 
void setup() {
  u8g2.begin();
}
 
void loop() {
  // A beépített Hall-szenzor értéke (mágneses térerő)
  int magnet = hallRead(); 
 
  u8g2.clearBuffer();
 
  // Szöveges kijelzés
  u8g2.setFont(u8g2_font_ncenB14_tr);
  u8g2.setCursor(0, 30);
  u8g2.print("Hall: ");
  u8g2.print(magnet);
 
  // Vizuális skála (középen a nulla)
  u8g2.drawFrame(0, 50, 128, 10);
  u8g2.drawVLine(64, 50, 10); // Középvonal
  u8g2.drawBox(64, 52, magnet / 2, 6); // Csík hossza a térerő alapján
 
  u8g2.sendBuffer();
  delay(50);
}

Az alábbi példa egy élő magnetométer, ami kirajzolja a mágneses térerősséget az idő függvényében.

#include <Arduino.h>
#include <U8g2lib.h>
 
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE);
 
// Adatok tárolása a grafikonhoz (128 pixel széles a kijelző)
int adatok[128]; 
 
void setup() {
  u8g2.begin();
  // Tömb feltöltése alaphelyzetbe
  for(int i=0; i<128; i++) adatok[i] = 0;
}
 
void loop() {
  // 1. Új adat beolvasása (Hall szenzor)
  int nyersErtek = hallRead(); 
  // Skálázás: a Hall értékét lefordítjuk a kék sáv magasságára (0-45 pixel)
  int ujPont = map(nyersErtek, -100, 100, 0, 45);
  ujPont = constrain(ujPont, 0, 45); // Biztonsági korlát
 
  // 2. Adatok eltolása balra
  for(int i=0; i<127; i++) {
    adatok[i] = adatok[i+1];
  }
  adatok[127] = ujPont; // Az utolsó pont az új érték
 
  // 3. Megjelenítés
  u8g2.clearBuffer();
 
  // Sárga sáv: Szöveg
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.drawStr(0, 12, "ELO MAGNETOMETER");
  u8g2.drawHLine(0, 15, 128);
 
  // Kék sáv: Grafikon rajzolása pontról pontra
  for(int x=0; x<127; x++) {
    // Vonal húzása két egymást követő pont közé (fordított Y tengely!)
    u8g2.drawLine(x, 63 - adatok[x], x + 1, 63 - adatok[x+1]);
  }
 
  u8g2.sendBuffer();
  delay(20); // Gyors mintavételezés
}

Érintés érzékelő

Az eszköz tartalmaz egy érintés érzékelőt. Az alábbi programot úgy lehet kipróbálni, hogy megérintjük alul jobbról a harmadik lábat. Érintésre a kék LED világít.

#include <Arduino.h>
#include <U8g2lib.h>
 
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE);
 
const int TOUCH_PIN = 13; // Használj egy vezetéket a GPIO 13-as lábon!
const int LED_PIN = 2;    // A kék LED
const int KUSZOB = 80;    // Ezen érték alatt számít érintésnek
 
void setup() {
  u8g2.begin();
  pinMode(LED_PIN, OUTPUT);
}
 
void loop() {
  // Érintési érték beolvasása (0-100 közötti szám)
  int ertek = touchRead(TOUCH_PIN);
 
  u8g2.clearBuffer();
 
  // Fejléc
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.drawStr(0, 12, "ERINTES ERZEKELO");
  u8g2.drawHLine(0, 15, 128);
 
  // Érték kiírása
  u8g2.setFont(u8g2_font_ncenB14_tr);
  u8g2.setCursor(10, 40);
  u8g2.print("Ertek: ");
  u8g2.print(ertek);
 
  // Vizuális visszajelzés
  // Egy keret, amiben a csík mozog
  u8g2.drawFrame(10, 50, 108, 10);
  // A csík hossza az érték alapján (minél kisebb az érték, annál nagyobb az érintés)
  int barWidth = map(ertek, 0, 100, 108, 0); 
  if(barWidth > 108) barWidth = 0; // Biztonsági korlát
  u8g2.drawBox(10, 50, barWidth, 10);
 
  // LED kapcsolása, ha hozzáérsz
  if (ertek < KUSZOB && ertek > 0) {
    digitalWrite(LED_PIN, HIGH);
  } else {
    digitalWrite(LED_PIN, LOW);
  }
 
  u8g2.sendBuffer();
  delay(50);
}

Wifi

Az ESP32 alapból tartalmaz wifit. Most ezt próbáljuk ki. Csatlakozzunk a helyi wifi hálózatra (ehhez be kell állítani a wifi adatait). Lekérdezzük a pontos időt és megjelenítjük.

A futtatáshoz nem megfelelő az a tápellátás, amit a számítógép USB portja biztosít (itt kell magának a processzornak, a képernyőnek és a wifinek is áram), emiatt feltöltés után érdemes egy külső áramforrásba dugni.

#include <Arduino.h>
#include <U8g2lib.h>
#include <WiFi.h>
#include "time.h"
 
const char* ssid     = "WIFI_NEVE";
const char* password = "WIFI_JELSZAVA";
 
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE);
 
void setup() {
  Serial.begin(115200);
  u8g2.begin();
 
  Serial.println("\n--- WiFi Teszt Indul ---");
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.drawStr(0, 12, "WiFi: Probalom...");
  u8g2.drawStr(0, 25, ssid);
  u8g2.sendBuffer();
 
  WiFi.begin(ssid, password);
 
  int timeout = 0;
  while (WiFi.status() != WL_CONNECTED && timeout < 40) { // Max 20 mp várakozás
    delay(500);
    timeout++;
 
    Serial.print(".");
 
    // Pontok rajzolása a kijelzőre (frissítés nélkül, hogy ne villogjon)
    u8g2.drawStr(timeout * 3, 35, ".");
    u8g2.sendBuffer();
 
    if (timeout == 39) {
      Serial.println("\nIdotullepes! Ellenorizd az adatokat.");
      u8g2.drawStr(0, 50, "HIBA: Idotullepes!");
      u8g2.sendBuffer();
      while(1); // Megállunk itt
    }
  }
 
  Serial.println("\nSikeres csatlakozas!");
  Serial.print("IP cim: ");
  Serial.println(WiFi.localIP());
 
  u8g2.clearBuffer();
  u8g2.drawStr(0, 12, "OK! IP Cim:");
  u8g2.setCursor(0, 30);
  u8g2.print(WiFi.localIP());
  u8g2.sendBuffer();
  delay(2000);
 
  configTime(3600, 3600, "pool.ntp.org");
}
 
void loop() {
  struct tm timeinfo;
  u8g2.clearBuffer();
 
  // 1. WiFi térerő lekérése
  long rssi = WiFi.RSSI();
 
  if(getLocalTime(&timeinfo)){
    char timeStr[10];
    strftime(timeStr, sizeof(timeStr), "%H:%M:%S", &timeinfo);
 
    // Óra megjelenítése
    u8g2.setFont(u8g2_font_ncenB18_tr);
    u8g2.setCursor(15, 45);
    u8g2.print(timeStr);
 
    // Felső sáv: Cím + Térerő
    u8g2.setFont(u8g2_font_6x10_tf);
    u8g2.drawStr(0, 12, "WiFi:");
    u8g2.setCursor(35, 12);
    u8g2.print(rssi);
    u8g2.print(" dBm");
 
    // Egy kis grafikus térerő-jelző
    int bars = map(rssi, -100, -30, 0, 5); // 0-5 sáv közötti átalakítás
    for(int i=0; i<bars; i++) {
      u8g2.drawBox(100 + (i*4), 12 - (i*2), 3, i*2 + 2);
    }
  } else {
    u8g2.setFont(u8g2_font_6x10_tf);
    u8g2.drawStr(0, 30, "Ido szinkronizalasa...");
  }
 
  u8g2.sendBuffer();
  delay(200);
}

A wifi hálózatok kilistázása

Az alábbi példakód kilistázza a wifi hálózatokat. Érdemes megfigyelni azt, hogy a kék LED időnként elhalványodik.

#include <Arduino.h>
#include <U8g2lib.h>
#include <WiFi.h>
#include "soc/soc.h"
#include "soc/rtc_cntl_reg.h"
 
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE);
 
const int LED_PIN = 2;
const int PWM_CHANNEL = 0;
 
void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // Védelem a feszültségesés ellen
 
  Serial.begin(115200);
  delay(1000);
  Serial.println("\n--- WiFi Scanner Debug Indul ---");
 
  u8g2.begin();
 
  ledcSetup(PWM_CHANNEL, 5000, 8);
  ledcAttachPin(LED_PIN, PWM_CHANNEL);
 
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
 
  Serial.println("Kijelzo es WiFi kesz.");
}
 
void loop() {
  Serial.println("Szkenneles inditasa...");
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.drawStr(0, 12, "KERESES...");
  u8g2.sendBuffer();
 
  // Ez a sor tartat a legtovabb (akár 2-5 másodperc)
  int n = WiFi.scanNetworks();
 
  Serial.print("Talalt halozatok szama: ");
  Serial.println(n);
 
  u8g2.clearBuffer();
  u8g2.drawStr(0, 12, "WIFI LISTA:");
  u8g2.drawHLine(0, 14, 128);
 
  if (n == 0) {
    u8g2.drawStr(0, 30, "Nincs talalat!");
  } else {
    for (int i = 0; i < (n > 5 ? 5 : n); ++i) {
      u8g2.setCursor(0, 26 + (i * 9));
      u8g2.print(i + 1);
      u8g2.print(". ");
      u8g2.print(WiFi.SSID(i));
      Serial.printf("%d: %s (%d dBm)\n", i+1, WiFi.SSID(i).c_str(), WiFi.RSSI(i));
    }
  }
  u8g2.sendBuffer();
 
  // LED "lelegzes" es varakozas
  Serial.println("Varakozas es LED villogtatas...");
  for(int j = 0; j < 50; j++) {
    ledcWrite(PWM_CHANNEL, j * 5); // Fényerő fel
    delay(20);
  }
  for(int j = 50; j > 0; j--) {
    ledcWrite(PWM_CHANNEL, j * 5); // Fényerő le
    delay(20);
  }
 
  Serial.println("--- Ciklus vege, ujrakezdes ---");
  delay(1000);
}

Web szerver

Az alábbi példa egy webszervert hoz létre. Kapcsolódjunk böngészővel a kiírt IP címre. Ott ki-be kapcsolhatjuk a kék LED-et.

#include <Arduino.h>
#include <U8g2lib.h>
#include <WiFi.h>
#include <WebServer.h>
#include "soc/soc.h"           // Brownout védelemhez
#include "soc/rtc_cntl_reg.h"  // Brownout védelemhez
 
// --- WIFI ADATOK ---
const char* ssid     = "WIFI_NEVE";
const char* password = "WIFI_JELSZAVA";
 
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE);
WebServer server(80);
 
const int LED_PIN = 2;
String kijelzoUzenet = "Vara kozas...";
 
void setup() {
  // 1. MÉLYSÉGI VÉDELEM: Brownout kikapcsolása azonnal
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); 
 
  Serial.begin(115200);
  u8g2.begin();
  pinMode(LED_PIN, OUTPUT);
 
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.drawStr(0, 12, "WiFi: Inditas...");
  u8g2.sendBuffer();
 
  // 2. WIFI KÍMÉLŐ MÓD: Visszavesszük a rádió erejét a stabilitásért
  WiFi.mode(WIFI_STA);
  WiFi.setTxPower(WIFI_POWER_11dBm); // Kevesebb áramot ránt be
  WiFi.begin(ssid, password);
 
  Serial.print("Csatlakozas");
  int probalkozas = 0;
 
  while (WiFi.status() != WL_CONNECTED && probalkozas < 30) {
    delay(1000); // 1 másodperces várakozás
    probalkozas++;
    Serial.print(".");
 
    u8g2.clearBuffer();
    u8g2.drawStr(0, 12, "Csatlakozas...");
    u8g2.setCursor(0, 30);
    u8g2.print(ssid);
    u8g2.drawFrame(0, 40, 128, 10);
    u8g2.drawBox(0, 40, probalkozas * 4, 10); // Haladás jelző
    u8g2.sendBuffer();
  }
 
  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\nSiker!");
    // Szerver útvonalak
    server.on("/", []() {
      String html = "<h1>IdeaSpark OK</h1><a href='/led'>LED Valtas</a>";
      server.send(200, "text/html", html);
    });
 
    server.on("/led", []() {
      digitalWrite(LED_PIN, !digitalRead(LED_PIN));
      server.send(200, "text/html", "<h1>LED atvaltva!</h1><a href='/'>Vissza</a>");
    });
 
    server.begin();
  } else {
    u8g2.clearBuffer();
    u8g2.drawStr(0, 30, "HIBA: Nincs WiFi!");
    u8g2.sendBuffer();
    while(1);
  }
}
 
void loop() {
  server.handleClient();
 
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.drawStr(0, 12, "WEB SZERVER AKTIV");
  u8g2.setCursor(0, 35);
  u8g2.print("IP: ");
  u8g2.print(WiFi.localIP());
  u8g2.sendBuffer();
  delay(100);
}

Bluetooth

Az ESP32 Bluetooth-t is tartalmaz. Az alábbi program kipróbálásához érdemes feltelepíteni a Serial Bluetooth Terminal alkalmazást. Itt is külső áramforrásra van szükség. Párosítsuk a telefonnal az IdeaSpark_BT eszközt, majd küldjünk 1-et (LED bekapcsol) vagy 0-t (LED kikapcsol).

#include <Arduino.h>
#include <U8g2lib.h>
#include "BluetoothSerial.h"
 
BluetoothSerial SerialBT;
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE);
 
const int LED_PIN = 2; // A kék LED lába
String uzenet = "Varakozas...";
 
void frissitKijelzo();
 
void setup() {
  u8g2.begin();
  pinMode(LED_PIN, OUTPUT);
 
  // Bluetooth indítása
  SerialBT.begin("IdeaSpark_BT"); 
 
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.drawStr(0, 12, "BT KETIRANYU MOD");
  u8g2.drawStr(0, 30, "Kuldj 1-est vagy 0-at!");
  u8g2.sendBuffer();
}
 
void loop() {
  if (SerialBT.available()) {
    char bejovo = SerialBT.read(); // Egy karakter beolvasása
 
    if (bejovo == '1') {
      digitalWrite(LED_PIN, HIGH);
      uzenet = "LED: BEKAPCSOLVA";
      SerialBT.println("A kek LED vilagit."); // Visszaküldés a telefonra
    } 
    else if (bejovo == '0') {
      digitalWrite(LED_PIN, LOW);
      uzenet = "LED: KIKAPCSOLVA";
      SerialBT.println("A kek LED kialudt."); // Visszaküldés a telefonra
    }
    else if (bejovo != '\n' && bejovo != '\r') {
      // Ha nem 1 vagy 0, akkor csak írjuk ki a kijelzőre
      uzenet = "Szoveg: ";
      uzenet += bejovo;
      SerialBT.print("Ezt kaptam: ");
      SerialBT.println(bejovo);
    }
 
    // Frissítsük a kijelzőt azonnal, ha jött adat
    frissitKijelzo();
  }
}
 
void frissitKijelzo() {
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.drawStr(0, 12, "BLUETOOTH STATUSZ");
  u8g2.drawHLine(0, 15, 128);
 
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.setCursor(0, 40);
  u8g2.print(uzenet);
 
  u8g2.sendBuffer();
}

Vélemény

Kétségkívül pozitívuma, hogy egy ilyen olcsó kategóriára rátettek egy kis kijelzőt, így nem kell külön megvásárolni, elkészíteni a kapcsolást és ezáltal lábakat sem foglal.

Hátrányának tartom viszont, hogy nincs rajta megfelelő számú nyomógomb, ezáltal nehézkes interaktív alkalmazást készíteni. Ma ebben a kategóriában elvárnék legalább 2 általános célú nyomógombot, a szokásos reseten felül.

A másik hátránya, ami szerintem ma már nehezen megbocsájtható, az a kezdeti lépések nehézkessége. Nem világos, hogy miért nincs olyan IDE, ami alapból támogatná az ESP32 családot. A példaprogramok használata sem egyértelmű elsőre.

oldalváltozat: 13, utoljára szerkesztve: 28 Jan 2026 07:31

Szerkesztés Rate (0) Címkék Vita Előzmények Fájlok Nyomtatás Eszközök + Opciók

Faragó Csaba

Áttekintés