Merge pull request #786 from openmv/cambus_fix

Make cambus functions accept I2C handle.
This commit is contained in:
Ibrahim Abd Elkader 2020-05-08 22:13:19 +02:00 committed by GitHub
commit 8b7d4b2122
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 605 additions and 599 deletions

View File

@ -71,7 +71,9 @@
#include "LEPTON_Types.h"
#include "LEPTON_ErrorCodes.h"
#include "LEPTON_I2C_Service.h"
#include "sensor.h"
#include "cambus.h"
extern sensor_t sensor;
/******************************************************************************/
/** LOCAL DEFINES **/
@ -163,7 +165,7 @@ LEP_RESULT LEP_I2C_MasterReadData(LEP_UINT16 portID,
LEP_RESULT result = LEP_OK;
for (int i = 0; i < dataLength; i++) {
if (cambus_readw2(deviceAddress << 1, subAddress + (i * 2), &dataPtr[i])) return LEP_ERROR;
if (cambus_readw2(&sensor.i2c, deviceAddress << 1, subAddress + (i * 2), &dataPtr[i])) return LEP_ERROR;
}
return(result);
@ -191,7 +193,7 @@ LEP_RESULT LEP_I2C_MasterWriteData(LEP_UINT16 portID,
LEP_RESULT result = LEP_OK;
for (int i = 0; i < dataLength; i++) {
if (cambus_writew2(deviceAddress << 1, subAddress + (i * 2), dataPtr[i])) return LEP_ERROR;
if (cambus_writew2(&sensor.i2c, deviceAddress << 1, subAddress + (i * 2), dataPtr[i])) return LEP_ERROR;
}
return(result);
@ -205,7 +207,7 @@ LEP_RESULT LEP_I2C_MasterReadRegister(LEP_UINT16 portID,
{
LEP_RESULT result = LEP_OK;
if (cambus_readw2(deviceAddress << 1, regAddress, regValue)) return LEP_ERROR;
if (cambus_readw2(&sensor.i2c, deviceAddress << 1, regAddress, regValue)) return LEP_ERROR;
return(result);
}
@ -218,7 +220,7 @@ LEP_RESULT LEP_I2C_MasterWriteRegister(LEP_UINT16 portID,
{
LEP_RESULT result = LEP_OK;
if (cambus_writew2(deviceAddress << 1, regAddress, regValue)) return LEP_ERROR;
if (cambus_writew2(&sensor.i2c, deviceAddress << 1, regAddress, regValue)) return LEP_ERROR;
return(result);
}

View File

@ -107,6 +107,7 @@
#define SCCB_PORT (GPIOB)
#define SCCB_SCL_PIN (GPIO_PIN_8)
#define SCCB_SDA_PIN (GPIO_PIN_9)
#define SCCB_TIMING (0) // ignored
/* DCMI */
#define DCMI_TIM (TIM1)

View File

@ -17,37 +17,35 @@
#define I2C_FREQUENCY (100000)
#define I2C_TIMEOUT (1000)
static I2C_HandleTypeDef I2CHandle;
int cambus_init()
int cambus_init(I2C_HandleTypeDef *i2c, I2C_TypeDef *instance, uint32_t timing)
{
/* Configure I2C */
I2CHandle.Instance = SCCB_I2C;
I2CHandle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
#if defined(SCCB_TIMING)
I2CHandle.Init.Timing = SCCB_TIMING;
i2c->Instance = instance;
i2c->Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
#if !defined(STM32F4)
i2c->Init.Timing = timing;
#else
I2CHandle.Init.ClockSpeed = I2C_FREQUENCY;
I2CHandle.Init.DutyCycle = I2C_DUTYCYCLE_2;
i2c->Init.ClockSpeed = I2C_FREQUENCY;
i2c->Init.DutyCycle = I2C_DUTYCYCLE_2;
#endif
I2CHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
I2CHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
I2CHandle.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
I2CHandle.Init.OwnAddress1 = 0xFE;
I2CHandle.Init.OwnAddress2 = 0xFE;
i2c->Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
i2c->Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
i2c->Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
i2c->Init.OwnAddress1 = 0xFE;
i2c->Init.OwnAddress2 = 0xFE;
if (HAL_I2C_Init(&I2CHandle) != HAL_OK) {
if (HAL_I2C_Init(i2c) != HAL_OK) {
/* Initialization Error */
return -1;
}
return 0;
}
int cambus_scan()
int cambus_scan(I2C_HandleTypeDef *i2c)
{
for (uint8_t addr=0x09; addr<=0x77; addr++) {
__disable_irq();
if (HAL_I2C_IsDeviceReady(&I2CHandle, addr << 1, 10, I2C_TIMEOUT) == HAL_OK) {
if (HAL_I2C_IsDeviceReady(i2c, addr << 1, 10, I2C_TIMEOUT) == HAL_OK) {
__enable_irq();
return (addr << 1);
}
@ -57,37 +55,37 @@ int cambus_scan()
return 0;
}
int cambus_readb(uint8_t slv_addr, uint8_t reg_addr, uint8_t *reg_data)
int cambus_readb(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint8_t reg_addr, uint8_t *reg_data)
{
int ret = 0;
__disable_irq();
if((HAL_I2C_Master_Transmit(&I2CHandle, slv_addr, &reg_addr, 1, I2C_TIMEOUT) != HAL_OK)
|| (HAL_I2C_Master_Receive(&I2CHandle, slv_addr, reg_data, 1, I2C_TIMEOUT) != HAL_OK)) {
if((HAL_I2C_Master_Transmit(i2c, slv_addr, &reg_addr, 1, I2C_TIMEOUT) != HAL_OK)
|| (HAL_I2C_Master_Receive (i2c, slv_addr, reg_data, 1, I2C_TIMEOUT) != HAL_OK)) {
ret = -1;
}
__enable_irq();
return ret;
}
int cambus_writeb(uint8_t slv_addr, uint8_t reg_addr, uint8_t reg_data)
int cambus_writeb(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint8_t reg_addr, uint8_t reg_data)
{
int ret=0;
uint8_t buf[] = {reg_addr, reg_data};
__disable_irq();
if(HAL_I2C_Master_Transmit(&I2CHandle, slv_addr, buf, 2, I2C_TIMEOUT) != HAL_OK) {
if(HAL_I2C_Master_Transmit(i2c, slv_addr, buf, 2, I2C_TIMEOUT) != HAL_OK) {
ret = -1;
}
__enable_irq();
return ret;
}
int cambus_readb2(uint8_t slv_addr, uint16_t reg_addr, uint8_t *reg_data)
int cambus_readb2(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint16_t reg_addr, uint8_t *reg_data)
{
int ret=0;
__disable_irq();
if (HAL_I2C_Mem_Read(&I2CHandle, slv_addr, reg_addr,
if (HAL_I2C_Mem_Read(i2c, slv_addr, reg_addr,
I2C_MEMADD_SIZE_16BIT, reg_data, 1, I2C_TIMEOUT) != HAL_OK) {
ret = -1;
}
@ -95,11 +93,11 @@ int cambus_readb2(uint8_t slv_addr, uint16_t reg_addr, uint8_t *reg_data)
return ret;
}
int cambus_writeb2(uint8_t slv_addr, uint16_t reg_addr, uint8_t reg_data)
int cambus_writeb2(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint16_t reg_addr, uint8_t reg_data)
{
int ret=0;
__disable_irq();
if (HAL_I2C_Mem_Write(&I2CHandle, slv_addr, reg_addr,
if (HAL_I2C_Mem_Write(i2c, slv_addr, reg_addr,
I2C_MEMADD_SIZE_16BIT, &reg_data, 1, I2C_TIMEOUT) != HAL_OK) {
ret = -1;
}
@ -107,11 +105,11 @@ int cambus_writeb2(uint8_t slv_addr, uint16_t reg_addr, uint8_t reg_data)
return ret;
}
int cambus_readw(uint8_t slv_addr, uint8_t reg_addr, uint16_t *reg_data)
int cambus_readw(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint8_t reg_addr, uint16_t *reg_data)
{
int ret=0;
__disable_irq();
if (HAL_I2C_Mem_Read(&I2CHandle, slv_addr, reg_addr,
if (HAL_I2C_Mem_Read(i2c, slv_addr, reg_addr,
I2C_MEMADD_SIZE_8BIT, (uint8_t*) reg_data, 2, I2C_TIMEOUT) != HAL_OK) {
ret = -1;
}
@ -120,12 +118,12 @@ int cambus_readw(uint8_t slv_addr, uint8_t reg_addr, uint16_t *reg_data)
return ret;
}
int cambus_writew(uint8_t slv_addr, uint8_t reg_addr, uint16_t reg_data)
int cambus_writew(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint8_t reg_addr, uint16_t reg_data)
{
int ret=0;
reg_data = (reg_data >> 8) | (reg_data << 8);
__disable_irq();
if (HAL_I2C_Mem_Write(&I2CHandle, slv_addr, reg_addr,
if (HAL_I2C_Mem_Write(i2c, slv_addr, reg_addr,
I2C_MEMADD_SIZE_8BIT, (uint8_t*) &reg_data, 2, I2C_TIMEOUT) != HAL_OK) {
ret = -1;
}
@ -133,11 +131,11 @@ int cambus_writew(uint8_t slv_addr, uint8_t reg_addr, uint16_t reg_data)
return ret;
}
int cambus_readw2(uint8_t slv_addr, uint16_t reg_addr, uint16_t *reg_data)
int cambus_readw2(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint16_t reg_addr, uint16_t *reg_data)
{
int ret=0;
__disable_irq();
if (HAL_I2C_Mem_Read(&I2CHandle, slv_addr, reg_addr,
if (HAL_I2C_Mem_Read(i2c, slv_addr, reg_addr,
I2C_MEMADD_SIZE_16BIT, (uint8_t*) reg_data, 2, I2C_TIMEOUT) != HAL_OK) {
ret = -1;
}
@ -146,12 +144,12 @@ int cambus_readw2(uint8_t slv_addr, uint16_t reg_addr, uint16_t *reg_data)
return ret;
}
int cambus_writew2(uint8_t slv_addr, uint16_t reg_addr, uint16_t reg_data)
int cambus_writew2(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint16_t reg_addr, uint16_t reg_data)
{
int ret=0;
reg_data = (reg_data >> 8) | (reg_data << 8);
__disable_irq();
if (HAL_I2C_Mem_Write(&I2CHandle, slv_addr, reg_addr,
if (HAL_I2C_Mem_Write(i2c, slv_addr, reg_addr,
I2C_MEMADD_SIZE_16BIT, (uint8_t*) &reg_data, 2, I2C_TIMEOUT) != HAL_OK) {
ret = -1;
}

View File

@ -11,14 +11,17 @@
#ifndef __CAMBUS_H__
#define __CAMBUS_H__
#include <stdint.h>
int cambus_init();
int cambus_scan();
int cambus_readb(uint8_t slv_addr, uint8_t reg_addr, uint8_t *reg_data);
int cambus_writeb(uint8_t slv_addr, uint8_t reg_addr, uint8_t reg_data);
int cambus_readb2(uint8_t slv_addr, uint16_t reg_addr, uint8_t *reg_data);
int cambus_writeb2(uint8_t slv_addr, uint16_t reg_addr, uint8_t reg_data);
int cambus_readw(uint8_t slv_addr, uint8_t reg_addr, uint16_t *reg_data);
int cambus_writew(uint8_t slv_addr, uint8_t reg_addr, uint16_t reg_data);
int cambus_readw2(uint8_t slv_addr, uint16_t reg_addr, uint16_t *reg_data);
int cambus_writew2(uint8_t slv_addr, uint16_t reg_addr, uint16_t reg_data);
#include STM32_HAL_H
int cambus_init(I2C_HandleTypeDef *i2c, I2C_TypeDef *instance, uint32_t timing);
int cambus_deinit(I2C_HandleTypeDef *i2c);
int cambus_scan(I2C_HandleTypeDef *i2c);
int cambus_readb(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint8_t reg_addr, uint8_t *reg_data);
int cambus_writeb(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint8_t reg_addr, uint8_t reg_data);
int cambus_readb2(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint16_t reg_addr, uint8_t *reg_data);
int cambus_writeb2(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint16_t reg_addr, uint8_t reg_data);
int cambus_readw(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint8_t reg_addr, uint16_t *reg_data);
int cambus_writew(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint8_t reg_addr, uint16_t reg_data);
int cambus_readw2(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint16_t reg_addr, uint16_t *reg_data);
int cambus_writew2(I2C_HandleTypeDef *i2c, uint8_t slv_addr, uint16_t reg_addr, uint16_t reg_data);
#endif // __CAMBUS_H__

View File

@ -119,12 +119,12 @@ static int reset(sensor_t *sensor)
if (retry == 0) {
return -1;
}
if (cambus_writeb2(sensor->slv_addr, SW_RESET, HIMAX_RESET) != 0) {
if (cambus_writeb2(&sensor->i2c, sensor->slv_addr, SW_RESET, HIMAX_RESET) != 0) {
return -1;
}
// Delay for 1ms.
systick_sleep(1);
if (cambus_readb2(sensor->slv_addr, MODE_SELECT, &reg) != 0) {
if (cambus_readb2(&sensor->i2c, sensor->slv_addr, MODE_SELECT, &reg) != 0) {
return -1;
}
}
@ -132,14 +132,14 @@ static int reset(sensor_t *sensor)
// Write default regsiters
int ret = 0;
for (int i=0; default_regs[i][0] && ret == 0; i++) {
ret |= cambus_writeb2(sensor->slv_addr, default_regs[i][0], default_regs[i][1]);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, default_regs[i][0], default_regs[i][1]);
}
// Set PCLK polarity.
ret |= cambus_writeb2(sensor->slv_addr, PCLK_POLARITY, (0x20 | PCLK_FALLING_EDGE));
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, PCLK_POLARITY, (0x20 | PCLK_FALLING_EDGE));
// Set mode to streaming
ret |= cambus_writeb2(sensor->slv_addr, MODE_SELECT, HIMAX_MODE_STREAMING);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, MODE_SELECT, HIMAX_MODE_STREAMING);
return ret;
}
@ -147,7 +147,7 @@ static int reset(sensor_t *sensor)
static int read_reg(sensor_t *sensor, uint16_t reg_addr)
{
uint8_t reg_data;
if (cambus_readb2(sensor->slv_addr, reg_addr, &reg_data) != 0) {
if (cambus_readb2(&sensor->i2c, sensor->slv_addr, reg_addr, &reg_data) != 0) {
return -1;
}
return reg_data;
@ -155,7 +155,7 @@ static int read_reg(sensor_t *sensor, uint16_t reg_addr)
static int write_reg(sensor_t *sensor, uint16_t reg_addr, uint16_t reg_data)
{
return cambus_writeb2(sensor->slv_addr, reg_addr, reg_data);
return cambus_writeb2(&sensor->i2c, sensor->slv_addr, reg_addr, reg_data);
}
static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
@ -185,16 +185,16 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize)
static int set_hmirror(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb2(sensor->slv_addr, IMG_ORIENTATION, &reg);
ret |= cambus_writeb2(sensor->slv_addr, IMG_ORIENTATION, HIMAX_SET_HMIRROR(reg, enable)) ;
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, IMG_ORIENTATION, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, IMG_ORIENTATION, HIMAX_SET_HMIRROR(reg, enable)) ;
return ret;
}
static int set_vflip(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb2(sensor->slv_addr, IMG_ORIENTATION, &reg);
ret |= cambus_writeb2(sensor->slv_addr, IMG_ORIENTATION, HIMAX_SET_VMIRROR(reg, enable)) ;
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, IMG_ORIENTATION, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, IMG_ORIENTATION, HIMAX_SET_VMIRROR(reg, enable)) ;
return ret;
}

View File

@ -119,7 +119,7 @@ static int sleep(sensor_t *sensor, int enable)
static int read_reg(sensor_t *sensor, uint16_t reg_addr)
{
uint16_t reg_data;
if (cambus_readw2(sensor->slv_addr, reg_addr, &reg_data)) {
if (cambus_readw2(&sensor->i2c, sensor->slv_addr, reg_addr, &reg_data)) {
return -1;
}
return reg_data;
@ -127,7 +127,7 @@ static int read_reg(sensor_t *sensor, uint16_t reg_addr)
static int write_reg(sensor_t *sensor, uint16_t reg_addr, uint16_t reg_data)
{
return cambus_writew2(sensor->slv_addr, reg_addr, reg_data);
return cambus_writew2(&sensor->i2c, sensor->slv_addr, reg_addr, reg_data);
}
static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)

View File

@ -126,12 +126,12 @@ static int reset(sensor_t *sensor)
int ret = 0;
uint16_t chip_control;
ret |= cambus_readw(sensor->slv_addr, MT9V034_CHIP_CONTROL, &chip_control);
ret |= cambus_writew(sensor->slv_addr, MT9V034_CHIP_CONTROL, (chip_control & (~MT9V034_CHIP_CONTROL_RESERVED)));
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_CHIP_CONTROL, &chip_control);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_CHIP_CONTROL, (chip_control & (~MT9V034_CHIP_CONTROL_RESERVED)));
uint16_t read_mode;
ret |= cambus_readw(sensor->slv_addr, MT9V034_READ_MODE, &read_mode);
ret |= cambus_writew(sensor->slv_addr, MT9V034_READ_MODE, read_mode | MT9V034_READ_MODE_ROW_FLIP | MT9V034_READ_MODE_COL_FLIP);
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_READ_MODE, &read_mode);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_READ_MODE, read_mode | MT9V034_READ_MODE_ROW_FLIP | MT9V034_READ_MODE_COL_FLIP);
return ret;
}
@ -153,7 +153,7 @@ static int read_reg(sensor_t *sensor, uint16_t reg_addr)
{
uint16_t reg_data;
if (cambus_readw(sensor->slv_addr, reg_addr, &reg_data) != 0) {
if (cambus_readw(&sensor->i2c, sensor->slv_addr, reg_addr, &reg_data) != 0) {
return -1;
}
@ -162,7 +162,7 @@ static int read_reg(sensor_t *sensor, uint16_t reg_addr)
static int write_reg(sensor_t *sensor, uint16_t reg_addr, uint16_t reg_data)
{
return cambus_writew(sensor->slv_addr, reg_addr, reg_data);
return cambus_writew(&sensor->i2c, sensor->slv_addr, reg_addr, reg_data);
}
static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
@ -184,7 +184,7 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize)
uint16_t read_mode;
if (cambus_readw(sensor->slv_addr, MT9V034_READ_MODE, &read_mode) != 0) {
if (cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_READ_MODE, &read_mode) != 0) {
return -1;
}
@ -201,12 +201,12 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize)
int ret = 0;
ret |= cambus_writew(sensor->slv_addr, MT9V034_COL_START,
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_COL_START,
((MT9V034_MAX_WIDTH - (width * read_mode_mul)) / 2) + MT9V034_COL_START_MIN);
ret |= cambus_writew(sensor->slv_addr, MT9V034_ROW_START,
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_ROW_START,
((MT9V034_MAX_HEIGHT - (height * read_mode_mul)) / 2) + MT9V034_ROW_START_MIN);
ret |= cambus_writew(sensor->slv_addr, MT9V034_WINDOW_WIDTH, width * read_mode_mul);
ret |= cambus_writew(sensor->slv_addr, MT9V034_WINDOW_HEIGHT, height * read_mode_mul);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_WINDOW_WIDTH, width * read_mode_mul);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_WINDOW_HEIGHT, height * read_mode_mul);
// Notes: 1. The MT9V034 uses column parallel analog-digital converters, thus short row timing is not possible.
// The minimum total row time is 690 columns (horizontal width + horizontal blanking). The minimum
@ -214,14 +214,14 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize)
// must be increased.
//
// The STM32H7 needs more than 94+(752-640) clocks between rows otherwise it can't keep up with the pixel rate.
ret |= cambus_writew(sensor->slv_addr, MT9V034_HORIZONTAL_BLANKING,
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_HORIZONTAL_BLANKING,
MT9V034_HORIZONTAL_BLANKING_DEF + (MT9V034_MAX_WIDTH - IM_MIN(width * read_mode_mul, 640)));
ret |= cambus_writew(sensor->slv_addr, MT9V034_READ_MODE, read_mode);
ret |= cambus_writew(sensor->slv_addr, MT9V034_PIXEL_COUNT, (width * height) / 8);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_READ_MODE, read_mode);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_PIXEL_COUNT, (width * height) / 8);
// We need more setup time for the pixel_clk at the full data rate...
ret |= cambus_writew(sensor->slv_addr, MT9V034_PIXEL_CLOCK, (read_mode_mul == 1) ? MT9V034_PIXEL_CLOCK_INV_PXL_CLK : 0);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_PIXEL_CLOCK, (read_mode_mul == 1) ? MT9V034_PIXEL_CLOCK_INV_PXL_CLK : 0);
return ret;
}
@ -254,8 +254,8 @@ static int set_quality(sensor_t *sensor, int quality)
static int set_colorbar(sensor_t *sensor, int enable)
{
uint16_t test;
int ret = cambus_readw(sensor->slv_addr, MT9V034_TEST_PATTERN, &test);
ret |= cambus_writew(sensor->slv_addr, MT9V034_TEST_PATTERN,
int ret = cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_TEST_PATTERN, &test);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_TEST_PATTERN,
(test & (~(MT9V034_TEST_PATTERN_ENABLE | MT9V034_TEST_PATTERN_GRAY_MASK)))
| ((enable != 0) ? (MT9V034_TEST_PATTERN_ENABLE | MT9V034_TEST_PATTERN_GRAY_VERTICAL) : 0));
ret |= sensor->snapshot(sensor, NULL, NULL); // Force shadow mode register to update...
@ -270,21 +270,21 @@ static int set_special_effect(sensor_t *sensor, sde_t sde)
static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain_db_ceiling)
{
uint16_t reg;
int ret = cambus_readw(sensor->slv_addr, MT9V034_AEC_AGC_ENABLE, &reg);
ret |= cambus_writew(sensor->slv_addr, MT9V034_AEC_AGC_ENABLE,
int ret = cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_AEC_AGC_ENABLE, &reg);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_AEC_AGC_ENABLE,
(reg & (~MT9V034_AGC_ENABLE)) | ((enable != 0) ? MT9V034_AGC_ENABLE : 0));
ret |= sensor->snapshot(sensor, NULL, NULL); // Force shadow mode register to update...
if ((enable == 0) && (!isnanf(gain_db)) && (!isinff(gain_db))) {
int gain = IM_MAX(IM_MIN(fast_roundf(fast_expf((gain_db / 20.0) * fast_log(10.0)) * 16.0), 127), 0);
ret |= cambus_readw(sensor->slv_addr, MT9V034_ANALOG_GAIN, &reg);
ret |= cambus_writew(sensor->slv_addr, MT9V034_ANALOG_GAIN, (reg & 0xFF80) | gain);
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_ANALOG_GAIN, &reg);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_ANALOG_GAIN, (reg & 0xFF80) | gain);
} else if ((enable != 0) && (!isnanf(gain_db_ceiling)) && (!isinff(gain_db_ceiling))) {
int gain_ceiling = IM_MAX(IM_MIN(fast_roundf(fast_expf((gain_db_ceiling / 20.0) * fast_log(10.0)) * 16.0), 127), 16);
ret |= cambus_readw(sensor->slv_addr, MT9V034_MAX_GAIN, &reg);
ret |= cambus_writew(sensor->slv_addr, MT9V034_MAX_GAIN, (reg & 0xFF80) | gain_ceiling);
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_MAX_GAIN, &reg);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_MAX_GAIN, (reg & 0xFF80) | gain_ceiling);
}
return ret;
@ -293,7 +293,7 @@ static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain
static int get_gain_db(sensor_t *sensor, float *gain_db)
{
uint16_t gain;
int ret = cambus_readw(sensor->slv_addr, MT9V034_ANALOG_GAIN, &gain);
int ret = cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_ANALOG_GAIN, &gain);
*gain_db = 20.0 * (fast_log((gain & 0x7F) / 16.0) / fast_log(10.0));
@ -303,31 +303,31 @@ static int get_gain_db(sensor_t *sensor, float *gain_db)
static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
{
uint16_t reg, row_time_0, row_time_1;
int ret = cambus_readw(sensor->slv_addr, MT9V034_AEC_AGC_ENABLE, &reg);
ret |= cambus_writew(sensor->slv_addr, MT9V034_AEC_AGC_ENABLE,
int ret = cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_AEC_AGC_ENABLE, &reg);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_AEC_AGC_ENABLE,
(reg & (~MT9V034_AEC_ENABLE)) | ((enable != 0) ? MT9V034_AEC_ENABLE : 0));
ret |= sensor->snapshot(sensor, NULL, NULL); // Force shadow mode register to update...
if ((enable == 0) && (exposure_us >= 0)) {
ret |= cambus_readw(sensor->slv_addr, MT9V034_WINDOW_WIDTH, &row_time_0);
ret |= cambus_readw(sensor->slv_addr, MT9V034_HORIZONTAL_BLANKING, &row_time_1);
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_WINDOW_WIDTH, &row_time_0);
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_HORIZONTAL_BLANKING, &row_time_1);
int exposure = IM_MIN(exposure_us, MICROSECOND_CLKS / 2) * (MT9V034_XCLK_FREQ / MICROSECOND_CLKS);
int row_time = row_time_0 + row_time_1;
int coarse_time = exposure / row_time;
int fine_time = exposure % row_time;
ret |= cambus_writew(sensor->slv_addr, MT9V034_TOTAL_SHUTTER_WIDTH, coarse_time);
ret |= cambus_writew(sensor->slv_addr, MT9V034_FINE_SHUTTER_WIDTH_TOTAL, fine_time);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_TOTAL_SHUTTER_WIDTH, coarse_time);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_FINE_SHUTTER_WIDTH_TOTAL, fine_time);
} else if ((enable != 0) && (exposure_us >= 0)) {
ret |= cambus_readw(sensor->slv_addr, MT9V034_WINDOW_WIDTH, &row_time_0);
ret |= cambus_readw(sensor->slv_addr, MT9V034_HORIZONTAL_BLANKING, &row_time_1);
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_WINDOW_WIDTH, &row_time_0);
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_HORIZONTAL_BLANKING, &row_time_1);
int exposure = IM_MIN(exposure_us, MICROSECOND_CLKS / 2) * (MT9V034_XCLK_FREQ / MICROSECOND_CLKS);
int row_time = row_time_0 + row_time_1;
int coarse_time = exposure / row_time;
ret |= cambus_writew(sensor->slv_addr, MT9V034_MAX_EXPOSE, coarse_time);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_MAX_EXPOSE, coarse_time);
}
return ret;
@ -336,10 +336,10 @@ static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
static int get_exposure_us(sensor_t *sensor, int *exposure_us)
{
uint16_t int_rows, int_pixels, row_time_0, row_time_1;
int ret = cambus_readw(sensor->slv_addr, MT9V034_TOTAL_SHUTTER_WIDTH, &int_rows);
ret |= cambus_readw(sensor->slv_addr, MT9V034_FINE_SHUTTER_WIDTH_TOTAL, &int_pixels);
ret |= cambus_readw(sensor->slv_addr, MT9V034_WINDOW_WIDTH, &row_time_0);
ret |= cambus_readw(sensor->slv_addr, MT9V034_HORIZONTAL_BLANKING, &row_time_1);
int ret = cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_TOTAL_SHUTTER_WIDTH, &int_rows);
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_FINE_SHUTTER_WIDTH_TOTAL, &int_pixels);
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_WINDOW_WIDTH, &row_time_0);
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_HORIZONTAL_BLANKING, &row_time_1);
*exposure_us = ((int_rows * (row_time_0 + row_time_1)) + int_pixels) / (MT9V034_XCLK_FREQ / MICROSECOND_CLKS);
@ -359,8 +359,8 @@ static int get_rgb_gain_db(sensor_t *sensor, float *r_gain_db, float *g_gain_db,
static int set_hmirror(sensor_t *sensor, int enable)
{
uint16_t read_mode;
int ret = cambus_readw(sensor->slv_addr, MT9V034_READ_MODE, &read_mode);
ret |= cambus_writew(sensor->slv_addr, MT9V034_READ_MODE, // inverted behavior
int ret = cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_READ_MODE, &read_mode);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_READ_MODE, // inverted behavior
(read_mode & (~MT9V034_READ_MODE_COL_FLIP)) | ((enable == 0) ? MT9V034_READ_MODE_COL_FLIP : 0));
ret |= sensor->snapshot(sensor, NULL, NULL); // Force shadow mode register to update...
return ret;
@ -369,8 +369,8 @@ static int set_hmirror(sensor_t *sensor, int enable)
static int set_vflip(sensor_t *sensor, int enable)
{
uint16_t read_mode;
int ret = cambus_readw(sensor->slv_addr, MT9V034_READ_MODE, &read_mode);
ret |= cambus_writew(sensor->slv_addr, MT9V034_READ_MODE, // inverted behavior
int ret = cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_READ_MODE, &read_mode);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_READ_MODE, // inverted behavior
(read_mode & (~MT9V034_READ_MODE_ROW_FLIP)) | ((enable == 0) ? MT9V034_READ_MODE_ROW_FLIP : 0));
ret |= sensor->snapshot(sensor, NULL, NULL); // Force shadow mode register to update...
return ret;
@ -389,8 +389,8 @@ static int ioctl(sensor_t *sensor, int request, va_list ap)
switch (request) {
case IOCTL_SET_TRIGGERED_MODE: {
int enable = va_arg(ap, int);
ret = cambus_readw(sensor->slv_addr, MT9V034_CHIP_CONTROL, &chip_control);
ret |= cambus_writew(sensor->slv_addr, MT9V034_CHIP_CONTROL,
ret = cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_CHIP_CONTROL, &chip_control);
ret |= cambus_writew(&sensor->i2c, sensor->slv_addr, MT9V034_CHIP_CONTROL,
(chip_control & (~MT9V034_CHIP_CONTROL_MODE_MASK))
| ((enable != 0) ? MT9V034_CHIP_CONTROL_SNAP_MODE : MT9V034_CHIP_CONTROL_MASTER_MODE));
ret |= sensor->snapshot(sensor, NULL, NULL); // Force shadow mode register to update...
@ -398,7 +398,7 @@ static int ioctl(sensor_t *sensor, int request, va_list ap)
}
case IOCTL_GET_TRIGGERED_MODE: {
int *enable = va_arg(ap, int *);
ret = cambus_readw(sensor->slv_addr, MT9V034_CHIP_CONTROL, &chip_control);
ret = cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_CHIP_CONTROL, &chip_control);
if (ret >= 0) {
*enable = ((chip_control & MT9V034_CHIP_CONTROL_MODE_MASK) == MT9V034_CHIP_CONTROL_SNAP_MODE);
}

View File

@ -345,15 +345,15 @@ static const uint8_t saturation_regs[NUM_SATURATION_LEVELS + 1][5] = {
static int reset(sensor_t *sensor)
{
// Reset all registers
int ret = cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_writeb(sensor->slv_addr, COM7, COM7_SRST);
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM7, COM7_SRST);
// Delay 5 ms
systick_sleep(5);
// Write default regsiters
for (int i = 0; default_regs[i][0]; i++) {
ret |= cambus_writeb(sensor->slv_addr, default_regs[i][0], default_regs[i][1]);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, default_regs[i][0], default_regs[i][1]);
}
// Delay 300 ms
@ -365,7 +365,7 @@ static int reset(sensor_t *sensor)
static int sleep(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, COM2, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM2, &reg);
if (enable) {
reg |= COM2_STDBY;
@ -374,13 +374,13 @@ static int sleep(sensor_t *sensor, int enable)
}
// Write back register
return cambus_writeb(sensor->slv_addr, COM2, reg) | ret;
return cambus_writeb(&sensor->i2c, sensor->slv_addr, COM2, reg) | ret;
}
static int read_reg(sensor_t *sensor, uint16_t reg_addr)
{
uint8_t reg_data;
if (cambus_readb(sensor->slv_addr, reg_addr, &reg_data) != 0) {
if (cambus_readb(&sensor->i2c, sensor->slv_addr, reg_addr, &reg_data) != 0) {
return -1;
}
return reg_data;
@ -388,7 +388,7 @@ static int read_reg(sensor_t *sensor, uint16_t reg_addr)
static int write_reg(sensor_t *sensor, uint16_t reg_addr, uint16_t reg_data)
{
return cambus_writeb(sensor->slv_addr, reg_addr, reg_data);
return cambus_writeb(&sensor->i2c, sensor->slv_addr, reg_addr, reg_data);
}
static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
@ -416,7 +416,7 @@ static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
// Write regsiters
for (int i = 0; regs[i][0]; i++) {
ret |= cambus_writeb(sensor->slv_addr, regs[i][0], regs[i][1]);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, regs[i][0], regs[i][1]);
}
// Delay 300 ms
@ -455,7 +455,7 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize)
// Write setup regsiters
for (int i = 0; regs[i][0]; i++) {
ret |= cambus_writeb(sensor->slv_addr, regs[i][0], regs[i][1]);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, regs[i][0], regs[i][1]);
}
uint64_t tmp_div = IM_MIN(sensor_w / w, sensor_h / h);
@ -466,18 +466,18 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize)
uint16_t x_off = (sensor_w - w_mul) / 2;
uint16_t y_off = (sensor_h - h_mul) / 2;
ret |= cambus_writeb(sensor->slv_addr, CTRLI, CTRLI_LP_DP | CTRLI_V_DIV_SET(log_div) | CTRLI_H_DIV_SET(log_div));
ret |= cambus_writeb(sensor->slv_addr, HSIZE, HSIZE_SET(w_mul));
ret |= cambus_writeb(sensor->slv_addr, VSIZE, VSIZE_SET(h_mul));
ret |= cambus_writeb(sensor->slv_addr, XOFFL, XOFFL_SET(x_off));
ret |= cambus_writeb(sensor->slv_addr, YOFFL, YOFFL_SET(y_off));
ret |= cambus_writeb(sensor->slv_addr, VHYX, VHYX_HSIZE_SET(w_mul) | VHYX_VSIZE_SET(h_mul) | VHYX_XOFF_SET(x_off) | VHYX_YOFF_SET(y_off));
ret |= cambus_writeb(sensor->slv_addr, TEST, TEST_HSIZE_SET(w_mul));
ret |= cambus_writeb(sensor->slv_addr, ZMOW, ZMOW_OUTW_SET(w));
ret |= cambus_writeb(sensor->slv_addr, ZMOH, ZMOH_OUTH_SET(h));
ret |= cambus_writeb(sensor->slv_addr, ZMHH, ZMHH_OUTW_SET(w) | ZMHH_OUTH_SET(h));
ret |= cambus_writeb(sensor->slv_addr, R_DVP_SP, div);
ret |= cambus_writeb(sensor->slv_addr, RESET, 0x00);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, CTRLI, CTRLI_LP_DP | CTRLI_V_DIV_SET(log_div) | CTRLI_H_DIV_SET(log_div));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, HSIZE, HSIZE_SET(w_mul));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, VSIZE, VSIZE_SET(h_mul));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, XOFFL, XOFFL_SET(x_off));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, YOFFL, YOFFL_SET(y_off));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, VHYX, VHYX_HSIZE_SET(w_mul) | VHYX_VSIZE_SET(h_mul) | VHYX_XOFF_SET(x_off) | VHYX_YOFF_SET(y_off));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, TEST, TEST_HSIZE_SET(w_mul));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, ZMOW, ZMOW_OUTW_SET(w));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, ZMOH, ZMOH_OUTH_SET(h));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, ZMHH, ZMHH_OUTW_SET(w) | ZMHH_OUTH_SET(h));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, R_DVP_SP, div);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, RESET, 0x00);
// Delay 300 ms
systick_sleep(300);
@ -495,11 +495,11 @@ static int set_contrast(sensor_t *sensor, int level)
}
/* Switch to DSP register bank */
ret |= cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
/* Write contrast registers */
for (int i=0; i<sizeof(contrast_regs[0])/sizeof(contrast_regs[0][0]); i++) {
ret |= cambus_writeb(sensor->slv_addr, contrast_regs[0][i], contrast_regs[level][i]);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, contrast_regs[0][i], contrast_regs[level][i]);
}
return ret;
@ -515,11 +515,11 @@ static int set_brightness(sensor_t *sensor, int level)
}
/* Switch to DSP register bank */
ret |= cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
/* Write brightness registers */
for (int i=0; i<sizeof(brightness_regs[0])/sizeof(brightness_regs[0][0]); i++) {
ret |= cambus_writeb(sensor->slv_addr, brightness_regs[0][i], brightness_regs[level][i]);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, brightness_regs[0][i], brightness_regs[level][i]);
}
return ret;
@ -535,11 +535,11 @@ static int set_saturation(sensor_t *sensor, int level)
}
/* Switch to DSP register bank */
ret |= cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
/* Write saturation registers */
for (int i=0; i<sizeof(saturation_regs[0])/sizeof(saturation_regs[0][0]); i++) {
ret |= cambus_writeb(sensor->slv_addr, saturation_regs[0][i], saturation_regs[level][i]);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, saturation_regs[0][i], saturation_regs[level][i]);
}
return ret;
@ -550,10 +550,10 @@ static int set_gainceiling(sensor_t *sensor, gainceiling_t gainceiling)
int ret=0;
/* Switch to SENSOR register bank */
ret |= cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
/* Write gain ceiling register */
ret |= cambus_writeb(sensor->slv_addr, COM9, COM9_AGC_SET(gainceiling));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM9, COM9_AGC_SET(gainceiling));
return ret;
}
@ -563,10 +563,10 @@ static int set_quality(sensor_t *sensor, int qs)
int ret=0;
/* Switch to DSP register bank */
ret |= cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
/* Write QS register */
ret |= cambus_writeb(sensor->slv_addr, QS, qs);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, QS, qs);
return ret;
}
@ -574,8 +574,8 @@ static int set_quality(sensor_t *sensor, int qs)
static int set_colorbar(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(sensor->slv_addr, COM7, &reg);
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, &reg);
if (enable) {
reg |= COM7_COLOR_BAR;
@ -583,15 +583,15 @@ static int set_colorbar(sensor_t *sensor, int enable)
reg &= ~COM7_COLOR_BAR;
}
return cambus_writeb(sensor->slv_addr, COM7, reg) | ret;
return cambus_writeb(&sensor->i2c, sensor->slv_addr, COM7, reg) | ret;
}
static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain_db_ceiling)
{
uint8_t reg;
int ret = cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(sensor->slv_addr, COM8, &reg);
ret |= cambus_writeb(sensor->slv_addr, COM8, (reg & (~COM8_AGC_EN)) | ((enable != 0) ? COM8_AGC_EN : 0));
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, (reg & (~COM8_AGC_EN)) | ((enable != 0) ? COM8_AGC_EN : 0));
if ((enable == 0) && (!isnanf(gain_db)) && (!isinff(gain_db))) {
float gain = IM_MAX(IM_MIN(fast_expf((gain_db / 20.0) * fast_log(10.0)), 32.0), 1.0);
@ -600,12 +600,12 @@ static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain
int gain_hi = 0xF >> (4 - gain_temp);
int gain_lo = IM_MIN(fast_roundf(((gain / (1 << gain_temp)) - 1.0) * 16.0), 15);
ret |= cambus_writeb(sensor->slv_addr, GAIN, (gain_hi << 4) | (gain_lo << 0));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, GAIN, (gain_hi << 4) | (gain_lo << 0));
} else if ((enable != 0) && (!isnanf(gain_db_ceiling)) && (!isinff(gain_db_ceiling))) {
float gain_ceiling = IM_MAX(IM_MIN(fast_expf((gain_db_ceiling / 20.0) * fast_log(10.0)), 128.0), 2.0);
ret |= cambus_readb(sensor->slv_addr, COM9, &reg);
ret |= cambus_writeb(sensor->slv_addr, COM9, (reg & 0x1F) | ((fast_ceilf(fast_log2(gain_ceiling)) - 1) << 5));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM9, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM9, (reg & 0x1F) | ((fast_ceilf(fast_log2(gain_ceiling)) - 1) << 5));
}
return ret;
@ -614,20 +614,20 @@ static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain
static int get_gain_db(sensor_t *sensor, float *gain_db)
{
uint8_t reg, gain;
int ret = cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(sensor->slv_addr, COM8, &reg);
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, &reg);
// DISABLED
// if (reg & COM8_AGC_EN) {
// ret |= cambus_writeb(sensor->slv_addr, COM8, reg & (~COM8_AGC_EN));
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, reg & (~COM8_AGC_EN));
// }
// DISABLED
ret |= cambus_readb(sensor->slv_addr, GAIN, &gain);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, GAIN, &gain);
// DISABLED
// if (reg & COM8_AGC_EN) {
// ret |= cambus_writeb(sensor->slv_addr, COM8, reg | COM8_AGC_EN);
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, reg | COM8_AGC_EN);
// }
// DISABLED
@ -641,24 +641,24 @@ static int get_gain_db(sensor_t *sensor, float *gain_db)
static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
{
uint8_t reg;
int ret = cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(sensor->slv_addr, COM8, &reg);
ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AEC(reg, (enable != 0)));
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, COM8_SET_AEC(reg, (enable != 0)));
if ((enable == 0) && (exposure_us >= 0)) {
ret |= cambus_readb(sensor->slv_addr, COM7, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, &reg);
int t_line = 0;
if (COM7_GET_RES(reg) == COM7_RES_UXGA) t_line = 1600 + 322;
if (COM7_GET_RES(reg) == COM7_RES_SVGA) t_line = 800 + 390;
if (COM7_GET_RES(reg) == COM7_RES_CIF) t_line = 400 + 195;
ret |= cambus_readb(sensor->slv_addr, CLKRC, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CLKRC, &reg);
int pll_mult = ((reg & CLKRC_DOUBLE) ? 2 : 1) * 3;
int clk_rc = (reg & CLKRC_DIVIDER_MASK) + 2;
ret |= cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_readb(sensor->slv_addr, IMAGE_MODE, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, IMAGE_MODE, &reg);
int t_pclk = 0;
if (IMAGE_MODE_GET_FMT(reg) == IMAGE_MODE_YUV422) t_pclk = 2;
@ -667,16 +667,16 @@ static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
int exposure = IM_MAX(IM_MIN(((exposure_us*(((OMV_XCLK_FREQUENCY/clk_rc)*pll_mult)/1000000))/t_pclk)/t_line,0xFFFF),0x0000);
ret |= cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(sensor->slv_addr, REG04, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG04, (reg & 0xFC) | ((exposure >> 0) & 0x3));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG04, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG04, (reg & 0xFC) | ((exposure >> 0) & 0x3));
ret |= cambus_readb(sensor->slv_addr, AEC, &reg);
ret |= cambus_writeb(sensor->slv_addr, AEC, (reg & 0x00) | ((exposure >> 2) & 0xFF));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, AEC, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, AEC, (reg & 0x00) | ((exposure >> 2) & 0xFF));
ret |= cambus_readb(sensor->slv_addr, REG45, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG45, (reg & 0xC0) | ((exposure >> 10) & 0x3F));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG45, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG45, (reg & 0xC0) | ((exposure >> 10) & 0x3F));
}
return ret;
@ -685,38 +685,38 @@ static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
static int get_exposure_us(sensor_t *sensor, int *exposure_us)
{
uint8_t reg, aec_10, aec_92, aec_1510;
int ret = cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(sensor->slv_addr, COM8, &reg);
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, &reg);
// DISABLED
// if (reg & COM8_AEC_EN) {
// ret |= cambus_writeb(sensor->slv_addr, COM8, reg & (~COM8_AEC_EN));
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, reg & (~COM8_AEC_EN));
// }
// DISABLED
ret |= cambus_readb(sensor->slv_addr, REG04, &aec_10);
ret |= cambus_readb(sensor->slv_addr, AEC, &aec_92);
ret |= cambus_readb(sensor->slv_addr, REG45, &aec_1510);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG04, &aec_10);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, AEC, &aec_92);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG45, &aec_1510);
// DISABLED
// if (reg & COM8_AEC_EN) {
// ret |= cambus_writeb(sensor->slv_addr, COM8, reg | COM8_AEC_EN);
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, reg | COM8_AEC_EN);
// }
// DISABLED
ret |= cambus_readb(sensor->slv_addr, COM7, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, &reg);
int t_line = 0;
if (COM7_GET_RES(reg) == COM7_RES_UXGA) t_line = 1600 + 322;
if (COM7_GET_RES(reg) == COM7_RES_SVGA) t_line = 800 + 390;
if (COM7_GET_RES(reg) == COM7_RES_CIF) t_line = 400 + 195;
ret |= cambus_readb(sensor->slv_addr, CLKRC, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CLKRC, &reg);
int pll_mult = ((reg & CLKRC_DOUBLE) ? 2 : 1) * 3;
int clk_rc = (reg & CLKRC_DIVIDER_MASK) + 2;
ret |= cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_readb(sensor->slv_addr, IMAGE_MODE, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, IMAGE_MODE, &reg);
int t_pclk = 0;
if (IMAGE_MODE_GET_FMT(reg) == IMAGE_MODE_YUV422) t_pclk = 2;
@ -732,9 +732,9 @@ static int get_exposure_us(sensor_t *sensor, int *exposure_us)
static int set_auto_whitebal(sensor_t *sensor, int enable, float r_gain_db, float g_gain_db, float b_gain_db)
{
uint8_t reg;
int ret = cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_readb(sensor->slv_addr, CTRL1, &reg);
ret |= cambus_writeb(sensor->slv_addr, CTRL1, (reg & (~CTRL1_AWB)) | ((enable != 0) ? CTRL1_AWB : 0));
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CTRL1, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, CTRL1, (reg & (~CTRL1_AWB)) | ((enable != 0) ? CTRL1_AWB : 0));
if ((enable == 0) && (!isnanf(r_gain_db)) && (!isnanf(g_gain_db)) && (!isnanf(b_gain_db))
&& (!isinff(r_gain_db)) && (!isinff(g_gain_db)) && (!isinff(b_gain_db))) {
@ -746,18 +746,18 @@ static int set_auto_whitebal(sensor_t *sensor, int enable, float r_gain_db, floa
static int get_rgb_gain_db(sensor_t *sensor, float *r_gain_db, float *g_gain_db, float *b_gain_db)
{
uint8_t reg;
int ret = cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_readb(sensor->slv_addr, CTRL1, &reg);
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CTRL1, &reg);
// DISABLED
// if (reg & CTRL1_AWB) {
// ret |= cambus_writeb(sensor->slv_addr, CTRL1, reg & (~CTRL1_AWB));
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, CTRL1, reg & (~CTRL1_AWB));
// }
// DISABLED
// DISABLED
// if (reg & CTRL1_AWB) {
// ret |= cambus_writeb(sensor->slv_addr, CTRL1, reg | CTRL1_AWB);
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, CTRL1, reg | CTRL1_AWB);
// }
// DISABLED
@ -771,8 +771,8 @@ static int get_rgb_gain_db(sensor_t *sensor, float *r_gain_db, float *g_gain_db,
static int set_hmirror(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(sensor->slv_addr, REG04, &reg);
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG04, &reg);
if (!enable) { // Already mirrored.
reg |= REG04_HFLIP_IMG;
@ -780,14 +780,14 @@ static int set_hmirror(sensor_t *sensor, int enable)
reg &= ~REG04_HFLIP_IMG;
}
return cambus_writeb(sensor->slv_addr, REG04, reg) | ret;
return cambus_writeb(&sensor->i2c, sensor->slv_addr, REG04, reg) | ret;
}
static int set_vflip(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(sensor->slv_addr, REG04, &reg);
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG04, &reg);
if (!enable) { // Already flipped.
reg |= REG04_VFLIP_IMG | REG04_VREF_EN;
@ -795,7 +795,7 @@ static int set_vflip(sensor_t *sensor, int enable)
reg &= ~(REG04_VFLIP_IMG | REG04_VREF_EN);
}
return cambus_writeb(sensor->slv_addr, REG04, reg) | ret;
return cambus_writeb(&sensor->i2c, sensor->slv_addr, REG04, reg) | ret;
}
static int set_special_effect(sensor_t *sensor, sde_t sde)
@ -804,20 +804,20 @@ static int set_special_effect(sensor_t *sensor, sde_t sde)
switch (sde) {
case SDE_NEGATIVE:
ret |= cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_writeb(sensor->slv_addr, BPADDR, 0x00);
ret |= cambus_writeb(sensor->slv_addr, BPDATA, 0x40);
ret |= cambus_writeb(sensor->slv_addr, BPADDR, 0x05);
ret |= cambus_writeb(sensor->slv_addr, BPDATA, 0x80);
ret |= cambus_writeb(sensor->slv_addr, BPDATA, 0x80);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BPADDR, 0x00);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BPDATA, 0x40);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BPADDR, 0x05);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BPDATA, 0x80);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BPDATA, 0x80);
break;
case SDE_NORMAL:
ret |= cambus_writeb(sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_writeb(sensor->slv_addr, BPADDR, 0x00);
ret |= cambus_writeb(sensor->slv_addr, BPDATA, 0x00);
ret |= cambus_writeb(sensor->slv_addr, BPADDR, 0x05);
ret |= cambus_writeb(sensor->slv_addr, BPDATA, 0x80);
ret |= cambus_writeb(sensor->slv_addr, BPDATA, 0x80);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BPADDR, 0x00);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BPDATA, 0x00);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BPADDR, 0x05);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BPDATA, 0x80);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BPDATA, 0x80);
break;
default:
return -1;

