ppifcd_test.c

This is the source code of Camera driver for OV2640 camera from OmniVision using in Blackfin platfor

	pa_pParameter[172] 	= 0xDA04;
	pa_pParameter[173] 	= 0xD382;
	pa_pParameter[174] 	= 0xE000;

	count = 175;
#endif

	for (i = 0; i < count; i++) {
		i2c_write_register(I2C_DEVICE, DEVID, pa_pParameter[i]>>8, 0xFF & pa_pParameter[i]);
	}
	return count;
}

/*
 *  Return the difference between two struct timevals in microseconds
 */
long tvdelta(struct timeval *t1, struct timeval *t2)
{
	long delta, usec;

	delta = 1000000 * (t1->tv_sec - t2->tv_sec);
	usec = t1->tv_usec;
	if (t1->tv_usec < t2->tv_usec) {
		usec += 1000000;
		delta -= 1000000;
	}
	delta += (usec - t2->tv_usec);

	return delta;
}

long getoffset(void)
{
	int i;
	struct timeval t, o;
	long delta = 0;

	for (i = 0; i < AVERAGE; i++) {
		gettimeofday(&o, NULL);
		gettimeofday(&t, NULL);
		delta += tvdelta(&t, &o);
	}

	return (delta / AVERAGE);
}

long calculate_total_frame_time(void)
{
	long row_time, total_frame_time;

	row_time = ((i2c_read_register(I2C_DEVICE, DEVID, 0x04) + 1)
		    + (244 + i2c_read_register(I2C_DEVICE, DEVID, 0x05) - 19));

	total_frame_time = (i2c_read_register(I2C_DEVICE, DEVID, 0x03) + 1
			    + i2c_read_register(I2C_DEVICE, DEVID, 0x06) + 1)
	    * row_time;
	printf
	    ("************* Calculated Times Based on the actual Camera setting *************\n");
	printf("Master Clock = \t\t%d MHz \n", MASTERCLOCK);
	printf
	    ("row_time = \t\t%d pixel clocks\ntotal_frame_time = \t%d pixel clocks\ntotal_frame_time = \t%d usec\n",
	     row_time, total_frame_time, total_frame_time / MASTERCLOCK);
	printf
	    ("*******************************************************************************\n");
}

void usage(FILE * fp, int rc)
{
	fprintf(fp,
		"Usage: ppifcd_test [-h?vt] [-c count] [-r REG -a REGVALUE] [BMP output filename]\n");
	fprintf(fp, "        -h?            this help\n");
	fprintf(fp, "        -v             print version info\n");
	fprintf(fp,
		"        -t             user trigger strobe to capture image\n");
	fprintf(fp, "        -c count       repeat count times\n");
	fprintf(fp, "        -r REG         I2C register\n");
	fprintf(fp, "        -a VAL         I2C value\n");
	fprintf(fp, "        -b             Bluetechnix board < 561 >; STAMP board < 533 | 537 >\n");
	exit(rc);
}

void mydelay(unsigned int delay)
{
	clock_t goal = delay * CLOCKS_PER_SEC / 1000 + clock();
	while (goal > clock()) ;
}

