vcc_gnd
/
esp-who
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

🔥 remove old example structure

pull/190/head
Ye Hang Yang 2021-09-09 20:22:13 +08:00
parent 5653aea126
commit 9f86332250
52 changed files with 0 additions and 7243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
examples/camera_lcd/CMakeLists.txt
View File

@ -1,8 +0,0 @@
# The following lines of boilerplate have to be in your project's
# CMakeLists in this exact order for cmake to work correctly
cmake_minimum_required(VERSION 3.5)
set(EXTRA_COMPONENT_DIRS ../../components)
add_compile_options(-fdiagnostics-color=always)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(camera_lcd)

12
examples/camera_lcd/Makefile
View File

@ -1,12 +0,0 @@
#
# This is a project Makefile. It is assumed the directory this Makefile resides in is a
# project subdirectory.
#
PROJECT_NAME := camera_lcd
SOLUTION_PATH ?= $(abspath $(shell pwd))/../../..
include $(SOLUTION_PATH)/components/component_conf.mk
include $(IDF_PATH)/make/project.mk

0
examples/camera_lcd/README.rst
View File

41
examples/camera_lcd/README_cn.rst
View File

@ -1,41 +0,0 @@
################################################################################################################################
Camera with LCD `[English] <./README.rst>`_
################################################################################################################################
该示例的输入图片来自摄像头，输出结果显示在 LCD 屏上。该示例演示了以下模型接口在实际项目中的使用情况。
+ `HumanFaceDetectMSR01 <https://github.com/espressif/esp-dl/blob/master/include/model_zoo/human_face_detect_msr01.hpp>`_
+ `HumanFaceDetectMNP01 <https://github.com/espressif/esp-dl/blob/master/include/model_zoo/human_face_detect_mnp01.hpp>`_
+ `CatFaceDetectMN03 <https://github.com/espressif/esp-dl/blob/master/include/model_zoo/cat_face_detect_mn03.hpp>`_
+ `移动侦测 <https://github.com/espressif/esp-dl/blob/master/include/image/dl_image.hpp#L322>`_
支持的开发套件
************************************************************************************************
+ `ESP-S3-EYE <https://www.espressif.com/zh-hans/products/devkits/esp-eye/overview>`_
运行示例
************************************************************************************************
1. 参考首页的 `说明文档 <../../>`_ 配置示例。
.. attention::
该示例仅支持 RGB565
2. 烧录程序，运行 IDF 监视器：
.. code:: shell
idf.py flash monitor
您将在 ESP-S3-EYE 的 LCD 屏上看到实时效果，在终端上看到各部分的耗时。

11
examples/camera_lcd/main/CMakeLists.txt
View File

@ -1,11 +0,0 @@
set(COMPONENT_SRCS "app_main.cpp" "app_dl.cpp")
# set(COMPONENT_ADD_INCLUDEDIRS ".")
set(COMPONENT_REQUIRES
esp32-camera
esp-dl
common
bus
screen)
register_component()

169
examples/camera_lcd/main/app_dl.cpp
View File

@ -1,169 +0,0 @@
#include "app_dl.hpp"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "sdkconfig.h"
#include "app_camera.hpp"
#include "app_lcd.h"
#include <list>
#include "dl_tool.hpp"
#include "dl_image.hpp"
#include "dl_detect_define.hpp"
#include "app_common.hpp"
#if CONFIG_DL_HUMAN_FACE_DETECTION_S1_MSR01
#include "human_face_detect_msr01.hpp"
#endif
#if CONFIG_DL_HUMAN_FACE_DETECTION_S2_MNP01
#include "human_face_detect_mnp01.hpp"
#endif
#if CONFIG_DL_CAT_FACE_DETECTION_MN03
#include "cat_face_detect_mn03.hpp"
#endif
#if CONFIG_DL_HUMAN_FACE_RECOGNITION_XXX
// TODO: recognize human face
#endif
static const char *TAG = "app_dl";
void task_dl(void *arg)
{
dl::tool::Latency latency_total(24);
dl::tool::Latency latency_fetch;
dl::tool::Latency latency_decode;
dl::tool::Latency latency_detect;
dl::tool::Latency latency_recognize;
dl::tool::Latency latency_moving;
#if CONFIG_DL_HUMAN_FACE
#if CONFIG_DL_HUMAN_FACE_DETECTION_S1_MSR01
HumanFaceDetectMSR01 detector(0.3F, 0.3F, 10, 0.3F);
#endif
#if CONFIG_DL_HUMAN_FACE_DETECTION_S2_MNP01
HumanFaceDetectMNP01 detector2(0.4F, 0.3F, 10);
#endif
#if CONFIG_DL_HUMAN_FACE_RECOGNITION_XXX
// TODO: recognize human face
#endif
#endif
#if CONFIG_DL_CAT_FACE
#if CONFIG_DL_CAT_FACE_DETECTION_MN03
CatFaceDetectMN03 detector(0.4F, 0.3F, 10, 0.3F);
#endif
#endif
while (true)
{
latency_fetch.clear_period();
latency_decode.clear_period();
latency_detect.clear_period();
latency_recognize.clear_period();
latency_moving.clear_period();
latency_total.start();
latency_fetch.start();
camera_fb_t *frame = esp_camera_fb_get();
if (!frame)
{
ESP_LOGE(TAG, "Camera capture failed");
continue;
}
latency_fetch.end();
#if CONFIG_DL_MOVING_TARGET_DETECTION_ENABLED
camera_fb_t *frame2 = esp_camera_fb_get();
if (!frame2)
{
ESP_LOGE(TAG, "Camera capture failed");
continue;
}
latency_fetch.end();
latency_moving.start();
uint32_t moving_point_number = dl::image::get_moving_point_number((uint16_t *)frame->buf, (uint16_t *)frame2->buf, frame->height, frame->width, 8, 15);
latency_moving.end();
if (moving_point_number > 50)
{
ESP_LOGI("Moving Target", "Detected.");
dl::image::draw_filled_rectangle((uint16_t *)frame->buf, frame->height, frame->width, 0, 0, 10, 10);
}
esp_camera_fb_return(frame2);
#endif
#if CONFIG_DL_ENABLED
#if CONFIG_DL_HUMAN_FACE
latency_detect.start();
#if CONFIG_DL_HUMAN_FACE_DETECTION_S2_ENABLED
std::list<dl::detect::result_t> &detect_candidates = detector.infer((uint16_t *)frame->buf, {(int)frame->height, (int)frame->width, 3});
std::list<dl::detect::result_t> &detect_results = detector2.infer((uint16_t *)frame->buf, {(int)frame->height, (int)frame->width, 3}, detect_candidates);
#else
std::list<dl::detect::result_t> &detect_results = detector.infer((uint16_t *)frame->buf, {(int)frame->height, (int)frame->width, 3});
#endif
latency_detect.end();
if (detect_results.size() > 0)
{
draw_detection_result((uint16_t *)frame->buf, frame->height, frame->width, detect_results);
#if CONFIG_DL_HUMAN_FACE_RECOGNITION_ENABLED
latency_recognize.start();
// TODO: recognize human face
latency_recognize.end();
#endif
}
#endif // CONFIG_DL_HUMAN_FACE
#if CONFIG_DL_CAT_FACE
latency_detect.start();
std::list<dl::detect::result_t> &detect_results = detector.infer((uint16_t *)frame->buf, {(int)frame->height, (int)frame->width, 3});
latency_detect.end();
if (detect_results.size() > 0)
{
draw_detection_result((uint16_t *)frame->buf, frame->height, frame->width, detect_results);
}
#endif // CONFIG_DL_CAT_FACE
#if CONFIG_DL_HUMAN_HAND
latency_detect.start();
// TODO:
latency_detect.end();
#endif // CONFIG_DL_HUMAN_HAND
#endif // CONFIG_DL_ENABLED
app_lcd_draw_bitmap((uint16_t *)frame->buf, frame->height, frame->width);
esp_camera_fb_return(frame);
latency_total.end();
uint32_t frame_latency = latency_total.get_period() / 1000;
uint32_t average_frame_latency = latency_total.get_average_period() / 1000;
ESP_LOGI("Frame Latency", "%4ums (%2.1ffps), Average: %4ums (%2.1ffps) | fetch: %4ums, "
#if CONFIG_DL_MOVING_TARGET_DETECTION_ENABLED
"moving: %4uus, "
#endif
"decode: %4ums, detect: %4ums, recognize: %5ums",
frame_latency, 1000.0 / frame_latency, average_frame_latency, 1000.0 / average_frame_latency,
latency_fetch.get_period() / 1000,
#if CONFIG_DL_MOVING_TARGET_DETECTION_ENABLED
latency_moving.get_period(),
#endif
latency_decode.get_period() / 1000,
latency_detect.get_period() / 1000,
latency_recognize.get_period() / 1000);
}
}
void app_dl_init()
{
xTaskCreatePinnedToCore(task_dl, "dl", 4 * 1024, NULL, 5, NULL, 1);
}

3
examples/camera_lcd/main/app_dl.hpp
View File

@ -1,3 +0,0 @@
#pragma once
void app_dl_init();

37
examples/camera_lcd/main/app_main.cpp
View File

