From a92c927aedae9d6f7bddab740e0e147fdf55b557 Mon Sep 17 00:00:00 2001 From: iabdalkader Date: Fri, 8 May 2020 19:22:19 +0200 Subject: [PATCH] Make cambus functions accept I2C handle. --- src/lepton/src/LEPTON_I2C_Service.c | 10 +- src/omv/boards/OPENMV2/omv_boardconfig.h | 1 + src/omv/cambus.c | 66 +++-- src/omv/cambus.h | 23 +- src/omv/hm01b0.c | 22 +- src/omv/lepton.c | 4 +- src/omv/mt9v034.c | 88 +++---- src/omv/ov2640.c | 190 +++++++------- src/omv/ov5640.c | 308 +++++++++++------------ src/omv/ov7690.c | 178 ++++++------- src/omv/ov7725.c | 180 ++++++------- src/omv/ov9650.c | 106 ++++---- src/omv/sensor.c | 26 +- src/omv/sensor.h | 2 + 14 files changed, 605 insertions(+), 599 deletions(-) diff --git a/src/lepton/src/LEPTON_I2C_Service.c b/src/lepton/src/LEPTON_I2C_Service.c index 8462e5909..9433a21b2 100755 --- a/src/lepton/src/LEPTON_I2C_Service.c +++ b/src/lepton/src/LEPTON_I2C_Service.c @@ -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); } diff --git a/src/omv/boards/OPENMV2/omv_boardconfig.h b/src/omv/boards/OPENMV2/omv_boardconfig.h index 0056fe357..0b209baa8 100644 --- a/src/omv/boards/OPENMV2/omv_boardconfig.h +++ b/src/omv/boards/OPENMV2/omv_boardconfig.h @@ -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) diff --git a/src/omv/cambus.c b/src/omv/cambus.c index e2a2afd97..7c9d15e8b 100644 --- a/src/omv/cambus.c +++ b/src/omv/cambus.c @@ -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; } diff --git a/src/omv/cambus.h b/src/omv/cambus.h index 765b65c18..43507a3fd 100644 --- a/src/omv/cambus.h +++ b/src/omv/cambus.h @@ -11,14 +11,17 @@ #ifndef __CAMBUS_H__ #define __CAMBUS_H__ #include -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__ diff --git a/src/omv/hm01b0.c b/src/omv/hm01b0.c index 674430da8..319242094 100644 --- a/src/omv/hm01b0.c +++ b/src/omv/hm01b0.c @@ -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; } diff --git a/src/omv/lepton.c b/src/omv/lepton.c index 5f4930ece..191615e95 100644 --- a/src/omv/lepton.c +++ b/src/omv/lepton.c @@ -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) diff --git a/src/omv/mt9v034.c b/src/omv/mt9v034.c index e64a96715..787512cd8 100644 --- a/src/omv/mt9v034.c +++ b/src/omv/mt9v034.c @@ -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); } diff --git a/src/omv/ov2640.c b/src/omv/ov2640.c index 69b786979..b43c3ae18 100644 --- a/src/omv/ov2640.c +++ b/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; islv_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; islv_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; islv_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; diff --git a/src/omv/ov5640.c b/src/omv/ov5640.c index 2a7635aa0..1e4ccb3bb 100644 --- a/src/omv/ov5640.c +++ b/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) diff --git a/src/omv/ov7690.c b/src/omv/ov7690.c index 38ce0d10c..d70ac779d 100644 --- a/src/omv/ov7690.c +++ b/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; } diff --git a/src/omv/ov7725.c b/src/omv/ov7725.c index 3be81e7c3..aacd9916d 100644 --- a/src/omv/ov7725.c +++ b/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; } diff --git a/src/omv/ov9650.c b/src/omv/ov9650.c index f157bf233..bd192378c 100644 --- a/src/omv/ov9650.c +++ b/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; } diff --git a/src/omv/sensor.c b/src/omv/sensor.c index 9ab01c14f..99ec335ef 100644 --- a/src/omv/sensor.c +++ b/src/omv/sensor.c @@ -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: diff --git a/src/omv/sensor.h b/src/omv/sensor.h index 9f412e280..86573f5db 100644 --- a/src/omv/sensor.h +++ b/src/omv/sensor.h @@ -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);