Stamp-AddOn Cam0308 Arduino Tutorial

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

#define CAMERA_USE_AP_MODE 1

#if CAMERA_USE_AP_MODE
const char *ssid     = "Stamp-AddOn Cam0308";
const char *password = "12345678";
#else
const char *ssid     = "ssid";
const char *password = "password";
#endif

WebServer server(80);

#define PWDN_GPIO_NUM  39
#define RESET_GPIO_NUM 41
#define XCLK_GPIO_NUM  46
#define SIOD_GPIO_NUM  48
#define SIOC_GPIO_NUM  47

#define Y9_GPIO_NUM 40
#define Y8_GPIO_NUM 38
#define Y7_GPIO_NUM 12
#define Y6_GPIO_NUM 14
#define Y5_GPIO_NUM 15
#define Y4_GPIO_NUM 16
#define Y3_GPIO_NUM 18
#define Y2_GPIO_NUM 21

#define VSYNC_GPIO_NUM 42
#define HREF_GPIO_NUM  17
#define PCLK_GPIO_NUM  13

static camera_config_t camera_config = {
    .pin_pwdn     = PWDN_GPIO_NUM,
    .pin_reset    = RESET_GPIO_NUM,
    .pin_xclk     = XCLK_GPIO_NUM,
    .pin_sscb_sda = SIOD_GPIO_NUM,
    .pin_sscb_scl = SIOC_GPIO_NUM,
    .pin_d7       = Y9_GPIO_NUM,
    .pin_d6       = Y8_GPIO_NUM,
    .pin_d5       = Y7_GPIO_NUM,
    .pin_d4       = Y6_GPIO_NUM,
    .pin_d3       = Y5_GPIO_NUM,
    .pin_d2       = Y4_GPIO_NUM,
    .pin_d1       = Y3_GPIO_NUM,
    .pin_d0       = Y2_GPIO_NUM,

    .pin_vsync = VSYNC_GPIO_NUM,
    .pin_href  = HREF_GPIO_NUM,
    .pin_pclk  = PCLK_GPIO_NUM,

    .xclk_freq_hz = 20000000,
    .ledc_timer   = LEDC_TIMER_0,
    .ledc_channel = LEDC_CHANNEL_0,

    .pixel_format  = PIXFORMAT_RGB565,
    .frame_size    = FRAMESIZE_QVGA,
    // .frame_size    = FRAMESIZE_VGA,
    .jpeg_quality  = 20,
    .fb_count      = 2,
    .fb_location   = CAMERA_FB_IN_PSRAM,
    .grab_mode     = CAMERA_GRAB_WHEN_EMPTY,
    .sccb_i2c_port = -1,
};

static constexpr char STREAM_BOUNDARY[] = "123456789000000000000987654321";
static constexpr uint8_t JPEG_QUALITY   = 80;

static bool writeAll(WiFiClient &client, const uint8_t *data, size_t length)
{
    while (length > 0 && client.connected()) {
        const size_t written = client.write(data, length);
        if (written == 0) {
            return false;
        }
        data += written;
        length -= written;
        yield();
    }
    return length == 0;
}

static bool captureJpeg(uint8_t **jpgBuffer, size_t *jpgLength)
{
    camera_fb_t *fb = esp_camera_fb_get();
    if (!fb) {
        Serial.println("Camera capture failed");
        return false;
    }

    const bool converted = frame2jpg(fb, JPEG_QUALITY, jpgBuffer, jpgLength);
    esp_camera_fb_return(fb);

    if (!converted || !*jpgBuffer) {
        Serial.println("JPEG convert failed");
        return false;
    }
    return true;
}

static bool cameraBegin()
{
    pinMode(PWDN_GPIO_NUM, OUTPUT);
    digitalWrite(PWDN_GPIO_NUM, LOW);

    pinMode(RESET_GPIO_NUM, OUTPUT);
    digitalWrite(RESET_GPIO_NUM, LOW);
    delay(20);
    digitalWrite(RESET_GPIO_NUM, HIGH);
    delay(100);

    const esp_err_t err = esp_camera_init(&camera_config);
    if (err != ESP_OK) {
        Serial.printf("Camera Init Fail: 0x%x\r\n", err);
        return false;
    }

    sensor_t *sensor = esp_camera_sensor_get();
    if (!sensor) {
        Serial.println("Camera sensor get failed");
        esp_camera_deinit();
        return false;
    }

    Serial.println("Camera Init Success");
    return true;
}

