Detector de autos mal estacionados con ESP32-CAM: visión por IA y alerta a WhatsApp

#include "esp_camera.h"
#include "esp_tls.h"
#include "esp_crt_bundle.h"
#include "esp_sntp.h"
#include <WiFi.h>
#include <time.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
const char* WIFI_SSID = "your_ssid";
const char* WIFI_PASS = "your_password";
const char* API_KEY   = "your_api_key";
const char* PHONE     = "91---------";
// ─── Tuning Parameters ────────────────────────────────────────────
#define PIXEL_DIFF_THRESHOLD  30  
#define MOTION_THRESHOLD      350 
#define UPLOAD_COOLDOWN_MS    10000UL
#define BUZZER_PIN            4   //  Assigned to GPIO 4
#define LED_PIN               2   // Added external/flash LED to GPIO 2
#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
// ─── Shared State ─────────────────────────────────────────────────
static uint8_t* g_imgBuf   = nullptr;
static size_t   g_imgLen   = 0;
static uint8_t* previousFrame = NULL;
static size_t   motionFrameSize = 0;
static char     g_status[64]    = "Unknown Vehicle";
static char     g_imageUrl[256] = "";
static char     g_jsonBuf[2048] = {};
static SemaphoreHandle_t g_startSem = nullptr;
static SemaphoreHandle_t g_doneSem  = nullptr;
static unsigned long lastUploadTime = 0;

static bool setupMotionBaseline()
 {
 camera_fb_t *fb = esp_camera_fb_get();
 if (!fb) {
   Serial.println("[CAM] Warning: Failed to acquire baseline frame. Retrying...");
   return false;
 }
 motionFrameSize = fb->len;
 if (previousFrame != NULL) {
   free(previousFrame);
   previousFrame = NULL;
 }
 previousFrame = (uint8_t *)malloc(motionFrameSize);
 if (previousFrame) {
   memcpy(previousFrame, fb->buf, motionFrameSize);
 }
 esp_camera_fb_return(fb);
 return (previousFrame != NULL);
}

static bool tlsWriteAll(esp_tls_t* tls, const uint8_t* buf, size_t len) {
 size_t sent = 0;
 while (sent < len) {
   int n = esp_tls_conn_write(tls, buf + sent, len - sent);
   if (n < 0) return false;
   sent += n;
 }
 return true;
}
static size_t tlsReadAll(esp_tls_t* tls, char* buf, size_t maxLen) {
 size_t total = 0;
 uint32_t t = millis();
 while (total < maxLen - 1) {
   if (millis() - t > 15000) break;
   int n = esp_tls_conn_read(tls, buf + total, maxLen - 1 - total);
   if (n == 0) break;
   if (n == ESP_TLS_ERR_SSL_WANT_READ) { vTaskDelay(pdMS_TO_TICKS(10)); continue; }
   if (n < 0) break;
   total += n; t = millis();
 }
 buf[total] = '\0';
 return total;
}
static esp_tls_t* openTLS(const char* host, int port) {
 esp_tls_cfg_t cfg = {};
 cfg.crt_bundle_attach = esp_crt_bundle_attach;
 esp_tls_t* tls = esp_tls_init();
 if (!tls) return nullptr;
 if (esp_tls_conn_new_sync(host, strlen(host), port, &cfg, tls) == 1) return tls;
 esp_tls_conn_destroy(tls);
 return nullptr;
}

