VmodCAM图像采集 VGA显示

先上图

总体框图

效果图

效果不是很好，因为暂时用的是zedboard自带的VGA，其只能RGB只有3*3*3的彩色度

VmodCAM原理图

VmodCAM的zedboard管脚约束见：http://blog.csdn.net/xiabodan/article/details/26144749

VmodCAM的zedboard初始化见    ：http://blog.csdn.net/xiabodan/article/details/26346935

初始化采用SDK 中C编程，没有用HDL，原因嘛，想体验一下HDL与SDK混合使用的感觉，结果感觉就是很他妈复杂，太繁琐了，还不如直接多敲点verilog算了。废话不说，做都做了只能将就吧。

其中遇到一个问题就是在HDL中的代码用到了RAM IP核，在导入EDK的create or import peripheral ->inport existing peripheral ->To XPS project ->Name->（选中HDL和Netlist），在后续的步骤中需要添加*.ngc文件，*.ngc文件就是core generate 生成相应IP时产生的网表文件（有了网表文件是可以不需要HDL文件的）。

V

转接板VmodCAM转接板

转接板VmodCAM转接板接在FMC上的：前段时间没事做了一块FMC的转接板，正好用上。

VGA原理图

vga用的是zedboard上自带的vga分辨率有限，接下来准备用HDMI

vga管脚约束

# VGA out
NET vga_blue<0>       LOC = Y21  | IOSTANDARD=LVCMOS33;  # "VGA-B1"
NET vga_blue<1>       LOC = Y20  | IOSTANDARD=LVCMOS33;  # "VGA-B2"
NET vga_blue<2>       LOC = AB20 | IOSTANDARD=LVCMOS33;  # "VGA-B3"
NET vga_blue<3>       LOC = AB19 | IOSTANDARD=LVCMOS33;  # "VGA-B4"
NET vga_green<0>      LOC = AB22 | IOSTANDARD=LVCMOS33;  # "VGA-G1"
NET vga_green<1>      LOC = AA22 | IOSTANDARD=LVCMOS33;  # "VGA-G2"
NET vga_green<2>      LOC = AB21 | IOSTANDARD=LVCMOS33;  # "VGA-G3"
NET vga_green<3>      LOC = AA21 | IOSTANDARD=LVCMOS33;  # "VGA-G4"
NET vga_red<0>        LOC = V20  | IOSTANDARD=LVCMOS33;  # "VGA-R1"
NET vga_red<1>        LOC = U20  | IOSTANDARD=LVCMOS33;  # "VGA-R2"
NET vga_red<2>        LOC = V19  | IOSTANDARD=LVCMOS33;  # "VGA-R3"
NET vga_red<3>        LOC = V18  | IOSTANDARD=LVCMOS33;  # "VGA-R4"
NET vga_hsync         LOC = AA19 | IOSTANDARD=LVCMOS33;  # "VGA-HS"
NET vga_vsync         LOC = Y19  | IOSTANDARD=LVCMOS33;  # "VGA-VS"

VmodCAM管脚约束

NET "OV7670_PWDN"    LOC = "Y11"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JA0
NET "OV7670_RESET"   LOC = "AB11" | IOSTANDARD=LVTTL | SLEW=SLOW; # JA4
NET "OV7670_D<0>"    LOC = "J20"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JA1
NET "OV7670_D<1>"    LOC = "K21"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JA5
NET "OV7670_D<2>"    LOC = "M22"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JA2
NET "OV7670_D<3>"    LOC = "J22"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JA6
NET "OV7670_D<4>"    LOC = "P20"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JA3
NET "OV7670_D<5>"    LOC = "P21"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JA7

NET "OV7670_D<6>"    LOC = "T16"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JB0
NET "OV7670_D<7>"    LOC = "T17"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JB4
NET "OV7670_XCLK"    LOC = "P22"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JB1
NET "OV7670_PCLK"    LOC = "J16"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JB5
NET "OV7670_HREF"    LOC = "N18"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JB2
NET "OV7670_VSYNC"   LOC = "N17"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JB6
NET "OV7670_SIOD"    LOC = "P17"  | IOSTANDARD=LVTTL | SLEW=SLOW | PULLUP; # JB3
NET "OV7670_SIOC"    LOC = "P18"  | IOSTANDARD=LVTTL | SLEW=SLOW; # JB7
NET "OV7670_PCLK"    CLOCK_DEDICATED_ROUTE = FALSE;

