mirror of
https://github.com/openmv/openmv.git
synced 2025-11-04 14:49:50 +08:00
Merge pull request #786 from openmv/cambus_fix
Make cambus functions accept I2C handle.
This commit is contained in:
commit
8b7d4b2122
@ -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);
|
||||
}
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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, ®_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, ®_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, ®_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*) ®_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*) ®_data, 2, I2C_TIMEOUT) != HAL_OK) {
|
||||
ret = -1;
|
||||
}
|
||||
|
||||
@ -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__
|
||||
|
||||
@ -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, ®) != 0) {
|
||||
if (cambus_readb2(&sensor->i2c, sensor->slv_addr, MODE_SELECT, ®) != 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, ®_data) != 0) {
|
||||
if (cambus_readb2(&sensor->i2c, sensor->slv_addr, reg_addr, ®_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, ®);
|
||||
ret |= cambus_writeb2(sensor->slv_addr, IMG_ORIENTATION, HIMAX_SET_HMIRROR(reg, enable)) ;
|
||||
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, IMG_ORIENTATION, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb2(sensor->slv_addr, IMG_ORIENTATION, HIMAX_SET_VMIRROR(reg, enable)) ;
|
||||
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, IMG_ORIENTATION, ®);
|
||||
ret |= cambus_writeb2(&sensor->i2c, sensor->slv_addr, IMG_ORIENTATION, HIMAX_SET_VMIRROR(reg, enable)) ;
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@ -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, ®_data)) {
|
||||
if (cambus_readw2(&sensor->i2c, sensor->slv_addr, reg_addr, ®_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)
|
||||
|
||||
@ -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, ®_data) != 0) {
|
||||
if (cambus_readw(&sensor->i2c, sensor->slv_addr, reg_addr, ®_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, ®);
|
||||
ret |= cambus_writew(sensor->slv_addr, MT9V034_AEC_AGC_ENABLE,
|
||||
int ret = cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_AEC_AGC_ENABLE, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writew(sensor->slv_addr, MT9V034_ANALOG_GAIN, (reg & 0xFF80) | gain);
|
||||
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_ANALOG_GAIN, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writew(sensor->slv_addr, MT9V034_MAX_GAIN, (reg & 0xFF80) | gain_ceiling);
|
||||
ret |= cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_MAX_GAIN, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writew(sensor->slv_addr, MT9V034_AEC_AGC_ENABLE,
|
||||
int ret = cambus_readw(&sensor->i2c, sensor->slv_addr, MT9V034_AEC_AGC_ENABLE, ®);
|
||||
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);
|
||||
}
|
||||
|
||||
190
src/omv/ov2640.c
190
src/omv/ov2640.c
@ -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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM2, ®);
|
||||
|
||||
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, ®_data) != 0) {
|
||||
if (cambus_readb(&sensor->i2c, sensor->slv_addr, reg_addr, ®_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, ®);
|
||||
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, ®);
|
||||
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, ®);
|
||||
|
||||
// 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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CLKRC, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, IMAGE_MODE, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, REG04, (reg & 0xFC) | ((exposure >> 0) & 0x3));
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG04, ®);
|
||||
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG04, (reg & 0xFC) | ((exposure >> 0) & 0x3));
|
||||
|
||||
ret |= cambus_readb(sensor->slv_addr, AEC, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, AEC, (reg & 0x00) | ((exposure >> 2) & 0xFF));
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, AEC, ®);
|
||||
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, AEC, (reg & 0x00) | ((exposure >> 2) & 0xFF));
|
||||
|
||||
ret |= cambus_readb(sensor->slv_addr, REG45, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, REG45, (reg & 0xC0) | ((exposure >> 10) & 0x3F));
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG45, ®);
|
||||
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, ®);
|
||||
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, ®);
|
||||
|
||||
// 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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CLKRC, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, IMAGE_MODE, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_DSP);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CTRL1, ®);
|
||||
|
||||
// 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, ®);
|
||||
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG04, ®);
|
||||
|
||||
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, ®);
|
||||
int ret = cambus_writeb(&sensor->i2c, sensor->slv_addr, BANK_SEL, BANK_SEL_SENSOR);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG04, ®);
|
||||
|
||||
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;
|
||||
|
||||
308
src/omv/ov5640.c
308
src/omv/ov5640.c
@ -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, ®);
|
||||
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, SYSTEM_CTROL0, ®);
|
||||
|
||||
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, ®_data) != 0) {
|
||||
if (cambus_readb2(&sensor->i2c, sensor->slv_addr, reg_addr, ®_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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb2(sensor->slv_addr, TIMING_HTS_L, ®2);
|
||||
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_HTS_H, ®);
|
||||
ret |= cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_HTS_L, ®2);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb2(sensor->slv_addr, JPEG_CTRL07, (reg & 0xC0) | (qs >> 2));
|
||||
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, JPEG_CTRL07, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_21, ®);
|
||||
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, ®);
|
||||
int ret = cambus_readb2(&sensor->i2c, sensor->slv_addr, TIMING_TC_REG_20, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
return cambus_writeb2(&sensor->i2c, sensor->slv_addr, ISP_CONTROL_00, (reg & 0x7F) | (enable ? 0x80 : 0x00)) | ret;
|
||||
}
|
||||
|
||||
int ov5640_init(sensor_t *sensor)
|
||||
|
||||
178
src/omv/ov7690.c
178
src/omv/ov7690.c
@ -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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG0E, ®);
|
||||
|
||||
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, ®_data) != 0) {
|
||||
if (cambus_readb(&sensor->i2c, sensor->slv_addr, reg_addr, ®_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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG12, ®);
|
||||
|
||||
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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG12, ®);
|
||||
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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG12, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, REGD2, (reg & 0xFB) | ((level != 0) << 2));
|
||||
ret |= cambus_readb(sensor->slv_addr, 0xdc, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REGD2, (reg & 0xFB) | ((level != 0) << 2));
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, 0xdc, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG14, ®);
|
||||
|
||||
// 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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG82, ®);
|
||||
|
||||
// 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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, REG13, (reg & 0xFB) | ((enable != 0) << 2));
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG13, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®15);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, GAIN, &gain);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG15, ®15);
|
||||
|
||||
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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, REG13, (reg & 0xFE) | ((enable != 0) << 0));
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG13, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG12, ®);
|
||||
int t_line = (reg & 0x40) ? (320 + 456) : (640 + 136);
|
||||
|
||||
ret |= cambus_readb(sensor->slv_addr, REG3E, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG3E, ®);
|
||||
int t_pclk = (reg & 0x10) ? 2 : 1;
|
||||
|
||||
ret |= cambus_readb(sensor->slv_addr, PLL, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, PLL, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CLKRC, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG12, ®);
|
||||
int t_line = (reg & 0x40) ? (320 + 456) : (640 + 136);
|
||||
|
||||
ret |= cambus_readb(sensor->slv_addr, REG3E, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG3E, ®);
|
||||
int t_pclk = (reg & 0x10) ? 2 : 1;
|
||||
|
||||
ret |= cambus_readb(sensor->slv_addr, PLL, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, PLL, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CLKRC, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, REG13, (reg & 0xFD) | ((enable != 0) << 1));
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG13, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, REG0C, (reg & 0xBF) | ((enable == 0) << 6));
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG0C, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, REG0C, (reg & 0x7F) | ((enable == 0) << 7));
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG0C, ®);
|
||||
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;
|
||||
}
|
||||
|
||||
180
src/omv/ov7725.c
180
src/omv/ov7725.c
@ -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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM2, ®);
|
||||
|
||||
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, ®_data) != 0) {
|
||||
if (cambus_readb(&sensor->i2c, sensor->slv_addr, reg_addr, ®_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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, ®);
|
||||
|
||||
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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, ®);
|
||||
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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, ®);
|
||||
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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM9, ®);
|
||||
|
||||
// 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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM3, ®);
|
||||
|
||||
// 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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, DSP_CTRL3, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AGC(reg, (enable != 0)));
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, ®);
|
||||
|
||||
// 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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AEC(reg, (enable != 0)));
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, ®);
|
||||
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM4, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CLKRC, ®);
|
||||
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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, ®);
|
||||
|
||||
// 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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM7, ®);
|
||||
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, COM4, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, CLKRC, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, COM8, COM8_SET_AWB(reg, (enable != 0)));
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, AWB_CTRL1, ®);
|
||||
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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM8, ®);
|
||||
|
||||
// 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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, AWB_CTRL1, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, COM3, COM3_SET_MIRROR(reg, enable)) ;
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM3, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, COM3, COM3_SET_FLIP(reg, enable));
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, COM3, ®);
|
||||
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;
|
||||
}
|
||||
|
||||
106
src/omv/ov9650.c
106
src/omv/ov9650.c
@ -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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM8, ®);
|
||||
|
||||
// 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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM7, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_CLKRC, ®);
|
||||
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, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, REG_COM1, (reg & 0xFC) | ((exposure >> 0) & 0x3));
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM1, ®);
|
||||
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_COM1, (reg & 0xFC) | ((exposure >> 0) & 0x3));
|
||||
|
||||
ret |= cambus_readb(sensor->slv_addr, REG_AECH, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, REG_AECH, (reg & 0x00) | ((exposure >> 2) & 0xFF));
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_AECH, ®);
|
||||
ret |= cambus_writeb(&sensor->i2c, sensor->slv_addr, REG_AECH, (reg & 0x00) | ((exposure >> 2) & 0xFF));
|
||||
|
||||
ret |= cambus_readb(sensor->slv_addr, REG_AECHM, ®);
|
||||
ret |= cambus_writeb(sensor->slv_addr, REG_AECHM, (reg & 0xC0) | ((exposure >> 10) & 0x3F));
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_AECHM, ®);
|
||||
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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM8, ®);
|
||||
|
||||
// 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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM7, ®);
|
||||
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, ®);
|
||||
ret |= cambus_readb(&sensor->i2c, sensor->slv_addr, REG_CLKRC, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
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, ®);
|
||||
int ret = cambus_readb(&sensor->i2c, sensor->slv_addr, REG_COM8, ®);
|
||||
|
||||
// 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;
|
||||
}
|
||||
|
||||
@ -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:
|
||||
|
||||
@ -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);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user