Placa de cámara TTGO T-Journal ESP32: Primeros pasos |

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

¿Estás buscando una cámara compacta y versátil para tus proyectos de IoT? La Cámara TTGO T-Journal ESP32 cuenta con un programador incorporado, pantalla OLED, antena y una amplia variedad de ejemplos de proyectos para inspirarte. Descubre todas sus funciones y posibilidades en este artículo.

Esta es una guía introductoria para la placa de desarrollo de cámara TTGO T-Journal ESP32. El TTGO T-Journal cuenta con una cámara OV2640, una pantalla OLED, múltiples GPIO para conectar periféricos y un programador incorporado que facilita la carga de código. Echaremos un vistazo rápido a la placa de desarrollo de la cámara y aprenderemos cómo programarla usando Arduino IDE.

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

Contenido

¿Donde comprar?

Puedes ir al… Página de TTGO T-Journal en Maker Advisor Para comparar el tablero en diferentes tiendas.

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

Presentamos la cámara TTGO T-Journal ESP32

El Diario TTGO T es una placa de desarrollo de cámara ESP32 de $ 12-15 con una cámara OV2640, una antena, una pantalla OLED I2C SSD1306 de 0,91 pulgadas, algunos GPIO expuestos y una interfaz micro USB que hace que cargar código en la placa sea rápido y fácil.

Para obtener una descripción completa de este tablero, puede ver el video a continuación o leer este artículo: Revisión de la placa de desarrollo de cámara TTGO T-Journal ESP32.

Características de TTGO T-Journal ESP32

Aquí hay un resumen de las características del TTGO T-Journal:

  • Chipset ESPRESSIF-ESP32-PCIO-D4 Microprocesador LX6 de 32 bits Xtensa® de 240 MHz de uno o dos núcleos
  • FLASH Flash QSPI/SRAM, hasta 4 x 16 MBSRAM 520 kB SRAM
  • Botón de reinicio y botón en GPIO 32
  • Pantalla OLED SSD1306 de 0,91 pulgadas
  • Indicador de encendido LED rojo
  • USB a TTL CP2104 (puede cargar el código mediante un cable USB);
  • Cámara OV2640 2 megapíxeles
  • Servo analógico para motor de dirección (viene con dos juegos de pines, ideal para conectar servos)
  • Voltaje de funcionamiento: 2,3 V – 3,6 V
  • Corriente de trabajo: aprox. 160 mA
  • Tamaño: 64,57 mm x 23,98 mm

Especificaciones de la fuente de alimentación:

  • Fuente de alimentación USB 5V/1A
  • Corriente de carga 1A
  • Batería Batería de litio de 3,7 V.

Lea nuestra revisión detallada: Placa de desarrollo de cámara TTGO T-Journal ESP32

Pinout de la placa TTGO T-Journal ESP32

La configuración de pines correcta para la placa de su cámara es muy importante. Si no asigna los pines de cámara correctos en su código, la cámara no funcionará. La siguiente imagen muestra el pinout de la placa TTGO T-Journal ESP32.

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos
Fuente de imagen

Conectores de cámara TTGO T-Journal ESP32

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

Aquí tenéis una tabla con las conexiones entre el ESP32 y la cámara:

cámara OV2640 ESP32
T2 – El segundo día GPIO 17
T3 – El maravilloso mundo de la locura GPIO35
T4 – El gran sueño GPIO34
T5 – El gran éxito GPIO5
T6 GPIO39
T7 – El gran sueño GPIO 18
T8 – El gran sueño GPIO36
T9 – El maravilloso mundo de la locura GPIO 19
SIOC GPIO23
SIOD GPIO25
XCLK GPIO27
VSYNC GPIO22
HREF GPIO26
PCLK GPIO21
primero GPIO 15
PWDN GPIO 0

Entonces, el pinout en tu boceto de Arduino debería verse así:

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