static void handleCapture()
{
    WiFiClient client  = server.client();
    uint8_t *jpgBuffer = nullptr;
    size_t jpgLength   = 0;

    if (!captureJpeg(&jpgBuffer, &jpgLength)) {
        server.send(503, "text/plain", "Camera capture failed\n");
        return;
    }

    client.println("HTTP/1.1 200 OK");
    client.println("Content-Type: image/jpeg");
    client.printf("Content-Length: %u\r\n", static_cast<unsigned int>(jpgLength));
    client.println("Content-Disposition: inline; filename=capture.jpg");
    client.println("Cache-Control: no-store, no-cache, must-revalidate");
    client.println("Pragma: no-cache");
    client.println("Access-Control-Allow-Origin: *");
    client.println("Connection: close");
    client.println();

    writeAll(client, jpgBuffer, jpgLength);
    free(jpgBuffer);
    client.stop();
}

static void handleStream()
{
    WiFiClient client   = server.client();
    int64_t lastFrameUs = esp_timer_get_time();

    client.println("HTTP/1.1 200 OK");
    client.printf("Content-Type: multipart/x-mixed-replace; boundary=%s\r\n", STREAM_BOUNDARY);
    client.println("Cache-Control: no-store, no-cache, must-revalidate");
    client.println("Pragma: no-cache");
    client.println("Access-Control-Allow-Origin: *");
    client.println("Connection: close");
    client.println();

    while (client.connected()) {
        uint8_t *jpgBuffer = nullptr;
        size_t jpgLength   = 0;
        if (!captureJpeg(&jpgBuffer, &jpgLength)) {
            delay(30);
            continue;
        }

        client.printf("--%s\r\n", STREAM_BOUNDARY);
        client.println("Content-Type: image/jpeg");
        client.printf("Content-Length: %u\r\n\r\n", static_cast<unsigned int>(jpgLength));
        const bool sent = writeAll(client, jpgBuffer, jpgLength);
        free(jpgBuffer);

        if (!sent || client.print("\r\n") == 0) {
            break;
        }

        const int64_t nowUs       = esp_timer_get_time();
        const int64_t frameTimeMs = (nowUs - lastFrameUs) / 1000;
        lastFrameUs               = nowUs;
        const float fps           = frameTimeMs > 0 ? 1000.0f / frameTimeMs : 0.0f;
        Serial.printf("MJPG: %uKB %lldms (%.1ffps)\r\n", static_cast<unsigned int>(jpgLength / 1024), frameTimeMs, fps);
        yield();
    }

    client.stop();
}

static IPAddress startWiFi()
{
#if CAMERA_USE_AP_MODE
    WiFi.mode(WIFI_AP);
    if (!WiFi.softAP(ssid, password)) {
        Serial.println("WiFi AP start failed");
        return IPAddress();
    }

    const IPAddress ip = WiFi.softAPIP();
    Serial.printf("WiFi AP: %s\r\n", ssid);
    Serial.printf("IP address: %s\r\n", ip.toString().c_str());
    return ip;
#else
    WiFi.mode(WIFI_STA);
    WiFi.setSleep(false);
    WiFi.begin(ssid, password);

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

    Serial.println();
    const IPAddress ip = WiFi.localIP();
    Serial.printf("IP address: %s\r\n", ip.toString().c_str());
    return ip;
#endif
}

void setup()
{
    Serial.begin(115200);
    delay(1000);

    if (!cameraBegin()) {
        while (true) {
            delay(1000);
        }
    }

    const IPAddress ip = startWiFi();
    if (ip == IPAddress()) {
        while (true) {
            delay(1000);
        }
    }

    server.on("/", HTTP_GET, handleStream);
    server.on("/stream", HTTP_GET, handleStream);
    server.on("/capture", HTTP_GET, handleCapture);
    server.onNotFound([]() { server.send(404, "text/plain", "Not found\n"); });
    server.begin();

    Serial.println("Camera HTTP server started");
    Serial.printf("Stream:  http://%s/stream\r\n", ip.toString().c_str());
    Serial.printf("Capture: http://%s/capture\r\n", ip.toString().c_str());
}

void loop()
{
    server.handleClient();
    delay(1);
}