Télégramme : ESP32-CAM Prendre et envoyer une photo (Arduino IDE)

View raw code

How the Code Works

This section explains how the code works. Continue reading to learn how the code works or skip to the Demonstration section.

Importing Libraries

Start by importing the required libraries.

#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include "soc/soc.h"
#include "soc/rtc_cntl_reg.h"
#include "esp_camera.h"
#include <UniversalTelegramBot.h>
#include <ArduinoJson.h>

Identifiants du réseau

Insérez vos informations d'identification réseau dans les variables suivantes.

const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

ID utilisateur du télégramme

Insérez votre identifiant de chat. Celui que vous avez de l'IDBot.

String CHAT_ID = "XXXXXXXXXX";

Jeton de robot de télégramme

Insérez votre jeton Telegram Bot que vous avez reçu de Botfather sur le BOTtoken variable.

String BOTtoken = "XXXXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";

le envoyer une photo La variable booléenne indique s'il est temps d'envoyer une nouvelle photo à votre compte télégramme. Par défaut, il est défini sur faux.

bool sendPhoto = false;

Créez un nouveau client WiFi avec WiFiClientSécurisé.

WiFiClientSecure clientTCP;

Créez un bot avec le jeton et le client définis précédemment.

UniversalTelegramBot bot(BOTtoken, clientTCP);

Créez une variable pour contenir la broche du flash LED (FLASH_LED_PIN). Dans l'ESP32-CAM AI Thinker, le flash est connecté à GPIO 4. Par défaut, définissez-le sur MEUGLER.

define FLASH_LED_PIN 4
bool flashState = LOW;

le botRequestDelay et lasTimeBotRan Les variables sont utilisées pour rechercher de nouveaux messages Telegram toutes les x secondes. Dans ce cas, le code vérifiera les nouveaux messages toutes les secondes (1000 millisecondes). Vous pouvez modifier ce délai dans le botRequestDelay variable.

int botRequestDelay = 1000;
unsigned long lastTimeBotRan;

Initialisation ESP32-CAM

Les lignes suivantes attribuent les broches ESP32-CAM AI-Thinker. Si vous utilisez un autre modèle de caméra ESP32, n'oubliez pas de modifier le brochage (lisez Cartes de caméra ESP32-CAM : Guide d'attribution des broches et des GPIO).

//CAMERA_MODEL_AI_THINKER
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22

le configInitCamera() La fonction initialise la caméra ESP32.

void configInitCamera(){
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;
  //init with high specs to pre-allocate larger buffers
  if(psramFound()){
    config.frame_size = FRAMESIZE_UXGA;
    config.jpeg_quality = 10;  //0-63 lower number means higher quality
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;  //0-63 lower number means higher quality
    config.fb_count = 1;
  }
  // camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    delay(1000);
    ESP.restart();
  }
  // Drop down frame size for higher initial frame rate
  sensor_t * s = esp_camera_sensor_get();
  s->set_framesize(s, FRAMESIZE_CIF);  // UXGA|SXGA|XGA|SVGA|VGA|CIF|QVGA|HQVGA|QQVGA
}

handleNouveauxMessages()

le handleNouveauxMessages() La fonction gère ce qui se passe lorsque de nouveaux messages arrivent.