Dado que esta placa usa la misma cámara que la placa ESP32-CAM, los ejemplos para ESP32-CAM (que no usan una tarjeta microSD) también deberían funcionar con el TTGO T-Journal cambiando la definición del pin. Le mostraremos algunos ejemplos de inmediato.

Conectores OLED de placa TTGO T-Journal ESP32

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

Esta placa está equipada con una pantalla OLED I2C SSD1306 de 0,91 pulgadas. Para interactuar con la pantalla puede Adafruta SSD1306El pantalla oled ssd1306 u otras bibliotecas compatibles. Normalmente utilizamos el Adafruit SSD1306 junto con el Adafruit_GFX para interactuar con pantallas OLED.

El OLED se comunica con el ESP32 a través de los siguientes pines:

OLED ESP32
ASD GPIO 14
SCL GPIO 13

Pantalla OLED de control de placa TTGO T-Journal ESP32

En esta sección, le mostraremos consejos rápidos sobre cómo controlar la pantalla OLED de la placa TTGO T-Journal ESP32.

Instalación de bibliotecas

Para controlar la pantalla OLED utilizamos el Adafruta SSD1306 Y Adafruit GFX Bibliotecas. Estas bibliotecas se pueden instalar a través del administrador de bibliotecas Arduino IDE.

Vaya a su IDE de Arduino Bosquejo > incluir biblioteca > Administrar bibliotecas. Luego busque el nombre de la biblioteca e instálela.

Pines OLED I2C y tamaño de pantalla

Controlar esta pantalla OLED es similar a controlar una pantalla OLED normal de 0,96 conectada a un ESP32. La única diferencia es la forma en que inicializa la pantalla.

Debes considerar los pines I2C utilizados por esta pantalla (ya que no usa los pines I2C estándar) y el tamaño de la pantalla.

  • Pines I2C:
    • SDA (GPIO 14)
    • SCL (GPIO 13)
  • Tamaño de pantalla:
    • Ancho: 128 píxeles
    • Altura: 32 píxeles

boceto de arduino

Para controlar la pantalla OLED, primero debe importar las bibliotecas requeridas:

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Definir tamaño OLED:

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32

Defina los pines I2C:

#define I2C_SDA 14
#define I2C_SCL 13

A continuación, crea uno Adafruit_SSD1306 Objeto nombrado Anuncio como sigue:

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

En el configuración()necesita inicializar una comunicación I2C en los pines I2C que definió previamente de la siguiente manera:

Wire.begin(I2C_SDA, I2C_SCL);

Luego inicialice la pantalla OLED de la siguiente manera:

if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C, false, false)) {
  Serial.println(F("SSD1306 allocation failed"));
  for(;;);
}

Una vez que la pantalla se haya inicializado correctamente, podrá utilizar las funciones habituales de escribir texto y mostrar formas en la pantalla OLED. Lea nuestro tutorial OLED con ESP32 para obtener más información sobre cómo interactuar con la pantalla OLED.

Para fines de prueba, puede cargar el siguiente código en su tablero. Simplemente muestra «Hola mundo».

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/ttgo-t-journal-esp32-camera-getting-started/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
#define I2C_SDA 14
#define I2C_SCL 13

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

void setup() {
  
  Wire.begin(I2C_SDA, I2C_SCL);

  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C, false, false)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }
  
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 0);
  display.print("Hello World!");;
  display.display();
}

void loop() {
  // put your main code here, to run repeatedly:
}

Ver código sin formato

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

Proyectos de cámara TTGO T-Journal ESP32

Hemos modificado algunos de nuestros proyectos CAM ESP32 existentes para que sean compatibles con TTGO T-Journal.

Servidor web de transmisión de vídeo

