Hur man ansluter SSD1306 OLED-skärm till ESP32 för att visa text, former och bilder

Att använda en OLED-skärm som SSD1306 tillsammans med ESP32 mikrokontroller erbjuder en mängd olika användningsmöjligheter för att visa både text och grafik i dina projekt. För att ansluta SSD1306 till ESP32 används oftast I2C-kommunikation, vilket är en enkel och effektiv metod för att överföra data mellan enheten och skärmen. Genom att utnyttja ESP32:s SCL- och SDA-pinnar kan du etablera en direkt kommunikation med skärmen.

I det här exemplet har vi definierat skärmens bredd och höjd som 128x64 pixlar. Genom att skapa en instans av Adafruit_SSD1306-klassen kan vi definiera en skärm med dessa dimensioner och börja använda funktioner som clearDisplay(), drawBitmap() och println() för att visa text, rita former och lägga till bilder.

Koden fungerar på så sätt att i setup()-funktionen utförs en initialisering av skärmen. Om detta misslyckas, skriver programmet ut ett felmeddelande och stänger av sig. Efter en lyckad initialisering kan du börja använda funktioner för att visa text, rita rektanglar, cirklar, linjer och till och med visa bitmapbilder. I loop()-funktionen upprepas dessa operationer, vilket innebär att texten och de grafiska objekten uppdateras på skärmen med jämna mellanrum. Varje grafisk operation upprepas i ett oändligt loop-scenario, där varje objekt visas i 2 sekunder innan nästa visas.

Det är viktigt att förstå att den grafiska förmågan hos SSD1306 är begränsad i jämförelse med mer avancerade TFT-skärmar. Du kan bara visa svartvita bilder och text i en enkel, monokromatisk stil. För mer komplexa grafiska användningar, som färggrafik eller pekskärmsfunktionalitet, kan det vara nödvändigt att överväga andra skärmar som TFT eller OLED med färgdisplay.

I detta kapitel har vi alltså lärt oss att ansluta SSD1306 OLED till ESP32 och visa olika typer av grafiska objekt. Från att visa enkel text till att rita former och visa bilder, ger denna skärm en solid grund för att arbeta med visuella representationer i dina projekt.

Det är viktigt att komma ihåg att varje typ av display har sina specifika fördelar och begränsningar. OLED-skärmar, såsom SSD1306, är utmärkta för enklare grafiska gränssnitt, där man inte behöver färg eller hög upplösning. Däremot kan TFT-skärmar, med sina högre upplösningar och färgkapabiliteter, vara ett bättre alternativ för mer komplexa användargränssnitt där detaljerad grafik och färg är viktigt.

Hur man skapar och testar BLE-servrar och -klienter med ESP32

ESP32, den mångsidiga mikrocontrolleren, erbjuder kraftfulla verktyg för att bygga trådlösa kommunikationssystem. En av de mest imponerande funktionerna är dess inbyggda stöd för Bluetooth Low Energy (BLE), vilket gör det möjligt att skapa energieffektiva och flexibla lösningar för Internet of Things (IoT)-applikationer. BLE gör det enkelt att skapa personliga nätverk för datadelning mellan enheter, och ESP32 ger oss den nödvändiga funktionaliteten för att implementera både servrar och klienter.

En BLE-server fungerar som en grundläggande byggsten för att skapa trådlös kommunikation mellan BLE-enheter. Den erbjuder specifika tjänster och data till andra enheter, kallade BLE-klienter, inom dess räckvidd. Dessa tjänster innehåller karakteristik, som representerar specifika datapunkter eller attribut. BLE-serverns uppgift är att svara på läs- och skrivbegärningar från klienter, vilket gör det möjligt för dem att hämta eller ändra data.

En BLE-server kan användas inom en mängd olika områden. I smarta hem kan BLE-servrar göra det möjligt att styra enheter som lampor, termostater och dörrlås via smartphones. Inom hälsovård integreras BLE-servrar ofta i bärbara enheter som pulsmätare och aktivitetsnivåmätare för att skicka realtidsdata till övervakningsappar. Inom detaljhandeln används BLE-servrar för platsbaserade tjänster, där kunder kan få personliga erbjudanden baserat på sin plats i butiken. Andra exempel på användning av BLE-servrar är i lagerhantering, bilindustrin, logistik och industriell automation.

För att skapa en BLE-server på ESP32-plattformen behöver vi en grundläggande kod som definierar servern, dess tjänster och karakteristik. Här är ett exempel på hur koden kan se ut:

cpp
Copy code
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
void setup() {
  Serial.begin(115200);
  Serial.println("Starting BLE work!");
  BLEDevice::init("Long name works now");
  BLEServer *pServer = BLEDevice::createServer();
  BLEService *pService = pServer->createService(SERVICE_UUID);
  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
      CHARACTERISTIC_UUID, 
      BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_WRITE
  );
  pCharacteristic->setValue("Hello World");
  pService->start();
  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->setScanResponse(true);
  pAdvertising->setMinPreferred(0x06); // iPhone connection fix
  pAdvertising->setMinPreferred(0x12);
  BLEDevice::startAdvertising();
  Serial.println("Characteristic defined! Now you can read it in your phone!");
}
void loop() {
  delay(2000); // Main loop
}