View File

@ -358,15 +358,15 @@ static const uint8_t saturation_regs[NUM_SATURATION_LEVELS][6] = {
static int reset(sensor_t *sensor)
{
// Reset all registers
int ret = cambus_writeb2(sensor->slv_addr, SCCB_SYSTEM_CTRL_1, 0x11);
ret |= cambus_writeb2(sensor->slv_addr, SYSTEM_CTROL0, 0x82);
int ret = cambus_writeb2(&sensor->i2c, sensor->slv_addr, SCCB_SYSTEM_CTRL_1, 0x11);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, SYSTEM_CTROL0, 0x82);
// Delay 5 ms
systick_sleep(5);
// Write default regsiters
for (int i = 0; default_regs[i][0]; i++) {
ret |= cambus_writeb2(sensor->slv_addr, (default_regs[i][0] << 8) | (default_regs[i][1] << 0), default_regs[i][2]);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, (default_regs[i][0] << 8) | (default_regs[i][1] << 0), default_regs[i][2]);
}
// Delay 300 ms
@ -378,7 +378,7 @@ static int reset(sensor_t *sensor)
static int sleep(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb2(sensor->slv_addr, SYSTEM_CTROL0, &reg);
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, SYSTEM_CTROL0, &reg);
if (enable) {
reg |= 0x40;
@ -386,13 +386,13 @@ static int sleep(sensor_t *sensor, int enable)
reg &= ~0x40;
}
return cambus_writeb2(sensor->slv_addr, SYSTEM_CTROL0, reg) | ret;
return cambus_writeb2(&sensor->i2c, sensor->slv_addr, SYSTEM_CTROL0, reg) | ret;
}
static int read_reg(sensor_t *sensor, uint16_t reg_addr)
{
uint8_t reg_data;
if (cambus_readb2(sensor->slv_addr, reg_addr, &reg_data) != 0) {
if (cambus_readb2(&sensor->i2c, sensor->slv_addr, reg_addr, &reg_data) != 0) {
return -1;
}
return reg_data;
@ -400,7 +400,7 @@ static int read_reg(sensor_t *sensor, uint16_t reg_addr)
static int write_reg(sensor_t *sensor, uint16_t reg_addr, uint16_t reg_data)
{
return cambus_writeb2(sensor->slv_addr, reg_addr, reg_data);
return cambus_writeb2(&sensor->i2c, sensor->slv_addr, reg_addr, reg_data);
}
static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
@ -420,55 +420,55 @@ static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
switch (pixformat) {
case PIXFORMAT_RGB565:
ret |= cambus_writeb2(sensor->slv_addr, FORMAT_CONTROL, 0x61);
ret |= cambus_writeb2(sensor->slv_addr, FORMAT_CONTROL_MUX, 0x01);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, FORMAT_CONTROL, 0x61);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, FORMAT_CONTROL_MUX, 0x01);
pll = 0x64; // 40 MHz
break;
case PIXFORMAT_GRAYSCALE:
case PIXFORMAT_YUV422:
ret |= cambus_writeb2(sensor->slv_addr, FORMAT_CONTROL, 0x10);
ret |= cambus_writeb2(sensor->slv_addr, FORMAT_CONTROL_MUX, 0x00);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, FORMAT_CONTROL, 0x10);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, FORMAT_CONTROL_MUX, 0x00);
pll = 0x64; // 40 MHz
break;
case PIXFORMAT_BAYER:
ret |= cambus_writeb2(sensor->slv_addr, FORMAT_CONTROL, 0x00);
ret |= cambus_writeb2(sensor->slv_addr, FORMAT_CONTROL_MUX, 0x01);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, FORMAT_CONTROL, 0x00);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, FORMAT_CONTROL_MUX, 0x01);
pll = 0x64; // 40 MHz (jpeg can go faster at higher reses)
break;
case PIXFORMAT_JPEG:
ret |= cambus_writeb2(sensor->slv_addr, FORMAT_CONTROL, 0x30);
ret |= cambus_writeb2(sensor->slv_addr, FORMAT_CONTROL_MUX, 0x00);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, FORMAT_CONTROL, 0x30);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, FORMAT_CONTROL_MUX, 0x00);
pll = 0x64; // 40 MHz
break;
default:
return -1;
}
ret |= cambus_readb2(sensor->slv_addr, TIMING_TC_REG_21, &reg);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_TC_REG_21, (reg & 0xDF) | ((pixformat == PIXFORMAT_JPEG) ? 0x20 : 0x00));
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_21, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_21, (reg & 0xDF) | ((pixformat == PIXFORMAT_JPEG) ? 0x20 : 0x00));
ret |= cambus_readb2(sensor->slv_addr, SYSTEM_RESET_02, &reg);
ret |= cambus_writeb2(sensor->slv_addr, SYSTEM_RESET_02, (reg & 0xE3) | ((pixformat == PIXFORMAT_JPEG) ? 0x00 : 0x1C));
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, SYSTEM_RESET_02, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, SYSTEM_RESET_02, (reg & 0xE3) | ((pixformat == PIXFORMAT_JPEG) ? 0x00 : 0x1C));
ret |= cambus_readb2(sensor->slv_addr, CLOCK_ENABLE_02, &reg);
ret |= cambus_writeb2(sensor->slv_addr, CLOCK_ENABLE_02, (reg & 0xD7) | ((pixformat == PIXFORMAT_JPEG) ? 0x28 : 0x00));
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, CLOCK_ENABLE_02, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, CLOCK_ENABLE_02, (reg & 0xD7) | ((pixformat == PIXFORMAT_JPEG) ? 0x28 : 0x00));
// Adjust JPEG quality.
if (pixformat == PIXFORMAT_JPEG) {
bool high_res = (resolution[sensor->framesize][0] > 1280) || (resolution[sensor->framesize][1] > 960);
ret |= cambus_writeb2(sensor->slv_addr, JPEG_CTRL07, high_res ? 0x10 : 0x4);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, JPEG_CTRL07, high_res ? 0x10 : 0x4);
if (sensor->pixformat != PIXFORMAT_JPEG) { // We have to double this.
ret |= cambus_readb2(sensor->slv_addr, TIMING_HTS_H, &reg);
ret |= cambus_readb2(sensor->slv_addr, TIMING_HTS_L, &reg2);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_HTS_H, &reg);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_HTS_L, &reg2);
uint16_t sensor_hts = ((((reg << 8) | reg2) - HSYNC_TIME) * 2) + HSYNC_TIME;
ret |= cambus_writeb2(sensor->slv_addr, TIMING_HTS_H, sensor_hts >> 8);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_HTS_L, sensor_hts);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_HTS_H, sensor_hts >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_HTS_L, sensor_hts);
}
}
return cambus_writeb2(sensor->slv_addr, SC_PLL_CONTRL2, pll) | ret;
return cambus_writeb2(&sensor->i2c, sensor->slv_addr, SC_PLL_CONTRL2, pll) | ret;
}
static int set_framesize(sensor_t *sensor, framesize_t framesize)
@ -555,59 +555,59 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize)
// Step 6: Write regs.
ret |= cambus_writeb2(sensor->slv_addr, TIMING_HS_H, sensor_ws >> 8);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_HS_L, sensor_ws);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_HS_H, sensor_ws >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_HS_L, sensor_ws);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_VS_H, sensor_hs >> 8);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_VS_L, sensor_hs);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_VS_H, sensor_hs >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_VS_L, sensor_hs);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_HW_H, sensor_we >> 8);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_HW_L, sensor_we);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_HW_H, sensor_we >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_HW_L, sensor_we);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_VH_H, sensor_he >> 8);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_VH_L, sensor_he);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_VH_H, sensor_he >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_VH_L, sensor_he);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_DVPHO_H, w >> 8);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_DVPHO_L, w);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_DVPHO_H, w >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_DVPHO_L, w);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_DVPVO_H, h >> 8);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_DVPVO_L, h);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_DVPVO_H, h >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_DVPVO_L, h);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_HTS_H, sensor_hts >> 8);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_HTS_L, sensor_hts);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_HTS_H, sensor_hts >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_HTS_L, sensor_hts);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_VTS_H, sensor_vts >> 8);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_VTS_L, sensor_vts);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_VTS_H, sensor_vts >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_VTS_L, sensor_vts);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_HOFFSET_H, x_off >> 8);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_HOFFSET_L, x_off);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_HOFFSET_H, x_off >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_HOFFSET_L, x_off);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_VOFFSET_H, y_off >> 8);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_VOFFSET_L, y_off);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_VOFFSET_H, y_off >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_VOFFSET_L, y_off);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_X_INC, sensor_x_inc);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_Y_INC, sensor_y_inc);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_X_INC, sensor_x_inc);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_Y_INC, sensor_y_inc);
ret |= cambus_readb2(sensor->slv_addr, TIMING_TC_REG_20, &reg);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_TC_REG_20, (reg & 0xFE) | (sensor_div > 1));
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_20, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_20, (reg & 0xFE) | (sensor_div > 1));
ret |= cambus_readb2(sensor->slv_addr, TIMING_TC_REG_21, &reg);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_TC_REG_21, (reg & 0xFE) | (sensor_div > 1));
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_21, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_21, (reg & 0xFE) | (sensor_div > 1));
ret |= cambus_writeb2(sensor->slv_addr, VFIFO_HSIZE_H, w >> 8);
ret |= cambus_writeb2(sensor->slv_addr, VFIFO_HSIZE_L, w);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, VFIFO_HSIZE_H, w >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, VFIFO_HSIZE_L, w);
ret |= cambus_writeb2(sensor->slv_addr, VFIFO_VSIZE_H, h >> 8);
ret |= cambus_writeb2(sensor->slv_addr, VFIFO_VSIZE_L, h);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, VFIFO_VSIZE_H, h >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, VFIFO_VSIZE_L, h);
// Step 7: Adjust JPEG quality.
ret |= cambus_writeb2(sensor->slv_addr, JPEG_CTRL07, (sensor_div > 1) ? 0x4 : 0x10);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, JPEG_CTRL07, (sensor_div > 1) ? 0x4 : 0x10);
// Step 8: Adjust PLL freq.
pll = 0x64; // 40 Mhz
ret |= cambus_writeb2(sensor->slv_addr, SC_PLL_CONTRL2, pll);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, SC_PLL_CONTRL2, pll);
// Delay 300 ms
systick_sleep(300);
@ -624,11 +624,11 @@ static int set_contrast(sensor_t *sensor, int level)
return -1;
}
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0x03); // start group 3
ret |= cambus_writeb2(sensor->slv_addr, 0x5586, (new_level + 5) << 2);
ret |= cambus_writeb2(sensor->slv_addr, 0x5585, contrast_regs[new_level][0]);
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0x13); // end group 3
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0xa3); // launch group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0x03); // start group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5586, (new_level + 5) << 2);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5585, contrast_regs[new_level][0]);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0x13); // end group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0xa3); // launch group 3
return ret;
}
@ -642,11 +642,11 @@ static int set_brightness(sensor_t *sensor, int level)
return -1;
}
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0x03); // start group 3
ret |= cambus_writeb2(sensor->slv_addr, 0x5587, abs(level) << 4);
ret |= cambus_writeb2(sensor->slv_addr, 0x5588, (level < 0) ? 0x09 : 0x01);
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0x13); // end group 3
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0xa3); // launch group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0x03); // start group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5587, abs(level) << 4);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5588, (level < 0) ? 0x09 : 0x01);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0x13); // end group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0xa3); // launch group 3
return ret;
}
@ -660,20 +660,20 @@ static int set_saturation(sensor_t *sensor, int level)
return -1;
}
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0x03); // start group 3
ret |= cambus_writeb2(sensor->slv_addr, 0x5581, 0x1c);
ret |= cambus_writeb2(sensor->slv_addr, 0x5582, 0x5a);
ret |= cambus_writeb2(sensor->slv_addr, 0x5583, 0x06);
ret |= cambus_writeb2(sensor->slv_addr, 0x5584, saturation_regs[new_level][0]);
ret |= cambus_writeb2(sensor->slv_addr, 0x5585, saturation_regs[new_level][1]);
ret |= cambus_writeb2(sensor->slv_addr, 0x5586, saturation_regs[new_level][2]);
ret |= cambus_writeb2(sensor->slv_addr, 0x5587, saturation_regs[new_level][3]);
ret |= cambus_writeb2(sensor->slv_addr, 0x5588, saturation_regs[new_level][4]);
ret |= cambus_writeb2(sensor->slv_addr, 0x5589, saturation_regs[new_level][5]);
ret |= cambus_writeb2(sensor->slv_addr, 0x558b, 0x98);
ret |= cambus_writeb2(sensor->slv_addr, 0x558a, 0x01);
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0x13); // end group 3
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0xa3); // launch group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0x03); // start group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5581, 0x1c);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5582, 0x5a);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5583, 0x06);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5584, saturation_regs[new_level][0]);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5585, saturation_regs[new_level][1]);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5586, saturation_regs[new_level][2]);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5587, saturation_regs[new_level][3]);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5588, saturation_regs[new_level][4]);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5589, saturation_regs[new_level][5]);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x558b, 0x98);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x558a, 0x01);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0x13); // end group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0xa3); // launch group 3
return ret;
}
@ -688,9 +688,9 @@ static int set_gainceiling(sensor_t *sensor, gainceiling_t gainceiling)
return -1;
}
ret |= cambus_readb2(sensor->slv_addr, AEC_GAIN_CEILING_H, &reg);
ret |= cambus_writeb2(sensor->slv_addr, AEC_GAIN_CEILING_H, (reg & 0xFC) | (new_gainceiling >> 8));
ret |= cambus_writeb2(sensor->slv_addr, AEC_GAIN_CEILING_L, new_gainceiling);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, AEC_GAIN_CEILING_H, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AEC_GAIN_CEILING_H, (reg & 0xFC) | (new_gainceiling >> 8));
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AEC_GAIN_CEILING_L, new_gainceiling);
return ret;
}
@ -698,8 +698,8 @@ static int set_gainceiling(sensor_t *sensor, gainceiling_t gainceiling)
static int set_quality(sensor_t *sensor, int qs)
{
uint8_t reg;
int ret = cambus_readb2(sensor->slv_addr, JPEG_CTRL07, &reg);
ret |= cambus_writeb2(sensor->slv_addr, JPEG_CTRL07, (reg & 0xC0) | (qs >> 2));
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, JPEG_CTRL07, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, JPEG_CTRL07, (reg & 0xC0) | (qs >> 2));
return ret;
}
@ -707,28 +707,28 @@ static int set_quality(sensor_t *sensor, int qs)
static int set_colorbar(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb2(sensor->slv_addr, PRE_ISP_TEST, &reg);
return cambus_writeb2(sensor->slv_addr, PRE_ISP_TEST, (reg & 0x7F) | (enable ? 0x80 : 0x00)) | ret;
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, PRE_ISP_TEST, &reg);
return cambus_writeb2(&sensor->i2c, sensor->slv_addr, PRE_ISP_TEST, (reg & 0x7F) | (enable ? 0x80 : 0x00)) | ret;
}
static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain_db_ceiling)
{
uint8_t reg;
int ret = cambus_readb2(sensor->slv_addr, AEC_PK_MANUAL, &reg);
ret |= cambus_writeb2(sensor->slv_addr, AEC_PK_MANUAL, (reg & 0xFD) | ((enable == 0) << 1));
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, AEC_PK_MANUAL, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AEC_PK_MANUAL, (reg & 0xFD) | ((enable == 0) << 1));
if ((enable == 0) && (!isnanf(gain_db)) && (!isinff(gain_db))) {
int gain = IM_MAX(IM_MIN(fast_expf((gain_db / 20.0) * fast_log(10.0)) * 16.0, 1023), 0);
ret |= cambus_readb2(sensor->slv_addr, AEC_PK_REAL_GAIN_H, &reg);
ret |= cambus_writeb2(sensor->slv_addr, AEC_PK_REAL_GAIN_H, (reg & 0xFC) | (gain >> 8));
ret |= cambus_writeb2(sensor->slv_addr, AEC_PK_REAL_GAIN_L, gain);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, AEC_PK_REAL_GAIN_H, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AEC_PK_REAL_GAIN_H, (reg & 0xFC) | (gain >> 8));
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AEC_PK_REAL_GAIN_L, gain);
} else if ((enable != 0) && (!isnanf(gain_db_ceiling)) && (!isinff(gain_db_ceiling))) {
int gain_ceiling = IM_MAX(IM_MIN(fast_expf((gain_db_ceiling / 20.0) * fast_log(10.0)) * 16.0, 1023), 0);
ret |= cambus_readb2(sensor->slv_addr, AEC_GAIN_CEILING_H, &reg);
ret |= cambus_writeb2(sensor->slv_addr, AEC_GAIN_CEILING_H, (reg & 0xFC) | (gain_ceiling >> 8));
ret |= cambus_writeb2(sensor->slv_addr, AEC_GAIN_CEILING_L, gain_ceiling);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, AEC_GAIN_CEILING_H, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AEC_GAIN_CEILING_H, (reg & 0xFC) | (gain_ceiling >> 8));
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AEC_GAIN_CEILING_L, gain_ceiling);
}
return ret;
@ -738,8 +738,8 @@ static int get_gain_db(sensor_t *sensor, float *gain_db)
{
uint8_t gainh, gainl;
int ret = cambus_readb2(sensor->slv_addr, AEC_PK_REAL_GAIN_H, &gainh);
ret |= cambus_readb2(sensor->slv_addr, AEC_PK_REAL_GAIN_L, &gainl);
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, AEC_PK_REAL_GAIN_H, &gainh);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, AEC_PK_REAL_GAIN_L, &gainl);
*gain_db = 20.0 * (fast_log((((gainh & 0x3) << 8) | gainl) / 16.0) / fast_log(10.0));
@ -749,17 +749,17 @@ static int get_gain_db(sensor_t *sensor, float *gain_db)
static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
{
uint8_t reg, pll, hts_h, hts_l, vts_h, vts_l;
int ret = cambus_readb2(sensor->slv_addr, AEC_PK_MANUAL, &reg);
ret |= cambus_writeb2(sensor->slv_addr, AEC_PK_MANUAL, (reg & 0xFE) | ((enable == 0) << 0));
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, AEC_PK_MANUAL, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AEC_PK_MANUAL, (reg & 0xFE) | ((enable == 0) << 0));
if ((enable == 0) && (exposure_us >= 0)) {
ret |= cambus_readb2(sensor->slv_addr, SC_PLL_CONTRL2, &pll);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, SC_PLL_CONTRL2, &pll);
ret |= cambus_readb2(sensor->slv_addr, TIMING_HTS_H, &hts_h);
ret |= cambus_readb2(sensor->slv_addr, TIMING_HTS_L, &hts_l);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_HTS_H, &hts_h);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_HTS_L, &hts_l);
ret |= cambus_readb2(sensor->slv_addr, TIMING_VTS_H, &vts_h);
ret |= cambus_readb2(sensor->slv_addr, TIMING_VTS_L, &vts_l);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_VTS_H, &vts_h);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_VTS_L, &vts_l);
uint16_t hts = (hts_h << 8) | hts_l;
uint16_t vts = (vts_h << 8) | vts_l;
@ -775,12 +775,12 @@ static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
int new_vts = IM_MAX(exposure, vts);
ret |= cambus_writeb2(sensor->slv_addr, AEC_PK_EXPOSURE_0, exposure >> 12);
ret |= cambus_writeb2(sensor->slv_addr, AEC_PK_EXPOSURE_1, exposure >> 4);
ret |= cambus_writeb2(sensor->slv_addr, AEC_PK_EXPOSURE_2, exposure << 4);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AEC_PK_EXPOSURE_0, exposure >> 12);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AEC_PK_EXPOSURE_1, exposure >> 4);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AEC_PK_EXPOSURE_2, exposure << 4);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_VTS_H, new_vts >> 8);
ret |= cambus_writeb2(sensor->slv_addr, TIMING_VTS_L, new_vts);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_VTS_H, new_vts >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_VTS_L, new_vts);
}
return ret;
@ -789,14 +789,14 @@ static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
static int get_exposure_us(sensor_t *sensor, int *exposure_us)
{
uint8_t pll, aec_0, aec_1, aec_2, hts_h, hts_l;
int ret = cambus_readb2(sensor->slv_addr, SC_PLL_CONTRL2, &pll);
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, SC_PLL_CONTRL2, &pll);
ret |= cambus_readb2(sensor->slv_addr, AEC_PK_EXPOSURE_0, &aec_0);
ret |= cambus_readb2(sensor->slv_addr, AEC_PK_EXPOSURE_1, &aec_1);
ret |= cambus_readb2(sensor->slv_addr, AEC_PK_EXPOSURE_2, &aec_2);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, AEC_PK_EXPOSURE_0, &aec_0);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, AEC_PK_EXPOSURE_1, &aec_1);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, AEC_PK_EXPOSURE_2, &aec_2);
ret |= cambus_readb2(sensor->slv_addr, TIMING_HTS_H, &hts_h);
ret |= cambus_readb2(sensor->slv_addr, TIMING_HTS_L, &hts_l);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_HTS_H, &hts_h);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_HTS_L, &hts_l);
uint32_t aec = ((aec_0 << 16) | (aec_1 << 8) | aec_2) >> 4;
uint16_t hts = (hts_h << 8) | hts_l;
@ -816,8 +816,8 @@ static int get_exposure_us(sensor_t *sensor, int *exposure_us)
static int set_auto_whitebal(sensor_t *sensor, int enable, float r_gain_db, float g_gain_db, float b_gain_db)
{
uint8_t reg;
int ret = cambus_readb2(sensor->slv_addr, AWB_MANUAL_CONTROL, &reg);
ret |= cambus_writeb2(sensor->slv_addr, AWB_MANUAL_CONTROL, (reg & 0xFE) | (enable == 0));
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, AWB_MANUAL_CONTROL, &reg);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AWB_MANUAL_CONTROL, (reg & 0xFE) | (enable == 0));
if ((enable == 0) && (!isnanf(r_gain_db)) && (!isnanf(g_gain_db)) && (!isnanf(b_gain_db))
&& (!isinff(r_gain_db)) && (!isinff(g_gain_db)) && (!isinff(b_gain_db))) {
@ -826,12 +826,12 @@ static int set_auto_whitebal(sensor_t *sensor, int enable, float r_gain_db, floa
int g_gain = IM_MAX(IM_MIN(fast_roundf(fast_expf((g_gain_db / 20.0) * fast_log(10.0))), 4095), 0);
int b_gain = IM_MAX(IM_MIN(fast_roundf(fast_expf((b_gain_db / 20.0) * fast_log(10.0))), 4095), 0);
ret |= cambus_writeb2(sensor->slv_addr, AWB_R_GAIN_H, r_gain >> 8);
ret |= cambus_writeb2(sensor->slv_addr, AWB_R_GAIN_L, r_gain);
ret |= cambus_writeb2(sensor->slv_addr, AWB_G_GAIN_H, g_gain >> 8);
ret |= cambus_writeb2(sensor->slv_addr, AWB_G_GAIN_L, g_gain);
ret |= cambus_writeb2(sensor->slv_addr, AWB_B_GAIN_H, b_gain >> 8);
ret |= cambus_writeb2(sensor->slv_addr, AWB_B_GAIN_L, b_gain);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AWB_R_GAIN_H, r_gain >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AWB_R_GAIN_L, r_gain);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AWB_G_GAIN_H, g_gain >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AWB_G_GAIN_L, g_gain);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AWB_B_GAIN_H, b_gain >> 8);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, AWB_B_GAIN_L, b_gain);
}
return ret;
@ -841,12 +841,12 @@ static int get_rgb_gain_db(sensor_t *sensor, float *r_gain_db, float *g_gain_db,
{
uint8_t redh, redl, greenh, greenl, blueh, bluel;
int ret = cambus_readb2(sensor->slv_addr, AWB_R_GAIN_H, &redh);
ret |= cambus_readb2(sensor->slv_addr, AWB_R_GAIN_L, &redl);
ret |= cambus_readb2(sensor->slv_addr, AWB_G_GAIN_H, &greenh);
ret |= cambus_readb2(sensor->slv_addr, AWB_G_GAIN_L, &greenl);
ret |= cambus_readb2(sensor->slv_addr, AWB_B_GAIN_H, &blueh);
ret |= cambus_readb2(sensor->slv_addr, AWB_B_GAIN_L, &bluel);
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, AWB_R_GAIN_H, &redh);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, AWB_R_GAIN_L, &redl);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, AWB_G_GAIN_H, &greenh);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, AWB_G_GAIN_L, &greenl);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, AWB_B_GAIN_H, &blueh);
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, AWB_B_GAIN_L, &bluel);
*r_gain_db = 20.0 * (fast_log(((redh & 0xF) << 8) | redl) / fast_log(10.0));
*g_gain_db = 20.0 * (fast_log(((greenh & 0xF) << 8) | greenl) / fast_log(10.0));
@ -858,11 +858,11 @@ static int get_rgb_gain_db(sensor_t *sensor, float *r_gain_db, float *g_gain_db,
static int set_hmirror(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb2(sensor->slv_addr, TIMING_TC_REG_21, &reg);
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_21, &reg);
if (enable){
ret |= cambus_writeb2(sensor->slv_addr, TIMING_TC_REG_21, reg|0x06);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_21, reg|0x06);
} else {
ret |= cambus_writeb2(sensor->slv_addr, TIMING_TC_REG_21, reg&0xF9);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_21, reg&0xF9);
}
return ret;
}
@ -870,11 +870,11 @@ static int set_hmirror(sensor_t *sensor, int enable)
static int set_vflip(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb2(sensor->slv_addr, TIMING_TC_REG_20, &reg);
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_20, &reg);
if (!enable){
ret |= cambus_writeb2(sensor->slv_addr, TIMING_TC_REG_20, reg|0x06);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_20, reg|0x06);
} else {
ret |= cambus_writeb2(sensor->slv_addr, TIMING_TC_REG_20, reg&0xF9);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_20, reg&0xF9);
}
return ret;
}
@ -885,22 +885,22 @@ static int set_special_effect(sensor_t *sensor, sde_t sde)
switch (sde) {
case SDE_NEGATIVE:
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0x03); // start group 3
ret |= cambus_writeb2(sensor->slv_addr, 0x5580, 0x40);
ret |= cambus_writeb2(sensor->slv_addr, 0x5003, 0x08);
ret |= cambus_writeb2(sensor->slv_addr, 0x5583, 0x40); // sat U
ret |= cambus_writeb2(sensor->slv_addr, 0x5584, 0x10); // sat V
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0x13); // end group 3
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0xa3); // latch group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0x03); // start group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5580, 0x40);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5003, 0x08);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5583, 0x40); // sat U
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5584, 0x10); // sat V
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0x13); // end group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0xa3); // latch group 3
break;
case SDE_NORMAL:
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0x03); // start group 3
ret |= cambus_writeb2(sensor->slv_addr, 0x5580, 0x06);
ret |= cambus_writeb2(sensor->slv_addr, 0x5583, 0x40); // sat U
ret |= cambus_writeb2(sensor->slv_addr, 0x5584, 0x10); // sat V
ret |= cambus_writeb2(sensor->slv_addr, 0x5003, 0x08);
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0x13); // end group 3
ret |= cambus_writeb2(sensor->slv_addr, 0x3212, 0xa3); // latch group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0x03); // start group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5580, 0x06);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5583, 0x40); // sat U
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5584, 0x10); // sat V
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x5003, 0x08);
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0x13); // end group 3
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, 0x3212, 0xa3); // latch group 3
break;
default:
return -1;
@ -912,8 +912,8 @@ static int set_special_effect(sensor_t *sensor, sde_t sde)
static int set_lens_correction(sensor_t *sensor, int enable, int radi, int coef)
{
uint8_t reg;
int ret = cambus_readb2(sensor->slv_addr, ISP_CONTROL_00, &reg);
return cambus_writeb2(sensor->slv_addr, ISP_CONTROL_00, (reg & 0x7F) | (enable ? 0x80 : 0x00)) | ret;
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, ISP_CONTROL_00, &reg);
return cambus_writeb2(&sensor->i2c, sensor->slv_addr, ISP_CONTROL_00, (reg & 0x7F) | (enable ? 0x80 : 0x00)) | ret;
}
int ov5640_init(sensor_t *sensor)