El siguiente código crea un servidor web de transmisión de video en la dirección IP de la cámara. A continuación le mostramos cómo puede crear una cámara IP que se pueda integrar en plataformas de automatización del hogar como Home Assistant o Node-RED.

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/ttgo-t-journal-esp32-camera-getting-started/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include "esp_camera.h"
#include <WiFi.h>
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "fb_gfx.h"
#include "soc/soc.h" //disable brownout problems
#include "soc/rtc_cntl_reg.h"  //disable brownout problems
#include "esp_http_server.h"

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
#define I2C_SDA 14
#define I2C_SCL 13

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

//Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

#define PART_BOUNDARY "123456789000000000000987654321"

// OV2640 camera module pins (CAMERA_MODEL_TTGO-T-Journal)
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM     27
#define SIOD_GPIO_NUM     25
#define SIOC_GPIO_NUM     23
#define Y9_GPIO_NUM       19
#define Y8_GPIO_NUM       36
#define Y7_GPIO_NUM       18
#define Y6_GPIO_NUM       39
#define Y5_GPIO_NUM       5
#define Y4_GPIO_NUM       34
#define Y3_GPIO_NUM       35
#define Y2_GPIO_NUM       17
#define VSYNC_GPIO_NUM    22
#define HREF_GPIO_NUM     26
#define PCLK_GPIO_NUM     21

static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
static const char* _STREAM_BOUNDARY = "rn--" PART_BOUNDARY "rn";
static const char* _STREAM_PART = "Content-Type: image/jpegrnContent-Length: %urnrn";

httpd_handle_t stream_httpd = NULL;

static esp_err_t stream_handler(httpd_req_t *req){
  camera_fb_t * fb = NULL;
  esp_err_t res = ESP_OK;
  size_t _jpg_buf_len = 0;
  uint8_t * _jpg_buf = NULL;
  char * part_buf[64];

  res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
  if(res != ESP_OK){
    return res;
  }

  while(true){
    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      res = ESP_FAIL;
    } else {
      if(fb->width > 400){
        if(fb->format != PIXFORMAT_JPEG){
          bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
          esp_camera_fb_return(fb);
          fb = NULL;
          if(!jpeg_converted){
            Serial.println("JPEG compression failed");
            res = ESP_FAIL;
          }
        } else {
          _jpg_buf_len = fb->len;
          _jpg_buf = fb->buf;
        }
      }
    }
    if(res == ESP_OK){
      size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);
      res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
    }
    if(res == ESP_OK){
      res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
    }
    if(res == ESP_OK){
      res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
    }
    if(fb){
      esp_camera_fb_return(fb);
      fb = NULL;
      _jpg_buf = NULL;
    } else if(_jpg_buf){
      free(_jpg_buf);
      _jpg_buf = NULL;
    }
    if(res != ESP_OK){
      break;
    }
    //Serial.printf("MJPG: %uBn",(uint32_t)(_jpg_buf_len));
  }
  return res;
}

void startCameraServer(){
  httpd_config_t config = HTTPD_DEFAULT_CONFIG();
  config.server_port = 80;

  httpd_uri_t index_uri = {
    .uri       = "/",
    .method    = HTTP_GET,
    .handler   = stream_handler,
    .user_ctx  = NULL
  };
  
  //Serial.printf("Starting web server on port: '%d'n", config.server_port);
  if (httpd_start(&stream_httpd, &config) == ESP_OK) {
    httpd_register_uri_handler(stream_httpd, &index_uri);
  }
}

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector
 
  Serial.begin(115200);
  Serial.setDebugOutput(false);
  
  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(psramFound()){
    config.frame_size = FRAMESIZE_UXGA;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    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);
    return;
  }
  // Wi-Fi connection
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  
  Serial.print("Camera Stream Ready! Go to: http://");
  Serial.print(WiFi.localIP());

  // Init OLED
  Wire.begin(I2C_SDA, I2C_SCL);

  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C, false, false)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(5, 5);
  display.print(WiFi.localIP());;
  display.display();
  
  // Start streaming web server
  startCameraServer();
}

void loop() {
  delay(1);
}

Ver código sin formato

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