EDK硬件设计

EDK中硬件只需要将我们的HDL设计添加进来（包括图像采集，VGA显示）。再添加一个IIC用于VmodCAM的配置就行了。当然其他的外设可以根据需要自己设计

 

HDL软件

代码包见：http://download.csdn.net/detail/xiabodan/7489075

vga

----------------------------------------------------------------------------------
-- Engineer:
-- Description: Generate analog 640x480 VGA, double-doublescanned from 19200 bytes of RAM
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity vga is
    Port (
		clk25       : in  STD_LOGIC;
		vga_red     : out STD_LOGIC_VECTOR(3 downto 0);
		vga_green   : out STD_LOGIC_VECTOR(3 downto 0);
		vga_blue    : out STD_LOGIC_VECTOR(3 downto 0);
		vga_hsync   : out STD_LOGIC;
		vga_vsync   : out STD_LOGIC;
		frame_addr  : out STD_LOGIC_VECTOR(18 downto 0);
		frame_pixel : in  STD_LOGIC_VECTOR(11 downto 0)
	 );
end vga;

architecture Behavioral of vga is
   -- Timing constants
   constant hRez       : natural := 640;
   constant hStartSync : natural := 640+16;
   constant hEndSync   : natural := 640+16+96;
   constant hMaxCount  : natural := 800;

   constant vRez       : natural := 480;
   constant vStartSync : natural := 480+10;
   constant vEndSync   : natural := 480+10+2;
   constant vMaxCount  : natural := 480+10+2+33;

	constant hsync_active : std_logic := '0';
	constant vsync_active : std_logic := '0';

   signal hCounter : unsigned( 9 downto 0) := (others => '0');
   signal vCounter : unsigned( 9 downto 0) := (others => '0');
	signal address  : unsigned(18 downto 0) := (others => '0');
	signal blank    : std_logic := '1';

begin
	frame_addr <= std_logic_vector(address);

   process(clk25)
   begin
		if rising_edge(clk25) then
			-- Count the lines and rows
			if hCounter = hMaxCount-1 then
				hCounter <= (others => '0');
				if vCounter = vMaxCount-1 then
					vCounter <= (others => '0');
				else
					vCounter <= vCounter+1;
				end if;
			else
				hCounter <= hCounter+1;
			end if;

			if blank = '0' then
				vga_red   <= frame_pixel(11 downto 8);
				vga_green <= frame_pixel( 7 downto 4);
				vga_blue  <= frame_pixel( 3 downto 0);
			else
				vga_red   <= (others => '0');
				vga_green <= (others => '0');
				vga_blue  <= (others => '0');
			end if;

			if vCounter  >= vRez then
				address <= (others => '0');
				blank <= '1';
			else
				if hCounter  < 640 then
					blank <= '0';
					address <= address+1;
				else
					blank <= '1';
				end if;
			end if;

			-- Are we in the hSync pulse? (one has been added to include frame_buffer_latency)
			if hCounter > hStartSync and hCounter <= hEndSync then
				vga_hSync <= hsync_active;
			else
				vga_hSync <= not hsync_active;
			end if;

			-- Are we in the vSync pulse?
			if vCounter >= vStartSync and vCounter < vEndSync then
				vga_vSync <= vsync_active;
			else
				vga_vSync <= not vsync_active;
			end if;
		end if;
	end process;
end Behavioral;

captrue

----------------------------------------------------------------------------------
-- Engineer:
--
-- Description: Captures the pixels coming from the OV7670 camera and
--              Stores them in block RAM
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity ov7670_capture is
    Port ( pclk  : in   STD_LOGIC;
           vsync : in   STD_LOGIC;
           href  : in   STD_LOGIC;
           d     : in   STD_LOGIC_VECTOR (7 downto 0);
           addr  : out  STD_LOGIC_VECTOR (18 downto 0);
           dout  : out  STD_LOGIC_VECTOR (11 downto 0);
           we    : out  STD_LOGIC);
end ov7670_capture;

