Rev 174 | Blame | Last modification | View Log | Download
/*
Copyright (C) 2004 John Orlando
AVRcam: a small real-time image processing engine.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public
License along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
For more information on the AVRcam, please contact:
john@jrobot.net
or go to www.jrobot.net for more details regarding the system.
*/
/***********************************************************
Module Name: CamInterface.c
Module Date: 04/12/2004
Module Auth: John Orlando
Description: This file is responsible for providing an
interface to the OV6620 camera hardware. This includes
an interface to CamInterface.S for certain low-level,
optimized camera access routines.
Revision History:
Date Rel Ver. Notes
4/10/2004 0.1 Module created
6/30/2004 1.0 Initial release for Circuit Cellar
contest.
11/15/2004 1.2 ifdef'd out the resetCam routine, since
resetting the cam now causes the OV6620's
clock to not be output (we have to start
it up after each reset with the external
tiny12 processor).
1/16/2005 1.4 Ensure that the TCCR1B register is set so
nothing is clocking timer1 at startup.
***********************************************************/
/* Includes */
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <avr/eeprom.h>
#include <stdlib.h>
#include <string.h>
#include "CommonDefs.h"
#include "CamInterface.h"
#include "Utility.h"
#include "UIMgr.h"
#include "Executive.h"
#include "UartInterface.h"
/* Local Variables */
/* Local Structures and Typedefs */
/* Definitions */
//#define OUTPUT_INITIAL_COLOR_MAP 1
#define FAST_ACQUIRE 1
#define CAM_G_BUS PINB
#define CAM_G_BUS_DIR DDRB
#define CAM_RB_BUS PINC
#define CAM_RB_BUS_DIR DDRC
#define CAM_CONTROL_PORT PORTD
#define CAM_CONTROL_PORT_DIR DDRD
#define CAM_RESET_LINE BIT7
#define CAM_PIXEL_CLK_COUNT BIT5
#define CAM_HREF BIT4
#define CAM_PIXEL_CLK_INT BIT3
#define CAM_VSYNC BIT2
/* Global Variables */
/* NOTE: This file MUST appear first in the Makefile for these variables to
be placed properly in RAM */
/* The colorMap[] table provides the membership lookup table to convert
RGB or YUV pixel values into actual colors. The membership table contains
16 elements for each color channel, concatenated together. The Red (or Y)
value is located in the first 16 bytes, the G (or U) value is located in
the second 16 bytes, and the B (or V) value is located in the last 16 bytes:
----------------------------------------------------------------------------------
|red0|red1|red2|...|red15|green0|green1|green2|...|green15|blue0|blue1|...|blue15|
mem:|0x00 0x01 0x02 0x15 0x16 0x17 0x18 0x31 0x32 0x33 0x47 |
---------------------------------------------------------------------------------
Thus, the red lookup is accessed at colorMap+0, the green lookup is accessed
at colorMap+16, and the blue lookup is accessed at colorMap+32. */
unsigned char colorMap[NUM_ELEMENTS_IN_COLOR_MAP] __attribute__ ((section (".noinit")));
/* Extern Variables */
/* These two buffers hold the current and previous lines
of pixel data. They are sized to the worst case scenario,
where the color changes between every pixel (unrealistic).
The format of each buffer is for all the even bytes to hold
the run-length, and the odd bytes to hold the color data. */
/* In addition, if we are in frameDump mode, we use these buffers
to store the acquired line data...we are actually grabbing ALL of the
pixels in a line (176) instead of the 88 we get normally during tracking.
But since we have enough to hold 88-RLE blocks, we already have the 176
allocated for this... */
unsigned char currentLineBuffer[LENGTH_OF_LINE_BUFFER];
unsigned char previousLineBuffer[LENGTH_OF_LINE_BUFFER];
/* Extern Functions */
/* These functions are located in assembly files, and thus
must be externed here so they can be referenced in the source below. */
extern void CamIntAsm_waitForNewTrackingFrame(unsigned char *pBuffer, unsigned char *pMemLookup);
extern void CamIntAsm_waitForNewDumpFrame(unsigned char *pCurrBuffer, unsigned char *pPrevBuffer);
extern void CamIntAsm_acquireTrackingLine(unsigned char *pBuffer, unsigned char *pMemLookup);
extern void CamIntAsm_acquireDumpLine(unsigned char *pCurrBuffer, unsigned char *pPrevBuffer);
/***********************************************************
Function Name: CamInt_init
Function Description: This function is responsible
for initializing the camera interface. This includes
setting up the i/o ports that are used to read the
camera busses, as well as resetting the camera.
Inputs: none
Outputs: none
***********************************************************/
void CamInt_init(void)
{
#if OUTPUT_INITIAL_COLOR_MAP
unsigned char asciiBuffer[5];
unsigned char i;
#endif
/* set up the mega8 ports that will be interfacing
with the camera */
CAM_CONTROL_PORT_DIR |= (1<<CAM_RESET_LINE); /* cam reset is output */
CAM_CONTROL_PORT_DIR |= 0x80; /* set just the MSB as an output */
CAM_CONTROL_PORT_DIR &= 0xFB; /* make sure bit2 is clear (input) */
CAM_CONTROL_PORT &= 0x7F; /* set reset line low */
CAM_G_BUS_DIR &= 0xF0; /* 4-bit G bus all inputs */
CAM_G_BUS_DIR |= 0xF0; /* disable the pull-up on PB4 and PB5 */
CAM_RB_BUS_DIR &= 0xF0; /* 4-bit RB bus all inputs */
/* ensure that timer1 is disabled to start...eventually, when PCLK needs
to feed timer1 through the external counter, it will be enabled on an
"as needed" basis...*/
TCCR1B &= ~( (1<<CS12)|(1<<CS11)|(1<<CS10) );
/* we'll turn on the interrupt after we assign the initial TCNT value */
/* set up External Interrupt1 to interrupt us on rising edges (HREF)...
this is needed to indicate when the first pixel of each line is about to start, so
we can synch up with it...this interrupt will be disabled once HREF goes high */
MCUCR |= (1<<ISC11) | (1<<ISC10); /* rising edge interrupt */
/* the interrupt will be enabled when we are ready to detect the rising edge of
HREF...its now primed and ready to go */
/* set up External Interrupt0 to interrupt us on rising edges (VSYNC) */
MCUCR |= (1<<ISC01) | (1<<ISC00); /* rising edge interrupt */
GICR |= (1<<INT0); /* interrupt request enabled */
/* set up TimerO to count and be clocked from an external pulse source
(HREF) on falling edges...eventually, we need to enable the interrupt
for this! FIX THIS */
TCCR0 = (1<<CS02)|(1<<CS01)|(0<<CS00);
/* setting up the PCLK counter with Timer1 will be done right after
we start receiving pixels in each line...we sacrifice the first pixel
in each line, but we'll account for it...*/
/* set up the mega8 so that its sleep mode puts it in an IDLE sleep
mode, where it can wake up as fast as possible */
set_sleep_mode(SLEEP_MODE_IDLE);
/* umm....we need to actually enable the sleep mode...*/
MCUCR |= 0x80;
/* initialize the memLookup table */
memset(colorMap,0x00,NUM_ELEMENTS_IN_COLOR_MAP);
/* read the color map out of EEPROM */
eeprom_read_block(colorMap, (unsigned char*)0x01,NUM_ELEMENTS_IN_COLOR_MAP);
#if OUTPUT_INITIAL_COLOR_MAP
UIMgr_txBuffer("\r\n",2);
for (i=0; i<NUM_ELEMENTS_IN_COLOR_MAP; i++)
{
memset(asciiBuffer,0x00,5);
itoa(colorMap[i],asciiBuffer,10);
UIMgr_txBuffer(asciiBuffer,3);
UIMgr_txBuffer(" ",1);
if (i==15 || i == 31)
{
/* break up the output */
UIMgr_txBuffer("\r\n",2);
}
}
#endif
#ifndef NO_CRYSTAL
CamInt_resetCam();
#endif
}
/***********************************************************
Function Name: CamInt_resetCam
Function Description: This function is responsible
for resetting the camera. This is accomplished by
toggling the reset line on the OV6620 for ~100 mS.
Inputs: none
Outputs: none
IMPORTANT NOTE: This function has effectively been removed
since resetting the camera now causes the camera to not
output the clock signal. Thus, if we reset the cam, the
AVR has no clock, and thus doesn't run...
***********************************************************/
void CamInt_resetCam(void)
{
#if 0
CAM_CONTROL_PORT |= (1<<CAM_RESET_LINE); /* cam reset line high */
Utility_delay(500);
CAM_CONTROL_PORT &= (0<<CAM_RESET_LINE); /* cam reset line low */
Utility_delay(100);
#endif
}