Obtenga más información sobre este proyecto: Servidor web de transmisión de video ESP32-CAM

Tome una foto y muéstrela en el servidor web.

El siguiente código crea un servidor web al que puede acceder para tomar y ver fotografías. La dirección IP del servidor web se muestra en la pantalla OLED.

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/ttgo-t-journal-esp32-camera-getting-started/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include "WiFi.h"
#include "esp_camera.h"
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "soc/soc.h"           // Disable brownour problems
#include "soc/rtc_cntl_reg.h"  // Disable brownour problems
#include "driver/rtc_io.h"
#include <ESPAsyncWebServer.h>
#include <StringArray.h>
#include <SPIFFS.h>
#include <FS.h>

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
#define I2C_SDA 14
#define I2C_SCL 13

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Create AsyncWebServer object on port 80
AsyncWebServer server(80);

boolean takeNewPhoto = false;

// Photo File Name to save in SPIFFS
#define FILE_PHOTO "/photo.jpg"

// OV2640 camera module pins (CAMERA_MODEL_TTGO-T-Journal)
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM     27
#define SIOD_GPIO_NUM     25
#define SIOC_GPIO_NUM     23
#define Y9_GPIO_NUM       19
#define Y8_GPIO_NUM       36
#define Y7_GPIO_NUM       18
#define Y6_GPIO_NUM       39
#define Y5_GPIO_NUM       5
#define Y4_GPIO_NUM       34
#define Y3_GPIO_NUM       35
#define Y2_GPIO_NUM       17
#define VSYNC_GPIO_NUM    22
#define HREF_GPIO_NUM     26
#define PCLK_GPIO_NUM     21

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    body { text-align:center; }
    .vert { margin-bottom: 10%; }
    .hori{ margin-bottom: 0%; }
  </style>
</head>
<body>
  <div id="container">
    <h2>ESP32-CAM Last Photo</h2>
    <p>It might take more than 5 seconds to capture a photo.</p>
    <p>
      <button onclick="rotatePhoto();">ROTATE</button>
      <button onclick="capturePhoto()">CAPTURE PHOTO</button>
      <button onclick="location.reload();">REFRESH PAGE</button>
    </p>
  </div>
  <div><img src="saved-photo" id="photo" width="70%"></div>
</body>
<script>
  var deg = 0;
  function capturePhoto() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', "/capture", true);
    xhr.send();
  }
  function rotatePhoto() {
    var img = document.getElementById("photo");
    deg += 90;
    if(isOdd(deg/90)){ document.getElementById("container").className = "vert"; }
    else{ document.getElementById("container").className = "hori"; }
    img.style.transform = "rotate(" + deg + "deg)";
  }
  function isOdd(n) { return Math.abs(n % 2) == 1; }
</script>
</html>)rawliteral";

void setup() {
  // Serial port for debugging purposes
  Serial.begin(115200);

  // Connect to Wi-Fi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  if (!SPIFFS.begin(true)) {
    Serial.println("An Error has occurred while mounting SPIFFS");
    ESP.restart();
  }
  else {
    delay(500);
    Serial.println("SPIFFS mounted successfully");
  }

  // Print ESP32 Local IP Address
  Serial.print("IP Address: http://");
  Serial.println(WiFi.localIP());

  // Init OLED
  Wire.begin(I2C_SDA, I2C_SCL);

  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C, false, false)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(5, 5);
  display.print(WiFi.localIP());;
  display.display();


  // Turn-off the 'brownout detector'
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);

  // OV2640 camera module
  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 (psramFound()) {
    config.frame_size = FRAMESIZE_UXGA;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    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);
    ESP.restart();
  }

  // Route for root / web page
  server.on("/", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send_P(200, "text/html", index_html);
  });

  server.on("/capture", HTTP_GET, [](AsyncWebServerRequest * request) {
    takeNewPhoto = true;
    request->send_P(200, "text/plain", "Taking Photo");
  });

  server.on("/saved-photo", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send(SPIFFS, FILE_PHOTO, "image/jpg", false);
  });

  // Start server
  server.begin();

}