architecture Behavioral of ov7670_capture is
   signal d_latch      : std_logic_vector(15 downto 0) := (others => '0');
   signal address      : STD_LOGIC_VECTOR(18 downto 0) := (others => '0');
   signal address_next : STD_LOGIC_VECTOR(18 downto 0) := (others => '0');
   signal wr_hold      : std_logic_vector(1 downto 0)  := (others => '0');

begin
   addr <= address;
   process(pclk)
   begin
      if rising_edge(pclk) then
         -- This is a bit tricky href starts a pixel transfer that takes 3 cycles
         --        Input   | state after clock tick
         --         href   | wr_hold    d_latch           d                 we address  address_next
         -- cycle -1  x    |    xx      xxxxxxxxxxxxxxxx  xxxxxxxxxxxxxxxx  x   xxxx     xxxx
         -- cycle 0   1    |    x1      xxxxxxxxRRRRRGGG  xxxxxxxxxxxxxxxx  x   xxxx     addr
         -- cycle 1   0    |    10      RRRRRGGGGGGBBBBB  xxxxxxxxRRRRRGGG  x   addr     addr
         -- cycle 2   x    |    0x      GGGBBBBBxxxxxxxx  RRRRRGGGGGGBBBBB  1   addr     addr+1

         if vsync = '0' then
            address <= (others => '0');
            address_next <= (others => '0');
            wr_hold <= (others => '0');
         else
-- This should be a different order, but seems to be GRB!
--            dout    <= d_latch(11 downto 10) & d_latch(11 downto 10) & d_latch(15 downto 12) & d_latch(9 downto 8) & d_latch(9 downto 8);
            dout    <= d_latch(15 downto 12) & d_latch(10 downto 7) & d_latch(4 downto 1);
            address <= address_next;
            we      <= wr_hold(1);
            wr_hold <= wr_hold(0) & (href and not wr_hold(0));
            d_latch <= d_latch( 7 downto  0) & d;

            if wr_hold(1) = '1' then
               address_next <= std_logic_vector(unsigned(address_next)+1);
            end if;

         end if;
      end if;
   end process;
end Behavioral;

SDK 软件

IIC配置摄像头

#define XPAR_FMC_IIC_0_BASEADDR 0x41600000
#define XPAR_CAMER_IIC_A_BASEADDR 0x41660000
#define XPAR_CAMER_IIC_B_BASEADDR 0x41640000