View File

@ -184,14 +184,14 @@ static const uint8_t contrast_regs[NUM_CONTRAST_LEVELS][1] = {
static int reset(sensor_t *sensor)
{
// Reset all registers
int ret = cambus_writeb(sensor->slv_addr, REG12, 0x80);
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, REG12, 0x80);
// Delay 2 ms
systick_sleep(2);
// Write default regsiters
for (int i = 0; default_regs[i][0]; i++) {
ret |= cambus_writeb(sensor->slv_addr, default_regs[i][0], default_regs[i][1]);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, default_regs[i][0], default_regs[i][1]);
}
// Delay 300 ms
@ -203,7 +203,7 @@ static int reset(sensor_t *sensor)
static int sleep(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG0E, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG0E, &reg);
if (enable) {
reg |= 0x8;
@ -212,13 +212,13 @@ static int sleep(sensor_t *sensor, int enable)
}
// Write back register
return cambus_writeb(sensor->slv_addr, REG0E, reg) | ret;
return cambus_writeb(&sensor->i2c, sensor->slv_addr, REG0E, reg) | ret;
}
static int read_reg(sensor_t *sensor, uint16_t reg_addr)
{
uint8_t reg_data;
if (cambus_readb(sensor->slv_addr, reg_addr, &reg_data) != 0) {
if (cambus_readb(&sensor->i2c, sensor->slv_addr, reg_addr, &reg_data) != 0) {
return -1;
}
return reg_data;
@ -226,7 +226,7 @@ static int read_reg(sensor_t *sensor, uint16_t reg_addr)
static int write_reg(sensor_t *sensor, uint16_t reg_addr, uint16_t reg_data)
{
return cambus_writeb(sensor->slv_addr, reg_addr, reg_data);
return cambus_writeb(&sensor->i2c, sensor->slv_addr, reg_addr, reg_data);
}
static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
@ -236,31 +236,31 @@ static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
}
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG12, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG12, &reg);
switch (pixformat) {
case PIXFORMAT_RGB565:
reg = (reg & 0xFC) | 0x2;
ret |= cambus_writeb(sensor->slv_addr, REG3E, 0x30);
ret |= cambus_writeb(sensor->slv_addr, REG82, 0x07);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG3E, 0x30);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG82, 0x07);
break;
case PIXFORMAT_YUV422:
case PIXFORMAT_GRAYSCALE:
reg = (reg & 0xFC) | 0x0;
ret |= cambus_writeb(sensor->slv_addr, REG3E, 0x30);
ret |= cambus_writeb(sensor->slv_addr, REG82, 0x07);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG3E, 0x30);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG82, 0x07);
break;
case PIXFORMAT_BAYER:
reg = (reg & 0xFC) | 0x1;
ret |= cambus_writeb(sensor->slv_addr, REG3E, 0x20);
ret |= cambus_writeb(sensor->slv_addr, REG82, 0x00);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG3E, 0x20);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG82, 0x00);
break;
default:
return -1;
}
// Write back register
return cambus_writeb(sensor->slv_addr, REG12, reg) | ret;
return cambus_writeb(&sensor->i2c, sensor->slv_addr, REG12, reg) | ret;
}
static int set_framesize(sensor_t *sensor, framesize_t framesize)
@ -277,35 +277,35 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize)
if ((w <= 320) && (h <= 240)) {
// Set QVGA Resolution
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG12, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG12, &reg);
reg = (reg & 0xBF) | 0x40;
ret |= cambus_writeb(sensor->slv_addr, REG12, reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG12, reg);
// Set QVGA Window Size
ret |= cambus_writeb(sensor->slv_addr, REG19, 0x03);
ret |= cambus_writeb(sensor->slv_addr, REGC8, 0x02);
ret |= cambus_writeb(sensor->slv_addr, REGC9, 0x80);
ret |= cambus_writeb(sensor->slv_addr, REGCA, 0x00);
ret |= cambus_writeb(sensor->slv_addr, REGCB, 0xF0);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG19, 0x03);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGC8, 0x02);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGC9, 0x80);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGCA, 0x00);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGCB, 0xF0);
} else {
// Set VGA Resolution
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG12, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG12, &reg);
reg = (reg & 0xBF) | 0x00;
ret |= cambus_writeb(sensor->slv_addr, REG12, reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG12, reg);
// Set VGA Window Size
ret |= cambus_writeb(sensor->slv_addr, REG19, 0x0b);
ret |= cambus_writeb(sensor->slv_addr, REGC8, 0x02);
ret |= cambus_writeb(sensor->slv_addr, REGC9, 0x80);
ret |= cambus_writeb(sensor->slv_addr, REGCA, 0x01);
ret |= cambus_writeb(sensor->slv_addr, REGCB, 0xE0);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG19, 0x0b);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGC8, 0x02);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGC9, 0x80);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGCA, 0x01);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGCB, 0xE0);
}
ret |= cambus_writeb(sensor->slv_addr, REGCC, w>>8);
ret |= cambus_writeb(sensor->slv_addr, REGCD, w);
ret |= cambus_writeb(sensor->slv_addr, REGCE, h>>8);
ret |= cambus_writeb(sensor->slv_addr, REGCF, h);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGCC, w>>8);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGCD, w);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGCE, h>>8);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGCF, h);
return ret;
}
@ -319,13 +319,13 @@ static int set_contrast(sensor_t *sensor, int level)
return -1;
}
ret |= cambus_writeb(sensor->slv_addr, 0xd5, 0x20);
ret |= cambus_writeb(sensor->slv_addr, 0xd4, 0x10 + (4 * new_level));
ret |= cambus_writeb(sensor->slv_addr, 0xd3, contrast_regs[new_level][0]);
ret |= cambus_readb(sensor->slv_addr, REGD2, &reg);
ret |= cambus_writeb(sensor->slv_addr, REGD2, (reg & 0xFB) | ((level != 0) << 2));
ret |= cambus_readb(sensor->slv_addr, 0xdc, &reg);
ret |= cambus_writeb(sensor->slv_addr, 0xdc, (level < 0) ? (reg | 0x04) : (reg & 0xFB));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, 0xd5, 0x20);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, 0xd4, 0x10 + (4 * new_level));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, 0xd3, contrast_regs[new_level][0]);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REGD2, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGD2, (reg & 0xFB) | ((level != 0) << 2));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, 0xdc, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, 0xdc, (level < 0) ? (reg | 0x04) : (reg & 0xFB));
return ret;
}
@ -343,21 +343,21 @@ static int set_saturation(sensor_t *sensor, int level)
return -1;
}
ret |= cambus_writeb(sensor->slv_addr, REGD8, 0x10 * new_level);
ret |= cambus_writeb(sensor->slv_addr, REGD9, 0x10 * new_level);
ret |= cambus_readb(sensor->slv_addr, REGD2, &reg);
ret |= cambus_writeb(sensor->slv_addr, REGD2, (reg & 0xFD) | ((level != 0) << 1));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGD8, 0x10 * new_level);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGD9, 0x10 * new_level);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REGD2, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGD2, (reg & 0xFD) | ((level != 0) << 1));
return ret;
}
static int set_gainceiling(sensor_t *sensor, gainceiling_t gainceiling)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG14, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG14, &reg);
// Set gain ceiling
reg = (reg & 0x8F) | (gainceiling << 4);
return cambus_writeb(sensor->slv_addr, REG14, reg) | ret;
return cambus_writeb(&sensor->i2c, sensor->slv_addr, REG14, reg) | ret;
}
static int set_quality(sensor_t *sensor, int qs)
@ -368,18 +368,18 @@ static int set_quality(sensor_t *sensor, int qs)
static int set_colorbar(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG82, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG82, &reg);
// Enable colorbars
reg = (reg & 0xF7) | ((enable != 0) << 3);
return cambus_writeb(sensor->slv_addr, REG82, reg) | ret;
return cambus_writeb(&sensor->i2c, sensor->slv_addr, REG82, reg) | ret;
}
static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain_db_ceiling)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG13, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG13, (reg & 0xFB) | ((enable != 0) << 2));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG13, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG13, (reg & 0xFB) | ((enable != 0) << 2));
if ((enable == 0) && (!isnanf(gain_db)) && (!isinff(gain_db))) {
float gain = IM_MAX(IM_MIN(fast_expf((gain_db / 20.0) * fast_log(10.0)), 128.0), 1.0);
@ -388,14 +388,14 @@ static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain
int gain_hi = 0x3F >> (6 - gain_temp);
int gain_lo = IM_MIN(fast_roundf(((gain / (1 << gain_temp)) - 1.0) * 16.0), 15);
ret |= cambus_writeb(sensor->slv_addr, GAIN, (gain_hi << 4) | (gain_lo << 0));
ret |= cambus_readb(sensor->slv_addr, REG15, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG15, (reg & 0xFC) | (gain_hi >> 4));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, GAIN, (gain_hi << 4) | (gain_lo << 0));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG15, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG15, (reg & 0xFC) | (gain_hi >> 4));
} else if ((enable != 0) && (!isnanf(gain_db_ceiling)) && (!isinff(gain_db_ceiling))) {
float gain_ceiling = IM_MAX(IM_MIN(fast_expf((gain_db_ceiling / 20.0) * fast_log(10.0)), 128.0), 2.0);
ret |= cambus_readb(sensor->slv_addr, REG14, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG14, (reg & 0x8F) | ((fast_ceilf(fast_log2(gain_ceiling)) - 1) << 4));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG14, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG14, (reg & 0x8F) | ((fast_ceilf(fast_log2(gain_ceiling)) - 1) << 4));
}
return ret;
@ -406,8 +406,8 @@ static int get_gain_db(sensor_t *sensor, float *gain_db)
uint8_t gain, reg15;
int ret=0;
ret |= cambus_readb(sensor->slv_addr, GAIN, &gain);
ret |= cambus_readb(sensor->slv_addr, REG15, &reg15);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, GAIN, &gain);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG15, &reg15);
int hi_gain = 1 << (((reg15 >> 1) & 1) + ((reg15 >> 0) & 1) + ((gain >> 7) & 1) + ((gain >> 6) & 1) + ((gain >> 5) & 1) + ((gain >> 4) & 1));
float lo_gain = 1.0 + (((gain >> 0) & 0xF) / 16.0);
@ -419,17 +419,17 @@ static int get_gain_db(sensor_t *sensor, float *gain_db)
static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG13, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG13, (reg & 0xFE) | ((enable != 0) << 0));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG13, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG13, (reg & 0xFE) | ((enable != 0) << 0));
if ((enable == 0) && (exposure_us >= 0)) {
ret |= cambus_readb(sensor->slv_addr, REG12, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG12, &reg);
int t_line = (reg & 0x40) ? (320 + 456) : (640 + 136);
ret |= cambus_readb(sensor->slv_addr, REG3E, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG3E, &reg);
int t_pclk = (reg & 0x10) ? 2 : 1;
ret |= cambus_readb(sensor->slv_addr, PLL, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, PLL, &reg);
int pll_div = reg >> 6, pll_mult = 1;
switch ((reg >> 4) & 0x3) {
@ -439,7 +439,7 @@ static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
case 3: pll_mult = 8; break;
}
ret |= cambus_readb(sensor->slv_addr, CLKRC, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CLKRC, &reg);
int clk_rc;
if (reg & 0x40) {
@ -450,8 +450,8 @@ static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
int exposure = IM_MAX(IM_MIN(((exposure_us*((((OV7690_XCLK_FREQ/clk_rc)*pll_mult)/pll_div)/1000000))/t_pclk)/t_line,0xFFFF),0x0000);
ret |= cambus_writeb(sensor->slv_addr, AECL, ((exposure >> 0) & 0xFF));
ret |= cambus_writeb(sensor->slv_addr, AECH, ((exposure >> 8) & 0xFF));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, AECL, ((exposure >> 0) & 0xFF));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, AECH, ((exposure >> 8) & 0xFF));
}
return ret;
@ -462,16 +462,16 @@ static int get_exposure_us(sensor_t *sensor, int *exposure_us)
uint8_t aec_l, aec_h, reg;
int ret=0;
ret |= cambus_readb(sensor->slv_addr, AECL, &aec_l);
ret |= cambus_readb(sensor->slv_addr, AECH, &aec_h);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, AECL, &aec_l);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, AECH, &aec_h);
ret |= cambus_readb(sensor->slv_addr, REG12, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG12, &reg);
int t_line = (reg & 0x40) ? (320 + 456) : (640 + 136);
ret |= cambus_readb(sensor->slv_addr, REG3E, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG3E, &reg);
int t_pclk = (reg & 0x10) ? 2 : 1;
ret |= cambus_readb(sensor->slv_addr, PLL, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, PLL, &reg);
int pll_div = reg >> 6, pll_mult = 1;
switch ((reg >> 4) & 0x3) {
@ -481,7 +481,7 @@ static int get_exposure_us(sensor_t *sensor, int *exposure_us)
case 3: pll_mult = 8; break;
}
ret |= cambus_readb(sensor->slv_addr, CLKRC, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CLKRC, &reg);
int clk_rc;
if (reg & 0x40) {
@ -498,8 +498,8 @@ static int get_exposure_us(sensor_t *sensor, int *exposure_us)
static int set_auto_whitebal(sensor_t *sensor, int enable, float r_gain_db, float g_gain_db, float b_gain_db)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG13, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG13, (reg & 0xFD) | ((enable != 0) << 1));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG13, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG13, (reg & 0xFD) | ((enable != 0) << 1));
if ((enable == 0) && (!isnanf(r_gain_db)) && (!isnanf(g_gain_db)) && (!isnanf(b_gain_db))
&& (!isinff(r_gain_db)) && (!isinff(g_gain_db)) && (!isinff(b_gain_db))) {
@ -508,9 +508,9 @@ static int set_auto_whitebal(sensor_t *sensor, int enable, float r_gain_db, floa
int g_gain = IM_MAX(IM_MIN(fast_roundf(fast_expf((g_gain_db / 20.0) * fast_log(10.0))), 255), 0);
int b_gain = IM_MAX(IM_MIN(fast_roundf(fast_expf((b_gain_db / 20.0) * fast_log(10.0))), 255), 0);
ret |= cambus_writeb(sensor->slv_addr, BGAIN, b_gain);
ret |= cambus_writeb(sensor->slv_addr, RGAIN, r_gain);
ret |= cambus_writeb(sensor->slv_addr, GGAIN, g_gain);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BGAIN, b_gain);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, RGAIN, r_gain);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, GGAIN, g_gain);
}
return ret;
@ -521,9 +521,9 @@ static int get_rgb_gain_db(sensor_t *sensor, float *r_gain_db, float *g_gain_db,
uint8_t blue, red, green;
int ret=0;
ret |= cambus_readb(sensor->slv_addr, BGAIN, &blue);
ret |= cambus_readb(sensor->slv_addr, RGAIN, &red);
ret |= cambus_readb(sensor->slv_addr, GGAIN, &green);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, BGAIN, &blue);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, RGAIN, &red);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, GGAIN, &green);
*r_gain_db = 20.0 * (fast_log(red) / fast_log(10.0));
*g_gain_db = 20.0 * (fast_log(green) / fast_log(10.0));
@ -535,8 +535,8 @@ static int get_rgb_gain_db(sensor_t *sensor, float *r_gain_db, float *g_gain_db,
static int set_hmirror(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG0C, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG0C, (reg & 0xBF) | ((enable == 0) << 6));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG0C, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG0C, (reg & 0xBF) | ((enable == 0) << 6));
return ret;
}
@ -544,8 +544,8 @@ static int set_hmirror(sensor_t *sensor, int enable)
static int set_vflip(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG0C, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG0C, (reg & 0x7F) | ((enable == 0) << 7));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG0C, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG0C, (reg & 0x7F) | ((enable == 0) << 7));
return ret;
}
@ -556,10 +556,10 @@ static int set_special_effect(sensor_t *sensor, sde_t sde)
switch (sde) {
case SDE_NEGATIVE:
ret |= cambus_writeb(sensor->slv_addr, 0x28, 0x80);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, 0x28, 0x80);
break;
case SDE_NORMAL:
ret |= cambus_writeb(sensor->slv_addr, 0x28, 0x00);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, 0x28, 0x00);
break;
default:
return -1;
@ -572,11 +572,11 @@ static int set_lens_correction(sensor_t *sensor, int enable, int radi, int coef)
{
int ret=0;
ret |= cambus_writeb(sensor->slv_addr, LCC0, (enable != 0) << 4);
ret |= cambus_writeb(sensor->slv_addr, LCC1, radi);
ret |= cambus_writeb(sensor->slv_addr, LCC4, coef);
ret |= cambus_writeb(sensor->slv_addr, LCC5, coef);
ret |= cambus_writeb(sensor->slv_addr, LCC6, coef);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, LCC0, (enable != 0) << 4);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, LCC1, radi);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, LCC4, coef);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, LCC5, coef);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, LCC6, coef);
return ret;
}

