From 23deb29b066dbfe5b32c15e513d466186ee3e107 Mon Sep 17 00:00:00 2001 From: LynnL4 Date: Tue, 5 Nov 2024 09:34:43 +0800 Subject: [PATCH 1/5] Add support for HM1055 --- CMakeLists.txt | 1 + Kconfig | 9 + driver/esp_camera.c | 6 + driver/include/sensor.h | 3 + driver/sensor.c | 1 + sensors/hm1055.c | 833 ++++++++++++++++++++++ sensors/private_include/hm1055.h | 27 + sensors/private_include/hm1055_regs.h | 120 ++++ sensors/private_include/hm1055_settings.h | 697 ++++++++++++++++++ 9 files changed, 1697 insertions(+) create mode 100755 sensors/hm1055.c create mode 100755 sensors/private_include/hm1055.h create mode 100755 sensors/private_include/hm1055_regs.h create mode 100755 sensors/private_include/hm1055_settings.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 9947ae802d..5e4f9888a8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -41,6 +41,7 @@ if(IDF_TARGET STREQUAL "esp32" OR IDF_TARGET STREQUAL "esp32s2" OR IDF_TARGET ST sensors/sc101iot.c sensors/sc030iot.c sensors/sc031gs.c + sensors/hm1055.c ) list(APPEND priv_include_dirs diff --git a/Kconfig b/Kconfig index de706e0e89..a73f262a87 100755 --- a/Kconfig +++ b/Kconfig @@ -116,6 +116,15 @@ menu "Camera configuration" SC031GS is a global shutter CMOS sensor with high frame rate and single-frame HDR. Enable this option if you want to use the SC031GS. Disable this option to save memory. + + config HM1055_SUPPORT + bool "Support HM1055 VGA" + default y + help + Enable this option if you want to use the HM1055. + Disable this option to save memory. + + config SCCB_I2C_PORT choice SCCB_HARDWARE_I2C_PORT bool "I2C peripheral to use for SCCB" diff --git a/driver/esp_camera.c b/driver/esp_camera.c index e39b597fa1..3f6a8ea8f2 100644 --- a/driver/esp_camera.c +++ b/driver/esp_camera.c @@ -69,6 +69,9 @@ #if CONFIG_SC031GS_SUPPORT #include "sc031gs.h" #endif +#if CONFIG_HM1055_SUPPORT +#include "hm1055.h" +#endif #if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG) #include "esp32-hal-log.h" @@ -143,6 +146,9 @@ static const sensor_func_t g_sensors[] = { #if CONFIG_SC031GS_SUPPORT {sc031gs_detect, sc031gs_init}, #endif +#if CONFIG_HM1055_SUPPORT + {hm1055_detect, hm1055_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 6ab12a21aa..d74ad3d998 100755 --- a/driver/include/sensor.h +++ b/driver/include/sensor.h @@ -31,6 +31,7 @@ typedef enum { SC101IOT_PID = 0xda4a, SC030IOT_PID = 0x9a46, SC031GS_PID = 0x0031, + HM1055_PID = 0x0955, } camera_pid_t; typedef enum { @@ -48,6 +49,7 @@ typedef enum { CAMERA_SC101IOT, CAMERA_SC030IOT, CAMERA_SC031GS, + CAMERA_HM1055, CAMERA_MODEL_MAX, CAMERA_NONE, } camera_model_t; @@ -67,6 +69,7 @@ typedef enum { SC101IOT_SCCB_ADDR = 0x68,// 0xd0 >> 1 SC030IOT_SCCB_ADDR = 0x68,// 0xd0 >> 1 SC031GS_SCCB_ADDR = 0x30, + HM1055_SCCB_ADDR = 0x24, } camera_sccb_addr_t; typedef enum { diff --git a/driver/sensor.c b/driver/sensor.c index 23071f6c2c..0180a6a928 100644 --- a/driver/sensor.c +++ b/driver/sensor.c @@ -17,6 +17,7 @@ const camera_sensor_info_t camera_sensor[CAMERA_MODEL_MAX] = { {CAMERA_SC101IOT, "SC101IOT", SC101IOT_SCCB_ADDR, SC101IOT_PID, FRAMESIZE_HD, false}, {CAMERA_SC030IOT, "SC030IOT", SC030IOT_SCCB_ADDR, SC030IOT_PID, FRAMESIZE_VGA, false}, {CAMERA_SC031GS, "SC031GS", SC031GS_SCCB_ADDR, SC031GS_PID, FRAMESIZE_VGA, false}, + {CAMERA_HM1055, "HM1055", HM1055_SCCB_ADDR, HM1055_PID, FRAMESIZE_HD, false}, }; const resolution_info_t resolution[FRAMESIZE_INVALID] = { diff --git a/sensors/hm1055.c b/sensors/hm1055.c new file mode 100755 index 0000000000..d3318a7f30 --- /dev/null +++ b/sensors/hm1055.c @@ -0,0 +1,833 @@ +/* + * + * HM1055 driver. + * + */ +#include +#include +#include +#include "sccb.h" +#include "xclk.h" +#include "hm1055.h" +#include "hm1055_regs.h" +#include "hm1055_settings.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 = "HM1055"; +#endif + +// #define REG_DEBUG_ON + +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); + +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 check_reg_mask(uint8_t slv_addr, uint16_t reg, uint8_t mask) +{ + return (read_reg(slv_addr, reg) & mask) == mask; +} + +static int read_reg16(uint8_t slv_addr, const uint16_t reg) +{ + int ret = 0, ret2 = 0; + ret = read_reg(slv_addr, reg); + if (ret >= 0) + { + ret = (ret & 0xFF) << 8; + ret2 = read_reg(slv_addr, reg + 1); + if (ret2 < 0) + { + ret = ret2; + } + else + { + ret |= ret2 & 0xFF; + } + } + return ret; +} + +static int write_reg(uint8_t slv_addr, const uint16_t reg, uint8_t value) +{ + int ret = 0; +#ifndef REG_DEBUG_ON + ret = SCCB_Write16(slv_addr, reg, value); +#else + int old_value = read_reg(slv_addr, reg); + if (old_value < 0) + { + return old_value; + } + if ((uint8_t)old_value != value) + { + ESP_LOGD(TAG, "NEW REG 0x%04x: 0x%02x to 0x%02x", reg, (uint8_t)old_value, value); + ret = SCCB_Write16(slv_addr, reg, value); + } + else + { + ESP_LOGD(TAG, "OLD REG 0x%04x: 0x%02x", reg, (uint8_t)old_value); + ret = SCCB_Write16(slv_addr, reg, value); // maybe not? + } + if (ret < 0) + { + ESP_LOGE(TAG, "WRITE REG 0x%04x FAILED: %d", reg, ret); + } +#endif + return ret; +} + +static int set_reg_bits(uint8_t slv_addr, uint16_t reg, uint8_t offset, uint8_t mask, uint8_t value) +{ + int ret = 0; + uint8_t c_value, new_value; + ret = read_reg(slv_addr, reg); + if (ret < 0) + { + return ret; + } + c_value = ret; + new_value = (c_value & ~(mask << offset)) | ((value & mask) << offset); + ret = write_reg(slv_addr, reg, new_value); + return ret; +} + +static int write_regs(uint8_t slv_addr, const uint16_t (*regs)[2]) +{ + int i = 0, ret = 0; + while (!ret && regs[i][0] != REGLIST_TAIL) + { + if (regs[i][0] == REG_DLY) + { + vTaskDelay(regs[i][1] / portTICK_PERIOD_MS); + } + else + { + ret = write_reg(slv_addr, regs[i][0], regs[i][1]); + } + i++; + } + return ret; +} + +static int write_reg16(uint8_t slv_addr, const uint16_t reg, uint16_t value) +{ + if (write_reg(slv_addr, reg, value >> 8) || write_reg(slv_addr, reg + 1, value)) + { + return -1; + } + return 0; +} + +static int write_addr_reg(uint8_t slv_addr, const uint16_t reg, uint16_t x_value, uint16_t y_value) +{ + if (write_reg16(slv_addr, reg, x_value) || write_reg16(slv_addr, reg + 2, y_value)) + { + return -1; + } + return 0; +} + +#define write_reg_bits(slv_addr, reg, mask, enable) set_reg_bits(slv_addr, reg, 0, mask, (enable) ? (mask) : 0) + +static int set_ae_level(sensor_t *sensor, int level); + +static int reset(sensor_t *sensor) +{ + vTaskDelay(100 / portTICK_PERIOD_MS); + int ret = 0; + // Software Reset: clear all registers and reset them to their default values + ret = write_reg(sensor->slv_addr, SFTRST, 0x55); + if (ret) + { + ESP_LOGE(TAG, "Software Reset FAILED!"); + return ret; + } + vTaskDelay(100 / portTICK_PERIOD_MS); + ret = write_regs(sensor->slv_addr, sensor_default_regs); + if (ret == 0) + { + ESP_LOGD(TAG, "Camera defaults loaded"); + vTaskDelay(100 / portTICK_PERIOD_MS); + set_ae_level(sensor, 0); + } + return ret; +} + +static int set_pixformat(sensor_t *sensor, pixformat_t pixformat) +{ + int ret = 0; + + switch (pixformat) + { + case PIXFORMAT_RAW: + ret = write_reg(sensor->slv_addr, PORTCTRL, 0x20); + break; + case PIXFORMAT_YUV422: + ret = write_reg(sensor->slv_addr, PORTCTRL, 0x30); + break; + case PIXFORMAT_RGB565: + case PIXFORMAT_RGB888: + ret = write_reg(sensor->slv_addr, PORTCTRL, 0x40); + break; + case PIXFORMAT_RGB555: + ret = write_reg(sensor->slv_addr, PORTCTRL, 0x50); + break; + case PIXFORMAT_RGB444: + ret = write_reg(sensor->slv_addr, PORTCTRL, 0x60); + break; + default: + break; + } + + if (ret == 0) + { + sensor->pixformat = pixformat; + ESP_LOGD(TAG, "Set pixformat: %d", pixformat); + } + + return ret; +} + +static int set_framesize(sensor_t *sensor, framesize_t framesize) +{ + int ret = 0; + + sensor->status.framesize = framesize; + ESP_LOGD(TAG, "Set framesize: %d", framesize); + ret = write_regs(sensor->slv_addr, sensor_default_regs); + if (framesize == FRAMESIZE_QQVGA) + { + ESP_LOGD(TAG, "Set FRAMESIZE_QQVGA"); + ret = write_regs(sensor->slv_addr, sensor_framesize_QQVGA); + } + else if (framesize == FRAMESIZE_QCIF) + { + ESP_LOGD(TAG, "Set FRAMESIZE_QCIF"); + ret = write_regs(sensor->slv_addr, sensor_framesize_QCIF); + } + else if (framesize == FRAMESIZE_240X240) + { + ESP_LOGD(TAG, "Set FRAMESIZE_240X240"); + ret = write_regs(sensor->slv_addr, sensor_framesize_240X240); + } + else if (framesize == FRAMESIZE_QVGA) + { + ESP_LOGD(TAG, "Set FRAMESIZE_QVGA"); + ret = write_regs(sensor->slv_addr, sensor_framesize_QVGA); + } + else if (framesize == FRAMESIZE_CIF) + { + ESP_LOGD(TAG, "Set FRAMESIZE_CIF"); + ret = write_regs(sensor->slv_addr, sensor_framesize_CIF); + } + else if (framesize == FRAMESIZE_VGA) + { + ESP_LOGD(TAG, "Set FRAMESIZE_VGA"); + ret = write_regs(sensor->slv_addr, sensor_framesize_VGA); + } + else if (framesize == FRAMESIZE_SVGA) + { + ESP_LOGD(TAG, "Set FRAMESIZE_SVGA"); + ret = write_regs(sensor->slv_addr, sensor_framesize_SVGA); + } + else if (framesize == FRAMESIZE_HD) + { + ESP_LOGD(TAG, "Set FRAMESIZE_HD"); + ret = write_regs(sensor->slv_addr, sensor_framesize_HD); + ret = _set_pll(sensor, 0, 288, 1, 0, 0, 0, 1, 16); + } + else + { + ESP_LOGD(TAG, "Dont suppost this size, Set FRAMESIZE_VGA"); + ret = write_regs(sensor->slv_addr, sensor_framesize_VGA); + } + + if (ret == 0) + { + ret = write_reg(sensor->slv_addr, CMU, 0x01) || write_reg(sensor->slv_addr, TGRDCFG, 0x01); + } + + return ret; +} + +static int set_hmirror(sensor_t *sensor, int enable) +{ + int ret = 0; + ret = write_reg_bits(sensor->slv_addr, RDCFG, 0x02, enable); + if (ret == 0) + { + ESP_LOGD(TAG, "Set hmirror to: %d", enable); + sensor->status.hmirror = enable; + } + return ret; +} + +static int set_vflip(sensor_t *sensor, int enable) +{ + int ret = 0; + ret = write_reg_bits(sensor->slv_addr, RDCFG, 0x01, enable); + if (ret == 0) + { + ESP_LOGD(TAG, "Set vflip to: %d", enable); + sensor->status.vflip = enable; + } + return ret; +} + +static int set_quality(sensor_t *sensor, int qs) +{ + return 0; +} + +static int set_colorbar(sensor_t *sensor, int enable) +{ + return 0; +} + +static int set_gain_ctrl(sensor_t *sensor, int enable) +{ + return 0; +} + +static int set_exposure_ctrl(sensor_t *sensor, int enable) +{ + int ret = 0; + + ret = write_reg_bits(sensor->slv_addr, AEWBCFG, 0x01, enable); + + if (ret == 0) + { + ESP_LOGD(TAG, "Set aec to: %d", enable); + sensor->status.aec = enable; + } + + return ret; +} + +static int set_whitebal(sensor_t *sensor, int enable) +{ + int ret = 0; + + ret = write_reg_bits(sensor->slv_addr, AEWBCFG, 0x02, enable); + + if (ret == 0) + { + ESP_LOGD(TAG, "Set awb to: %d", enable); + sensor->status.awb = enable; + } + return ret; +} + +// Gamma enable +static int set_raw_gma_dsp(sensor_t *sensor, int enable) +{ + int ret = 0; + ret = write_reg_bits(sensor->slv_addr, ISPCTRL1, 0x04, enable); + if (ret == 0) + { + ESP_LOGD(TAG, "Set raw_gma to: %d", enable); + sensor->status.raw_gma = enable; + } + return 0; +} + +static int set_lenc_dsp(sensor_t *sensor, int enable) +{ + int ret = 0; + ret = write_reg_bits(sensor->slv_addr, ISPCTRL3, 0x40, enable); + if (ret == 0) + { + ESP_LOGD(TAG, "Set lenc to: %d", enable); + sensor->status.lenc = enable; + } + return -1; +} +// real gain +static int set_agc_gain(sensor_t *sensor, int gain) +{ + int ret = 0; + if (gain < 0 || gain > 7) + { + return -1; + } + + ret = write_reg(sensor->slv_addr, AGAIN, gain); + if (ret == 0) + { + ESP_LOGD(TAG, "Set gain to: %d", gain); + sensor->status.agc_gain = gain; + } + return 0; +} +static int set_aec_value(sensor_t *sensor, int value) +{ + int ret = 0; + ret = write_reg(sensor->slv_addr, AETARGM, value); + if (ret == 0) + { + ESP_LOGD(TAG, "Set aec_value to: %d", value); + sensor->status.aec_value = value; + } + + return 0; +} + +static int set_ae_level(sensor_t *sensor, int level) +{ + int ret = 0; + if (level < -5 || level > 5) + { + return -1; + } + uint8_t target_level = ((level + 5) * 10) + 5; + uint8_t upper = target_level * 27 / 25; + uint8_t lower = target_level * 23 / 25; + + ret = write_reg(sensor->slv_addr, AETARGU, upper) || write_reg(sensor->slv_addr, AETARGL, lower); + if (ret == 0) + { + ESP_LOGD(TAG, "Set ae_level to: %d", level); + sensor->status.ae_level = level; + } + return 0; +} + +static int set_awb_gain_dsp(sensor_t *sensor, int enable) +{ + return 0; +} + +static int set_brightness(sensor_t *sensor, int level) +{ + int ret = 0; + uint8_t ispctrl5 = read_reg(sensor->slv_addr, ISPCTRL5); + uint8_t brightness = 0; + + switch (level) + { + case 3: + brightness = 0xFF; + break; + + case 2: + brightness = 0xBA; + break; + + case 1: + brightness = 0x96; + break; + + case 0: + brightness = 0x72; + break; + + case -1: + brightness = 0x48; + break; + + case -2: + brightness = 0x24; + break; + + case -3: + brightness = 0x00; + break; + + default: // 0 + break; + } + + ispctrl5 |= 0x40; // enable brightness + ret = write_reg(sensor->slv_addr, ISPCTRL5, ispctrl5); + ret = write_reg(sensor->slv_addr, BRIGHT, brightness); + 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; + uint8_t ispctrl5 = read_reg(sensor->slv_addr, ISPCTRL5); + uint8_t value1 = 0; + + ispctrl5 |= 0x80; // enable contrast + ret = write_reg(sensor->slv_addr, ISPCTRL5, ispctrl5); + ret = write_reg(sensor->slv_addr, ACONTQ, (level * 0x20) & 0xFF); + 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; + ret = write_reg(sensor->slv_addr, SAT, (level * 0x20) + 0x4A); + if (ret == 0) + { + ESP_LOGD(TAG, "Set saturation to: %d", level); + sensor->status.saturation = level; + } + return ret; +} + +static int get_sharpness(sensor_t *sensor) +{ + int ret = 0; + int level = 0; + ret = read_reg(sensor->slv_addr, EDGE); + + level = (ret - 0x60) / 0x20; + ESP_LOGD(TAG, "Get sharpness: %d", level); + + return level; +} +static int set_sharpness(sensor_t *sensor, int level) +{ + int ret = 0; + ret = write_reg(sensor->slv_addr, EDGE, (level * 0x20) + 0x60); + if (ret == 0) + { + ESP_LOGD(TAG, "Set sharpness to: %d", level); + sensor->status.sharpness = level; + } + return ret; +} + +static int get_denoise(sensor_t *sensor) +{ + int ret = 0; + int level = 0; + ret = read_reg(sensor->slv_addr, YDN); + + level = (ret - 0x07) / 2; + ESP_LOGD(TAG, "Get denoise: %d", level); + + return level; +} +static int set_denoise(sensor_t *sensor, int level) +{ + int ret = 0; + uint8_t ispctrl5 = read_reg(sensor->slv_addr, ISPCTRL5); + + ispctrl5 |= 0x20; // enable denoise + ret = write_reg(sensor->slv_addr, ISPCTRL5, ispctrl5); + ret = write_reg(sensor->slv_addr, YDN, (level * 2) + 0x07); + + if (ret == 0) + { + ESP_LOGD(TAG, "Set denoise to: %d", level); + sensor->status.denoise = level; + } + + return ret; +} + +static int get_reg(sensor_t *sensor, int reg, int mask) +{ + int ret = 0, ret2 = 0; + if (mask > 0xFF) + { + ret = read_reg16(sensor->slv_addr, reg); + if (ret >= 0 && mask > 0xFFFF) + { + ret2 = read_reg(sensor->slv_addr, reg + 2); + if (ret2 >= 0) + { + ret = (ret << 8) | ret2; + } + else + { + ret = ret2; + } + } + } + else + { + ret = read_reg(sensor->slv_addr, reg); + } + if (ret > 0) + { + ret &= mask; + } + return ret; +} + +static int set_reg(sensor_t *sensor, int reg, int mask, int value) +{ + int ret = 0, ret2 = 0; + if (mask > 0xFF) + { + ret = read_reg16(sensor->slv_addr, reg); + if (ret >= 0 && mask > 0xFFFF) + { + ret2 = read_reg(sensor->slv_addr, reg + 2); + if (ret2 >= 0) + { + ret = (ret << 8) | ret2; + } + else + { + ret = ret2; + } + } + } + else + { + ret = read_reg(sensor->slv_addr, reg); + } + if (ret < 0) + { + return ret; + } + value = (ret & ~mask) | (value & mask); + if (mask > 0xFFFF) + { + ret = write_reg16(sensor->slv_addr, reg, value >> 8); + if (ret >= 0) + { + ret = write_reg(sensor->slv_addr, reg + 2, value & 0xFF); + } + } + else if (mask > 0xFF) + { + ret = write_reg16(sensor->slv_addr, reg, value); + } + else + { + ret = write_reg(sensor->slv_addr, reg, value); + } + return ret; +} + +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 0; +} + +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) +{ + int ret = 0; + uint8_t ckcfg1 = 0; + uint8_t ckcfg2 = 0; + uint8_t ckcfg3 = 0; + uint8_t pll2 = 0; + + if (sensor->xclk_freq_hz <= 6000000) + { + ckcfg2 = 0x00; + } + else if (sensor->xclk_freq_hz <= 12000000) + { + ckcfg2 = 0x20; + } + else if (sensor->xclk_freq_hz <= 18000000) + { + ckcfg2 = 0x40; + } + else if (sensor->xclk_freq_hz <= 24000000) + { + ckcfg2 = 0x60; + } + else if (sensor->xclk_freq_hz <= 30000000) + { + ckcfg2 = 0x80; + } + else if (sensor->xclk_freq_hz <= 36000000) + { + ckcfg2 = 0xA0; + } + else if (sensor->xclk_freq_hz <= 42000000) + { + ckcfg2 = 0xC0; + } + else + { // max is 48000000 + ckcfg2 = 0xE0; + } + + if (bypass == 0) + { + switch (multiplier) + { + case 204: + ckcfg2 |= 10; + break; + case 216: + ckcfg2 |= 11; + break; + case 228: + ckcfg2 |= 0x12; + break; + case 240: + ckcfg2 |= 0x13; + break; + case 288: + ckcfg2 |= 0x17; + break; + case 300: + ckcfg2 |= 0x18; + break; + case 312: + ckcfg2 |= 0x19; + break; + case 324: + ckcfg2 |= 0x1A; + break; + case 336: + ckcfg2 |= 0x1B; + break; + case 348: + ckcfg2 |= 0x1C; + break; + case 360: + ckcfg2 |= 0x1D; + break; + default: + ckcfg2 |= 0x17; + break; + } + } + + if (pclk_manual > 0) + { + if (pclk_div > 128) + { + pclk_div = 128; + } + if (pclk_div < 1) + { + pclk_div = 1; + } + ckcfg1 |= (pclk_div - 1); + } + + if (root_2x > 0) + { + ckcfg3 = 0x00; + } + else + { + ckcfg3 = 0x01; + } + + ESP_LOGD(TAG, "ckcfg1 = 0x%02x, ckcfg2 = 0x%02x, ckcfg3 = 0x%02x, pll2 = 0x%02x", ckcfg1, ckcfg2, ckcfg3, pll2); + ret = write_reg(sensor->slv_addr, CKCFG1, ckcfg1); + ret = write_reg(sensor->slv_addr, CKCFG2, ckcfg2); + ret = write_reg(sensor->slv_addr, CKCFG3, ckcfg3); + ret = write_reg(sensor->slv_addr, PLL2, pll2); + + return ret; +} + +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); + if (ret == 0) + { + ESP_LOGD(TAG, "Set xclk to %d", xclk); + } + return ret; +} + +static int init_status(sensor_t *sensor) +{ + sensor->status.brightness = 0; + sensor->status.contrast = 0; + sensor->status.saturation = 0; + sensor->status.sharpness = get_sharpness(sensor); + sensor->status.denoise = get_denoise(sensor); + sensor->status.ae_level = 0; + sensor->status.awb = check_reg_mask(sensor->slv_addr, AEWBCFG, 0x02); + sensor->status.agc = true; + sensor->status.aec = check_reg_mask(sensor->slv_addr, AEWBCFG, 0x04); + sensor->status.hmirror = check_reg_mask(sensor->slv_addr, RDCFG, 0x02); + sensor->status.vflip = check_reg_mask(sensor->slv_addr, RDCFG, 0x01); + sensor->status.lenc = check_reg_mask(sensor->slv_addr, ISPCTRL3, 0x40); + sensor->status.awb_gain = read_reg(sensor->slv_addr, DGAIN); + sensor->status.agc_gain = read_reg(sensor->slv_addr, AGAIN); + sensor->status.aec_value = read_reg(sensor->slv_addr, AETARGM); + return 0; +} + +int hm1055_detect(int slv_addr, sensor_id_t *id) +{ + if (HM1055_SCCB_ADDR == slv_addr) + { + uint8_t h = SCCB_Read16(slv_addr, IDH); + uint8_t l = SCCB_Read16(slv_addr, IDL); + uint16_t PID = (h << 8) | l; + if (HM1055_PID == PID) + { + id->PID = PID; + return PID; + } + else + { + ESP_LOGD(TAG, "Mismatch PID=0x%x", PID); + } + } + return 0; +} + +int hm1055_init(sensor_t *sensor) +{ + 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_sharpness; + sensor->set_gainceiling = NULL; + sensor->set_quality = set_quality; + sensor->set_colorbar = set_colorbar; + sensor->set_gain_ctrl = set_gain_ctrl; + sensor->set_exposure_ctrl = set_exposure_ctrl; + sensor->set_whitebal = set_whitebal; + sensor->set_hmirror = set_hmirror; + sensor->set_vflip = set_vflip; + sensor->init_status = init_status; + sensor->set_aec2 = NULL; + sensor->set_aec_value = set_aec_value; + sensor->set_special_effect = NULL; + sensor->set_wb_mode = NULL; + sensor->set_ae_level = set_ae_level; + sensor->set_dcw = NULL; + sensor->set_bpc = NULL; + sensor->set_wpc = NULL; + sensor->set_agc_gain = set_agc_gain; + sensor->set_raw_gma = set_raw_gma_dsp; + sensor->set_lenc = set_lenc_dsp; + sensor->set_denoise = set_denoise; + + 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; + return 0; +} diff --git a/sensors/private_include/hm1055.h b/sensors/private_include/hm1055.h new file mode 100755 index 0000000000..dd6d44d753 --- /dev/null +++ b/sensors/private_include/hm1055.h @@ -0,0 +1,27 @@ +/* + * HM1055 driver. + */ +#ifndef __HM1055_H__ +#define __HM1055_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 hm1055_detect(int slv_addr, sensor_id_t *id); + +/** + * @brief initialize sensor function pointers + * + * @param sensor pointer of sensor + * @return + * Always 0 + */ +int hm1055_init(sensor_t *sensor); + +#endif // __HM1055_H__ diff --git a/sensors/private_include/hm1055_regs.h b/sensors/private_include/hm1055_regs.h new file mode 100755 index 0000000000..da83db0993 --- /dev/null +++ b/sensors/private_include/hm1055_regs.h @@ -0,0 +1,120 @@ +/* + * HM1055 register definitions. + */ +#ifndef __REG_REGS_H__ +#define __REG_REGS_H__ + +// Imager Configuration +#define CMU 0x0000 +#define IDH 0x0001 +#define IDL 0x0002 +#define VID 0x0003 +#define PWDCTRL 0x0004 +#define TGRDCFG 0x0005 +#define RDCFG 0x0006 +#define VREAD 0x000D +#define HREAD 0x000E +#define IMG_CFG 0x000F + +// Imager Operation +#define BLNKRH 0x0010 +#define BLNKRL 0x0011 +#define BLNKCCLK 0x0012 +#define BLNKC 0x0013 +#define INTGH 0x0015 +#define INTGL 0x0016 +#define AGAIN 0x0018 +#define DGAIN 0x001D + +// IO and Clock Configuration Setting +#define OPRTCFG 0x0020 +#define SFTRST 0x0022 // any value to reset +#define IOCTRLH 0x0023 +#define IOCTRLL 0x0024 +#define CKCFG1 0x0025 +#define CKCFG2 0x0026 +#define PORTCTRL 0x0027 +#define TESTIMG 0x0028 +#define CCIR656 0x0029 +#define PLL1 0x002A +#define CKCFG3 0x002B +#define PLL2 0x002C + +// Black Level Target +#define BLCTGT 0x0040 +#define BLCTGT2 0x0053 + +// Vertical Arbitrary Window Configuration +#define VAWINSTARTH 0x0078 +#define VAWINSTARTL 0x0079 +#define VAWINENDH 0x007A +#define VAWINENDL 0x007B + +// Image Signal Processing Control +#define CMU_AE 0x0100 +#define CMU_AWB 0x0101 +#define ISPID 0x0105 +#define ISPCTRL1 0x0120 +#define ISPCTRL2 0x0121 +#define ISPCTRL3 0x0122 +#define ISPCTRL4 0x0124 +#define ISPCTRL5 0x0125 +#define ISPCTRL6 0x0126 + +// RAW Noise Filter Control +#define RAWNF 0x01E4 +#define ARAWNF 0x01E5 +#define ARAWNFODEL 0x01E6 + +// Automatic Exposure Control Registers +#define AEWBCFG 0x0380 +#define AETARGU 0x0381 +#define AETARGL 0x0382 +#define AETARGM 0x0383 + +// Saturation and Hue Control +#define SAT 0x0480 +#define ASAT 0x0481 +#define ASATODEL 0x0482 +#define HUESIN 0x0486 +#define HUECOS 0x0487 +#define SCENE 0x0488 + +// Contrast and Brightness Control +#define CONTM 0x04B0 +#define ACONTM 0x04B1 +#define CONTQ 0x04B3 +#define ACONTQ 0x04B4 +#define CONTN 0x04B6 +#define CONTP 0x04B9 +#define CONTGAIN 0x04BC +#define YMEAN 0x04BD +#define BRIGHT 0x04C0 + +// Y Denoise Control +#define YDN 0x0580 +#define AYDN 0x0581 +#define AYDNODEL 0x0582 + +// Sharpness Control +#define EDGE 0x05A1 + +// Fade to Black Control +#define F2BMEAN 0x05D0 +#define F2BRANGE 0x05D1 + +// Digital Window Control +#define YUVSCXL 0x05E0 +#define YUVSCXH 0x05E1 +#define YUVSCYL 0x05E2 +#define YUVSCYH 0x05E3 +#define WINXSTL 0x05E4 +#define WINXSTH 0x05E5 +#define WINXEDL 0x05E6 +#define WINXEDH 0x05E7 +#define WINYSTL 0x05E8 +#define WINYSTH 0x05E9 +#define WINYEDL 0x05EA +#define WINYEDH 0x05EB + +#endif //__REG_REGS_H__ diff --git a/sensors/private_include/hm1055_settings.h b/sensors/private_include/hm1055_settings.h new file mode 100755 index 0000000000..9d2831db18 --- /dev/null +++ b/sensors/private_include/hm1055_settings.h @@ -0,0 +1,697 @@ + +#include + +#define REG_DLY 0xffff +#define REGLIST_TAIL 0xffff + +static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { + {0x0022, 0x00}, // RESET + {0x0026, 0x77}, // 24MHz MCLK, 72MHz PCLK + {0x002A, 0x44}, // Modified by Wilson + {0x002B, 0x02}, + {0x002C, 0x00}, // Turn off DCC + {0x0025, 0x00}, // PLL on + {0x0020, 0x08}, + {0x0027, 0x40}, // FPGA 24 data format + {0x0028, 0xC0}, // + {0x0004, 0x10}, // + {0x0006, 0x00}, // Modified by Brandon. No Flip + {0x0012, 0x0F}, + {0x0044, 0x04}, + {0x004A, 0x2A}, + {0x004B, 0x72}, + {0x004E, 0x30}, + {0x0070, 0x2A}, + {0x0071, 0x57}, + {0x0072, 0x55}, + {0x0073, 0x30}, + {0x0077, 0x04}, + {0x0080, 0xC2}, + {0x0082, 0xA2}, + {0x0083, 0xF0}, + {0x0085, 0x11}, // Set ADC power to 100% and Increase Comparator power and reduce ADC swing range(4/19, K.Kim) + {0x0086, 0x22}, + {0x0087, 0x08}, + {0x0088, 0x6e}, // Temperature config 0x80[7:5]:76C, Minimize CTIA & PGA power and set VCMI to 200mV(4/19, K.Kim) + {0x0089, 0x2A}, + {0x008A, 0x2F}, // Set BLC power to 50%(4/19, K.Kim) + {0x008D, 0x20}, + {0x008f, 0x77}, + {0x0090, 0x01}, + {0x0091, 0x02}, + {0x0092, 0x03}, + {0x0093, 0x04}, + {0x0094, 0x14}, + {0x0095, 0x09}, + {0x0096, 0x0A}, + {0x0097, 0x0B}, + {0x0098, 0x0C}, + {0x0099, 0x04}, + {0x009A, 0x14}, + {0x009B, 0x34}, + {0x00A0, 0x00}, + {0x00A1, 0x00}, + {0x0B3B, 0x0B}, + {0x0040, 0x0A}, // BLC Phase1 + {0x0053, 0x0A}, // BLC Phase2 + {0x0120, 0x36}, // 36:50Hz, 37:60Hz + {0x0121, 0x80}, + {0x0122, 0xEB}, // 122[3] is temperature_control_bit2 + {0x0123, 0xCC}, // 123[3:0]maskTH + {0x0124, 0xDE}, + {0x0125, 0xDF}, + {0x0126, 0x70}, + {0x0128, 0x1F}, + {0x0129, 0x8F}, + {0x0132, 0xF8}, + {0x011F, 0x08}, // BPC COLD PIXEL ENABLE if 11F[0] = 1 then on else 0 off + {0x0144, 0x04}, // Hot pixel ratio + {0x0145, 0x00}, // Hot pixel ratio alpha + {0x0146, 0x20}, // Vertical Line TH + {0x0147, 0x20}, // Vertical Line TH alpha + {0x0148, 0x14}, // HD_2line_BPC_TH + {0x0149, 0x14}, // HD_2line_BPC_TH alpha + {0x0156, 0x0C}, // BPC RATIO FOR COLD PIXEL + {0x0157, 0x0C}, // BPC RATIO FOR COLD PIXEL + {0x0158, 0x0A}, // 2 LINE BPC RATIO + {0x0159, 0x0A}, // 2 LINE BPC RATIO + {0x015A, 0x03}, // BPC RATIO FOR COLD PIXEL + {0x015B, 0x40}, // Corner TH + {0x015C, 0x21}, // Corner TH alpha + {0x015E, 0x0F}, // Debug_mode + {0x0168, 0xC8}, // BPC T1 + {0x0169, 0xC8}, // BPC T1 ALPHA + {0x016A, 0x96}, // BPC T2 + {0x016B, 0x96}, // BPC T2 ALPHA + {0x016C, 0x64}, // BPC T3 + {0x016D, 0x64}, // BPC T3 ALPHA + {0x016E, 0x32}, // BPC T4 + {0x016F, 0x32}, // BPC T4 ALPHA + {0x01EF, 0xF1}, // BPC Control Byte + {0x0131, 0x44}, //[6] DS_EN, [5] VOFF, [4] EDGEON, [3] SBPI_MODE, [2] RAW_SAHRPNESS_EN, [1]G1G2B_EN + {0x014C, 0x60}, // VSUB + {0x014D, 0x24}, // VSUB ALPHA0 + {0x015D, 0x90}, //[7] TG_en// [6:0]:min Tgain + {0x01D8, 0x40}, // NOISE TH + {0x01D9, 0x20}, // NL_V1 + {0x01DA, 0x23}, // NL_V2 + {0x0150, 0x05}, // NL_INC1 + {0x0155, 0x07}, // NL_INC2 + {0x0178, 0x10}, // EVDIV + {0x017A, 0x10}, // EVDIVD + {0x01BA, 0x10}, // EVSUB + {0x0176, 0x00}, // EDGE2W + {0x0179, 0x10}, // EVDIV ALPHA0 + {0x017B, 0x10}, // EVDIVD ALPHA0 + {0x01BB, 0x10}, // EVSUB ALPHA0 + {0x0177, 0x00}, // EDGE2W ALPHA0 + {0x01E7, 0x20}, // TLTH1 + {0x01E8, 0x30}, // TLTH2 + {0x01E9, 0x50}, // TLTH3 + {0x01E4, 0x18}, // BD STRENGTH + {0x01E5, 0x20}, // BD STRENGTH ALPHA0 + {0x01E6, 0x04}, // BD STRENGTH OUTDOOR + {0x0210, 0x21}, // STD + {0x0211, 0x0A}, // STD ALPHA0 + {0x0212, 0x21}, // STD OUTDOOR + {0x01DB, 0x04}, // G1G2 STRENGTH + {0x01DC, 0x14}, // SBPI_OFFSET + {0x0151, 0x08}, + {0x01F2, 0x18}, + {0x01F8, 0x3C}, + {0x01FE, 0x24}, + {0x0213, 0x03}, // BPC_Control_BYTE_2 // BPC_line_edge_th 3rd bpc + {0x0214, 0x03}, // BPC_Control_BYTE_3 // 3rd bpc strength[4:0] , [7:5] is for 2line bpc temp_control_bit + {0x0215, 0x10}, // BPC_Control_BYTE_4 // 1st bpc strength[4:0] + {0x0216, 0x08}, // BPC_Control_BYTE_5 // 1st br pulse strength[4:0] + {0x0217, 0x05}, // BPC_Control_BYTE_6 // 1st gbgr pulse strengh[4:0] + {0x0218, 0xB8}, + {0x0219, 0x01}, + {0x021A, 0xB8}, + {0x021B, 0x01}, + {0x021C, 0xB8}, + {0x021D, 0x01}, + {0x021E, 0xB8}, + {0x021F, 0x01}, + {0x0220, 0xF1}, + {0x0221, 0x5D}, + {0x0222, 0x0A}, + {0x0223, 0x80}, + {0x0224, 0x50}, + {0x0225, 0x09}, + {0x0226, 0x80}, + {0x022A, 0x56}, + {0x022B, 0x13}, + {0x022C, 0x80}, + {0x022D, 0x11}, + {0x022E, 0x08}, + {0x022F, 0x11}, + {0x0230, 0x08}, + {0x0233, 0x11}, + {0x0234, 0x08}, + {0x0235, 0x88}, + {0x0236, 0x02}, + {0x0237, 0x88}, + {0x0238, 0x02}, + {0x023B, 0x88}, + {0x023C, 0x02}, + {0x023D, 0x68}, + {0x023E, 0x01}, + {0x023F, 0x68}, + {0x0240, 0x01}, + {0x0243, 0x68}, + {0x0244, 0x01}, + {0x0251, 0x0F}, + {0x0252, 0x00}, + {0x0260, 0x00}, + {0x0261, 0x4A}, + {0x0262, 0x2C}, + {0x0263, 0x68}, + {0x0264, 0x40}, + {0x0265, 0x2C}, + {0x0266, 0x6A}, + {0x026A, 0x40}, + {0x026B, 0x30}, + {0x026C, 0x66}, + {0x0278, 0x98}, + {0x0279, 0x20}, + {0x027A, 0x80}, + {0x027B, 0x73}, + {0x027C, 0x08}, + {0x027D, 0x80}, + {0x0280, 0x0D}, + {0x0282, 0x1A}, + {0x0284, 0x30}, + {0x0286, 0x53}, + {0x0288, 0x62}, + {0x028a, 0x6E}, + {0x028c, 0x7A}, + {0x028e, 0x83}, + {0x0290, 0x8B}, + {0x0292, 0x92}, + {0x0294, 0x9D}, + {0x0296, 0xA8}, + {0x0298, 0xBC}, + {0x029a, 0xCF}, + {0x029c, 0xE2}, + {0x029e, 0x2A}, + {0x02A0, 0x02}, + {0x02C0, 0x7D}, // CCM N + {0x02C1, 0x01}, + {0x02C2, 0x7C}, + {0x02C3, 0x04}, + {0x02C4, 0x01}, + {0x02C5, 0x04}, + {0x02C6, 0x3E}, + {0x02C7, 0x04}, + {0x02C8, 0x90}, + {0x02C9, 0x01}, + {0x02CA, 0x52}, + {0x02CB, 0x04}, + {0x02CC, 0x04}, + {0x02CD, 0x04}, + {0x02CE, 0xA9}, + {0x02CF, 0x04}, + {0x02D0, 0xAD}, + {0x02D1, 0x01}, + {0x0302, 0x00}, + {0x0303, 0x00}, + {0x0304, 0x00}, + {0x02e0, 0x04}, // CCM by Alpha + {0x02F0, 0x4E}, // CCM A + {0x02F1, 0x04}, + {0x02F2, 0xB1}, + {0x02F3, 0x00}, + {0x02F4, 0x63}, + {0x02F5, 0x04}, + {0x02F6, 0x28}, + {0x02F7, 0x04}, + {0x02F8, 0x29}, + {0x02F9, 0x04}, + {0x02FA, 0x51}, + {0x02FB, 0x00}, + {0x02FC, 0x64}, + {0x02FD, 0x04}, + {0x02FE, 0x6B}, + {0x02FF, 0x04}, + {0x0300, 0xCF}, + {0x0301, 0x00}, + {0x0305, 0x08}, + {0x0306, 0x40}, + {0x0307, 0x00}, + {0x032D, 0x70}, + {0x032E, 0x01}, + {0x032F, 0x00}, + {0x0330, 0x01}, + {0x0331, 0x70}, + {0x0332, 0x01}, + {0x0333, 0x82}, // AWB channel offset + {0x0334, 0x82}, + {0x0335, 0x86}, + {0x0340, 0x30}, // AWB + {0x0341, 0x44}, + {0x0342, 0x4A}, + {0x0343, 0x3C}, // CT1 + {0x0344, 0x83}, // + {0x0345, 0x4D}, // CT2 + {0x0346, 0x75}, // + {0x0347, 0x56}, // CT3 + {0x0348, 0x68}, // + {0x0349, 0x5E}, // CT4 + {0x034A, 0x5C}, // + {0x034B, 0x65}, // CT5 + {0x034C, 0x52}, // + {0x0350, 0x88}, + {0x0352, 0x18}, + {0x0354, 0x80}, + {0x0355, 0x50}, + {0x0356, 0x88}, + {0x0357, 0xE0}, + {0x0358, 0x00}, + {0x035A, 0x00}, + {0x035B, 0xAC}, + {0x0360, 0x02}, + {0x0361, 0x18}, + {0x0362, 0x50}, + {0x0363, 0x6C}, + {0x0364, 0x00}, + {0x0365, 0xF0}, + {0x0366, 0x08}, + {0x036A, 0x10}, + {0x036B, 0x18}, + {0x036E, 0x10}, + {0x0370, 0x10}, + {0x0371, 0x18}, + {0x0372, 0x0C}, + {0x0373, 0x38}, + {0x0374, 0x3A}, + {0x0375, 0x12}, + {0x0376, 0x20}, + {0x0380, 0xFF}, + {0x0381, 0x44}, + {0x0382, 0x34}, + {0x038A, 0x80}, + {0x038B, 0x0A}, + {0x038C, 0xC1}, + {0x038E, 0x3C}, + {0x038F, 0x09}, + {0x0390, 0xE0}, + {0x0391, 0x01}, + {0x0392, 0x03}, + {0x0393, 0x80}, + {0x0395, 0x22}, + {0x0398, 0x02}, // AE Frame Control + {0x0399, 0xF0}, + {0x039A, 0x03}, + {0x039B, 0xAC}, + {0x039C, 0x04}, + {0x039D, 0x68}, + {0x039E, 0x05}, + {0x039F, 0xE0}, + {0x03A0, 0x07}, + {0x03A1, 0x58}, + {0x03A2, 0x08}, + {0x03A3, 0xD0}, + {0x03A4, 0x0B}, + {0x03A5, 0xC0}, + {0x03A6, 0x18}, + {0x03A7, 0x1C}, + {0x03A8, 0x20}, + {0x03A9, 0x24}, + {0x03AA, 0x28}, + {0x03AB, 0x30}, + {0x03AC, 0x24}, + {0x03AD, 0x21}, + {0x03AE, 0x1C}, + {0x03AF, 0x18}, + {0x03B0, 0x17}, + {0x03B1, 0x13}, + {0x03B7, 0x64}, // AEAWB Windowing Step for 7x7 + {0x03B8, 0x00}, + {0x03B9, 0xB4}, + {0x03BA, 0x00}, + {0x03bb, 0xff}, // WinWeight 7x7 + {0x03bc, 0xff}, + {0x03bd, 0xff}, + {0x03be, 0xff}, + {0x03bf, 0xff}, + {0x03c0, 0xff}, + {0x03c1, 0x01}, + {0x03e0, 0x04}, + {0x03e1, 0x11}, + {0x03e2, 0x01}, + {0x03e3, 0x04}, + {0x03e4, 0x10}, + {0x03e5, 0x21}, + {0x03e6, 0x11}, + {0x03e7, 0x00}, + {0x03e8, 0x11}, + {0x03e9, 0x32}, + {0x03ea, 0x12}, + {0x03eb, 0x01}, + {0x03ec, 0x21}, + {0x03ed, 0x33}, + {0x03ee, 0x23}, + {0x03ef, 0x01}, + {0x03f0, 0x11}, + {0x03f1, 0x32}, + {0x03f2, 0x12}, + {0x03f3, 0x01}, + {0x03f4, 0x10}, + {0x03f5, 0x21}, + {0x03f6, 0x11}, + {0x03f7, 0x00}, + {0x03f8, 0x04}, + {0x03f9, 0x11}, + {0x03fa, 0x01}, + {0x03fb, 0x04}, + {0x03DC, 0x47}, // SubWinAE setting, min_dark_cnt=7, exit_dark_cnt=4 + {0x03DD, 0x5A}, // AEbl_th=70% + {0x03DE, 0x41}, // enable SubWinAE, bottom 3x5, DM_tol=12.5% + {0x03DF, 0x53}, // limit_ratio=65% + {0x0420, 0x82}, // Digital Gain offset + {0x0421, 0x00}, + {0x0422, 0x00}, + {0x0423, 0x88}, + {0x0430, 0x08}, // ABLC + {0x0431, 0x30}, + {0x0432, 0x0c}, + {0x0433, 0x04}, // 0A + {0x0435, 0x08}, // 10 + {0x0450, 0xFF}, // Alpha + {0x0451, 0xD0}, + {0x0452, 0xB8}, + {0x0453, 0x88}, + {0x0454, 0x00}, + {0x0458, 0x80}, + {0x0459, 0x03}, + {0x045A, 0x00}, + {0x045B, 0x50}, + {0x045C, 0x00}, + {0x045D, 0x90}, + {0x0465, 0x02}, + {0x0466, 0x14}, + {0x047A, 0x00}, // ELOFFNRB + {0x047B, 0x00}, // ELOFFNRY + {0x047C, 0x04}, + {0x047D, 0x50}, + {0x047E, 0x04}, + {0x047F, 0x90}, + {0x0480, 0x58}, + {0x0481, 0x06}, + {0x0482, 0x08}, // Sat outdoor + {0x04B0, 0x50}, // Contrast + {0x04B6, 0x30}, + {0x04B9, 0x10}, + {0x04B3, 0x00}, + {0x04B1, 0x85}, + {0x04B4, 0x00}, + {0x0540, 0x00}, // + {0x0541, 0xBC}, // 60Hz Flicker + {0x0542, 0x00}, // + {0x0543, 0xE1}, // 50Hz Flicker + {0x0580, 0x04}, // BLUR WEIGHT + {0x0581, 0x0F}, // BLUR WEIGHT ALPHA0 + {0x0582, 0x04}, // BLUR WEIGHT OUTDOOR + {0x05A1, 0x0A}, // SHARPNESS STRENGTH + {0x05A2, 0x21}, //[6:4] SHARP_ORE_NEG, [1:0] FIL SELECTION + {0x05A3, 0x84}, //[7]EA_EN, [6] EE_CENTER, [3:0] EDGEDIV + {0x05A4, 0x24}, // SHARP_ORE + {0x05A5, 0xFF}, // ORE_MAX + {0x05A6, 0x00}, // ORE_LOW + {0x05A7, 0x24}, // OUGB_HOT + {0x05A8, 0x24}, // OUGB_COLD + {0x05A9, 0x02}, // EDGE RANGE + {0x05B1, 0x24}, // EDGE SUB + {0x05B2, 0x0C}, //[3] Y_ADJC, [2]CMODE + {0x05B4, 0x1F}, // FIX WEIGHT + {0x05AE, 0x75}, // OAR START + {0x05AF, 0x78}, //[7:5]OAR STEP, [4:0]OAR DECSTR + {0x05B6, 0x00}, // SHARPNESS STRENGTH ALPHA0 + {0x05B7, 0x10}, // SHARP_ORE ALPHA0 + {0x05BF, 0x20}, // EDGESUB ALPHA0 + {0x05C1, 0x06}, // SHARPNESS STRENGTH OUTDOOR + {0x05C2, 0x18}, // SHARP ORE OUTDOOR + {0x05C7, 0x00}, // TFBPI + {0x05CC, 0x04}, // Raw sharpness strength + {0x05CD, 0x00}, // Raw sharpness strength ALPHA0 + {0x05CE, 0x03}, // Raw sharpness strength outdoor + {0x05E4, 0x08}, + {0x05E5, 0x00}, + {0x05E6, 0x07}, + {0x05E7, 0x05}, + {0x05E8, 0x08}, + {0x05E9, 0x00}, + {0x05EA, 0xD7}, + {0x05EB, 0x02}, + {0x0660, 0x00}, + {0x0661, 0x16}, + {0x0662, 0x07}, + {0x0663, 0xf1}, + {0x0664, 0x07}, + {0x0665, 0xde}, + {0x0666, 0x07}, + {0x0667, 0xe7}, + {0x0668, 0x00}, + {0x0669, 0x35}, + {0x066a, 0x07}, + {0x066b, 0xf9}, + {0x066c, 0x07}, + {0x066d, 0xb7}, + {0x066e, 0x00}, + {0x066f, 0x27}, + {0x0670, 0x07}, + {0x0671, 0xf3}, + {0x0672, 0x07}, + {0x0673, 0xc5}, + {0x0674, 0x07}, + {0x0675, 0xee}, + {0x0676, 0x00}, + {0x0677, 0x16}, + {0x0678, 0x01}, + {0x0679, 0x80}, + {0x067a, 0x00}, + {0x067b, 0x85}, + {0x067c, 0x07}, + {0x067d, 0xe1}, + {0x067e, 0x07}, + {0x067f, 0xf5}, + {0x0680, 0x07}, + {0x0681, 0xb9}, + {0x0682, 0x00}, + {0x0683, 0x31}, + {0x0684, 0x07}, + {0x0685, 0xe6}, + {0x0686, 0x07}, + {0x0687, 0xd3}, + {0x0688, 0x00}, + {0x0689, 0x18}, + {0x068a, 0x07}, + {0x068b, 0xfa}, + {0x068c, 0x07}, + {0x068d, 0xd2}, + {0x068e, 0x00}, + {0x068f, 0x08}, + {0x0690, 0x00}, + {0x0691, 0x02}, + {0xAFD0, 0x03}, // Auto Flicker detection off + {0xAFD3, 0x18}, + {0xAFD4, 0x04}, + {0xAFD5, 0xB8}, // auto flicker samp time 3188 + {0xAFD6, 0x02}, + {0xAFD7, 0x44}, + {0xAFD8, 0x02}, + + // QVGA + {0x0006, 0x00}, + {0x000D, 0x01}, + {0x000E, 0x11}, + {0x0122, 0xFB}, + {0x0125, 0xFF}, + {0x0126, 0x70}, + {0x05E0, 0XBE}, + {0x05E1, 0x00}, + {0x05E2, 0xBE}, + {0x05E3, 0x00}, + {0x05E4, 0x3A}, + {0x05E5, 0x00}, + {0x05E6, 0x79}, + {0x05E7, 0x01}, + {0x05E8, 0x04}, + {0x05E9, 0x00}, + {0x05EA, 0xF3}, + {0x05EB, 0x00}, + + {0x0000, 0x01}, + {0x0100, 0x01}, + {0x0101, 0x01}, + {REGLIST_TAIL, 0x00}, // tail +}; + +static const DRAM_ATTR uint16_t sensor_framesize_HD[][2] = { + {0x0006, 0x00}, + {0x000D, 0x00}, + {0x000E, 0x00}, + {0x0122, 0xFB}, + {0x0125, 0xDF}, + {0x0126, 0x70}, + {0x05E4, 0x08}, + {0x05E5, 0x00}, + {0x05E6, 0x07}, + {0x05E7, 0x05}, + {0x05E8, 0x08}, + {0x05E9, 0x00}, + {0x05EA, 0xD7}, + {0x05EB, 0x02}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_SVGA[][2] = { + {0x0006, 0x10}, + {0x000D, 0x00}, + {0x000E, 0x00}, + {0x0122, 0xEB}, + {0x0125, 0xDF}, + {0x0126, 0x70}, + {0x05E4, 0x58}, + {0x05E5, 0x00}, + {0x05E6, 0x77}, + {0x05E7, 0x03}, + {0x05E8, 0x42}, + {0x05E9, 0x00}, + {0x05EA, 0x99}, + {0x05EB, 0x02}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_VGA[][2] = { + {0x0006, 0x10}, + {0x000D, 0x00}, + {0x000E, 0x00}, + {0x0122, 0xEB}, + {0x0125, 0xFF}, + {0x0126, 0x70}, + {0x05E0, 0XC1}, + {0x05E1, 0x00}, + {0x05E2, 0xC1}, + {0x05E3, 0x00}, + {0x05E4, 0x03}, + {0x05E5, 0x00}, + {0x05E6, 0x82}, + {0x05E7, 0x02}, + {0x05E8, 0x04}, + {0x05E9, 0x00}, + {0x05EA, 0xE3}, + {0x05EB, 0x01}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_CIF[][2] = { + {0x0006, 0x00}, + {0x000D, 0x01}, + {0x000E, 0x11}, + {0x0122, 0xFB}, + {0x0125, 0xFF}, + {0x0126, 0x72}, + {0x05E0, 0XC0}, + {0x05E1, 0x00}, + {0x05E2, 0x8F}, + {0x05E3, 0x00}, + {0x05E4, 0x11}, + {0x05E5, 0x00}, + {0x05E6, 0xA0}, + {0x05E7, 0x01}, + {0x05E8, 0x08}, + {0x05E9, 0x00}, + {0x05EA, 0x2F}, + {0x05EB, 0x01}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_QVGA[][2] = { + {0x0006, 0x00}, + {0x000D, 0x01}, + {0x000E, 0x11}, + {0x0122, 0xFB}, + {0x0125, 0xFF}, + {0x0126, 0x70}, + {0x05E0, 0XBE}, + {0x05E1, 0x00}, + {0x05E2, 0xBE}, + {0x05E3, 0x00}, + {0x05E4, 0x3A}, + {0x05E5, 0x00}, + {0x05E6, 0x79}, + {0x05E7, 0x01}, + {0x05E8, 0x04}, + {0x05E9, 0x00}, + {0x05EA, 0xF3}, + {0x05EB, 0x00}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_QCIF[][2] = { + {0x0006, 0x00}, + {0x000D, 0x01}, + {0x000E, 0x11}, + {0x0122, 0xFB}, + {0x0125, 0xFF}, + {0x0126, 0x72}, + {0x05E0, 0X52}, + {0x05E1, 0x01}, + {0x05E2, 0x38}, + {0x05E3, 0x01}, + {0x05E4, 0x22}, + {0x05E5, 0x00}, + {0x05E6, 0xD1}, + {0x05E7, 0x00}, + {0x05E8, 0x04}, + {0x05E9, 0x00}, + {0x05EA, 0x93}, + {0x05EB, 0x00}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_240X240[][2] = { + {0x0006, 0x00}, + {0x000D, 0x01}, + {0x000E, 0x11}, + {0x0122, 0xFB}, + {0x0125, 0xFF}, + {0x0126, 0x70}, + {0x05E0, 0XBE}, + {0x05E1, 0x00}, + {0x05E2, 0xBE}, + {0x05E3, 0x00}, + {0x05E4, 0x62}, + {0x05E5, 0x00}, + {0x05E6, 0x51}, + {0x05E7, 0x01}, + {0x05E8, 0x04}, + {0x05E9, 0x00}, + {0x05EA, 0xF3}, + {0x05EB, 0x00}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_QQVGA[][2] = { + {0x0006, 0x00}, + {0x000D, 0x01}, + {0x000E, 0x11}, + {0x0122, 0xFB}, + {0x0125, 0xFF}, + {0x0126, 0x70}, + {0x05E0, 0X78}, + {0x05E1, 0x01}, + {0x05E2, 0x78}, + {0x05E3, 0x01}, + {0x05E4, 0x1E}, + {0x05E5, 0x00}, + {0x05E6, 0xBD}, + {0x05E7, 0x00}, + {0x05E8, 0x03}, + {0x05E9, 0x00}, + {0x05EA, 0x7A}, + {0x05EB, 0x00}, + {REGLIST_TAIL, 0x00}, +}; \ No newline at end of file From ca09cc4218356c1d2f12724c0380741b4bfa0bfa Mon Sep 17 00:00:00 2001 From: LynnL4 Date: Tue, 5 Nov 2024 15:08:50 +0800 Subject: [PATCH 2/5] Add support for HM0360 --- CMakeLists.txt | 1 + Kconfig | 7 + driver/esp_camera.c | 6 + driver/include/sensor.h | 4 + driver/sensor.c | 1 + sensors/hm0360.c | 410 +++++++++++++++++ sensors/private_include/hm0360.h | 27 ++ sensors/private_include/hm0360_regs.h | 86 ++++ sensors/private_include/hm0360_settings.h | 509 ++++++++++++++++++++++ target/esp32s3/ll_cam.c | 2 +- 10 files changed, 1052 insertions(+), 1 deletion(-) create mode 100755 sensors/hm0360.c create mode 100755 sensors/private_include/hm0360.h create mode 100755 sensors/private_include/hm0360_regs.h create mode 100755 sensors/private_include/hm0360_settings.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 5e4f9888a8..b92a4e246a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -42,6 +42,7 @@ if(IDF_TARGET STREQUAL "esp32" OR IDF_TARGET STREQUAL "esp32s2" OR IDF_TARGET ST sensors/sc030iot.c sensors/sc031gs.c sensors/hm1055.c + sensors/hm0360.c ) list(APPEND priv_include_dirs diff --git a/Kconfig b/Kconfig index a73f262a87..b0e2df39bb 100755 --- a/Kconfig +++ b/Kconfig @@ -123,6 +123,13 @@ menu "Camera configuration" help Enable this option if you want to use the HM1055. Disable this option to save memory. + + config HM0360_SUPPORT + bool "Support HM0360 VGA" + default y + help + Enable this option if you want to use the HM0360. + Disable this option to save memory. config SCCB_I2C_PORT diff --git a/driver/esp_camera.c b/driver/esp_camera.c index 3f6a8ea8f2..fa0911a278 100644 --- a/driver/esp_camera.c +++ b/driver/esp_camera.c @@ -72,6 +72,9 @@ #if CONFIG_HM1055_SUPPORT #include "hm1055.h" #endif +#if CONFIG_HM0360_SUPPORT +#include "hm0360.h" +#endif #if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG) #include "esp32-hal-log.h" @@ -149,6 +152,9 @@ static const sensor_func_t g_sensors[] = { #if CONFIG_HM1055_SUPPORT {hm1055_detect, hm1055_init}, #endif +#if CONFIG_HM0360_SUPPORT + {hm0360_detect, hm0360_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 d74ad3d998..a477aae0c4 100755 --- a/driver/include/sensor.h +++ b/driver/include/sensor.h @@ -32,6 +32,7 @@ typedef enum { SC030IOT_PID = 0x9a46, SC031GS_PID = 0x0031, HM1055_PID = 0x0955, + HM0360_PID = 0x0360 } camera_pid_t; typedef enum { @@ -50,6 +51,7 @@ typedef enum { CAMERA_SC030IOT, CAMERA_SC031GS, CAMERA_HM1055, + CAMERA_HM0360, CAMERA_MODEL_MAX, CAMERA_NONE, } camera_model_t; @@ -70,6 +72,7 @@ typedef enum { SC030IOT_SCCB_ADDR = 0x68,// 0xd0 >> 1 SC031GS_SCCB_ADDR = 0x30, HM1055_SCCB_ADDR = 0x24, + HM0360_SCCB_ADDR = 0x12, } camera_sccb_addr_t; typedef enum { @@ -82,6 +85,7 @@ typedef enum { PIXFORMAT_RAW, // RAW PIXFORMAT_RGB444, // 3BP2P/RGB444 PIXFORMAT_RGB555, // 3BP2P/RGB555 + PIXFORMAT_RAW8, // RAW 8-bit } pixformat_t; typedef enum { diff --git a/driver/sensor.c b/driver/sensor.c index 0180a6a928..1b0a4ba147 100644 --- a/driver/sensor.c +++ b/driver/sensor.c @@ -18,6 +18,7 @@ const camera_sensor_info_t camera_sensor[CAMERA_MODEL_MAX] = { {CAMERA_SC030IOT, "SC030IOT", SC030IOT_SCCB_ADDR, SC030IOT_PID, FRAMESIZE_VGA, false}, {CAMERA_SC031GS, "SC031GS", SC031GS_SCCB_ADDR, SC031GS_PID, FRAMESIZE_VGA, false}, {CAMERA_HM1055, "HM1055", HM1055_SCCB_ADDR, HM1055_PID, FRAMESIZE_HD, false}, + {CAMERA_HM0360, "HM0360", HM0360_SCCB_ADDR, HM0360_PID, FRAMESIZE_VGA, false}, }; const resolution_info_t resolution[FRAMESIZE_INVALID] = { diff --git a/sensors/hm0360.c b/sensors/hm0360.c new file mode 100755 index 0000000000..20ec82d389 --- /dev/null +++ b/sensors/hm0360.c @@ -0,0 +1,410 @@ +/* + * + * HM0360 driver. + * + */ +#include +#include +#include +#include "sccb.h" +#include "xclk.h" +#include "hm0360.h" +#include "hm0360_regs.h" +#include "hm0360_settings.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 = "HM0360"; +#endif + +// #define REG_DEBUG_ON + +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); + +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 check_reg_mask(uint8_t slv_addr, uint16_t reg, uint8_t mask) +{ + return (read_reg(slv_addr, reg) & mask) == mask; +} + +static int read_reg16(uint8_t slv_addr, const uint16_t reg) +{ + int ret = 0, ret2 = 0; + ret = read_reg(slv_addr, reg); + if (ret >= 0) + { + ret = (ret & 0xFF) << 8; + ret2 = read_reg(slv_addr, reg + 1); + if (ret2 < 0) + { + ret = ret2; + } + else + { + ret |= ret2 & 0xFF; + } + } + return ret; +} + +static int write_reg(uint8_t slv_addr, const uint16_t reg, uint8_t value) +{ + int ret = 0; +#ifndef REG_DEBUG_ON + ret = SCCB_Write16(slv_addr, reg, value); +#else + int old_value = read_reg(slv_addr, reg); + if (old_value < 0) + { + return old_value; + } + if ((uint8_t)old_value != value) + { + ESP_LOGD(TAG, "NEW REG 0x%04x: 0x%02x to 0x%02x", reg, (uint8_t)old_value, value); + ret = SCCB_Write16(slv_addr, reg, value); + } + else + { + ESP_LOGD(TAG, "OLD REG 0x%04x: 0x%02x", reg, (uint8_t)old_value); + ret = SCCB_Write16(slv_addr, reg, value); // maybe not? + } + if (ret < 0) + { + ESP_LOGE(TAG, "WRITE REG 0x%04x FAILED: %d", reg, ret); + } +#endif + return ret; +} + +static int set_reg_bits(uint8_t slv_addr, uint16_t reg, uint8_t offset, uint8_t mask, uint8_t value) +{ + int ret = 0; + uint8_t c_value, new_value; + ret = read_reg(slv_addr, reg); + if (ret < 0) + { + return ret; + } + c_value = ret; + new_value = (c_value & ~(mask << offset)) | ((value & mask) << offset); + ret = write_reg(slv_addr, reg, new_value); + return ret; +} + +static int write_regs(uint8_t slv_addr, const uint16_t (*regs)[2]) +{ + int i = 0, ret = 0; + while (!ret && regs[i][0] != REGLIST_TAIL) + { + if (regs[i][0] == REG_DLY) + { + vTaskDelay(regs[i][1] / portTICK_PERIOD_MS); + } + else + { + ret = write_reg(slv_addr, regs[i][0], regs[i][1]); + } + i++; + } + return ret; +} + +static int write_reg16(uint8_t slv_addr, const uint16_t reg, uint16_t value) +{ + if (write_reg(slv_addr, reg, value >> 8) || write_reg(slv_addr, reg + 1, value)) + { + return -1; + } + return 0; +} + +static int write_addr_reg(uint8_t slv_addr, const uint16_t reg, uint16_t x_value, uint16_t y_value) +{ + if (write_reg16(slv_addr, reg, x_value) || write_reg16(slv_addr, reg + 2, y_value)) + { + return -1; + } + return 0; +} + +#define write_reg_bits(slv_addr, reg, mask, enable) set_reg_bits(slv_addr, reg, 0, mask, (enable) ? (mask) : 0) + +static int set_ae_level(sensor_t *sensor, int level); + +static int reset(sensor_t *sensor) +{ + vTaskDelay(100 / portTICK_PERIOD_MS); + int ret = 0; + // Software Reset: clear all registers and reset them to their default values + ret = write_reg(sensor->slv_addr, SW_RESET, 0x00); + if (ret) + { + ESP_LOGE(TAG, "Software Reset FAILED!"); + return ret; + } + vTaskDelay(100 / portTICK_PERIOD_MS); + ret = write_regs(sensor->slv_addr, sensor_default_regs); + if (ret == 0) + { + ESP_LOGD(TAG, "Camera defaults loaded"); + vTaskDelay(100 / portTICK_PERIOD_MS); + set_ae_level(sensor, 0); + } + return ret; +} + +static int set_pixformat(sensor_t *sensor, pixformat_t pixformat) +{ + int ret = 0; + return ret; +} + +static int set_framesize(sensor_t *sensor, framesize_t framesize) +{ + int ret = 0; + + return ret; +} + +static int set_hmirror(sensor_t *sensor, int enable) +{ + int ret = 0; + return ret; +} + +static int set_vflip(sensor_t *sensor, int enable) +{ + int ret = 0; + return ret; +} + +static int set_quality(sensor_t *sensor, int qs) +{ + return 0; +} + +static int set_colorbar(sensor_t *sensor, int enable) +{ + return 0; +} + +static int set_gain_ctrl(sensor_t *sensor, int enable) +{ + return 0; +} + +static int set_exposure_ctrl(sensor_t *sensor, int enable) +{ + int ret = 0; + + return ret; +} + +// real gain +static int set_agc_gain(sensor_t *sensor, int gain) +{ + int ret = 0; + return ret; +} +static int set_aec_value(sensor_t *sensor, int value) +{ + int ret = 0; + return ret; +} + +static int set_ae_level(sensor_t *sensor, int level) +{ + int ret = 0; + return ret; +} + +static int set_brightness(sensor_t *sensor, int level) +{ + int ret = 0; + return ret; +} + +static int get_reg(sensor_t *sensor, int reg, int mask) +{ + int ret = 0, ret2 = 0; + if (mask > 0xFF) + { + ret = read_reg16(sensor->slv_addr, reg); + if (ret >= 0 && mask > 0xFFFF) + { + ret2 = read_reg(sensor->slv_addr, reg + 2); + if (ret2 >= 0) + { + ret = (ret << 8) | ret2; + } + else + { + ret = ret2; + } + } + } + else + { + ret = read_reg(sensor->slv_addr, reg); + } + if (ret > 0) + { + ret &= mask; + } + return ret; +} + +static int set_reg(sensor_t *sensor, int reg, int mask, int value) +{ + int ret = 0, ret2 = 0; + if (mask > 0xFF) + { + ret = read_reg16(sensor->slv_addr, reg); + if (ret >= 0 && mask > 0xFFFF) + { + ret2 = read_reg(sensor->slv_addr, reg + 2); + if (ret2 >= 0) + { + ret = (ret << 8) | ret2; + } + else + { + ret = ret2; + } + } + } + else + { + ret = read_reg(sensor->slv_addr, reg); + } + if (ret < 0) + { + return ret; + } + value = (ret & ~mask) | (value & mask); + if (mask > 0xFFFF) + { + ret = write_reg16(sensor->slv_addr, reg, value >> 8); + if (ret >= 0) + { + ret = write_reg(sensor->slv_addr, reg + 2, value & 0xFF); + } + } + else if (mask > 0xFF) + { + ret = write_reg16(sensor->slv_addr, reg, value); + } + else + { + ret = write_reg(sensor->slv_addr, reg, value); + } + return ret; +} + +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 0; +} +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); + if (ret == 0) + { + ESP_LOGD(TAG, "Set xclk to %d", xclk); + } + return ret; +} + +static int init_status(sensor_t *sensor) +{ + sensor->status.brightness = 0; + sensor->status.contrast = 0; + sensor->status.saturation = 0; + // sensor->status.awb = check_reg_mask(sensor->slv_addr, AEWBCFG, 0x02); + sensor->status.agc = true; + // sensor->status.aec = check_reg_mask(sensor->slv_addr, AEWBCFG, 0x04); + // sensor->status.hmirror = check_reg_mask(sensor->slv_addr, RDCFG, 0x02); + // sensor->status.vflip = check_reg_mask(sensor->slv_addr, RDCFG, 0x01); + // sensor->status.lenc = check_reg_mask(sensor->slv_addr, ISPCTRL3, 0x40); + // sensor->status.awb_gain = read_reg(sensor->slv_addr, DGAIN); + // sensor->status.agc_gain = read_reg(sensor->slv_addr, AGAIN); + // sensor->status.aec_value = read_reg(sensor->slv_addr, AETARGM); + return 0; +} + +int hm0360_detect(int slv_addr, sensor_id_t *id) +{ + if (HM1055_SCCB_ADDR == slv_addr) + { + uint8_t h = SCCB_Read16(slv_addr, MODEL_ID_H); + uint8_t l = SCCB_Read16(slv_addr, MODEL_ID_L); + uint16_t PID = (h << 8) | l; + if (HM0360_PID == PID) + { + id->PID = PID; + id->VER = SCCB_Read16(slv_addr, SILICON_REV); + return PID; + } + else + { + ESP_LOGD(TAG, "Mismatch PID=0x%x", PID); + } + } + return 0; +} + +int hm0360_init(sensor_t *sensor) +{ + sensor->reset = reset; + sensor->set_pixformat = set_pixformat; + sensor->set_framesize = set_framesize; + sensor->set_contrast = NULL; + sensor->set_brightness = set_brightness; + sensor->set_saturation = NULL; + sensor->set_sharpness = NULL; + sensor->set_gainceiling = NULL; + sensor->set_quality = set_quality; + sensor->set_colorbar = set_colorbar; + sensor->set_gain_ctrl = set_gain_ctrl; + sensor->set_exposure_ctrl = set_exposure_ctrl; + sensor->set_whitebal = NULL; + sensor->set_hmirror = set_hmirror; + sensor->set_vflip = set_vflip; + sensor->init_status = init_status; + sensor->set_aec2 = NULL; + sensor->set_aec_value = set_aec_value; + sensor->set_special_effect = NULL; + sensor->set_wb_mode = NULL; + sensor->set_ae_level = set_ae_level; + sensor->set_dcw = NULL; + sensor->set_bpc = NULL; + sensor->set_wpc = NULL; + sensor->set_agc_gain = set_agc_gain; + sensor->set_raw_gma = NULL; + sensor->set_lenc = NULL; + sensor->set_denoise = NULL; + + sensor->get_reg = get_reg; + sensor->set_reg = set_reg; + sensor->set_res_raw = set_res_raw; + sensor->set_pll = NULL; + sensor->set_xclk = set_xclk; + return 0; +} diff --git a/sensors/private_include/hm0360.h b/sensors/private_include/hm0360.h new file mode 100755 index 0000000000..822ecab2d4 --- /dev/null +++ b/sensors/private_include/hm0360.h @@ -0,0 +1,27 @@ +/* + * HM0360 driver. + */ +#ifndef __HM0360_H__ +#define __HM0360_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 hm0360_detect(int slv_addr, sensor_id_t *id); + +/** + * @brief initialize sensor function pointers + * + * @param sensor pointer of sensor + * @return + * Always 0 + */ +int hm0360_init(sensor_t *sensor); + +#endif // __HM1055_H__ diff --git a/sensors/private_include/hm0360_regs.h b/sensors/private_include/hm0360_regs.h new file mode 100755 index 0000000000..314ae6c126 --- /dev/null +++ b/sensors/private_include/hm0360_regs.h @@ -0,0 +1,86 @@ +/* + * HM1055 register definitions. + */ +#ifndef __REG_REGS_H__ +#define __REG_REGS_H__ + +// Sensor ID +#define MODEL_ID_H 0x0000 +#define MODEL_ID_L 0x0001 +#define SILICON_REV 0x0002 +#define FRAME_COUNT_H 0x0005 +#define FRAME_COUNT_L 0x0006 +#define PIXEL_ODERDER 0x0007 + +// Snesor mode control +#define MODEL_SELECT 0x0100 +#define IMAGE_ORIENTATION 0x0101 +#define EMBEDDED_LINE_EN 0x0102 +#define SW_RESET 0x0103 +#define COMMAND_UPDATE 0x0104 + +// Sensor exposure gain control +#define INTERGRATION_H 0x0202 +#define INTERGRATION_L 0x0203 +#define ANALOG_GAIN 0x0205 +#define DIGITAL_GAIN_H 0x020E +#define DIGITAL_GAIN_L 0x020F + +// clock control +#define PLL1CFG 0x0300 +#define PLL2CFG 0x0301 +#define PLL3CFG 0x0302 + +// frame timming control +#define FRAME_LENGTH_LINES_H 0x0340 +#define FRAME_LENGTH_LINES_L 0x0341 +#define LINE_LENGTH_PCK_H 0x0342 +#define LINE_LENGTH_PCK_L 0x0343 + +// monochrome programming +#define MONO_MODE 0x0370 +#define MONO_MODE_ISP 0x0371 +#define MONO_MONIDE_SEL 0x0372 + +// sub-sampling / binning control +#define H_SUB 0x0380 +#define V_SUB 0x0381 +#define BINNING 0x0382 + +// test pattern control +#define TEST_PATTERN_MODE 0x0601 +#define TEST_DATA_BLUE_H 0x0602 +#define TEST_DATA_BLUE_L 0x0603 +#define TEST_DATA_GB_H 0x0604 +#define TEST_DATA_GB_L 0x0605 +#define TEST_DATA_GR_H 0x0605 +#define TEST_DATA_GR_L 0x0606 +#define TEST_DATA_RED_H 0x0608 +#define TEST_DATA_RED_L 0x0609 + +// black level control +#define BLC_TGT 0x1004 +#define BLC2_TGT 0x1009 + +// monochrome programming +#define MONO_CTRL 0x100A + +// VSYNC / HSYNC / pixel shift +#define OPFM_CTRL 0x1014 + +// automatic exposure programming +#define AE_CTRL 0x2000 +#define AE_CTRL2 0x2001 +#define CNT_ORG_H_H 0x2002 +#define CNT_ORG_H_L 0x2003 +#define CNT_ORG_V_H 0x2004 +#define CNT_ORG_V_L 0x2005 +#define CNT_ST_H_H 0x2006 +#define CNT_ST_H_L 0x2007 +#define CNT_ST_V_H 0x2008 +#define CNT_ST_V_L 0x2009 +#define CTRL_PG_SKIPCNT 0x200A +#define BV_WIN_WEIGHT_EN 0x200D + + +#endif //__REG_REGS_H__ diff --git a/sensors/private_include/hm0360_settings.h b/sensors/private_include/hm0360_settings.h new file mode 100755 index 0000000000..39f442a301 --- /dev/null +++ b/sensors/private_include/hm0360_settings.h @@ -0,0 +1,509 @@ + +#include + +#define REG_DLY 0xffff +#define REGLIST_TAIL 0xffff + +static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { + {0x0103, 0x00}, + // 0xffff,0xc0, + {0x3035, 0x01}, + {0x3126, 0x03}, + {0x3128, 0x57}, + {0x3142, 0x9F}, + {0x311C, 0x10}, + {0x3115, 0x42}, + {0x3116, 0x10}, + {0x3117, 0x0A}, + {0x310B, 0x10}, + {0x3031, 0x01}, + {0x312E, 0x00}, + {0x30D7, 0x00}, + {0x30DC, 0x00}, + {0x30E1, 0x00}, + {0x30E6, 0x00}, + {0x30EB, 0x00}, + {0x30F0, 0x00}, + {0x30F5, 0x00}, + {0x30FA, 0x00}, + {0x30FF, 0x00}, + {0x3104, 0x00}, + {0x30D8, 0xA7}, + {0x30DD, 0x27}, + {0x30E2, 0x27}, + {0x30E7, 0x27}, + {0x30EC, 0x27}, + {0x30F1, 0xA7}, + {0x30F6, 0x27}, + {0x30FB, 0x27}, + {0x3100, 0x27}, + {0x3105, 0x27}, + {0x30D9, 0x05}, + {0x30DE, 0x05}, + {0x30E3, 0x05}, + {0x30E8, 0x05}, + {0x30ED, 0x05}, + {0x30F2, 0x05}, + {0x30F7, 0x05}, + {0x30FC, 0x05}, + {0x3101, 0x05}, + {0x3106, 0x05}, + {0x30C4, 0x10}, + {0x30C5, 0x01}, + {0x30C6, 0xBF}, + {0x30CB, 0xFF}, + {0x30CC, 0xFF}, + {0x30CD, 0x7F}, + {0x30CE, 0x7F}, + {0x30D3, 0x01}, + {0x30D4, 0xFF}, + {0x311F, 0x0E}, + {0x3120, 0x0D}, + {0x3121, 0x0F}, + {0x3122, 0x00}, + {0x3147, 0x18}, + {0x314B, 0x01}, + {0x3149, 0x18}, + {0x3150, 0x50}, + {0x3152, 0x00}, + {0x3156, 0x2C}, + {0x3163, 0x1F}, + {0x3165, 0x7F}, + {0x312B, 0x41}, + {0x3113, 0xA0}, + {0x3114, 0x67}, + {0x317D, 0x02}, + {0x3160, 0x1F}, + {0x318C, 0x00}, + {0x315C, 0xE0}, + {0x311E, 0x0F}, + {0x30D5, 0x00}, + {0x30DA, 0x01}, + {0x30DF, 0x07}, + {0x30E4, 0x47}, + {0x30E9, 0x87}, + {0x30FD, 0x47}, + {0x3102, 0x87}, + {0x311D, 0x06}, + {0x3141, 0x2A}, + {0x315A, 0x0A}, + {0x30D6, 0x40}, + {0x30DB, 0x40}, + {0x30E0, 0x40}, + {0x30E5, 0x30}, + {0x30EA, 0x30}, + {0x30EF, 0x40}, + {0x30F4, 0x40}, + {0x30F9, 0x40}, + {0x30FE, 0x30}, + {0x3103, 0x30}, + {0x3164, 0x7F}, + {0x282A, 0x0F}, + {0x282E, 0x2F}, + {0x282B, 0x08}, + {0x312A, 0x11}, + {0x1000, 0x43}, + {0x1001, 0x80}, + {0x0350, 0xE0}, + {0x101D, 0xCF}, + {0x1021, 0x5D}, + {0x3500, 0x74}, + {0x3501, 0x0A}, + {0x3502, 0x77}, + {0x3503, 0x04}, + {0x3504, 0x14}, + {0x3505, 0x03}, + {0x3506, 0x00}, + {0x3507, 0x00}, + {0x3508, 0x00}, + {0x3509, 0x00}, + {0x350A, 0xFF}, + {0x350B, 0x00}, + {0x350D, 0x01}, + {0x350C, 0x00}, + {0x350F, 0x00}, + {0x3510, 0x01}, + {0x3513, 0x00}, + {0x351C, 0x00}, + {0x3514, 0x00}, + {0x3515, 0x01}, + {0x3516, 0x00}, + {0x3517, 0x02}, + {0x3518, 0x00}, + {0x3519, 0x7F}, + {0x351A, 0x00}, + {0x351B, 0x5F}, + {0x351D, 0x04}, + {0x351E, 0x10}, + {0x352A, 0x01}, + {0x352B, 0x04}, + {0x352C, 0x01}, + {0x352D, 0x38}, + {0x354B, 0x21}, + {0x354C, 0x01}, + {0x354D, 0xE0}, + {0x354E, 0xF0}, + {0x354F, 0x10}, + {0x3550, 0x10}, + {0x3551, 0x10}, + {0x3552, 0x20}, + {0x3553, 0x10}, + {0x3554, 0x01}, + {0x3555, 0x06}, + {0x3556, 0x0C}, + {0x3557, 0x12}, + {0x3558, 0x1C}, + {0x3559, 0x30}, + {0x3549, 0x04}, + {0x354A, 0x35}, + {0x355A, 0x74}, + {0x355B, 0x0A}, + {0x355C, 0x77}, + {0x355D, 0x04}, + {0x355E, 0x14}, + {0x355F, 0x03}, + {0x3560, 0x00}, + {0x3561, 0x01}, + {0x3562, 0x01}, + {0x3563, 0x00}, + {0x3564, 0xFF}, + {0x3565, 0x00}, + {0x3567, 0x01}, + {0x3566, 0x00}, + {0x3569, 0x00}, + {0x356A, 0x01}, + {0x356D, 0x00}, + {0x3576, 0x00}, + {0x356E, 0x00}, + {0x356F, 0x01}, + {0x3570, 0x00}, + {0x3571, 0x02}, + {0x3572, 0x00}, + {0x3573, 0x3F}, + {0x3574, 0x00}, + {0x3575, 0x2F}, + {0x3577, 0x04}, + {0x3578, 0x10}, + {0x3584, 0x01}, + {0x3585, 0x04}, + {0x3586, 0x01}, + {0x3587, 0x38}, + {0x3588, 0x02}, + {0x3589, 0x12}, + {0x358A, 0x04}, + {0x358B, 0x24}, + {0x358C, 0x06}, + {0x358D, 0x36}, + {0x35A5, 0x21}, + {0x35A6, 0x01}, + {0x35A7, 0xE0}, + {0x35A8, 0xF0}, + {0x35A9, 0x10}, + {0x35AA, 0x10}, + {0x35AB, 0x10}, + {0x35AC, 0x20}, + {0x35AD, 0x10}, + {0x35AE, 0x01}, + {0x35AF, 0x06}, + {0x35B0, 0x0C}, + {0x35B1, 0x12}, + {0x35B2, 0x1C}, + {0x35B3, 0x30}, + {0x35A3, 0x02}, + {0x35A4, 0x03}, + {0x3512, 0x3F}, + {0x351F, 0x04}, + {0x3520, 0x03}, + {0x3521, 0x00}, + {0x3523, 0x60}, + {0x3524, 0x08}, + {0x3525, 0x19}, + {0x3526, 0x08}, + {0x3527, 0x10}, + {0x356C, 0x3F}, + {0x3579, 0x04}, + {0x357A, 0x03}, + {0x357B, 0x00}, + {0x357D, 0x60}, + {0x357E, 0x08}, + {0x357F, 0x19}, + {0x3580, 0x08}, + {0x3581, 0x10}, + {0x2048, 0x00}, + {0x2049, 0x10}, + {0x204A, 0x40}, + {0x204E, 0x00}, + {0x204F, 0x38}, + {0x2050, 0xE0}, + {0x204B, 0x00}, + {0x204C, 0x08}, + {0x204D, 0x20}, + {0x2051, 0x00}, + {0x2052, 0x1C}, + {0x2053, 0x70}, + {0x2054, 0x00}, + {0x2055, 0x1A}, + {0x2056, 0xC0}, + {0x2057, 0x00}, + {0x2058, 0x06}, + {0x2059, 0xB0}, + {0x2080, 0x41}, + {0x2083, 0x01}, + {0x208D, 0x02}, + {0x208E, 0x08}, + {0x208F, 0x0D}, + {0x2090, 0x14}, + {0x2091, 0x1D}, + {0x2092, 0x30}, + {0x2093, 0x08}, + {0x2094, 0x0A}, + {0x2095, 0x0F}, + {0x2096, 0x14}, + {0x2097, 0x18}, + {0x2098, 0x20}, + {0x2099, 0x10}, + {0x209A, 0x00}, + {0x209B, 0x01}, + {0x209C, 0x01}, + {0x209D, 0x11}, + {0x209E, 0x06}, + {0x1030, 0x09}, + {0x1031, 0x12}, + {0x1032, 0x23}, + {0x1033, 0x31}, + {0x1034, 0x3E}, + {0x1035, 0x4B}, + {0x1036, 0x56}, + {0x1037, 0x5E}, + {0x1038, 0x65}, + {0x1039, 0x72}, + {0x103A, 0x7F}, + {0x103B, 0x8C}, + {0x103C, 0x98}, + {0x103D, 0xB2}, + {0x103E, 0xCC}, + {0x103F, 0xE6}, + {0x35B4, 0x74}, + {0x35B5, 0x0A}, + {0x35B6, 0x77}, + {0x35B7, 0x00}, + {0x35B8, 0x94}, + {0x35B9, 0x03}, + {0x35BA, 0x00}, + {0x35BB, 0x03}, + {0x35BD, 0x00}, + {0x35BE, 0xFF}, + {0x35BF, 0x00}, + {0x35C1, 0x01}, + {0x35C0, 0x01}, + {0x35C3, 0x00}, + {0x35C4, 0x00}, + {0x35C6, 0x3F}, + {0x35C7, 0x00}, + {0x35D0, 0x00}, + {0x35D3, 0x04}, + {0x35D7, 0x18}, + {0x35D8, 0x01}, + {0x35D9, 0x20}, + {0x35DA, 0x08}, + {0x35DB, 0x14}, + {0x35DC, 0x70}, + {0x35C8, 0x00}, + {0x35C9, 0x01}, + {0x35CA, 0x00}, + {0x35CB, 0x02}, + {0x35CC, 0x00}, + {0x35CD, 0x0F}, + {0x35CE, 0x00}, + {0x35CF, 0x0B}, + {0x35DE, 0x00}, + {0x35DF, 0x01}, + {0x35FD, 0x00}, + {0x35FE, 0x5E}, + {0x3024, 0x00}, + {0x3025, 0x12}, + {0x3026, 0x03}, + {0x3027, 0x81}, + {0x3028, 0x01}, + {0x3029, 0x00}, + {0x302A, 0x30}, + {0x2061, 0x00}, + {0x2062, 0x00}, + {0x2063, 0xC8}, + {0x1014, 0x00}, + {0x102F, 0x08}, + {0x309E, 0x05}, + {0x309F, 0x02}, + {0x30A0, 0x02}, + {0x30A1, 0x00}, + {0x30A2, 0x08}, + {0x30A3, 0x00}, + {0x30A4, 0x20}, + {0x30A5, 0x04}, + {0x30A6, 0x02}, + {0x30A7, 0x02}, + {0x30A8, 0x01}, + {0x30B0, 0x03}, + {0x3112, 0x04}, + {0x311A, 0x30}, + {0x2800, 0x00}, + {0x0370, 0x00}, + {0x0371, 0x00}, + {0x0372, 0x01}, + {0x100A, 0x05}, + {0x2590, 0x01}, + {0x0104, 0x01}, + {0x0100, 0x01}, + // 0xFFFF,0xC0, + {REGLIST_TAIL, 0x00}, // tail +}; + +static const DRAM_ATTR uint16_t sensor_framesize_HD[][2] = { + {0x0006, 0x00}, + {0x000D, 0x00}, + {0x000E, 0x00}, + {0x0122, 0xFB}, + {0x0125, 0xDF}, + {0x0126, 0x70}, + {0x05E4, 0x08}, + {0x05E5, 0x00}, + {0x05E6, 0x07}, + {0x05E7, 0x05}, + {0x05E8, 0x08}, + {0x05E9, 0x00}, + {0x05EA, 0xD7}, + {0x05EB, 0x02}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_VGA[][2] = { + {0x0006, 0x10}, + {0x000D, 0x00}, + {0x000E, 0x00}, + {0x0122, 0xEB}, + {0x0125, 0xFF}, + {0x0126, 0x70}, + {0x05E0, 0XC1}, + {0x05E1, 0x00}, + {0x05E2, 0xC1}, + {0x05E3, 0x00}, + {0x05E4, 0x03}, + {0x05E5, 0x00}, + {0x05E6, 0x82}, + {0x05E7, 0x02}, + {0x05E8, 0x04}, + {0x05E9, 0x00}, + {0x05EA, 0xE3}, + {0x05EB, 0x01}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_CIF[][2] = { + {0x0006, 0x00}, + {0x000D, 0x01}, + {0x000E, 0x11}, + {0x0122, 0xFB}, + {0x0125, 0xFF}, + {0x0126, 0x72}, + {0x05E0, 0XC0}, + {0x05E1, 0x00}, + {0x05E2, 0x8F}, + {0x05E3, 0x00}, + {0x05E4, 0x11}, + {0x05E5, 0x00}, + {0x05E6, 0xA0}, + {0x05E7, 0x01}, + {0x05E8, 0x08}, + {0x05E9, 0x00}, + {0x05EA, 0x2F}, + {0x05EB, 0x01}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_QVGA[][2] = { + {0x0006, 0x00}, + {0x000D, 0x01}, + {0x000E, 0x11}, + {0x0122, 0xFB}, + {0x0125, 0xFF}, + {0x0126, 0x70}, + {0x05E0, 0XBE}, + {0x05E1, 0x00}, + {0x05E2, 0xBE}, + {0x05E3, 0x00}, + {0x05E4, 0x3A}, + {0x05E5, 0x00}, + {0x05E6, 0x79}, + {0x05E7, 0x01}, + {0x05E8, 0x04}, + {0x05E9, 0x00}, + {0x05EA, 0xF3}, + {0x05EB, 0x00}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_QCIF[][2] = { + {0x0006, 0x00}, + {0x000D, 0x01}, + {0x000E, 0x11}, + {0x0122, 0xFB}, + {0x0125, 0xFF}, + {0x0126, 0x72}, + {0x05E0, 0X52}, + {0x05E1, 0x01}, + {0x05E2, 0x38}, + {0x05E3, 0x01}, + {0x05E4, 0x22}, + {0x05E5, 0x00}, + {0x05E6, 0xD1}, + {0x05E7, 0x00}, + {0x05E8, 0x04}, + {0x05E9, 0x00}, + {0x05EA, 0x93}, + {0x05EB, 0x00}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_240X240[][2] = { + {0x0006, 0x00}, + {0x000D, 0x01}, + {0x000E, 0x11}, + {0x0122, 0xFB}, + {0x0125, 0xFF}, + {0x0126, 0x70}, + {0x05E0, 0XBE}, + {0x05E1, 0x00}, + {0x05E2, 0xBE}, + {0x05E3, 0x00}, + {0x05E4, 0x62}, + {0x05E5, 0x00}, + {0x05E6, 0x51}, + {0x05E7, 0x01}, + {0x05E8, 0x04}, + {0x05E9, 0x00}, + {0x05EA, 0xF3}, + {0x05EB, 0x00}, + {REGLIST_TAIL, 0x00}, +}; + +static const DRAM_ATTR uint16_t sensor_framesize_QQVGA[][2] = { + {0x0006, 0x00}, + {0x000D, 0x01}, + {0x000E, 0x11}, + {0x0122, 0xFB}, + {0x0125, 0xFF}, + {0x0126, 0x70}, + {0x05E0, 0X78}, + {0x05E1, 0x01}, + {0x05E2, 0x78}, + {0x05E3, 0x01}, + {0x05E4, 0x1E}, + {0x05E5, 0x00}, + {0x05E6, 0xBD}, + {0x05E7, 0x00}, + {0x05E8, 0x03}, + {0x05E9, 0x00}, + {0x05EA, 0x7A}, + {0x05EB, 0x00}, + {REGLIST_TAIL, 0x00}, +}; \ No newline at end of file diff --git a/target/esp32s3/ll_cam.c b/target/esp32s3/ll_cam.c index 71caf14f69..f5c1aa0e7a 100644 --- a/target/esp32s3/ll_cam.c +++ b/target/esp32s3/ll_cam.c @@ -557,7 +557,7 @@ size_t IRAM_ATTR ll_cam_memcpy(cam_obj_t *cam, uint8_t *out, const uint8_t *in, esp_err_t ll_cam_set_sample_mode(cam_obj_t *cam, pixformat_t pix_format, uint32_t xclk_freq_hz, uint16_t sensor_pid) { if (pix_format == PIXFORMAT_GRAYSCALE) { - if (sensor_pid == OV3660_PID || sensor_pid == OV5640_PID || sensor_pid == NT99141_PID || sensor_pid == SC031GS_PID || sensor_pid == BF20A6_PID || sensor_pid == GC0308_PID) { + if (sensor_pid == OV3660_PID || sensor_pid == OV5640_PID || sensor_pid == NT99141_PID || sensor_pid == SC031GS_PID || sensor_pid == BF20A6_PID || sensor_pid == GC0308_PID || sensor_pid == HM0360_PID) { cam->in_bytes_per_pixel = 1; // camera sends Y8 } else { cam->in_bytes_per_pixel = 2; // camera sends YU/YV From 269a9b8acfb05650bba7e74c6533f7199c5120c8 Mon Sep 17 00:00:00 2001 From: Lesords <2385342343@qq.com> Date: Fri, 29 Nov 2024 20:22:55 +0800 Subject: [PATCH 3/5] perf: improve some interface functions of hm0360 camera and discarded useless interfaces --- sensors/hm0360.c | 209 ++++++++++------ sensors/private_include/hm0360_regs.h | 74 +++++- sensors/private_include/hm0360_settings.h | 284 ++++++++++++---------- 3 files changed, 368 insertions(+), 199 deletions(-) diff --git a/sensors/hm0360.c b/sensors/hm0360.c index 20ec82d389..1c96022e3e 100755 --- a/sensors/hm0360.c +++ b/sensors/hm0360.c @@ -144,8 +144,6 @@ static int write_addr_reg(uint8_t slv_addr, const uint16_t reg, uint16_t x_value #define write_reg_bits(slv_addr, reg, mask, enable) set_reg_bits(slv_addr, reg, 0, mask, (enable) ? (mask) : 0) -static int set_ae_level(sensor_t *sensor, int level); - static int reset(sensor_t *sensor) { vTaskDelay(100 / portTICK_PERIOD_MS); @@ -163,7 +161,6 @@ static int reset(sensor_t *sensor) { ESP_LOGD(TAG, "Camera defaults loaded"); vTaskDelay(100 / portTICK_PERIOD_MS); - set_ae_level(sensor, 0); } return ret; } @@ -171,6 +168,16 @@ static int reset(sensor_t *sensor) static int set_pixformat(sensor_t *sensor, pixformat_t pixformat) { int ret = 0; + sensor->pixformat = pixformat; + + switch (pixformat) { + case PIXFORMAT_GRAYSCALE: + break; + default: + ESP_LOGE(TAG, "Only support GRAYSCALE"); + return -1; + } + return ret; } @@ -178,65 +185,107 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize) { int ret = 0; + sensor->status.framesize = framesize; + ret = write_regs(sensor->slv_addr, sensor_default_regs); + + if (framesize == FRAMESIZE_QQVGA) + { + ESP_LOGI(TAG, "Set FRAMESIZE_QQVGA"); + ret |= write_regs(sensor->slv_addr, sensor_framesize_QQVGA); + ret |= set_reg_bits(sensor->slv_addr, 0x3024, 0, 0x01, 1); + } + else if (framesize == FRAMESIZE_QVGA) + { + ESP_LOGI(TAG, "Set FRAMESIZE_QVGA"); + ret |= write_regs(sensor->slv_addr, sensor_framesize_QVGA); + ret |= set_reg_bits(sensor->slv_addr, 0x3024, 0, 0x01, 1); + } + else if (framesize == FRAMESIZE_VGA) + { + ESP_LOGI(TAG, "Set FRAMESIZE_VGA"); + ret |= set_reg_bits(sensor->slv_addr, 0x3024, 0, 0x01, 0); + } + else + { + ESP_LOGI(TAG, "Dont suppost this size, Set FRAMESIZE_VGA"); + ret |= set_reg_bits(sensor->slv_addr, 0x3024, 0, 0x01, 0); + } + + if (ret == 0) + { + _set_pll(sensor, 0, 0, 0, 0, 0, 0, 0, 0); + ret |= write_reg(sensor->slv_addr, 0x0104, 0x01); + } + return ret; } static int set_hmirror(sensor_t *sensor, int enable) { - int ret = 0; - return ret; + if (set_reg_bits(sensor->slv_addr, 0x0101, 0, 0x01, enable)) { + return -1; + } + + ESP_LOGD(TAG, "Set h-mirror to: %d", enable); + + return 0; } static int set_vflip(sensor_t *sensor, int enable) { - int ret = 0; - return ret; -} + if (set_reg_bits(sensor->slv_addr, 0x0101, 1, 0x01, enable)) { + return -1; + } + + ESP_LOGD(TAG, "Set v-flip to: %d", enable); -static int set_quality(sensor_t *sensor, int qs) -{ return 0; } static int set_colorbar(sensor_t *sensor, int enable) { - return 0; -} + if (set_reg_bits(sensor->slv_addr, 0x0601, 0, 0x01, enable)) { + return -1; + } + + ESP_LOGD(TAG, "Set color-bar to: %d", enable); -static int set_gain_ctrl(sensor_t *sensor, int enable) -{ return 0; } static int set_exposure_ctrl(sensor_t *sensor, int enable) { - int ret = 0; - - return ret; -} + if (set_reg_bits(sensor->slv_addr, 0x2000, 0, 0x01, enable)) { + return -1; + } -// real gain -static int set_agc_gain(sensor_t *sensor, int gain) -{ - int ret = 0; - return ret; -} -static int set_aec_value(sensor_t *sensor, int value) -{ - int ret = 0; - return ret; -} + ESP_LOGD(TAG, "Set exposure to: %d", enable); -static int set_ae_level(sensor_t *sensor, int level) -{ - int ret = 0; - return ret; + return 0; } static int set_brightness(sensor_t *sensor, int level) { - int ret = 0; - return ret; + uint8_t ae_mean; + + switch (level) { + case 0: + ae_mean = 60; + break; + case 1: + ae_mean = 80; + break; + case 2: + ae_mean = 100; + break; + case 3: + ae_mean = 127; + break; + default: + ae_mean = 80; + } + + return write_reg(sensor->slv_addr, AE_TARGET_MEAN, ae_mean); } static int get_reg(sensor_t *sensor, int reg, int mask) @@ -316,10 +365,6 @@ static int set_reg(sensor_t *sensor, int reg, int mask, int value) return ret; } -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 0; -} static int set_xclk(sensor_t *sensor, int timer, int xclk) { int ret = 0; @@ -332,20 +377,40 @@ static int set_xclk(sensor_t *sensor, int timer, int xclk) return ret; } +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) +{ + uint8_t value = 0; + uint8_t pll_cfg = 0; + + if (sensor->xclk_freq_hz <= 6000000) + { + value = 0x03; + } + else if (sensor->xclk_freq_hz <= 12000000) + { + value = 0x02; + } + else if (sensor->xclk_freq_hz <= 18000000) + { + value = 0x01; + } + else + { // max is 48000000 + value = 0x00; + } + + pll_cfg = read_reg(sensor->slv_addr, PLL1CFG); + return write_reg(sensor->slv_addr, PLL1CFG, (pll_cfg & 0xFC) | value); +} + +static int set_dummy(sensor_t *sensor, int val) +{ + ESP_LOGW(TAG, "Unsupported"); + return -1; +} + static int init_status(sensor_t *sensor) { - sensor->status.brightness = 0; - sensor->status.contrast = 0; - sensor->status.saturation = 0; - // sensor->status.awb = check_reg_mask(sensor->slv_addr, AEWBCFG, 0x02); - sensor->status.agc = true; - // sensor->status.aec = check_reg_mask(sensor->slv_addr, AEWBCFG, 0x04); - // sensor->status.hmirror = check_reg_mask(sensor->slv_addr, RDCFG, 0x02); - // sensor->status.vflip = check_reg_mask(sensor->slv_addr, RDCFG, 0x01); - // sensor->status.lenc = check_reg_mask(sensor->slv_addr, ISPCTRL3, 0x40); - // sensor->status.awb_gain = read_reg(sensor->slv_addr, DGAIN); - // sensor->status.agc_gain = read_reg(sensor->slv_addr, AGAIN); - // sensor->status.aec_value = read_reg(sensor->slv_addr, AETARGM); return 0; } @@ -375,36 +440,36 @@ int hm0360_init(sensor_t *sensor) sensor->reset = reset; sensor->set_pixformat = set_pixformat; sensor->set_framesize = set_framesize; - sensor->set_contrast = NULL; + sensor->set_contrast = set_dummy; sensor->set_brightness = set_brightness; - sensor->set_saturation = NULL; - sensor->set_sharpness = NULL; - sensor->set_gainceiling = NULL; - sensor->set_quality = set_quality; + sensor->set_saturation = set_dummy; + sensor->set_sharpness = set_dummy; + sensor->set_gainceiling = set_dummy; + sensor->set_quality = set_dummy; sensor->set_colorbar = set_colorbar; - sensor->set_gain_ctrl = set_gain_ctrl; + sensor->set_gain_ctrl = set_dummy; sensor->set_exposure_ctrl = set_exposure_ctrl; - sensor->set_whitebal = NULL; + sensor->set_whitebal = set_dummy; sensor->set_hmirror = set_hmirror; sensor->set_vflip = set_vflip; sensor->init_status = init_status; - sensor->set_aec2 = NULL; - sensor->set_aec_value = set_aec_value; - sensor->set_special_effect = NULL; - sensor->set_wb_mode = NULL; - sensor->set_ae_level = set_ae_level; - sensor->set_dcw = NULL; - sensor->set_bpc = NULL; - sensor->set_wpc = NULL; - sensor->set_agc_gain = set_agc_gain; - sensor->set_raw_gma = NULL; - sensor->set_lenc = NULL; - sensor->set_denoise = NULL; + sensor->set_aec2 = set_dummy; + sensor->set_aec_value = set_dummy; + sensor->set_special_effect = set_dummy; + sensor->set_wb_mode = set_dummy; + sensor->set_ae_level = set_dummy; + sensor->set_dcw = set_dummy; + sensor->set_bpc = set_dummy; + sensor->set_wpc = set_dummy; + sensor->set_agc_gain = set_dummy; + sensor->set_raw_gma = set_dummy; + sensor->set_lenc = set_dummy; + sensor->set_denoise = set_dummy; sensor->get_reg = get_reg; sensor->set_reg = set_reg; - sensor->set_res_raw = set_res_raw; - sensor->set_pll = NULL; + sensor->set_res_raw = NULL; + sensor->set_pll = _set_pll; sensor->set_xclk = set_xclk; return 0; } diff --git a/sensors/private_include/hm0360_regs.h b/sensors/private_include/hm0360_regs.h index 314ae6c126..9017484889 100755 --- a/sensors/private_include/hm0360_regs.h +++ b/sensors/private_include/hm0360_regs.h @@ -20,8 +20,8 @@ #define COMMAND_UPDATE 0x0104 // Sensor exposure gain control -#define INTERGRATION_H 0x0202 -#define INTERGRATION_L 0x0203 +#define INTEGRATION_H 0x0202 +#define INTEGRATION_L 0x0203 #define ANALOG_GAIN 0x0205 #define DIGITAL_GAIN_H 0x020E #define DIGITAL_GAIN_L 0x020F @@ -40,12 +40,12 @@ // monochrome programming #define MONO_MODE 0x0370 #define MONO_MODE_ISP 0x0371 -#define MONO_MONIDE_SEL 0x0372 +#define MONO_MODE_SEL 0x0372 // sub-sampling / binning control #define H_SUB 0x0380 #define V_SUB 0x0381 -#define BINNING 0x0382 +#define BINNING_MODE 0x0382 // test pattern control #define TEST_PATTERN_MODE 0x0601 @@ -68,9 +68,28 @@ // VSYNC / HSYNC / pixel shift #define OPFM_CTRL 0x1014 +// Tone mapping registers +#define CMPRS_CTRL 0x102F +#define CMPRS_01 0x1030 +#define CMPRS_02 0x1031 +#define CMPRS_03 0x1032 +#define CMPRS_04 0x1033 +#define CMPRS_05 0x1034 +#define CMPRS_06 0x1035 +#define CMPRS_07 0x1036 +#define CMPRS_08 0x1037 +#define CMPRS_09 0x1038 +#define CMPRS_10 0x1039 +#define CMPRS_11 0x103A +#define CMPRS_12 0x103B +#define CMPRS_13 0x103C +#define CMPRS_14 0x103D +#define CMPRS_15 0x103E +#define CMPRS_16 0x103F + // automatic exposure programming #define AE_CTRL 0x2000 -#define AE_CTRL2 0x2001 +#define AE_CTRL1 0x2001 #define CNT_ORG_H_H 0x2002 #define CNT_ORG_H_L 0x2003 #define CNT_ORG_V_H 0x2004 @@ -81,6 +100,51 @@ #define CNT_ST_V_L 0x2009 #define CTRL_PG_SKIPCNT 0x200A #define BV_WIN_WEIGHT_EN 0x200D +#define MAX_INTG_H 0x2029 +#define MAX_INTG_L 0x202A +#define MAX_AGAIN 0x202B +#define MAX_DGAIN_H 0x202C +#define MAX_DGAIN_L 0x202D +#define MIN_INTG 0x202E +#define MIN_AGAIN 0x202F +#define MIN_DGAIN 0x2030 +#define T_DAMPING 0x2031 +#define N_DAMPING 0x2032 +#define ALC_TH 0x2033 +#define AE_TARGET_MEAN 0x2034 +#define AE_MIN_MEAN 0x2035 +#define AE_TARGET_ZONE 0x2036 +#define CONVERGE_IN_TH 0x2037 +#define CONVERGE_OUT_TH 0x2038 + +// Interrupt control +#define PULSE_MODE 0x2061 +#define PULSE_TH_H 0x2062 +#define PULSE_TH_L 0x2063 +#define INT_INDIC 0x2064 +#define INT_CLEAR 0x2065 + +// Motion detection control +#define MD_CTRL 0x2080 +#define ROI_START_END_V 0x2081 +#define ROI_START_END_H 0x2082 +#define MD_TH_MIN 0x2083 +#define MD_TH_STR_L 0x2084 +#define MD_TH_STR_H 0x2085 +#define MD_LIGHT_COEF 0x2099 +#define MD_BLOCK_NUM_TH 0x209B +#define MD_LATENCY 0x209C +#define MD_LATENCY_TH 0x209D +#define MD_CTRL1 0x209E + +// Context switch control registers +#define PMU_CFG_3 0x3024 +#define PMU_CFG_4 0x3025 + +// Operation mode control +#define WIN_MODE 0x3030 +// IO and clock control +#define PAD_REGISTER_07 0x3112 #endif //__REG_REGS_H__ diff --git a/sensors/private_include/hm0360_settings.h b/sensors/private_include/hm0360_settings.h index 39f442a301..942e9b17da 100755 --- a/sensors/private_include/hm0360_settings.h +++ b/sensors/private_include/hm0360_settings.h @@ -2,11 +2,11 @@ #include #define REG_DLY 0xffff -#define REGLIST_TAIL 0xffff +#define REGLIST_TAIL 0x0000 static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { {0x0103, 0x00}, - // 0xffff,0xc0, + {REG_DLY, 100}, {0x3035, 0x01}, {0x3126, 0x03}, {0x3128, 0x57}, @@ -38,19 +38,19 @@ static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { {0x30FB, 0x27}, {0x3100, 0x27}, {0x3105, 0x27}, - {0x30D9, 0x05}, + {0x30D9, 0x00}, // 220215 {0x30DE, 0x05}, {0x30E3, 0x05}, {0x30E8, 0x05}, {0x30ED, 0x05}, - {0x30F2, 0x05}, + {0x30F2, 0x00}, // 220215 {0x30F7, 0x05}, {0x30FC, 0x05}, {0x3101, 0x05}, {0x3106, 0x05}, {0x30C4, 0x10}, {0x30C5, 0x01}, - {0x30C6, 0xBF}, + {0x30C6, 0x2F}, // 220215 {0x30CB, 0xFF}, {0x30CC, 0xFF}, {0x30CD, 0x7F}, @@ -63,7 +63,7 @@ static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { {0x3122, 0x00}, {0x3147, 0x18}, {0x314B, 0x01}, - {0x3149, 0x18}, + {0x3149, 0x28}, {0x3150, 0x50}, {0x3152, 0x00}, {0x3156, 0x2C}, @@ -107,6 +107,8 @@ static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { {0x0350, 0xE0}, {0x101D, 0xCF}, {0x1021, 0x5D}, + + // setA VGA {0x3500, 0x74}, {0x3501, 0x0A}, {0x3502, 0x77}, @@ -156,6 +158,8 @@ static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { {0x3559, 0x30}, {0x3549, 0x04}, {0x354A, 0x35}, + + // setB QVGA {0x355A, 0x74}, {0x355B, 0x0A}, {0x355C, 0x77}, @@ -211,6 +215,8 @@ static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { {0x35B3, 0x30}, {0x35A3, 0x02}, {0x35A4, 0x03}, + + // AE_tuning {0x3512, 0x3F}, {0x351F, 0x04}, {0x3520, 0x03}, @@ -247,6 +253,8 @@ static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { {0x2057, 0x00}, {0x2058, 0x06}, {0x2059, 0xB0}, + + // MD tuning {0x2080, 0x41}, {0x2083, 0x01}, {0x208D, 0x02}, @@ -267,22 +275,26 @@ static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { {0x209C, 0x01}, {0x209D, 0x11}, {0x209E, 0x06}, - {0x1030, 0x09}, - {0x1031, 0x12}, - {0x1032, 0x23}, - {0x1033, 0x31}, - {0x1034, 0x3E}, - {0x1035, 0x4B}, - {0x1036, 0x56}, - {0x1037, 0x5E}, - {0x1038, 0x65}, - {0x1039, 0x72}, - {0x103A, 0x7F}, - {0x103B, 0x8C}, - {0x103C, 0x98}, - {0x103D, 0xB2}, - {0x103E, 0xCC}, - {0x103F, 0xE6}, + + // Tone mapping + {0x1030, 0x04}, + {0x1031, 0x08}, + {0x1032, 0x10}, + {0x1033, 0x18}, + {0x1034, 0x20}, + {0x1035, 0x28}, + {0x1036, 0x30}, + {0x1037, 0x38}, + {0x1038, 0x40}, + {0x1039, 0x50}, + {0x103A, 0x60}, + {0x103B, 0x70}, + {0x103C, 0x80}, + {0x103D, 0xA0}, + {0x103E, 0xC0}, + {0x103F, 0xE0}, + + // RESERVED {0x35B4, 0x74}, {0x35B5, 0x0A}, {0x35B6, 0x77}, @@ -320,6 +332,8 @@ static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { {0x35DF, 0x01}, {0x35FD, 0x00}, {0x35FE, 0x5E}, + + // RESERVED {0x3024, 0x00}, {0x3025, 0x12}, {0x3026, 0x03}, @@ -327,9 +341,13 @@ static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { {0x3028, 0x01}, {0x3029, 0x00}, {0x302A, 0x30}, + + // Interrupt {0x2061, 0x00}, {0x2062, 0x00}, {0x2063, 0xC8}, + + // Parallel I/F {0x1014, 0x00}, {0x102F, 0x08}, {0x309E, 0x05}, @@ -345,8 +363,12 @@ static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { {0x30A8, 0x01}, {0x30B0, 0x03}, {0x3112, 0x04}, - {0x311A, 0x30}, + {0x311A, 0x30}, //31：bypass internal ldo 30:internal LDO + + // MIPI {0x2800, 0x00}, + + // Enable BPC} {0x0370, 0x00}, {0x0371, 0x00}, {0x0372, 0x01}, @@ -354,26 +376,8 @@ static const DRAM_ATTR uint16_t sensor_default_regs[][2] = { {0x2590, 0x01}, {0x0104, 0x01}, {0x0100, 0x01}, - // 0xFFFF,0xC0, - {REGLIST_TAIL, 0x00}, // tail -}; -static const DRAM_ATTR uint16_t sensor_framesize_HD[][2] = { - {0x0006, 0x00}, - {0x000D, 0x00}, - {0x000E, 0x00}, - {0x0122, 0xFB}, - {0x0125, 0xDF}, - {0x0126, 0x70}, - {0x05E4, 0x08}, - {0x05E5, 0x00}, - {0x05E6, 0x07}, - {0x05E7, 0x05}, - {0x05E8, 0x08}, - {0x05E9, 0x00}, - {0x05EA, 0xD7}, - {0x05EB, 0x02}, - {REGLIST_TAIL, 0x00}, + {REGLIST_TAIL, 0x00}, // tail }; static const DRAM_ATTR uint16_t sensor_framesize_VGA[][2] = { @@ -398,69 +402,65 @@ static const DRAM_ATTR uint16_t sensor_framesize_VGA[][2] = { {REGLIST_TAIL, 0x00}, }; -static const DRAM_ATTR uint16_t sensor_framesize_CIF[][2] = { - {0x0006, 0x00}, - {0x000D, 0x01}, - {0x000E, 0x11}, - {0x0122, 0xFB}, - {0x0125, 0xFF}, - {0x0126, 0x72}, - {0x05E0, 0XC0}, - {0x05E1, 0x00}, - {0x05E2, 0x8F}, - {0x05E3, 0x00}, - {0x05E4, 0x11}, - {0x05E5, 0x00}, - {0x05E6, 0xA0}, - {0x05E7, 0x01}, - {0x05E8, 0x08}, - {0x05E9, 0x00}, - {0x05EA, 0x2F}, - {0x05EB, 0x01}, - {REGLIST_TAIL, 0x00}, -}; - static const DRAM_ATTR uint16_t sensor_framesize_QVGA[][2] = { - {0x0006, 0x00}, - {0x000D, 0x01}, - {0x000E, 0x11}, - {0x0122, 0xFB}, - {0x0125, 0xFF}, - {0x0126, 0x70}, - {0x05E0, 0XBE}, - {0x05E1, 0x00}, - {0x05E2, 0xBE}, - {0x05E3, 0x00}, - {0x05E4, 0x3A}, - {0x05E5, 0x00}, - {0x05E6, 0x79}, - {0x05E7, 0x01}, - {0x05E8, 0x04}, - {0x05E9, 0x00}, - {0x05EA, 0xF3}, - {0x05EB, 0x00}, - {REGLIST_TAIL, 0x00}, -}; + {0x355A, 0x74}, // vt_sys_d + {0x355B, 0x0A}, // op_sys_d + {0x355C, 0x77}, // mclk_div_d + {0x355D, 0x01}, + {0x355E, 0x1C}, + {0x355F, 0x03}, + {0x3560, 0x00}, + {0x3561, 0x01}, + {0x3562, 0x01}, + {0x3563, 0x00}, + {0x3564, 0xFF}, + {0x3565, 0x00}, + {0x3567, 0x01}, + {0x3566, 0x00}, + {0x3569, 0x00}, + {0x356A, 0x01}, + {0x356C, 0x7F}, + {0x356D, 0x00}, + {0x3576, 0x00}, + {0x3579, 0x03}, // Max Again + {0x356E, 0x00}, // AE cnt org H HB + {0x356F, 0x01}, // AE cnt org H LB + {0x3570, 0x00}, // AE cnt org V HB + {0x3571, 0x02}, // AE cnt org V LB + {0x3572, 0x00}, // AE cnt st H HB + {0x3573, 0x3F}, // AE cnt st H LB + {0x3574, 0x00}, // AE cnt st V HB + {0x3575, 0x2F}, // AE cnt st V LB + {0x3577, 0x04}, + {0x3578, 0x24}, + {0x3584, 0x01}, + {0x3585, 0x04}, + {0x3586, 0x01}, + {0x3587, 0x38}, + {0x3588, 0x02}, // FR stage 1 H + {0x3589, 0x12}, // FR stage 1 L + {0x358A, 0x04}, // FR stage 2 H + {0x358B, 0x24}, // FR stage 2 L + {0x358C, 0x06}, // FR stage 3 H + {0x358D, 0x36}, // FR stage 3 L + {0x35A5, 0x21}, // [7:1]MD_light_coef [0] MD enable + {0x35A6, 0x01}, // MD_block_num_th + {0x35A7, 0xE0}, // [7:4]md_roi_end_v [3:0]md_roi_start_v + {0x35A8, 0xF0}, // [7:4]md_roi_end_h [3:0]md_roi_start_h + {0x35A9, 0x10}, // [6:0] md_th_str_HCG + {0x35AA, 0x10}, // [5:0] md_th_str_LCG + {0x35AB, 0x10}, // [5:0] md_th_str_HDR + {0x35AC, 0x20}, // md_flick_skip_th_adj_N + {0x35AD, 0x10}, // md_flick_skip_th_adj_P + {0x35AE, 0x01}, + {0x35AF, 0x06}, + {0x35B0, 0x0C}, + {0x35B1, 0x12}, + {0x35BC, 0x1C}, + {0x35B3, 0x30}, + {0x35A3, 0x02}, // full trigger H + {0x35A4, 0x03}, // full trigger L -static const DRAM_ATTR uint16_t sensor_framesize_QCIF[][2] = { - {0x0006, 0x00}, - {0x000D, 0x01}, - {0x000E, 0x11}, - {0x0122, 0xFB}, - {0x0125, 0xFF}, - {0x0126, 0x72}, - {0x05E0, 0X52}, - {0x05E1, 0x01}, - {0x05E2, 0x38}, - {0x05E3, 0x01}, - {0x05E4, 0x22}, - {0x05E5, 0x00}, - {0x05E6, 0xD1}, - {0x05E7, 0x00}, - {0x05E8, 0x04}, - {0x05E9, 0x00}, - {0x05EA, 0x93}, - {0x05EB, 0x00}, {REGLIST_TAIL, 0x00}, }; @@ -487,23 +487,63 @@ static const DRAM_ATTR uint16_t sensor_framesize_240X240[][2] = { }; static const DRAM_ATTR uint16_t sensor_framesize_QQVGA[][2] = { - {0x0006, 0x00}, - {0x000D, 0x01}, - {0x000E, 0x11}, - {0x0122, 0xFB}, - {0x0125, 0xFF}, - {0x0126, 0x70}, - {0x05E0, 0X78}, - {0x05E1, 0x01}, - {0x05E2, 0x78}, - {0x05E3, 0x01}, - {0x05E4, 0x1E}, - {0x05E5, 0x00}, - {0x05E6, 0xBD}, - {0x05E7, 0x00}, - {0x05E8, 0x03}, - {0x05E9, 0x00}, - {0x05EA, 0x7A}, - {0x05EB, 0x00}, + {0x355A, 0x74}, // vt_sys_d + {0x355B, 0x0A}, // op_sys_d + {0x355C, 0x77}, // mclk_div_d + {0x355D, 0x00}, + {0x355E, 0x8E}, + {0x355F, 0x03}, + {0x3560, 0x00}, + {0x3561, 0x02}, + {0x3562, 0x02}, + {0x3563, 0x00}, + {0x3564, 0xFF}, + {0x3565, 0x00}, + {0x3567, 0x01}, + {0x3566, 0x00}, + {0x3569, 0x00}, + {0x356A, 0x01}, + {0x356C, 0x7F}, + {0x356D, 0x00}, + {0x3576, 0x00}, + {0x3579, 0x03}, // Max Again + {0x356E, 0x00}, // AE cnt org H HB + {0x356F, 0x01}, // AE cnt org H LB + {0x3570, 0x00}, // AE cnt org V HB + {0x3571, 0x02}, // AE cnt org V LB + {0x3572, 0x00}, // AE cnt st H HB + {0x3573, 0x1F}, // AE cnt st H LB + {0x3574, 0x00}, // AE cnt st V HB + {0x3575, 0x17}, // AE cnt st V LB + {0x3577, 0x04}, + {0x3578, 0x24}, + {0x3584, 0x01}, + {0x3585, 0x04}, + {0x3586, 0x01}, + {0x3587, 0x38}, + {0x3588, 0x02}, // FR stage 1 H + {0x3589, 0x12}, // FR stage 1 L + {0x358A, 0x04}, // FR stage 2 H + {0x358B, 0x24}, // FR stage 2 L + {0x358C, 0x06}, // FR stage 3 H + {0x358D, 0x36}, // FR stage 3 L + {0x35A5, 0x21}, // [7:1]MD_light_coef [0] MD enable + {0x35A6, 0x01}, // MD_block_num_th + {0x35A7, 0xD0}, // [7:4]md_roi_end_v [3:0]md_roi_start_v + {0x35A8, 0xF0}, // [7:4]md_roi_end_h [3:0]md_roi_start_h + {0x35A9, 0x10}, // [6:0] md_th_str_HCG + {0x35AA, 0x10}, // [5:0] md_th_str_LCG + {0x35AB, 0x10}, // [5:0] md_th_str_HDR + {0x35AC, 0x20}, // md_flick_skip_th_adj_N + {0x35AD, 0x10}, // md_flick_skip_th_adj_P + {0x35AE, 0x01}, + {0x35AF, 0x06}, + {0x35B0, 0x0C}, + {0x35B1, 0x12}, + {0x35B2, 0x1C}, + {0x35B3, 0x30}, + {0x35A3, 0x00}, // full trigger H + {0x35A4, 0xEA}, // full trigger L + {REGLIST_TAIL, 0x00}, -}; \ No newline at end of file +}; From 69b4ee41ef77013a7b8f69139d26b8275348b1e4 Mon Sep 17 00:00:00 2001 From: Lesords <2385342343@qq.com> Date: Wed, 4 Dec 2024 14:42:19 +0800 Subject: [PATCH 4/5] style: update code format --- sensors/hm0360.c | 167 +++++++++++++++++------------------------------ 1 file changed, 61 insertions(+), 106 deletions(-) diff --git a/sensors/hm0360.c b/sensors/hm0360.c index 1c96022e3e..a3acea47f8 100755 --- a/sensors/hm0360.c +++ b/sensors/hm0360.c @@ -29,8 +29,7 @@ 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) - { + if (ret < 0) { ESP_LOGE(TAG, "READ REG 0x%04x FAILED: %d", reg, ret); } #endif @@ -45,20 +44,18 @@ static int check_reg_mask(uint8_t slv_addr, uint16_t reg, uint8_t mask) static int read_reg16(uint8_t slv_addr, const uint16_t reg) { int ret = 0, ret2 = 0; + ret = read_reg(slv_addr, reg); - if (ret >= 0) - { + if (ret >= 0) { ret = (ret & 0xFF) << 8; ret2 = read_reg(slv_addr, reg + 1); - if (ret2 < 0) - { + if (ret2 < 0) { ret = ret2; - } - else - { + } else { ret |= ret2 & 0xFF; } } + return ret; } @@ -69,22 +66,18 @@ static int write_reg(uint8_t slv_addr, const uint16_t reg, uint8_t value) ret = SCCB_Write16(slv_addr, reg, value); #else int old_value = read_reg(slv_addr, reg); - if (old_value < 0) - { + if (old_value < 0) { return old_value; } - if ((uint8_t)old_value != value) - { + + if ((uint8_t)old_value != value) { ESP_LOGD(TAG, "NEW REG 0x%04x: 0x%02x to 0x%02x", reg, (uint8_t)old_value, value); ret = SCCB_Write16(slv_addr, reg, value); - } - else - { + } else { ESP_LOGD(TAG, "OLD REG 0x%04x: 0x%02x", reg, (uint8_t)old_value); ret = SCCB_Write16(slv_addr, reg, value); // maybe not? } - if (ret < 0) - { + if (ret < 0) { ESP_LOGE(TAG, "WRITE REG 0x%04x FAILED: %d", reg, ret); } #endif @@ -95,11 +88,12 @@ static int set_reg_bits(uint8_t slv_addr, uint16_t reg, uint8_t offset, uint8_t { int ret = 0; uint8_t c_value, new_value; + ret = read_reg(slv_addr, reg); - if (ret < 0) - { + if (ret < 0) { return ret; } + c_value = ret; new_value = (c_value & ~(mask << offset)) | ((value & mask) << offset); ret = write_reg(slv_addr, reg, new_value); @@ -109,25 +103,22 @@ static int set_reg_bits(uint8_t slv_addr, uint16_t reg, uint8_t offset, uint8_t static int write_regs(uint8_t slv_addr, const uint16_t (*regs)[2]) { int i = 0, ret = 0; - while (!ret && regs[i][0] != REGLIST_TAIL) - { - if (regs[i][0] == REG_DLY) - { + + while (!ret && regs[i][0] != REGLIST_TAIL) { + if (regs[i][0] == REG_DLY) { vTaskDelay(regs[i][1] / portTICK_PERIOD_MS); - } - else - { + } else { ret = write_reg(slv_addr, regs[i][0], regs[i][1]); } i++; } + return ret; } static int write_reg16(uint8_t slv_addr, const uint16_t reg, uint16_t value) { - if (write_reg(slv_addr, reg, value >> 8) || write_reg(slv_addr, reg + 1, value)) - { + if (write_reg(slv_addr, reg, value >> 8) || write_reg(slv_addr, reg + 1, value)) { return -1; } return 0; @@ -135,8 +126,7 @@ static int write_reg16(uint8_t slv_addr, const uint16_t reg, uint16_t value) static int write_addr_reg(uint8_t slv_addr, const uint16_t reg, uint16_t x_value, uint16_t y_value) { - if (write_reg16(slv_addr, reg, x_value) || write_reg16(slv_addr, reg + 2, y_value)) - { + if (write_reg16(slv_addr, reg, x_value) || write_reg16(slv_addr, reg + 2, y_value)) { return -1; } return 0; @@ -148,20 +138,21 @@ static int reset(sensor_t *sensor) { vTaskDelay(100 / portTICK_PERIOD_MS); int ret = 0; + // Software Reset: clear all registers and reset them to their default values ret = write_reg(sensor->slv_addr, SW_RESET, 0x00); - if (ret) - { + if (ret) { ESP_LOGE(TAG, "Software Reset FAILED!"); return ret; } + vTaskDelay(100 / portTICK_PERIOD_MS); ret = write_regs(sensor->slv_addr, sensor_default_regs); - if (ret == 0) - { + if (ret == 0) { ESP_LOGD(TAG, "Camera defaults loaded"); vTaskDelay(100 / portTICK_PERIOD_MS); } + return ret; } @@ -188,31 +179,23 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize) sensor->status.framesize = framesize; ret = write_regs(sensor->slv_addr, sensor_default_regs); - if (framesize == FRAMESIZE_QQVGA) - { + if (framesize == FRAMESIZE_QQVGA) { ESP_LOGI(TAG, "Set FRAMESIZE_QQVGA"); ret |= write_regs(sensor->slv_addr, sensor_framesize_QQVGA); ret |= set_reg_bits(sensor->slv_addr, 0x3024, 0, 0x01, 1); - } - else if (framesize == FRAMESIZE_QVGA) - { + } else if (framesize == FRAMESIZE_QVGA) { ESP_LOGI(TAG, "Set FRAMESIZE_QVGA"); ret |= write_regs(sensor->slv_addr, sensor_framesize_QVGA); ret |= set_reg_bits(sensor->slv_addr, 0x3024, 0, 0x01, 1); - } - else if (framesize == FRAMESIZE_VGA) - { + } else if (framesize == FRAMESIZE_VGA) { ESP_LOGI(TAG, "Set FRAMESIZE_VGA"); ret |= set_reg_bits(sensor->slv_addr, 0x3024, 0, 0x01, 0); - } - else - { + } else { ESP_LOGI(TAG, "Dont suppost this size, Set FRAMESIZE_VGA"); ret |= set_reg_bits(sensor->slv_addr, 0x3024, 0, 0x01, 0); } - if (ret == 0) - { + if (ret == 0) { _set_pll(sensor, 0, 0, 0, 0, 0, 0, 0, 0); ret |= write_reg(sensor->slv_addr, 0x0104, 0x01); } @@ -291,28 +274,22 @@ static int set_brightness(sensor_t *sensor, int level) static int get_reg(sensor_t *sensor, int reg, int mask) { int ret = 0, ret2 = 0; - if (mask > 0xFF) - { + + if (mask > 0xFF) { ret = read_reg16(sensor->slv_addr, reg); - if (ret >= 0 && mask > 0xFFFF) - { + if (ret >= 0 && mask > 0xFFFF) { ret2 = read_reg(sensor->slv_addr, reg + 2); - if (ret2 >= 0) - { + if (ret2 >= 0) { ret = (ret << 8) | ret2; - } - else - { + } else { ret = ret2; } } - } - else - { + } else { ret = read_reg(sensor->slv_addr, reg); } - if (ret > 0) - { + + if (ret > 0) { ret &= mask; } return ret; @@ -321,47 +298,37 @@ static int get_reg(sensor_t *sensor, int reg, int mask) static int set_reg(sensor_t *sensor, int reg, int mask, int value) { int ret = 0, ret2 = 0; - if (mask > 0xFF) - { + + if (mask > 0xFF) { ret = read_reg16(sensor->slv_addr, reg); - if (ret >= 0 && mask > 0xFFFF) - { + if (ret >= 0 && mask > 0xFFFF) { ret2 = read_reg(sensor->slv_addr, reg + 2); - if (ret2 >= 0) - { + if (ret2 >= 0) { ret = (ret << 8) | ret2; - } - else - { + } else { ret = ret2; } } - } - else - { + } else { ret = read_reg(sensor->slv_addr, reg); } - if (ret < 0) - { + + if (ret < 0) { return ret; } + value = (ret & ~mask) | (value & mask); - if (mask > 0xFFFF) - { + if (mask > 0xFFFF) { ret = write_reg16(sensor->slv_addr, reg, value >> 8); - if (ret >= 0) - { + if (ret >= 0) { ret = write_reg(sensor->slv_addr, reg + 2, value & 0xFF); } - } - else if (mask > 0xFF) - { + } else if (mask > 0xFF) { ret = write_reg16(sensor->slv_addr, reg, value); - } - else - { + } else { ret = write_reg(sensor->slv_addr, reg, value); } + return ret; } @@ -370,8 +337,7 @@ 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); - if (ret == 0) - { + if (ret == 0) { ESP_LOGD(TAG, "Set xclk to %d", xclk); } return ret; @@ -382,20 +348,13 @@ static int _set_pll(sensor_t *sensor, int bypass, int multiplier, int sys_div, i uint8_t value = 0; uint8_t pll_cfg = 0; - if (sensor->xclk_freq_hz <= 6000000) - { + if (sensor->xclk_freq_hz <= 6000000) { value = 0x03; - } - else if (sensor->xclk_freq_hz <= 12000000) - { + } else if (sensor->xclk_freq_hz <= 12000000) { value = 0x02; - } - else if (sensor->xclk_freq_hz <= 18000000) - { + } else if (sensor->xclk_freq_hz <= 18000000) { value = 0x01; - } - else - { // max is 48000000 + } else { // max is 48000000 value = 0x00; } @@ -416,19 +375,15 @@ static int init_status(sensor_t *sensor) int hm0360_detect(int slv_addr, sensor_id_t *id) { - if (HM1055_SCCB_ADDR == slv_addr) - { + if (HM1055_SCCB_ADDR == slv_addr) { uint8_t h = SCCB_Read16(slv_addr, MODEL_ID_H); uint8_t l = SCCB_Read16(slv_addr, MODEL_ID_L); uint16_t PID = (h << 8) | l; - if (HM0360_PID == PID) - { + if (HM0360_PID == PID) { id->PID = PID; id->VER = SCCB_Read16(slv_addr, SILICON_REV); return PID; - } - else - { + } else { ESP_LOGD(TAG, "Mismatch PID=0x%x", PID); } } From f963c96fa5b9734773c052b2c0207a5a139f6ea3 Mon Sep 17 00:00:00 2001 From: Lesords <2385342343@qq.com> Date: Wed, 4 Dec 2024 15:43:40 +0800 Subject: [PATCH 5/5] docs: update sensor information for hm0360 and hm1055 --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 092f893f8a..def7aa1fff 100644 --- a/README.md +++ b/README.md @@ -29,6 +29,8 @@ This repository hosts ESP32 series Soc compatible driver for image sensors. Addi | SC101IOT| 1280 x 720 | color | YUV/YCbCr422
Raw RGB | 1/4.2" | | SC030IOT| 640 x 480 | color | YUV/YCbCr422
RAW Bayer | 1/6.5" | | SC031GS | 640 x 480 | monochrome | RAW MONO
Grayscale | 1/6" | +| HM0360 | 656 x 496 | monochrome | RAW MONO
Grayscale | 1/6" | +| HM1055 | 1280 x 720 | color | 8/10-bit Raw
YUV/YCbCr422
RGB565/555/444 | 1/6" | ## Important to Remember