mirror of
https://github.com/espressif/esp32-camera.git
synced 2025-08-24 16:01:17 +08:00
408 lines
11 KiB
C
408 lines
11 KiB
C
// Copyright 2015-2021 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 <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "sccb.h"
|
|
#include "mega_ccm.h"
|
|
#include "mega_ccm_regs.h"
|
|
#include "mega_ccm_settings.h"
|
|
|
|
#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
|
|
#include "esp32-hal-log.h"
|
|
#else
|
|
#include "esp_log.h"
|
|
static const char *TAG = "mega_ccm";
|
|
#endif
|
|
|
|
#define H8(v) ((v)>>8)
|
|
#define L8(v) ((v)&0xff)
|
|
|
|
//#define REG_DEBUG_ON
|
|
|
|
|
|
static int read_reg(uint8_t slv_addr, const uint16_t reg){
|
|
int ret = SCCB_Read16(slv_addr, reg);
|
|
#ifdef REG_DEBUG_ON
|
|
if (ret < 0) {
|
|
ESP_LOGE(TAG, "READ REG 0x%04x FAILED: %d", reg, ret);
|
|
}
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
static int write_reg(uint8_t slv_addr, const uint16_t reg, uint8_t value){
|
|
int ret = 0;
|
|
ret = SCCB_Write16(slv_addr, reg, value);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int reset(sensor_t *sensor)
|
|
{
|
|
int ret;
|
|
ret = write_reg(sensor->slv_addr, CAMERA_RST_REG, 0x00);
|
|
ret += write_reg(sensor->slv_addr, CAMERA_RST_REG, 0x01);
|
|
vTaskDelay(1000 / portTICK_PERIOD_MS);
|
|
return ret;
|
|
}
|
|
|
|
static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
|
|
{
|
|
int ret = 0;
|
|
switch (pixformat) {
|
|
case PIXFORMAT_JPEG:
|
|
ret = write_reg(sensor->slv_addr, PIXEL_FMT_REG, 0x01);
|
|
break;
|
|
case PIXFORMAT_RGB565:
|
|
ret = write_reg(sensor->slv_addr, PIXEL_FMT_REG, 0x02);
|
|
break;
|
|
case PIXFORMAT_YUV422:
|
|
ret = write_reg(sensor->slv_addr, PIXEL_FMT_REG, 0x03);
|
|
break;
|
|
default:
|
|
ESP_LOGW(TAG, "unsupport format");
|
|
ret = -1;
|
|
break;
|
|
}
|
|
if (ret == 0) {
|
|
sensor->pixformat = pixformat;
|
|
ESP_LOGD(TAG, "Set pixformat to: %u", pixformat);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int set_framesize(sensor_t *sensor, framesize_t framesize)
|
|
{
|
|
ESP_LOGI(TAG, "set_framesize");
|
|
int ret = 0;
|
|
if (framesize > FRAMESIZE_5MP) {
|
|
ESP_LOGW(TAG, "Invalid framesize: %u", framesize);
|
|
framesize = FRAMESIZE_5MP;
|
|
}
|
|
sensor->status.framesize = framesize;
|
|
uint16_t w = resolution[framesize].width;
|
|
uint16_t h = resolution[framesize].height;
|
|
switch (framesize){
|
|
case FRAMESIZE_QVGA:
|
|
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x01); //320x240
|
|
ret += write_reg(sensor->slv_addr, SYSTEM_CLK_DIV_REG, 0x02); // set system clk
|
|
ret += write_reg(sensor->slv_addr, SYSTEM_PLL_DIV_REG, 0x01); // set system pll
|
|
break;
|
|
case FRAMESIZE_VGA:
|
|
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x02); //640x480
|
|
ret += write_reg(sensor->slv_addr, SYSTEM_CLK_DIV_REG, 0x02); // set system clk
|
|
ret += write_reg(sensor->slv_addr, SYSTEM_PLL_DIV_REG, 0x01); // set system pll
|
|
break;
|
|
case FRAMESIZE_HD:
|
|
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x03); //1280x720
|
|
ret += write_reg(sensor->slv_addr, SYSTEM_CLK_DIV_REG, 0x02); // set system clk
|
|
ret += write_reg(sensor->slv_addr, SYSTEM_PLL_DIV_REG, 0x01); // set system pll
|
|
break;
|
|
case FRAMESIZE_UXGA:
|
|
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x04); //1600x1200
|
|
ret += write_reg(sensor->slv_addr, SYSTEM_CLK_DIV_REG, 0x02); // set system clk
|
|
ret += write_reg(sensor->slv_addr, SYSTEM_PLL_DIV_REG, 0x01); // set system pll
|
|
break;
|
|
case FRAMESIZE_FHD:
|
|
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x05); //1920x1080
|
|
ret += write_reg(sensor->slv_addr, SYSTEM_CLK_DIV_REG, 0x02); // set system clk
|
|
ret += write_reg(sensor->slv_addr, SYSTEM_PLL_DIV_REG, 0x01); // set system pll
|
|
break;
|
|
case FRAMESIZE_5MP:
|
|
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x06); //2592x1944
|
|
break;
|
|
case FRAMESIZE_96X96:
|
|
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x07); //96x96
|
|
break;
|
|
case FRAMESIZE_128X128:
|
|
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x08); //128x128
|
|
break;
|
|
case FRAMESIZE_320X320:
|
|
ret = write_reg(sensor->slv_addr, RESOLUTION_REG, 0x09); //320x320
|
|
break;
|
|
default:
|
|
ESP_LOGW(TAG, "unsupport framesize");
|
|
ret = -1;
|
|
break;
|
|
}
|
|
if (ret == 0) {
|
|
ESP_LOGD(TAG, "Set framesize to: %ux%u", w, h);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int set_hmirror(sensor_t *sensor, int enable)
|
|
{
|
|
int ret = 0;
|
|
sensor->status.hmirror = enable;
|
|
ret = write_reg(sensor->slv_addr, IMAGE_MIRROR_REG, enable);
|
|
if (ret == 0) {
|
|
ESP_LOGD(TAG, "Set h-mirror to: %d", enable);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int set_vflip(sensor_t *sensor, int enable)
|
|
{
|
|
int ret = 0;
|
|
sensor->status.vflip = enable;
|
|
ret = write_reg(sensor->slv_addr, IMAGE_FLIP_REG, enable);
|
|
if (ret == 0) {
|
|
ESP_LOGD(TAG, "Set v-flip to: %d", enable);
|
|
}
|
|
return ret;
|
|
}
|
|
static int set_quality(sensor_t *sensor, int qs)
|
|
{
|
|
int ret = 0;
|
|
ret = write_reg(sensor->slv_addr, IMAGE_QUALITY_REG, qs);
|
|
if (ret == 0) {
|
|
sensor->status.quality = qs;
|
|
ESP_LOGD(TAG, "Set quality to: %d", qs);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int set_brightness(sensor_t *sensor, int level)
|
|
{
|
|
int ret = 0;
|
|
if(level < 0) {
|
|
level = 0;
|
|
} else if(level > 8) {
|
|
level = 8;
|
|
}
|
|
ret = write_reg(sensor->slv_addr, BRIGHTNESS_REG, level);
|
|
if (ret == 0) {
|
|
ESP_LOGD(TAG, "Set brightness to: %d", level);
|
|
sensor->status.brightness = level;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int set_contrast (sensor_t *sensor, int level)
|
|
{
|
|
int ret = 0;
|
|
if(level < 0) {
|
|
level = 0;
|
|
} else if(level > 6) {
|
|
level = 6;
|
|
}
|
|
ret = write_reg(sensor->slv_addr, CONTRAST_REG, level);
|
|
if (ret == 0) {
|
|
ESP_LOGD(TAG, "Set contrast to: %d", level);
|
|
sensor->status.contrast = level;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int set_saturation (sensor_t *sensor, int level)
|
|
{
|
|
int ret = 0;
|
|
if(level < 0) {
|
|
level = 0;
|
|
} else if(level > 6) {
|
|
level = 6;
|
|
}
|
|
ret = write_reg(sensor->slv_addr, SATURATION_REG, level);
|
|
if (ret == 0) {
|
|
ESP_LOGD(TAG, "Set saturation to: %d", level);
|
|
sensor->status.saturation = level;
|
|
}
|
|
return ret;
|
|
}
|
|
static int set_agc_mode (sensor_t *sensor, int enable)
|
|
{
|
|
int ret = 0;
|
|
ret = write_reg(sensor->slv_addr, AGC_MODE_REG, enable);
|
|
if (ret == 0) {
|
|
ESP_LOGD(TAG, "Set agc mode to: %d", enable);
|
|
sensor->status.aec = enable;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int set_wb_mode (sensor_t *sensor, int mode)
|
|
{
|
|
int ret = 0;
|
|
if(mode < 0) {
|
|
mode = 0;
|
|
} else if(mode > 5) {
|
|
mode = 5;
|
|
}
|
|
ret = write_reg(sensor->slv_addr, AWB_MODE_REG, mode);
|
|
if (ret == 0) {
|
|
ESP_LOGD(TAG, "Set wb_mode to: %d", mode);
|
|
sensor->status.wb_mode = mode;
|
|
}
|
|
return ret;
|
|
|
|
}
|
|
|
|
static int set_special_effect (sensor_t *sensor, int effect)
|
|
{
|
|
|
|
int ret = 0;
|
|
if(effect < 0) {
|
|
effect = 0;
|
|
} else if(effect > 6) {
|
|
effect = 6;
|
|
}
|
|
ret = write_reg(sensor->slv_addr, SPECIAL_REG, effect);
|
|
if (ret == 0) {
|
|
ESP_LOGD(TAG, "Set special_effect to: %d", effect);
|
|
sensor->status.special_effect = effect;
|
|
}
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
static int analog_gain (sensor_t *sensor, int val)
|
|
{
|
|
|
|
int ret = 0;
|
|
ret = write_reg(sensor->slv_addr, MANUAL_AGC_REG, val);
|
|
if (ret == 0) {
|
|
ESP_LOGD(TAG, "Set analog gain to: %d", val);
|
|
}
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
static int exposure_line (sensor_t *sensor, int val)
|
|
{
|
|
|
|
int ret = 0;
|
|
ret = write_reg(sensor->slv_addr, MANUAL_EXP_H_REG, val>>8);
|
|
ret += write_reg(sensor->slv_addr, MANUAL_EXP_L_REG, val>>8);
|
|
if (ret == 0) {
|
|
ESP_LOGD(TAG, "Set exposure_line to: %d", val);
|
|
}
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
static int init_status(sensor_t *sensor)
|
|
{
|
|
sensor->status.brightness = 0;
|
|
sensor->status.contrast = 0;
|
|
sensor->status.saturation = 0;
|
|
sensor->status.sharpness = 0;
|
|
sensor->status.denoise = 0;
|
|
sensor->status.ae_level = 0;
|
|
sensor->status.gainceiling = 0;
|
|
sensor->status.awb = 0;
|
|
sensor->status.dcw = 0;
|
|
sensor->status.agc = 0;
|
|
sensor->status.aec = 0;
|
|
sensor->status.hmirror = 0;
|
|
sensor->status.vflip = 0;
|
|
sensor->status.colorbar = 0;
|
|
sensor->status.bpc = 0;
|
|
sensor->status.wpc = 0;
|
|
sensor->status.raw_gma = 0;
|
|
sensor->status.lenc = 0;
|
|
sensor->status.quality = 0;
|
|
sensor->status.special_effect = 0;
|
|
sensor->status.wb_mode = 0;
|
|
sensor->status.awb_gain = 0;
|
|
sensor->status.agc_gain = 0;
|
|
sensor->status.aec_value = 0;
|
|
sensor->status.aec2 = 0;
|
|
return 0;
|
|
}
|
|
|
|
static int set_dummy(sensor_t *sensor, int val)
|
|
{
|
|
ESP_LOGW(TAG, "Unsupported");
|
|
return -1;
|
|
}
|
|
static int set_gainceiling_dummy(sensor_t *sensor, gainceiling_t val)
|
|
{
|
|
ESP_LOGW(TAG, "Unsupported");
|
|
return -1;
|
|
}
|
|
|
|
int mega_ccm_detect(int slv_addr, sensor_id_t *id)
|
|
{
|
|
if (MEGA_CCM_SCCB_ADDR == slv_addr) {
|
|
uint8_t h = read_reg(slv_addr, SENSOR_ID_HIGH);
|
|
uint8_t l = read_reg(slv_addr, SENSOR_ID_LOW);
|
|
uint16_t PID = (h<<8) | l;
|
|
if (MEGA_CCM_PID == PID) {
|
|
id->PID = PID;
|
|
return PID;
|
|
} else {
|
|
ESP_LOGI(TAG, "Mismatch PID=0x%x", PID);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int mega_ccm_init(sensor_t *sensor)
|
|
{
|
|
sensor->init_status = init_status;
|
|
sensor->reset = reset;
|
|
sensor->set_pixformat = set_pixformat;
|
|
sensor->set_framesize = set_framesize;
|
|
sensor->set_contrast = set_contrast;
|
|
sensor->set_brightness = set_brightness;
|
|
sensor->set_saturation = set_saturation;
|
|
sensor->set_sharpness = set_dummy;
|
|
sensor->set_denoise = set_dummy;
|
|
sensor->set_gainceiling = set_gainceiling_dummy;
|
|
sensor->set_quality = set_quality;
|
|
sensor->set_colorbar = set_dummy;
|
|
sensor->set_whitebal = set_dummy;
|
|
sensor->set_gain_ctrl = set_dummy;
|
|
sensor->set_exposure_ctrl = set_dummy;
|
|
sensor->set_hmirror = set_hmirror;
|
|
sensor->set_vflip = set_vflip;
|
|
|
|
sensor->set_aec2 = set_agc_mode;
|
|
sensor->set_awb_gain = set_dummy;
|
|
sensor->set_agc_gain = analog_gain;
|
|
sensor->set_aec_value = exposure_line;
|
|
|
|
sensor->set_special_effect = set_special_effect;
|
|
sensor->set_wb_mode = set_wb_mode;
|
|
sensor->set_ae_level = set_dummy;
|
|
|
|
sensor->set_dcw = set_dummy;
|
|
sensor->set_bpc = set_dummy;
|
|
sensor->set_wpc = set_dummy;
|
|
|
|
sensor->set_raw_gma = set_dummy;
|
|
sensor->set_lenc = set_dummy;
|
|
|
|
sensor->get_reg = NULL;
|
|
sensor->set_reg = NULL;
|
|
sensor->set_res_raw = NULL;
|
|
sensor->set_pll = NULL;
|
|
sensor->set_xclk = NULL;
|
|
|
|
ESP_LOGD(TAG, "MEGA_CCM Attached");
|
|
return 0;
|
|
}
|