View File

@ -150,14 +150,14 @@ static const uint8_t saturation_regs[NUM_SATURATION_LEVELS][2] = {
static int reset(sensor_t *sensor)
{
// Reset all registers
int ret = cambus_writeb(sensor->slv_addr, COM7, COM7_RESET);
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, COM7, COM7_RESET);
// Delay 2 ms
systick_sleep(2);
// Write default regsiters
for (int i = 0; default_regs[i][0]; i++) {
ret |= cambus_writeb(sensor->slv_addr, default_regs[i][0], default_regs[i][1]);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, default_regs[i][0], default_regs[i][1]);
}
// Delay 300 ms
@ -169,7 +169,7 @@ static int reset(sensor_t *sensor)
static int sleep(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, COM2, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM2, &reg);
if (enable) {
reg |= COM2_SOFT_SLEEP;
@ -178,13 +178,13 @@ static int sleep(sensor_t *sensor, int enable)
}
// Write back register
return cambus_writeb(sensor->slv_addr, COM2, reg) | ret;
return cambus_writeb(&sensor->i2c, sensor->slv_addr, COM2, reg) | ret;
}
static int read_reg(sensor_t *sensor, uint16_t reg_addr)
{
uint8_t reg_data;
if (cambus_readb(sensor->slv_addr, reg_addr, &reg_data) != 0) {
if (cambus_readb(&sensor->i2c, sensor->slv_addr, reg_addr, &reg_data) != 0) {
return -1;
}
return reg_data;
@ -192,34 +192,34 @@ static int read_reg(sensor_t *sensor, uint16_t reg_addr)
static int write_reg(sensor_t *sensor, uint16_t reg_addr, uint16_t reg_data)
{
return cambus_writeb(sensor->slv_addr, reg_addr, reg_data);
return cambus_writeb(&sensor->i2c, sensor->slv_addr, reg_addr, reg_data);
}
static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, COM7, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, &reg);
switch (pixformat) {
case PIXFORMAT_RGB565:
reg = COM7_SET_FMT(reg, COM7_FMT_RGB);
ret |= cambus_writeb(sensor->slv_addr, DSP_CTRL4, DSP_CTRL4_YUV_RGB);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, DSP_CTRL4, DSP_CTRL4_YUV_RGB);
break;
case PIXFORMAT_YUV422:
case PIXFORMAT_GRAYSCALE:
reg = COM7_SET_FMT(reg, COM7_FMT_YUV);
ret |= cambus_writeb(sensor->slv_addr, DSP_CTRL4, DSP_CTRL4_YUV_RGB);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, DSP_CTRL4, DSP_CTRL4_YUV_RGB);
break;
case PIXFORMAT_BAYER:
reg = COM7_SET_FMT(reg, COM7_FMT_P_BAYER);
ret |= cambus_writeb(sensor->slv_addr, DSP_CTRL4, DSP_CTRL4_RAW8);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, DSP_CTRL4, DSP_CTRL4_RAW8);
break;
default:
return -1;
}
// Write back register
return cambus_writeb(sensor->slv_addr, COM7, reg) | ret;
return cambus_writeb(&sensor->i2c, sensor->slv_addr, COM7, reg) | ret;
}
static int set_framesize(sensor_t *sensor, framesize_t framesize)
@ -229,47 +229,47 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize)
uint16_t h = resolution[framesize][1];
// Write MSBs
ret |= cambus_writeb(sensor->slv_addr, HOUTSIZE, w>>2);
ret |= cambus_writeb(sensor->slv_addr, VOUTSIZE, h>>1);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, HOUTSIZE, w>>2);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, VOUTSIZE, h>>1);
// Write LSBs
ret |= cambus_writeb(sensor->slv_addr, EXHCH, ((w&0x3) | ((h&0x1) << 2)));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, EXHCH, ((w&0x3) | ((h&0x1) << 2)));
if ((w <= 320) && (h <= 240)) {
// Set QVGA Resolution
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, COM7, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, &reg);
reg = COM7_SET_RES(reg, COM7_RES_QVGA);
ret |= cambus_writeb(sensor->slv_addr, COM7, reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM7, reg);
// Set QVGA Window Size
ret |= cambus_writeb(sensor->slv_addr, HSTART, 0x3F);
ret |= cambus_writeb(sensor->slv_addr, HSIZE, 0x50);
ret |= cambus_writeb(sensor->slv_addr, VSTART, 0x03);
ret |= cambus_writeb(sensor->slv_addr, VSIZE, 0x78);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, HSTART, 0x3F);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, HSIZE, 0x50);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, VSTART, 0x03);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, VSIZE, 0x78);
// Enable auto-scaling/zooming factors
ret |= cambus_writeb(sensor->slv_addr, DSPAUTO, 0xFF);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, DSPAUTO, 0xFF);
} else {
// Set VGA Resolution
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, COM7, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, &reg);
reg = COM7_SET_RES(reg, COM7_RES_VGA);
ret |= cambus_writeb(sensor->slv_addr, COM7, reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM7, reg);
// Set VGA Window Size
ret |= cambus_writeb(sensor->slv_addr, HSTART, 0x23);
ret |= cambus_writeb(sensor->slv_addr, HSIZE, 0xA0);
ret |= cambus_writeb(sensor->slv_addr, VSTART, 0x07);
ret |= cambus_writeb(sensor->slv_addr, VSIZE, 0xF0);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, HSTART, 0x23);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, HSIZE, 0xA0);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, VSTART, 0x07);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, VSIZE, 0xF0);
// Disable auto-scaling/zooming factors
ret |= cambus_writeb(sensor->slv_addr, DSPAUTO, 0xF3);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, DSPAUTO, 0xF3);
// Clear auto-scaling/zooming factors
ret |= cambus_writeb(sensor->slv_addr, SCAL0, 0x00);
ret |= cambus_writeb(sensor->slv_addr, SCAL1, 0x40);
ret |= cambus_writeb(sensor->slv_addr, SCAL2, 0x40);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, SCAL0, 0x00);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, SCAL1, 0x40);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, SCAL2, 0x40);
}
return ret;
@ -282,7 +282,7 @@ static int set_contrast(sensor_t *sensor, int level)
return -1;
}
return cambus_writeb(sensor->slv_addr, CONTRAST, contrast_regs[level][0]);
return cambus_writeb(&sensor->i2c, sensor->slv_addr, CONTRAST, contrast_regs[level][0]);
}
static int set_brightness(sensor_t *sensor, int level)
@ -293,8 +293,8 @@ static int set_brightness(sensor_t *sensor, int level)
return -1;
}
ret |= cambus_writeb(sensor->slv_addr, BRIGHTNESS, brightness_regs[level][0]);
ret |= cambus_writeb(sensor->slv_addr, SIGN_BIT, brightness_regs[level][1]);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BRIGHTNESS, brightness_regs[level][0]);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, SIGN_BIT, brightness_regs[level][1]);
return ret;
}
@ -306,41 +306,41 @@ static int set_saturation(sensor_t *sensor, int level)
return -1;
}
ret |= cambus_writeb(sensor->slv_addr, USAT, saturation_regs[level][0]);
ret |= cambus_writeb(sensor->slv_addr, VSAT, saturation_regs[level][1]);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, USAT, saturation_regs[level][0]);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, VSAT, saturation_regs[level][1]);
return ret;
}
static int set_gainceiling(sensor_t *sensor, gainceiling_t gainceiling)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, COM9, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM9, &reg);
// Set gain ceiling
reg = COM9_SET_AGC(reg, gainceiling);
return cambus_writeb(sensor->slv_addr, COM9, reg) | ret;
return cambus_writeb(&sensor->i2c, sensor->slv_addr, COM9, reg) | ret;
}
static int set_colorbar(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, COM3, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM3, &reg);
// Enable colorbar test pattern output
reg = COM3_SET_CBAR(reg, enable);
ret |= cambus_writeb(sensor->slv_addr, COM3, reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM3, reg);
// Enable DSP colorbar output
ret |= cambus_readb(sensor->slv_addr, DSP_CTRL3, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, DSP_CTRL3, &reg);
reg = DSP_CTRL3_SET_CBAR(reg, enable);
return cambus_writeb(sensor->slv_addr, DSP_CTRL3, reg) | ret;
return cambus_writeb(&sensor->i2c, sensor->slv_addr, DSP_CTRL3, reg) | ret;
}
static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain_db_ceiling)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, COM8, &reg);
ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AGC(reg, (enable != 0)));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, COM8_SET_AGC(reg, (enable != 0)));
if ((enable == 0) && (!isnanf(gain_db)) && (!isinff(gain_db))) {
float gain = IM_MAX(IM_MIN(fast_expf((gain_db / 20.0) * fast_log(10.0)), 32.0), 1.0);
@ -349,12 +349,12 @@ static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain
int gain_hi = 0xF >> (4 - gain_temp);
int gain_lo = IM_MIN(fast_roundf(((gain / (1 << gain_temp)) - 1.0) * 16.0), 15);
ret |= cambus_writeb(sensor->slv_addr, GAIN, (gain_hi << 4) | (gain_lo << 0));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, GAIN, (gain_hi << 4) | (gain_lo << 0));
} else if ((enable != 0) && (!isnanf(gain_db_ceiling)) && (!isinff(gain_db_ceiling))) {
float gain_ceiling = IM_MAX(IM_MIN(fast_expf((gain_db_ceiling / 20.0) * fast_log(10.0)), 32.0), 2.0);
ret |= cambus_readb(sensor->slv_addr, COM9, &reg);
ret |= cambus_writeb(sensor->slv_addr, COM9, (reg & 0x8F) | ((fast_ceilf(fast_log2(gain_ceiling)) - 1) << 4));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM9, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM9, (reg & 0x8F) | ((fast_ceilf(fast_log2(gain_ceiling)) - 1) << 4));
}
return ret;
@ -363,19 +363,19 @@ static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain
static int get_gain_db(sensor_t *sensor, float *gain_db)
{
uint8_t reg, gain;
int ret = cambus_readb(sensor->slv_addr, COM8, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, &reg);
// DISABLED
// if (reg & COM8_AGC_EN) {
// ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AGC(reg, 0));
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, COM8_SET_AGC(reg, 0));
// }
// DISABLED
ret |= cambus_readb(sensor->slv_addr, GAIN, &gain);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, GAIN, &gain);
// DISABLED
// if (reg & COM8_AGC_EN) {
// ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AGC(reg, 1));
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, COM8_SET_AGC(reg, 1));
// }
// DISABLED
@ -389,16 +389,16 @@ static int get_gain_db(sensor_t *sensor, float *gain_db)
static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, COM8, &reg);
ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AEC(reg, (enable != 0)));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, COM8_SET_AEC(reg, (enable != 0)));
if ((enable == 0) && (exposure_us >= 0)) {
ret |= cambus_readb(sensor->slv_addr, COM7, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, &reg);
int t_line = (reg & COM7_RES_QVGA) ? (320 + 256) : (640 + 144);
int t_pclk = (COM7_GET_FMT(reg) == COM7_FMT_P_BAYER) ? 1 : 2;
ret |= cambus_readb(sensor->slv_addr, COM4, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM4, &reg);
int pll_mult = 0;
if (COM4_GET_PLL(reg) == COM4_PLL_BYPASS) pll_mult = 1;
@ -406,7 +406,7 @@ static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
if (COM4_GET_PLL(reg) == COM4_PLL_6x) pll_mult = 6;
if (COM4_GET_PLL(reg) == COM4_PLL_8x) pll_mult = 8;
ret |= cambus_readb(sensor->slv_addr, CLKRC, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CLKRC, &reg);
int clk_rc = 0;
if (reg & CLKRC_NO_PRESCALE) {
@ -417,8 +417,8 @@ static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
int exposure = IM_MAX(IM_MIN(((exposure_us*(((OMV_XCLK_FREQUENCY/clk_rc)*pll_mult)/1000000))/t_pclk)/t_line,0xFFFF),0x0000);
ret |= cambus_writeb(sensor->slv_addr, AEC, ((exposure >> 0) & 0xFF));
ret |= cambus_writeb(sensor->slv_addr, AECH, ((exposure >> 8) & 0xFF));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, AEC, ((exposure >> 0) & 0xFF));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, AECH, ((exposure >> 8) & 0xFF));
}
return ret;
@ -427,29 +427,29 @@ static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
static int get_exposure_us(sensor_t *sensor, int *exposure_us)
{
uint8_t reg, aec_l, aec_h;
int ret = cambus_readb(sensor->slv_addr, COM8, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, &reg);
// DISABLED
// if (reg & COM8_AEC_EN) {
// ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AEC(reg, 0));
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, COM8_SET_AEC(reg, 0));
// }
// DISABLED
ret |= cambus_readb(sensor->slv_addr, AEC, &aec_l);
ret |= cambus_readb(sensor->slv_addr, AECH, &aec_h);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, AEC, &aec_l);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, AECH, &aec_h);
// DISABLED
// if (reg & COM8_AEC_EN) {
// ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AEC(reg, 1));
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, COM8_SET_AEC(reg, 1));
// }
// DISABLED
ret |= cambus_readb(sensor->slv_addr, COM7, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, &reg);
int t_line = (reg & COM7_RES_QVGA) ? (320 + 256) : (640 + 144);
int t_pclk = (COM7_GET_FMT(reg) == COM7_FMT_P_BAYER) ? 1 : 2;
ret |= cambus_readb(sensor->slv_addr, COM4, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM4, &reg);
int pll_mult = 0;
if (COM4_GET_PLL(reg) == COM4_PLL_BYPASS) pll_mult = 1;
@ -457,7 +457,7 @@ static int get_exposure_us(sensor_t *sensor, int *exposure_us)
if (COM4_GET_PLL(reg) == COM4_PLL_6x) pll_mult = 6;
if (COM4_GET_PLL(reg) == COM4_PLL_8x) pll_mult = 8;
ret |= cambus_readb(sensor->slv_addr, CLKRC, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CLKRC, &reg);
int clk_rc = 0;
if (reg & CLKRC_NO_PRESCALE) {
@ -474,21 +474,21 @@ static int get_exposure_us(sensor_t *sensor, int *exposure_us)
static int set_auto_whitebal(sensor_t *sensor, int enable, float r_gain_db, float g_gain_db, float b_gain_db)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, COM8, &reg);
ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AWB(reg, (enable != 0)));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, COM8_SET_AWB(reg, (enable != 0)));
if ((enable == 0) && (!isnanf(r_gain_db)) && (!isnanf(g_gain_db)) && (!isnanf(b_gain_db))
&& (!isinff(r_gain_db)) && (!isinff(g_gain_db)) && (!isinff(b_gain_db))) {
ret |= cambus_readb(sensor->slv_addr, AWB_CTRL1, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, AWB_CTRL1, &reg);
float gain_div = (reg & 0x2) ? 64.0 : 128.0;
int r_gain = IM_MAX(IM_MIN(fast_roundf(fast_expf((r_gain_db / 20.0) * fast_log(10.0)) * gain_div), 255), 0);
int g_gain = IM_MAX(IM_MIN(fast_roundf(fast_expf((g_gain_db / 20.0) * fast_log(10.0)) * gain_div), 255), 0);
int b_gain = IM_MAX(IM_MIN(fast_roundf(fast_expf((b_gain_db / 20.0) * fast_log(10.0)) * gain_div), 255), 0);
ret |= cambus_writeb(sensor->slv_addr, BLUE, b_gain);
ret |= cambus_writeb(sensor->slv_addr, RED, r_gain);
ret |= cambus_writeb(sensor->slv_addr, GREEN, g_gain);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BLUE, b_gain);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, RED, r_gain);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, GREEN, g_gain);
}
return ret;
@ -497,25 +497,25 @@ static int set_auto_whitebal(sensor_t *sensor, int enable, float r_gain_db, floa
static int get_rgb_gain_db(sensor_t *sensor, float *r_gain_db, float *g_gain_db, float *b_gain_db)
{
uint8_t reg, blue, red, green;
int ret = cambus_readb(sensor->slv_addr, COM8, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, &reg);
// DISABLED
// if (reg & COM8_AWB_EN) {
// ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AWB(reg, 0));
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, COM8_SET_AWB(reg, 0));
// }
// DISABLED
ret |= cambus_readb(sensor->slv_addr, BLUE, &blue);
ret |= cambus_readb(sensor->slv_addr, RED, &red);
ret |= cambus_readb(sensor->slv_addr, GREEN, &green);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, BLUE, &blue);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, RED, &red);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, GREEN, &green);
// DISABLED
// if (reg & COM8_AWB_EN) {
// ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AWB(reg, 1));
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM8, COM8_SET_AWB(reg, 1));
// }
// DISABLED
ret |= cambus_readb(sensor->slv_addr, AWB_CTRL1, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, AWB_CTRL1, &reg);
float gain_div = (reg & 0x2) ? 64.0 : 128.0;
*r_gain_db = 20.0 * (fast_log(red / gain_div) / fast_log(10.0));
@ -528,8 +528,8 @@ static int get_rgb_gain_db(sensor_t *sensor, float *r_gain_db, float *g_gain_db,
static int set_hmirror(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, COM3, &reg);
ret |= cambus_writeb(sensor->slv_addr, COM3, COM3_SET_MIRROR(reg, enable)) ;
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM3, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM3, COM3_SET_MIRROR(reg, enable)) ;
return ret;
}
@ -537,8 +537,8 @@ static int set_hmirror(sensor_t *sensor, int enable)
static int set_vflip(sensor_t *sensor, int enable)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, COM3, &reg);
ret |= cambus_writeb(sensor->slv_addr, COM3, COM3_SET_FLIP(reg, enable));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM3, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, COM3, COM3_SET_FLIP(reg, enable));
return ret;
}
@ -549,12 +549,12 @@ static int set_special_effect(sensor_t *sensor, sde_t sde)
switch (sde) {
case SDE_NEGATIVE:
ret |= cambus_writeb(sensor->slv_addr, SDE, 0x46);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, SDE, 0x46);
break;
case SDE_NORMAL:
ret |= cambus_writeb(sensor->slv_addr, SDE, 0x06);
ret |= cambus_writeb(sensor->slv_addr, UFIX, 0x80);
ret |= cambus_writeb(sensor->slv_addr, VFIX, 0x80);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, SDE, 0x06);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, UFIX, 0x80);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, VFIX, 0x80);
break;
default:
return -1;
@ -567,9 +567,9 @@ static int set_lens_correction(sensor_t *sensor, int enable, int radi, int coef)
{
int ret=0;
ret |= cambus_writeb(sensor->slv_addr, LC_CTR, (enable&0x01));
ret |= cambus_writeb(sensor->slv_addr, LC_RADI, radi);
ret |= cambus_writeb(sensor->slv_addr, LC_COEF, coef);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, LC_CTR, (enable&0x01));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, LC_RADI, radi);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, LC_COEF, coef);
return ret;
}