void handleNewMessages(int numNewMessages) {
  Serial.print("Handle New Messages: ");
  Serial.println(numNewMessages);

Il vérifie les messages disponibles :

for (int i = 0; i < numNewMessages; i++) {

Obtenez l'ID de chat pour un message particulier et stockez-le dans le chat_id variable. L'ID de chat identifie qui a envoyé le message.

String chat_id = String(bot.messages[i].chat_id);

Si la chat_id est différent de votre identifiant de chat (CHAT_ID), cela signifie que quelqu'un (ce n'est pas vous) a envoyé un message à votre bot. Si tel est le cas, ignorez le message et attendez le prochain message.

if (chat_id != CHAT_ID){
  bot.sendMessage(chat_id, "Unauthorized user", "");
  continue;
}

Sinon, cela signifie que le message a été envoyé par un utilisateur valide, nous allons donc l'enregistrer dans le texte variable et vérifiez son contenu.

String text = bot.messages[i].text;
Serial.println(text);

le de_nom variable enregistre le nom de l'expéditeur.

String from_name = bot.messages[i].from_name;

S'il reçoit le /début message, nous enverrons les commandes valides pour contrôler l'ESP. Ceci est utile s'il vous arrive d'oublier quelles sont les commandes pour contrôler votre carte.

if (text == "/start") {
  String welcome = "Welcome , " + from_name + "n";
  welcome += "Use the following commands to interact with the ESP32-CAM n";
  welcome += "/photo : takes a new photon";
  welcome += "/flash : toggles flash LED n";
  bot.sendMessage(CHAT_ID, welcome, "");
}

Envoyer un message au bot est très simple. Il vous suffit d'utiliser le envoyer le message() sur l'objet bot et passez en arguments l'ID de discussion du destinataire, le message et le mode d'analyse.

bool sendMessage(String chat_id, String text, String parse_mode = "");

Dans notre exemple, nous enverrons le message à l'ID stocké sur le CHAT_ID variable (qui correspond à votre identifiant de chat personnel) et envoyez le message enregistré sur la variable de bienvenue.

bot.sendMessage(CHAT_ID, welcome, "");

S'il reçoit le /éclat message, inversez le flashState variable et mettre à jour l'état de la led flash. Si c'était auparavant MEUGLER, réglez-le sur HAUT. Si c'était auparavant HAUT, réglez-le sur MEUGLER.

if (text == "/flash") {
  flashState = !flashState;
  digitalWrite(FLASH_LED_PIN, flashState);
  Serial.println("Change flash LED state");
}

Enfin, s'il reçoit le /photo message, définissez le envoyer une photo variable à vrai. Ensuite, dans le boucler(), vérifiez la valeur de envoyer une photo variable et procédez en conséquence.

if (text == "/photo") {
  sendPhoto = true;
  Serial.println("New photo request");
}

envoyerPhotoTelegram()

le envoyerPhotoTelegram() fonction prend une photo avec l'ESP32-CAM.

camera_fb_t * fb = NULL;
fb = esp_camera_fb_get();  
if(!fb) {
  Serial.println("Camera capture failed");
  delay(1000);
  ESP.restart();
  return "Camera capture failed";
}  

Ensuite, il fait une requête HTTP POST pour envoyer la photo à votre bot de télégramme.

clientTCP.println("POST /bot"+BOTtoken+"/sendPhoto HTTP/1.1");
clientTCP.println("Host: " + String(myDomain));
clientTCP.println("Content-Length: " + String(totalLen));
clientTCP.println("Content-Type: multipart/form-data; boundary=Raspberryme.com");
clientTCP.println();
clientTCP.print(head);

mettre en place()

Dans le mettre en place(), initialisez le moniteur série.

Serial.begin(115200);

Réglez la LED flash comme sortie et réglez-la sur son état initial.

pinMode(FLASH_LED_PIN, OUTPUT);
digitalWrite(FLASH_LED_PIN, flashState);

Appeler le configInitCamera() fonction pour configurer et initialiser la caméra.

configInitCamera();

Connectez votre ESP32-CAM à votre réseau local.

WiFi.mode(WIFI_STA);
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
  Serial.print(".");
  delay(500);
}

boucler()

Dans le boucler(), vérifiez l'état du envoyer une photo variable. Si c'est vrai, appeler le envoyerPhotoTelegram() fonction pour prendre et envoyer une photo à votre compte de télégramme.

if (sendPhoto) {
  Serial.println("Preparing photo");
  sendPhotoTelegram();

Quand c'est fait, réglez le envoyer une photo variable à faux.

sendPhoto = false;

Dans le boucler(), vous recherchez également de nouveaux messages chaque seconde.

if (millis() > lastTimeBotRan + botRequestDelay)  {
  int numNewMessages = bot.getUpdates(bot.last_message_received + 1);
  while (numNewMessages) {
    Serial.println("got response");
    handleNewMessages(numNewMessages);
    numNewMessages = bot.getUpdates(bot.last_message_received + 1);
  }
  lastTimeBotRan = millis();
}

Lorsqu'un nouveau message arrive, appelez le handleNouveauxMessages() une fonction.

while (numNewMessages) {
  Serial.println("got response");
  handleNewMessages(numNewMessages);
  numNewMessages = bot.getUpdates(bot.last_message_received + 1);
}

C'est à peu près comme ça que le code fonctionne.

Manifestation

Téléchargez le code sur votre carte ESP32-CAM. N'oubliez pas d'aller à Outils > Conseil et sélectionnez le tableau que vous utilisez. Aller à Outils > Port et sélectionnez le port COM auquel votre carte est connectée.

Après avoir téléchargé le code, appuyez sur le bouton RST intégré de l'ESP32-CAM pour qu'il commence à exécuter le code. Ensuite, vous pouvez ouvrir le moniteur série pour vérifier ce qui se passe en arrière-plan.

Accédez à votre compte Telegram et ouvrez une conversation avec votre bot. Envoyez les commandes suivantes et voyez le bot répondre :

• /début affiche le message de bienvenue avec les commandes valides ;
• /éclat inverse l'état du flash LED ;
• /photo prend une nouvelle photo et l'envoie à votre compte Telegram.

En même temps, sur le Serial Monitor, vous devriez voir que l'ESP32-CAM reçoit les messages.

Si vous essayez d'interagir avec votre bot à partir d'un autre compte, vous recevrez le message « Utilisateur non autorisé ».

Dans ce tutoriel, vous avez appris comment envoyer une photo de l'ESP32-CAM à votre compte Telegram. Tant que vous avez accès à Internet sur votre smartphone, vous pouvez demander une nouvelle photo où que vous soyez. C'est idéal pour surveiller votre ESP32-CAM de n'importe où dans le monde.

Nous avons d'autres tutoriels utilisant Telegram qui pourraient vous intéresser :

En savoir plus sur l'ESP32-CAM avec nos ressources :

Merci d'avoir lu.