static bool detectVehicle() {
 const char* host = "www.circuitdigest.cloud";
 const char* bnd  = "----ESP32Boundary";
 const char* classesParam = "[\"car\",\"truck\",\"bus\",\"motorcycle\"]";
 const char* confidenceParam = "0.40";
 char phHead[256];
 int phLen = snprintf(phHead, sizeof(phHead),
   "--%s\r\nContent-Disposition: form-data; name=\"imageFile\"; filename=\"photo.jpg\"\r\nContent-Type: image/jpeg\r\n\r\n", bnd);
 char classesPart[256];
 int cpLen = snprintf(classesPart, sizeof(classesPart),
   "\r\n--%s\r\nContent-Disposition: form-data; name=\"classes\"\r\n\r\n%s\r\n", bnd, classesParam);
 char confPart[128];
 int coLen = snprintf(confPart, sizeof(confPart),
   "--%s\r\nContent-Disposition: form-data; name=\"confidence\"\r\n\r\n%s\r\n", bnd, confidenceParam);
 char ptTail[64];
 int ptLen = snprintf(ptTail, sizeof(ptTail), "--%s--\r\n", bnd);
 size_t contentLen = phLen + g_imgLen + cpLen + coLen + ptLen;
 char reqHdr[512];
 int reqLen = snprintf(reqHdr, sizeof(reqHdr),
   "POST /api/v1/object-detection/detect HTTP/1.1\r\n"
   "Host: %s\r\nAuthorization: %s\r\n" 
   "Content-Type: multipart/form-data; boundary=%s\r\n"
   "Content-Length: %u\r\nConnection: close\r\n\r\n",
   host, API_KEY, bnd, (unsigned)contentLen);
 esp_tls_t* tls = openTLS(host, 443);
 if (!tls) return false;
 bool ok =
   tlsWriteAll(tls, (const uint8_t*)reqHdr, reqLen) &&
   tlsWriteAll(tls, (const uint8_t*)phHead, phLen) &&
   tlsWriteAll(tls, g_imgBuf, g_imgLen) &&
   tlsWriteAll(tls, (const uint8_t*)classesPart, cpLen) &&
   tlsWriteAll(tls, (const uint8_t*)confPart, coLen) &&
   tlsWriteAll(tls, (const uint8_t*)ptTail, ptLen);
 static char respBuf[3072];
 if (ok) tlsReadAll(tls, respBuf, sizeof(respBuf));
 esp_tls_conn_destroy(tls);
 if (!ok) return false;
 char* bodyStart = strstr(respBuf, "\r\n\r\n");
 if (!bodyStart) return false;
 bodyStart += 4;
 while (*bodyStart && ((*bodyStart >= '0' && *bodyStart <= '9') || (*bodyStart >= 'a' && *bodyStart <= 'f') || (*bodyStart >= 'A' && *bodyStart <= 'F'))) bodyStart++;
 if (*bodyStart == '\r') bodyStart += 2;
 size_t bodyLen = strlen(bodyStart);
 if (bodyLen >= sizeof(g_jsonBuf)) bodyLen = sizeof(g_jsonBuf) - 1;
 memcpy(g_jsonBuf, bodyStart, bodyLen);
 g_jsonBuf[bodyLen] = '\0';
 Serial.printf("[API Response] %s\n", g_jsonBuf);
 return g_jsonBuf[0] != '\0';
}

static bool parseVehicleDetails() {
 const char* j = g_jsonBuf;
 g_imageUrl[0] = '\0';
 bool vehicleFound = false;
 
 if (strstr(j, "\"class_name\":\"car\""))        { strncpy(g_status, "Car Arrived", sizeof(g_status));        vehicleFound = true; }
 else if (strstr(j, "\"class_name\":\"truck\""))   { strncpy(g_status, "Truck Arrived", sizeof(g_status));      vehicleFound = true; }
 else if (strstr(j, "\"class_name\":\"bus\""))     { strncpy(g_status, "Bus Arrived", sizeof(g_status));        vehicleFound = true; }
 else if (strstr(j, "\"class_name\":\"motorcycle\"")){ strncpy(g_status, "Motorcycle Arrived", sizeof(g_status)); vehicleFound = true; }
 if (!vehicleFound) {
   return false; 
 }
 const char* url_key = "\"annotated_image_url\":\"";
 const char* ui = strstr(j, url_key);
 if (ui) {
   const char* vs = ui + strlen(url_key);
   const char* ve = strchr(vs, '"');
   if (ve && ve > vs) {
     size_t len = ve - vs;
     if (len >= sizeof(g_imageUrl)) len = sizeof(g_imageUrl) - 1;
     strncpy(g_imageUrl, vs, len);
     g_imageUrl[len] = '\0';
     char* p = g_imageUrl; char* q = g_imageUrl;
     while(*p) { if(*p == '\\' && *(p+1) == '/') p++; *q++ = *p++; }
     *q = '\0';
   }
 }
 return true;
}

static void sendWhatsApp() {
 const char* host = "www.circuitdigest.cloud";
 char ts[64] = "Time Unknown";
 struct tm ti;
 if (getLocalTime(&ti, 500)) strftime(ts, sizeof(ts), "%I:%M %p, %B %d, %Y", &ti);
 char reqBody[1024];
 int bodyLen = snprintf(reqBody, sizeof(reqBody),
   "{"
     "\"phone_number\":\"%s\","
     "\"template_id\":\"image_capture_alert\"," 
     "\"variables\":{"
       "\"event_type\":\"%s\","
       "\"location\":\"Driveway Intersection\","
       "\"device_name\":\"ESP32-CAM Vehicle Node\","
       "\"captured_time\":\"%s\","
       "\"image_link\":\"%s\"" 
     "}"
   "}",
   PHONE, g_status, ts, g_imageUrl);
 char reqHdr[512];
 int reqLen = snprintf(reqHdr, sizeof(reqHdr),
   "POST /api/v1/whatsapp/send HTTP/1.1\r\n"
   "Host: %s\r\nAuthorization: %s\r\n" 
   "Content-Type: application/json\r\n"
   "Content-Length: %u\r\nConnection: close\r\n\r\n",
   host, API_KEY, (unsigned)bodyLen);
 esp_tls_t* tls = openTLS(host, 443);
 if (!tls) return;
 tlsWriteAll(tls, (const uint8_t*)reqHdr, reqLen);
 tlsWriteAll(tls, (const uint8_t*)reqBody, bodyLen);
 static char respBuf[512];
 tlsReadAll(tls, respBuf, sizeof(respBuf));
 esp_tls_conn_destroy(tls);
 
 Serial.printf("[WhatsApp Gateway Status] Success transmission logged\n");
}