@ -1,37 +0,0 @@
/* ESPRESSIF MIT License
*
* Copyright (c) 2018 <ESPRESSIF SYSTEMS (SHANGHAI) PTE LTD>
*
* Permission is hereby granted for use on all ESPRESSIF SYSTEMS products, in which case,
* it is free of charge, to any person obtaining a copy of this software and associated
* documentation files (the "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished
* to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "app_camera.hpp"
#include "app_lcd.h"
#include "app_dl.hpp"
extern "C" void app_main()
{
app_lcd_init();
app_lcd_set_color(COLOR_BLACK);
vTaskDelay(pdMS_TO_TICKS(500));
app_lcd_draw_wallpaper();
vTaskDelay(pdMS_TO_TICKS(500));
app_camera_init(PIXFORMAT_RGB565, FRAMESIZE_240X240, 2);
app_dl_init();
}

12
examples/camera_lcd/main/component.mk
View File

@ -1,12 +0,0 @@
#
# Main Makefile. This is basically the same as a component makefile.
#
# This Makefile should, at the very least, just include $(SDK_PATH)/make/component.mk. By default,
# this will take the sources in the src/ directory, compile them and link them into
# lib(subdirectory_name).a in the build directory. This behaviour is entirely configurable,
# please read the SDK documents if you need to do this.
#
COMPONENT_EMBED_FILES := www/index_ov2640.html.gz
COMPONENT_EMBED_FILES += www/index_ov3660.html.gz
COMPONENT_EMBED_FILES += www/index_ov5640.html.gz
COMPONENT_EMBED_FILES += www/monitor.html.gz

4
examples/camera_lcd/partitions.csv
View File

@ -1,4 +0,0 @@
# Espressif ESP32 Partition Table
# Name, Type, SubType, Offset, Size
factory, app, factory, 0x010000, 3840K
nvs, data, nvs, 0x3D0000, 16K
1 # Espressif ESP32 Partition Table
2 # Name, Type, SubType, Offset, Size
3 factory, app, factory, 0x010000, 3840K
4 nvs, data, nvs, 0x3D0000, 16K

28
examples/camera_lcd/sdkconfig.defaults
View File

@ -1,28 +0,0 @@
CONFIG_ESP32S3_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP32S3_SPIRAM_SUPPORT=y
CONFIG_SPIRAM_SPEED_80M=y
CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL=4096
CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP=y
CONFIG_FREERTOS_HZ=1000
CONFIG_CAMERA_PIXEL_FORMAT_RGB565=y
CONFIG_LCD_DRIVER_SCREEN_CONTROLLER_ILI9341=y
CONFIG_LCD_DRIVER_SCREEN_CONTROLLER_ILI9486=y
CONFIG_LCD_DRIVER_SCREEN_CONTROLLER_ILI9806=y
CONFIG_LCD_DRIVER_SCREEN_CONTROLLER_NT35510=y
CONFIG_LCD_DRIVER_SCREEN_CONTROLLER_RM68120=y
CONFIG_LCD_DRIVER_SCREEN_CONTROLLER_SSD1351=y
CONFIG_LCD_DRIVER_SCREEN_CONTROLLER_ST7789=y
CONFIG_LCD_DRIVER_SCREEN_CONTROLLER_ST7796=y
CONFIG_LCD_DRIVER_SCREEN_CONTROLLER_SSD1306=y
CONFIG_LCD_DRIVER_SCREEN_CONTROLLER_SSD1307=y
CONFIG_LCD_DRIVER_SCREEN_CONTROLLER_SSD1322=y
CONFIG_CAMERA_MODULE_ESP_S3_EYE=y
CONFIG_ESPTOOLPY_NO_STUB=y
CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=y
CONFIG_SPI_FLASH_USE_LEGACY_IMPL=y

6
examples/camera_terminal/CMakeLists.txt
View File

@ -1,6 +0,0 @@
cmake_minimum_required(VERSION 3.5)
set(EXTRA_COMPONENT_DIRS ../../components)
add_compile_options(-fdiagnostics-color=always)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(camera_terminal)

5
examples/camera_terminal/README.rst
View File

@ -1,5 +0,0 @@
################################################################################################################################
Camera with Terminal `[中文] <./README_cn.rst>`_
################################################################################################################################

33
examples/camera_terminal/README_cn.rst
View File

@ -1,33 +0,0 @@
################################################################################################################################
Camera with Terminal `[English] <./README.rst>`_
################################################################################################################################
该示例的输入图片来自摄像头，输出结果打印在终端。该示例演示了以下模型接口在实际项目中的使用情况。
+ `HumanFaceDetectMSR01 <https://github.com/espressif/esp-dl/blob/master/include/model_zoo/human_face_detect_msr01.hpp>`_
+ `HumanFaceDetectMNP01 <https://github.com/espressif/esp-dl/blob/master/include/model_zoo/human_face_detect_mnp01.hpp>`_
+ `CatFaceDetectMN03 <https://github.com/espressif/esp-dl/blob/master/include/model_zoo/cat_face_detect_mn03.hpp>`_
+ `移动侦测 <https://github.com/espressif/esp-dl/blob/master/include/image/dl_image.hpp#L322>`_
运行示例
************************************************************************************************
1. 参考首页的 `说明文档 <../../>`_ 配置示例。
2. 烧录程序，运行 IDF 监视器获取实时结果：
.. code:: shell
idf.py flash monitor
以选择模型 ``HumanFaceDetectMSR01`` 为例，当人脸凑近摄像头约 50cm 左右，终端打印结果如下所示：
.. figure:: ./img/result_on_terminal.png
:align: center
..
打印结果中包括时间消耗和检测的框选坐标。

BIN
examples/camera_terminal/img/result_on_terminal.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 129 KiB

16
examples/camera_terminal/main/CMakeLists.txt
View File

@ -1,16 +0,0 @@
set(COMPONENT_SRCS
app_main.cpp
app_dl.cpp
)
set(COMPONENT_ADD_INCLUDEDIRS
include
)
set(COMPONENT_REQUIRES
esp32-camera
esp-dl
common
)
register_component()

188
examples/camera_terminal/main/app_dl.cpp
View File

@ -1,188 +0,0 @@
#include "app_dl.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "sdkconfig.h"
#include "app_camera.hpp"
#include <list>
#include "dl_tool.hpp"
#include "dl_image.hpp"
#include "dl_detect_define.hpp"
#include "app_common.hpp"
#if CONFIG_DL_HUMAN_FACE_DETECTION_S1_MSR01
#include "human_face_detect_msr01.hpp"
#endif
#if CONFIG_DL_HUMAN_FACE_DETECTION_S2_MNP01
#include "human_face_detect_mnp01.hpp"
#endif
#if CONFIG_DL_CAT_FACE_DETECTION_MN03
#include "cat_face_detect_mn03.hpp"
#endif
#if CONFIG_DL_HUMAN_FACE_RECOGNITION_XXX
// TODO: recognize human face
#endif
static const char *TAG = "app_dl";
void task_dl(void *arg)
{
dl::tool::Latency latency_total(24);
dl::tool::Latency latency_fetch;
dl::tool::Latency latency_decode;
dl::tool::Latency latency_detect;
dl::tool::Latency latency_recognize;
dl::tool::Latency latency_moving;
/* 1. Load configuration for detection */
#if CONFIG_DL_HUMAN_FACE
#if CONFIG_DL_HUMAN_FACE_DETECTION_S1_MSR01
HumanFaceDetectMSR01 detector(0.3F, 0.3F, 10, 0.3F);
#endif
#if CONFIG_DL_HUMAN_FACE_DETECTION_S2_MNP01
HumanFaceDetectMNP01 detector2(0.4F, 0.3F, 10);
#endif
#if CONFIG_DL_HUMAN_FACE_RECOGNITION_XXX
// TODO: recognize human face
#endif
#endif
#if CONFIG_DL_CAT_FACE
#if CONFIG_DL_CAT_FACE_DETECTION_MN03
CatFaceDetectMN03 detector(0.4F, 0.3F, 10, 0.3F);
#endif
#endif
while (true)
{
latency_fetch.clear_period();
latency_decode.clear_period();
latency_detect.clear_period();
latency_recognize.clear_period();
latency_moving.clear_period();
latency_total.start();
latency_fetch.start();
camera_fb_t *frame = esp_camera_fb_get();
if (!frame)
{
ESP_LOGE(TAG, "Camera capture failed");
continue;
}
latency_fetch.end();
#if CONFIG_DL_MOVING_TARGET_DETECTION_ENABLED && CONFIG_CAMERA_PIXEL_FORMAT_RGB565
camera_fb_t *frame2 = esp_camera_fb_get();
if (!frame2)
{
ESP_LOGE(TAG, "Camera capture failed");
continue;
}
latency_fetch.end();
latency_moving.start();
uint32_t moving_point_number = dl::image::get_moving_point_number((uint16_t *)frame->buf, (uint16_t *)frame2->buf, frame->height, frame->width, 8, 15);
latency_moving.end();
if (moving_point_number > 50)
{
ESP_LOGI("Moving Target", "Detected.");
dl::image::draw_filled_rectangle((uint16_t *)frame->buf, frame->height, frame->width, 0, 0, 10, 10);
}
esp_camera_fb_return(frame2);
#endif
#if CONFIG_DL_ENABLED
latency_decode.start();
IMAGE_T *image_ptr = (IMAGE_T *)app_camera_decode(frame);
if (!image_ptr)
{
esp_camera_fb_return(frame);
continue;
}
int image_height = frame->height;
int image_width = frame->width;
pixformat_t image_format = frame->format;
if (image_format != PIXFORMAT_RGB565)
esp_camera_fb_return(frame);
latency_decode.end();
#if CONFIG_DL_HUMAN_FACE
latency_detect.start();
#if CONFIG_DL_HUMAN_FACE_DETECTION_S2_ENABLED
std::list<dl::detect::result_t> &detect_candidates = detector.infer(image_ptr, {(int)image_height, (int)image_width, 3});
std::list<dl::detect::result_t> &detect_results = detector2.infer(image_ptr, {(int)image_height, (int)image_width, 3}, detect_candidates);
#else
std::list<dl::detect::result_t> &detect_results = detector.infer(image_ptr, {(int)image_height, (int)image_width, 3});
#endif
latency_detect.end();
if (detect_results.size() > 0)
{
print_detection_result(detect_results);
#if CONFIG_DL_HUMAN_FACE_RECOGNITION_ENABLED
latency_recognize.start();
// TODO: recognize human face
latency_recognize.end();
#endif
}
#endif // CONFIG_DL_HUMAN_FACE
#if CONFIG_DL_CAT_FACE
latency_detect.start();
std::list<dl::detect::result_t> &detect_results = detector.infer(image_ptr, {(int)image_height, (int)image_width, 3});
latency_detect.end();
if (detect_results.size() > 0)
{
print_detection_result(detect_results);
}
#endif // CONFIG_DL_CAT_FACE
#if CONFIG_DL_HUMAN_HAND
latency_detect.start();
// TODO:
latency_detect.end();
#endif // CONFIG_DL_HUMAN_HAND
if (image_format == PIXFORMAT_RGB565)
esp_camera_fb_return(frame);
else
free(image_ptr);
#else
esp_camera_fb_return(frame);
#endif // CONFIG_DL_ENABLED
latency_total.end();
uint32_t frame_latency = latency_total.get_period() / 1000;
uint32_t average_frame_latency = latency_total.get_average_period() / 1000;
ESP_LOGI("Frame Latency", "%4ums (%2.1ffps), Average: %4ums (%2.1ffps) | fetch: %4ums, "
#if CONFIG_DL_MOVING_TARGET_DETECTION_ENABLED && CONFIG_CAMERA_PIXEL_FORMAT_RGB565
"moving: %4uus, "
#endif
"decode: %4ums, detect: %4ums, recognize: %5ums",
frame_latency, 1000.0 / frame_latency, average_frame_latency, 1000.0 / average_frame_latency,
latency_fetch.get_period() / 1000,
#if CONFIG_DL_MOVING_TARGET_DETECTION_ENABLED && CONFIG_CAMERA_PIXEL_FORMAT_RGB565
latency_moving.get_period(),
#endif
latency_decode.get_period() / 1000,
latency_detect.get_period() / 1000,
latency_recognize.get_period() / 1000);
}
}
void app_dl_init()
{
xTaskCreatePinnedToCore(task_dl, "dl", 4 * 1024, NULL, 5, NULL, 1);
}

