Hur skickar man e-post med ESP32 och SMTP?

I det här avsnittet går vi igenom hur du kan skicka e-postmeddelanden från ditt ESP32-drivna system med hjälp av SMTP (Simple Mail Transfer Protocol). Detta protokoll är avgörande för elektronisk kommunikation och används för att överföra e-post från en server till en annan, och är därför en oumbärlig del av många moderna system som kräver pålitlig e-postkommunikation. Genom att integrera SMTP i vårt växtövervakningssystem kan vi skapa ett system som inte bara samlar data utan också kommunicerar direkt med användaren via e-post.

För att kunna skicka e-post via ESP32 behöver vi först konfigurera ett Gmail-konto och ge nödvändiga autentiseringsuppgifter. Här är en steg-för-steg-guide för att förbereda ditt Gmail-konto för att skicka e-post från ditt ESP32-system:

1. Gå till Google My Account.

2. Klicka på fliken "Säkerhet".

3. Under "Hur du loggar in på Google", välj "2-stegsverifiering" och följ instruktionerna för att aktivera det.

4. När 2-stegsverifiering är aktiverat, sök efter "App-lösenord" i inställningarna.

5. Välj "Annat (anpassat namn)" och skriv namnet på enheten, t.ex. "ESP32".

6. Klicka på "GENERERA" för att skapa ett lösenord som du sedan kan använda i din kod.

När detta är klart har du den autentisering som behövs för att ESP32 ska kunna skicka e-post.

Nästa steg är att skriva själva koden för att skicka e-post. Här följer en grundläggande kodsnutt som använder Arduino IDE för att skicka e-post från ESP32:

cpp
Copy code
#include <WiFi.h>

#include <ESP_Mail_Client.h>
#include <DHT.h>
// WiFi Credentials
#define WIFI_SSID "Your_WIFI_SSID"
#define WIFI_PASSWORD "Your_WIFI_PASSWORD"
// Email Credentials
#define SMTP_SERVER "smtp.gmail.com"
#define SMTP_PORT 465
#define SENDER_EMAIL "[email protected]"
#define SENDER_PASSWORD "your-app-password"
#define RECIPIENT_EMAIL "[email protected]"
#define RECIPIENT_NAME "Recipient"
// Sensor setup
DHT dht(4, DHT22); // Temperature and Humidity Sensor on pin 4
void setup() {
  Serial.begin(115200);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.println("Connecting to WiFi...");
  }
  Serial.println("Connected to WiFi");
  dht.begin();
}
void loop() {
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();
  String message = "Current Temperature: " + String(temperature) + "°C\n";
  message += "Current Humidity: " + String(humidity) + "%";
  sendEmail(message); // Function to send the email
  delay(60000); // Delay for 1 minute
}
void sendEmail(String messageText) {
  ESP_Mail_Session session;
  session.server.host = SMTP_SERVER;
  session.server.port = SMTP_PORT;
  session.login.email = SENDER_EMAIL;
  session.login.password = SENDER_PASSWORD;
  SMTP_Message message;
  message.sender.name = "ESP32 Plant Monitor";
  message.sender.email = SENDER_EMAIL;
  message.subject = "Plant Health Update";
  message.addRecipient(RECIPIENT_EMAIL, RECIPIENT_NAME);
  message.text.content = messageText;
  if (MailClient.sendMail(session, message)) {
    Serial.println("Email sent successfully!");
  } else {
    Serial.println("Error sending email: " + MailClient.errorReason());
  }
}

För att göra detta möjligt krävs att alla anslutningsparametrar är korrekt inställda, såsom Wi-Fi-information och e-postautentisering. Det är viktigt att dessa autentiseringar hålls säkra och att lösenord inte delas öppet i koden, särskilt i produktionsmiljöer.

För att göra systemet ännu mer användbart, kan du också konfigurera det att skicka e-postmeddelanden vid specifika tröskelvärden. Till exempel, om temperaturen stiger över ett visst värde eller om luftfuktigheten blir för låg, kan systemet automatiskt skicka en varning via e-post till användaren.

Vidare kan det vara en bra idé att överväga att skicka e-postmeddelanden med periodiska sammanfattningar av växtens hälsa, snarare än att bara skicka ett e-postmeddelande vid extrema värden. Detta ger användaren en kontinuerlig överblick över hur deras växt mår.

Hur man publicerar tweets med ESP32 och Twitter API

För att skicka en tweet från ESP32, behöver vi en funktion som hanterar kommunikationen med Twitter API. Här är en funktion, sendTweet, som gör just detta. Den är utformad för att ta en textsträng, som innehåller själva tweeten, och sedan skicka denna till Twitter genom API:et. För att förstå hur denna funktion fungerar, är det viktigt att bryta ner varje steg noggrant.

Första steget i funktionen är anropet till twitter.timeConfig(), som troligtvis är en metod för att konfigurera tid och autentisering. Detta steg är avgörande för att säkerställa att tidstämplarna för tweeten är korrekta och att kommunikationen mellan ESP32 och Twitter API är säker och synkroniserad.

Den centrala delen av funktionen är twitter.sendTweet(const_cast<char*>(tweetText)), där tweetText konverteras och skickas till Twitter API via en metod som kallas sendTweet i biblioteket för Twitter. Om tweeten skickas framgångsrikt, returneras ett true värde, vilket sparas i variabeln success.

Slutligen, om tweeten har skickats framgångsrikt, får användaren ett meddelande via seriell monitor som bekräftar att tweeten har skickats: Serial.println("Tweet Sent").