int main(int argc, char *argv[])
{

	int fd, i, c, cnt, delay, board, trigger_strobe;
	int fd_standby, fd_led, fd_fs3;
	char *buffer, *filename;
	u_char addr;
	u_short value, usetrigger, sendi2c;
	struct timeval o, t;
	long delta, usec, offset;
	char trigger[10], led[10], standby[10];
	/* Check the passed arg */

	cnt = 1;
	board = 0;
	while ((c = getopt(argc, argv, "vth?tr:a:c:b:")) > 0) {
		switch (c) {
		case 'v':
			printf("%s: version %s\n", argv[0], VERSION);
			exit(0);
		case 't':
			usetrigger++;
			break;
		case 'r':
			sendi2c++;
			addr = atoi(optarg);
			break;
		case 'a':
			sendi2c++;
			value = atoi(optarg);
			break;
		case 'c':
			cnt = atoi(optarg);
			break;
		case 'b':
			board = atoi(optarg);
			break;
		case 'h':
		case '?':
			usage(stdout, 0);
			break;
		default:
			fprintf(stderr, "ERROR: unkown option '%c'\n", c);
			usage(stderr, 1);
			break;
		}
	}

	if (board == 537) {
		strcpy(standby, BF537_MICRON_STANDBY);
		strcpy(led, BF537_MICRON_LED);
		trigger_strobe = BF537_MICRON_TRIGGER_STROBE;
	} else if (board == 533) {
		strcpy(standby, BF533_MICRON_STANDBY);
		strcpy(led, BF533_MICRON_LED);
		trigger_strobe = BF533_MICRON_TRIGGER_STROBE;
		if (usetrigger) {
			fprintf(stderr, "ERROR:Trigger option unsupported on BF533-STAMP\n", c);
			usetrigger = 0;
		}
	} else if (board == 561) {
//		strcpy(standby, BF533_MICRON_STANDBY);
//		strcpy(led, BF533_MICRON_LED);
//		trigger_strobe = BF533_MICRON_TRIGGER_STROBE;
//		if (usetrigger) {
//			fprintf(stderr, "ERROR:Trigger option unsupported on BF533-STAMP\n", c);
//			usetrigger = 0;
//		}
			printf("Bypass the Standby, Led and Trigger setup\n");
	} else {
		usage(stderr, 1);
		exit(1);
	}

if (board != 561) {
	fd_standby = open(standby, O_RDWR, 0);
	if (fd_standby < 0) {
		printf("%s open error %d\n", standby, errno);
		return -1;
	}

	fd_led = open(led, O_RDWR, 0);
	if (fd_led < 0) {
		printf("%s open error %d\n", led, errno);
		return -1;
	}
	
	/* Get latency between to gettimeofday calls */

	offset = getoffset();

	write(fd_standby, "0", sizeof("0"));

	if (board == 533) {

		fd_fs3 = open(FS3, O_RDWR, 0);
		if (fd_fs3 < 0) {
			printf("%s open error %d\n", FS3, errno);
			return -1;
		}
		write(fd_fs3, "0", sizeof("0"));
	}

	write(fd_led, "1", sizeof("0"));

	if (usetrigger) {
		i2c_write_register(I2C_DEVICE, DEVID, 0x1E, 0x8100);
		mydelay(36);
	} else
		i2c_write_register(I2C_DEVICE, DEVID, 0x1E, 0x8000);

	/* Global Gain: 0x35 */
	i2c_write_register(I2C_DEVICE, DEVID, 0x35, 0x50);

	if (sendi2c == 2)
		i2c_write_register(I2C_DEVICE, DEVID, addr, value);

	calculate_total_frame_time();

	/* Allocate meory for the raw image and BMP Header */
	buffer = (char *)malloc(IMAGESIZE + sizeof(bmphead));

	/* Open /dev/ppi */
	fd = open(PPI_DEVICE, O_RDONLY, 0);
	if (fd == -1) {
		printf("Could not open dev\/ppi : %d \n", errno);
		free(buffer);
		exit(1);
	}

	ioctl(fd, CMD_PPI_SET_PIXELS_PER_LINE, WIDTH);
	ioctl(fd, CMD_PPI_SET_LINES_PER_FRAME, HEIGHT);

	if (usetrigger) {
		ioctl(fd, CMD_SET_TRIGGER_GPIO, trigger_strobe);
	}

	/* Read the raw image data from the PPI */

	for (i = 0; i < cnt; i++) {

		gettimeofday(&o, NULL);

		read(fd, buffer + sizeof(bmphead), HEIGHT * WIDTH);

		gettimeofday(&t, NULL);

		//sleep(1);

		delta = tvdelta(&t, &o);

		printf
		    ("Read Start:\t\t\t%lu.%06lu\nRead End:\t\t\t%lu.%06lu\nTotal Frame Capture Time:\t%ld usec\n\n",
		     o.tv_sec, o.tv_usec, t.tv_sec, t.tv_usec, delta - offset);
	}

	/* Close PPI */
	close(fd);

	/* When data is transmitted from a  CMOS camera that uses the Bayer Color Filter Array
	   (Bayer CFA) we get a stream of alternating values of Red (R) Green (G) for odd rows
	   and alternating values of Green (G) and Blue (B) for even rows.

	   In order to construct an RGB picture, we need to calculate Green and Blue values for
	   each Red pixel, Blue and Red values for each Green pixel and Red and Green values
	   for each Blue pixel.

	   http://www.helicontech.co.il/whitepapers/bayer-rgb.html */

	/*For CFA Sensors: cfa2rgb( buffer+sizeof(bmphead) ); */

	/* Write image back to file */

	filename = argv[optind];

	if (filename) {

		/* Copy the BMP header information into the buffer */
		(void)memcpy(buffer, bmphead, sizeof(bmphead));

		fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);

		if (fd == -1) {
			(void)printf("%s: failed to open \"%s\"", argv[0],
				     filename);
			free(buffer);
			exit(-1);
		}
		(void)write(fd, buffer, IMAGESIZE + sizeof(bmphead));
		(void)close(fd);
		printf
		    ("*******************************************************************************\n");
		printf("Saved: %s \nSize : %d\n", filename,
		       IMAGESIZE + sizeof(bmphead));
		printf
		    ("*******************************************************************************\n");
	}

	write(fd_led, "0", sizeof("0"));

	close(fd_standby);
	close(fd_led);

	if (board == 533)
		close(fd_fs3);

	free(buffer);
	exit(0);
} else {
/******************************************************************************/
/*    CM-BF561 with OV2640FSL                                                 */
/******************************************************************************/
	i2c_write_register(I2C_DEVICE, DEVID, 0xFF, 0x01);
#define CAM_REG_RESET 			0x12
#define CAM_MASK_RESET_BIT		(1 << 7)
	i2c_write_register(I2C_DEVICE, DEVID, CAM_REG_RESET, CAM_MASK_RESET_BIT);
	printf("Reset CAM succesfful. Wait for stable.\n");
//	sleep(5000);

/*  CAM config  */
	CAM_config();

	if (sendi2c == 2)
		i2c_write_register(I2C_DEVICE, DEVID, addr, value);
	printf("CAM configured\n");
	sleep(2);

	calculate_total_frame_time();

	/* Allocate meory for the raw image and BMP Header */
	buffer = (char *)malloc(2*IMAGESIZE);

	/* Open /dev/ppi */
	fd = open(PPI_DEVICE, O_RDONLY, 0);
	if (fd == -1) {
		printf("Could not open dev\/ppi : %d \n", errno);
		free(buffer);
		exit(1);
	}
	printf("Open ppi successful.\n");

	ioctl(fd, CMD_PPI_SET_PIXELS_PER_LINE, WIDTH);
	ioctl(fd, CMD_PPI_SET_LINES_PER_FRAME, HEIGHT);
	printf("Set frame width x height succesfful.\n");

	/* Read the raw image data from the PPI */

	for (i = 0; i < cnt; i++) {
		gettimeofday(&o, NULL);

		read(fd, buffer, 2*IMAGESIZE);	//Multiple with 2 for store each pixel in 16-bits data

		gettimeofday(&t, NULL);

		//sleep(1);

		delta = tvdelta(&o, &t);

		printf
		    ("Read Start:\t\t\t%lu.%06lu\nRead End:\t\t\t%lu.%06lu\nTotal Frame Capture Time:\t%ld usec\n\n",
		     o.tv_sec, o.tv_usec, t.tv_sec, t.tv_usec, delta - offset);
	}

	/* Close PPI */
	close(fd);

	printf("PPI closed; image captured successfully\n");

	/* When data is transmitted from a  CMOS camera that uses the Bayer Color Filter Array
	   (Bayer CFA) we get a stream of alternating values of Red (R) Green (G) for odd rows
	   and alternating values of Green (G) and Blue (B) for even rows.

	   In order to construct an RGB picture, we need to calculate Green and Blue values for
	   each Red pixel, Blue and Red values for each Green pixel and Red and Green values
	   for each Blue pixel.

	   http://www.helicontech.co.il/whitepapers/bayer-rgb.html */

	/*For CFA Sensors: cfa2rgb( buffer+sizeof(bmphead) ); */

	/* Write image back to file */

	filename = argv[optind];

	if (filename) {

		/* Copy the BMP header information into the buffer */
		//(void)memcpy(buffer, bmphead, sizeof(bmphead));

		fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);

		if (fd == -1) {
			(void)printf("%s: failed to open \"%s\"", argv[0],
				     filename);
			free(buffer);
			exit(-1);
		}
		(void)write(fd, buffer, 2*IMAGESIZE);
		(void)close(fd);
		printf
		    ("*******************************************************************************\n");
		printf("Saved: %s \nSize : %d\n", filename,
		       2*IMAGESIZE);
		printf
		    ("*******************************************************************************\n");
	}
/*
	write(fd_led, "0", sizeof("0"));

	close(fd_standby);
	close(fd_led);

	if (board == 533)
		close(fd_fs3);
*/
	free(buffer);
	exit(0);
}	// end of if(board != 561) else...
}	// end of main()