static int set_colorbar(sensor_t *sensor, int enable)
{
uint8_t ret = 0;
// Read register scaling_xsc
uint8_t reg = SCCB_Read(sensor->slv_addr, SCALING_XSC);
// Pattern to set color bar bit[0]=0 in every case
reg = SCALING_XSC_CBAR(reg);
// Write pattern to SCALING_XSC
ret = SCCB_Write(sensor->slv_addr, SCALING_XSC, reg);
// Read register scaling_ysc
uint8_t reg = SCCB_Read(sensor->slv_addr, SCALING_YSC);
// Pattern to set color bar bit[0]=0 in every case
reg = SCALING_YSC_CBAR(reg,enable);
// Write pattern to SCALING_YSC
ret = ret | SCCB_Write(sensor->slv_addr, SCALING_YSC, reg);
// Set mirror on/off to pass self-tests
// Read register MVFP
uint8_t reg = SCCB_Read(sensor->slv_addr, MVFP);
// Set mirror on/off
reg = MVFP_SET_MIRROR(reg, enable);
// Write back register MVFP
ret = ret | SCCB_Write(sensor->slv_addr, MVFP, reg);
// return 0 or 0xFF
return ret;
}
//读OV7660寄存器
u8 OV_ReadReg(u8 regID, u8 *regDat)
{
//通过写操作设置寄存器地址
SCCB_Start();
if(SCCB_Write(0x42))//写地址
{
SCCB_Stop();//发送SCCB 总线停止传输命令
return 1;//错误返回
}
delay_us(10);
if(SCCB_Write(regID))//积存器ID
{
SCCB_Stop();//发送SCCB 总线停止传输命令
return 2;//错误返回
}
SCCB_Stop();//发送SCCB 总线停止传输命令
delay_us(10);
//设置寄存器地址后，才是读
SCCB_Start();
if(SCCB_Write(0x43))//读地址
{
SCCB_Stop();//发送SCCB 总线停止传输命令
return 3;//错误返回
}
delay_us(10);
*regDat=SCCB_Read();//返回读到的值
noAck();//发送NACK命令
SCCB_Stop();//发送SCCB 总线停止传输命令
return 0;//成功返回
}
static int set_framesize(sensor_t *sensor, framesize_t framesize)
{
uint8_t com7=0; /* framesize/RGB */
uint8_t com1=0; /* Skip option */
/* read COM7 RGB bit */
com7 = (SCCB_Read(sensor->slv_addr, REG_COM7) & REG_COM7_RGB);
switch (framesize) {
case FRAMESIZE_QQCIF:
com7 |= REG_COM7_QCIF;
com1 |= REG_COM1_QQCIF|REG_COM1_SKIP2;
break;
case FRAMESIZE_QQVGA:
com7 |= REG_COM7_QVGA;
com1 |= REG_COM1_QQVGA|REG_COM1_SKIP2;
break;
case FRAMESIZE_QCIF:
com7 |= REG_COM7_QCIF;
break;
default:
return -1;
}
/* write the frame size registers */
SCCB_Write(sensor->slv_addr, REG_COM1, com1);
SCCB_Write(sensor->slv_addr, REG_COM7, com7);
return 0;
}
static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
{
int ret=0;
// Read register COM7
uint8_t reg = SCCB_Read(sensor->slv_addr, COM7);
switch (pixformat) {
case PIXFORMAT_RGB565:
reg = COM7_SET_FMT(reg, COM7_FMT_RGB);
break;
case PIXFORMAT_YUV422:
case PIXFORMAT_GRAYSCALE:
reg = COM7_SET_FMT(reg, COM7_FMT_YUV);
break;
default:
return -1;
}
// Write back register COM7
ret = SCCB_Write(sensor->slv_addr, COM7, reg);
// Delay
systick_sleep(30);
return ret;
}
int initMPU(void){
int initOkay = -1;
HAL_I2C_StateTypeDef state;
uint8_t tempByte = 13;
uint8_t buffer[10] = {0,0,0,0,0,0,0,0,0,0};
hnd.Instance = I2C1;
hnd.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hnd.Init.ClockSpeed = 400000;
hnd.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hnd.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hnd.Init.DutyCycle = I2C_DUTYCYCLE_2;
hnd.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
hnd.Init.OwnAddress1 = 0x00;
HAL_I2C_Init(&hnd);
__HAL_I2C_ENABLE(&hnd);
state = HAL_I2C_GetState(&hnd);
if(state == HAL_I2C_STATE_READY){
initOkay = 0;
}
buffer[0]=MPU6050_RA_PWR_MGMT_1;
buffer[1]=0x80;
printf("READ: %u",SCCB_Read(MPU6050_RA_WHO_AM_I));
printf("error: %u",HAL_I2C_GetError(&hnd));
return initOkay;
}
static int set_vflip(sensor_t *sensor, int enable)
{
uint8_t val;
val = SCCB_Read(sensor->slv_addr, REG_MVFP);
SCCB_Write(sensor->slv_addr, REG_MVFP,
enable ? (val | REG_MVFP_VFLIP) : (val & ~REG_MVFP_VFLIP));
return 0;
}
static int set_hmirror(sensor_t *sensor, int enable)
{
uint8_t val;
val = SCCB_Read(sensor->slv_addr, REG_MVFP);
SCCB_Write(sensor->slv_addr, REG_MVFP,
enable ? (val | REG_MVFP_HMIRROR) : (val & ~REG_MVFP_HMIRROR));
return 0;
}
static int set_whitebal(sensor_t *sensor, int enable)
{
uint8_t val;
val = SCCB_Read(sensor->slv_addr, REG_COM8);
SCCB_Write(sensor->slv_addr, REG_COM8,
enable ? (val | REG_COM8_AWB) : (val & ~REG_COM8_AWB));
return 0;
}
static int set_gainceiling(struct sensor_dev *sensor, enum sensor_gainceiling gainceiling)
{
// Read register COM9
uint8_t reg = SCCB_Read(sensor->slv_addr, COM9);
// Set gain ceiling
reg = COM9_SET_AGC(reg, gainceiling);
// Write back register COM9
return SCCB_Write(sensor->slv_addr, COM9, reg);
}
static int set_exposure_ctrl(sensor_t *sensor, int enable)
{
// Read register COM8
uint8_t reg = SCCB_Read(sensor->slv_addr, COM8);
// Set white bal on/off
reg = COM8_SET_AEC(reg, enable);
// Write back register COM8
return SCCB_Write(sensor->slv_addr, COM8, reg);
}
static int set_hmirror(sensor_t *sensor, int enable)
{
// Read register MVFP
uint8_t reg = SCCB_Read(sensor->slv_addr, MVFP);
// Set mirror on/off
reg = MVFP_SET_MIRROR(reg, enable);
// Write back register COM3
return SCCB_Write(sensor->slv_addr, MVFP, reg);
}
static int set_vflip(sensor_t *sensor, int enable)
{
// Read register COM3
uint8_t reg = SCCB_Read(sensor->slv_addr, COM3);
// Set mirror on/off
reg = COM3_SET_FLIP(reg, enable);
// Write back register COM3
return SCCB_Write(sensor->slv_addr, COM3, reg);
}
static int set_colorbar(struct sensor_dev *sensor, int enable)
{
// Read register COM3
uint8_t reg = SCCB_Read(sensor->slv_addr, COM3);
// Set color bar on/off
reg = COM3_SET_CBAR(reg, enable);
// Set mirror on/off to pass self-tests
reg = COM3_SET_MIRROR(reg, enable);
// Write back register COM3
return SCCB_Write(sensor->slv_addr, COM3, reg);
}
/**
* @brief Read data form specific register in Camera Module OV7670
* @param Address: address of register in Camera Module
* @retval ReturnState.Data -> Return read data from register
* ReturnState.State -> Return state of the transmission
*/
ReturnState *Camera_ReadReg(uint8_t Address)
{
ReturnState returnState;
// Structure for return Data and State (Success/Error)
returnState.Data = 0x00;
returnState.State = ERROR;
// Create start condition on SCCB/I2C interface
SCCB_Start();
// Write data (Address of slave device for Write) on SCCB/I2C interface
if(Error == (SCCB_Write(WriteAddress)))
{
SCCB_Stop(); // Create stop condition on SCCB/I2C interface
return(&returnState); // Return error and cancel the communication
}
Delay_us(100);
// Write data (Address of register in Camera Module)on SCCB/I2C interface
if(Error == (SCCB_Write(Address)))
{
SCCB_Stop(); // Create stop condition on SCCB/I2C interface
return(&returnState); // Return error and cancel the communication
}
// Create stop condition on SCCB/I2C interface
SCCB_Stop();
// Delay for SCCB/I2C
Delay_us(100);
// Create start condition on SCCB/I2C interface
SCCB_Start();
// Write data (Address of slave device for Read) on SCCB/I2C interface
if(Error == (SCCB_Write(ReadAddress)))
{
SCCB_Stop(); // Create stop condition on SCCB/I2C interface
return(&returnState); // Return error and cancel the communication
}
Delay_us(500);
// Received data from Camera Module (SCCB/I2C)
returnState.Data = SCCB_Read();
// No acknowlage on SCCB/I2C interface
NoAck();
// Create stop condition on SCCB/I2C interface
SCCB_Stop();
// If everything is done correct return success
returnState.State = SUCCESS;
return(&returnState);
}
static int set_exposure(sensor_t *sensor, int exposure)
{
uint8_t val;
val = SCCB_Read(sensor->slv_addr, REG_COM1);
/* exposure [1:0] */
SCCB_Write(sensor->slv_addr, REG_COM1, val | (exposure&0x03));
/* exposure [9:2] */
SCCB_Write(sensor->slv_addr, REG_AECH, ((exposure>>2)&0xFF));
/* exposure [15:10] */
SCCB_Write(sensor->slv_addr, REG_AECHM, ((exposure>>10)&0x3F));
return 0;
}
static int set_pixformat(struct sensor_dev *sensor, enum sensor_pixformat pixformat)
{
// Read register COM7
uint8_t reg = SCCB_Read(sensor->slv_addr, COM7);
switch (pixformat) {
case PIXFORMAT_RGB565:
reg = COM7_SET_FMT(reg, COM7_FMT_RGB);
break;
case PIXFORMAT_YUV422:
case PIXFORMAT_GRAYSCALE:
reg = COM7_SET_FMT(reg, COM7_FMT_YUV);
break;
default:
return -1;
}
// Write back register COM7
return SCCB_Write(sensor->slv_addr, COM7, reg);
}
static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
{
int i=0;
const uint8_t (*regs)[2];
uint8_t com7=0; /* framesize/RGB */
/* read pixel format reg */
com7 = SCCB_Read(sensor->slv_addr, REG_COM7);
switch (pixformat) {
case PIXFORMAT_RGB565:
com7 |= REG_COM7_RGB;
regs = rgb565_regs;
break;
case PIXFORMAT_YUV422:
com7 &= (~REG_COM7_RGB);
regs = yuv422_regs;
break;
case PIXFORMAT_GRAYSCALE:
com7 &= (~REG_COM7_RGB);
regs = yuv422_regs;
break;
default:
return -1;
}
/* Set pixel format */
SCCB_Write(sensor->slv_addr, REG_COM7, com7);
/* Write pixel format registers */
while (regs[i][0]) {
SCCB_Write(sensor->slv_addr, regs[i][0], regs[i][1]);
i++;
}
return 0;
}
int sensor_read_reg(uint8_t reg)
{
return SCCB_Read(reg);
}
int sensor_init()
{
/* Do a power cycle */
DCMI_PWDN_HIGH();
systick_sleep(10);
DCMI_PWDN_LOW();
systick_sleep(100);
/* Initialize the SCCB interface */
SCCB_Init();
systick_sleep(10);
/* Configure the external clock (XCLK) */
extclk_config(XCLK_FREQ);
systick_sleep(10);
/* Reset the sesnor state */
memset(&sensor, 0, sizeof(struct sensor_dev));
/* Some sensors have different reset polarities, and we can't know which sensor
is connected before initializing SCCB and reading the PID register, which in
turn requires pulling the sensor out of the reset state. So we try to read a
register with both polarities to determine line state. */
sensor.reset_pol = ACTIVE_HIGH;
DCMI_RESET_HIGH();
systick_sleep(10);
DCMI_RESET_LOW();
systick_sleep(10);
/* Check if we can read PID */
if (SCCB_Read(REG_PID) == 255) {
/* Sensor is held in reset, so reset is active high */
sensor.reset_pol = ACTIVE_LOW;
DCMI_RESET_LOW();
systick_sleep(10);
DCMI_RESET_HIGH();
systick_sleep(10);
}
/* Read the sensor information */
sensor.id.MIDH = SCCB_Read(REG_MIDH);
sensor.id.MIDL = SCCB_Read(REG_MIDL);
sensor.id.PID = SCCB_Read(REG_PID);
sensor.id.VER = SCCB_Read(REG_VER);
/* Call the sensor-specific init function */
switch (sensor.id.PID) {
case OV9650_PID:
ov9650_init(&sensor);
break;
case OV2640_PID:
ov2640_init(&sensor);
break;
default:
/* sensor not supported */
return -1;
}
/* Configure the DCMI DMA Stream */
if (dma_config() != 0) {
return -1;
}
/* Configure the DCMI interface. This should be called
after ovxxx_init to set VSYNC/HSYNC/PCLK polarities */
if (dcmi_config() != 0){
return -1;
}
/* init/re-init mutex */
mutex_init(&fb->lock);
return 0;
}
static mp_obj_t py_sensor_read_reg(mp_obj_t addr) {
return mp_obj_new_int(SCCB_Read(mp_obj_get_int(addr)));
}
int sensor_init()
{
/* Do a power cycle */
DCMI_PWDN_HIGH();
systick_sleep(10);
DCMI_PWDN_LOW();
systick_sleep(100);
/* Initialize the SCCB interface */
SCCB_Init();
systick_sleep(10);
/* Configure the sensor external clock (XCLK) to XCLK_FREQ (13MHz).
Note: The sensor's internal PLL (when CLKRC=0x80) doubles the XCLK_FREQ
(XCLK=XCLK_FREQ*2), and the unscaled PIXCLK output is XCLK_FREQ*4 */
extclk_config(XCLK_FREQ);
/* Uncomment this to pass through the MCO1 clock (HSI=16MHz) this results in a
64MHz PIXCLK output from the sensor.
Note: The maximum pixel clock input on the STM32F4xx is 54MHz,
the STM32F7 can probably handle higher input pixel clock.
*/
//(void) extclk_config;
//HAL_RCC_MCOConfig(RCC_MCO1, RCC_MCO1SOURCE_HSI, RCC_MCODIV_1);
/* Reset the sesnor state */
memset(&sensor, 0, sizeof(struct sensor_dev));
/* Some sensors have different reset polarities, and we can't know which sensor
is connected before initializing SCCB and reading the PID register, which in
turn requires pulling the sensor out of the reset state. So we try to read a
register with both polarities to determine line state. */
sensor.reset_pol = ACTIVE_HIGH;
DCMI_RESET_HIGH();
systick_sleep(10);
DCMI_RESET_LOW();
systick_sleep(10);
/* Check if we can read PID */
if (SCCB_Read(REG_PID) == 255) {
/* Sensor is held in reset, so reset is active high */
sensor.reset_pol = ACTIVE_LOW;
DCMI_RESET_LOW();
systick_sleep(10);
DCMI_RESET_HIGH();
systick_sleep(10);
}
/* Read the sensor information */
sensor.id.MIDH = SCCB_Read(REG_MIDH);
sensor.id.MIDL = SCCB_Read(REG_MIDL);
sensor.id.PID = SCCB_Read(REG_PID);
sensor.id.VER = SCCB_Read(REG_VER);
/* Call the sensor-specific init function */
switch (sensor.id.PID) {
case OV9650_PID:
ov9650_init(&sensor);
break;
case OV2640_PID:
ov2640_init(&sensor);
break;
default:
/* sensor not supported */
return -1;
}
/* Configure the DCMI DMA Stream */
if (dma_config() != 0) {
return -2;
}
/* Configure the DCMI interface. This should be called
after ovxxx_init to set VSYNC/HSYNC/PCLK polarities */
if (dcmi_config(DCMI_JPEG_DISABLE) != 0){
return -3;
}
/* init/re-init mutex */
mutex_init(&fb->lock);
// blocks usbdbg until the sensor is configured
fb->ready=0;
return 0;
}
