Telegram ESP32-CAM: send image [Arduino IDE]

This ESP32-CAM project covers how to send images to Telegram using ESP32-CAM. It shows how to integrate a Telegram bot with ESP32-CAM so that we can request images and receive them in our Telegram account. We will use the Arduino IDE to develop this project.

Project overview: send image to Telegram from ESP32-CAM

Before diving into the project details, it is useful to describe how this project works. The image below shows how to use Telegram with ESP32-CAM.

To build this project, it is necessary:

• to build a Telegram bot
• acquire images using ESP32-CAM
• send the image to the telegram account

What is Telegram

If you don’t know Telegram, it is a cloud messaging platform. We can use Telegram from web or there clients for Android and iOS. Telegram is focused on security and speed.

The interesting part of Telegram is it supports bot. A bot is a software application that executes repetitive tasks. A Telegram bot is an account that is operated by a software. We can interact with Telegram bot using a set of API. We will use a bot to interact with the ESP32-CAM so that we can request images from out device.

How to create a Telegram bot

The first step is creating a Telegram bot. You can download the app from app store or Google store or use a web interface. Open the app or go the link and search for the Botfather:

Next type the command /newbot and give a name to your bot:

Integrating ESP32-CAM with Telegram bot

Once we have created our Telegram bot we can integrate it with ESP32-CAM. To do it we will use a great library named Universal Arduino Telegram bot. It connects the ESP32-CAM with Telegram bot API so that we can receive and send messages. Moreover, we can send images captured by the ESP32-CAM.

Installing Universal Arduino Telegram bot in the Arduino IDE

Open the Arduino IDE and in the Sketch Menu select Include Library item and then Manage Library. Look for the Universal Arduino Telegram and install it.

Be sure that the version installed is the latest one. Otherwise, you can clone the github repository:

and then add .zip library.

ESP32-CAM sketch

Create a new sketch and then add the following code:

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include "esp_camera.h"
#include "camera_pins.h"
#include "UniversalTelegramBot.h"


#define BOT_TOKEN "your_bot_it"
#define _debug

const char* ssid = "wifi_ssid";
const char* password = "wifi_pwd";

WiFiClientSecure client;
UniversalTelegramBot bot(BOT_TOKEN, client);

long bot_last_check;
int bot_check_interval = 3000;

bool hasMoreData;
camera_fb_t * fb = NULL;

bool hasMoreDataAvailable();
byte* getNextBuffer();
int getBufferLen();

void setup() {
  Serial.begin(9600);
  Serial.setDebugOutput(true);
  Serial.println();

  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;
  
  // if PSRAM IC present, init with UXGA resolution and higher JPEG quality
  // for larger pre-allocated frame buffer.
  if(psramFound()){
    config.frame_size = FRAMESIZE_QVGA;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_QVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }

#if defined(CAMERA_MODEL_ESP_EYE)
  pinMode(13, INPUT_PULLUP);
  pinMode(14, INPUT_PULLUP);
#endif

  // camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }

  sensor_t * s = esp_camera_sensor_get();
  // initial sensors are flipped vertically and colors are a bit saturated
  if (s->id.PID == OV3660_PID) {
    s->set_vflip(s, 1); // flip it back
    s->set_brightness(s, 1); // up the brightness just a bit
    s->set_saturation(s, 0); // lower the saturation
  }
  // drop down frame size for higher initial frame rate
  s->set_framesize(s, FRAMESIZE_QVGA);

#if defined(CAMERA_MODEL_M5STACK_WIDE)
  s->set_vflip(s, 1);
  s->set_hmirror(s, 1);
#endif

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

  bot.longPoll = 60;
}


bool hasMoreDataAvailable() {
  Serial.println("Has more daa");
  if (hasMoreData) {
    hasMoreData = false;
    return true;
  }

  return false;
}


byte* getNextBuffer() {
  Serial.println("Next Buffer ");
  if (fb)
    return fb->buf;

  return nullptr;
}

int getBufferLen() {
Serial.println("Buffer len");
 if (fb)
   return fb->len;

  return 0;
}