void setup() {
 Serial.begin(115200);
 vTaskDelay(pdMS_TO_TICKS(500));
 Serial.println("\n=== Async Vehicle Tracker Deployed ===");
 // Setup both Alert Pins cleanly
 pinMode(BUZZER_PIN, OUTPUT);
 pinMode(LED_PIN, OUTPUT);
 digitalWrite(BUZZER_PIN, LOW);
 digitalWrite(LED_PIN, LOW);
 WiFi.mode(WIFI_STA);
 WiFi.setSleep(false);
 WiFi.begin(WIFI_SSID, WIFI_PASS);
 while (WiFi.status() != WL_CONNECTED) { vTaskDelay(pdMS_TO_TICKS(500)); Serial.print("."); }
 Serial.printf("\n[Network Connected] IP: %s\n", WiFi.localIP().toString().c_str());
 configTime(19800, 0, "pool.ntp.org", "time.nist.gov"); 
 struct tm timeinfo;
 getLocalTime(&timeinfo, 5000);
 g_startSem = xSemaphoreCreateBinary();
 g_doneSem  = xSemaphoreCreateBinary();
 if (setCameraSensingMode(PIXFORMAT_GRAYSCALE, FRAMESIZE_QQVGA, 12)) {
   Serial.println("[System Status] Waking up camera engine...");
   vTaskDelay(pdMS_TO_TICKS(1000)); 
   while (!setupMotionBaseline()) {
     vTaskDelay(pdMS_TO_TICKS(500));
   }
   Serial.println("[System Status] Low-power scanning baseline monitoring armed...");
 }
 xTaskCreatePinnedToCore(networkTask, "net_task", 8192, nullptr, 5, nullptr, 0);
}

void loop() {
 if (previousFrame == NULL || motionFrameSize == 0) {
   vTaskDelay(pdMS_TO_TICKS(100));
   return;
 }
 camera_fb_t *fb = esp_camera_fb_get();
 if (!fb) { vTaskDelay(pdMS_TO_TICKS(100)); return; }
 int changedPixels = 0;
 for (size_t i = 0; i < motionFrameSize; i += 8) {
   int diff = abs((int)fb->buf[i] - (int)previousFrame[i]);
   if (diff > PIXEL_DIFF_THRESHOLD) { changedPixels++; }
 }
 bool coolingDown = (millis() - lastUploadTime < UPLOAD_COOLDOWN_MS);
 if (!coolingDown && (changedPixels > MOTION_THRESHOLD)) {
   esp_camera_fb_return(fb);
   
   Serial.printf("\n[Alert] Tripwire activated (%d). Locking scan engine.\n", changedPixels);
   Serial.println("Holding 2 seconds for target stabilization...");
   vTaskDelay(pdMS_TO_TICKS(2000));
   if (setCameraSensingMode(PIXFORMAT_JPEG, FRAMESIZE_VGA, 10)) {
     vTaskDelay(pdMS_TO_TICKS(600)); 
     camera_fb_t* flushFb = esp_camera_fb_get();
     if(flushFb) esp_camera_fb_return(flushFb);
     camera_fb_t* captureFb = esp_camera_fb_get();
     if (captureFb) {
       g_imgLen = captureFb->len;
       g_imgBuf = (uint8_t*)malloc(g_imgLen);
       if (g_imgBuf) {
         memcpy(g_imgBuf, captureFb->buf, g_imgLen);
         esp_camera_fb_return(captureFb);
         xSemaphoreGive(g_startSem);
         xSemaphoreTake(g_doneSem, portMAX_DELAY);
         return;
       }
       esp_camera_fb_return(captureFb);
     }
   }
   setCameraSensingMode(PIXFORMAT_GRAYSCALE, FRAMESIZE_QQVGA, 12);
   while (!setupMotionBaseline()) { vTaskDelay(pdMS_TO_TICKS(200)); }
 } else {
   if (motionFrameSize == fb->len) {
     memcpy(previousFrame, fb->buf, motionFrameSize);
   }
   esp_camera_fb_return(fb);
   vTaskDelay(pdMS_TO_TICKS(150));
 }
}