I detta exempel importeras de nödvändiga BLE-biblioteken, och två UUID:n definieras för att identifiera tjänsten och dess karakteristik. Servern initieras, och en tjänst skapas med en definierad karakteristik som tillåter både läsning och skrivning av data. I det här fallet är den initiala värdet "Hello World". När servern är konfigurerad startar den sin annonsering, vilket gör att klienter kan upptäcka den och kommunicera med den.

För att testa BLE-servern på en mobiltelefon kan du använda appen nRF Connect for Mobile, som är tillgänglig för både Android och iOS. Efter installationen av appen kan du följa dessa steg för att ansluta till BLE-servern:

1. Slå på Bluetooth på din telefon.

2. Öppna appen.

3. Ge appen nödvändiga behörigheter för att använda Bluetooth.

4. Hitta din BLE-server i appen och interagera med dess tjänster och data.

Förutom grundläggande funktioner som läsning och skrivning av data, erbjuder ESP32:s BLE-implementation även viktiga säkerhetsfunktioner, som kryptering, autentisering och parning. Dessa funktioner är avgörande för att skydda integriteten och konfidentialiteten för den data som utbyts mellan BLE-enheter. Dessutom kan ESP32 användas som en BLE-beacon, vilket gör det möjligt att sända annonseringspaket till enheter i närheten för platsbaserade tjänster och marknadsföring.

För att bygga effektiva och innovativa lösningar inom IoT är det nödvändigt att förstå både hur BLE fungerar och hur ESP32:s BLE-funktioner kan användas för att skapa ett robust kommunikationssystem. Genom att kombinera server- och klientfunktioner kan du skapa kompletta BLE-lösningar för ett brett spektrum av tillämpningar, från smarta hem till industriell automation.

Hur man integrerar PayPal och ESP32 för att hyra ut parkeringsplatser

När man skapar ett system för att hyra ut parkeringsplatser via PayPal och använder en ESP32 mikrokontroller, är det viktigt att förstå hur man både visar QR-koder för betalningar och tar emot notifieringar om betalningar via Webhooks. Detta är en komplex process som involverar både hårdvara och mjukvara. Nedan går vi igenom en detaljerad beskrivning av hur systemet fungerar, inklusive nödvändiga steg för att integrera både OLED-skärmen för visning av QR-koder och kommunikationen med PayPal för att ta emot betalningsnotifikationer.

I setup()-funktionen startas seriell kommunikation med en baudrate på 115200, och OLED-skärmen initialiseras med display.begin(SSD1306_SWITCHCAPVCC, 0x3C). Om denna initialisering misslyckas, skrivs ett felmeddelande ut och systemet går in i en oändlig loop. Här kallas också funktionen showScantoPay() för att visa QR-koden och meddelandet på skärmen.

Efter att ha konfigurerat OLED-skärmen och visat QR-koden, kan systemet nu ta emot betalningsnotifikationer via Webhooks från PayPal. För att ställa in Webhooks skapas en unik URL via https://www.webhook.site. Denna URL kommer att användas för att ta emot notifikationer när en betalning görs. För att testa detta kan man använda PayPals Instant Payment Notification (IPN) simulator, som finns på https://developer.paypal.com/dashboard/ipnsimulator. Här kan man fylla i den unika URL:en och välja "Web Accept" som transaktionstyp för att simulera en betalning.

För att ta emot och hantera dessa notifieringar på ESP32 används olika bibliotek. WiFi-biblioteket gör det möjligt för ESP32 att ansluta till Wi-Fi-nätverk, medan HTTPClient-biblioteket används för att göra HTTP-förfrågningar för att hämta data från Webhook-tjänsten. ArduinoJson-biblioteket används för att parsa JSON-data, och NTPClient-biblioteket synkroniserar tiden med hjälp av Network Time Protocol (NTP). En viktig del här är att definiera en funktion, som t.ex. parseTimestamp(), för att korrekt hantera tidsstämpeln från IPN.

I setup()-funktionen ansluter ESP32 till Wi-Fi och skriver ut en bekräftelse på att anslutningen är etablerad. Den viktigaste delen är checkPayment()-funktionen, som ansvarar för att kontrollera och bearbeta betalningsdata. Här används amountPaid för att lagra betalningsbeloppet och en tidsgräns på två minuter sätts för att definiera om data är för gammal. Funktionen uppdaterar systemets tid med hjälp av NTP och kontrollerar om ESP32 fortfarande är ansluten till Wi-Fi.

Om anslutningen är etablerad görs en HTTP GET-förfrågan till den specifika URL:en och notifikationen om betalningen hämtas. När svaret mottas, om det är en lyckad begäran, parsas JSON-data för att extrahera information om betalningen. Om betalningen är äldre än två minuter eller om inga nya data finns, informeras användaren om detta. Slutligen stängs HTTP-anslutningen och betalningsbeloppet returneras.

