Subversion Repositories svnkaklik

/*
    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: CamConfig.c
        Module Date: 04/10/2004
    Module Auth: John Orlando 
        
        Description: This module is responsible for the 
        high-level configuration activities of the OV6620
        camera module.  This module interfaces with the
        I2CInterface module to perform this configuration.
    
    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     Added code to un-tri-state the
                           OV6620's pixel data busses at
                           startup after four seconds.  
                           This was added in to 
                           allow the user to re-program the
                           mega8 at startup if needed.
***********************************************************/

/*  Includes */
#include <avr/io.h>
#include "CamConfig.h"
#include "I2CInterface.h"
#include "CommonDefs.h"
#include "Utility.h"

/**********************************************************/
/*  Definitions */
/* The length of an I2C command is made up of a register address
plus the actual value of the register */
#define SIZE_OF_I2C_CMD 2
#define MAX_NUM_CONFIG_CMDS 8
#define CAM_CONFIG_TX_FIFO_SIZE MAX_NUM_CONFIG_CMDS 
#define CAM_CONFIG_TX_FIFO_MASK CAM_CONFIG_TX_FIFO_SIZE-1

/*  Local Variables */

/*  Local Structures and Typedefs */

/*  Local Function Prototypes */
static i2cCmd_t CamConfig_readTxFifo(void);

/*  Extern Variables */
i2cCmd_t                CamConfig_txFifo[CAM_CONFIG_TX_FIFO_SIZE];
unsigned char CamConfig_txFifoHead=0;
unsigned char CamConfig_txFifoTail=0;

/***********************************************************
        Function Name: CamConfig_init
        Function Description: This function is responsible for
        performing the initial configuration of the camera.
        Inputs:  none
        Outputs: none
***********************************************************/    
void CamConfig_init(void)
{
        CamConfig_setCamReg(0x14,0x20);  /* reduce frame size */
        CamConfig_setCamReg(0x39,0x40);  /* gate PCLK with HREF */
        CamConfig_setCamReg(0x12,0x28);  /* set RGB mode, with no AWB */
        CamConfig_setCamReg(0x28,0x05);  /* set color sequencer */
    CamConfig_setCamReg(0x13,0x01);  /* un-tri-state the Y/UV lines */
        
        /* send the first four cmds in the I2C fifo */
        CamConfig_sendFifoCmds();       
}


/***********************************************************
        Function Name: CamConfig_setCamReg
        Function Description: This function is responsible for
        creating an I2C cmd structure and placing it into the
        cmd fifo.
        Inputs:  reg - the register to modify
                 val - the new value of the register
        Outputs: none
***********************************************************/    
void CamConfig_setCamReg(unsigned char reg, unsigned char val)
{
        i2cCmd_t cmd;
        
        cmd.configReg = reg;
        cmd.data = val;
#ifndef SIMULATION      
        CamConfig_writeTxFifo(cmd);
#endif  
}
/***********************************************************
        Function Name: CamConfig_sendFifoCmds
        Function Description: This function is responsible for
        sending the entire contents of the config fifo.  This
        function won't return until the configuration process
        is complete (or an error is encountered).
        Inputs:  none
        Outputs: none
        Note: Since this function is written to use the TWI
        interrupt in the I2CInterface module, there will be 
        some busy-waiting here...no big deal, since we end up
        having to trash the frame that we are executing this
        slave write in anyway (since we can't meet the strict
        timing requirements and write i2c at the same time).
***********************************************************/    
void CamConfig_sendFifoCmds(void)
{
        i2cCmd_t cmd;
        
        while (CamConfig_txFifoHead != CamConfig_txFifoTail)
        {
                cmd = CamConfig_readTxFifo();
                I2CInt_writeData(CAM_ADDRESS,&cmd.configReg,SIZE_OF_I2C_CMD);
                Utility_delay(100);             
                /* wait for the I2C transaction to complete */
                while(I2CInt_isI2cBusy() == TRUE);
        } 
}

/***********************************************************
        Function Name: CamConfig_writeTxFifo
        Function Description: This function is responsible for
        adding a new command to the tx fifo.  It adjusts all
        needed pointers.
        Inputs:  cmd - the i2cCmd_t to add to the fifo
        Outputs: bool_t - indicating if writing to the fifo
                 causes it to wrap
***********************************************************/    
bool_t CamConfig_writeTxFifo(i2cCmd_t cmd)
{
        unsigned char tmpHead;
        bool_t retVal = TRUE;
        
        CamConfig_txFifo[CamConfig_txFifoHead] = cmd;
                
        /* see if we need to wrap */
        tmpHead = (CamConfig_txFifoHead+1) & (CAM_CONFIG_TX_FIFO_MASK);
        CamConfig_txFifoHead = tmpHead;
        
        /* check to see if we have filled up the queue */
        if (CamConfig_txFifoHead == CamConfig_txFifoTail)
        {
                /* we wrapped the fifo...return false */
                retVal = FALSE;
        }
        return(retVal);
}

/***********************************************************
        Function Name: CamConfig_readTxFifo
        Function Description: This function is responsible for
        reading a cmd out of the tx fifo.
        Inputs:  none
        Outputs: i2cCmd_t - the cmd read from the fifo
***********************************************************/    
static i2cCmd_t CamConfig_readTxFifo(void)
{
        i2cCmd_t cmd;
        unsigned char tmpTail;
        
        /* just return the current tail from the rx fifo */
        cmd = CamConfig_txFifo[CamConfig_txFifoTail];   
        tmpTail = (CamConfig_txFifoTail+1) & (CAM_CONFIG_TX_FIFO_MASK);
        CamConfig_txFifoTail = tmpTail;
        
        return(cmd);
}