View File

@ -205,14 +205,14 @@ static int reset(sensor_t *sensor)
const uint8_t (*regs)[2]=default_regs;
/* Reset all registers */
cambus_writeb(sensor->slv_addr, REG_COM7, 0x80);
cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM7, 0x80);
/* delay n ms */
systick_sleep(10);
/* Write initial regsiters */
while (regs[i][0]) {
cambus_writeb(sensor->slv_addr, regs[i][0], regs[i][1]);
cambus_writeb(&sensor->i2c, sensor->slv_addr, regs[i][0], regs[i][1]);
i++;
}
@ -226,7 +226,7 @@ static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
uint8_t com7=0; /* framesize/RGB */
/* read pixel format reg */
cambus_readb(sensor->slv_addr, REG_COM7, &com7);
cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM7, &com7);
switch (pixformat) {
case PIXFORMAT_RGB565:
@ -246,11 +246,11 @@ static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
}
/* Set pixel format */
cambus_writeb(sensor->slv_addr, REG_COM7, com7);
cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM7, com7);
/* Write pixel format registers */
while (regs[i][0]) {
cambus_writeb(sensor->slv_addr, regs[i][0], regs[i][1]);
cambus_writeb(&sensor->i2c, sensor->slv_addr, regs[i][0], regs[i][1]);
i++;
}
@ -263,7 +263,7 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize)
uint8_t com1=0; /* Skip option */
/* read COM7 RGB bit */
cambus_readb(sensor->slv_addr, REG_COM7, &com7);
cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM7, &com7);
com7 &= REG_COM7_RGB;
switch (framesize) {
@ -283,8 +283,8 @@ static int set_framesize(sensor_t *sensor, framesize_t framesize)
}
/* write the frame size registers */
cambus_writeb(sensor->slv_addr, REG_COM1, com1);
cambus_writeb(sensor->slv_addr, REG_COM7, com7);
cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM1, com1);
cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM7, com7);
return 0;
}
@ -310,7 +310,7 @@ static int set_brightness(sensor_t *sensor, int level)
}
for (i=0; i<3; i++) {
cambus_writeb(sensor->slv_addr, regs[0][i], regs[level][i]);
cambus_writeb(&sensor->i2c, sensor->slv_addr, regs[0][i], regs[level][i]);
}
return 0;
@ -319,15 +319,15 @@ static int set_brightness(sensor_t *sensor, int level)
static int set_gainceiling(sensor_t *sensor, gainceiling_t gainceiling)
{
/* Write gain ceiling register */
cambus_writeb(sensor->slv_addr, REG_COM9, (gainceiling<<4));
cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM9, (gainceiling<<4));
return 0;
}
static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain_db_ceiling)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG_COM8, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG_COM8, (reg & (~REG_COM8_AGC)) | ((enable != 0) ? REG_COM8_AGC : 0));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM8, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM8, (reg & (~REG_COM8_AGC)) | ((enable != 0) ? REG_COM8_AGC : 0));
if ((enable == 0) && (!isnanf(gain_db)) && (!isinf(gain_db))) {
float gain = IM_MAX(IM_MIN(fast_expf((gain_db / 20.0) * fast_log(10.0)), 128.0), 1.0);
@ -336,14 +336,14 @@ static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain
int gain_hi = 0x3F >> (6 - gain_temp);
int gain_lo = IM_MIN(fast_roundf(((gain / (1 << gain_temp)) - 1.0) * 16.0), 15);
ret |= cambus_writeb(sensor->slv_addr, REG_GAIN, ((gain_hi & 0x0F) << 4) | (gain_lo << 0));
ret |= cambus_readb(sensor->slv_addr, REG_VREF, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG_VREF, ((gain_hi & 0x30) << 2) | (reg & 0x3F));
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_GAIN, ((gain_hi & 0x0F) << 4) | (gain_lo << 0));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_VREF, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_VREF, ((gain_hi & 0x30) << 2) | (reg & 0x3F));
} else if ((enable != 0) && (!isnanf(gain_db_ceiling)) && (!isinf(gain_db_ceiling))) {
float gain_ceiling = IM_MAX(IM_MIN(fast_expf((gain_db_ceiling / 20.0) * fast_log(10.0)), 128.0), 2.0);
ret |= cambus_readb(sensor->slv_addr, REG_COM9, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG_COM9, (reg & 0x8F) | ((fast_ceilf(fast_log2(gain_ceiling)) - 1) << 4));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM9, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM9, (reg & 0x8F) | ((fast_ceilf(fast_log2(gain_ceiling)) - 1) << 4));
}
return ret;
@ -352,20 +352,20 @@ static int set_auto_gain(sensor_t *sensor, int enable, float gain_db, float gain
static int get_gain_db(sensor_t *sensor, float *gain_db)
{
uint8_t reg, gain_lo, gain_hi;
int ret = cambus_readb(sensor->slv_addr, REG_COM8, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM8, &reg);
// DISABLED
// if (reg & REG_COM8_AGC) {
// ret |= cambus_writeb(sensor->slv_addr, REG_COM8, reg & (~REG_COM8_AGC));
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM8, reg & (~REG_COM8_AGC));
// }
// DISABLED
ret |= cambus_readb(sensor->slv_addr, REG_GAIN, &gain_lo);
ret |= cambus_readb(sensor->slv_addr, REG_VREF, &gain_hi);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_GAIN, &gain_lo);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_VREF, &gain_hi);
// DISABLED
// if (reg & REG_COM8_AGC) {
// ret |= cambus_writeb(sensor->slv_addr, REG_COM8, reg | REG_COM8_AGC);
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM8, reg | REG_COM8_AGC);
// }
// DISABLED
@ -380,11 +380,11 @@ static int get_gain_db(sensor_t *sensor, float *gain_db)
static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG_COM8, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG_COM8, (reg & (~REG_COM8_AEC)) | ((enable != 0) ? REG_COM8_AEC : 0));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM8, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM8, (reg & (~REG_COM8_AEC)) | ((enable != 0) ? REG_COM8_AEC : 0));
if ((enable == 0) && (exposure_us >= 0)) {
ret |= cambus_readb(sensor->slv_addr, REG_COM7, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM7, &reg);
int t_line = 0, t_pclk = (reg & REG_COM7_RGB) ? 2 : 1;
if (reg & REG_COM7_VGA) t_line = 640 + 160;
@ -392,20 +392,20 @@ static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
if (reg & REG_COM7_QVGA) t_line = 320 + 80;
if (reg & REG_COM7_QCIF) t_line = 176 + 84;
ret |= cambus_readb(sensor->slv_addr, REG_CLKRC, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_CLKRC, &reg);
int pll_mult = (reg & REG_CLKRC_DOUBLE) ? 2 : 1;
int clk_rc = ((reg & REG_CLKRC_DIVIDER_MASK) + 1) * 2;
int exposure = IM_MAX(IM_MIN(((exposure_us*(((OMV_XCLK_FREQUENCY/clk_rc)*pll_mult)/1000000))/t_pclk)/t_line,0xFFFF),0x0000);
ret |= cambus_readb(sensor->slv_addr, REG_COM1, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG_COM1, (reg & 0xFC) | ((exposure >> 0) & 0x3));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM1, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM1, (reg & 0xFC) | ((exposure >> 0) & 0x3));
ret |= cambus_readb(sensor->slv_addr, REG_AECH, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG_AECH, (reg & 0x00) | ((exposure >> 2) & 0xFF));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_AECH, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_AECH, (reg & 0x00) | ((exposure >> 2) & 0xFF));
ret |= cambus_readb(sensor->slv_addr, REG_AECHM, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG_AECHM, (reg & 0xC0) | ((exposure >> 10) & 0x3F));
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_AECHM, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_AECHM, (reg & 0xC0) | ((exposure >> 10) & 0x3F));
}
return ret;
@ -414,25 +414,25 @@ static int set_auto_exposure(sensor_t *sensor, int enable, int exposure_us)
static int get_exposure_us(sensor_t *sensor, int *exposure_us)
{
uint8_t reg, aec_10, aec_92, aec_1510;
int ret = cambus_readb(sensor->slv_addr, REG_COM8, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM8, &reg);
// DISABLED
// if (reg & REG_COM8_AEC) {
// ret |= cambus_writeb(sensor->slv_addr, REG_COM8, reg & (~REG_COM8_AEC));
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM8, reg & (~REG_COM8_AEC));
// }
// DISABLED
ret |= cambus_readb(sensor->slv_addr, REG_COM1, &aec_10);
ret |= cambus_readb(sensor->slv_addr, REG_AECH, &aec_92);
ret |= cambus_readb(sensor->slv_addr, REG_AECHM, &aec_1510);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM1, &aec_10);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_AECH, &aec_92);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_AECHM, &aec_1510);
// DISABLED
// if (reg & REG_COM8_AEC) {
// ret |= cambus_writeb(sensor->slv_addr, REG_COM8, reg | REG_COM8_AEC);
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM8, reg | REG_COM8_AEC);
// }
// DISABLED
ret |= cambus_readb(sensor->slv_addr, REG_COM7, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM7, &reg);
int t_line = 0, t_pclk = (reg & REG_COM7_RGB) ? 2 : 1;
if (reg & REG_COM7_VGA) t_line = 640 + 160;
@ -440,7 +440,7 @@ static int get_exposure_us(sensor_t *sensor, int *exposure_us)
if (reg & REG_COM7_QVGA) t_line = 320 + 80;
if (reg & REG_COM7_QCIF) t_line = 176 + 84;
ret |= cambus_readb(sensor->slv_addr, REG_CLKRC, &reg);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_CLKRC, &reg);
int pll_mult = (reg & REG_CLKRC_DOUBLE) ? 2 : 1;
int clk_rc = ((reg & REG_CLKRC_DIVIDER_MASK) + 1) * 2;
@ -453,16 +453,16 @@ static int get_exposure_us(sensor_t *sensor, int *exposure_us)
static int set_auto_whitebal(sensor_t *sensor, int enable, float r_gain_db, float g_gain_db, float b_gain_db)
{
uint8_t reg;
int ret = cambus_readb(sensor->slv_addr, REG_COM8, &reg);
ret |= cambus_writeb(sensor->slv_addr, REG_COM8, (reg & (~REG_COM8_AWB)) | ((enable != 0) ? REG_COM8_AWB : 0));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM8, &reg);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM8, (reg & (~REG_COM8_AWB)) | ((enable != 0) ? REG_COM8_AWB : 0));
if ((enable == 0) && (!isnanf(r_gain_db)) && (!isnanf(g_gain_db)) && (!isnanf(b_gain_db))
&& (!isinff(r_gain_db)) && (!isinff(g_gain_db)) && (!isinff(b_gain_db))) {
int r_gain = IM_MAX(IM_MIN(fast_roundf(fast_expf((r_gain_db / 20.0) * fast_log(10.0)) * 128.0), 255), 0);
int b_gain = IM_MAX(IM_MIN(fast_roundf(fast_expf((b_gain_db / 20.0) * fast_log(10.0)) * 128.0), 255), 0);
ret |= cambus_writeb(sensor->slv_addr, REG_BLUE, b_gain);
ret |= cambus_writeb(sensor->slv_addr, REG_RED, r_gain);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_BLUE, b_gain);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_RED, r_gain);
}
return ret;
@ -471,20 +471,20 @@ static int set_auto_whitebal(sensor_t *sensor, int enable, float r_gain_db, floa
static int get_rgb_gain_db(sensor_t *sensor, float *r_gain_db, float *g_gain_db, float *b_gain_db)
{
uint8_t reg, blue, red;
int ret = cambus_readb(sensor->slv_addr, REG_COM8, &reg);
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM8, &reg);
// DISABLED
// if (reg & REG_COM8_AWB) {
// ret |= cambus_writeb(sensor->slv_addr, REG_COM8, reg & (~REG_COM8_AWB));
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM8, reg & (~REG_COM8_AWB));
// }
// DISABLED
ret |= cambus_readb(sensor->slv_addr, REG_BLUE, &blue);
ret |= cambus_readb(sensor->slv_addr, REG_RED, &red);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_BLUE, &blue);
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_RED, &red);
// DISABLED
// if (reg & REG_COM8_AWB) {
// ret |= cambus_writeb(sensor->slv_addr, REG_COM8, reg | REG_COM8_AWB);
// ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM8, reg | REG_COM8_AWB);
// }
// DISABLED
@ -497,8 +497,8 @@ static int get_rgb_gain_db(sensor_t *sensor, float *r_gain_db, float *g_gain_db,
static int set_hmirror(sensor_t *sensor, int enable)
{
uint8_t val;
int ret = cambus_readb(sensor->slv_addr, REG_MVFP, &val);
ret |= cambus_writeb(sensor->slv_addr, REG_MVFP, enable ? (val | REG_MVFP_HMIRROR) : (val & (~REG_MVFP_HMIRROR)));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG_MVFP, &val);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_MVFP, enable ? (val | REG_MVFP_HMIRROR) : (val & (~REG_MVFP_HMIRROR)));
return ret;
}
@ -506,8 +506,8 @@ static int set_hmirror(sensor_t *sensor, int enable)
static int set_vflip(sensor_t *sensor, int enable)
{
uint8_t val;
int ret = cambus_readb(sensor->slv_addr, REG_MVFP, &val);
ret |= cambus_writeb(sensor->slv_addr, REG_MVFP, enable ? (val | REG_MVFP_VFLIP) : (val & (~REG_MVFP_VFLIP)));
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG_MVFP, &val);
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_MVFP, enable ? (val | REG_MVFP_VFLIP) : (val & (~REG_MVFP_VFLIP)));
return ret;
}