8
examples/camera_terminal/main/app_main.cpp
View File

@ -1,8 +0,0 @@
#include "app_camera.hpp"
#include "app_dl.h"
extern "C" void app_main()
{
app_camera_init(CAMERA_PIXEL_FORMAT, FRAMESIZE_QVGA, 2);
app_dl_init();
}

16
examples/camera_terminal/main/include/app_dl.h
View File

@ -1,16 +0,0 @@
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
/**
* @brief Initialize deep-learning application task.
*
*/
void app_dl_init();
#ifdef __cplusplus
}
#endif

4
examples/camera_terminal/partitions.csv
View File

@ -1,4 +0,0 @@
# Espressif ESP32 Partition Table
# Name, Type, SubType, Offset, Size
factory, app, factory, 0x010000, 2M
nvs, data, nvs, 0x310000, 16K
1 # Espressif ESP32 Partition Table
2 # Name, Type, SubType, Offset, Size
3 factory, app, factory, 0x010000, 2M
4 nvs, data, nvs, 0x310000, 16K

17
examples/camera_terminal/sdkconfig.defaults
View File

@ -1,17 +0,0 @@
CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
CONFIG_ESPTOOLPY_FLASHMODE_QIO=y
CONFIG_SPIRAM_SPEED_80M=y
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
CONFIG_ESP_TASK_WDT=n
# Wait for esp-idf stable
CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_PERF=y
CONFIG_BOOTLOADER_LOG_LEVEL_NONE=y
CONFIG_SPIRAM_MEMTEST=n

4
examples/camera_terminal/sdkconfig.defaults.esp32
View File

@ -1,4 +0,0 @@
CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP32_SPIRAM_SUPPORT=y
CONFIG_CAMERA_MODULE_ESP_EYE=y

2
examples/camera_terminal/sdkconfig.defaults.esp32s2
View File

@ -1,2 +0,0 @@
CONFIG_ESP32S2_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP32S2_SPIRAM_SUPPORT=y

6
examples/camera_terminal/sdkconfig.defaults.esp32s3
View File

@ -1,6 +0,0 @@
CONFIG_ESP32S3_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP32S3_SPIRAM_SUPPORT=y
CONFIG_CAMERA_MODULE_ESP_S3_EYE=y
CONFIG_ESPTOOLPY_NO_STUB=y
CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=y

8
examples/camera_web_server/CMakeLists.txt
View File

@ -1,8 +0,0 @@
# The following lines of boilerplate have to be in your project's
# CMakeLists in this exact order for cmake to work correctly
cmake_minimum_required(VERSION 3.5)
set(EXTRA_COMPONENT_DIRS ../../components)
add_compile_options(-fdiagnostics-color=always)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(camera_web_server)

5
examples/camera_web_server/README.rst
View File

@ -1,5 +0,0 @@
################################################################################################################################
Camera with Web Server `[中文] <./README_cn.rst>`_
################################################################################################################################

55
examples/camera_web_server/README_cn.rst
View File

@ -1,55 +0,0 @@
################################################################################################################################
Camera with Web Server `[English] <./README.rst>`_
################################################################################################################################
该示例的输入图片来自摄像头，输出结果网页端。该示例演示了以下模型接口在实际项目中的使用情况。
+ `HumanFaceDetectMSR01 <https://github.com/espressif/esp-dl/blob/master/include/model_zoo/human_face_detect_msr01.hpp>`_
+ `HumanFaceDetectMNP01 <https://github.com/espressif/esp-dl/blob/master/include/model_zoo/human_face_detect_mnp01.hpp>`_
+ `CatFaceDetectMN03 <https://github.com/espressif/esp-dl/blob/master/include/model_zoo/cat_face_detect_mn03.hpp>`_
+ `移动侦测 <https://github.com/espressif/esp-dl/blob/master/include/image/dl_image.hpp#L322>`_
运行示例
************************************************************************************************
1. 参考首页的 `说明文档 <../../>`_ 配置示例。
2. 该示例具有属于自己的示例配置，可配置 WiFi 属性，如下图：
.. figure:: ./img/example-config.png
:align: center
..
3. 烧录程序，运行 IDF 监视器：
.. code:: shell
idf.py flash monitor
4. 连接 WiFi，以上图配置为例，WiFi 名为 ``myWiFi``，WiFi 密码为 ``00000000``。
5. 打开浏览器，并登录 IP 地址，以上图配置为例，IP 地址为为 ``192.168.4.1``。
6. 您可以
+ ``Get Still`` 拍摄一张照片
+ ``Start Stream`` 连续获取图片，此时，
+ 打开 ``Detection`` 可使能检测功能
+ 打开 ``Recognition`` 可使能识别功能（当然您在配置时使能了这个选项）
.. figure:: ./img/example-result.png
:align: center
..

BIN
examples/camera_web_server/img/example-config.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 45 KiB

BIN
examples/camera_web_server/img/example-result.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 231 KiB

20
examples/camera_web_server/main/CMakeLists.txt
View File

@ -1,20 +0,0 @@
set(COMPONENT_SRCS "app_main.cpp" "app_wifi.c" "app_httpd.cpp" "app_mdns.c")
set(COMPONENT_ADD_INCLUDEDIRS "include")
set(COMPONENT_REQUIRES
esp32-camera
esp-dl
common
nvs_flash
esp_http_server
fb_gfx
mdns
)
set(COMPONENT_EMBED_FILES
"www/index_ov2640.html.gz"
"www/index_ov3660.html.gz"
"www/index_ov5640.html.gz"
"www/monitor.html.gz")
register_component()

57
examples/camera_web_server/main/Kconfig.projbuild
View File

@ -1,57 +0,0 @@
menu "Example Configuration"
config ESP_HOST_NAME
string "Camera Host Name"
default ""
help
Hostname that the camera will advertise over mDNS.
config ESP_WIFI_SSID
string "WiFi STA SSID"
default ""
help
WiFi SSID (network name) to connect to or empty for Off.
config ESP_WIFI_PASSWORD
string "WiFi STA Password"
default ""
help
WiFi Password if WEP/WPA/WPA2 or empty if Open.
config ESP_WIFI_AP_SSID
string "WiFi AP SSID"
default "ESP32-Camera"
help
AP SSID (network name) to create or empty for Off.
config ESP_WIFI_AP_PASSWORD
string "WiFi AP Password"
default ""
help
AP password for WPA2 or empty for Open.
config MAX_STA_CONN
int "Maximal STA connections"
default 1
help
Max number of the STA connects to AP.
config ESP_WIFI_AP_CHANNEL
string "WiFi AP Channel"
default ""
help
AP channel for better connection performance.
config SERVER_IP
string "WiFi AP IP Address"
default "192.168.4.1"
help
IP address that the ESP will assign to it's AP interface. You can use this IP to connect to the camera after flashing.
config ESP_MAXIMUM_RETRY
int "Maximum retry"
default 5
help
Set the Maximum retry to avoid station reconnecting to the AP unlimited when the AP is really inexistent.
endmenu

969
examples/camera_web_server/main/app_httpd.cpp
View File

