695 lines
17 KiB
C
695 lines
17 KiB
C
/*
|
|
* 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
|