dm642main.c

编译环境： TI CCS2.20.18 芯片：TI64X系列都可 功能：实现采集图像的边沿检测

#include <csl.h>
#include <csl_emifa.h>
#include <csl_i2c.h>
#include <csl_gpio.h>
#include <csl_irq.h>
#include <csl_chip.h>
#include <csl_dat.h>
#include <csl_cache.h>
#include "iic.h"
#include "vportcap.h"
#include "vportdis.h"
#include "sa7121h.h"
#include "TVP51xx.h"
#include "seeddm642.h"

EMIFA_Config Seeddm642ConfigA ={
	   0x00052078,
	   0xffffffd3,
	   0x73a28e01,  			  
	   0x22a28a22, 
       0x22a28a42, 
	   0x57115000,
	   0x0000081b,
	   0x001faf4d, 
	   0x00000002, 
	   0x00000002, 
	   0x00000002, 
	   0x00000073 
};

I2C_Config SEEDDM642IIC_Config = {
    0,  
    0,  
    (20-5), 
    (20-5), 
    1,  
    0, 
    0x4ea0,
    (75-1),
};

CHIP_Config SEEDDM642percfg = {
	CHIP_VP2+\
	CHIP_VP1+\
	CHIP_VP0+\
	CHIP_I2C
};
I2C_Handle hSeeddm642i2c;
int portNumber;
extern SA7121H_ConfParams sa7121hPAL[45];
extern SA7121H_ConfParams sa7121hNTSC[45];
Uint8 vFromat = 0;
Uint8 misc_ctrl = 0x6D;
Uint8 output_format = 0x47;
Uint8 input_sel = 0x00;
Uint8 pin_cfg = 0x02;
Uint8 chro_ctrl_2 = 0x14;
VP_Handle vpHchannel0;
VP_Handle vpHchannel1;
VP_Handle vpHchannel2;
int numPixels = 720;
int numLines  = 576;
Uint32 capYbuffer  = 0x80000000;
Uint32 capCbbuffer = 0x800675c0;
Uint32 capCrbuffer = 0x8009b0a0;
Uint32 disYbuffer  = 0x80100000;
Uint32 disCbbuffer = 0x801675c0; 
Uint32 disCrbuffer = 0x8019b0a0;
Uint32 tempYbuffer = 0x80200000;
Uint32 temp2Ybuffer =0x80300000;
Uint32 temp3Ybuffer =0x80400000;

Uint8 NTSCorPAL = 0;
extern far void vectors();
extern volatile Uint32 capNewFrame;
extern volatile Uint32 disNewFrame;