@ -1,969 +0,0 @@
// Copyright 2015-2016 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 "app_httpd.hpp"
#include <list>
#include "esp_http_server.h"
#include "esp_timer.h"
#include "img_converters.h"
#include "fb_gfx.h"
#include "app_mdns.h"
#include "app_camera.hpp"
#include "app_common.hpp"
#include "sdkconfig.h"
#include "dl_tool.hpp"
#include "dl_image.hpp"
#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
#include "esp32-hal-log.h"
#define TAG ""
#else
#include "esp_log.h"
static const char *TAG = "camera_httpd";
#endif
#if CONFIG_DL_HUMAN_FACE_DETECTION_S1_MSR01
#include "human_face_detect_msr01.hpp"
#endif
#if CONFIG_DL_HUMAN_FACE_DETECTION_S2_MNP01
#include "human_face_detect_mnp01.hpp"
#endif
#if CONFIG_DL_CAT_FACE_DETECTION_MN03
#include "cat_face_detect_mn03.hpp"
#endif
#if CONFIG_DL_HUMAN_FACE_RECOGNITION_XXX
// TODO: recognize human face
#endif
static int8_t detection_enabled = 0;
static int8_t recognition_enabled = 0;
static int8_t is_enrolling = 0;
#ifdef CONFIG_LED_ILLUMINATOR_ENABLED
#include "app_led.h"
int led_duty = 0;
#endif
typedef struct
{
httpd_req_t *req;
size_t len;
} jpg_chunking_t;
#define PART_BOUNDARY "123456789000000000000987654321"
static const char *_STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
static const char *_STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
static const char *_STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\nX-Timestamp: %d.%06d\r\n\r\n";
httpd_handle_t stream_httpd = NULL;
httpd_handle_t camera_httpd = NULL;
static size_t jpg_encode_stream(void *arg, size_t index, const void *data, size_t len)
{
jpg_chunking_t *j = (jpg_chunking_t *)arg;
if (!index)
{
j->len = 0;
}
if (httpd_resp_send_chunk(j->req, (const char *)data, len) != ESP_OK)
{
return 0;
}
j->len += len;
return len;
}
static esp_err_t capture_handler(httpd_req_t *req)
{
dl::tool::Latency latency_total;
latency_total.start();
camera_fb_t *frame = NULL;
esp_err_t res = ESP_OK;
#ifdef CONFIG_LED_ILLUMINATOR_ENABLED
app_led_duty(led_duty);
vTaskDelay(150 / portTICK_PERIOD_MS); // The LED needs to be turned on ~150ms before the call to esp_camera_fb_get()
frame = esp_camera_fb_get(); // or it won't be visible in the frame. A better way to do this is needed.
app_led_duty(0);
#else
frame = esp_camera_fb_get();
#endif
if (!frame)
{
ESP_LOGE(TAG, "Camera capture failed");
httpd_resp_send_500(req);
return ESP_FAIL;
}
httpd_resp_set_type(req, "image/jpeg");
httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.jpg");
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
char ts[32];
snprintf(ts, 32, "%ld.%06ld", frame->timestamp.tv_sec, frame->timestamp.tv_usec);
httpd_resp_set_hdr(req, "X-Timestamp", (const char *)ts);
size_t fb_len = 0;
if (frame->format == PIXFORMAT_JPEG)
{
fb_len = frame->len;
res = httpd_resp_send(req, (const char *)frame->buf, frame->len);
}
else
{
jpg_chunking_t jchunk = {req, 0};
res = frame2jpg_cb(frame, 80, jpg_encode_stream, &jchunk) ? ESP_OK : ESP_FAIL;
httpd_resp_send_chunk(req, NULL, 0);
fb_len = jchunk.len;
}
esp_camera_fb_return(frame);
latency_total.end();
ESP_LOGI(TAG, "JPG: %uB %ums", (uint32_t)(fb_len), latency_total.get_period() / 1000);
return res;
}
static esp_err_t stream_handler(httpd_req_t *req)
{
camera_fb_t *frame = NULL;
struct timeval _timestamp;
esp_err_t res = ESP_OK;
size_t _jpg_buf_len = 0;
uint8_t *_jpg_buf = NULL;
char *part_buf[128];
dl::tool::Latency latency_total(24);
IMAGE_T *image_ptr = NULL;
bool is_detected = false;
dl::tool::Latency latency_fetch;
dl::tool::Latency latency_decode;
dl::tool::Latency latency_encode;
dl::tool::Latency latency_detect;
dl::tool::Latency latency_recognize;
dl::tool::Latency latency_moving;
#if CONFIG_DL_HUMAN_FACE
#if CONFIG_DL_HUMAN_FACE_DETECTION_S1_MSR01
HumanFaceDetectMSR01 detector(0.3F, 0.3F, 10, 0.3F);
#endif
#if CONFIG_DL_HUMAN_FACE_DETECTION_S2_MNP01
HumanFaceDetectMNP01 detector2(0.4F, 0.3F, 10);
#endif
#if CONFIG_DL_HUMAN_FACE_RECOGNITION_XXX
// TODO: recognize human face
#endif
#endif
#if CONFIG_DL_CAT_FACE
#if CONFIG_DL_CAT_FACE_DETECTION_MN03
CatFaceDetectMN03 detector(0.4F, 0.3F, 10, 0.3F);
#endif
#endif
res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
if (res != ESP_OK)
{
return res;
}
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
httpd_resp_set_hdr(req, "X-Framerate", "60");
#ifdef CONFIG_LED_ILLUMINATOR_ENABLED
app_led_duty(led_duty);
#endif
while (true)
{
latency_fetch.clear_period();
latency_decode.clear_period();
latency_encode.clear_period();
latency_detect.clear_period();
latency_recognize.clear_period();
latency_moving.clear_period();
image_ptr = NULL;
is_detected = false;
do
{
latency_total.start();
latency_fetch.start();
frame = esp_camera_fb_get();
if (!frame)
{
ESP_LOGE(TAG, "Camera capture failed");
res = ESP_FAIL;
break;
}
_timestamp.tv_sec = frame->timestamp.tv_sec;
_timestamp.tv_usec = frame->timestamp.tv_usec;
latency_fetch.end();
#if CONFIG_DL_MOVING_TARGET_DETECTION_ENABLED && CONFIG_CAMERA_PIXEL_FORMAT_RGB565
camera_fb_t *frame2 = esp_camera_fb_get();
if (!frame2)
{
ESP_LOGE(TAG, "Camera capture failed");
continue;
}
latency_fetch.end();
latency_moving.start();
uint32_t moving_point_number = dl::image::get_moving_point_number((uint16_t *)frame->buf, (uint16_t *)frame2->buf, frame->height, frame->width, 8, 15);
latency_moving.end();
if (moving_point_number > 50)
{
ESP_LOGI("Moving Target", "Detected.");
dl::image::draw_filled_rectangle((uint16_t *)frame->buf, frame->height, frame->width, 0, 0, 10, 10);
}
esp_camera_fb_return(frame2);
#endif
#if CONFIG_DL_ENABLED
if (detection_enabled && frame->width < 400)
{
latency_decode.start();
image_ptr = (IMAGE_T *)app_camera_decode(frame);
if (!image_ptr)
{
ESP_LOGE(TAG, "Frame decode failed");
res = ESP_FAIL;
break;
}
latency_decode.end();
#if CONFIG_DL_HUMAN_FACE
latency_detect.start();
#if CONFIG_DL_HUMAN_FACE_DETECTION_S2_ENABLED
std::list<dl::detect::result_t> &detect_candidates = detector.infer(image_ptr, {(int)frame->height, (int)frame->width, 3});
std::list<dl::detect::result_t> &detect_results = detector2.infer(image_ptr, {(int)frame->height, (int)frame->width, 3}, detect_candidates);
#else
std::list<dl::detect::result_t> &detect_results = detector.infer(image_ptr, {(int)frame->height, (int)frame->width, 3});
#endif
latency_detect.end();
if (detect_results.size() > 0)
{
is_detected = true;
draw_detection_result(image_ptr, frame->height, frame->width, detect_results);
latency_recognize.start();
if (recognition_enabled)
{
#if CONFIG_DL_HUMAN_FACE_RECOGNITION_XXX
// TODO: recognize human face
#endif
}
latency_recognize.end();
}
#endif // CONFIG_DL_HUMAN_FACE
#if CONFIG_DL_CAT_FACE
latency_detect.start();
std::list<dl::detect::result_t> &detect_results = detector.infer(image_ptr, {(int)frame->height, (int)frame->width, 3});
latency_detect.end();
if (detect_results.size() > 0)
{
is_detected = true;
draw_detection_result(image_ptr, frame->height, frame->width, detect_results);
}
#endif // CONFIG_DL_CAT_FACE
#if CONFIG_DL_HUMAN_HAND
latency_detect.start();
// TODO:
latency_detect.end();
#endif // CONFIG_DL_HUMAN_HAND
}
#endif // CONFIG_DL_ENABLED
latency_encode.start();
if (is_detected)
{
if (!fmt2jpg((uint8_t *)image_ptr, frame->width * frame->height * 3, frame->width, frame->height, CAMERA_PIXEL_FORMAT, 90, &_jpg_buf, &_jpg_buf_len))
{
ESP_LOGE(TAG, "fmt2jpg failed");
res = ESP_FAIL;
break;
}
if (frame->format == PIXFORMAT_RGB565)
image_ptr = NULL;
esp_camera_fb_return(frame);
frame = NULL;
}
else if (frame->format == PIXFORMAT_JPEG)
{
_jpg_buf = frame->buf;
_jpg_buf_len = frame->len;
}
else
{
if (!frame2jpg(frame, 80, &_jpg_buf, &_jpg_buf_len))
{
ESP_LOGE(TAG, "JPEG compression failed");
res = ESP_FAIL;
break;
}
if (frame->format == PIXFORMAT_RGB565)
image_ptr = NULL;
esp_camera_fb_return(frame);
frame = NULL;
}
if (image_ptr)
free(image_ptr);
latency_encode.end();
} while (0);
if (res == ESP_OK)
{
res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
}
if (res == ESP_OK)
{
size_t hlen = snprintf((char *)part_buf, 128, _STREAM_PART, _jpg_buf_len, _timestamp.tv_sec, _timestamp.tv_usec);
res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
}
if (res == ESP_OK)
{
res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
}
if (frame)
{
esp_camera_fb_return(frame);
frame = NULL;
_jpg_buf = NULL;
}
else if (_jpg_buf)
{
free(_jpg_buf);
_jpg_buf = NULL;
}
if (res != ESP_OK)
{
break;
}
latency_total.end();
uint32_t frame_latency = latency_total.get_period() / 1000;
uint32_t average_frame_latency = latency_total.get_average_period() / 1000;
ESP_LOGI("Frame Latency", "%4ums (%2.1ffps), Average: %4ums (%2.1ffps) | fetch %4ums, "
#if CONFIG_DL_MOVING_TARGET_DETECTION_ENABLED && CONFIG_CAMERA_PIXEL_FORMAT_RGB565
"moving: %4uus, "
#endif
"decode: %4ums, detect: %4ums, recognize: %5ums, encode: %4ums",
frame_latency, 1000.0 / frame_latency, average_frame_latency, 1000.0 / average_frame_latency,
latency_fetch.get_period() / 1000,
#if CONFIG_DL_MOVING_TARGET_DETECTION_ENABLED && CONFIG_CAMERA_PIXEL_FORMAT_RGB565
latency_moving.get_period(),
#endif
latency_decode.get_period() / 1000,
latency_detect.get_period() / 1000,
latency_recognize.get_period() / 1000,
latency_encode.get_period() / 1000);
}
#ifdef CONFIG_LED_ILLUMINATOR_ENABLED
app_led_duty(0);
#endif
return res;
}
static esp_err_t parse_get(httpd_req_t *req, char **obuf)
{
char *buf = NULL;
size_t buf_len = 0;
buf_len = httpd_req_get_url_query_len(req) + 1;
if (buf_len > 1)
{
buf = (char *)malloc(buf_len);
if (!buf)
{
httpd_resp_send_500(req);
return ESP_FAIL;
}
if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK)
{
*obuf = buf;
return ESP_OK;
}
free(buf);
}
httpd_resp_send_404(req);
return ESP_FAIL;
}
static esp_err_t cmd_handler(httpd_req_t *req)
{
char *buf = NULL;
char variable[32];
char value[32];
if (parse_get(req, &buf) != ESP_OK ||
httpd_query_key_value(buf, "var", variable, sizeof(variable)) != ESP_OK ||
httpd_query_key_value(buf, "val", value, sizeof(value)) != ESP_OK)
{
free(buf);
httpd_resp_send_404(req);
return ESP_FAIL;
}
free(buf);
int val = atoi(value);
ESP_LOGI(TAG, "%s = %d", variable, val);
sensor_t *s = esp_camera_sensor_get();
int res = 0;
if (!strcmp(variable, "framesize"))
{
if (s->pixformat == PIXFORMAT_JPEG)
{
res = s->set_framesize(s, (framesize_t)val);
if (res == 0)
{
app_mdns_update_framesize(val);
}
}
}
else if (!strcmp(variable, "quality"))
res = s->set_quality(s, val);
else if (!strcmp(variable, "contrast"))
res = s->set_contrast(s, val);
else if (!strcmp(variable, "brightness"))
res = s->set_brightness(s, val);
else if (!strcmp(variable, "saturation"))
res = s->set_saturation(s, val);
else if (!strcmp(variable, "gainceiling"))
res = s->set_gainceiling(s, (gainceiling_t)val);
else if (!strcmp(variable, "colorbar"))
res = s->set_colorbar(s, val);
else if (!strcmp(variable, "awb"))
res = s->set_whitebal(s, val);
else if (!strcmp(variable, "agc"))
res = s->set_gain_ctrl(s, val);
else if (!strcmp(variable, "aec"))
res = s->set_exposure_ctrl(s, val);
else if (!strcmp(variable, "hmirror"))
res = s->set_hmirror(s, val);
else if (!strcmp(variable, "vflip"))
res = s->set_vflip(s, val);
else if (!strcmp(variable, "awb_gain"))
res = s->set_awb_gain(s, val);
else if (!strcmp(variable, "agc_gain"))
res = s->set_agc_gain(s, val);
else if (!strcmp(variable, "aec_value"))
res = s->set_aec_value(s, val);
else if (!strcmp(variable, "aec2"))
res = s->set_aec2(s, val);
else if (!strcmp(variable, "dcw"))
res = s->set_dcw(s, val);
else if (!strcmp(variable, "bpc"))
res = s->set_bpc(s, val);
else if (!strcmp(variable, "wpc"))
res = s->set_wpc(s, val);
else if (!strcmp(variable, "raw_gma"))
res = s->set_raw_gma(s, val);
else if (!strcmp(variable, "lenc"))
res = s->set_lenc(s, val);
else if (!strcmp(variable, "special_effect"))
res = s->set_special_effect(s, val);
else if (!strcmp(variable, "wb_mode"))
res = s->set_wb_mode(s, val);
else if (!strcmp(variable, "ae_level"))
res = s->set_ae_level(s, val);
#ifdef CONFIG_LED_ILLUMINATOR_ENABLED
else if (!strcmp(variable, "led_intensity"))
led_duty = val;
#endif
else if (!strcmp(variable, "face_detect"))
{
detection_enabled = val;
if (!detection_enabled)
{
recognition_enabled = 0;
}
}
else if (!strcmp(variable, "face_enroll"))
is_enrolling = val;
else if (!strcmp(variable, "face_recognize"))
{
recognition_enabled = val;
if (recognition_enabled)
{
detection_enabled = val;
}
}
else
{
res = -1;
}
if (res)
{
return httpd_resp_send_500(req);
}
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
return httpd_resp_send(req, NULL, 0);
}
static int print_reg(char *p, sensor_t *s, uint16_t reg, uint32_t mask)
{
return sprintf(p, "\"0x%x\":%u,", reg, s->get_reg(s, reg, mask));
}
static esp_err_t status_handler(httpd_req_t *req)
{
static char json_response[1024];
sensor_t *s = esp_camera_sensor_get();
char *p = json_response;
*p++ = '{';
if (s->id.PID == OV5640_PID || s->id.PID == OV3660_PID)
{
for (int reg = 0x3400; reg < 0x3406; reg += 2)
{
p += print_reg(p, s, reg, 0xFFF); //12 bit
}
p += print_reg(p, s, 0x3406, 0xFF);
p += print_reg(p, s, 0x3500, 0xFFFF0); //16 bit
p += print_reg(p, s, 0x3503, 0xFF);
p += print_reg(p, s, 0x350a, 0x3FF); //10 bit
p += print_reg(p, s, 0x350c, 0xFFFF); //16 bit
for (int reg = 0x5480; reg <= 0x5490; reg++)
{
p += print_reg(p, s, reg, 0xFF);
}
for (int reg = 0x5380; reg <= 0x538b; reg++)
{
p += print_reg(p, s, reg, 0xFF);
}
for (int reg = 0x5580; reg < 0x558a; reg++)
{
p += print_reg(p, s, reg, 0xFF);
}
p += print_reg(p, s, 0x558a, 0x1FF); //9 bit
}
else
{
p += print_reg(p, s, 0xd3, 0xFF);
p += print_reg(p, s, 0x111, 0xFF);
p += print_reg(p, s, 0x132, 0xFF);
}
p += sprintf(p, "\"board\":\"%s\",", CAMERA_MODULE_NAME);
p += sprintf(p, "\"xclk\":%u,", s->xclk_freq_hz / 1000000);
p += sprintf(p, "\"pixformat\":%u,", s->pixformat);
p += sprintf(p, "\"framesize\":%u,", s->status.framesize);
p += sprintf(p, "\"quality\":%u,", s->status.quality);
p += sprintf(p, "\"brightness\":%d,", s->status.brightness);
p += sprintf(p, "\"contrast\":%d,", s->status.contrast);
p += sprintf(p, "\"saturation\":%d,", s->status.saturation);
p += sprintf(p, "\"sharpness\":%d,", s->status.sharpness);
p += sprintf(p, "\"special_effect\":%u,", s->status.special_effect);
p += sprintf(p, "\"wb_mode\":%u,", s->status.wb_mode);
p += sprintf(p, "\"awb\":%u,", s->status.awb);
p += sprintf(p, "\"awb_gain\":%u,", s->status.awb_gain);
p += sprintf(p, "\"aec\":%u,", s->status.aec);
p += sprintf(p, "\"aec2\":%u,", s->status.aec2);
p += sprintf(p, "\"ae_level\":%d,", s->status.ae_level);
p += sprintf(p, "\"aec_value\":%u,", s->status.aec_value);
p += sprintf(p, "\"agc\":%u,", s->status.agc);
p += sprintf(p, "\"agc_gain\":%u,", s->status.agc_gain);
p += sprintf(p, "\"gainceiling\":%u,", s->status.gainceiling);
p += sprintf(p, "\"bpc\":%u,", s->status.bpc);
p += sprintf(p, "\"wpc\":%u,", s->status.wpc);
p += sprintf(p, "\"raw_gma\":%u,", s->status.raw_gma);
p += sprintf(p, "\"lenc\":%u,", s->status.lenc);
p += sprintf(p, "\"hmirror\":%u,", s->status.hmirror);
p += sprintf(p, "\"dcw\":%u,", s->status.dcw);
p += sprintf(p, "\"colorbar\":%u", s->status.colorbar);
#ifdef CONFIG_LED_ILLUMINATOR_ENABLED
p += sprintf(p, ",\"led_intensity\":%u", led_duty);
#else
p += sprintf(p, ",\"led_intensity\":%d", -1);
#endif
p += sprintf(p, ",\"face_detect\":%u", detection_enabled);
p += sprintf(p, ",\"face_enroll\":%u,", is_enrolling);
p += sprintf(p, "\"face_recognize\":%u", recognition_enabled);
*p++ = '}';
*p++ = 0;
httpd_resp_set_type(req, "application/json");
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
return httpd_resp_send(req, json_response, strlen(json_response));
}
static esp_err_t mdns_handler(httpd_req_t *req)
{
size_t json_len = 0;
const char *json_response = app_mdns_query(&json_len);
httpd_resp_set_type(req, "application/json");
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
return httpd_resp_send(req, json_response, json_len);
}
static esp_err_t xclk_handler(httpd_req_t *req)
{
char *buf = NULL;
char _xclk[32];
if (parse_get(req, &buf) != ESP_OK ||
httpd_query_key_value(buf, "xclk", _xclk, sizeof(_xclk)) != ESP_OK)
{
free(buf);
httpd_resp_send_404(req);
return ESP_FAIL;
}
free(buf);
int xclk = atoi(_xclk);
ESP_LOGI(TAG, "Set XCLK: %d MHz", xclk);
sensor_t *s = esp_camera_sensor_get();
int res = s->set_xclk(s, LEDC_TIMER_0, xclk);
if (res)
{
return httpd_resp_send_500(req);
}
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
return httpd_resp_send(req, NULL, 0);
}
static esp_err_t reg_handler(httpd_req_t *req)
{
char *buf = NULL;
char _reg[32];
char _mask[32];
char _val[32];
if (parse_get(req, &buf) != ESP_OK ||
httpd_query_key_value(buf, "reg", _reg, sizeof(_reg)) != ESP_OK ||
httpd_query_key_value(buf, "mask", _mask, sizeof(_mask)) != ESP_OK ||
httpd_query_key_value(buf, "val", _val, sizeof(_val)) != ESP_OK)
{
free(buf);
httpd_resp_send_404(req);
return ESP_FAIL;
}
free(buf);
int reg = atoi(_reg);
int mask = atoi(_mask);
int val = atoi(_val);
ESP_LOGI(TAG, "Set Register: reg: 0x%02x, mask: 0x%02x, value: 0x%02x", reg, mask, val);
sensor_t *s = esp_camera_sensor_get();
int res = s->set_reg(s, reg, mask, val);
if (res)
{
return httpd_resp_send_500(req);
}
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
return httpd_resp_send(req, NULL, 0);
}
static esp_err_t greg_handler(httpd_req_t *req)
{
char *buf = NULL;
char _reg[32];
char _mask[32];
if (parse_get(req, &buf) != ESP_OK ||
httpd_query_key_value(buf, "reg", _reg, sizeof(_reg)) != ESP_OK ||
httpd_query_key_value(buf, "mask", _mask, sizeof(_mask)) != ESP_OK)
{
free(buf);
httpd_resp_send_404(req);
return ESP_FAIL;
}
free(buf);
int reg = atoi(_reg);
int mask = atoi(_mask);
sensor_t *s = esp_camera_sensor_get();
int res = s->get_reg(s, reg, mask);
if (res < 0)
{
return httpd_resp_send_500(req);
}
ESP_LOGI(TAG, "Get Register: reg: 0x%02x, mask: 0x%02x, value: 0x%02x", reg, mask, res);
char buffer[20];
const char *val = itoa(res, buffer, 10);
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
return httpd_resp_send(req, val, strlen(val));
}
static int parse_get_var(char *buf, const char *key, int def)
{
char _int[16];
if (httpd_query_key_value(buf, key, _int, sizeof(_int)) != ESP_OK)
{
return def;
}
return atoi(_int);
}
static esp_err_t pll_handler(httpd_req_t *req)
{
char *buf = NULL;
if (parse_get(req, &buf) != ESP_OK)
{
free(buf);
httpd_resp_send_404(req);
return ESP_FAIL;
}
int bypass = parse_get_var(buf, "bypass", 0);
int mul = parse_get_var(buf, "mul", 0);
int sys = parse_get_var(buf, "sys", 0);
int root = parse_get_var(buf, "root", 0);
int pre = parse_get_var(buf, "pre", 0);
int seld5 = parse_get_var(buf, "seld5", 0);
int pclken = parse_get_var(buf, "pclken", 0);
int pclk = parse_get_var(buf, "pclk", 0);
free(buf);
ESP_LOGI(TAG, "Set Pll: bypass: %d, mul: %d, sys: %d, root: %d, pre: %d, seld5: %d, pclken: %d, pclk: %d", bypass, mul, sys, root, pre, seld5, pclken, pclk);
sensor_t *s = esp_camera_sensor_get();
int res = s->set_pll(s, bypass, mul, sys, root, pre, seld5, pclken, pclk);
if (res)
{
return httpd_resp_send_500(req);
}
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
return httpd_resp_send(req, NULL, 0);
}
static esp_err_t win_handler(httpd_req_t *req)
{
char *buf = NULL;
if (parse_get(req, &buf) != ESP_OK)
{
free(buf);
httpd_resp_send_404(req);
return ESP_FAIL;
}
int startX = parse_get_var(buf, "sx", 0);
int startY = parse_get_var(buf, "sy", 0);
int endX = parse_get_var(buf, "ex", 0);
int endY = parse_get_var(buf, "ey", 0);
int offsetX = parse_get_var(buf, "offx", 0);
int offsetY = parse_get_var(buf, "offy", 0);
int totalX = parse_get_var(buf, "tx", 0);
int totalY = parse_get_var(buf, "ty", 0);
int outputX = parse_get_var(buf, "ox", 0);
int outputY = parse_get_var(buf, "oy", 0);
bool scale = parse_get_var(buf, "scale", 0) == 1;
bool binning = parse_get_var(buf, "binning", 0) == 1;
free(buf);
ESP_LOGI(TAG, "Set Window: Start: %d %d, End: %d %d, Offset: %d %d, Total: %d %d, Output: %d %d, Scale: %u, Binning: %u", startX, startY, endX, endY, offsetX, offsetY, totalX, totalY, outputX, outputY, scale, binning);
sensor_t *s = esp_camera_sensor_get();
int res = s->set_res_raw(s, startX, startY, endX, endY, offsetX, offsetY, totalX, totalY, outputX, outputY, scale, binning);
if (res)
{
return httpd_resp_send_500(req);
}
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
return httpd_resp_send(req, NULL, 0);
}
static esp_err_t index_handler(httpd_req_t *req)
{
extern const unsigned char index_ov2640_html_gz_start[] asm("_binary_index_ov2640_html_gz_start");
extern const unsigned char index_ov2640_html_gz_end[] asm("_binary_index_ov2640_html_gz_end");
size_t index_ov2640_html_gz_len = index_ov2640_html_gz_end - index_ov2640_html_gz_start;
extern const unsigned char index_ov3660_html_gz_start[] asm("_binary_index_ov3660_html_gz_start");
extern const unsigned char index_ov3660_html_gz_end[] asm("_binary_index_ov3660_html_gz_end");
size_t index_ov3660_html_gz_len = index_ov3660_html_gz_end - index_ov3660_html_gz_start;
extern const unsigned char index_ov5640_html_gz_start[] asm("_binary_index_ov5640_html_gz_start");
extern const unsigned char index_ov5640_html_gz_end[] asm("_binary_index_ov5640_html_gz_end");
size_t index_ov5640_html_gz_len = index_ov5640_html_gz_end - index_ov5640_html_gz_start;
httpd_resp_set_type(req, "text/html");
httpd_resp_set_hdr(req, "Content-Encoding", "gzip");
sensor_t *s = esp_camera_sensor_get();
if (s != NULL)
{
if (s->id.PID == OV3660_PID)
{
return httpd_resp_send(req, (const char *)index_ov3660_html_gz_start, index_ov3660_html_gz_len);
}
else if (s->id.PID == OV5640_PID)
{
return httpd_resp_send(req, (const char *)index_ov5640_html_gz_start, index_ov5640_html_gz_len);
}
else
{
return httpd_resp_send(req, (const char *)index_ov2640_html_gz_start, index_ov2640_html_gz_len);
}
}
else
{
ESP_LOGE(TAG, "Camera sensor not found");
return httpd_resp_send_500(req);
}
}
static esp_err_t monitor_handler(httpd_req_t *req)
{
extern const unsigned char monitor_html_gz_start[] asm("_binary_monitor_html_gz_start");
extern const unsigned char monitor_html_gz_end[] asm("_binary_monitor_html_gz_end");
size_t monitor_html_gz_len = monitor_html_gz_end - monitor_html_gz_start;
httpd_resp_set_type(req, "text/html");
httpd_resp_set_hdr(req, "Content-Encoding", "gzip");
return httpd_resp_send(req, (const char *)monitor_html_gz_start, monitor_html_gz_len);
}
void app_httpd_main()
{
httpd_config_t config = HTTPD_DEFAULT_CONFIG();
config.max_uri_handlers = 12;
httpd_uri_t index_uri = {
.uri = "/",
.method = HTTP_GET,
.handler = index_handler,
.user_ctx = NULL};
httpd_uri_t status_uri = {
.uri = "/status",
.method = HTTP_GET,
.handler = status_handler,
.user_ctx = NULL};
httpd_uri_t cmd_uri = {
.uri = "/control",
.method = HTTP_GET,
.handler = cmd_handler,
.user_ctx = NULL};
httpd_uri_t capture_uri = {
.uri = "/capture",
.method = HTTP_GET,
.handler = capture_handler,
.user_ctx = NULL};
httpd_uri_t stream_uri = {
.uri = "/stream",
.method = HTTP_GET,
.handler = stream_handler,
.user_ctx = NULL};
httpd_uri_t xclk_uri = {
.uri = "/xclk",
.method = HTTP_GET,
.handler = xclk_handler,
.user_ctx = NULL};
httpd_uri_t reg_uri = {
.uri = "/reg",
.method = HTTP_GET,
.handler = reg_handler,
.user_ctx = NULL};
httpd_uri_t greg_uri = {
.uri = "/greg",
.method = HTTP_GET,
.handler = greg_handler,
.user_ctx = NULL};
httpd_uri_t pll_uri = {
.uri = "/pll",
.method = HTTP_GET,
.handler = pll_handler,
.user_ctx = NULL};
httpd_uri_t win_uri = {
.uri = "/resolution",
.method = HTTP_GET,
.handler = win_handler,
.user_ctx = NULL};
httpd_uri_t mdns_uri = {
.uri = "/mdns",
.method = HTTP_GET,
.handler = mdns_handler,
.user_ctx = NULL};
httpd_uri_t monitor_uri = {
.uri = "/monitor",
.method = HTTP_GET,
.handler = monitor_handler,
.user_ctx = NULL};
ESP_LOGI(TAG, "Starting web server on port: '%d'", config.server_port);
if (httpd_start(&camera_httpd, &config) == ESP_OK)
{
httpd_register_uri_handler(camera_httpd, &index_uri);
httpd_register_uri_handler(camera_httpd, &cmd_uri);
httpd_register_uri_handler(camera_httpd, &status_uri);
httpd_register_uri_handler(camera_httpd, &capture_uri);
httpd_register_uri_handler(camera_httpd, &xclk_uri);
httpd_register_uri_handler(camera_httpd, &reg_uri);
httpd_register_uri_handler(camera_httpd, &greg_uri);
httpd_register_uri_handler(camera_httpd, &pll_uri);
httpd_register_uri_handler(camera_httpd, &win_uri);
httpd_register_uri_handler(camera_httpd, &mdns_uri);
httpd_register_uri_handler(camera_httpd, &monitor_uri);
}
config.server_port += 1;
config.ctrl_port += 1;
ESP_LOGI(TAG, "Starting stream server on port: '%d'", config.server_port);
if (httpd_start(&stream_httpd, &config) == ESP_OK)
{
httpd_register_uri_handler(stream_httpd, &stream_uri);
}
}