void loop() {
  if (takeNewPhoto) {
    capturePhotoSaveSpiffs();
    takeNewPhoto = false;
  }
  delay(1);
}

// Check if photo capture was successful
bool checkPhoto( fs::FS &fs ) {
  File f_pic = fs.open( FILE_PHOTO );
  unsigned int pic_sz = f_pic.size();
  return ( pic_sz > 100 );
}

// Capture Photo and Save it to SPIFFS
void capturePhotoSaveSpiffs( void ) {
  camera_fb_t * fb = NULL; // pointer
  bool ok = 0; // Boolean indicating if the picture has been taken correctly

  do {
    // Take a photo with the camera
    Serial.println("Taking a photo...");

    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      return;
    }

    // Photo file name
    Serial.printf("Picture file name: %sn", FILE_PHOTO);
    File file = SPIFFS.open(FILE_PHOTO, FILE_WRITE);

    // Insert the data in the photo file
    if (!file) {
      Serial.println("Failed to open file in writing mode");
    }
    else {
      file.write(fb->buf, fb->len); // payload (image), payload length
      Serial.print("The picture has been saved in ");
      Serial.print(FILE_PHOTO);
      Serial.print(" - Size: ");
      Serial.print(file.size());
      Serial.println(" bytes");
    }
    // Close the file
    file.close();
    esp_camera_fb_return(fb);

    // check if file has been correctly saved in SPIFFS
    ok = checkPhoto(SPIFFS);
  } while ( !ok );
}

Ver código sin formato

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

Obtenga más información sobre este proyecto: ESP32-CAM Tome una foto y muéstrela en el servidor web

Ejemplo de CameraWebServer

También puede ejecutar el ejemplo estándar CameraWebServer que viene con el IDE de Arduino. Vaya a su IDE de Arduino archivo > Ejemplos > ESP32 > cámara y ábrelo CámaraServidorWeb Ejemplo.

Puede hacer clic en el siguiente enlace para descargar el archivo ZIP con el código final:

De lo contrario, tendrá que cambiar la asignación de pines del TTGO T-Journal Camera_Pins.h Pestaña.

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

Copie lo siguiente en el archivo camera_pins.h.

#if defined(CAMERA_MODEL_T_JOURNAL)
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM     27
#define SIOD_GPIO_NUM     25
#define SIOC_GPIO_NUM     23

#define Y9_GPIO_NUM       19
#define Y8_GPIO_NUM       36
#define Y7_GPIO_NUM       18
#define Y6_GPIO_NUM       39
#define Y5_GPIO_NUM       5
#define Y4_GPIO_NUM       34
#define Y3_GPIO_NUM       35
#define Y2_GPIO_NUM       17
#define VSYNC_GPIO_NUM    22
#define HREF_GPIO_NUM     26
#define PCLK_GPIO_NUM     21

Luego, en la pestaña CameraWebServer, comente todos los modelos de cámara existentes y agregue su cámara de la siguiente manera:

// Select camera model
#define CAMERA_MODEL_T_JOURNAL
//#define CAMERA_MODEL_WROVER_KIT
//#define CAMERA_MODEL_ESP_EYE
//#define CAMERA_MODEL_M5STACK_PSRAM
//#define CAMERA_MODEL_M5STACK_WIDE
//#define CAMERA_MODEL_AI_THINKER

Dado que esta cámara no tiene PSRAM, las funciones de captura y detección de rostros de este proyecto no funcionarán con esta cámara. Todas las demás funciones funcionan bien.

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

Subir código a la cámara TTGO T-Journal ESP32

Para cargar código, solo necesitas conectar la placa a tu computadora y luego en el IDE de Arduino. Herramientas > Puerto y seleccione el puerto COM al que está conectado.