View File

@ -227,10 +227,6 @@ int sensor_init()
DCMI_PWDN_LOW();
systick_sleep(10);
// Initialize the camera bus.
cambus_init();
systick_sleep(10);
// Configure the sensor external clock (XCLK) to XCLK_FREQ.
//
// Max pixclk is 2.5 * HCLK:
@ -281,8 +277,12 @@ int sensor_init()
DCMI_RESET_LOW();
systick_sleep(10);
// Initialize the camera bus.
cambus_init(&sensor.i2c, SCCB_I2C, SCCB_TIMING);
systick_sleep(10);
/* Probe the sensor */
sensor.slv_addr = cambus_scan();
sensor.slv_addr = cambus_scan(&sensor.i2c);
if (sensor.slv_addr == 0) {
/* Sensor has been held in reset,
so the reset line is active low */
@ -293,21 +293,21 @@ int sensor_init()
systick_sleep(10);
/* Probe again to set the slave addr */
sensor.slv_addr = cambus_scan();
sensor.slv_addr = cambus_scan(&sensor.i2c);
if (sensor.slv_addr == 0) {
sensor.pwdn_pol = ACTIVE_LOW;
DCMI_PWDN_HIGH();
systick_sleep(10);
sensor.slv_addr = cambus_scan();
sensor.slv_addr = cambus_scan(&sensor.i2c);
if (sensor.slv_addr == 0) {
sensor.reset_pol = ACTIVE_HIGH;
DCMI_RESET_LOW();
systick_sleep(10);
sensor.slv_addr = cambus_scan();
sensor.slv_addr = cambus_scan(&sensor.i2c);
if (sensor.slv_addr == 0) {
return -2;
}
@ -323,23 +323,23 @@ int sensor_init()
switch (sensor.slv_addr) {
case OV2640_SLV_ADDR:
cambus_readb(sensor.slv_addr, OV_CHIP_ID, &sensor.chip_id);
cambus_readb(&sensor.i2c, sensor.slv_addr, OV_CHIP_ID, &sensor.chip_id);
break;
case OV5640_SLV_ADDR:
cambus_readb2(sensor.slv_addr, OV5640_CHIP_ID, &sensor.chip_id);
cambus_readb2(&sensor.i2c, sensor.slv_addr, OV5640_CHIP_ID, &sensor.chip_id);
break;
case OV7725_SLV_ADDR: // Same for OV7690.
cambus_readb(sensor.slv_addr, OV_CHIP_ID, &sensor.chip_id);
cambus_readb(&sensor.i2c, sensor.slv_addr, OV_CHIP_ID, &sensor.chip_id);
break;
case MT9V034_SLV_ADDR:
cambus_readb(sensor.slv_addr, ON_CHIP_ID, &sensor.chip_id);
cambus_readb(&sensor.i2c, sensor.slv_addr, ON_CHIP_ID, &sensor.chip_id);
break;
case LEPTON_SLV_ADDR:
sensor.chip_id = LEPTON_ID;
break;
#if (OMV_ENABLE_HM01B0 == 1)
case HM01B0_SLV_ADDR:
cambus_readb2(sensor.slv_addr, HIMAX_CHIP_ID, &sensor.chip_id);
cambus_readb2(&sensor.i2c, sensor.slv_addr, HIMAX_CHIP_ID, &sensor.chip_id);
break;
#endif //(OMV_ENABLE_HM01B0 == 1)
default:

View File

@ -167,6 +167,8 @@ typedef struct _sensor {
bool transpose; // Transpose Image
bool auto_rotation; // Rotate Image Automatically
I2C_HandleTypeDef i2c; // SCCB/I2C bus.
// Sensor function pointers
int (*reset) (sensor_t *sensor);
int (*sleep) (sensor_t *sensor, int enable);