#define CAMERA_ADDRESS_ID (0x78>>1)
#define MT9D112_CONFIG_BUFFER_ROWS ((sizeof(MT9D112_CONFIG_BUFFER))/(sizeof(MT9D112_CONFIG_BUFFER[0])))
#define MT9D112_R_READ_BUFFER_ROWS ((sizeof(MT9D112_R_READ_BUFFER))/(sizeof(MT9D112_R_READ_BUFFER[0])))
static const char *MT9D112_R_MESSAGE[] = {"R[0X3000]","R[0X3214]","R[0X341C]","R[0X341E]","R[0X3202]","R[0X3386]","R[0X338C]","R[0X3390]","R[0X3040]"};
u8 MT9D112_R_READ_BUFFER[][2] = {
				{0x30,0x00},
				{0x32,0x14},//Slew rate control
				{0x34,0x1c},//PLL dividers
				{0x34,0x1e},//PLL control
				{0x32,0x02},//stanbdy
				{0x33,0x86},
				{0x33,0x8c},
				{0x33,0x90},
				{0x30,0x40}
};
void Read_MT9D112_R_Message(u32 BaseAddress)
{
	u8 i=0;
	u8 ReadCamera_R[2];
	printf("*******camera initialize register*********\n");
	for(i=0;i<MT9D112_R_READ_BUFFER_ROWS;i++)
	{
		read_camera_config(BaseAddress,MT9D112_R_READ_BUFFER[i],ReadCamera_R);
		printf("    %s is: 0x%x\n",MT9D112_R_MESSAGE[i],(ReadCamera_R[0]<<8)|ReadCamera_R[1]);
	}
	printf("*****************end**********************\n");
}
u8 MT9D112_CONFIG_BUFFER[][4] = {
				0x30,0x00,0x00,0x00, // Chip version. Default 0x1580  !! only for read   !!
				0x33,0x86,0x05,0x01, // MCU Reset
				0x33,0x86,0x05,0x00, // MCU Release from reset
				0x32,0x14,0x0D,0x85, // Slew rate control, PCLK 5, D 5
				0x34,0x1E,0x8F,0x09, // PLL control; bypassed, powered down
				0x34,0x1C,0x02,0x50, // PLL dividers; M=80,N=2,fMCLK=fCLKIN*M/(N+1)/8=80MHz
				0x34,0x1E,0x8F,0x09, // PLL control; Power-up PLL; wait 1ms after this!
				0x34,0x1E,0x8F,0x08, // PLL control; Turn off bypass
				0x32,0x02,0x00,0x08, // Standby control; Wake up
				0x33,0x8C,0x27,0x97, // Output format; Context B shadow
				0x33,0x90,0x00,0x20, // RGB with BT656 codes
				0x33,0x8C,0x27,0x2F, // Sensor Row Start Context B
				0x33,0x90,0x00,0x04, // 4
				0x33,0x8C,0x27,0x33, // Sensor Row End Context B
				0x33,0x90,0x04,0xBB, // 1211
				0x33,0x8C,0x27,0x31, // Sensor Column Start Context B
				0x33,0x90,0x00,0x04, // 4
				0x33,0x8C,0x27,0x35, // Sensor Column End Context B
				0x33,0x90,0x06,0x4B, // 1611
				0x33,0x8C,0x27,0x07, // Output width; Context B
				0x33,0x90,0x02,0x80, // 640
				0x33,0x8C,0x27,0x09, // Output height; Context B
				0x33,0x90,0x01,0xE0, // 480
				0x33,0x8C,0x27,0x5F, // Crop X0; Context B
				0x33,0x90,0x00,0x00, // 0
				0x33,0x8C,0x27,0x63, // Crop Y0; Context B
				0x33,0x90,0x00,0x00, // 0
				0x33,0x8C,0x27,0x61, // Crop X1; Context B
				0x33,0x90,0x06,0x40, // 1600
				0x33,0x8C,0x27,0x65, // Crop Y1; Context B
				0x33,0x90,0x04,0xB0, // 1200
				0x33,0x8C,0x27,0x41, // Sensor_Fine_IT_min B
				0x33,0x90,0x01,0x69, // 361
				0x33,0x8C,0xA1,0x20, // Capture mode options
				0x33,0x90,0x00,0xF2, // Turn on AWB, AE, HG, Video
				0x33,0x8C,0xA1,0x03, // Refresh Sequencer Mode
				0x33,0x90,0x00,0x02, // Capture sequencer
				0x33,0x90,0x00,0x00, // Read until  in mode 0 (run)  ,This Frame is used for Read , do not write
				0x30,0x1A,0x02,0xCC, // reset/output control; parallel enable, drive pins, start streaming
};
int Vmod_Camera_IIC_Config(u32 BaseAddress)
{
	unsigned ByteCount=0;
	int i = 0;
	u8 ReadCamera_PLL_Config[2]; //Read the PLL configure register
	u8 ReadCamera_ChipVersion_Rdata[2];
	u8 ReadCamera_Refresh[2];
	u16 Chip_Version = 0;
	printf("**********************Camera  config********************\n");
	printf("	Here we go\n");
	printf("	Config the Camera\n");

	for(i=0;i<MT9D112_CONFIG_BUFFER_ROWS;i++)
	{
		if (0 == i)
		{
			read_camera_config(BaseAddress,MT9D112_CONFIG_BUFFER[i],ReadCamera_ChipVersion_Rdata);
			Chip_Version = (ReadCamera_ChipVersion_Rdata[0] << 8) | ReadCamera_ChipVersion_Rdata[1];
			printf("	Read Chip Version is:0x%x\n",Chip_Version);
		}
//		else if( 8 == i)
//		{
//			read_camera_config(XPAR_CAMER_IIC_A_BASEADDR,MT9D112_CONFIG_BUFFER[i],ReadCamera_PLL_Config);
//			ByteCount += XIic_Send(XPAR_CAMER_IIC_A_BASEADDR,CAMERA_ADDRESS_ID,MT9D112_CONFIG_BUFFER[i],4,XIIC_STOP);
//		}
		else if(6 == i)
		{
			DelayMs(50);
			ByteCount += XIic_Send(BaseAddress,CAMERA_ADDRESS_ID,MT9D112_CONFIG_BUFFER[i],4,XIIC_STOP);
		}
		else if((MT9D112_CONFIG_BUFFER_ROWS-2) == i)
		{
			read_camera_config(BaseAddress,MT9D112_CONFIG_BUFFER[i],ReadCamera_Refresh);
			while(ReadCamera_Refresh[1] !=0)
				read_camera_config(BaseAddress,MT9D112_CONFIG_BUFFER[i],ReadCamera_Refresh);
			printf("	Refresh Sequencer Mode Complete\n");
		}
		else
			ByteCount += XIic_Send(BaseAddress,CAMERA_ADDRESS_ID,MT9D112_CONFIG_BUFFER[i],4,XIIC_STOP);
	}
	if((MT9D112_CONFIG_BUFFER_ROWS-2)*4 == ByteCount)
	{
		print("		Camera  Configure success\n");
		printf("	Camera  Configure ByteCount Frame is:%d\n",ByteCount/4);
		printf("********************************************************\n");
		return ByteCount;
	}
	else
	{
		printf("	Camera  Configure ByteCount Frame is:%d\n",ByteCount/4);
		print("Error: Camera  Configure fail!\n");
		printf("********************************************************\n");
	}
}
void read_camera_config (u32 BaseAddress, u8 *sub_addr, u8 *RdData)
{
	u8 sent_byte_count;
	u8 received_byte_count;

	RdData[0] = 0;
	RdData[1] = 0;

//	xil_printf("Read         \t");

	sent_byte_count = XIic_Send(BaseAddress, 0x78>>1, sub_addr, 2, XIIC_STOP); //write sub-address

	if (sent_byte_count != 2)
		print("Error: send the address fail when read camera register!\n");

	received_byte_count = XIic_Recv(BaseAddress, 0x79>>1, RdData, 2, XIIC_STOP); //read 2 byte datas

	if (received_byte_count != 2)
		print("Error: read data fail  when read camera register!      \n");
//	else
//		xil_printf("0x%02x 0x%02x\r\n", RdData[0], RdData[1]);

}

主函数

/*
 * Copyright (c) 2009-2012 Xilinx, Inc.  All rights reserved.
 *
 * Xilinx, Inc.
 * XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" AS A
 * COURTESY TO YOU.  BY PROVIDING THIS DESIGN, CODE, OR INFORMATION AS
 * ONE POSSIBLE   IMPLEMENTATION OF THIS FEATURE, APPLICATION OR
 * STANDARD, XILINX IS MAKING NO REPRESENTATION THAT THIS IMPLEMENTATION
 * IS FREE FROM ANY CLAIMS OF INFRINGEMENT, AND YOU ARE RESPONSIBLE
 * FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE FOR YOUR IMPLEMENTATION.
 * XILINX EXPRESSLY DISCLAIMS ANY WARRANTY WHATSOEVER WITH RESPECT TO
 * THE ADEQUACY OF THE IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO
 * ANY WARRANTIES OR REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE
 * FROM CLAIMS OF INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 */
#include <stdio.h>
#include "xparameters.h"
#include "xgpio.h"
#include "xgpiops.h"
#include "xiic.h"
#include "xiic_l.h"
#include "iic_config.h"
#include "public.h"
#include <malloc.h>
/*
 * system define
 */
#define VMODCAMERA
#define CAMER_GPIO_CTL_ADDRESS 0x41220000
#define EEPROM_ADDRESS 0x50	/* 0xA0 as an 8 bit number. */
/*
 * The page size determines how much data should be written at a time.
 * The ML300 board supports a page size of 32 and 16.
 * The write function should be called with this as a maximum byte count.
 */
#define PAGE_SIZE   3
/*
 * The Starting address in the IIC EEPROM on which this test is performed.
 */
#define EEPROM_TEST_START_ADDRESS   0x80

/*
 *  PS GPIO define
 */
#define PS_LD9_PINNUM       7
#define PS_INPIN_DERECTION  0
#define PS_OUTPIN_DERECTION 1
#define PS_GPIO_OUTENBLE    1
/*
 * AXI GPIO define
 */