void sendImage(String chat_id) { 
  Serial.println("Sending Image");
  fb = NULL;
  fb = esp_camera_fb_get();
  hasMoreData = true;

  Serial.println(fb->len);
  
  bot.sendPhotoByBinary(chat_id, "image/jpeg", fb->len, hasMoreDataAvailable, nullptr, getNextBuffer, getBufferLen);
  
  esp_camera_fb_return(fb);

}

void loop() {
  if (millis() > bot_last_check + bot_check_interval) {
    int numNewMessages = bot.getUpdates(bot.last_message_received + 1);
    while (numNewMessages) {
        for (int i = 0; i < numNewMessages; i++) {
           String chat_id = bot.messages[i].chat_id;
           String msg = bot.messages[i].text;
           Serial.println("Chat id:" + chat_id);
           Serial.println("Msg: " + msg);
           sendImage(chat_id);
        }
        numNewMessages = bot.getUpdates(bot.last_message_received + 1);
    }

    bot_last_check = millis();
  }
  
 // delay(10);
}
Code language: PHP (php)

The core is the sendImage function. First, the ESP32-CAM acquires the image and uses the Universal Arduino Telegram bot to send the image. This function uses three different sub-functions:

• hasMoreDataAvailable: to know if there is more data to send
• getNextBuffer: this returns the image buffer acquired before
• getBufferLen: this returns the buffer size

As you can notice this is very simple thanks to the wonderful Telegram Arduino Library.

If you want to have more information about ESP32-CAM, you can read my post covering how to capture image using ESP32-CAM.

If you want to use Raspberry Pi instead of ESP32-CAM you can read how to use Raspberry Pi with Telegram.

Test the sketch: Sending the image from ESP32-CAM to Telegram

Now we can test the Arduino sketch. We will use the Telegram bot to trigger the image acquisition from the ESP32-CAM. Then, the ESP32-CAM sends the image back to the client.

As you can notice, as soon as we send a message the ESP32-CAM captures the image and send it back. Later, we will cover how to improve the ESP32-CAM sketch.

If you are interested on ESP32-CAM or ESP32 and how to use it to build IoT projects, go to how to uese ESP32 in IoT.

How to improve the ESP32-CAM and Telegram

The code above simply sends an image every time we send a message to the ESP32-CAM. We can improve it and verify if the message contains a predefined command such as /image or /capture. Let us modify the code as shown below:

void loop() {
  if (millis() > bot_last_check + bot_check_interval) {
    int numNewMessages = bot.getUpdates(bot.last_message_received + 1);
    while (numNewMessages) {
        for (int i = 0; i < numNewMessages; i++) {
           String chat_id = bot.messages[i].chat_id;
           String msg = bot.messages[i].text;
           Serial.println("Chat id:" + chat_id);
           Serial.println("Msg: " + msg);
           if (msg == "/capture") {
             sendImage(chat_id);
           }
        }
        numNewMessages = bot.getUpdates(bot.last_message_received + 1);
    }

    bot_last_check = millis();
  }
  
 // delay(10);
}
Code language: JavaScript (javascript)

Verifying the Telegram ID

The next improvment is verifying the telegram ID used to send the message. In this way, we can accept messages only from our client avoiding others can use the bot.

First search for the Telegram ID Bot (named IDBot):

Next start a conversation with the IDBot:

and then type /getid. You will get your ID. Finally, let us modify the code:

void loop() {
  if (millis() > bot_last_check + bot_check_interval) {
    int numNewMessages = bot.getUpdates(bot.last_message_received + 1);
    while (numNewMessages) {
        for (int i = 0; i < numNewMessages; i++) {
           String chat_id = bot.messages[i].chat_id;
           String msg = bot.messages[i].text;
           Serial.println("Chat id:" + chat_id);
           Serial.println("Msg: " + msg);
           if (chat_id != "your_chat_id") {
             bot.sendMessage(chat_id, "You are not authorize to use this bot", "");
             continue;
           }
           if (msg == "/capture") {
             sendImage(chat_id);
           }
        }
        numNewMessages = bot.getUpdates(bot.last_message_received + 1);
    }

    bot_last_check = millis();
  }
  
 // delay(10);
}
Code language: JavaScript (javascript)

Wrapping up

At the end of this tutorial, we have discovered how to use ESP32-CAM with Telegram bot. We have described how to create and configure a Telegram bot to send commands to the ESP32-CAM so that it captures an image and send it back.