From 49edbbfac045810cee7c24bcc460ba2206963a7c Mon Sep 17 00:00:00 2001
From: yuxinwww <67987549+WangYuxin-esp@users.noreply.github.com>
Date: Tue, 18 Jan 2022 22:43:42 +0800
Subject: [PATCH] feat: add camera sensor bf3005 support (#350)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
BF3005 is a VGA CMOS Image Sensor.
The sensor is well stocked and comes with a series of image processing functions.
The support for this sensor is added here to facilitate the use of this sensor by more people. PTAL，Thanks.
---
CMakeLists.txt | 1 +
Kconfig | 7 +
README.md | 1 +
driver/esp_camera.c | 7 +-
driver/include/sensor.h | 3 +
driver/sensor.c | 1 +
sensors/bf3005.c | 541 ++++++++++++++++++++++++++
sensors/private_include/bf3005.h | 33 ++
sensors/private_include/bf3005_regs.h | 337 ++++++++++++++++
9 files changed, 930 insertions(+), 1 deletion(-)
create mode 100644 sensors/bf3005.c
create mode 100644 sensors/private_include/bf3005.h
create mode 100644 sensors/private_include/bf3005_regs.h
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5ceec97..8090f32 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,6 +13,7 @@ if(IDF_TARGET STREQUAL "esp32" OR IDF_TARGET STREQUAL "esp32s2" OR IDF_TARGET ST
sensors/gc0308.c
sensors/gc2145.c
sensors/gc032a.c
+ sensors/bf3005.c
conversions/yuv.c
conversions/to_jpg.cpp
conversions/to_bmp.c
diff --git a/Kconfig b/Kconfig
index b9bc842..dbf6708 100755
--- a/Kconfig
+++ b/Kconfig
@@ -62,6 +62,13 @@ menu "Camera configuration"
help
Enable this option if you want to use the GC0308.
Disable this option to save memory.
+
+ config BF3005_SUPPORT
+ bool "Support BF3005(BYD3005) VGA"
+ default y
+ help
+ Enable this option if you want to use the BF3005.
+ Disable this option to save memory.
choice SCCB_HARDWARE_I2C_PORT
bool "I2C peripheral to use for SCCB"
diff --git a/README.md b/README.md
index e93d5cd..de61a5b 100644
--- a/README.md
+++ b/README.md
@@ -24,6 +24,7 @@ This repository hosts ESP32 series Soc compatible driver for image sensors. Addi
| GC032A | 640 x 480 | color | YUV/YCbCr422
RAW Bayer
RGB565 | 1/10" |
| GC0308 | 640 x 480 | color | YUV/YCbCr422
RAW Bayer
RGB565 | 1/6.5" |
| GC2145 | 1600 x 1200 | color | YUV/YCbCr422
RAW Bayer
RGB565 | 1/5" |
+| BF3005 | 640 x 480 | color | YUV/YCbCr422
RAW Bayer
RGB565 | 1/4" |
## Important to Remember
diff --git a/driver/esp_camera.c b/driver/esp_camera.c
index 9ae1b56..5b671c0 100644
--- a/driver/esp_camera.c
+++ b/driver/esp_camera.c
@@ -54,7 +54,9 @@
#if CONFIG_GC0308_SUPPORT
#include "gc0308.h"
#endif
-
+#if CONFIG_BF3005_SUPPORT
+#include "bf3005.h"
+#endif
#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
#include "esp32-hal-log.h"
@@ -114,6 +116,9 @@ static const sensor_func_t g_sensors[] = {
#if CONFIG_GC0308_SUPPORT
{gc0308_detect, gc0308_init},
#endif
+#if CONFIG_BF3005_SUPPORT
+ {bf3005_detect, bf3005_init},
+#endif
};
static esp_err_t camera_probe(const camera_config_t *config, camera_model_t *out_camera_model)
diff --git a/driver/include/sensor.h b/driver/include/sensor.h
index 1f99c15..b2bf55f 100755
--- a/driver/include/sensor.h
+++ b/driver/include/sensor.h
@@ -26,6 +26,7 @@ typedef enum {
GC2145_PID = 0x2145,
GC032A_PID = 0x232a,
GC0308_PID = 0x9b,
+ BF3005_PID = 0x30,
} camera_pid_t;
typedef enum {
@@ -38,6 +39,7 @@ typedef enum {
CAMERA_GC2145,
CAMERA_GC032A,
CAMERA_GC0308,
+ CAMERA_BF3005,
CAMERA_MODEL_MAX,
CAMERA_NONE,
} camera_model_t;
@@ -52,6 +54,7 @@ typedef enum {
GC2145_SCCB_ADDR = 0x3C,// 0x78 >> 1
GC032A_SCCB_ADDR = 0x21,// 0x42 >> 1
GC0308_SCCB_ADDR = 0x21,// 0x42 >> 1
+ BF3005_SCCB_ADDR = 0x6E,
} camera_sccb_addr_t;
typedef enum {
diff --git a/driver/sensor.c b/driver/sensor.c
index 7ebd7af..bf6d313 100644
--- a/driver/sensor.c
+++ b/driver/sensor.c
@@ -12,6 +12,7 @@ const camera_sensor_info_t camera_sensor[CAMERA_MODEL_MAX] = {
{CAMERA_GC2145, "GC2145", GC2145_SCCB_ADDR, GC2145_PID, FRAMESIZE_UXGA, false},
{CAMERA_GC032A, "GC032A", GC032A_SCCB_ADDR, GC032A_PID, FRAMESIZE_VGA, false},
{CAMERA_GC0308, "GC0308", GC0308_SCCB_ADDR, GC0308_PID, FRAMESIZE_VGA, false},
+ {CAMERA_BF3005, "BF3005", BF3005_SCCB_ADDR, BF3005_PID, FRAMESIZE_VGA, false},
};
const resolution_info_t resolution[FRAMESIZE_INVALID] = {
diff --git a/sensors/bf3005.c b/sensors/bf3005.c
new file mode 100644
index 0000000..5a6166e
--- /dev/null
+++ b/sensors/bf3005.c
@@ -0,0 +1,541 @@
+/*
+ * This file is part of the OpenMV project.
+ * Copyright (c) 2013/2014 Ibrahim Abdelkader
+ * This work is licensed under the MIT license, see the file LICENSE for details.
+ *
+ * BF3005 driver.
+ *
+ * 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
+#include
+#include
+#include
+#include "sccb.h"
+#include "xclk.h"
+#include "bf3005.h"
+#include "bf3005_regs.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.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 = "bf3005";
+#endif
+
+static const uint8_t default_regs[][2] = {
+ {0x12, 0x40}, //soft reset
+ {0xff, 0xff}, //delay
+ {0xff, 0xff}, //delay
+ {0xff, 0xff}, //delay
+ {0xff, 0xff}, //delay
+ {0x13, 0x10},
+ {0x8c, 0x00},
+ {0x8d, 0x64},
+ {0x87, 0x10},
+ {0x13, 0x17},
+ {0x00, 0x20},
+ {0x01, 0x1a},
+ {0x02, 0x22},
+ {0x09, 0x03},
+ {0x0c, 0x80},
+ {0x0d, 0x24},
+ {0x0e, 0x21},
+ {0x0f, 0x28},
+ {0x11, 0x08},
+ {0x15, 0x10}, // 0X10
+ {0x16, 0x03},
+ {0x1e, 0x30},
+ {0x20, 0x8a},
+ {0x21, 0x03},
+ {0x23, 0x55},
+ {0x24, 0x68},
+ {0x25, 0x78},
+ {0x2a, 0x00},
+ {0x2b, 0x00},
+ {0x2d, 0x4f},
+ {0x2e, 0x98},
+ {0x2f, 0x04},
+ {0x30, 0xad},
+ {0x31, 0x17},
+ {0x32, 0x6e},
+ {0x33, 0x20},
+ {0x35, 0xa6},
+ {0x3b, 0x00},
+ {0x3e, 0x00},
+ {0x3f, 0xA8},
+ {0x40, 0x38},
+ {0x41, 0x32},
+ {0x42, 0x2b},
+ {0x43, 0x26},
+ {0x44, 0x1a},
+ {0x45, 0x16},
+ {0x46, 0x10},
+ {0x47, 0x0f},
+ {0x48, 0x0c},
+ {0x49, 0x0a},
+ {0x4b, 0x09},
+ {0x4c, 0x08},
+ {0x4d, 0x3c},
+ {0x4e, 0x06},
+ {0x4f, 0x05},
+ {0x50, 0x03},
+ {0x51, 0x25},
+ {0x52, 0x88},
+ {0x53, 0x03},
+ {0x63, 0x20},
+ {0x64, 0x02},
+ {0x65, 0xa6},
+ {0x66, 0xb6},
+ {0x69, 0x00},
+ {0x70, 0xFF},
+ {0x71, 0xa6},
+ {0x72, 0x2f},
+ {0x73, 0x2f},
+ {0x74, 0x2F},
+ {0x75, 0x0e},
+ {0x76, 0x1e},
+ {0x77, 0x00},
+ {0x78, 0x1e},
+ {0x79, 0x8a},
+ {0x7d, 0xe2},
+ {0x80, 0x44},
+ {0x81, 0x00},
+ {0x82, 0x18},
+ {0x83, 0x1b},
+ {0x84, 0x24},
+ {0x85, 0x2a},
+ {0x86, 0x4f},
+ {0x89, 0x82}, //0x82
+ {0x8b, 0x02},
+ {0x8e, 0x03},
+ {0x8f, 0xFC},
+ {0x9d, 0x4d},
+ {0x9e, 0x41},
+ {0xa1, 0x21},
+ {0xa2, 0x12},
+ {0xa3, 0x32},
+ {0xa4, 0x05},
+ {0xa5, 0x32},
+ {0xa6, 0x04},
+ {0xa7, 0x7f},
+ {0xa8, 0x7f},
+ {0xa9, 0x21},
+ {0xaa, 0x21},
+ {0xab, 0x21},
+ {0xac, 0x0a},
+ {0xad, 0xf0},
+ {0xae, 0xff},
+ {0xaf, 0x1d},
+ {0xb0, 0x94},
+ {0xb1, 0xc0},
+ {0xb2, 0xc0},
+ {0xd2, 0x30},
+ {0xe0, 0x0d},
+ {0xe1, 0x44},
+ {0xe7, 0x7c},
+ {0xe8, 0x89},
+ {0xe9, 0x01},
+ {0xea, 0x01},
+ {0xf0, 0x01},
+ {0xf3, 0x49},
+ {0xf4, 0xff},
+ {0xf5, 0x01},
+ {0xf6, 0xf2},
+ {0xf7, 0x6f},
+ {0x1b, 0x80},
+ {0x00, 0x00},
+};
+
+static int get_reg(sensor_t *sensor, int reg, int mask)
+{
+ int ret = SCCB_Read(sensor->slv_addr, reg & 0xFF);
+ if(ret > 0){
+ ret &= mask;
+ }
+ return ret;
+}
+
+static int set_reg(sensor_t *sensor, int reg, int mask, int value)
+{
+ int ret = 0;
+ ret = SCCB_Read(sensor->slv_addr, reg & 0xFF);
+ if(ret < 0){
+ return ret;
+ }
+ value = (ret & ~mask) | (value & mask);
+ ret = SCCB_Write(sensor->slv_addr, reg & 0xFF, value);
+ return ret;
+}
+
+static int set_reg_bits(sensor_t *sensor, uint8_t reg, uint8_t offset, uint8_t length, uint8_t value)
+{
+ int ret = 0;
+ ret = SCCB_Read(sensor->slv_addr, reg);
+ if(ret < 0){
+ return ret;
+ }
+ uint8_t mask = ((1 << length) - 1) << offset;
+ value = (ret & ~mask) | ((value << offset) & mask);
+ ret = SCCB_Write(sensor->slv_addr, reg & 0xFF, value);
+ return ret;
+}
+
+static int get_reg_bits(sensor_t *sensor, uint8_t reg, uint8_t offset, uint8_t length)
+{
+ int ret = 0;
+ ret = SCCB_Read(sensor->slv_addr, reg);
+ if(ret < 0){
+ return ret;
+ }
+ uint8_t mask = ((1 << length) - 1) << offset;
+ return (ret & mask) >> offset;
+}
+
+
+static int reset(sensor_t *sensor)
+{
+ int i=0;
+ const uint8_t (*regs)[2];
+
+ // Write default regsiters
+ for (i=0, regs = default_regs; regs[i][0]; i++) {
+ SCCB_Write(sensor->slv_addr, regs[i][0], regs[i][1]);
+ }
+
+ // Delay
+ vTaskDelay(50 / portTICK_PERIOD_MS);
+
+ return 0;
+}
+
+static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
+{
+ int ret=0;
+ sensor->pixformat = pixformat;
+
+ switch (pixformat) {
+ case PIXFORMAT_RGB565:
+ set_reg_bits(sensor, 0x12, 2, 1, 1);
+ break;
+ case PIXFORMAT_RAW:
+ set_reg_bits(sensor, 0x12, 0, 3, 0x4);
+ break;
+ case PIXFORMAT_YUV422:
+ case PIXFORMAT_GRAYSCALE:
+ set_reg_bits(sensor, 0x12, 2, 1, 0);
+ break;
+ default:
+ return -1;
+ }
+
+ // Delay
+ vTaskDelay(30 / portTICK_PERIOD_MS);
+
+ return ret;
+}
+
+static int set_framesize(sensor_t *sensor, framesize_t framesize)
+{
+ int ret=0;
+ if (framesize > FRAMESIZE_VGA) {
+ return -1;
+ }
+ uint16_t w = resolution[framesize].width;
+ uint16_t h = resolution[framesize].height;
+ // uint8_t reg = SCCB_Read(sensor->slv_addr, COM7);
+
+ sensor->status.framesize = framesize;
+
+ // Write MSBs
+ ret |= SCCB_Write(sensor->slv_addr, 0x17, 0);
+ ret |= SCCB_Write(sensor->slv_addr, 0x18, w>>2);
+
+ ret |= SCCB_Write(sensor->slv_addr, 0x19, 0);
+ ret |= SCCB_Write(sensor->slv_addr, 0x1a, h>>2);
+
+ // Write LSBs
+ ret |= SCCB_Write(sensor->slv_addr, 0x03, 0);
+ printf("%s %d\r\n", __func__, __LINE__);
+ if((w<=320)&&(h<=240))
+ {
+ printf("%s %d\r\n", __func__, __LINE__);
+ // Enable auto-scaling/zooming factors
+ //ret |= SCCB_Write(sensor->slv_addr, 0x12, 0x50);
+ set_reg_bits(sensor, 0x12, 4, 1, 1);
+
+ ret |= SCCB_Write(sensor->slv_addr, 0x17, (80-w/4));
+ ret |= SCCB_Write(sensor->slv_addr, 0x18, (80+w/4));
+
+ ret |= SCCB_Write(sensor->slv_addr, 0x19, (60-h/4));
+
+ ret |= SCCB_Write(sensor->slv_addr, 0x1a, (60+h/4));
+ ret |= SCCB_Write(sensor->slv_addr, 0x03, 0);
+
+ } else if((w<=640)&&(h<=480))
+ {
+ // Enable auto-scaling/zooming factors
+ //ret |= SCCB_Write(sensor->slv_addr, 0x12, 0x40);
+ set_reg_bits(sensor, 0x12, 4, 1, 0);
+
+ ret |= SCCB_Write(sensor->slv_addr, 0x17, (80-w/8));
+ ret |= SCCB_Write(sensor->slv_addr, 0x18, (80+w/8));
+
+ ret |= SCCB_Write(sensor->slv_addr, 0x19, (60-h/8));
+
+ ret |= SCCB_Write(sensor->slv_addr, 0x1a, (60+h/8));
+ ret |= SCCB_Write(sensor->slv_addr, 0x03, 0);
+ }
+
+ // Delay
+ vTaskDelay(30 / portTICK_PERIOD_MS);
+
+ return ret;
+}
+
+static int set_colorbar(sensor_t *sensor, int value)
+{
+ int ret=0;
+ sensor->status.colorbar = value;
+
+ ret |= SCCB_Write(sensor->slv_addr, 0xb9, value);
+
+ return ret;
+}
+
+static int set_whitebal(sensor_t *sensor, int enable)
+{
+ if(set_reg_bits(sensor, 0x13, 1, 1, enable) >= 0){
+ sensor->status.awb = !!enable;
+ }
+ return sensor->status.awb;
+}
+
+
+static int set_gain_ctrl(sensor_t *sensor, int enable)
+{
+ if(set_reg_bits(sensor, 0x13, 2, 1, enable) >= 0){
+ sensor->status.agc = !!enable;
+ }
+ return sensor->status.agc;
+}
+
+
+static int set_exposure_ctrl(sensor_t *sensor, int enable)
+{
+ if(set_reg_bits(sensor, 0x13, 0, 1, enable) >= 0){
+ sensor->status.aec = !!enable;
+ }
+ return sensor->status.aec;
+}
+
+static int set_hmirror(sensor_t *sensor, int enable)
+{
+ if(set_reg_bits(sensor, 0x1e, 5, 1, enable) >= 0){
+ sensor->status.hmirror = !!enable;
+ }
+ return sensor->status.hmirror;
+}
+
+static int set_vflip(sensor_t *sensor, int enable)
+{
+ if(set_reg_bits(sensor, 0x1e, 4, 1, enable) >= 0){
+ sensor->status.vflip = !!enable;
+ }
+ return sensor->status.vflip;
+}
+
+static int set_raw_gma_dsp(sensor_t *sensor, int enable)
+{
+ int ret = 0;
+ ret = set_reg_bits(sensor, 0xf1, 1, 1, !enable);
+ if (ret == 0) {
+ ESP_LOGD(TAG, "Set raw_gma to: %d", !enable);
+ sensor->status.raw_gma = !enable;
+ }
+ return ret;
+}
+
+
+static int set_lenc_dsp(sensor_t *sensor, int enable)
+{
+ int ret = 0;
+ ret = set_reg_bits(sensor, 0xf1, 0, 1, !enable);
+ if (ret == 0) {
+ ESP_LOGD(TAG, "Set lenc to: %d", !enable);
+ sensor->status.lenc = !enable;
+ }
+ return ret;
+}
+
+static int set_agc_gain(sensor_t *sensor, int option)
+{
+ int ret = 0;
+ ret = set_reg_bits(sensor, 0x13, 4, 1, !!option);
+ if (ret == 0) {
+ ESP_LOGD(TAG, "Set gain to: %d", !!option);
+ sensor->status.agc_gain = !!option;
+ }
+ return ret;
+}
+
+static int set_awb_gain_dsp(sensor_t *sensor, int value)
+{
+ int ret = 0;
+ ret = SCCB_Write(sensor->slv_addr, 0xa6, value);
+ if (ret == 0) {
+ ESP_LOGD(TAG, "Set awb gain threthold to: %d", value);
+ sensor->status.awb_gain = value;
+ }
+ return ret;
+}
+
+static int set_brightness(sensor_t *sensor, int level)
+{
+ int ret = 0;
+ ret = SCCB_Write(sensor->slv_addr, 0x55, 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;
+ ret = SCCB_Write(sensor->slv_addr, 0x56, level);
+ if (ret == 0) {
+ ESP_LOGD(TAG, "Set contrast to: %d", level);
+ sensor->status.contrast = level;
+ }
+ return ret;
+}
+
+static int set_sharpness(sensor_t *sensor, int level)
+{
+ int ret = 0;
+ ret = SCCB_Write(sensor->slv_addr, 0x70, level);
+ if (ret == 0) {
+ ESP_LOGD(TAG, "Set sharpness to: %d", level);
+ sensor->status.sharpness = level;
+ }
+ return ret;
+}
+
+static int init_status(sensor_t *sensor)
+{
+ sensor->status.brightness = SCCB_Read(sensor->slv_addr, 0x55);
+ sensor->status.contrast = SCCB_Read(sensor->slv_addr, 0x56);
+ sensor->status.saturation = 0;
+ sensor->status.ae_level = 0;
+
+ sensor->status.gainceiling = SCCB_Read(sensor->slv_addr, 0x87);
+ sensor->status.awb = get_reg_bits(sensor, 0x13, 1, 1);
+ sensor->status.awb_gain = SCCB_Read(sensor->slv_addr, 0xa6);
+ sensor->status.aec = get_reg_bits(sensor, 0x13, 0, 1);
+
+ sensor->status.agc = get_reg_bits(sensor, 0x13, 2, 1);
+
+ sensor->status.raw_gma = get_reg_bits(sensor, 0xf1, 1, 1);
+ sensor->status.lenc = get_reg_bits(sensor, 0xf1, 0, 1);
+ sensor->status.hmirror = get_reg_bits(sensor, 0x1e, 5, 1);
+ sensor->status.vflip = get_reg_bits(sensor, 0x1e, 4, 1);
+
+ sensor->status.colorbar = SCCB_Read(sensor->slv_addr, 0xb9);
+ sensor->status.sharpness = SCCB_Read(sensor->slv_addr, 0x70);
+
+ return 0;
+}
+
+static int set_dummy(sensor_t *sensor, int val){ return -1; }
+static int set_gainceiling_dummy(sensor_t *sensor, gainceiling_t val){ return -1; }
+static int set_res_raw(sensor_t *sensor, int startX, int startY, int endX, int endY, int offsetX, int offsetY, int totalX, int totalY, int outputX, int outputY, bool scale, bool binning){return -1;}
+static int _set_pll(sensor_t *sensor, int bypass, int multiplier, int sys_div, int root_2x, int pre_div, int seld5, int pclk_manual, int pclk_div){return -1;}
+
+static int set_xclk(sensor_t *sensor, int timer, int xclk)
+{
+ int ret = 0;
+ sensor->xclk_freq_hz = xclk * 1000000U;
+ ret = xclk_timer_conf(timer, sensor->xclk_freq_hz);
+ return ret;
+}
+
+int bf3005_detect(int slv_addr, sensor_id_t *id)
+{
+ if (BF3005_SCCB_ADDR == slv_addr) {
+ uint16_t PID = SCCB_Read(slv_addr, 0xFC);
+ if (BF3005_PID == PID) {
+ id->PID = PID;
+ id->VER = SCCB_Read(slv_addr, 0xFD);
+ id->MIDL = SCCB_Read(slv_addr, 0xFC);
+ id->MIDH = SCCB_Read(slv_addr, 0xFD);
+ return PID;
+ } else {
+ ESP_LOGI(TAG, "Mismatch PID=0x%x", PID);
+ }
+ }
+ return 0;
+}
+
+int bf3005_init(sensor_t *sensor)
+{
+ // Set function pointers
+ sensor->reset = reset;
+ sensor->init_status = init_status;
+ sensor->set_pixformat = set_pixformat;
+ sensor->set_framesize = set_framesize;
+ sensor->set_brightness = set_brightness;
+ sensor->set_contrast = set_contrast;
+
+ sensor->set_colorbar = set_colorbar;
+
+ sensor->set_gain_ctrl = set_gain_ctrl;
+ sensor->set_exposure_ctrl = set_exposure_ctrl;
+ sensor->set_hmirror = set_hmirror;
+ sensor->set_vflip = set_vflip;
+
+ sensor->set_whitebal = set_whitebal;
+
+ sensor->set_awb_gain = set_awb_gain_dsp;
+ sensor->set_agc_gain = set_agc_gain;
+
+ sensor->set_raw_gma = set_raw_gma_dsp;
+ sensor->set_lenc = set_lenc_dsp;
+
+ sensor->set_sharpness = set_sharpness;
+ //not supported
+ sensor->set_saturation= set_dummy;
+ sensor->set_denoise = set_dummy;
+ sensor->set_quality = set_dummy;
+ sensor->set_special_effect = set_dummy;
+ sensor->set_wb_mode = set_dummy;
+ sensor->set_ae_level = set_dummy;
+ sensor->set_gainceiling = set_gainceiling_dummy;
+
+
+ sensor->get_reg = get_reg;
+ sensor->set_reg = set_reg;
+ sensor->set_res_raw = set_res_raw;
+ sensor->set_pll = _set_pll;
+ sensor->set_xclk = set_xclk;
+
+ ESP_LOGD(TAG, "BF3005 Attached");
+
+ return 0;
+}
\ No newline at end of file
diff --git a/sensors/private_include/bf3005.h b/sensors/private_include/bf3005.h
new file mode 100644
index 0000000..3d1bfdf
--- /dev/null
+++ b/sensors/private_include/bf3005.h
@@ -0,0 +1,33 @@
+/*
+ * This file is part of the OpenMV project.
+ * Copyright (c) 2013/2014 Ibrahim Abdelkader
+ * This work is licensed under the MIT license, see the file LICENSE for details.
+ *
+ * BF3005 driver.
+ *
+ */
+#ifndef __BF3005_H__
+#define __BF3005_H__
+#include "sensor.h"
+
+/**
+ * @brief Detect sensor pid
+ *
+ * @param slv_addr SCCB address
+ * @param id Detection result
+ * @return
+ * 0: Can't detect this sensor
+ * Nonzero: This sensor has been detected
+ */
+int bf3005_detect(int slv_addr, sensor_id_t *id);
+
+/**
+ * @brief initialize sensor function pointers
+ *
+ * @param sensor pointer of sensor
+ * @return
+ * Always 0
+ */
+int bf3005_init(sensor_t *sensor);
+
+#endif // __BF3005_H__
\ No newline at end of file
diff --git a/sensors/private_include/bf3005_regs.h b/sensors/private_include/bf3005_regs.h
new file mode 100644
index 0000000..ea53029
--- /dev/null
+++ b/sensors/private_include/bf3005_regs.h
@@ -0,0 +1,337 @@
+/*
+ * This file is part of the OpenMV project.
+ * Copyright (c) 2013/2014 Ibrahim Abdelkader
+ * This work is licensed under the MIT license, see the file LICENSE for details.
+ *
+ * BF3005 register definitions.
+ */
+#ifndef __REG_REGS_H__
+#define __REG_REGS_H__
+#if 0
+#define GAIN 0x00 /* AGC ¨C Gain control gain setting */
+#define BLUE 0x01 /* AWB ¨C Blue channel gain setting */
+#define RED 0x02 /* AWB ¨C Red channel gain setting */
+#define GREEN 0x03 /* AWB ¨C Green channel gain setting */
+#define BAVG 0x05 /* U/B Average Level */
+#define GAVG 0x06 /* Y/Gb Average Level */
+#define RAVG 0x07 /* V/R Average Level */
+#define AECH 0x08 /* Exposure Value ¨C AEC MSBs */
+
+#define COM2 0x09 /* Common Control 2 */
+#define COM2_SOFT_SLEEP 0x10 /* Soft sleep mode */
+#define COM2_OUT_DRIVE_1x 0x00 /* Output drive capability 1x */
+#define COM2_OUT_DRIVE_2x 0x01 /* Output drive capability 2x */
+#define COM2_OUT_DRIVE_3x 0x02 /* Output drive capability 3x */
+#define COM2_OUT_DRIVE_4x 0x03 /* Output drive capability 4x */
+
+#define REG_PID 0x0A /* Product ID Number MSB */
+#define REG_VER 0x0B /* Product ID Number LSB */
+
+#define COM3 0x0C /* Common Control 3 */
+#define COM3_VFLIP 0x80 /* Vertical flip image ON/OFF selection */
+#define COM3_MIRROR 0x40 /* Horizontal mirror image ON/OFF selection */
+#define COM3_SWAP_BR 0x20 /* Swap B/R output sequence in RGB output mode */
+#define COM3_SWAP_YUV 0x10 /* Swap Y/UV output sequence in YUV output mode */
+#define COM3_SWAP_MSB 0x08 /* Swap output MSB/LSB */
+#define COM3_TRI_CLOCK 0x04 /* Tri-state option for output clock at power-down period */
+#define COM3_TRI_DATA 0x02 /* Tri-state option for output data at power-down period */
+#define COM3_COLOR_BAR 0x01 /* Sensor color bar test pattern output enable */
+#define COM3_SET_CBAR(r, x) ((r&0xFE)|((x&1)<<0))
+#define COM3_SET_MIRROR(r, x) ((r&0xBF)|((x&1)<<6))
+#define COM3_SET_FLIP(r, x) ((r&0x7F)|((x&1)<<7))
+
+#define COM4 0x0D /* Common Control 4 */
+#define COM4_PLL_BYPASS 0x00 /* Bypass PLL */
+#define COM4_PLL_4x 0x40 /* PLL frequency 4x */
+#define COM4_PLL_6x 0x80 /* PLL frequency 6x */
+#define COM4_PLL_8x 0xc0 /* PLL frequency 8x */
+#define COM4_AEC_FULL 0x00 /* AEC evaluate full window */
+#define COM4_AEC_1_2 0x10 /* AEC evaluate 1/2 window */
+#define COM4_AEC_1_4 0x20 /* AEC evaluate 1/4 window */
+#define COM4_AEC_2_3 0x30 /* AEC evaluate 2/3 window */
+
+#define COM5 0x0E /* Common Control 5 */
+#define COM5_AFR 0x80 /* Auto frame rate control ON/OFF selection (night mode) */
+#define COM5_AFR_SPEED 0x40 /* Auto frame rate control speed selection */
+#define COM5_AFR_0 0x00 /* No reduction of frame rate */
+#define COM5_AFR_1_2 0x10 /* Max reduction to 1/2 frame rate */
+#define COM5_AFR_1_4 0x20 /* Max reduction to 1/4 frame rate */
+#define COM5_AFR_1_8 0x30 /* Max reduction to 1/8 frame rate */
+#define COM5_AFR_4x 0x04 /* Add frame when AGC reaches 4x gain */
+#define COM5_AFR_8x 0x08 /* Add frame when AGC reaches 8x gain */
+#define COM5_AFR_16x 0x0c /* Add frame when AGC reaches 16x gain */
+#define COM5_AEC_NO_LIMIT 0x01 /* No limit to AEC increase step */
+
+#define COM6 0x0F /* Common Control 6 */
+#define COM6_AUTO_WINDOW 0x01 /* Auto window setting ON/OFF selection when format changes */
+
+#define AEC 0x10 /* AEC[7:0] (see register AECH for AEC[15:8]) */
+#define CLKRC 0x11 /* Internal Clock */
+
+#define COM7 0x12 /* Common Control 7 */
+#define COM7_RESET 0x80 /* SCCB Register Reset */
+#define COM7_RES_VGA 0x00 /* Resolution VGA */
+#define COM7_RES_QVGA 0x40 /* Resolution QVGA */
+#define COM7_BT656 0x20 /* BT.656 protocol ON/OFF */
+#define COM7_SENSOR_RAW 0x10 /* Sensor RAW */
+#define COM7_FMT_GBR422 0x00 /* RGB output format GBR422 */
+#define COM7_FMT_RGB565 0x04 /* RGB output format RGB565 */
+#define COM7_FMT_RGB555 0x08 /* RGB output format RGB555 */
+#define COM7_FMT_RGB444 0x0C /* RGB output format RGB444 */
+#define COM7_FMT_YUV 0x00 /* Output format YUV */
+#define COM7_FMT_P_BAYER 0x01 /* Output format Processed Bayer RAW */
+#define COM7_FMT_RGB 0x02 /* Output format RGB */
+#define COM7_FMT_R_BAYER 0x03 /* Output format Bayer RAW */
+#define COM7_SET_FMT(r, x) ((r&0xFC)|((x&0x3)<<0))
+#define COM7_SET_RGB(r, x) ((r&0xF0)|(x&0x0C)|COM7_FMT_RGB)
+
+#define COM8 0x13 /* Common Control 8 */
+#define COM8_FAST_AUTO 0x80 /* Enable fast AGC/AEC algorithm */
+#define COM8_STEP_VSYNC 0x00 /* AEC - Step size limited to vertical blank */
+#define COM8_STEP_UNLIMIT 0x40 /* AEC - Step size unlimited step size */
+#define COM8_BANDF_EN 0x20 /* Banding filter ON/OFF */
+#define COM8_AEC_BANDF 0x10 /* Enable AEC below banding value */
+#define COM8_AEC_FINE_EN 0x08 /* Fine AEC ON/OFF control */
+#define COM8_AGC_EN 0x04 /* AGC Enable */
+#define COM8_AWB_EN 0x02 /* AWB Enable */
+#define COM8_AEC_EN 0x01 /* AEC Enable */
+#define COM8_SET_AGC(r, x) ((r&0xFB)|((x&0x1)<<2))
+#define COM8_SET_AWB(r, x) ((r&0xFD)|((x&0x1)<<1))
+#define COM8_SET_AEC(r, x) ((r&0xFE)|((x&0x1)<<0))
+
+#define COM9 0x14 /* Common Control 9 */
+#define COM9_HISTO_AVG 0x80 /* Histogram or average based AEC/AGC selection */
+#define COM9_AGC_GAIN_2x 0x00 /* Automatic Gain Ceiling 2x */
+#define COM9_AGC_GAIN_4x 0x10 /* Automatic Gain Ceiling 4x */
+#define COM9_AGC_GAIN_8x 0x20 /* Automatic Gain Ceiling 8x */
+#define COM9_AGC_GAIN_16x 0x30 /* Automatic Gain Ceiling 16x */
+#define COM9_AGC_GAIN_32x 0x40 /* Automatic Gain Ceiling 32x */
+#define COM9_DROP_VSYNC 0x04 /* Drop VSYNC output of corrupt frame */
+#define COM9_DROP_HREF 0x02 /* Drop HREF output of corrupt frame */
+#define COM9_SET_AGC(r, x) ((r&0x8F)|((x&0x07)<<4))
+
+#define COM10 0x15 /* Common Control 10 */
+#define COM10_NEGATIVE 0x80 /* Output negative data */
+#define COM10_HSYNC_EN 0x40 /* HREF changes to HSYNC */
+#define COM10_PCLK_FREE 0x00 /* PCLK output option: free running PCLK */
+#define COM10_PCLK_MASK 0x20 /* PCLK output option: masked during horizontal blank */
+#define COM10_PCLK_REV 0x10 /* PCLK reverse */
+#define COM10_HREF_REV 0x08 /* HREF reverse */
+#define COM10_VSYNC_FALLING 0x00 /* VSYNC changes on falling edge of PCLK */
+#define COM10_VSYNC_RISING 0x04 /* VSYNC changes on rising edge of PCLK */
+#define COM10_VSYNC_NEG 0x02 /* VSYNC negative */
+#define COM10_OUT_RANGE_8 0x01 /* Output data range: Full range */
+#define COM10_OUT_RANGE_10 0x00 /* Output data range: Data from [10] to [F0] (8 MSBs) */
+
+#define REG16 0x16 /* Register 16 */
+#define REG16_BIT_SHIFT 0x80 /* Bit shift test pattern options */
+#define HSTART 0x17 /* Horizontal Frame (HREF column) Start 8 MSBs (2 LSBs are at HREF[5:4]) */
+#define HSIZE 0x18 /* Horizontal Sensor Size (2 LSBs are at HREF[1:0]) */
+#define VSTART 0x19 /* Vertical Frame (row) Start 8 MSBs (1 LSB is at HREF[6]) */
+#define VSIZE 0x1A /* Vertical Sensor Size (1 LSB is at HREF[2]) */
+#define PSHFT 0x1B /* Data Format - Pixel Delay Select */
+#define REG_MIDH 0x1C /* Manufacturer ID Byte ¨C High */
+#define REG_MIDL 0x1D /* Manufacturer ID Byte ¨C Low */
+#define LAEC 0x1F /* Fine AEC Value - defines exposure value less than one row period */
+
+#define COM11 0x20 /* Common Control 11 */
+#define COM11_SNGL_FRAME_EN 0x02 /* Single frame ON/OFF selection */
+#define COM11_SNGL_XFR_TRIG 0x01 /* Single frame transfer trigger */
+
+#define BDBASE 0x22 /* Banding Filter Minimum AEC Value */
+#define DBSTEP 0x23 /* Banding Filter Maximum Step */
+#define AEW 0x24 /* AGC/AEC - Stable Operating Region (Upper Limit) */
+#define AEB 0x25 /* AGC/AEC - Stable Operating Region (Lower Limit) */
+#define VPT 0x26 /* AGC/AEC Fast Mode Operating Region */
+#define REG28 0x28 /* Selection on the number of dummy rows, N */
+#define HOUTSIZE 0x29 /* Horizontal Data Output Size MSBs (2 LSBs at register EXHCH[1:0]) */
+#define EXHCH 0x2A /* Dummy Pixel Insert MSB */
+#define EXHCL 0x2B /* Dummy Pixel Insert LSB */
+#define VOUTSIZE 0x2C /* Vertical Data Output Size MSBs (LSB at register EXHCH[2]) */
+#define ADVFL 0x2D /* LSB of Insert Dummy Rows in Vertical Sync (1 bit equals 1 row) */
+#define ADVFH 0x2E /* MSB of Insert Dummy Rows in Vertical Sync */
+#define YAVE 0x2F /* Y/G Channel Average Value */
+#define LUMHTH 0x30 /* Histogram AEC/AGC Luminance High Level Threshold */
+#define LUMLTH 0x31 /* Histogram AEC/AGC Luminance Low Level Threshold */
+#define HREF 0x32 /* Image Start and Size Control */
+#define DM_LNL 0x33 /* Dummy Row Low 8 Bits */
+#define DM_LNH 0x34 /* Dummy Row High 8 Bits */
+#define ADOFF_B 0x35 /* AD Offset Compensation Value for B Channel */
+#define ADOFF_R 0x36 /* AD Offset Compensation Value for R Channel */
+#define ADOFF_GB 0x37 /* AD Offset Compensation Value for GB Channel */
+#define ADOFF_GR 0x38 /* AD Offset Compensation Value for GR Channel */
+#define OFF_B 0x39 /* AD Offset Compensation Value for B Channel */
+#define OFF_R 0x3A /* AD Offset Compensation Value for R Channel */
+#define OFF_GB 0x3B /* AD Offset Compensation Value for GB Channel */
+#define OFF_GR 0x3C /* AD Offset Compensation Value for GR Channel */
+#define COM12 0x3D /* DC offset compensation for analog process */
+
+#define COM13 0x3E /* Common Control 13 */
+#define COM13_BLC_EN 0x80 /* BLC enable */
+#define COM13_ADC_EN 0x40 /* ADC channel BLC ON/OFF control */
+#define COM13_ANALOG_BLC 0x20 /* Analog processing channel BLC ON/OFF control */
+#define COM13_ABLC_GAIN_EN 0x04 /* ABLC gain trigger enable */
+
+#define COM14 0x3F /* Common Control 14 */
+#define COM15 0x40 /* Common Control 15 */
+#define COM16 0x41 /* Common Control 16 */
+#define TGT_B 0x42 /* BLC Blue Channel Target Value */
+#define TGT_R 0x43 /* BLC Red Channel Target Value */
+#define TGT_GB 0x44 /* BLC Gb Channel Target Value */
+#define TGT_GR 0x45 /* BLC Gr Channel Target Value */
+
+#define LC_CTR 0x46 /* Lens Correction Control */
+#define LC_CTR_RGB_COMP_1 0x00 /* R, G, and B channel compensation coefficient is set by LC_COEF (0x49) */
+#define LC_CTR_RGB_COMP_3 0x04 /* R, G, and B channel compensation coefficient is set by registers
+ LC_COEFB (0x4B), LC_COEF (0x49), and LC_COEFR (0x4C), respectively */
+#define LC_CTR_EN 0x01 /* Lens correction enable */
+#define LC_XC 0x47 /* X Coordinate of Lens Correction Center Relative to Array Center */
+#define LC_YC 0x48 /* Y Coordinate of Lens Correction Center Relative to Array Center */
+#define LC_COEF 0x49 /* Lens Correction Coefficient */
+#define LC_RADI 0x4A /* Lens Correction Radius */
+#define LC_COEFB 0x4B /* Lens Correction B Channel Compensation Coefficient */
+#define LC_COEFR 0x4C /* Lens Correction R Channel Compensation Coefficient */
+
+#define FIXGAIN 0x4D /* Analog Fix Gain Amplifier */
+#define AREF0 0x4E /* Sensor Reference Control */
+#define AREF1 0x4F /* Sensor Reference Current Control */
+#define AREF2 0x50 /* Analog Reference Control */
+#define AREF3 0x51 /* ADC Reference Control */
+#define AREF4 0x52 /* ADC Reference Control */
+#define AREF5 0x53 /* ADC Reference Control */
+#define AREF6 0x54 /* Analog Reference Control */
+#define AREF7 0x55 /* Analog Reference Control */
+#define UFIX 0x60 /* U Channel Fixed Value Output */
+#define VFIX 0x61 /* V Channel Fixed Value Output */
+#define AWBB_BLK 0x62 /* AWB Option for Advanced AWB */
+
+#define AWB_CTRL0 0x63 /* AWB Control Byte 0 */
+#define AWB_CTRL0_GAIN_EN 0x80 /* AWB gain enable */
+#define AWB_CTRL0_CALC_EN 0x40 /* AWB calculate enable */
+#define AWB_CTRL0_WBC_MASK 0x0F /* WBC threshold 2 */
+
+#define DSP_CTRL1 0x64 /* DSP Control Byte 1 */
+#define DSP_CTRL1_FIFO_EN 0x80 /* FIFO enable/disable selection */
+#define DSP_CTRL1_UV_EN 0x40 /* UV adjust function ON/OFF selection */
+#define DSP_CTRL1_SDE_EN 0x20 /* SDE enable */
+#define DSP_CTRL1_MTRX_EN 0x10 /* Color matrix ON/OFF selection */
+#define DSP_CTRL1_INTRP_EN 0x08 /* Interpolation ON/OFF selection */
+#define DSP_CTRL1_GAMMA_EN 0x04 /* Gamma function ON/OFF selection */
+#define DSP_CTRL1_BLACK_EN 0x02 /* Black defect auto correction ON/OFF */
+#define DSP_CTRL1_WHITE_EN 0x01 /* White defect auto correction ON/OFF */
+
+#define DSP_CTRL2 0x65 /* DSP Control Byte 2 */
+#define DSP_CTRL2_VDCW_EN 0x08 /* Vertical DCW enable */
+#define DSP_CTRL2_HDCW_EN 0x04 /* Horizontal DCW enable */
+#define DSP_CTRL2_VZOOM_EN 0x02 /* Vertical zoom out enable */
+#define DSP_CTRL2_HZOOM_EN 0x01 /* Horizontal zoom out enable */
+
+#define DSP_CTRL3 0x66 /* DSP Control Byte 3 */
+#define DSP_CTRL3_UV_EN 0x80 /* UV output sequence option */
+#define DSP_CTRL3_CBAR_EN 0x20 /* DSP color bar ON/OFF selection */
+#define DSP_CTRL3_FIFO_EN 0x08 /* FIFO power down ON/OFF selection */
+#define DSP_CTRL3_SCAL1_PWDN 0x04 /* Scaling module power down control 1 */
+#define DSP_CTRL3_SCAL2_PWDN 0x02 /* Scaling module power down control 2 */
+#define DSP_CTRL3_INTRP_PWDN 0x01 /* Interpolation module power down control */
+#define DSP_CTRL3_SET_CBAR(r, x) ((r&0xDF)|((x&1)<<5))
+
+
+#define DSP_CTRL4 0x67 /* DSP Control Byte 4 */
+#define DSP_CTRL4_YUV_RGB 0x00 /* Output selection YUV or RGB */
+#define DSP_CTRL4_RAW8 0x02 /* Output selection RAW8 */
+#define DSP_CTRL4_RAW10 0x03 /* Output selection RAW10 */
+
+
+#define AWB_BIAS 0x68 /* AWB BLC Level Clip */
+#define AWB_CTRL1 0x69 /* AWB Control 1 */
+#define AWB_CTRL2 0x6A /* AWB Control 2 */
+
+#define AWB_CTRL3 0x6B /* AWB Control 3 */
+#define AWB_CTRL3_ADVANCED 0x80 /* AWB mode select - Advanced AWB */
+#define AWB_CTRL3_SIMPLE 0x00 /* AWB mode select - Simple AWB */
+
+#define AWB_CTRL4 0x6C /* AWB Control 4 */
+#define AWB_CTRL5 0x6D /* AWB Control 5 */
+#define AWB_CTRL6 0x6E /* AWB Control 6 */
+#define AWB_CTRL7 0x6F /* AWB Control 7 */
+#define AWB_CTRL8 0x70 /* AWB Control 8 */
+#define AWB_CTRL9 0x71 /* AWB Control 9 */
+#define AWB_CTRL10 0x72 /* AWB Control 10 */
+#define AWB_CTRL11 0x73 /* AWB Control 11 */
+#define AWB_CTRL12 0x74 /* AWB Control 12 */
+#define AWB_CTRL13 0x75 /* AWB Control 13 */
+#define AWB_CTRL14 0x76 /* AWB Control 14 */
+#define AWB_CTRL15 0x77 /* AWB Control 15 */
+#define AWB_CTRL16 0x78 /* AWB Control 16 */
+#define AWB_CTRL17 0x79 /* AWB Control 17 */
+#define AWB_CTRL18 0x7A /* AWB Control 18 */
+#define AWB_CTRL19 0x7B /* AWB Control 19 */
+#define AWB_CTRL20 0x7C /* AWB Control 20 */
+#define AWB_CTRL21 0x7D /* AWB Control 21 */
+#define GAM1 0x7E /* Gamma Curve 1st Segment Input End Point 0x04 Output Value */
+#define GAM2 0x7F /* Gamma Curve 2nd Segment Input End Point 0x08 Output Value */
+#define GAM3 0x80 /* Gamma Curve 3rd Segment Input End Point 0x10 Output Value */
+#define GAM4 0x81 /* Gamma Curve 4th Segment Input End Point 0x20 Output Value */
+#define GAM5 0x82 /* Gamma Curve 5th Segment Input End Point 0x28 Output Value */
+#define GAM6 0x83 /* Gamma Curve 6th Segment Input End Point 0x30 Output Value */
+#define GAM7 0x84 /* Gamma Curve 7th Segment Input End Point 0x38 Output Value */
+#define GAM8 0x85 /* Gamma Curve 8th Segment Input End Point 0x40 Output Value */
+#define GAM9 0x86 /* Gamma Curve 9th Segment Input End Point 0x48 Output Value */
+#define GAM10 0x87 /* Gamma Curve 10th Segment Input End Point 0x50 Output Value */
+#define GAM11 0x88 /* Gamma Curve 11th Segment Input End Point 0x60 Output Value */
+#define GAM12 0x89 /* Gamma Curve 12th Segment Input End Point 0x70 Output Value */
+#define GAM13 0x8A /* Gamma Curve 13th Segment Input End Point 0x90 Output Value */
+#define GAM14 0x8B /* Gamma Curve 14th Segment Input End Point 0xB0 Output Value */
+#define GAM15 0x8C /* Gamma Curve 15th Segment Input End Point 0xD0 Output Value */
+#define SLOP 0x8D /* Gamma Curve Highest Segment Slope */
+#define DNSTH 0x8E /* De-noise Threshold */
+#define EDGE0 0x8F /* Edge Enhancement Strength Control */
+#define EDGE1 0x90 /* Edge Enhancement Threshold Control */
+#define DNSOFF 0x91 /* Auto De-noise Threshold Control */
+#define EDGE2 0x92 /* Edge Enhancement Strength Upper Limit */
+#define EDGE3 0x93 /* Edge Enhancement Strength Upper Limit */
+#define MTX1 0x94 /* Matrix Coefficient 1 */
+#define MTX2 0x95 /* Matrix Coefficient 2 */
+#define MTX3 0x96 /* Matrix Coefficient 3 */
+#define MTX4 0x97 /* Matrix Coefficient 4 */
+#define MTX5 0x98 /* Matrix Coefficient 5 */
+#define MTX6 0x99 /* Matrix Coefficient 6 */
+
+#define MTX_CTRL 0x9A /* Matrix Control */
+#define MTX_CTRL_DBL_EN 0x80 /* Matrix double ON/OFF selection */
+
+#define BRIGHTNESS 0x9B /* Brightness Control */
+#define CONTRAST 0x9C /* Contrast Gain */
+#define UVADJ0 0x9E /* Auto UV Adjust Control 0 */
+#define UVADJ1 0x9F /* Auto UV Adjust Control 1 */
+#define SCAL0 0xA0 /* DCW Ratio Control */
+#define SCAL1 0xA1 /* Horizontal Zoom Out Control */
+#define SCAL2 0xA2 /* Vertical Zoom Out Control */
+#define FIFODLYM 0xA3 /* FIFO Manual Mode Delay Control */
+#define FIFODLYA 0xA4 /* FIFO Auto Mode Delay Control */
+
+#define SDE 0xA6 /* Special Digital Effect Control */
+#define SDE_NEGATIVE_EN 0x40 /* Negative image enable */
+#define SDE_GRAYSCALE_EN 0x20 /* Gray scale image enable */
+#define SDE_V_FIXED_EN 0x10 /* V fixed value enable */
+#define SDE_U_FIXED_EN 0x08 /* U fixed value enable */
+#define SDE_CONT_BRIGHT_EN 0x04 /* Contrast/Brightness enable */
+#define SDE_SATURATION_EN 0x02 /* Saturation enable */
+#define SDE_HUE_EN 0x01 /* Hue enable */
+
+#define USAT 0xA7 /* U Component Saturation Gain */
+#define VSAT 0xA8 /* V Component Saturation Gain */
+#define HUECOS 0xA9 /* Cosine value ¡Á 0x80 */
+#define HUESIN 0xAA /* Sine value ¡Á 0x80 */
+#define SIGN_BIT 0xAB /* Sign Bit for Hue and Brightness */
+
+#define DSPAUTO 0xAC /* DSP Auto Function ON/OFF Control */
+#define DSPAUTO_AWB_EN 0x80 /* AWB auto threshold control */
+#define DSPAUTO_DENOISE_EN 0x40 /* De-noise auto threshold control */
+#define DSPAUTO_EDGE_EN 0x20 /* Sharpness (edge enhancement) auto strength control */
+#define DSPAUTO_UV_EN 0x10 /* UV adjust auto slope control */
+#define DSPAUTO_SCAL0_EN 0x08 /* Auto scaling factor control (register SCAL0 (0xA0)) */
+#define DSPAUTO_SCAL1_EN 0x04 /* Auto scaling factor control (registers SCAL1 (0xA1 and SCAL2 (0xA2))*/
+#define SET_REG(reg, x) (##reg_DEFAULT|x)
+#endif //__REG_REGS_H__
+#endif
\ No newline at end of file