Bool IMG_sobel
(
    const unsigned char *restrict in,   /* Input image data   */
    unsigned char       *restrict out,  /* Output image data  */
    short cols, short rows              /* Image dimensions   */
);
void main()
{
	Uint8 addrI2C;
	int i;

	CSL_init();
    DAT_open(DAT_CHAANY, DAT_PRI_LOW, DAT_OPEN_2D);
    
	CHIP_config(&SEEDDM642percfg);
	EMIFA_config(&Seeddm642ConfigA);

    IRQ_setVecs(vectors);
    IRQ_nmiEnable();
    IRQ_globalEnable();
    IRQ_map(IRQ_EVT_VINT1, 11);
    IRQ_map(IRQ_EVT_VINT0, 12);
    IRQ_reset(IRQ_EVT_VINT1);
    IRQ_reset(IRQ_EVT_VINT1);

    DAT_open(DAT_CHAANY, DAT_PRI_LOW, DAT_OPEN_2D);	

	hSeeddm642i2c = I2C_open(I2C_PORT0,I2C_OPEN_RESET);
	I2C_config(hSeeddm642i2c,&SEEDDM642IIC_Config);

	GPIO_RSET(GPGC,0x0);
	GPIO_RSET(GPDIR,0x1);
	GPIO_RSET(GPVAL,0x0);
							  
	addrI2C = 0xBA >>1;
    _IIC_write(hSeeddm642i2c, addrI2C,0x00, input_sel);
    _IIC_write(hSeeddm642i2c, addrI2C,0x03, misc_ctrl);
    _IIC_write(hSeeddm642i2c, addrI2C,0x0D, output_format);
    _IIC_write(hSeeddm642i2c, addrI2C,0x0F, pin_cfg);
    _IIC_write(hSeeddm642i2c, addrI2C,0x1B, chro_ctrl_2);

    _IIC_read(hSeeddm642i2c, addrI2C,0x8c, &vFromat);
    vFromat = vFromat & 0xff;
	switch (vFromat)
	{
		case TVP51XX_NTSCM:
		case TVP51XX_NTSC443:
			NTSCorPAL = 1;
			break;
		case TVP51XX_PALBGHIN:
		case TVP51XX_PALM:
			NTSCorPAL = 0;
			break;
		default:
			NTSCorPAL = 2;
			break;
	}
	if(NTSCorPAL ==2)
	{
		for(;;)
		{}
	}  		  
	GPIO_RSET(GPVAL,0x0);/*GPIO0输出为低，选择IIC1总线，配置图像输出*/						  
	addrI2C = 0xB8 >>1; 

	_IIC_write(hSeeddm642i2c, addrI2C,0x03, 0x1);

	GPIO_RSET(GPVAL,0x1);/*GPIO0输出为低，选择IIC1总线，配置图像输出*/	
	portNumber = 0;
	vpHchannel0 = bt656_8bit_ncfd(portNumber);
	for(i = 0; i < 100000; i ++);
	SEEDDM642_rset(SEEDDM642_WDOGEN,2);
	addrI2C = 0x88 >>1;					      
	for(i =0; i<43; i++)
	{
		if(NTSCorPAL == 1)
		{
			_IIC_write(hSeeddm642i2c, 
					   addrI2C,
					   (sa7121hNTSC[i].regsubaddr), 
					   (sa7121hNTSC[i].regvule));
		}
		else
		{
			_IIC_write(hSeeddm642i2c, 
					   addrI2C,
					   (sa7121hPAL[i].regsubaddr), 
					   (sa7121hPAL[i].regvule));	
		}		
	}
	portNumber = 1;
	vpHchannel1 = bt656_8bit_ncfc(portNumber);
	bt656_capture_start(vpHchannel1);
	while(capNewFrame == 0){}
	capNewFrame =0;
	for(i=0;i<numLines;i++)
	{
		/*传送Y缓冲区*/
		DAT_copy((void *)(capYbuffer + i * numPixels), 
	             (void *)(disYbuffer + i * numPixels),
	             numPixels);
	}
	//清除彩色信号
	for(i=0;i<0x675c0;i++)
	{
		*((Uint8 *)disCbbuffer+i)=0x80;
		*((Uint8 *)disCrbuffer+i)=0x80;
	}
	bt656_display_start(vpHchannel0);
	for(;;)
	{
		//CACHE_clean(CACHE_L2ALL, 0, 0);
		/*当采集区的数据已经采集好，而显示缓冲区的数据已空*/
		if((capNewFrame == 1)&&(disNewFrame == 1))
		{
			/*将数据装入显示缓冲区，并清采集完成的标志*/
			capNewFrame =0;
			disNewFrame =0;
			for(i=0;i<numLines;i++)
			{
			    DAT_copy((void *)(capYbuffer + i * numPixels), 
			         	(void *)(tempYbuffer + i * numPixels),
			         	 numPixels);
			    DAT_copy((void *)(temp2Ybuffer + i * numPixels), 
			         	(void *)(disYbuffer + i * numPixels),
			         	 numPixels);
			    /*DAT_copy((void *)(tempYbuffer + i * numPixels), 
			         	(void *)(disYbuffer + i * numPixels),
			         	 numPixels);*/			         	 			      
			}
			IMG_sobel
			(
			    ( const unsigned char *)tempYbuffer,   /* Input image data   */
  		  	    (       unsigned char *)temp2Ybuffer,  /* Output image data  */
  				numPixels, numLines              /* Image dimensions   */
			);	  			
			//IMGcnu_sobel(( const unsigned char *)tempYbuffer, ( unsigned char *)disYbuffer, 720, 576);						
		
			//IMG_histogram(in_data,128,1,t_hist_c,hist_c);                 				   		  	
		}
		
	}
	for(;;)
	{}	
} 
Bool IMG_sobel
(
    const unsigned char *restrict in,   /* Input image data   */
    unsigned char       *restrict out,  /* Output image data  */
    short cols, short rows              /* Image dimensions   */
)
{
    int H, O, V, i;
    int i00, i01, i02;
    int i10,      i12;
    int i20, i21, i22;
    int w = cols;

    /* -------------------------------------------------------------------- */
    /*  Iterate over entire image as a single, continuous raster line.      */
    /* -------------------------------------------------------------------- */
    for (i = 0; i < cols*(rows-2) - 2; i++)
    {
        /* ---------------------------------------------------------------- */
        /*  Read in the required 3x3 region from the input.                 */
        /* ---------------------------------------------------------------- */
        i00=in[i    ]; i01=in[i    +1]; i02=in[i    +2];
        i10=in[i+  w];                  i12=in[i+  w+2];
        i20=in[i+2*w]; i21=in[i+2*w+1]; i22=in[i+2*w+2];

        /* ---------------------------------------------------------------- */
        /*  Apply horizontal and vertical filter masks.  The final filter   */
        /*  output is the sum of the absolute values of these filters.      */
        /* ---------------------------------------------------------------- */

        H = -   i00 - 2*i01 -   i02 +
            +   i20 + 2*i21 +   i22;

        V = -   i00         +   i02
            - 2*i10         + 2*i12
            -   i20         +   i22;

        O = abs(H) + abs(V);

        /* ---------------------------------------------------------------- */
        /*  Clamp to 8-bit range.  The output is always positive due to     */
        /*  the absolute value, so we only need to check for overflow.      */
        /* ---------------------------------------------------------------- */
        if (O > 255) O = 255;

        /* ---------------------------------------------------------------- */
        /*  Store it.                                                       */
        /* ---------------------------------------------------------------- */
        out[i + 1] = O;
    }
    return TRUE;
}