24
examples/camera_web_server/main/app_main.cpp
View File

@ -1,24 +0,0 @@
#include "app_camera.hpp"
#include "app_wifi.h"
#include "app_httpd.hpp"
#include "app_mdns.h"
#if CONFIG_LED_ILLUMINATOR_ENABLED
#include "app_led.h"
#endif
extern "C" void app_main()
{
app_wifi_main();
#if CONFIG_CAMERA_PIXEL_FORMAT_RGB565
app_camera_init(CAMERA_PIXEL_FORMAT, FRAMESIZE_QVGA, 2);
#else
app_camera_init(CAMERA_PIXEL_FORMAT, FRAMESIZE_UXGA, 2);
#endif
#if CONFIG_LED_ILLUMINATOR_ENABLED
app_led_init();
#endif
app_httpd_main();
app_mdns_main();
}

250
examples/camera_web_server/main/app_mdns.c
View File

@ -1,250 +0,0 @@
/*
* ESPRESSIF MIT License
*
* Copyright (c) 2020 <ESPRESSIF SYSTEMS (SHANGHAI) PTE LTD>
*
* Permission is hereby granted for use on ESPRESSIF SYSTEMS products only, in which case,
* it is free of charge, to any person obtaining a copy of this software and associated
* documentation files (the "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished
* to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
#include <string.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "esp_log.h"
#include "esp_wifi.h"
#include "esp_camera.h"
#include "mdns.h"
#include "app_define.h"
static const char *TAG = "camera mdns";
static const char * service_name = "_esp-cam";
static const char * proto = "_tcp";
static mdns_result_t * found_cams = NULL;
static SemaphoreHandle_t query_lock = NULL;
static char iname[64];
static char hname[64];
static char framesize[4];
static char pixformat[4];
static const char * model = NULL;
static void mdns_query_for_cams()
{
mdns_result_t * new_cams = NULL;
esp_err_t err = mdns_query_ptr(service_name, proto, 5000, 4, &new_cams);
if(err){
ESP_LOGE(TAG, "MDNS Query Failed: %s", esp_err_to_name(err));
return;
}
xSemaphoreTake(query_lock, portMAX_DELAY);
if (found_cams != NULL) {
mdns_query_results_free(found_cams);
}
found_cams = new_cams;
xSemaphoreGive(query_lock);
}
static void mdns_task(void * arg)
{
for (;;) {
mdns_query_for_cams();
//delay 55 seconds
vTaskDelay((55 * 1000) / portTICK_PERIOD_MS);
}
vTaskDelete(NULL);
}
/*
* Public Functions
*/
const char * app_mdns_query(size_t * out_len)
{
//build JSON
static char json_response[2048];
char *p = json_response;
*p++ = '[';
//add own data first
tcpip_adapter_ip_info_t ip;
if (strlen(CONFIG_ESP_WIFI_SSID)) {
tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &ip);
} else {
tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_AP, &ip);
}
*p++ = '{';
p += sprintf(p, "\"instance\":\"%s\",", iname);
p += sprintf(p, "\"host\":\"%s.local\",", hname);
p += sprintf(p, "\"port\":80,");
p += sprintf(p, "\"txt\":{");
p += sprintf(p, "\"pixformat\":\"%s\",", pixformat);
p += sprintf(p, "\"framesize\":\"%s\",", framesize);
p += sprintf(p, "\"stream_port\":\"81\",");
p += sprintf(p, "\"board\":\"%s\",", CAMERA_MODULE_NAME);
p += sprintf(p, "\"model\":\"%s\"", model);
*p++ = '}';
*p++ = ',';
p += sprintf(p, "\"ip\":\"" IPSTR "\",", IP2STR(&(ip.ip)));
p += sprintf(p, "\"id\":\"" IPSTR ":80\",", IP2STR(&(ip.ip)));
p += sprintf(p, "\"service\":\"%s\",", service_name);
p += sprintf(p, "\"proto\":\"%s\"", proto);
*p++ = '}';
xSemaphoreTake(query_lock, portMAX_DELAY);
if (found_cams) {
*p++ = ',';
}
mdns_result_t * r = found_cams;
mdns_ip_addr_t * a = NULL;
int t;
while(r){
*p++ = '{';
if(r->instance_name){
p += sprintf(p, "\"instance\":\"%s\",", r->instance_name);
}
if(r->hostname){
p += sprintf(p, "\"host\":\"%s.local\",", r->hostname);
p += sprintf(p, "\"port\":%u,", r->port);
}
if(r->txt_count){
p += sprintf(p, "\"txt\":{");
for(t=0; t<r->txt_count; t++){
if (t > 0) {
*p++ = ',';
}
p += sprintf(p, "\"%s\":\"%s\"", r->txt[t].key, r->txt[t].value?r->txt[t].value:"NULL");
}
*p++ = '}';
*p++ = ',';
}
a = r->addr;
while(a){
if(a->addr.type != IPADDR_TYPE_V6){
p += sprintf(p, "\"ip\":\"" IPSTR "\",", IP2STR(&(a->addr.u_addr.ip4)));
p += sprintf(p, "\"id\":\"" IPSTR ":%u\",", IP2STR(&(a->addr.u_addr.ip4)), r->port);
break;
}
a = a->next;
}
p += sprintf(p, "\"service\":\"%s\",", service_name);
p += sprintf(p, "\"proto\":\"%s\"", proto);
*p++ = '}';
r = r->next;
if (r) {
*p++ = ',';
}
}
xSemaphoreGive(query_lock);
*p++ = ']';
*out_len = (uint32_t)p - (uint32_t)json_response;
*p++ = '\0';
ESP_LOGI(TAG, "JSON: %uB", *out_len);
return (const char *)json_response;
}
void app_mdns_update_framesize(int size)
{
snprintf(framesize, 4, "%d", size);
if(mdns_service_txt_item_set(service_name, proto, "framesize", (char*)framesize)){
ESP_LOGE(TAG, "mdns_service_txt_item_set() framesize Failed");
}
}
void app_mdns_main()
{
uint8_t mac[6];
query_lock = xSemaphoreCreateBinary();
if (query_lock == NULL) {
ESP_LOGE(TAG, "xSemaphoreCreateMutex() Failed");
return;
}
xSemaphoreGive(query_lock);
sensor_t * s = esp_camera_sensor_get();
if(s == NULL){
return;
}
switch(s->id.PID){
case OV2640_PID: model = "OV2640"; break;
case OV3660_PID: model = "OV3660"; break;
case OV5640_PID: model = "OV5640"; break;
case OV7725_PID: model = "OV7725"; break;
default: model = "UNKNOWN"; break;
}
if (strlen(CONFIG_ESP_HOST_NAME) > 0) {
snprintf(iname, 64, "%s", CONFIG_ESP_HOST_NAME);
} else {
if (esp_read_mac(mac, ESP_MAC_WIFI_STA) != ESP_OK) {
ESP_LOGE(TAG, "esp_read_mac() Failed");
return;
}
snprintf(iname, 64, "%s-%s-%02X%02X%02X", CAMERA_MODULE_NAME, model, mac[3], mac[4], mac[5]);
}
snprintf(framesize, 4, "%d", s->status.framesize);
snprintf(pixformat, 4, "%d", s->pixformat);
char * src = iname, * dst = hname, c;
while (*src) {
c = *src++;
if (c >= 'A' && c <= 'Z') {
c -= 'A' - 'a';
}
*dst++ = c;
}
*dst++ = '\0';
if(mdns_init() != ESP_OK){
ESP_LOGE(TAG, "mdns_init() Failed");
return;
}
if(mdns_hostname_set(hname) != ESP_OK){
ESP_LOGE(TAG, "mdns_hostname_set(\"%s\") Failed", hname);
return;
}
if(mdns_instance_name_set(iname) != ESP_OK){
ESP_LOGE(TAG, "mdns_instance_name_set(\"%s\") Failed", iname);
return;
}
if(mdns_service_add(NULL, "_http", "_tcp", 80, NULL, 0) != ESP_OK){
ESP_LOGE(TAG, "mdns_service_add() HTTP Failed");
return;
}
mdns_txt_item_t camera_txt_data[] = {
{(char*)"board" ,(char*)CAMERA_MODULE_NAME},
{(char*)"model" ,(char*)model},
{(char*)"stream_port" ,(char*)"81"},
{(char*)"framesize" ,(char*)framesize},
{(char*)"pixformat" ,(char*)pixformat}
};
if(mdns_service_add(NULL, service_name, proto, 80, camera_txt_data, 5)) {
ESP_LOGE(TAG, "mdns_service_add() ESP-CAM Failed");
return;
}
xTaskCreate(mdns_task, "mdns-cam", 2048, NULL, 2, NULL);
}

