Tracker HTTP

<?php
// si GET['addr'] est renseigné, c'est l'esp qui envoie son IP
if(isset($_GET["addr"])) file_put_contents("ip",$_GET["addr"]);
?>

Code ESP32

• Se connecte automatiquement au Wifi,
• indique au tracker son IP sur le réseau local,
• lance un serveur web,
• puis à chaque requête /img allume le flash, prend une photo et l'envoie.

/*
Pour installer les librairies ESPAsyncWebServer et AsyncTCP, Télécharger
https://github.com/me-no-dev/ESPAsyncWebServer/
https://github.com/me-no-dev/AsyncTCP
Puis Menu Croquis/inclure blbliothèque/Add zip
*/
// se connecter à http://ip/picture
// faire F5 ou page autorefresh

#include "esp_camera.h"
#include <WiFi.h>
#include "ESPAsyncWebServer.h"
#include <HTTPClient.h>
 
#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
#define LED_BLANCHE 4
/*============================================================*/
AsyncWebServer server(80);
/*============================================================*/
bool initCamera(){

  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; 
  config.frame_size   = FRAMESIZE_SVGA;
  config.jpeg_quality = 10;
  config.fb_count = 1;

  pinMode(LED_BLANCHE, OUTPUT);
  
  esp_err_t result = esp_camera_init(&config);
  return (result != ESP_OK) ? false : true;
}
/*============================================================*/
void envoiIPAuServeur(IPAddress ip){

  char url[59];
  HTTPClient http;
  int httpCode;

  Serial.print("ip:"); Serial.println(ip);
  sprintf(url, "https://apps.masta.fr/cam/tracker.php?addr=%u.%u.%u.%u", ip[0],ip[1],ip[2],ip[3]);
  Serial.println(url);
  http.begin(url);
  httpCode = http.GET();
  if (httpCode==200) { http.end(); return; }
  Serial.println("Error on HTTP request");
  String payload = http.getString();
  Serial.println(httpCode);
  Serial.println(payload);
  http.end();
  return;
}
/*============================================================*/
void setup() {
  Serial.begin(115200);
 
  if(!initCamera()){
    Serial.printf("Echec initialiser camera.");
    return;  
  }
   
  WiFi.begin("AndroidAP", "mot_de_passe");
  Serial.print("Connexion au WiFi");

  while (WiFi.status() != WL_CONNECTED){
    delay(1000);
    Serial.print(".");
  }

  envoiIPAuServeur(WiFi.localIP());
 
  server.on("/img", HTTP_GET, [](AsyncWebServerRequest* request){
      digitalWrite(LED_BLANCHE, HIGH);
      delay(300);
      camera_fb_t* frame = esp_camera_fb_get();
      digitalWrite(LED_BLANCHE, LOW);
      request->send_P(200, "image/jpeg", (const uint8_t *)frame->buf, frame->len);
      esp_camera_fb_return(frame);
  });

  server.on("/im", HTTP_GET, [](AsyncWebServerRequest* request){
      camera_fb_t* frame= esp_camera_fb_get();
      request->send_P(200, "image/jpeg", (const uint8_t *)frame->buf, frame->len);
      esp_camera_fb_return(frame);
  });

  server.begin();
}
 
void loop(){}

1re méthode, la plus simple

• http://xxx.xxx.xxx.xxx/img avec flash
• http://xxx.xxx.xxx.xxx/im sans flash

2e méthode

<title>Cam impr 3D</title>

<div style="width:800px;margin:auto;">

    <img id="img" style="width:800px;height:600px" src=""/><br>

    <div style="float:left">
        intervalle image refresh <span id="intervalle"></span>s
        <button onclick="setIntervalle()">-</button>
        <button onclick="setIntervalle(true)">+</button>
    </div>
    
    Flash <input type="checkbox" id="flash"/>
    
    <div style="float:right">
        <button onclick="seconds=0">Reset temps</button>
        <span id="duree"></span>
    </div>

</div>

<script>
const divduree = document.getElementById("duree");
let seconds = 0; // nombre de secondes écoulées

const divinterval = document.getElementById("intervalle");
let interval = 5;// secondes entre chaque appel d'image
let cpt = 0; // quand cpt arrivera à 5, demander une image
divinterval.textContent = interval;
const flash = document.getElementById("flash");
const divimg = document.getElementById("img");

function setIntervalle(plus=false){
    if(plus) interval++; else interval--;
    divinterval.textContent = interval;
}

// une fois par seconde rafraichit l'heure, puis demande une image à chaque intervalle
setInterval(function () {
    seconds++;
    let str = '';

    if(seconds >= 3600){
        const heures = Math.floor(seconds  3600);
        const nbHenS =  heures * 3600;
        const mn = Math.floor((seconds - nbHenS)60);
        const nbMnEnS = mn * 60
        const s = seconds - nbHenS - mn*60;
        str = heures+'h '+mn+'mn'+s+'s';
    }
    else if(seconds >= 60){
        const mn = Math.floor(seconds/60);
        const s = seconds - mn*60;
        str = mn+'mn'+s+'s';
    }
    else str = seconds+'s';    

    divduree.textContent = str;

    cpt++;
    if(cpt >= interval){
        cpt = 0;
        const strflash = (flash.checked) ? "g" : "";
        divimg.src = "http://<?php echo $ip; ?>/im"+strflash+"?"+ new Date().getTime();
    }

}, 1000);
</script>

3e méthode: Timelapse, client langage C

// Client Caméra Wifi
// Préciser en argv l'intervalle en secondes (5 par défaut)
// exemple pour capturer une image toutes les 30 secondes:
// ./timelapse 30

#include <arpa/inet.h>
#include <assert.h>
#include <netdb.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