Luego tienes que elegir un modelo de tabla. El TTGO T-Journal no está disponible en los modelos ESP32. Por lo tanto seleccione las siguientes configuraciones:

  • Tablón: “Módulo de recuperación ESP32”
  • Esquema de partición: “Aplicación enorme (3 MB, sin OTA)”
Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

Luego simplemente haga clic en el botón de carga de Arduino IDE y ¡listo!

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

[eBook] Crea proyectos CAM ESP32 con Arduino IDE

Aprenda a programar y crear proyectos con ESP32-CAM usando Arduino IDE 17 DESCARGAR «

Aprenda a programar y crear proyectos con ESP32-CAM usando Arduino IDE 17 DESCARGAR «

Envolver

Este tutorial fue una guía rápida para comenzar con la placa de desarrollo de cámara TTGO T-Journal ESP32. Aprendió a controlar la pantalla OLED y adaptar proyectos de cámara ESP32 existentes a su placa.

Esperamos que este tutorial te haya resultado útil. Para obtener más información sobre esta placa, puede leer nuestra revisión completa en Maker Advisor, así como nuestra publicación comparativa de la placa de desarrollo ESP32 CAM:

También te pueden interesar otras placas de desarrollo ESP32:

Gracias por leer.

Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded

Cámara TTGO T-Journal ESP32: Programador incorporado, OLED, antena y ejemplos de proyectos

Este es una guía de inicio para la placa de desarrollo de cámara TTGO T-Journal ESP32. La TTGO T-Journal cuenta con una cámara OV2640, una pantalla OLED, varios GPIO para conectar periféricos y un programador incorporado que facilita la carga de código. Echaremos un vistazo rápido a la placa de desarrollo de cámara y aprenderemos cómo programarla usando Arduino IDE.

¿Dónde Comprar?

Puede visitar la página de TTGO T-Journal en Maker Advisor para comparar la placa en diferentes tiendas.

TTGO T-Journal ESP32 Cámara + OLED + Antena + Programador Incorporado

Introducción a la TTGO T-Journal ESP32 Cámara

La TTGO T-Journal es una placa de desarrollo de cámara ESP32 de $12- $15 con una cámara OV2640, una antena, una pantalla OLED de 0.91 pulgadas I2C SSD1306, algunos GPIO expuestos y una interfaz micro-USB que facilita y agiliza la carga de código en la placa.

Para una visión general completa de esta placa, puede ver el siguiente video o leer este artículo: Reseña de la Placa de Desarrollo de Cámara TTGO T-Journal ESP32.

Características de la TTGO T-Journal ESP32

Aquí tienes un resumen de las características de la TTGO T-Journal:

  • Chipset ESPRESSIF-ESP32-PCIO-D4 procesador de microcontrolador LX6 de 32 bits de doble núcleo a 240 MHz FLASH QSPI flash/SRAM, hasta 4 x 16 MB SRAM 512 kB SRAM
  • Botón de reinicio y botón en GPIO 32
  • Pantalla OLED SSD1306 de 0.91 pulgadas
  • Indicador de encendido LED rojo
  • USB a TTL CP2104 (puedes cargar el código a través del cable USB)
  • Cámara OV2640 de 2 megapíxeles
  • Servo analógico de dirección (viene con dos juegos de pines ideales para conectar servos)
  • Voltaje de trabajo: 2.3V-3.6V
  • Corriente de trabajo: aproximadamente 160 mA
  • Tamaño: 64.57 mm x 23.98 mm

Especificaciones de la fuente de alimentación:

  • Fuente de alimentación USB 5V/1A
  • Corriente de carga 1A
  • Batería 3.7V batería de litio

Lea nuestra reseña detallada: Placa de Desarrollo de Cámara TTGO T-Journal ESP32.

Pinout de la Placa TTGO T-Journal ESP32

