ESP32 avec caméra

International Français
1

Bonjour à toutes et à tous,

J'aimerais m'amuser avec des modules ESP32/caméra dans le but d'"essayer" de faire de la corrélation d'images en mode vidéo.

J'ai vu qu'il y a deux types de caméra : OV2640 et OV5640.

La première étant plus rapide mais avec moins de définition (qualités et réglages).

Mon but serait de faire une corrélation (par blocs ?) à une cadence de 2 ou 3 par secondes.

Dans ces conditions, quel ESP32 et caméra me conseillez-vous.

Quelle est la focale de ces caméras ? Existe-t-il des complément optiques pour augmenter cette focale.

Merci pour vos renseignements.

Pierre.

2

vous pouvez regarder ce qu'il se fait côté Arducam

Ils proposent une gamme de lentilles M12 compatibles avec les modules ESP32-CAM, avec différentes focales pour ajuster le champ de vision selon vos besoins, du grand angle au téléobjectif.

L’ESP32 est plus rapide qu’un Arduino Uno mais ce n’est pas une plateforme très puissante comparée à un ordinateur ou un Raspberry Pi. Faire une corrélation d’images à 2 ou 3 Hz reste réaliste si vous travaillez avec une résolution réduite (peut être 320x240 pixels ou moins) mais bon ça dépend de l'approche retenue. Si au lieu de comparer pixel par pixel toute l’image, on compare bloc par bloc, ça réduit la quantité de calculs à faire.

3

Merci J-M-L pour ces infos.

Je pense acheter ce modèle avec la caméra OV2640 ; je n'ai pas besoin d'une grande définition. Qu'en pensez-vous ?

Cordialement.

Pierre.

4

Oui ça a l’air de correspondre au besoin. Au prix où c’est, il n’y a pas bcp de risques

5

J'ai effondré ma trésorerie en en achetant deux :upside_down_face:

J'ai écrit une fonction de corrélation de Pearson :

float correlation (uint16_t nb, float *x, float *y) {
  float xm = 0, ym = 0;
  float num = 0;
  float denX = 0, denY = 0;
  for (uint16_t i = 0; i < nb; i++) {
    xm += x[i];
    ym += y[i];
  }
  xm = xm/N;
  ym = ym/N;
  for (uint16_t i = 0; i < nb; i++) {
    num += (x[i]-xm)*(y[i]-ym);
    denX += pow((x[i]-xm), 2);
    denY += pow((y[i]-ym), 2);
  }
  return num/sqrt(denX*denY);
}

Avec un ESP32_WROOM-DA, il faut pratiquement 10 ms pour traiter un tableau de 4096 points !

Cordialement.

Pierre.

6

Essayez avec

float correlation(uint16_t nb, float *x, float *y) {
  float sumX = 0, sumY = 0;
  float sumX2 = 0, sumY2 = 0;
  float sumXY = 0;
  for (uint16_t i = 0; i < nb; i++) {
    sumX += x[i];
    sumY += y[i];
    sumX2 += x[i] * x[i];
    sumY2 += y[i] * y[i];
    sumXY += x[i] * y[i];
  }
  float xm = sumX / nb;
  float ym = sumY / nb;
  float num = sumXY - nb * xm * ym;
  float denX = sumX2 - nb * xm * xm;
  float denY = sumY2 - nb * ym * ym;
  return num / sqrtf(denX * denY);
}

L’usage de pow() est coûteux et on évite une passe et l’optimiseur doit conserver les données en cache et regrouper les calculs. Ça devrait aller plus vite.

7

J'avais déjà vu que cette fonction était une abomination, mais je n'y ai pas pris garde. Je ne sais pas à partir de quelle puissance elle est plus performante. En tous cas, le simple fait de remplacer le pow() par une multiplication fait passer de 9300 µs à 654 µS !! Un gain de 15.

Utilisant votre formulation, je passe à 364 µS et compactant les derniers calculs en deux lignes (trouvé grâce à Perplexity):

float correlation(int n, float x[], float y[]) {
    float sum_x = 0, sum_y = 0, sum_x2 = 0, sum_y2 = 0, sum_xy = 0;
    for (int i = 0; i < n; i++) {
        sum_x += x[i];
        sum_y += y[i];
        sum_x2 += x[i]*x[i];
        sum_y2 += y[i]*y[i];
        sum_xy += x[i]*y[i];
    }
    float numerator = n*sum_xy - sum_x*sum_y;
    float denominator = sqrt((n*sum_x2 - sum_x*sum_x) * (n*sum_y2 - sum_y*sum_y));
    return numerator / denominator;
}

je passe à 330 µS. Soit pratiquement un gain de 30 !!

NOTA : le fait de passer des float à des double fait repasser le temps à 10300 µS !

Merci de cette proposition.

Pierre.

8

Pas mal!!

9

J'ai acheté deux modules ESP32 équipés de caméra ov2640.

Mes premiers essais avec le sketch ESP32/camera/cameraWebServer sont infructueux.

