📄 image_sensor.c
字号:
}
else
{
sensor_config_data->flashlight_duty = 0;
sensor_config_data->flashlight_shut_factor = BASEGAIN;
shutter = ori_shutter;
}
}
#endif
if(shutter<1)
shutter=1;
write_cmos_sensor(0x09,shutter);
} /* MT9D011_capture() */
/*************************************************************************
* FUNCTION
* write_MT9D011_reg
*
* DESCRIPTION
* This function set the register of MT9D011.
*
* PARAMETERS
* addr : the register index of MT9D011
* para : setting parameter of the specified register of MT9D011
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void write_MT9D011_reg(kal_uint32 addr, kal_uint32 para)
{
write_cmos_sensor(addr,para);
} /* write_MT9D011_reg() */
/*************************************************************************
* FUNCTION
* read_cmos_sensor
*
* DESCRIPTION
* This function read parameter of specified register from MT9D011.
*
* PARAMETERS
* addr : the register index of MT9D011
*
* RETURNS
* the data that read from MT9D011
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_uint32 read_MT9D011_reg(kal_uint32 addr)
{
return (read_cmos_sensor(addr));
} /* read_MT9D011_reg() */
/*************************************************************************
* FUNCTION
* set_MT9D011_shutter
*
* DESCRIPTION
* This function set e-shutter of MT9D011 to change exposure time.
*
* PARAMETERS
* shutter : exposured lines
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void set_MT9D011_shutter(kal_uint16 shutter)
{
kal_uint16 tmp_shutter;
if(current_sensor_expo_width!=sensor_expo_width)
{
tmp_shutter=shutter*sensor_expo_width/current_sensor_expo_width;
shutter=tmp_shutter;
}
exposure_lines=shutter;
write_cmos_sensor(0x09,shutter);
} /* set_MT9D011_shutter */
/*************************************************************************
* FUNCTION
* set_MT9D011_gain
*
* DESCRIPTION
* This function is to set global gain to sensor.
*
* PARAMETERS
* gain : sensor global gain(base: 0x40)
*
* RETURNS
* the actually gain set to sensor.
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_uint16 set_MT9D011_gain(kal_uint16 gain)
{
kal_uint32 reg_gain;
write_MT9D011_gain(gain);
reg_gain=(sensor_global_gain*BASEGAIN)/sensor_gain_base;
return reg_gain;
}
/*************************************************************************
* FUNCTION
* MT9D011_night_mode
*
* DESCRIPTION
* This function night mode of MT9D011.
*
* PARAMETERS
* none
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void MT9D011_night_mode(kal_bool enable)
{
kal_uint32 dummy = IMAGE_SENSOR_PV_VBLANKING+PV_dummy_lines;
if(enable)
{
MAX_EXPOSURE_LINES = (kal_uint16)((sensor_pclk/VIDEO_NIGHTMODE_FRAME_RATE)/(PV_PERIOD_PIXEL_NUMS+PV_dummy_pixels));
if(MPEG4_encode_mode==KAL_TRUE)
{ // 24000000/7.5/(816+324) = 2807, 2807-621 = 2186 for 30 fps
// 12000000/7.5/(816+324) = 1404, 1404-621 = 783 fpr 15 fps
dummy = MAX_EXPOSURE_LINES - PV_ACTIVE_LINE_NUMS;
write_cmos_sensor(0x06, dummy);
}
if(camera_oper_data.pregain_mode==ISP_ONLY)
write_cmos_sensor(0x2F,night_gain);
sensor_night_mode=KAL_TRUE;
}
else
{
if(MPEG4_encode_mode==KAL_TRUE)
{
if(MPEG4_30fps_mode==KAL_TRUE)
{
MAX_EXPOSURE_LINES = (kal_uint16)((sensor_pclk/VIDEO_NORMALMODE_30FRAME_RATE)/(PV_PERIOD_PIXEL_NUMS+PV_dummy_pixels));
}
else
{
MAX_EXPOSURE_LINES = (kal_uint16)((sensor_pclk/VIDEO_NORMALMODE_FRAME_RATE)/(PV_PERIOD_PIXEL_NUMS+PV_dummy_pixels));
}
if((MAX_EXPOSURE_LINES>PV_ACTIVE_LINE_NUMS)&&(dummy<(MAX_EXPOSURE_LINES-PV_ACTIVE_LINE_NUMS)))
dummy = MAX_EXPOSURE_LINES - PV_ACTIVE_LINE_NUMS;
write_cmos_sensor(0x06, dummy);
}
if(camera_oper_data.pregain_mode==ISP_ONLY)
write_cmos_sensor(0x2F,normal_gain);
sensor_night_mode=KAL_FALSE;
}
if(camera_oper_data.pregain_mode==ISP_ONLY)
sensor_gain_base=read_MT9D011_gain();
} /* MT9D011_night_mode */
void set_flashlight (kal_bool enable)
{
flashlight_power_on(enable);
}
/*************************************************************************
* FUNCTION
* image_sensor_func_MT9D011
*
* DESCRIPTION
* MT9D011 Image Sensor functions struct.
*
* PARAMETERS
* none
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
image_sensor_func_struct image_sensor_func_MT9D011=
{
init_MT9D011,
get_MT9D011_id,
get_MT9D011_size,
get_MT9D011_period,
MT9D011_preview,
MT9D011_capture,
write_MT9D011_reg,
read_MT9D011_reg,
set_MT9D011_shutter,
MT9D011_night_mode,
power_off_MT9D011,
set_MT9D011_gain,
set_flashlight
}; /* image_sensor_func_MT9D011 */
/*************************************************************************
* FUNCTION
* cam_module_func_config
*
* DESCRIPTION
* This function maps the external camera module function API structure.
*
* PARAMETERS
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void image_sensor_func_config(void)
{
image_sensor_func=&image_sensor_func_MT9D011;
} /* cam_module_func_config() */
// write camera_para to sensor register
void camera_para_to_sensor(void)
{
kal_uint32 i;
for(i=0; 0xFFFFFFFF!=camera_para.SENSOR.reg[i].addr; i++)
{
write_MT9D011_reg(camera_para.SENSOR.reg[i].addr, camera_para.SENSOR.reg[i].para);
}
for(i=ENGINEER_START_ADDR; 0xFFFFFFFF!=camera_para.SENSOR.reg[i].addr; i++)
{
write_MT9D011_reg(camera_para.SENSOR.reg[i].addr, camera_para.SENSOR.reg[i].para);
}
for(i=FACTORY_START_ADDR+1; i<5; i++)
{
write_MT9D011_reg(camera_para.SENSOR.cct[i].addr, camera_para.SENSOR.cct[i].para);
}
}
// update camera_para from sensor register
void sensor_to_camera_para(void)
{
kal_uint32 i;
for(i=0; 0xFFFFFFFF!=camera_para.SENSOR.reg[i].addr; i++)
{
camera_para.SENSOR.reg[i].para = read_MT9D011_reg(camera_para.SENSOR.reg[i].addr);
}
for(i=ENGINEER_START_ADDR; 0xFFFFFFFF!=camera_para.SENSOR.reg[i].addr; i++)
{
camera_para.SENSOR.reg[i].para = read_MT9D011_reg(camera_para.SENSOR.reg[i].addr);
}
}
//------------------------Engineer mode---------------------------------
void get_sensor_group_count(kal_int32* sensor_count_ptr)
{
*sensor_count_ptr=GROUP_TOTAL_NUMS;
return;
}
void get_sensor_group_info(kal_uint16 group_idx, kal_int8* group_name_ptr, kal_int32* item_count_ptr)
{
switch (group_idx)
{
case PRE_GAIN:
sprintf(group_name_ptr, "CCT");
*item_count_ptr = 5;
break;
case CMMCLK_CURRENT:
sprintf(group_name_ptr, "CMMCLK Current");
*item_count_ptr = 1;
break;
case FRAME_RATE_LIMITATION:
sprintf(group_name_ptr, "Frame Rate Limitation");
*item_count_ptr = 2;
break;
case REGISTER_EDITOR:
sprintf(group_name_ptr, "Register Editor");
*item_count_ptr = 2;
break;
default:
ASSERT(0);
}
}
void get_sensor_item_info(kal_uint16 group_idx,kal_uint16 item_idx, ENG_sensor_info* info_ptr)
{
kal_int16 temp_reg;
kal_uint16 temp_gain, temp_addr, temp_para;
switch (group_idx)
{
case PRE_GAIN:
switch (item_idx)
{
case 0:
sprintf(info_ptr->item_name_ptr,"Pregain-R");
temp_addr = PRE_GAIN_R_INDEX;
break;
case 1:
sprintf(info_ptr->item_name_ptr,"Pregain-Gr");
temp_addr = PRE_GAIN_Gr_INDEX;
break;
case 2:
sprintf(info_ptr->item_name_ptr,"Pregain-Gb");
temp_addr = PRE_GAIN_Gb_INDEX;
break;
case 3:
sprintf(info_ptr->item_name_ptr,"Pregain-B");
temp_addr = PRE_GAIN_B_INDEX;
break;
case 4:
sprintf(info_ptr->item_name_ptr,"SENSOR_BASEGAIN");
temp_addr = SENSOR_BASEGAIN;
break;
default:
ASSERT(0);
}
temp_para=camera_para.SENSOR.cct[temp_addr].para;
if(temp_para>=0x20 && temp_para<=0x3F)
temp_gain=(temp_para*BASEGAIN)/32;
else if(temp_para>=0xA0 && temp_para<=0xFF)
temp_gain=((temp_para-128)*BASEGAIN)/16;
else if(temp_para>=0x1C0 && temp_para<=0x1FF)
temp_gain=((temp_para-384)*BASEGAIN)/8;
else
ASSERT(0);
temp_gain=(temp_gain*1000)/BASEGAIN;
info_ptr->item_value=temp_gain;
info_ptr->is_true_false=KAL_FALSE;
info_ptr->is_read_only=KAL_FALSE;
info_ptr->is_need_restart=KAL_FALSE;
info_ptr->min=1000;
info_ptr->max=15875;
break;
case CMMCLK_CURRENT:
switch (item_idx)
{
case 0:
sprintf(info_ptr->item_name_ptr,"Drv Cur[2,4,6,8]mA");
temp_reg=camera_para.SENSOR.reg[CMMCLK_CURRENT_INDEX].para;
if(temp_reg==ISP_DRIVING_2MA)
{
info_ptr->item_value=2;
}
else if(temp_reg==ISP_DRIVING_4MA)
{
info_ptr->item_value=4;
}
else if(temp_reg==ISP_DRIVING_6MA)
{
info_ptr->item_value=6;
}
else if(temp_reg==ISP_DRIVING_8MA)
{
info_ptr->item_value=8;
}
info_ptr->is_true_false=KAL_FALSE;
info_ptr->is_read_only=KAL_FALSE;
info_ptr->is_need_restart=KAL_TRUE;
info_ptr->min=2;
info_ptr->max=8;
break;
default:
ASSERT(0);
}
break;
case FRAME_RATE_LIMITATION:
switch (item_idx)
{
case 0:
sprintf(info_ptr->item_name_ptr,"Max Exposure Lines");
info_ptr->item_value=MAX_EXPOSURE_LINES;
info_ptr->is_true_false=KAL_FALSE;
info_ptr->is_read_only=KAL_TRUE;
info_ptr->is_need_restart=KAL_FALSE;
info_ptr->min=0;
info_ptr->max=0;
break;
case 1:
sprintf(info_ptr->item_name_ptr,"Min Frame Rate");
info_ptr->item_value=MIN_FRAME_RATE;
info_ptr->is_true_false=KAL_FALSE;
info_ptr->is_read_only=KAL_TRUE;
info_ptr->is_need_restart=KAL_FALSE;
info_ptr->min=0;
info_ptr->max=0;
break;
default:
ASSERT(0);
}
break;
case REGISTER_EDITOR:
switch (item_idx)
{
case 0:
sprintf(info_ptr->item_name_ptr,"REG Addr.");
info_ptr->item_value=0;
info_ptr->is_true_false=KAL_FALSE;
info_ptr->is_read_only=KAL_FALSE;
info_ptr->is_need_restart=KAL_FALSE;
info_ptr->min=0;
info_ptr->max=0xFFFF;
break;
case 1:
sprintf(info_ptr->item_name_ptr,"REG Value");
info_ptr->item_value=0;
info_ptr->is_true_false=KAL_FALSE;
info_ptr->is_read_only=KAL_FALSE;
info_ptr->is_need_restart=KAL_FALSE;
info_ptr->min=0;
info_ptr->max=0xFFFF;
break;
default:
ASSERT(0);
}
break;
default:
ASSERT(0);
}
}
kal_bool set_sensor_item_info(kal_uint16 group_idx, kal_uint16 item_idx, kal_int32 item_value)
{
kal_int16 temp_reg;
kal_uint16 temp_gain, temp_addr, temp_para;
switch (group_idx)
{
case PRE_GAIN:
switch (item_idx)
{
case 0:
temp_addr = PRE_GAIN_R_INDEX;
break;
case 1:
temp_addr = PRE_GAIN_Gr_INDEX;
break;
case 2:
temp_addr = PRE_GAIN_Gb_INDEX;
break;
case 3:
temp_addr = PRE_GAIN_B_INDEX;
break;
case 4:
temp_addr = SENSOR_BASEGAIN;
break;
default:
ASSERT(0);
}
temp_gain=((item_value*BASEGAIN+500)/1000); //+500:get closed integer value
if((temp_gain>=BASEGAIN) && (temp_gain<(2*BASEGAIN)))
{
temp_para=(temp_gain*32+BASEGAIN/2)/BASEGAIN;
}
else if((temp_gain>=(2*BASEGAIN)) && (temp_gain<(8*BASEGAIN)))
{
temp_para=(temp_gain*16+BASEGAIN/2)/BASEGAIN+128;
}
else if((temp_gain>=(8*BASEGAIN)) && (temp_gain<(16*BASEGAIN)))
{
temp_para=(temp_gain*8+BASEGAIN/2)/BASEGAIN+384;
}
else if(temp_gain>=(16*BASEGAIN))
{
temp_para=(kal_uint16)((15.875*BASEGAIN*8+BASEGAIN/2)/BASEGAIN+384);
}
else
return KAL_FALSE;
camera_para.SENSOR.cct[temp_addr].para = temp_para;
if(temp_addr != SENSOR_BASEGAIN)
{
write_MT9D011_reg(camera_para.SENSOR.cct[temp_addr].addr,temp_para);
}
sensor_gain_base=read_MT9D011_gain();
if(temp_addr == SENSOR_BASEGAIN)
{
write_MT9D011_gain(BASEGAIN);
}
break;
case CMMCLK_CURRENT:
switch (item_idx)
{
case 0:
if(item_value==2)
{
camera_para.SENSOR.reg[CMMCLK_CURRENT_INDEX].para = ISP_DRIVING_2MA;
set_isp_driving_current(ISP_DRIVING_2MA);
}
else if(item_value==3 || item_value==4)
{
camera_para.SENSOR.reg[CMMCLK_CURRENT_INDEX].para = ISP_DRIVING_4MA;
set_isp_driving_current(ISP_DRIVING_4MA);
}
else if(item_value==5 || item_value==6)
{
camera_para.SENSOR.reg[CMMCLK_CURRENT_INDEX].para = ISP_DRIVING_6MA;
set_isp_driving_current(ISP_DRIVING_6MA);
}
else
{
camera_para.SENSOR.reg[CMMCLK_CURRENT_INDEX].para = ISP_DRIVING_8MA;
set_isp_driving_current(ISP_DRIVING_8MA);
}
break;
default:
ASSERT(0);
}
break;
case FRAME_RATE_LIMITATION:
switch (item_idx)
{
ASSERT(0);
}
break;
case REGISTER_EDITOR:
switch (item_idx)
{
case 0:
FAC_SENSOR_REG=item_value;
break;
case 1:
write_MT9D011_reg(FAC_SENSOR_REG,item_value);
break;
default:
ASSERT(0);
}
break;
default:
ASSERT(0);
}
return KAL_TRUE;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -