WebSVN – svnkaklik – //programy/C/avr/AVRcam/CamInterface.c

/*
    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    
}
Subversion Repositories svnkaklik

(root)//programy/C/avr/AVRcam/CamInterface.c – Rev 174