Tener el pinout correcto para tu placa de cámara es muy importante. Si no asignas los pines de la cámara correctamente en tu código, la cámara no funcionará. La siguiente imagen muestra el pinout de la placa TTGO T-Journal ESP32.

Aquí tienes una tabla con las conexiones entre el ESP32 y la cámara:

Cámara OV2640 ESP32
D2 GPIO 17
D3 GPIO 35
D4 GPIO 34
D5 GPIO 5
D6 GPIO 39
D7 GPIO 18
D8 GPIO 36
D9 GPIO 19
SIOC GPIO 23
SIOD GPIO 25
XCLK GPIO 27
VSYNC GPIO 22
HREF GPIO 26
PCLK GPIO 21

Por lo tanto, la asignación de pines en tu boceto de Arduino debería ser la siguiente:

define PWDN_GPIO_NUM 32

define RESET_GPIO_NUM -1

define XCLK_GPIO_NUM 27

define SIOD_GPIO_NUM 25

define SIOC_GPIO_NUM 23

define Y9_GPIO_NUM 19

define Y8_GPIO_NUM 36

define Y7_GPIO_NUM 18

define Y6_GPIO_NUM 39

define Y5_GPIO_NUM 5

define Y4_GPIO_NUM 34

define Y3_GPIO_NUM 35

define Y2_GPIO_NUM 17

define VSYNC_GPIO_NUM 22

define HREF_GPIO_NUM 26

define PCLK_GPIO_NUM 21

Debido a que esta placa utiliza la misma cámara que la placa ESP32-CAM, los ejemplos para ESP32-CAM (que no utilizan tarjeta microSD) también deberían funcionar con la TTGO T-Journal cambiando la definición de los pines. Te mostraremos un par de ejemplos en un momento.

Conexiones de la Pantalla OLED de la Placa TTGO T-Journal ESP32

Esta placa viene con una pantalla OLED de 0,91 pulgadas I2C SSD1306. Para interactuar con la pantalla, puedes usar las librerías Adafruit SSD1306, oled-ssd1306 u otras librerías compatibles. Normalmente usamos Adafruit SSD1306 junto con Adafruit_GFX para interactuar con las pantallas OLED.

La OLED se comunica con el ESP32 utilizando los siguientes pines I2C:

OLED ESP32
SDA GPIO 14
SCL GPIO 13

Control de la Pantalla OLED de la Placa TTGO T-Journal ESP32

En esta sección, te mostraremos algunos consejos rápidos sobre cómo controlar la pantalla OLED de la placa TTGO T-Journal ESP32.

Instalación de Librerías

Para controlar la pantalla OLED, utilizaremos las librerías Adafruit SSD1306 y Adafruit GFX. Estas librerías se pueden instalar a través del Administrador de Librerías de Arduino IDE.

En tu Arduino IDE, ve a Sketch > Include Library > Manage Libraries. Luego, busca el nombre de la librería e instálala.

Pines I2C y Tamaño de la Pantalla

Controlar esta pantalla OLED es similar a controlar una pantalla OLED de 0.96 conectada a un ESP32. La única diferencia está en la forma en que inicializas la pantalla.

Debes tener en cuenta los pines I2C utilizados por esta pantalla (porque no utiliza los pines I2C predeterminados) y el tamaño de la pantalla.

  • Pines I2C:
    • SDA (GPIO 14)
    • SCL (GPIO 13)
  • Tamaño de la pantalla:
    • Ancho: 128 px
    • Alto: 32 px

Sketch de Arduino

Para controlar la pantalla OLED, primero debes importar las librerías necesarias:

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Define el tamaño de la OLED:

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32

Define los pines I2C:

#define I2C_SDA 14
#define I2C_SCL 13

A continuación, crea un objeto Adafruit_SSD1306 llamado display de la siguiente manera:

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

En el setup(), debes inicializar una comunicación I2C en los pines I2C que has definido anteriormente:

Wire.begin(I2C_SDA, I2C_SCL);