J'ai essayé avec différents modules Espressif :

  1. ESP32S3 Dev Module ;
  2. ESP32S3 Dev Module Octal(WROOM2)
  3. ESP32-S3-Box
  4. ESP32-S3-USB-OTG
  5. ESP32S3 CAM LCD
  6. AI THINKER ESP-CAM

Avec le module 1, ça reboot en permanence à l'abord de cette instruction : esp_err_t err = esp_camera_init(&config); avec un message :

Guru Meditation Error: Core  1 panic'ed (LoadProhibited). Exception was unhandled.

et tout les données qui vont avec

Avec le module 6 : à la compilation, ça me dit :

A fatal error occurred: This chip is ESP32-S3, not ESP32. Wrong chip argument?
Failed uploading: uploading error: exit status 2

Avec les autres, ça reboot sans information ou ça ne fait rien.

Toutefois, j'ai vu que le PSRAM était du type OPI et non QSPI.

Pour la caméra, j'ai vu (Perplexity) que l'ov2640 correspondait au choix : CAMERA_MODEL_AI_THINKER

Là, je ne sais plus trop quoi faire. Quelle carte choisir, est-ce la caméra choisie est la bonne, la configuration camera_config_t config; est-elle la bonne ?

Trop de choix. J'aurais tendance à dire que le problème est un problème de config. Est-ce que ce sont les bons GPIO affectés à config.

Avez-vous des idées ?

Cordialement.

Pierre.

10

Je n’ai pas de s3 mais chatGPT dit

Très bien. Vous utilisez donc une carte ESP32-S3 WROOM N16R8 CAM avec caméra OV2640. Ce module utilise une PSRAM en mode OPI et n’est pas compatible directement avec le sketch cameraWebServer conçu pour les ESP32 classiques.

Voici les GPIO utilisés par défaut sur cette carte :

XCLK = GPIO10

SIOD = GPIO40

SIOC = GPIO39

D7 = GPIO48

D6 = GPIO38

D5 = GPIO11

D4 = GPIO12

D3 = GPIO14

D2 = GPIO47

D1 = GPIO13

D0 = GPIO21

VSYNC = GPIO41

HREF = GPIO42

PCLK = GPIO9

PWDN = -1

RESET = -1

Dans l’IDE Arduino, vous devez choisir la carte ESP32S3 Dev Module, activer la PSRAM si l’option est proposée, et vous assurer que le support OPI est bien activé. Si ce n’est pas le cas, il faut mettre à jour les cartes Espressif dans le gestionnaire de cartes.

Le sketch cameraWebServer d’origine n’est pas prévu pour ce module. Vous devez modifier la structure camera_config_t avec les bonnes affectations GPIO, et vous assurer que les options de PSRAM sont bien compatibles avec le module.

À voir s’il a raison…

#include "esp_camera.h"
#include <WiFi.h>

const char* ssid = "VOTRE_SSID";
const char* password = "VOTRE_MOT_DE_PASSE";

#define PWDN_GPIO_NUM    -1
#define RESET_GPIO_NUM   -1
#define XCLK_GPIO_NUM    10
#define SIOD_GPIO_NUM    40
#define SIOC_GPIO_NUM    39

#define Y9_GPIO_NUM      48
#define Y8_GPIO_NUM      38
#define Y7_GPIO_NUM      11
#define Y6_GPIO_NUM      12
#define Y5_GPIO_NUM      14
#define Y4_GPIO_NUM      47
#define Y3_GPIO_NUM      13
#define Y2_GPIO_NUM      21

#define VSYNC_GPIO_NUM   41
#define HREF_GPIO_NUM    42
#define PCLK_GPIO_NUM     9

void startCameraServer();

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(200);
  }

  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;
  }

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

  startCameraServer();
  Serial.print("Camera ready. Stream URL: http://");
  Serial.print(WiFi.localIP());
  Serial.println(":80");
}

void loop() {}

#include <WebServer.h>

WebServer server(80);

void handle_jpg_stream(void) {
  WiFiClient client = server.client();
  camera_fb_t *fb = NULL;
  String response = "HTTP/1.1 200 OK\r\nContent-Type: multipart/x-mixed-replace; boundary=frame\r\n\r\n";
  client.print(response);
  while (true) {
    fb = esp_camera_fb_get();
    if (!fb) {
      continue;
    }
    client.printf("--frame\r\nContent-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n", fb->len);
    client.write(fb->buf, fb->len);
    client.print("\r\n");
    esp_camera_fb_return(fb);
    if (!client.connected()) break;
  }
}

void startCameraServer() {
  server.on("/", HTTP_GET, []() {
    server.send(200, "text/html", "<img src=\"/stream\">");
  });
  server.on("/stream", HTTP_GET, handle_jpg_stream);
  server.begin();
}
11

Merci pour cette recherche et pour cette proposition. Malheureusement, ça ne fonctionne toujours pas.

J'avais dit :

J'aurais tendance à dire que le problème est un problème de config. Est-ce que ce sont les bons GPIO affectés à config.

Cela s'avère. En effet, j'ai réussi à trouver le pinout de ma carte et j'ai appliqué ces valeurs : avec l'application cameraWebServer et celle proposée par chatGpt, la caméra est reconnue.