196
examples/camera_web_server/main/app_wifi.c
View File

@ -1,196 +0,0 @@
/* ESPRESSIF MIT License
*
* Copyright (c) 2018 <ESPRESSIF SYSTEMS (SHANGHAI) PTE LTD>
*
* Permission is hereby granted for use on all ESPRESSIF SYSTEMS products, in which case,
* it is free of charge, to any person obtaining a copy of this software and associated
* documentation files (the "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished
* to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event_loop.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "sdkconfig.h"
#include "lwip/err.h"
#include "lwip/sys.h"
#include "mdns.h"
/* The examples use 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"
*/
#define EXAMPLE_ESP_WIFI_SSID CONFIG_ESP_WIFI_SSID
#define EXAMPLE_ESP_WIFI_PASS CONFIG_ESP_WIFI_PASSWORD
#define EXAMPLE_ESP_MAXIMUM_RETRY CONFIG_ESP_MAXIMUM_RETRY
#define EXAMPLE_ESP_WIFI_AP_SSID CONFIG_ESP_WIFI_AP_SSID
#define EXAMPLE_ESP_WIFI_AP_PASS CONFIG_ESP_WIFI_AP_PASSWORD
#define EXAMPLE_MAX_STA_CONN CONFIG_MAX_STA_CONN
#define EXAMPLE_IP_ADDR CONFIG_SERVER_IP
#define EXAMPLE_ESP_WIFI_AP_CHANNEL CONFIG_ESP_WIFI_AP_CHANNEL
static const char *TAG = "camera wifi";
static int s_retry_num = 0;
static esp_err_t event_handler(void *ctx, system_event_t *event)
{
switch (event->event_id)
{
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);
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);
break;
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_retry_num = 0;
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
{
if (s_retry_num < EXAMPLE_ESP_MAXIMUM_RETRY)
{
esp_wifi_connect();
s_retry_num++;
ESP_LOGI(TAG, "retry to connect to the AP");
}
ESP_LOGI(TAG, "connect to the AP fail");
break;
}
default:
break;
}
mdns_handle_system_event(ctx, event);
return ESP_OK;
}
void wifi_init_softap()
{
if (strcmp(EXAMPLE_IP_ADDR, "192.168.4.1"))
{
int a, b, c, d;
sscanf(EXAMPLE_IP_ADDR, "%d.%d.%d.%d", &a, &b, &c, &d);
tcpip_adapter_ip_info_t ip_info;
IP4_ADDR(&ip_info.ip, a, b, c, d);
IP4_ADDR(&ip_info.gw, a, b, c, d);
IP4_ADDR(&ip_info.netmask, 255, 255, 255, 0);
ESP_ERROR_CHECK(tcpip_adapter_dhcps_stop(WIFI_IF_AP));
ESP_ERROR_CHECK(tcpip_adapter_set_ip_info(WIFI_IF_AP, &ip_info));
ESP_ERROR_CHECK(tcpip_adapter_dhcps_start(WIFI_IF_AP));
}
wifi_config_t wifi_config;
memset(&wifi_config, 0, sizeof(wifi_config_t));
snprintf((char *)wifi_config.ap.ssid, 32, "%s", EXAMPLE_ESP_WIFI_AP_SSID);
wifi_config.ap.ssid_len = strlen((char *)wifi_config.ap.ssid);
snprintf((char *)wifi_config.ap.password, 64, "%s", EXAMPLE_ESP_WIFI_AP_PASS);
wifi_config.ap.max_connection = EXAMPLE_MAX_STA_CONN;
wifi_config.ap.authmode = WIFI_AUTH_WPA_WPA2_PSK;
if (strlen(EXAMPLE_ESP_WIFI_AP_PASS) == 0)
{
wifi_config.ap.authmode = WIFI_AUTH_OPEN;
}
if (strlen(EXAMPLE_ESP_WIFI_AP_CHANNEL))
{
int channel;
sscanf(EXAMPLE_ESP_WIFI_AP_CHANNEL, "%d", &channel);
wifi_config.ap.channel = channel;
}
ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_AP, &wifi_config));
ESP_LOGI(TAG, "wifi_init_softap finished.SSID:%s password:%s",
EXAMPLE_ESP_WIFI_AP_SSID, EXAMPLE_ESP_WIFI_AP_PASS);
}
void wifi_init_sta()
{
wifi_config_t wifi_config;
memset(&wifi_config, 0, sizeof(wifi_config_t));
snprintf((char *)wifi_config.sta.ssid, 32, "%s", EXAMPLE_ESP_WIFI_SSID);
snprintf((char *)wifi_config.sta.password, 64, "%s", EXAMPLE_ESP_WIFI_PASS);
ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));
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);
}
void app_wifi_main()
{
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
wifi_mode_t mode = WIFI_MODE_NULL;
if (strlen(EXAMPLE_ESP_WIFI_AP_SSID) && strlen(EXAMPLE_ESP_WIFI_SSID))
{
mode = WIFI_MODE_APSTA;
}
else if (strlen(EXAMPLE_ESP_WIFI_AP_SSID))
{
mode = WIFI_MODE_AP;
}
else if (strlen(EXAMPLE_ESP_WIFI_SSID))
{
mode = WIFI_MODE_STA;
}
esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND)
{
ESP_ERROR_CHECK(nvs_flash_erase());
ret = nvs_flash_init();
}
ESP_ERROR_CHECK(ret);
if (mode == WIFI_MODE_NULL)
{
ESP_LOGW(TAG, "Neither AP or STA have been configured. WiFi will be off.");
return;
}
tcpip_adapter_init();
ESP_ERROR_CHECK(esp_event_loop_init(event_handler, NULL));
ESP_ERROR_CHECK(esp_wifi_init(&cfg));
ESP_ERROR_CHECK(esp_wifi_set_mode(mode));
if (mode & WIFI_MODE_AP)
{
wifi_init_softap();
}
if (mode & WIFI_MODE_STA)
{
wifi_init_sta();
}
ESP_ERROR_CHECK(esp_wifi_start());
ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE));
}