Luego, inicializa la pantalla OLED de la siguiente manera:

if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C, false, false)) {
  Serial.println(F("SSD1306 allocation failed"));
  for(;;);
}

Después de inicializar correctamente la pantalla, puedes usar las funciones habituales para escribir texto y mostrar formas en la OLED. Lee nuestro tutorial de OLED con ESP32 para aprender más sobre cómo interactuar con la pantalla OLED.

Para fines de prueba, puedes cargar el siguiente código en tu placa. Simplemente muestra "¡Hola Mundo!".

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
#define I2C_SDA 14
#define I2C_SCL 13

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

void setup() {

  Wire.begin(I2C_SDA, I2C_SCL);

  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C, false, false)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }

  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 0);
  display.print("Hello World!");;
  display.display();
}

void loop() {
  // put your main code here, to run repeatedly:
}

Proyectos de la Placa TTGO T-Journal ESP32 Cámara

Hemos modificado algunos de nuestros proyectos existentes de ESP32-CAM para que sean compatibles con la TTGO T-Journal.

Servidor de Vídeo en Streaming

El siguiente código crea un servidor web de streaming de vídeo en la dirección IP de la cámara. Así, puedes crear una cámara IP que se puede integrar en plataformas de domótica como Home Assistant o Node-RED.

// Código del servidor de vídeo en streaming aquí

Toma una Foto y Muéstrala en el Servidor Web

El siguiente código crea un servidor web al que puedes acceder para tomar y mostrar fotos. La dirección IP del servidor web se muestra en la OLED.

// Código para tomar una foto y mostrarla en un servidor web aquí

Ejemplo de la Aplicación CameraWebServer

También puedes ejecutar el ejemplo predeterminado de CameraWebServer que viene con el IDE de Arduino. En tu IDE de Arduino, ve a Archivo > Ejemplos > ESP32 > Cámara y abre el ejemplo CameraWebServer.

Para cargar el código en la TTGO T-Journal ESP32, asegúrese de agregar el pinout de la placa a la pestaña camera_pins.h.

Copie lo siguiente en el archivo camera_pins.h.

// Código del pinout de la CameraWebServer para la TTGO T-Journal ESP32 aquí

Luego, en la pestaña CameraWebServer, comente todos los modelos de cámaras existentes y agregue tu cámara, de la siguiente manera:

// Selecciona el modelo de la cámara
#define CAMERA_MODEL_T_JOURNAL
//#define CAMERA_MODEL_WROVER_KIT
//#define CAMERA_MODEL_ESP_EYE
//#define CAMERA_MODEL_M5STACK_PSRAM
//#define CAMERA_MODEL_M5STACK_WIDE
//#define CAMERA_MODEL_AI_THINKER

Debido a que esta cámara no tiene PSRAM, las funciones de reconocimiento facial y detección de esta aplicación no funcionarán con esta cámara. Todas las otras funcionalidades funcionan bien.

Para más detalles, visita nuestra página de referencia externa en Maker Advisor o nuestra comparación de placas de desarrollo ESP32-CAM:

Reseña de la Placa de Desarrollo de Cámara TTGO T-Journal ESP32
Comparación y Reseña de Placas de Desarrollo de Cámaras ESP32-CAM

Te puede interesar también otras placas de desarrollo ESP32:

¡Gracias por leer!

Conclusión

Este tutorial fue una guía rápida de inicio para la placa de desarrollo de cámara TTGO T-Journal ESP32. Has aprendido cómo controlar la pantalla OLED y cómo adaptar proyectos de cámaras ESP32 existentes a tu placa.

Esperamos que hayas encontrado útil este tutorial. Para aprender más sobre esta placa, puedes leer nuestra revisión completa en Maker Advisor, así como nuestra publicación de comparación de placas de desarrollo ESP32-CAM.

¡Gracias por leer!

Related Posts:

Deja un comentario