M5_Cam-test.ino

// Copyright 2015-2017 Espressif Systems (Shanghai) PTE LTD

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "freertos/FreeRTOS.h"

#include "freertos/task.h"

#include "freertos/semphr.h"

#include "freertos/event_groups.h"

#include "esp_system.h"

#include "esp_wifi.h"

#include "esp_event_loop.h"

#include "esp_log.h"

#include "esp_err.h"

#include "nvs_flash.h"

#include "driver/gpio.h"

extern "C" {

    #include "camera.h"

    #include "bitmap.h"

    #include "http_server.h"

}

/* The examples use simple WiFi configuration that you can set via

   'make menuconfig'.

   If you'd rather not, just change the below entries to strings with

   the config you want - ie #define EXAMPLE_WIFI_SSID "mywifissid"

 0x20001 | ESP_ERR_CAMERA_NOT_DETECTED | Check SCCB connection.

 0x20002 | ESP_ERR_CAMERA_FAILED_TO_SET_FRAME_SIZE | Check that resolution is supported.

 0x20003 | ESP_ERR_CAMERA_NOT_SUPPORTED | Check if camera-model is supported/activated.

*/

#define EXAMPLE_ESP_WIFI_MODE_AP true  // true:AP false:STA

#define EXAMPLE_ESP_WIFI_SSID "ESP32-CAM"

#define EXAMPLE_ESP_WIFI_PASS ""

//#define EXAMPLE_ESP_WIFI_MODE_AP false  // true:AP false:STA

//#define EXAMPLE_ESP_WIFI_SSID "xxxxxxx" 

//#define EXAMPLE_ESP_WIFI_PASS "xxxxxxx"

#define EXAMPLE_MAX_STA_CONN 1

#define CAMERA_LED_GPIO 16

#if EXAMPLE_ESP_WIFI_MODE_AP

static void wifi_init_softap(void);

#else

static void wifi_init_sta(void);

#endif 

static void handle_grayscale_pgm(http_context_t http_ctx, void* ctx);

static void handle_rgb_bmp(http_context_t http_ctx, void* ctx);

static void handle_rgb_bmp_stream(http_context_t http_ctx, void* ctx);

static void handle_jpg(http_context_t http_ctx, void* ctx);

static void handle_jpg_stream(http_context_t http_ctx, void* ctx);

static esp_err_t event_handler(void *ctx, system_event_t *event);

static const char* TAG = "camera_demo";

static const char* STREAM_CONTENT_TYPE =

        "multipart/x-mixed-replace; boundary=123456789000000000000987654321";

static const char* STREAM_BOUNDARY = "--123456789000000000000987654321";

static EventGroupHandle_t s_wifi_event_group;

const int CONNECTED_BIT = BIT0;

static ip4_addr_t s_ip_addr;

static camera_pixelformat_t s_pixel_format;

#define CAMERA_PIXEL_FORMAT CAMERA_PF_JPEG

#define CAMERA_FRAME_SIZE CAMERA_FS_SVGA

void setup()