6
examples/camera_web_server/main/include/app_httpd.hpp
View File

@ -1,6 +0,0 @@
#pragma once
#include "esp_http_server.h"
void app_httpd_main();

16
examples/camera_web_server/main/include/app_mdns.h
View File

@ -1,16 +0,0 @@
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
#include <stddef.h>
void app_mdns_main();
void app_mdns_update_framesize(int size);
const char *app_mdns_query(size_t *out_len);
#ifdef __cplusplus
}
#endif

37
examples/camera_web_server/main/include/app_wifi.h
View File

@ -1,37 +0,0 @@
/*
* ESPRESSIF MIT License
*
* Copyright (c) 2017 <ESPRESSIF SYSTEMS (SHANGHAI) PTE LTD>
*
* Permission is hereby granted for use on ESPRESSIF SYSTEMS products only, in which case,
* it is free of charge, to any person obtaining a copy of this software and associated
* documentation files (the "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the Software is furnished
* to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
#ifndef _APP_WIFI_H_
#define _APP_WIFI_H_
#ifdef __cplusplus
extern "C" {
#endif
void app_wifi_main();
#ifdef __cplusplus
}
#endif
#endif

7
examples/camera_web_server/main/www/compress_pages.sh
View File

@ -1,7 +0,0 @@
#!/bin/bash
for file in `ls *.html`; do
echo "Compressing: $file"
cp "$file" "copy_$file" && \
gzip -f "$file" && \
mv "copy_$file" "$file"
done

1152
examples/camera_web_server/main/www/index_ov2640.html
View File

File diff suppressed because it is too large Load Diff

BIN
examples/camera_web_server/main/www/index_ov2640.html.gz
View File

Binary file not shown.

1368
examples/camera_web_server/main/www/index_ov3660.html
View File

File diff suppressed because it is too large Load Diff

BIN
examples/camera_web_server/main/www/index_ov3660.html.gz
View File

Binary file not shown.

1391
examples/camera_web_server/main/www/index_ov5640.html
View File

File diff suppressed because it is too large Load Diff

BIN
examples/camera_web_server/main/www/index_ov5640.html.gz
View File

Binary file not shown.

1012
examples/camera_web_server/main/www/monitor.html
View File

File diff suppressed because one or more lines are too long

BIN
examples/camera_web_server/main/www/monitor.html.gz
View File

Binary file not shown.

4
examples/camera_web_server/partitions.csv
View File

@ -1,4 +0,0 @@
# Espressif ESP32 Partition Table
# Name, Type, SubType, Offset, Size
factory, app, factory, 0x010000, 3840K
nvs, data, nvs, 0x3D0000, 16K
1 # Espressif ESP32 Partition Table
2 # Name, Type, SubType, Offset, Size
3 factory, app, factory, 0x010000, 3840K
4 nvs, data, nvs, 0x3D0000, 16K

22
examples/camera_web_server/sdkconfig.defaults
View File

@ -1,22 +0,0 @@
CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
CONFIG_ESPTOOLPY_FLASHMODE_QIO=y
CONFIG_SPIRAM_SPEED_80M=y
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
CONFIG_ESP_TASK_WDT=n
CONFIG_DL_DETECT_ENABLED=y
CONFIG_DL_DETECT_HUMAN_FACE=y
CONFIG_DL_DETECT_HUMAN_FACE_WITH_KEYPOINT=y
CONFIG_DL_RECOGNIZE_HUMAN_FACE=y
# Wait for esp-idf stable
CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_PERF=y
CONFIG_BOOTLOADER_LOG_LEVEL_NONE=y
CONFIG_SPIRAM_MEMTEST=n

5
examples/camera_web_server/sdkconfig.defaults.esp32
View File

@ -1,5 +0,0 @@
CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP32_SPIRAM_SUPPORT=y
CONFIG_CAMERA_MODULE_ESP_EYE=y
CONFIG_CAMERA_PIXEL_FORMAT_JPEG=y

2
examples/camera_web_server/sdkconfig.defaults.esp32s2
View File

@ -1,2 +0,0 @@
CONFIG_ESP32S2_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP32S2_SPIRAM_SUPPORT=y

7
examples/camera_web_server/sdkconfig.defaults.esp32s3
View File

@ -1,7 +0,0 @@
CONFIG_ESP32S3_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP32S3_SPIRAM_SUPPORT=y
CONFIG_CAMERA_MODULE_ESP_S3_EYE=y
CONFIG_CAMERA_PIXEL_FORMAT_RGB565=y
CONFIG_ESPTOOLPY_NO_STUB=y
CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=y