För att skapa en användarvänlig upplevelse för potentiella hyresgäster är det viktigt att systemet är enkelt att använda och snabbt att interagera med. QR-koden på OLED-skärmen är en central del av användargränssnittet, vilket gör att hyresgästen snabbt kan scanna och betala för parkeringen. Vidare bör systemet vara tillförlitligt i att ta emot och bearbeta betalningar i realtid, vilket kräver att all kommunikation mellan PayPal, Webhook-tjänsten och ESP32 är korrekt konfigurerad och effektiv.

Hur kan ESP32 programmeras?

ESP32 kan programmeras på flera sätt, inklusive Arduino IDE, Python, Expressif-IoT Development Framework (ESP-IDF, det officiella utvecklingsramverket från Espressif) och många fler. De mest använda metoderna beskrivs nedan:

Arduino IDE är en nybörjarvänlig utvecklingsmiljö som gör det möjligt att skriva, kompilera och ladda upp kod till ESP32 med hjälp av Arduino-programmeringsspråket. MicroPython är en Python-baserad tolk som körs på ESP32, vilket tillåter utvecklare att skriva Python-kod och köra den direkt på enheten. ESP-IDF, å andra sidan, är det officiella utvecklingsramverket för ESP32 och erbjuder ett flertal API:er för låg-nivå åtkomst till hårdvara, vilket ger större flexibilitet i programmering och debugging.

Utöver dessa alternativ kan ESP32 också programmeras med hjälp av Visual Studio Code och PlatformIO, JavaScript och Node.js, samt Rust. De tre vanligaste alternativen för programmering av ESP32 beskrivs i tabellen nedan:

Tabellen visar på de grundläggande skillnaderna mellan de tre programmeringsalternativen för ESP32. Både Arduino IDE och MicroPython erbjuder nybörjarvänliga alternativ, medan ESP-IDF ger full åtkomst till ESP32:s funktionalitet. Från och med nu är det viktigt att notera att ESP-IDF och MicroPython inte har samma nivå av IDE-stöd som Arduino IDE, vilket kan göra det svårare för nybörjare att komma igång.

Arduino IDE 2.0 är den senaste versionen av den populära programvaran för att programmera Arduino-kort. Den erbjuder många förbättringar jämfört med tidigare versioner, och är mer användarvänlig och kraftfull. IDE:n gör det enkelt att hantera bibliotek, kort och projekt på ett och samma ställe, vilket förenklar organiseringen av arbetet. Även om det ursprungligen är utvecklat för Arduino-kort, kan man också lägga till stöd för andra kort som ESP32, ESP8266, NRF och STM.

För att installera Arduino IDE 2.0 är processen enkel. Man går till Arduino-webbplatsen, laddar ner programmet och installerar det enligt instruktionerna för respektive operativsystem (Windows, macOS eller Linux). När installationen är klar kan man börja använda IDE:n för att programmera ESP32, men först måste man installera stöd för ESP32-kortet. Det görs genom att lägga till en URL i "Additional boards manager URLs"-sektionen i inställningarna och sedan installera ESP32-stödet från Board Manager.

När ESP32-stödet är installerat kan man börja skapa projekt, som till exempel det enklaste testprogrammet, det så kallade "Hello World"-programmet. På ESP32 motsvaras detta av att få en LED att blinka, vilket bekräftar att både hårdvara och mjukvara fungerar som de ska.

För att skriva ett "Hello World"-program i Arduino IDE 2.0, öppnar man ett nytt skissdokument och skriver följande kod:

cpp
Copy code
void setup() {

    pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(1000);
    digitalWrite(LED_BUILTIN, LOW);
    delay(1000);
}

Denna kod består av två funktioner: setup() och loop(). Funktionen setup() körs endast en gång när ESP32 sätts på eller startas om, och här används den för att ställa in LED-pinnen som en utgång. Funktionen loop() körs kontinuerligt och styr blinken på LED-lampan. Funktionen digitalWrite() sätter den digitala pinnen till hög (HIGH) eller låg (LOW), och delay() väntar i 1000 millisekunder mellan varje växling.

När detta program körs korrekt kan utvecklaren vara säker på att både IDE:n och hårdvaran är korrekt anslutna och att kommunikationen fungerar. Detta gör det möjligt att gå vidare till mer avancerade projekt och skapa mer komplexa IoT-lösningar.

Det är också viktigt att förstå hur olika programmeringsspråk och ramverk påverkar utvecklingsprocessen. Arduino IDE är ett utmärkt val för nybörjare som vill komma igång snabbt, men för mer avancerad kontroll och komplexitet är ESP-IDF ett bättre alternativ, även om det kräver mer erfarenhet. MicroPython kan vara ett bra val för dem som är bekanta med Python och vill ha ett snabbt prototypingverktyg. Oavsett vilket ramverk man väljer, är det viktigt att vara medveten om hur varje plattform hanterar systemresurser och vilket stöd som finns tillgängligt för att lösa eventuella problem.