#define AXI_GPIO_CHANNEL_1  1
#define AXI_GPIO_CHANNEL_2  2
/*
 * instance define
 */
static XIic IicInstance;		    /* The instance of the AXI IIC device. */
static XGpio AXI_GPIOInstancePtr;   /* The instance of the AXI GPIO device.*/
static XGpioPs PS_GPIOInstancePtr;  /* The instance of the PS GPIO device. */
//static XGpio *CAMER_GPIOInstancePtr; /* The instance of the AXI GPIO device.*/
/*
 * global variable declare
 */
typedef  enum {
	BTNC = 0,BTND,BTNU,BTNR,BTNL,
	SW0,SW1,SW2,SW3,SW4,SW5,SW6,SW7
}GPIO2_RDATA;
static const char *BTNx[5] = {"BTNC","BTND","BTNU","BTNR","BTNL"};
/*
 * function  declare
 */
GPIO2_RDATA XGpioBtn();
void Axi_Gpio_initial(XGpio *AXI_GPIOInstancePtr);
void ps_gpio_initial(XGpioPs *PS_GPIOInstancePtr);
void IIC_Test();

void Axi_Gpio_initial(XGpio *AXI_GPIOInstancePtr)
{
	int Status = 0;
	 	 	 /*
	 	          *  initial AXI GPIO and set the derection
	 	          */
	 	    Status = XGpio_Initialize(AXI_GPIOInstancePtr,XPAR_AXI_GPIO_0_DEVICE_ID );
	 	    XGpio_SetDataDirection(AXI_GPIOInstancePtr, AXI_GPIO_CHANNEL_1,0); //output
	 	    XGpio_SetDataDirection(AXI_GPIOInstancePtr, AXI_GPIO_CHANNEL_2,0x0c000000); //BTNS and BTND is input and other is output
	 	    if(XST_SUCCESS != Status )
	 	    {
	 	    	print ("AXIGPIO initial failed \n\r ");
	 	    }
		    XGpio_DiscreteWrite(AXI_GPIOInstancePtr,AXI_GPIO_CHANNEL_1,0x04);//
		    /*   GPIO[31]	GPIO[30]	GPIO[29]	GPIO[28] 	GPIO[0]
		     *   CB_PWDN     VDD_EN      CA_RST     CA_PWDN      CB_RST
		     *     0          1            0          0			  0
		     *     0          1            1          0			  1
		     */

		    XGpio_DiscreteWrite(AXI_GPIOInstancePtr,AXI_GPIO_CHANNEL_1,0xFFFFFFFF);//
		    XGpio_DiscreteWrite(AXI_GPIOInstancePtr,AXI_GPIO_CHANNEL_2,0x4000AA00);//power on the four 8-leds , rst the camera
		    DelayMs(200);
		    XGpio_DiscreteWrite(AXI_GPIOInstancePtr,AXI_GPIO_CHANNEL_2,0x60005501);//power on the other four8-leds,release the rst of the camera
}
void ps_gpio_initial(XGpioPs *PS_GPIOInstancePtr)
{
	 	 	 /*
		      *  initial PS GPIO
		      */
	int Status = 0;
			XGpioPs_Config *PS_GPIOConfigPtr;
		    PS_GPIOConfigPtr = XGpioPs_LookupConfig(XPAR_PS7_GPIO_0_DEVICE_ID);
		    Status = XGpioPs_CfgInitialize(PS_GPIOInstancePtr, PS_GPIOConfigPtr, PS_GPIOConfigPtr->BaseAddr);
		    if (XST_SUCCESS != Status)
		    {
		    	print("PSGPIO initial failed \n\r");
		    }
		    XGpioPs_SetDirectionPin(PS_GPIOInstancePtr, PS_LD9_PINNUM,PS_OUTPIN_DERECTION); /*set MIO9 output*/
		    XGpioPs_SetOutputEnablePin(PS_GPIOInstancePtr, PS_LD9_PINNUM ,PS_GPIO_OUTENBLE);/*enable MIO9 output*/
}