För att detta ska fungera i praktiken måste användaren se till att alla autentiseringsuppgifter är uppdaterade och korrekt konfigurerade. Detta innebär att man måste byta ut API-nycklarna och andra autentiseringstoken, som är specifika för varje användare, för att säkerställa att kommunikationen fungerar korrekt. Dessutom krävs installationen av biblioteket TweESP32, vilket kan göras genom att ladda ner det från GitHub och installera det via Arduino IDE.

I detta exempel används även andra meddelandeplattformar som WhatsApp och Telegram för att skicka meddelanden, vilket innebär att användaren inte bara kan kommunicera via Twitter utan även via andra kanaler. Den slutliga koden publicerar inte bara tweets, utan även meddelanden på WhatsApp och Telegram genom integration med API:er från CallMeBot. På så sätt får användaren möjlighet att snabbt och effektivt distribuera information till ett brett nätverk av kontakter.

Att förstå hur man använder Twitter API på detta sätt ger en användbar grund för att bygga mer komplexa IoT-lösningar. Förutom att skicka textmeddelanden kan denna metod också användas för att hantera andra typer av interaktioner med användarna, vilket gör det möjligt att skapa interaktiva och responsiva system som kan användas i en mängd olika scenarier.

Slutligen, för att säkerställa att hela systemet fungerar korrekt och säkert, är det viktigt att hålla all programvara och alla autentiseringstoken uppdaterade. Vid utveckling av IoT-applikationer är säkerhet en prioritet, eftersom API-nycklar och andra autentiseringselement ofta är mål för hackare som försöker komma åt konton och data.

Hur fungerar UART-protokollet och hur kommunicerar två ESP32-moduler via UART?

UART är ett asynkront seriellt kommunikationsprotokoll som möjliggör överföring och mottagning av data mellan enheter. Eftersom det är asynkront, krävs ingen klocksignal för att synkronisera sändning och mottagning av data. Istället använder UART två datalinjer: en för mottagning av data (Rx) och en för sändning av data (Tx). Dataöverföringen består av ett startbit, ett antal databit (vanligtvis 8 bitar), ett eventuellt paritetsbit för felkontroll och ett eller flera stoppbit.

Startbitarna är alltid låga (0) och markerar början på dataramen. Data-bitarna representerar den faktiska informationen som överförs, och den valfria paritetsbiten används för felkontroll genom att lägga till ett extra bit (udda eller jämnt) till varje överfört byte. Paritetsbiten ställs in så att det totala antalet bitar (inklusive paritetsbiten) i varje byte antingen är jämnt eller udda. Vid mottagning kontrollerar mottagaren pariteten för den mottagna byten. Om det inte stämmer med den förväntade pariteten, upptäcks ett fel och kommunikationsprocessen avbryts.

För att överföra data via UART krävs en angiven överföringshastighet, känd som baudrate, som anger antalet bitar per sekund (bps). Vanliga baudrates är 9600, 115200 och 921600 bps.

UART-kommunikation mellan två ESP32-moduler

För att kommunicera mellan två ESP32-moduler via UART behöver vi först skapa ett kretsdiagram där de två ESP32:orna är anslutna via Rx och Tx-linjer. Rx från den första ESP32 ska kopplas till Tx på den andra ESP32 och vice versa. För att slutföra kretsen ska även jord (GND) för de båda ESP32:orna kopplas samman. När detta är gjort, kan vi skapa ett enkelt program i Arduino IDE för att sända och ta emot data mellan de två modulerna.

I Arduino IDE kan koden för att sända data vara så enkel som att använda Serial.begin(baudrate) för att sätta baudraten och Serial.println("IoT") för att sända strängen "IoT". Här är ett exempel på koden för att sända data från en ESP32-modul:

cpp
Copy code
void setup() {
    // Sätt UART baudrate till 9600
    Serial.begin(9600);
}
void loop() {
    // Skicka strängen "IoT" via UART
    Serial.println("IoT");
    // Vänta ett ögonblick innan nästa sändning
    delay(1000);
}

Den andra ESP32-modulen kommer att ta emot denna data genom att lyssna på den seriella porten och läsa den mottagna informationen. Här är ett exempel på mottagarens kod:

cpp
Copy code
void setup() {

    // Sätt UART baudrate till 9600
    Serial.begin(9600);
}
void loop() {
    if (Serial.available() > 0) {
        // Om data är tillgänglig för att läsa
        String receivedData = Serial.readString();
        // Processera eller använd den mottagna datan
        Serial.print("Mottagen data: ");
        Serial.println(receivedData);
    }
}

För att säkerställa att både ESP32-moduler använder samma baudrate och korrekt hantering av mottagen data, är det viktigt att kontrollera att både sändande och mottagande enheter är korrekt inställda.

Anslutning av sensorer som använder UART-kommunikation

Förutom grundläggande dataöverföring mellan ESP32-moduler, används UART även för att kommunicera med olika sensorer. Många sensorer använder UART för att skicka data till ESP32. Exempel på sådana sensorer är GPS-moduler, RFID-läsare och Bluetooth-moduler.

GPS-moduler, såsom ublox NEO 6m och NEO 7m, använder UART för att skicka positionsdata. RFID-läsare, som MFRC522 och PN532, använder också UART för att kommunicera med ESP32. Även om ESP32 har inbyggd Bluetooth, kan andra Bluetooth-moduler som HC-05 och HC-06 använda UART för att möjliggöra trådlös kommunikation med andra mikrokontroller som inte har inbyggd Bluetooth.