sadmen
/
openpilot_comma
mirror of https://github.com/commaai/openpilot.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

improved AE

Browse Source
pull/2047/head
Tici Engineer 5 years ago
parent a413f0577a
commit 4ad001665d
3 changed files with 123 additions and 128 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 212
      selfdrive/camerad/cameras/camera_qcom2.c
  2. 5
      selfdrive/camerad/cameras/camera_qcom2.h
  3. 34
      selfdrive/camerad/cameras/sensor2_i2c.h

212
selfdrive/camerad/cameras/camera_qcom2.c
Unescape View File

@ -1,4 +1,4 @@
#include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
@ -356,8 +356,11 @@ void sensors_init(int video0_fd, int sensor_fd, int camera_num) {
int ret = cam_control(sensor_fd, CAM_SENSOR_PROBE_CMD, (void *)cam_packet_handle, 0); int ret = cam_control(sensor_fd, CAM_SENSOR_PROBE_CMD, (void *)cam_packet_handle, 0);
assert(ret == 0); assert(ret == 0);
munmap(i2c_info, buf_desc[0].size);
release_fd(video0_fd, buf_desc[0].mem_handle); release_fd(video0_fd, buf_desc[0].mem_handle);
munmap(power, buf_desc[1].size);
release_fd(video0_fd, buf_desc[1].mem_handle); release_fd(video0_fd, buf_desc[1].mem_handle);
munmap(pkt, size);
release_fd(video0_fd, cam_packet_handle); release_fd(video0_fd, cam_packet_handle);
} }
@ -478,15 +481,14 @@ void config_isp(struct CameraState *s, int io_mem_handle, int fence, int request
void enqueue_buffer(struct CameraState *s, int i) { void enqueue_buffer(struct CameraState *s, int i) {
int ret; int ret;
int request_id = s->frame_id; //(++s->sched_request_id); int request_id = s->frame_id; //(++s->sched_request_id);
if (s->buf_handle[i]) { if (s->buf_handle[i]) {
release(s->video0_fd, s->buf_handle[i]); release(s->video0_fd, s->buf_handle[i]);
// wait // wait
struct cam_sync_wait sync_wait = {0}; //struct cam_sync_wait sync_wait = {0};
sync_wait.sync_obj = s->sync_objs[i]; //sync_wait.sync_obj = s->sync_objs[i];
sync_wait.timeout_ms = 50; //sync_wait.timeout_ms = 175;
ret = cam_control(s->video1_fd, CAM_SYNC_WAIT, &sync_wait, sizeof(sync_wait)); //ret = cam_control(s->video1_fd, CAM_SYNC_WAIT, &sync_wait, sizeof(sync_wait));
LOGD("fence wait: %d %d", ret, sync_wait.sync_obj); //LOGD("fence wait: %d %d", ret, sync_wait.sync_obj);
// destroy old output fence // destroy old output fence
struct cam_sync_info sync_destroy = {0}; struct cam_sync_info sync_destroy = {0};
@ -495,28 +497,16 @@ void enqueue_buffer(struct CameraState *s, int i) {
ret = cam_control(s->video1_fd, CAM_SYNC_DESTROY, &sync_destroy, sizeof(sync_destroy)); ret = cam_control(s->video1_fd, CAM_SYNC_DESTROY, &sync_destroy, sizeof(sync_destroy));
LOGD("fence destroy: %d %d", ret, sync_destroy.sync_obj); LOGD("fence destroy: %d %d", ret, sync_destroy.sync_obj);
} }
// new request_ids // new request_ids
s->request_ids[i] = request_id; s->request_ids[i] = request_id;
// do stuff // do stuff
if (request_id >= -1) {
struct cam_req_mgr_sched_request req_mgr_sched_request = {0}; struct cam_req_mgr_sched_request req_mgr_sched_request = {0};
req_mgr_sched_request.session_hdl = s->session_handle; req_mgr_sched_request.session_hdl = s->session_handle;
req_mgr_sched_request.link_hdl = s->link_handle; req_mgr_sched_request.link_hdl = s->link_handle;
req_mgr_sched_request.req_id = request_id; req_mgr_sched_request.req_id = request_id;
ret = cam_control(s->video0_fd, CAM_REQ_MGR_SCHED_REQ, &req_mgr_sched_request, sizeof(req_mgr_sched_request)); ret = cam_control(s->video0_fd, CAM_REQ_MGR_SCHED_REQ, &req_mgr_sched_request, sizeof(req_mgr_sched_request));
LOGD("sched req: %d %d", ret, request_id); LOGD("sched req: %d %d", ret, request_id);
} else {
struct cam_req_mgr_flush_info req_mgr_flush_request = {0};
req_mgr_flush_request.session_hdl = s->session_handle;
req_mgr_flush_request.link_hdl = s->link_handle;
req_mgr_flush_request.req_id = request_id;
req_mgr_flush_request.flush_type = CAM_REQ_MGR_FLUSH_TYPE_CANCEL_REQ;
ret = cam_control(s->video0_fd, CAM_REQ_MGR_FLUSH_REQ, &req_mgr_flush_request, sizeof(req_mgr_flush_request));
LOGD("flush req: %d %d", ret, request_id);
return;
}
// create output fence // create output fence
struct cam_sync_info sync_create = {0}; struct cam_sync_info sync_create = {0};
@ -572,8 +562,14 @@ static void camera_init(CameraState *s, int camera_id, int camera_num, unsigned
}}; }};
s->digital_gain = 1.0; s->digital_gain = 1.0;
s->digital_gain_pre = 4; // for WB s->digital_gain_pre = 4; // for WB
s->dc_opstate = 0;
s->dc_gain_enabled = false;
s->analog_gain_frac = 1.0; s->analog_gain_frac = 1.0;
s->analog_gain = 0x8;
s->exposure_time = 598; s->exposure_time = 598;
s->frame_id = -1;
s->first = true;
//s->missed_frame = 0;
} }
static void camera_open(CameraState *s, VisionBuf* b) { static void camera_open(CameraState *s, VisionBuf* b) {
@ -782,27 +778,17 @@ static void camera_open(CameraState *s, VisionBuf* b) {
req_mgr_link_control.link_hdls[0] = s->link_handle; req_mgr_link_control.link_hdls[0] = s->link_handle;
ret = cam_control(s->video0_fd, CAM_REQ_MGR_LINK_CONTROL, &req_mgr_link_control, sizeof(req_mgr_link_control)); ret = cam_control(s->video0_fd, CAM_REQ_MGR_LINK_CONTROL, &req_mgr_link_control, sizeof(req_mgr_link_control));
LOGD("link control: %d", ret); LOGD("link control: %d", ret);
// start devices
//LOG("-- Start devices");
//ret = device_control(s->isp_fd, CAM_START_DEV, s->session_handle, s->isp_dev_handle);
//LOGD("start isp: %d", ret);
//ret = device_control(s->csiphy_fd, CAM_START_DEV, s->session_handle, s->csiphy_dev_handle);
//LOGD("start csiphy: %d", ret);
//ret = device_control(s->sensor_fd, CAM_START_DEV, s->session_handle, s->sensor_dev_handle);
//LOGD("start sensor: %d", ret);
} }
void cameras_init(DualCameraState *s) { void cameras_init(DualCameraState *s) {
camera_init(&s->rear, CAMERA_ID_AR0231, 0, 20); camera_init(&s->rear, CAMERA_ID_AR0231, 1, 20);
printf("rear initted \n"); printf("rear initted \n");
camera_init(&s->wide, CAMERA_ID_AR0231, 1, 20); camera_init(&s->wide, CAMERA_ID_AR0231, 0, 20);
printf("wide initted \n"); printf("wide initted \n");
camera_init(&s->front, CAMERA_ID_AR0231, 2, 20); camera_init(&s->front, CAMERA_ID_AR0231, 2, 20);
printf("front initted \n"); printf("front initted \n");
#ifdef NOSCREEN #ifdef NOSCREEN
zsock_t *rgb_sock = zsock_new_push("tcp://192.168.5.1:7768"); zsock_t *rgb_sock = zsock_new_push("tcp://192.168.2.191:7768");
assert(rgb_sock); assert(rgb_sock);
s->rgb_sock = rgb_sock; s->rgb_sock = rgb_sock;
#endif #endif
@ -850,9 +836,9 @@ void cameras_open(DualCameraState *s, VisionBuf *camera_bufs_rear, VisionBuf *ca
LOG("-- Subscribing"); LOG("-- Subscribing");
static struct v4l2_event_subscription sub = {0}; static struct v4l2_event_subscription sub = {0};
sub.type = 0x8000000; sub.type = 0x8000000;
sub.id = 0; // SOF sub.id = 2; // should use boot time for sof
ret = ioctl(s->video0_fd, VIDIOC_SUBSCRIBE_EVENT, &sub); ret = ioctl(s->video0_fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
LOGD("req mgr subscribe: %d", ret); printf("req mgr subscribe: %d\n", ret);
camera_open(&s->rear, camera_bufs_rear); camera_open(&s->rear, camera_bufs_rear);
printf("rear opened \n"); printf("rear opened \n");
@ -929,17 +915,17 @@ struct video_event_data {
void cameras_run(DualCameraState *s) { void cameras_run(DualCameraState *s) {
// start devices // start devices
LOG("-- Start devices"); LOG("-- Start devices");
int ret = device_control(s->rear.isp_fd, CAM_START_DEV, s->rear.session_handle, s->rear.isp_dev_handle); int ret = device_control(s->rear.csiphy_fd, CAM_START_DEV, s->rear.session_handle, s->rear.csiphy_dev_handle);
ret = device_control(s->rear.isp_fd, CAM_START_DEV, s->rear.session_handle, s->rear.isp_dev_handle);
ret = device_control(s->rear.sensor_fd, CAM_START_DEV, s->rear.session_handle, s->rear.sensor_dev_handle);
ret = device_control(s->wide.csiphy_fd, CAM_START_DEV, s->wide.session_handle, s->wide.csiphy_dev_handle);
ret = device_control(s->wide.isp_fd, CAM_START_DEV, s->wide.session_handle, s->wide.isp_dev_handle); ret = device_control(s->wide.isp_fd, CAM_START_DEV, s->wide.session_handle, s->wide.isp_dev_handle);
ret = device_control(s->wide.sensor_fd, CAM_START_DEV, s->wide.session_handle, s->wide.sensor_dev_handle);
ret = device_control(s->front.csiphy_fd, CAM_START_DEV, s->front.session_handle, s->front.csiphy_dev_handle);
ret = device_control(s->front.isp_fd, CAM_START_DEV, s->front.session_handle, s->front.isp_dev_handle); ret = device_control(s->front.isp_fd, CAM_START_DEV, s->front.session_handle, s->front.isp_dev_handle);
ret = device_control(s->front.sensor_fd, CAM_START_DEV, s->front.session_handle, s->front.sensor_dev_handle);
LOGD("start isp: %d", ret); LOGD("start isp: %d", ret);
ret = device_control(s->rear.csiphy_fd, CAM_START_DEV, s->rear.session_handle, s->rear.csiphy_dev_handle);
ret = device_control(s->wide.csiphy_fd, CAM_START_DEV, s->wide.session_handle, s->wide.csiphy_dev_handle);
ret = device_control(s->front.csiphy_fd, CAM_START_DEV, s->front.session_handle, s->front.csiphy_dev_handle);
LOGD("start csiphy: %d", ret); LOGD("start csiphy: %d", ret);
ret = device_control(s->rear.sensor_fd, CAM_START_DEV, s->rear.session_handle, s->rear.sensor_dev_handle);
ret = device_control(s->wide.sensor_fd, CAM_START_DEV, s->wide.session_handle, s->wide.sensor_dev_handle);
ret = device_control(s->front.sensor_fd, CAM_START_DEV, s->front.session_handle, s->front.sensor_dev_handle);
LOGD("start sensor: %d", ret); LOGD("start sensor: %d", ret);
// poll events // poll events
@ -958,44 +944,52 @@ void cameras_run(DualCameraState *s) {
} }
if (!fds[0].revents) continue; if (!fds[0].revents) continue;
static struct v4l2_event ev = {0}; struct v4l2_event ev = {0};
ret = ioctl(fds[0].fd, VIDIOC_DQEVENT, &ev); ret = ioctl(fds[0].fd, VIDIOC_DQEVENT, &ev);
if (ev.type == 0x8000000) { if (ev.type == 0x8000000) {
struct video_event_data *event_data = (struct video_event_data *)ev.u.data; struct cam_req_mgr_message *event_data = (struct cam_req_mgr_message *)ev.u.data;
printf("sess_hdl %d, link_hdl %d, frame_id %d, reserved %d, req_id %lld, tv_sec %lld, tv_usec %lld\n", event_data->session_hdl, event_data->link_hdl, event_data->frame_id, event_data->reserved, event_data->req_id, event_data->tv_sec, event_data->tv_usec); printf("sess_hdl %d, link_hdl %d, frame_id %d, reserved %d, req_id %lld, timestamp 0x%llx, sof_status %d\n", event_data->session_hdl, event_data->u.frame_msg.link_hdl, event_data->u.frame_msg.frame_id, event_data->reserved, event_data->u.frame_msg.request_id, event_data->u.frame_msg.timestamp, event_data->u.frame_msg.sof_status);
uint64_t timestamp = event_data->u.frame_msg.timestamp;
uint64_t timestamp = (event_data->tv_sec*1000000000ULL // LOGD("video0 dqevent: %d type:0x%x frame_id:%d timestamp: %llx", ret, ev.type, event_data->frame_id, event_data->tv_sec); // TODO:copy items from printf
+ event_data->tv_usec*1000);
LOGD("video0 dqevent: %d type:0x%x frame_id:%d timestamp: %llu", ret, ev.type, event_data->frame_id, timestamp); if (event_data->u.frame_msg.request_id != 0 || (event_data->u.frame_msg.request_id == 0 &&
((s->rear.first && event_data->session_hdl == s->rear.req_mgr_session_info.session_hdl) ||
if (event_data->req_id != 0) { (s->wide.first && event_data->session_hdl == s->wide.req_mgr_session_info.session_hdl) ||
(s->front.first && event_data->session_hdl == s->front.req_mgr_session_info.session_hdl)))) {
if (event_data->session_hdl == s->rear.req_mgr_session_info.session_hdl) { if (event_data->session_hdl == s->rear.req_mgr_session_info.session_hdl) {
s->rear.frame_id = event_data->req_id; //s->rear.frame_id++;// = event_data->u.frame_msg.request_id;
s->rear.frame_id++;
if (event_data->u.frame_msg.request_id > 0) {s->rear.first = false;}
int buf_idx = s->rear.frame_id % FRAME_BUF_COUNT; int buf_idx = s->rear.frame_id % FRAME_BUF_COUNT;
printf("rear %d\n", s->rear.frame_id); //printf("rear %d\n", s->rear.frame_id);
tbuffer_dispatch(&s->rear.camera_tb, buf_idx);
s->rear.camera_bufs_metadata[buf_idx].frame_id = s->rear.frame_id; s->rear.camera_bufs_metadata[buf_idx].frame_id = s->rear.frame_id;
s->rear.camera_bufs_metadata[buf_idx].timestamp_eof = event_data->tv_sec; // not exactly eof s->rear.camera_bufs_metadata[buf_idx].timestamp_eof = timestamp; // only has sof?
tbuffer_dispatch(&s->rear.camera_tb, buf_idx);
} else if (event_data->session_hdl == s->wide.req_mgr_session_info.session_hdl) { } else if (event_data->session_hdl == s->wide.req_mgr_session_info.session_hdl) {
s->wide.frame_id = event_data->req_id; //s->wide.frame_id = event_data->u.frame_msg.request_id;
s->wide.frame_id++;
if (event_data->u.frame_msg.request_id > 0) {s->wide.first = false;}
int buf_idx = s->wide.frame_id % FRAME_BUF_COUNT; int buf_idx = s->wide.frame_id % FRAME_BUF_COUNT;
printf("wide %d\n", s->wide.frame_id); //printf("wide %d\n", s->wide.frame_id);
tbuffer_dispatch(&s->wide.camera_tb, buf_idx);
s->wide.camera_bufs_metadata[buf_idx].frame_id = s->wide.frame_id; s->wide.camera_bufs_metadata[buf_idx].frame_id = s->wide.frame_id;
s->wide.camera_bufs_metadata[buf_idx].timestamp_eof = event_data->tv_sec; s->wide.camera_bufs_metadata[buf_idx].timestamp_eof = timestamp;
tbuffer_dispatch(&s->wide.camera_tb, buf_idx);
} else if (event_data->session_hdl == s->front.req_mgr_session_info.session_hdl) { } else if (event_data->session_hdl == s->front.req_mgr_session_info.session_hdl) {
s->front.frame_id = event_data->req_id; //s->front.frame_id = event_data->u.frame_msg.request_id;
s->front.frame_id++;
if (event_data->u.frame_msg.request_id > 0) {s->front.first = false;}
int buf_idx = s->front.frame_id % FRAME_BUF_COUNT; int buf_idx = s->front.frame_id % FRAME_BUF_COUNT;
printf("front %d\n", s->front.frame_id); //printf("front %d\n", s->front.frame_id);
tbuffer_dispatch(&s->front.camera_tb, buf_idx);
s->front.camera_bufs_metadata[buf_idx].frame_id = s->front.frame_id; s->front.camera_bufs_metadata[buf_idx].frame_id = s->front.frame_id;
s->front.camera_bufs_metadata[buf_idx].timestamp_eof = event_data->tv_sec; s->front.camera_bufs_metadata[buf_idx].timestamp_eof = timestamp;
tbuffer_dispatch(&s->front.camera_tb, buf_idx);
} else { } else {
printf("Unknown vidioc event source\n"); printf("Unknown vidioc event source\n");
assert(false); assert(false);
} }
} }
// printf("current frames: %d, %d, %d \n", s->rear.frame_id, s->wide.frame_id, s->front.frame_id);
} }
} }
@ -1005,83 +999,65 @@ void cameras_run(DualCameraState *s) {
void camera_autoexposure(CameraState *s, float grey_frac) { void camera_autoexposure(CameraState *s, float grey_frac) {
// TODO: get stats from sensor // TODO: get stats from sensor
const float target_grey = 0.3; const float target_grey = 0.3;
const float analog_gain_frac_min = 0.25; const float analog_gain_frac_min = 0.25;
const float analog_gain_frac_max = 8.0; const float analog_gain_frac_max = 8.0;
const float digital_gain_min = 1.0; const float digital_gain_min = 1.0;
const float digital_gain_max = 3.99; // is the correct? const float digital_gain_max = 3.99; // is the correct?
const int exposure_time_min = 16; const int exposure_time_min = 64;
const int exposure_time_max = 1417; // no slower than 1/25 sec. calculated from 0x300C and clock freq const int exposure_time_max = 1416; // no slower than 1/25 sec. calculated from 0x300C and clock freq
float exposure_factor = pow(1.05, (target_grey - grey_frac) / 0.16 );
float exposure_factor = pow(1.05, (target_grey - grey_frac) / 0.1 ); // TODO: to be calibrated
if (s->analog_gain_frac > 2.0 && exposure_factor > 1 && !s->dc_gain_enabled && s->dc_opstate != 1) { // iso 1600
s->dc_gain_enabled = true;
printf("cam %d grey_frac is %f, ef is %f\n", s->camera_num, grey_frac, exposure_factor); s->analog_gain_frac *= 0.5;
if (s->analog_gain_frac >= 3 && exposure_factor < 1) { // set gain down if full gain and over exposed s->dc_opstate = 1;
s->analog_gain_frac *= exposure_factor; } else if (s->analog_gain_frac < 0.5 && exposure_factor < 1 && s->dc_gain_enabled && s->dc_opstate != 1) { // iso 400
} else if (s->exposure_time * exposure_factor <= exposure_time_max && s->exposure_time * exposure_factor >= exposure_time_min) { // adjust exposure time first s->dc_gain_enabled = false;
s->exposure_time *= exposure_factor; s->analog_gain_frac *= 2;
} else if (s->analog_gain_frac * exposure_factor <= analog_gain_frac_max && s->analog_gain_frac * exposure_factor >= analog_gain_frac_min) { s->dc_opstate = 1;
s->analog_gain_frac *= exposure_factor; } else if (s->analog_gain_frac > 0.5 && exposure_factor < 0.9) {
s->analog_gain_frac *= sqrt(exposure_factor);
s->exposure_time = max(min(s->exposure_time * sqrt(exposure_factor), exposure_time_max),exposure_time_min);
s->dc_opstate = 0;
} else if ((s->exposure_time < exposure_time_max || exposure_factor < 1) && (s->exposure_time > exposure_time_min || exposure_factor > 1)) {
s->exposure_time = max(min(s->exposure_time * exposure_factor, exposure_time_max),exposure_time_min);
s->dc_opstate = 0;
} else {
s->analog_gain_frac = max(min(s->analog_gain_frac * exposure_factor, analog_gain_frac_max),analog_gain_frac_min);
s->dc_opstate = 0;
} }
// set up config // set up config
// gain mapping: [1/8, 2/8, 2/7, 3/7, 3/6, 4/6, 4/5, 5/5, 5/4, 6/4, 6/3, 7/3, 7/2, 8/2, 8/1, N/A] -> 0 to 15 // gain mapping: [1/8, 2/8, 2/7, 3/7, 3/6, 4/6, 4/5, 5/5, 5/4, 6/4, 6/3, 7/3, 7/2, 8/2, 8/1, N/A] -> 0 to 15
uint16_t AG; uint16_t AG;
if (s->analog_gain_frac > 5.5) { if (s->analog_gain_frac > 4) {
s->analog_gain_frac = 8.0; s->analog_gain_frac = 8.0;
AG = 0xEEEE; AG = 0xEEEE;
printf("cam %d gain_frac is %f, set AG to 0x%X, S to %d \n", s->camera_num, s->analog_gain_frac, AG, s->exposure_time); // printf("cam %d gain_frac is %f, set AG to 0x%X, S to %d, dc %d \n", s->camera_num, s->analog_gain_frac, AG, s->exposure_time, s->dc_gain_enabled);
} else { } else {
AG = -(1.147 * s->analog_gain_frac * s->analog_gain_frac) + (7.67 * s->analog_gain_frac) - 0.1; AG = -(1.147 * s->analog_gain_frac * s->analog_gain_frac) + (7.67 * s->analog_gain_frac) - 0.1;
if (AG - s->analog_gain == -1) {AG = s->analog_gain;}
s->analog_gain = AG;
AG = AG * 4096 + AG * 256 + AG * 16 + AG; AG = AG * 4096 + AG * 256 + AG * 16 + AG;
printf("cam %d gain_frac is %f, set AG to 0x%X, S to %d \n", s->camera_num, s->analog_gain_frac, AG, s->exposure_time); // printf("cam %d gain_frac is %f, set AG to 0x%X, S to %d, dc %d \n", s->camera_num, s->analog_gain_frac, AG, s->exposure_time, s->dc_gain_enabled);
} }
struct i2c_random_wr_payload exp_reg_array[] = {{0x3366, 0x1111}, // analog gain struct i2c_random_wr_payload exp_reg_array[] = {{0x3366, AG}, // analog gain
{0x305A, 0x0075}, // RED_GAIN BB {0x318E, 0x0200}, // PRE_HDR_GAIN_EN
{0x3058, 0x00FA}, // BLUE_GAIN 12A {0x3362, s->dc_gain_enabled?0x01:0x00}, // DC_GAIN
{0x3056, 0x0080}, // GREEN1_GAIN
{0x305C, 0x0080}, // GREEN2_GAIN
{0x3012, s->exposure_time}}; // integ time {0x3012, s->exposure_time}}; // integ time
sensors_i2c(s, exp_reg_array, sizeof(exp_reg_array)/sizeof(struct i2c_random_wr_payload), sensors_i2c(s, exp_reg_array, sizeof(exp_reg_array)/sizeof(struct i2c_random_wr_payload),
CAM_SENSOR_PACKET_OPCODE_SENSOR_CONFIG); CAM_SENSOR_PACKET_OPCODE_SENSOR_CONFIG);
/*
FILE *evfile;
evfile = fopen("./exp", "r");
if (!evfile) {
struct i2c_random_wr_payload exp_reg_array[] = {{0x3366, 0x7777}, // analog gain
// {0x3056, 0x0080}, // G1
// {0x3058, 0x012A}, // B
// {0x305A, 0x00A0}, // R
// {0x305C, 0x0080}, // G2
// {0x305E, 0x0080}, // global digi gain
{0x3012, 0x0312}}; // integ time
sensors_i2c(s, exp_reg_array, sizeof(exp_reg_array)/sizeof(struct i2c_random_wr_payload),
CAM_SENSOR_PACKET_OPCODE_SENSOR_CONFIG);
} else {
uint16_t A = 0;
uint16_t T = 0;
fscanf(evfile, "%x,", &A);
fscanf(evfile, "%x,", &T);
struct i2c_random_wr_payload exp_reg_array[] = {{0x3366, A}, // analog gain
{0x3012, T}}; // integ time
sensors_i2c(s, exp_reg_array, sizeof(exp_reg_array)/sizeof(struct i2c_random_wr_payload),
CAM_SENSOR_PACKET_OPCODE_SENSOR_CONFIG);
fclose(evfile);
}
*/
} }
#ifdef NOSCREEN #ifdef NOSCREEN
void sendrgb(DualCameraState *s, uint8_t* dat, int len, uint8_t cam_id) { void sendrgb(DualCameraState *s, uint8_t* dat, int len, uint8_t cam_id) {
int err, err2; int err, err2;
int scale = 3; int scale = 4;
int old_width = FRAME_WIDTH / 2; int old_width = FRAME_WIDTH;
int old_height = FRAME_HEIGHT / 2; int old_height = FRAME_HEIGHT;
int new_width = FRAME_WIDTH / 2 / scale; int new_width = FRAME_WIDTH / scale;
int new_height = FRAME_HEIGHT / 2 / scale; int new_height = FRAME_HEIGHT / scale;
uint8_t resized_dat[new_width*new_height*3]; uint8_t resized_dat[new_width*new_height*3];
memset(&resized_dat, cam_id, 3); memset(&resized_dat, cam_id, 3);
for (uint32_t r=1;r<new_height;r++) { for (uint32_t r=1;r<new_height;r++) {
@ -1091,7 +1067,7 @@ void sendrgb(DualCameraState *s, uint8_t* dat, int len, uint8_t cam_id) {
resized_dat[(r*new_width+c)*3+2] = dat[(r*old_width + c)*scale*3+2]; resized_dat[(r*new_width+c)*3+2] = dat[(r*old_width + c)*scale*3+2];
} }
} }
err = zmq_send(zsock_resolve(s->rgb_sock), &resized_dat, new_width*new_height*3, ZMQ_DONTWAIT); err = zmq_send(zsock_resolve(s->rgb_sock), &resized_dat, new_width*new_height*3, 0);
err2 = zmq_errno(); err2 = zmq_errno();
//printf("zmq errcode %d, %d\n", err ,err2); //printf("zmq errcode %d, %d\n", err ,err2);
} }

5
selfdrive/camerad/cameras/camera_qcom2.h
Unescape View File

@ -31,7 +31,11 @@ typedef struct CameraState {
float digital_gain; float digital_gain;
int digital_gain_pre; int digital_gain_pre;
float analog_gain_frac; float analog_gain_frac;
uint16_t analog_gain;
uint8_t dc_opstate;
bool dc_gain_enabled;
int exposure_time; int exposure_time;
mat3 transform; mat3 transform;
int device_iommu; int device_iommu;
@ -61,6 +65,7 @@ typedef struct CameraState {
int request_ids[FRAME_BUF_COUNT]; int request_ids[FRAME_BUF_COUNT];
int sync_objs[FRAME_BUF_COUNT]; int sync_objs[FRAME_BUF_COUNT];
int frame_id; int frame_id;
bool first;
struct cam_req_mgr_session_info req_mgr_session_info; struct cam_req_mgr_session_info req_mgr_session_info;

34
selfdrive/camerad/cameras/sensor2_i2c.h
Unescape View File

@ -4,7 +4,6 @@ struct i2c_random_wr_payload stop_reg_array[] = {{0x301a, 0x18}};;
struct i2c_random_wr_payload init_array_ar0231[] = { struct i2c_random_wr_payload init_array_ar0231[] = {
{0x301A, 0x0018}, // RESET_REGISTER {0x301A, 0x0018}, // RESET_REGISTER
// //
{0x3092, 0x0C24}, // ROW_NOISE_CONTROL {0x3092, 0x0C24}, // ROW_NOISE_CONTROL
{0x337A, 0x0C80}, // DBLC_SCALE0 {0x337A, 0x0C80}, // DBLC_SCALE0
@ -278,6 +277,21 @@ struct i2c_random_wr_payload init_array_ar0231[] = {
{0x30BA, 0x11F2}, // DIGITAL_CTRL {0x30BA, 0x11F2}, // DIGITAL_CTRL
{0x3044, 0x0400}, // DARK_CONTROL {0x3044, 0x0400}, // DARK_CONTROL
{0x3064, 0x1802}, // SMIA_TEST {0x3064, 0x1802}, // SMIA_TEST
/*{0x3064, 0xCC2}, // STATS_EN
{0x3270, 0x10}, //
{0x3272, 0x30}, //
{0x3274, 0x50}, //
{0x3276, 0x10}, //
{0x3278, 0x30}, //
{0x327A, 0x50}, //
{0x3144, 0x0}, //
{0x3146, 0x0}, //
{0x3244, 0x0}, //
{0x3246, 0x0}, //
{0x3268, 0x0}, //
{0x326A, 0x0}, //
*/
{0x33E0, 0x0C80}, // TEST_ASIL_ROWS {0x33E0, 0x0C80}, // TEST_ASIL_ROWS
{0x3180, 0x0080}, // RESERVED_MFR_3180 {0x3180, 0x0080}, // RESERVED_MFR_3180
{0x33E4, 0x0080}, // RESERVED_MFR_33E4 {0x33E4, 0x0080}, // RESERVED_MFR_33E4
@ -321,8 +335,8 @@ struct i2c_random_wr_payload init_array_ar0231[] = {
{0x301A, 0x001C}, // RESET_REGISTER {0x301A, 0x001C}, // RESET_REGISTER
// HDR Settings // HDR Settings
{0x3082, 0x0004}, // OPERATION_MODE_CTRL {0x3082, 0x000C}, // OPERATION_MODE_CTRL
{0x3238, 0x0666}, // EXPOSURE_RATIO {0x3238, 0x0222}, // EXPOSURE_RATIO
{0x3014, 0x098E}, // FINE_INTEGRATION_TIME_ {0x3014, 0x098E}, // FINE_INTEGRATION_TIME_
{0x321E, 0x098E}, // FINE_INTEGRATION_TIME2 {0x321E, 0x098E}, // FINE_INTEGRATION_TIME2
{0x3222, 0x098E}, // FINE_INTEGRATION_TIME3 {0x3222, 0x098E}, // FINE_INTEGRATION_TIME3
@ -330,19 +344,19 @@ struct i2c_random_wr_payload init_array_ar0231[] = {
{0x30B0, 0x0800}, // DIGITAL_TEST {0x30B0, 0x0800}, // DIGITAL_TEST
{0x32EA, 0x3C0E}, // RESERVED_MFR_32EA {0x32EA, 0x3C0E}, // RESERVED_MFR_32EA
{0x32EC, 0x72A1}, // RESERVED_MFR_32EC {0x32EC, 0x72A1}, // RESERVED_MFR_32EC
{0x31D0, 0x0000}, // COMPANDING, no good in 10 bit? {0x31D0, 0x0001}, // COMPANDING, no good in 10 bit?
//{0x33DA, 0x0001}, // COMPANDING {0x33DA, 0x0001}, // COMPANDING
{0x3362, 0x0002}, // DC GAIN {0x3362, 0x0000}, // DC GAIN
{0x3370, 0x0001}, // DBLC {0x3370, 0x0231}, // DBLC
{0x318E, 0x0200}, // PRE_HDR_GAIN_EN {0x318E, 0x0200}, // PRE_HDR_GAIN_EN
// Initial Gains // Initial Gains
{0x3022, 0x01}, // GROUPED_PARAMETER_HOLD_ {0x3022, 0x01}, // GROUPED_PARAMETER_HOLD_
{0x3366, 0x7777}, // ANALOG_GAIN {0x3366, 0x7777}, // ANALOG_GAIN
//{0x3060, 0xAAAA}, // ANALOG_COLOR_GAIN //{0x3060, 0xAAAA}, // ANALOG_COLOR_GAIN
{0x3060, 0x5655}, // ANALOG_COLOR_GAIN {0x3060, 0x7777}, // ANALOG_COLOR_GAIN
{0x305A, 0x0080}, // RED_GAIN {0x305A, 0x00BB}, // RED_GAIN 75
{0x3058, 0x0080}, // BLUE_GAIN {0x3058, 0x0111}, // BLUE_GAIN FA
{0x3056, 0x0080}, // GREEN1_GAIN {0x3056, 0x0080}, // GREEN1_GAIN
{0x305C, 0x0080}, // GREEN2_GAIN {0x305C, 0x0080}, // GREEN2_GAIN
{0x3022, 0x00}, // GROUPED_PARAMETER_HOLD_ {0x3022, 0x00}, // GROUPED_PARAMETER_HOLD_

Write Preview
Loading…
Cancel
Save