{

    esp_log_level_set("wifi", ESP_LOG_INFO);

    esp_log_level_set("gpio", ESP_LOG_WARN);

    esp_log_level_set("isr", ESP_LOG_INFO);

    esp_log_level_set("http_server", ESP_LOG_NONE);

    esp_log_level_set("camera", ESP_LOG_INFO);

    esp_log_level_set("camera_xclk", ESP_LOG_NONE);

    esp_err_t err = nvs_flash_init();

    if (err != ESP_OK) {

        ESP_ERROR_CHECK( nvs_flash_erase() );

        ESP_ERROR_CHECK( nvs_flash_init() );

    }

    ESP_ERROR_CHECK(gpio_install_isr_service(0));

    gpio_set_direction(GPIO_NUM_16, GPIO_MODE_OUTPUT);

    gpio_set_level(GPIO_NUM_16, HIGH);

    camera_config_t camera_config = {

        .pin_reset = 15,

        .pin_xclk = 27,

        .pin_sscb_sda = 25,

        .pin_sscb_scl = 23,

        .pin_d7 = 19,

        .pin_d6 = 36,

        .pin_d5 = 18,

        .pin_d4 = 39,

        .pin_d3 = 5,

        .pin_d2 = 34,

        .pin_d1 = 35,

        .pin_d0 = 17,

        .pin_vsync = 22,

        .pin_href = 26,

        .pin_pclk = 21,

        .xclk_freq_hz = 8000000, 

        .ledc_timer = LEDC_TIMER_0,

        .ledc_channel = LEDC_CHANNEL_0,

    };

    camera_model_t camera_model;

    err = camera_probe(&camera_config, &camera_model);

    if (err != ESP_OK) {

        ESP_LOGE(TAG, "Camera probe failed with error 0x%x", err);

        return;

    }

    if (camera_model == CAMERA_OV7725) {

        s_pixel_format = CAMERA_PIXEL_FORMAT;

        camera_config.frame_size = CAMERA_FRAME_SIZE;

        ESP_LOGI(TAG, "Detected OV7725 camera, using %s bitmap format",

                CAMERA_PIXEL_FORMAT == CAMERA_PF_GRAYSCALE ?

                        "grayscale" : "RGB565");

    } else if (camera_model == CAMERA_OV2640) {

        ESP_LOGI(TAG, "Detected OV2640 camera, using JPEG format");

        s_pixel_format = CAMERA_PF_JPEG;

        camera_config.frame_size = CAMERA_FRAME_SIZE;

        camera_config.jpeg_quality = 15;

    } else {

        ESP_LOGE(TAG, "Camera not supported");

        return;

    }

    camera_config.pixel_format = s_pixel_format;

    err = camera_init(&camera_config);

    if (err != ESP_OK) {

        ESP_LOGE(TAG, "Camera init failed with error 0x%x", err);

        return;

    }

#if EXAMPLE_ESP_WIFI_MODE_AP

    ESP_LOGI(TAG, "ESP_WIFI_MODE_AP");

    wifi_init_softap();

#else

    ESP_LOGI(TAG, "ESP_WIFI_MODE_STA");

    wifi_init_sta();

    ESP_LOGI(TAG, "ESP_WIFI_MODE_STA");

#endif

    http_server_t server;

    http_server_options_t http_options = HTTP_SERVER_OPTIONS_DEFAULT();

    ESP_ERROR_CHECK( http_server_start(&http_options, &server) );

    if (s_pixel_format == CAMERA_PF_GRAYSCALE) {

        ESP_ERROR_CHECK( http_register_handler(server, "/pgm", HTTP_GET, HTTP_HANDLE_RESPONSE, &handle_grayscale_pgm, NULL) );

        ESP_LOGI(TAG, "Open http://" IPSTR "/pgm for a single image/x-portable-graymap image", IP2STR(&s_ip_addr));

    }

    if (s_pixel_format == CAMERA_PF_RGB565) {

        ESP_ERROR_CHECK( http_register_handler(server, "/bmp", HTTP_GET, HTTP_HANDLE_RESPONSE, &handle_rgb_bmp, NULL) );

        ESP_LOGI(TAG, "Open http://" IPSTR "/bmp for single image/bitmap image", IP2STR(&s_ip_addr));

        ESP_ERROR_CHECK( http_register_handler(server, "/bmp_stream", HTTP_GET, HTTP_HANDLE_RESPONSE, &handle_rgb_bmp_stream, NULL) );

        ESP_LOGI(TAG, "Open http://" IPSTR "/bmp_stream for multipart/x-mixed-replace stream of bitmaps", IP2STR(&s_ip_addr));

    }

    if (s_pixel_format == CAMERA_PF_JPEG) {

        ESP_ERROR_CHECK( http_register_handler(server, "/jpg", HTTP_GET, HTTP_HANDLE_RESPONSE, &handle_jpg, NULL) );

        ESP_LOGI(TAG, "Open http://" IPSTR "/jpg for single image/jpg image", IP2STR(&s_ip_addr));

        ESP_ERROR_CHECK( http_register_handler(server, "/jpg_stream", HTTP_GET, HTTP_HANDLE_RESPONSE, &handle_jpg_stream, NULL) );

        ESP_LOGI(TAG, "Open http://" IPSTR "/jpg_stream for multipart/x-mixed-replace stream of JPEGs", IP2STR(&s_ip_addr));

        ESP_ERROR_CHECK( http_register_handler(server, "/", HTTP_GET, HTTP_HANDLE_RESPONSE, &handle_jpg_stream, NULL) );

    }

    ESP_LOGI(TAG, "Free heap: %u", xPortGetFreeHeapSize());

    ESP_LOGI(TAG, "Camera demo ready");

}

void loop() {}

static esp_err_t write_frame(http_context_t http_ctx)

{

    http_buffer_t fb_data = {

            .data = camera_get_fb(),

            .size = camera_get_data_size(),

            .data_is_persistent = true

    };

    return http_response_write(http_ctx, &fb_data);

}