char ip[15];

/*============================================================================*/
// Se connecte au Tracker pour obtenir l'IP de l'ESP32-CAM.
// Problème: mon sous-domaine est automatiquement redirigé en HTTPS
// donc un simple wget puis lecture du fichier téléchargé
void getIpFromTracker(){

    FILE* fp;
    long lSize;

    system("wget -q https://apps.masta.fr/camerawifi/ip");

    fp = fopen ("ip", "r"); if(fp==NULL) exit(1);
    fseek(fp, 0, SEEK_END);
    lSize = ftell(fp);
    rewind(fp);
     fread (ip,1,lSize,fp);
    fclose(fp);

    system("rm ip");
}
/*============================================================================*/
// Se connecte au port 80 et retourne un socket connecté
int connexionHTTP(){

    int sk = -1;
    struct protoent *protoent;
    struct hostent *hostent;
    in_addr_t in_addr;
    struct sockaddr_in sockaddr_in;

    // Build the socket
    protoent = getprotobyname("tcp");
    if (protoent == NULL) { perror("getprotobyname"); exit(EXIT_FAILURE);}
    sk = socket(AF_INET, SOCK_STREAM, protoent->p_proto);
    if (sk == -1) {perror("socket");exit(EXIT_FAILURE);}

    // Build the address
    hostent = gethostbyname(ip);
    if (hostent == NULL) {fprintf(stderr, "error: gethostbyname(\"%s\")\n", ip); exit(EXIT_FAILURE);}
    in_addr = inet_addr(inet_ntoa(*(struct in_addr*)*(hostent->h_addr_list)));
    if (in_addr == (in_addr_t)-1) {fprintf(stderr, "error: inet_addr(\"%s\")\n", *(hostent->h_addr_list));exit(EXIT_FAILURE);}
    sockaddr_in.sin_addr.s_addr = in_addr;
    sockaddr_in.sin_family = AF_INET;
    sockaddr_in.sin_port = htons(80);

    // connexion maintenant
    if (connect(sk, (struct sockaddr*)&sockaddr_in, sizeof(sockaddr_in)) == -1) {perror("connect"); exit(EXIT_FAILURE);}

    return sk;
}
/*============================================================================*/
// Envoi de la requête HTTP, Réception et analyse de la réponse du serveur HTTP
void request_image(){

    char s[BUFSIZ];
    enum CONSTEXPR { MAX_REQUEST_LEN = 1024};
    char request[MAX_REQUEST_LEN];
    ssize_t nbytes_last;
    int contentLength=0, b=0, n, nbytes=0, octetsrecus = 0;
    char numpaquet=0, mot[10];
    FILE* fp = NULL;
    char nomimage[14]; // imgs/9999.jpg 13+1
    static int numimage = 0;

    // établit un point de communication full-duplex sur le port 80
    int sk = connexionHTTP();

    // Envoi de la requête HTTP
    n = snprintf(request, MAX_REQUEST_LEN, "GET /img HTTP/1.1\r\nHost: %s\r\n\r\n", ip);
    while (nbytes < n) {
        nbytes_last = write(sk, request + nbytes, n - nbytes);
        if (nbytes_last == -1) {perror("write");exit(EXIT_FAILURE);}
        nbytes += nbytes_last;
    }

    // Réception et analyse de la réponse du serveur HTTP
    while(1) {
        nbytes = read(sk, s, BUFSIZ);
        /* Premier paquet: le serveur répond
            HTTP/1.1 200 OK
            Content-Length: 28205
            Content-Type: image/jpeg
            Connection: close
            Accept-Ranges: none

            ligne vide puis le jpeg avec magic number header et pixels.
            Donc parse le 1er paquet pour déterminer le Content-length,
            écrire les premiers octets après l'en-tête HTTP du serveur
        */
        if(numpaquet==0){
            numpaquet=1;
            for(n=0; n<nbytes; n++){
                if(s[n]=='L' && s[n+1]=='e' && s[n+2]=='n' && s[n+3]=='g'){
                    n += 8;
                    while(s[n] != '\r' && s[n] != '\n') {mot[b++]=s[n++];}
                    mot[b] = 0;
                    contentLength = atoi(mot);
                    //printf("content-length:%d\n", contentLength);

                    // ouvre le fichier en écriture binaire
                    sprintf(nomimage,"imgs/%03d.jpg", numimage++);
                    fp = fopen(nomimage,"wb");

                    // poursuit jusqu'à la ligne vide de séparation...
                    while(n++){if(s[n] == '\n' && s[n+1] == '\r') break;} n+=3;
                    // pour copier les premiers octets de l'image jpeg
                    octetsrecus = nbytes-n;
                    fwrite (s+n, octetsrecus, 1, fp);
                    break;
                } 
            }
        }
        // sinon écriture du paquet entrant
        else {
            fwrite (s, nbytes, 1, fp);
            octetsrecus += nbytes;
        }
        //printf("paquet %d octets écrit %d sur %d\n", nbytes, octetsrecus, contentLength);

        // Vérifie s'il faut stopper grâce au content-length,
        // sinon ça part en timeout il bloque indéfiniment sur read()
        if(octetsrecus >= contentLength) break;
    }

    if(fp) fclose(fp);
    close(sk);
}
/*============================================================================*/
int main(int argc, char** argv) {

    int interval = 5; //secondes
    if(argc > 1) interval = atoi(argv[1]);

    getIpFromTracker();
    printf("IP from Tracker [%s]\nStart timelapse 1 image toutes les %d secondes ...\nCTRL-C pour quitter\n", ip, interval);

    // boucle périodique
    while(1){
        request_image();
        sleep(interval);
    }

    return 0;
}

Composants

Le boitier imprimé