libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/stm32/stm32h743-openmv-h7plus/board/ports/drv_ov5640.c

695 lines
17 KiB
C
Raw Blame History

/*
* Copyright (c) 2006-2022, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2020-08-03 thread-liu the first version
* 2022-04-13 Miaowulue fit openmv-h7plus
*/
#include "board.h"
#ifdef BSP_USING_OV5640
#include <dfs_file.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/statfs.h>
#include "drv_ov5640.h"
//#define DRV_DEBUG
//#define CAMERA_DUMP
#define LOG_TAG "drv.ov5640"
#include <drv_log.h>
#define CHIP_ADDRESS 0x3C /* OV5640 address */
#define I2C_NAME "i2c1"
#define RST_PIN GET_PIN(A, 10)
#define PWDN_PIN GET_PIN(D, 7)
#define JPEG_BUF_SIZE 8 * 1024
#define JPEG_LINE_SIZE 1 * 1024
static rt_int32_t JPEG_DATA_BUF[JPEG_BUF_SIZE];
static rt_int32_t JPEG_LINE_BUF[2][JPEG_LINE_SIZE];
volatile rt_uint32_t jpeg_data_len = 0;
volatile rt_uint8_t jpeg_data_ok = 0;
struct rt_i2c_bus_device *i2c_bus = RT_NULL;
extern DCMI_HandleTypeDef dcmi;
extern DMA_HandleTypeDef hdma_dcmi;
#if defined(CAMERA_DUMP)
#define __is_print(ch) ((unsigned int)((ch) - ' ') < 127u - ' ')
static void dump_hex(const rt_uint8_t *ptr, rt_size_t buflen)
{
unsigned char *buf = (unsigned char *)ptr;
int i, j;
for (i = 0; i < buflen; i += 16)
{
rt_kprintf("%08x:", i);
for (j = 0; j < 16; j++)
{
if (i + j < buflen)
{
rt_kprintf("%02x", buf[i + j]);
}
else
{
rt_kprintf(" ");
}
}
rt_kprintf(" ");
for (j = 0; j < 16; j++)
{
if (i + j < buflen)
{
rt_kprintf("%c", __is_print(buf[i + j]) ? buf[i + j] : '.');
}
}
rt_kprintf("\n");
}
}
#endif
/* i2c read reg */
static rt_err_t read_reg(struct rt_i2c_bus_device *bus, rt_uint16_t reg, rt_uint8_t len, rt_uint8_t *buf)
{
struct rt_i2c_msg msg[2] = {0, 0};
static rt_uint8_t i2c_reg[2] = {0, 0};
RT_ASSERT(bus != RT_NULL);
i2c_reg[0] = ((uint16_t)(reg >> 8) & 0xFF);
i2c_reg[1] = ((uint16_t)(reg & 0xFF));
msg[0].addr = CHIP_ADDRESS;
msg[0].flags = RT_I2C_WR;
msg[0].buf = i2c_reg;
msg[0].len = 2;
msg[1].addr = CHIP_ADDRESS;
msg[1].flags = RT_I2C_RD;
msg[1].len = len;
msg[1].buf = buf;
if (rt_i2c_transfer(bus, msg, 2) == 2)
{
return RT_EOK;
}
return -RT_ERROR;
}
/* i2c write reg */
static rt_err_t write_reg(struct rt_i2c_bus_device *bus, rt_uint16_t reg, rt_uint8_t data)
{
rt_uint8_t buf[3];
struct rt_i2c_msg msgs;
RT_ASSERT(bus != RT_NULL);
buf[0] = ((uint16_t)(reg >> 8) & 0xFF);
buf[1] = ((uint16_t)(reg)&0xFF);
buf[2] = data;
msgs.addr = CHIP_ADDRESS;
msgs.flags = RT_I2C_WR;
msgs.buf = buf;
msgs.len = 3;
if (rt_i2c_transfer(bus, &msgs, 1) == 1)
{
return RT_EOK;
}
return -RT_ERROR;
}
static rt_err_t ov5640_read_id(struct rt_i2c_bus_device *bus, rt_uint16_t *id)
{
rt_uint8_t read_value[2];
read_reg(bus, 0x300A, 1, &read_value[0]);
read_reg(bus, 0x300B, 1, &read_value[1]);
*id = ((uint16_t)(read_value[0] << 8) & 0xFF00);
*id |= ((uint16_t)(read_value[1]) & 0x00FF);
if (*id != OV5640_ID)
{
LOG_E("ov5640 init error, id: 0x%04x", *id);
return -RT_ERROR;
}
LOG_I("ov5640 init success, id: 0x%04x", *id);
return RT_EOK;
}
static rt_err_t ov5640_hard_reset(void)
{
rt_pin_mode(RST_PIN, PIN_MODE_OUTPUT);
rt_pin_mode(PWDN_PIN, PIN_MODE_OUTPUT);
rt_pin_write(RST_PIN, PIN_LOW);
rt_thread_mdelay(20);
rt_pin_write(PWDN_PIN, PIN_LOW);
rt_thread_mdelay(5);
rt_pin_write(RST_PIN, PIN_HIGH);
rt_thread_mdelay(20);
return RT_EOK;
}
void OV5640_Flash_Ctrl(struct rt_i2c_bus_device *bus, rt_uint8_t sw)
{
write_reg(bus, 0x3016, 0X02);
write_reg(bus, 0x301C, 0X02);
if (sw)
{
write_reg(bus, 0X3019, 0X02);
}
else
{
write_reg(bus, 0X3019, 0X00);
}
}
static rt_err_t ov5640_config(struct rt_i2c_bus_device *bus)
{
rt_uint32_t i = 0;
rt_uint8_t value = 0;
write_reg(bus, 0x3103, 0X11); /* system clock from pad, bit[1] */
write_reg(bus, 0X3008, 0X82); /* soft reset */
rt_thread_delay(10);
for (i = 0; i < (sizeof(RGB565_Init) / 4); i++)
{
write_reg(bus, RGB565_Init[i][0], RGB565_Init[i][1]);
rt_thread_delay(10);
read_reg(bus, RGB565_Init[i][0], 1, &value);
if (RGB565_Init[i][1] != value)
{
LOG_D("error reg value[0x%x]:0x%02x - 0x%02x", RGB565_Init[i][0], RGB565_Init[i][1], value);
}
}
OV5640_Flash_Ctrl(bus, 1); /* open camera flash*/
rt_thread_delay(3);
OV5640_Flash_Ctrl(bus, 0); /* close camera flash*/
return RT_EOK;
}
/* JPEG */
void ov5640_jpeg_mode(struct rt_i2c_bus_device *bus)
{
rt_uint16_t i = 0;
for (i = 0; i < (sizeof(OV5640_jpeg_reg_tbl) / 4); i++)
{
write_reg(bus, OV5640_jpeg_reg_tbl[i][0], OV5640_jpeg_reg_tbl[i][1]);
}
}
/* RGB565 */
void ov5640_rgb565_mode(struct rt_i2c_bus_device *bus)
{
rt_uint16_t i = 0;
for (i = 0; i < (sizeof(ov5640_rgb565_reg_tbl) / 4); i++)
{
write_reg(bus, ov5640_rgb565_reg_tbl[i][0], ov5640_rgb565_reg_tbl[i][1]);
}
write_reg(bus, 0x3821, 0x06);
}
rt_uint8_t ov5640_focus_init(struct rt_i2c_bus_device *bus)
{
rt_uint16_t tickstart = 0 ,i = 0;
rt_uint16_t addr = 0x8000;
rt_uint8_t state = 0x8F;
write_reg(bus, 0x3000, 0x20); //reset MCU
for (i = 0; i < sizeof(OV5640_AF_Config); i++)
{
write_reg(bus, addr, OV5640_AF_Config[i]);
addr++;
}
write_reg(bus, 0x3022, 0x00);
write_reg(bus, 0x3023, 0x00);
write_reg(bus, 0x3024, 0x00);
write_reg(bus, 0x3025, 0x00);
write_reg(bus, 0x3026, 0x00);
write_reg(bus, 0x3027, 0x00);
write_reg(bus, 0x3028, 0x00);
write_reg(bus, 0x3029, 0x7f);
write_reg(bus, 0x3000, 0x00);
i = 0;
tickstart = rt_tick_get();
do
{
read_reg(bus, 0x3029, 1, &state);
if (rt_tick_get() - tickstart > 1000)
{
return -RT_ERROR;
}
} while (state != 0x70);
return RT_EOK;
}
void ov5640_set_light(struct rt_i2c_bus_device *bus, rt_uint8_t mode)
{
rt_uint8_t i = 0;
write_reg(bus, 0x3212, 0x03); //start group 3
for (i = 0; i < 7; i++)
{
write_reg(bus, 0x3400 + i, OV5640_LIGHTMODE_TBL[mode][i]);
}
write_reg(bus, 0x3212, 0x13); //end group 3
write_reg(bus, 0x3212, 0xa3); //launch group 3
}
/* sat:0~6 */
void ov5640_color_saturation(struct rt_i2c_bus_device *bus, rt_uint8_t sat)
{
rt_uint8_t i = 0;
write_reg(bus, 0x3212, 0x03); //start group 3
write_reg(bus, 0x5381, 0x1c);
write_reg(bus, 0x5382, 0x5a);
write_reg(bus, 0x5383, 0x06);
for (i = 0; i < 6; i++)
{
write_reg(bus, 0x5384 + i, OV5640_SATURATION_TBL[sat][i]);
}
write_reg(bus, 0x538b, 0x98);
write_reg(bus, 0x538a, 0x01);
write_reg(bus, 0x3212, 0x13); //end group 3
write_reg(bus, 0x3212, 0xa3); //launch group 3
}
/* bright:0~8 */
void ov5640_set_brightness(struct rt_i2c_bus_device *bus, rt_uint8_t bright)
{
rt_uint8_t brtval;
if (bright < 4)
{
brtval = 4 - bright;
}
else
{
brtval = bright - 4;
}
write_reg(bus, 0x3212, 0x03); //start group 3
write_reg(bus, 0x5587, brtval << 4);
if (bright < 4)
{
write_reg(bus, 0x5588, 0x09);
}
else
{
write_reg(bus, 0x5588, 0x01);
}
write_reg(bus, 0x3212, 0x13); //end group 3
write_reg(bus, 0x3212, 0xa3); //launch group 3
}
/* contrast:0~6 */
void ov5640_contrast(struct rt_i2c_bus_device *bus, rt_uint8_t contrast)
{
rt_uint8_t reg0val = 0x00;
rt_uint8_t reg1val = 0x20;
switch (contrast)
{
case 0:
reg1val = reg0val = 0X14;
break;
case 1:
reg1val = reg0val = 0X18;
break;
case 2:
reg1val = reg0val = 0X1C;
break;
case 4:
reg0val = 0X10;
reg1val = 0X24;
break;
case 5:
reg0val = 0X18;
reg1val = 0X28;
break;
case 6:
reg0val = 0X1C;
reg1val = 0X2C;
break;
}
write_reg(bus, 0x3212, 0x03); //start group 3
write_reg(bus, 0x5585, reg0val);
write_reg(bus, 0x5586, reg1val);
write_reg(bus, 0x3212, 0x13); //end group 3
write_reg(bus, 0x3212, 0xa3); //launch group 3
}
/* sharp:0~33 */
void ov5640_set_sharpness(struct rt_i2c_bus_device *bus, rt_uint8_t sharp)
{
if (sharp < 33)
{
write_reg(bus, 0x5308, 0x65);
write_reg(bus, 0x5302, sharp);
}
else
{
write_reg(bus, 0x5308, 0x25);
write_reg(bus, 0x5300, 0x08);
write_reg(bus, 0x5301, 0x30);
write_reg(bus, 0x5302, 0x10);
write_reg(bus, 0x5303, 0x00);
write_reg(bus, 0x5309, 0x08);
write_reg(bus, 0x530a, 0x30);
write_reg(bus, 0x530b, 0x04);
write_reg(bus, 0x530c, 0x06);
}
}
rt_uint8_t ov5640_focus_constant(struct rt_i2c_bus_device *bus)
{
rt_uint8_t temp = 0;
rt_uint16_t tickstrat = 0;
write_reg(bus, 0x3023, 0x01);
write_reg(bus, 0x3022, 0x08);
do
{
tickstrat = rt_tick_get();
read_reg(bus, 0x3023, 1, &temp);
if (rt_tick_get() - tickstrat > 1000)
{
return -RT_ERROR;
}
} while (temp != 0x00);
write_reg(bus, 0x3023, 0x01);
write_reg(bus, 0x3022, 0x04);
do
{
tickstrat = rt_tick_get();
read_reg(bus, 0x3023, 1, &temp);
if (rt_tick_get() - tickstrat > 1000)
{
return -RT_ERROR;
}
} while (temp != 0x00);
return 0;
}
rt_uint8_t ov5640_set_outsize(struct rt_i2c_bus_device *bus, rt_uint16_t offx, rt_uint16_t offy, rt_uint16_t width, rt_uint16_t height)
{
write_reg(bus, 0X3212, 0X03);
write_reg(bus, 0x3808, width >> 8);
write_reg(bus, 0x3809, width & 0xff);
write_reg(bus, 0x380a, height >> 8);
write_reg(bus, 0x380b, height & 0xff);
write_reg(bus, 0x3810, offx >> 8);
write_reg(bus, 0x3811, offx & 0xff);
write_reg(bus, 0x3812, offy >> 8);
write_reg(bus, 0x3813, offy & 0xff);
write_reg(bus, 0X3212, 0X13);
write_reg(bus, 0X3212, 0Xa3);
return RT_EOK;
}
void rt_hw_camera_rx_callback(void)
{
rt_uint16_t i;
rt_int32_t *pbuf = RT_NULL;
pbuf = JPEG_DATA_BUF + jpeg_data_len;
if (((DMA_Stream_TypeDef *)hdma_dcmi.Instance)->CR & (1 << 19))
{
for (i = 0; i < JPEG_LINE_SIZE; i++)
{
pbuf[i] = JPEG_LINE_BUF[0][i];
}
jpeg_data_len += JPEG_LINE_SIZE;
}
else
{
for (i = 0; i < JPEG_LINE_SIZE; i++)
{
pbuf[i] = JPEG_LINE_BUF[1][i];
}
jpeg_data_len += JPEG_LINE_SIZE;
}
}
/* After a frame of JPEG data has been collected. */
void jpeg_data_process(void)
{
rt_uint16_t i, rlen;
int *pbuf = RT_NULL;
if (!jpeg_data_ok)
{
__HAL_DMA_DISABLE(&hdma_dcmi);
rlen = JPEG_LINE_SIZE - __HAL_DMA_GET_COUNTER(&hdma_dcmi);
pbuf = JPEG_DATA_BUF + jpeg_data_len;
if (((DMA_Stream_TypeDef *)hdma_dcmi.Instance)->CR & (1 << 19))
{
for (i = 0; i < rlen; i++)
{
pbuf[i] = JPEG_LINE_BUF[1][i];
}
}
else
{
for (i = 0; i < rlen; i++)
{
pbuf[i] = JPEG_LINE_BUF[0][i];
}
}
jpeg_data_len += rlen;
jpeg_data_ok = 1;
}
if (jpeg_data_ok == 2)
{
__HAL_DMA_SET_COUNTER(&hdma_dcmi, JPEG_LINE_SIZE);
__HAL_DMA_ENABLE(&hdma_dcmi);
jpeg_data_ok = 0;
jpeg_data_len = 0;
}
}
int ov5640_set_xclk_frequency(uint32_t frequency)
{
extern void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);
int tclk = HAL_RCC_GetPCLK2Freq() * 2;
int period = (tclk / frequency) - 1;
int pulse = period / 2;
TIM_HandleTypeDef TIMHandle = {.Instance = TIM1};
if (TIMHandle.Init.Period && (TIMHandle.Init.Period != period)) {
__HAL_TIM_SET_AUTORELOAD(&TIMHandle, period);
__HAL_TIM_SET_COMPARE(&TIMHandle, TIM_CHANNEL_1, pulse);
return 0;
}
TIMHandle.Init.Period = period;
TIMHandle.Init.Prescaler = 0;
TIMHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
TIMHandle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
TIMHandle.Init.RepetitionCounter = 0;
TIMHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
TIM_OC_InitTypeDef TIMOCHandle;
TIMOCHandle.Pulse = pulse;
TIMOCHandle.OCMode = TIM_OCMODE_PWM1;
TIMOCHandle.OCPolarity = TIM_OCPOLARITY_HIGH;
TIMOCHandle.OCNPolarity = TIM_OCNPOLARITY_HIGH;
TIMOCHandle.OCFastMode = TIM_OCFAST_DISABLE;
TIMOCHandle.OCIdleState = TIM_OCIDLESTATE_RESET;
TIMOCHandle.OCNIdleState = TIM_OCNIDLESTATE_RESET;
HAL_TIM_MspPostInit(&TIMHandle);
if ((HAL_TIM_PWM_Init(&TIMHandle) != HAL_OK)
|| (HAL_TIM_PWM_ConfigChannel(&TIMHandle, &TIMOCHandle, TIM_CHANNEL_1) != HAL_OK)
|| (HAL_TIM_PWM_Start(&TIMHandle, TIM_CHANNEL_1) != HAL_OK))
{
rt_kprintf("config fail!\n");
return -1;
}
return 0;
}
int rt_hw_ov5640_init(void)
{
ov5640_set_xclk_frequency(24000000);
extern void rt_hw_dcmi_dma_config(rt_uint32_t dst_addr1, rt_uint32_t dst_addr2, rt_uint16_t len);
static rt_uint16_t id = 0;
rt_device_t dcmi_dev = RT_NULL;
i2c_bus = rt_i2c_bus_device_find(I2C_NAME);
if (i2c_bus == RT_NULL)
{
LOG_E("can't find %c deivce", I2C_NAME);
return -RT_ERROR;
}
ov5640_hard_reset();
ov5640_read_id(i2c_bus, &id);
ov5640_config(i2c_bus);
ov5640_rgb565_mode(i2c_bus); /* rgb565 mode */
ov5640_focus_init(i2c_bus);
ov5640_jpeg_mode(i2c_bus); /* jpeg mode */
ov5640_set_light(i2c_bus, 0); /* auto mode */
ov5640_color_saturation(i2c_bus, 3);
ov5640_set_brightness(i2c_bus, 4); /* brigetness 0 */
ov5640_contrast(i2c_bus, 3);
ov5640_set_sharpness(i2c_bus, 33);
ov5640_focus_constant(i2c_bus);
/* dcmi init */
dcmi_dev = rt_device_find("dcmi");
if (dcmi_dev == RT_NULL)
{
LOG_E("can't find dcmi device!");
return -RT_ERROR;
}
rt_device_open(dcmi_dev, RT_DEVICE_FLAG_RDWR);
rt_hw_dcmi_dma_config((rt_uint32_t)&JPEG_LINE_BUF[0], (rt_uint32_t)&JPEG_LINE_BUF[1], JPEG_LINE_SIZE);
ov5640_set_outsize(i2c_bus, 4, 0, jpeg_picture_size[1][0], jpeg_picture_size[1][1]);
return RT_EOK;
}
INIT_APP_EXPORT(rt_hw_ov5640_init);
int camera_sample(int argc, char **argv)
{
int fd = -1;
rt_uint32_t i, jpg_start, jpg_len;
rt_uint16_t tickstart = 0;
rt_uint8_t jpg_head = 0;
rt_uint8_t *p = RT_NULL;
if (argc != 2)
{
rt_kprintf("Usage:\n");
rt_kprintf("camera_sample file.jpg\n");
return -1;
}
/* start dcmi capture */
__HAL_DMA_ENABLE(&hdma_dcmi);
dcmi.Instance->CR |= DCMI_CR_CAPTURE;
tickstart = rt_tick_get();
while (1)
{
if (rt_tick_get() - tickstart > 1000)
{
LOG_E("picture capture overtime!");
break;
}
if (jpeg_data_ok == 1)
{
dcmi.Instance->CR &= ~(DCMI_CR_CAPTURE);
tickstart = rt_tick_get();
while(dcmi.Instance->CR & 0x01)
{
if (rt_tick_get() - tickstart > 0x1000)
{
rt_kprintf("dcmi close failed!\n");
jpeg_data_ok = 2;
break;
}
}
__HAL_DMA_DISABLE(&hdma_dcmi);
p = (rt_uint8_t *)JPEG_DATA_BUF;
jpg_len = 0;
jpg_head = 0;
for (i = 0; i < jpeg_data_len * 4; i++)
{
/* jpg head */
if ((p[i] == 0xFF) && (p[i + 1] == 0xD8))
{
jpg_start = i;
jpg_head = 1;
}
/* jpg end */
if ((p[i] == 0xFF) && (p[i + 1] == 0xD9) && jpg_head)
{
jpg_len = i - jpg_start + 2; /* a picture len */
break;
}
}
if (jpg_len)
{
p += jpg_start;
fd = open(argv[1], O_WRONLY | O_CREAT);
if (fd < 0)
{
rt_kprintf("open file for recording failed!\n");
return -RT_ERROR;
}
else
{
write(fd, p, jpg_len);
close(fd);
rt_kprintf("picture capture complate!\n");
memset(JPEG_DATA_BUF,0,jpeg_data_len);
jpeg_data_len = 0;
jpeg_data_ok = 0;
break;
}
}
jpeg_data_ok = 2;
}
}
return RT_EOK;
}
MSH_CMD_EXPORT(camera_sample, record picture to a jpg file);
#endif
View Git Blame Copy Permalink