static void handle_grayscale_pgm(http_context_t http_ctx, void* ctx)

{

    esp_err_t err = camera_run();

    if (err != ESP_OK) {

        ESP_LOGD(TAG, "Camera capture failed with error = %d", err);

        return;

    }

    char* pgm_header_str;

    asprintf(&pgm_header_str, "P5 %d %d %d\n",

            camera_get_fb_width(), camera_get_fb_height(), 255);

    if (pgm_header_str == NULL) {

        return;

    }

    size_t response_size = strlen(pgm_header_str) + camera_get_data_size();

    http_response_begin(http_ctx, 200, "image/x-portable-graymap", response_size);

    http_response_set_header(http_ctx, "Content-disposition", "inline; filename=capture.pgm");

    http_buffer_t pgm_header = { .data = pgm_header_str };

    http_response_write(http_ctx, &pgm_header);

    free(pgm_header_str);

    write_frame(http_ctx);

    http_response_end(http_ctx);

}

static void handle_rgb_bmp(http_context_t http_ctx, void* ctx)

{

    esp_err_t err = camera_run();

    if (err != ESP_OK) {

        ESP_LOGD(TAG, "Camera capture failed with error = %d", err);

        return;

    }

    bitmap_header_t* header = bmp_create_header(camera_get_fb_width(), camera_get_fb_height());

    if (header == NULL) {

        return;

    }

    http_response_begin(http_ctx, 200, "image/bmp", sizeof(*header) + camera_get_data_size());

    http_buffer_t bmp_header = {

            .data = header,

            .size = sizeof(*header)

    };

    http_response_set_header(http_ctx, "Content-disposition", "inline; filename=capture.bmp");

    http_response_write(http_ctx, &bmp_header);

    free(header);

    write_frame(http_ctx);

    http_response_end(http_ctx);

}

static void handle_jpg(http_context_t http_ctx, void* ctx)

{

    esp_err_t err = camera_run();

    if (err != ESP_OK) {

        ESP_LOGD(TAG, "Camera capture failed with error = %d", err);

        return;

    }

    http_response_begin(http_ctx, 200, "image/jpeg", camera_get_data_size());

    http_response_set_header(http_ctx, "Content-disposition", "inline; filename=capture.jpg");

    write_frame(http_ctx);

    http_response_end(http_ctx);

}

static void handle_rgb_bmp_stream(http_context_t http_ctx, void* ctx)

{

    http_response_begin(http_ctx, 200, STREAM_CONTENT_TYPE, HTTP_RESPONSE_SIZE_UNKNOWN);

    bitmap_header_t* header = bmp_create_header(camera_get_fb_width(), camera_get_fb_height());

    if (header == NULL) {

        return;

    }

    http_buffer_t bmp_header = {

            .data = header,

            .size = sizeof(*header)

    };

    while (true) {

        esp_err_t err = camera_run();

        if (err != ESP_OK) {

            ESP_LOGD(TAG, "Camera capture failed with error = %d", err);

            return;

        }

        err = http_response_begin_multipart(http_ctx, "image/bitmap",

                camera_get_data_size() + sizeof(*header));

        if (err != ESP_OK) {

            break;

        }

        err = http_response_write(http_ctx, &bmp_header);

        if (err != ESP_OK) {

            break;

        }

        err = write_frame(http_ctx);

        if (err != ESP_OK) {

            break;

        }

        err = http_response_end_multipart(http_ctx, STREAM_BOUNDARY);

        if (err != ESP_OK) {

            break;

        }

    }

    free(header);

    http_response_end(http_ctx);

}

static void handle_jpg_stream(http_context_t http_ctx, void* ctx)

{

    http_response_begin(http_ctx, 200, STREAM_CONTENT_TYPE, HTTP_RESPONSE_SIZE_UNKNOWN);

    while (true) {

        esp_err_t err = camera_run();

        if (err != ESP_OK) {

            ESP_LOGD(TAG, "Camera capture failed with error = %d", err);

            return;

        }

        err = http_response_begin_multipart(http_ctx, "image/jpg",

                camera_get_data_size());

        if (err != ESP_OK) {

            break;

        }

        err = write_frame(http_ctx);

        if (err != ESP_OK) {

            break;

        }

        err = http_response_end_multipart(http_ctx, STREAM_BOUNDARY);

        if (err != ESP_OK) {

            break;

        }

    }

    http_response_end(http_ctx);

}

// /* FreeRTOS event group to signal when we are connected*/