Me connectant cette fois par WiFi, le site est fonctionnel avec l'application cameraWebServer, mais pas avec celle proposée par chatGpt.

Au cas où il y aurait de potentiels clients du module ESP32 que j'ai, voici les données à inclure :

dans board_congig.h : #define CAMERA_MODEL_OV2640_ESP32S3 // Has PSRAM en commentant toutes les autres caméras ;

dans camera_pins.h :

#elif defined(CAMERA_MODEL_OV2640_ESP32S3)
#define PWDN_GPIO_NUM  -1
#define RESET_GPIO_NUM -1
#define XCLK_GPIO_NUM  15
#define SIOD_GPIO_NUM  4
#define SIOC_GPIO_NUM  5

#define Y9_GPIO_NUM    16
#define Y8_GPIO_NUM    17
#define Y7_GPIO_NUM    18
#define Y6_GPIO_NUM    12
#define Y5_GPIO_NUM    10
#define Y4_GPIO_NUM    8
#define Y3_GPIO_NUM    9
#define Y2_GPIO_NUM    11
#define VSYNC_GPIO_NUM 6
#define HREF_GPIO_NUM  7
#define PCLK_GPIO_NUM  13

NOTA : la puissance WiFi de ces cartes est minable : ile faut que je tienne l'antenne imprimée entres mes doigts pour que la liaison se fasse.

Cordialement.

Pierre.

12

Merci pour le test

13

Je pense que j'avais un autre problème ; ça fonctionne correctement.

Pour autant, si tout cet ensemble fonctionne correctement en mode JPG, ça ne veut rien savoir en mode RGB565 ou en GRAYSCALE.

J'ai essayé tout un tas de configurations, mais je tombe toujours sur :

Camera init OK 0x0E (731) cam_hal: DMA overflow

Je suppose que le DMA a rien à voir avec la PSRAM( 16Mo). En effet, quelle que soit la taille que je choisis : toujours inférieure à 640 x 480, ce qui fait au maxi : 640 x 480 = 307 ko, on est loin des 16 Mo de PSRAM. Que représente donc ce DMA et comment s'affranchir de ce problème.

Cordialement.

Pierre

14

Le capteur OV2640 encode en JPEG matériellement, ce qui réduit fortement le volume de données à transférer et évite les débordements DMA. En revanche, en mode RGB565 ou GRAYSCALE, le flux brut est bien plus volumineux, je pense que c'est ce qui provoque un dépassement de la capacité DMA ou mémoire du système

essayez une résolution basse, comme FRAMESIZE_QQVGA ou FRAMESIZE_QVGA. Vous pouvez aussi essayer de réduire la fréquence xclk_freq_hz dans camera_config_t à 10 ou 8 MHz.

Le DMA (Direct Memory Access) est un mécanisme qui permet à un périphérique (comme votre caméra) de transférer des données directement vers ou depuis la mémoire, sans passer par le CPU.

Cela évite que le CPU soit bloqué à copier des données octets par octets, ce qui améliore considérablement les performances, surtout pour les transferts volumineux ou rapides.

Le DMA fonctionne avec des canaux configurés pour écouter un périphérique (source), et lorsqu’un événement se produit (comme une fin de ligne d’image), il transfère automatiquement un bloc de données en mémoire (destination). Pendant ce temps, le CPU peut exécuter d’autres tâches.

Pour que cela fonctionne, le DMA doit être bien configuré ➜ adresse source, adresse de destination, taille, déclencheur, priorité... Un débordement (overflow comme vous avez) signifie que les données arrivent plus vite que ce que le DMA ou la mémoire peut gérer.

==> c'est donc quand même potentiellement lié à la mémoire et à la PSRAM mais pas au niveau de la taille (enfin, peut-être que les buffers sont inadaptés)

15

J'ai un peu essayé tout un tas de configurations avec peu de pixels et un horloge descendu jusqu'à 2 MHz. J'ai même augmenté config.fb_count /*!< Number of frame buffers to be allocated. If more than one, then each frame will be acquired (double speed) */ jusqu'à 10. J'ai aussi changé la mémoire de transfert en config.fb_location = CAMERA_FB_IN_DRAM;. Rien n'y fait, toujours le même message :

Camera init OK 0x0E (829) cam_hal: DMA overflow
Guru Meditation Error: Core  0 panic'ed (Unhandled debug exception). 
Debug exception reason: Stack canary watchpoint triggered (cam_task)

C'est comme si tous ces paramètres étaient ignorés dans ces modes.

Cordialement.

Pierre.

16

Désolé je n’ai pas d’autres idées.,,

17

Ne soyez pas désolé. Le problème vient de la dernière version 3.3.0 ESP32 Espressif.

Je suis revenu à la précédente 3.2.1 et tout fonctionne bien.

J'avais déjà eu des problèmes (autres) avec des précédentes versions. Chaque nouvelle version amène son lot de correctifs :slightly_smiling_face:... et son lot de bugs :frowning_face:.

Cordialement.

Pierre.

18

Cool.