int main()
{
	    int Status ;
	 	 /*peripherals  initialize */
//	    init_platform();
	    printf("**********peripherals initialize**********\n");
	    print("    ----------test begin-------------\n");
	    Status = IIC_Initial(&IicInstance,XPAR_AXI_IIC_0_DEVICE_ID ); /* axi_0 initial*/
	    Axi_Gpio_initial(&AXI_GPIOInstancePtr);/* axi_gpio_0 initial*/
	    ps_gpio_initial(&PS_GPIOInstancePtr);  /* ps_gpio_0 initial*/
		XIic_WriteReg(XPAR_CAMER_IIC_A_BASEADDR, XIIC_RESETR_OFFSET,XIIC_RESET_MASK);//RESET the IIC bus
		XIic_WriteReg(XPAR_CAMER_IIC_B_BASEADDR, XIIC_RESETR_OFFSET,XIIC_RESET_MASK);//RESET the IIC bus
	    print("   --peripherals initialize success--\n");
	    printf("********************end*******************\n");
	    while(1)
	    {
//	    	IIC_Test();
	    	Status = XGpioBtn();
	    	if(BTNU == Status)
	    	{
	    		XIic_WriteReg(XPAR_CAMER_IIC_A_BASEADDR, XIIC_RESETR_OFFSET,XIIC_RESET_MASK);//RESET the IIC bus
	    		XIic_WriteReg(XPAR_CAMER_IIC_B_BASEADDR, XIIC_RESETR_OFFSET,XIIC_RESET_MASK);//RESET the IIC bus
	    		DelayMs(200);
	    		Vmod_Camera_IIC_Config(XPAR_CAMER_IIC_A_BASEADDR);
	    		DelayMs(200);
	    		Vmod_Camera_IIC_Config(XPAR_CAMER_IIC_B_BASEADDR);

	    	}
	    	if(BTNC == Status)
	    	{
	    		XIic_WriteReg(XPAR_CAMER_IIC_A_BASEADDR, XIIC_RESETR_OFFSET,XIIC_RESET_MASK);//RESET the IIC bus
	    		XIic_WriteReg(XPAR_CAMER_IIC_B_BASEADDR, XIIC_RESETR_OFFSET,XIIC_RESET_MASK);//RESET the IIC bus
	    		DelayMs(200);
	    		Read_MT9D112_R_Message(XPAR_CAMER_IIC_A_BASEADDR);
	    		DelayMs(200);
	    		Read_MT9D112_R_Message(XPAR_CAMER_IIC_B_BASEADDR);
	    	}

	    }
	    return 0;
}

GPIO2_RDATA XGpioBtn()
{
	 u32 AXI_Gpio_Channel_2_ReadData = 0;
	 u32 AXI_Gpio_Channel_2_ReadDirection = 0;
	 unsigned int index = 0;
	 DelayMs(50);
	 AXI_Gpio_Channel_2_ReadDirection = XGpio_GetDataDirection(&AXI_GPIOInstancePtr,2);             //Read the AXI_GPIO2 direction
	 XGpio_SetDataDirection(&AXI_GPIOInstancePtr, 2,0x0FFF8000 | AXI_Gpio_Channel_2_ReadDirection); //BTNX and SWx is input ,other is output
	 AXI_Gpio_Channel_2_ReadData = XGpio_DiscreteRead(&AXI_GPIOInstancePtr,AXI_GPIO_CHANNEL_2);     //Read the AXI_GPIO2 data
	 AXI_Gpio_Channel_2_ReadData = (AXI_Gpio_Channel_2_ReadData & 0x0FFF8000) >> 15 ;
// just return the only one button is be pressed
	 for(index=0;index<13;index++)
	 {
		 if((AXI_Gpio_Channel_2_ReadData & (1<<index)) != 0)
		 {
			 printf("--------%s is pressed------\n", BTNx[12-index]);
			 return (12 - index) ;
		 }
	 }

	 return -1;
}

参考：

1、hamsterworks http://hamsterworks.co.nz/mediawiki/index.php/Zedboard_OV7670

2、VmodCAM™ Reference Manuall

3、1/4-Inch 2Mp System-On-A-Chip (SOC) CMOS  Digital Image Sensor

4、VESA and Industry Standards and Guidelines  for Computer Display Monitor Timing（VGA规范）