// static EventGroupHandle_t s_wifi_event_group;

// /* The event group allows multiple bits for each event,

//    but we only care about one event - are we connected

//    to the AP with an IP? */

// const int WIFI_CONNECTED_BIT = BIT0;

static esp_err_t event_handler(void* ctx, system_event_t* event) 

{

  switch (event->event_id) {

    case SYSTEM_EVENT_STA_START:

      esp_wifi_connect();

      break;

    case SYSTEM_EVENT_STA_GOT_IP:

      ESP_LOGI(TAG, "got ip:%s", ip4addr_ntoa(&event->event_info.got_ip.ip_info.ip));

      s_ip_addr = event->event_info.got_ip.ip_info.ip;

      xEventGroupSetBits(s_wifi_event_group, CONNECTED_BIT);

      break;

    case SYSTEM_EVENT_AP_STACONNECTED:

      ESP_LOGI(TAG, "station:" MACSTR " join, AID=%d", MAC2STR(event->event_info.sta_connected.mac),

               event->event_info.sta_connected.aid);

#if EXAMPLE_ESP_WIFI_MODE_AP

      xEventGroupSetBits(s_wifi_event_group, CONNECTED_BIT);

#endif

      break;

    case SYSTEM_EVENT_AP_STADISCONNECTED:

      ESP_LOGI(TAG, "station:" MACSTR "leave, AID=%d", MAC2STR(event->event_info.sta_disconnected.mac),

               event->event_info.sta_disconnected.aid);

#if EXAMPLE_ESP_WIFI_MODE_AP

      xEventGroupClearBits(s_wifi_event_group, CONNECTED_BIT);

#endif

      break;

    case SYSTEM_EVENT_STA_DISCONNECTED:

      esp_wifi_connect();

      xEventGroupClearBits(s_wifi_event_group, CONNECTED_BIT);

      break;

    default:

      break;

  }

  return ESP_OK;

}

#if EXAMPLE_ESP_WIFI_MODE_AP

static void wifi_init_softap() 

{

  s_wifi_event_group = xEventGroupCreate();

  tcpip_adapter_init();

  ESP_ERROR_CHECK(esp_event_loop_init(event_handler, NULL));

  wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();

  ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    wifi_config_t wifi_config;

    strcpy(reinterpret_cast<char*>(wifi_config.ap.ssid), EXAMPLE_ESP_WIFI_SSID);

    strcpy(reinterpret_cast<char*>(wifi_config.ap.password), EXAMPLE_ESP_WIFI_PASS);

    wifi_config.ap.ssid_len = strlen(EXAMPLE_ESP_WIFI_SSID);

    wifi_config.ap.max_connection = EXAMPLE_MAX_STA_CONN;

    wifi_config.ap.authmode = WIFI_AUTH_WPA2_PSK;

    if (strlen(EXAMPLE_ESP_WIFI_PASS) == 0) {

    wifi_config.ap.authmode = WIFI_AUTH_OPEN;

  }

  ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));

  ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_AP, &wifi_config));

  ESP_ERROR_CHECK(esp_wifi_start());

  uint8_t addr[4] = {192, 168, 4, 1};

  s_ip_addr = *(ip4_addr_t*)&addr;

  ESP_LOGI(TAG, "wifi_init_softap finished.SSID:%s password:%s",

           EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS);

}

#else

static void wifi_init_sta() 

{

    s_wifi_event_group = xEventGroupCreate();

    tcpip_adapter_init();

    ESP_ERROR_CHECK(esp_event_loop_init(event_handler, NULL));

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();

    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    //wifi_config_t wifi_config = {

    //    .sta = {.ssid = EXAMPLE_ESP_WIFI_SSID, .password = EXAMPLE_ESP_WIFI_PASS},

    //};

    wifi_config_t wifi_config { };

    strcpy((char*)wifi_config.sta.ssid, (const char*)EXAMPLE_ESP_WIFI_SSID);

    strcpy((char*)wifi_config.sta.password, (const char*)EXAMPLE_ESP_WIFI_PASS);

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));

    ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));

    ESP_ERROR_CHECK(esp_wifi_start());

    ESP_LOGI(TAG, "wifi_init_sta finished.");

    ESP_LOGI(TAG, "connect to ap SSID:%s password:%s", EXAMPLE_ESP_WIFI_SSID,

            EXAMPLE_ESP_WIFI_PASS);

    xEventGroupWaitBits(s_wifi_event_group, CONNECTED_BIT, false, true, portMAX_DELAY);

}

#endif