Доброго времени суток

OV7670 - без буфера...

Не как не получается пообщаться с камерой(OV7670). На черное/белое/зеленое/красное/синие один ответ - мусор.

Для написания кода я выбрал формат RGB565 и картинку "qcif"(176X144).

Для примера использовал это:

http://supuntharanga...-ov7660-or.html

С регистрами

http://mbed.org/user...a4ed/ov7670.cpp



Роспиновка:

PA8 - XCLK

PB8 - SDIOC

PB9 - SDIOD

РB7: VSYNC

РA4: HSYNC

РA6: PCLK

РC6: data0

РC7: data1

РC8: data2

РC9: data3

РE4: data4

РB6: data5

РE5: data6

РE6: data7



ВОТ САМ КОД в Keil(Р.S. Если у кого то есть готовый рабочий проект поделитесь. Буду очень благодарен. Может есть еще связь с компом будет просто восхитительно!!!):

#include "stm32f4xx.h"
#include "stm32f4xx_rcc.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_i2c.h"
#include "stm32f4xx_dcmi.h"
#include "stm32f4xx_dma.h"
#include "misc.h"
#include "ov7670reg.h"

#define ONE_BYTE_REG_ADDR 0x01
#define TWO_BYTE_REG_ADDR 0x02
#define ROW 72
#define COLUMNS 80  //I got only 80 columns instead of 88 columns
#define BYTESPERPIX 2

int frame_buffer[19200]; //160*120

int frame_flag=1;

//FOR TEST LED)))
void InitTestLed()
{
GPIO_InitTypeDef gpioConf;
// ????????????? ?????, ????????????? ? ??????
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
gpioConf.GPIO_Pin = GPIO_Pin_0;
gpioConf.GPIO_Mode = GPIO_Mode_IN;
GPIO_Init(GPIOA, &gpioConf);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
// ????????????? ?????, ????????????? ? ??????????
gpioConf.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14;
gpioConf.GPIO_Mode = GPIO_Mode_OUT;
gpioConf.GPIO_Speed = GPIO_Speed_100MHz;
gpioConf.GPIO_OType = GPIO_OType_PP;
gpioConf.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &gpioConf);
}


//FOR DELAY USE STANDART FUNC
void Delay(uint32_t nCount)
{
   while(nCount--)
   {
   }
}


void SHOWIMAGE()
{   
   int WIDTH=160;
   int HEIGHT=120;
   int BYTES_PER_PIXEL =2;
   int z=0;
   int counter1=0;
   int counter2=0;
   
   for( z=0;z<ROW*COLUMNS*BYTESPERPIX/4;z++)
   {
	 int i = frame_buffer[4*z+1];
	  int k=frame_buffer[4*z+3];
	  int ooo=10;
	  if(i<70000000)
	  {
	   counter1++; 
	 }
	  else
	  {
	   counter2++; 
	 }
	  if((z+1)%40==0)
	  {
   //new row
	 }
   }
   if(counter1<counter2)
   {
   GPIO_SetBits(GPIOD, GPIO_Pin_13);
   }
   else
   {
  GPIO_SetBits(GPIOD, GPIO_Pin_14);
  }
	  
}



//-----------------------------
//Function for camera ov7670
//-----------------------------

//PA8 - XCLK// AND TEST WORK FUNCTION!!! 
void MCO1_Init(void)
{
   GPIO_InitTypeDef GPIO_InitStructure;
   //ENABLE CLOCK
   RCC_ClockSecuritySystemCmd(ENABLE);   
   // Enable GPIOs clocks 
   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
   // Enable AS MCO
   GPIO_PinAFConfig(GPIOA, GPIO_PinSource8, GPIO_AF_MCO);
   // Configure MCO (PA8)
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;  
  GPIO_Init(GPIOA, &GPIO_InitStructure);
   //SET divider4  (100/4= 25MHz)(ua => delitel`)
	RCC_MCO1Config(RCC_MCO1Source_PLLCLK, RCC_MCO1Div_4);
}

//THIS FUCNCTION TO CONFIGURATION CAMERA(I2C)
//PB8 - SDIOC PB9 - SDIOD 
void Hardware_InitI2C(void)
{
GPIO_InitTypeDef GPIO_InitStructure; // this is for the GPIO pins used as I2C1SDA and I2C1SCL
I2C_InitTypeDef I2C_InitStructure; // this is for the I2C1 initilization

// Enable APB1 peripheral clock for I2C1
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
// Enable the peripheral clock for the pins used 
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);

//Set up the I2C1SDA and I2C1SCL pins
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9; // Pins 10(I2C1_SCL) and 11(I2C1_SDA)
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; // the pins are configured as alternate function so the USART peripheral has access to them
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;// this defines the IO speed and has nothing to do with the baudrate!
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;// this defines the output type as open drain
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;// this activates the pullup resistors on the IO pins
GPIO_Init(GPIOB, &GPIO_InitStructure);// now all the values are passed to the GPIO_Init() 

//Configurated pins to Alternative FUNCTION
GPIO_PinAFConfig(GPIOB, GPIO_PinSource8, GPIO_AF_I2C1); 
GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_I2C1);

// Configure I2C1
  I2C_StructInit(&I2C_InitStructure);
  I2C_DeInit(I2C1);
   
   // Enable the I2C peripheral 
  I2C_Cmd(I2C1, ENABLE);
   
   //Set the I2C structure parameters 
  I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
  I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
  I2C_InitStructure.I2C_OwnAddress1 = 0x00;
  I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
  I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
  I2C_InitStructure.I2C_ClockSpeed = 100000;
  // I2C Peripheral Enable 
   I2C_ITConfig(I2C1, I2C_IT_ERR, ENABLE);
  // Initialize the I2C peripheral
  I2C_Init(I2C1,&I2C_InitStructure);
  I2C_Cmd(I2C1, ENABLE);
}

//FUNCTION TO SEND DATA FOR CONFIGURATE CAMERA
int i2c_send_data(u8 slave_addr, u16 reg_addr, u8 data, u8 addr_len)
{
   int timeout = 0x7FFFFF;
   int ret = 0;
   //SEND I2C
   I2C_GenerateSTART(I2C1, ENABLE);
   while( !I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_MODE_SELECT)) 
  {
   if ((timeout--) == 0) 
   {
	ret = 1;
	goto exit;
   }
  }
   I2C_Send7bitAddress(I2C1, slave_addr, I2C_Direction_Transmitter);  
  while(!(I2C1->SR1 & (1 << 1))) // check ADDR bit
  {
   if ((timeout--) == 0) 
   {
	ret = 2;
	goto exit;
   }
  }
	while(!(I2C1->SR2 & (1 << 2)))   // check TRA bit
  {
   if ((timeout--) == 0) 
   {
	ret = 3;
	goto exit;
   }
  }
   /* 2 byte reg address */
  if(addr_len == TWO_BYTE_REG_ADDR)
  {
   // MSB
   I2C_SendData(I2C1, (0xFF & (reg_addr >> 8)) );   
   while(!(I2C1->SR1 & (1 << 7)))
   {
   if ((timeout--) == 0) 
   {
	ret = 4;
	goto exit;
   }
   }
	 
   // LSB
   I2C_SendData(I2C1, (0xFF & reg_addr));   
   while(!(I2C1->SR1 & (1 << 7)))
   {
   if ((timeout--) == 0) 
   {
	ret = 5;
	goto exit;
   }
   }
  
  }
  /* 1 byte reg address */
  else 
  {
   I2C_SendData(I2C1, (0xFF & reg_addr));   
   while(!(I2C1->SR1 & (1 << 7)))
   {
   if ((timeout--) == 0) 
   {
	ret = 6;
	goto exit;
   }
   } 
  }

  I2C_SendData(I2C1, data);  
  while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  {
//   if ((timeout--) == 0) 
   {
	ret = 7;
	goto exit;
   }
  } 

  exit:  
  I2C_GenerateSTOP(I2C1, ENABLE);  
  return ret;
}

//FUNCTION TO RECIVE DATE FROM CAMERA
int i2c_receive_data(u8 slave_addr, u16 reg_addr, u8* data, u8 addr_len)
{
  int timeout = 0x7FFFFF;
  int ret = 0;
   /* send i2c*/
  while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY));
  I2C_GenerateSTART(I2C1, ENABLE); 
  while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_MODE_SELECT))
  {
   if ((timeout--) == 0) 
   {
	ret = 1;
	goto exit;
   }
  }
  
  I2C_Send7bitAddress(I2C1, slave_addr, I2C_Direction_Transmitter);  
  while(!(I2C1->SR1 & (1 << 1))) // check ADDR bit
  {
   if ((timeout--) == 0)	
   {
	ret = 2;
	goto exit;
   }
  }
  
  while(!(I2C1->SR2 & (1 << 2)))   // check TRA bit
  {
   if ((timeout--) == 0) 
   {
	ret = 3;
	goto exit;
   }
  }
  
  /* 2 byte reg address */
  if(addr_len == TWO_BYTE_REG_ADDR)
  {
   // MSB
   I2C_SendData(I2C1, (0xFF & (reg_addr >> 8)) );   
   while(!(I2C1->SR1 & (1 << 7))) 
   {
   if ((timeout--) == 0) 
   {
	ret = 4;
	goto exit;
   }
  }
	 
   // LSB
   I2C_SendData(I2C1, (0xFF & reg_addr));   
   while(!(I2C1->SR1 & (1 << 7)))
   {
   if ((timeout--) == 0) 
   {
	ret = 5;
	goto exit;
   }
  }
  }
  
  /* 1 byte reg address */
  else 
  {
   I2C_SendData(I2C1, (0xFF & reg_addr));
   while(!(I2C1->SR1 & (1 << 7)))
   {
   if ((timeout--) == 0) 
   {
	ret = 6;
	goto exit;
   }
  }
  }

  I2C_GenerateSTOP(I2C1, ENABLE);
  I2C_GenerateSTART(I2C1, ENABLE);
  while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_MODE_SELECT))
  {
   if ((timeout--) == 0) 
   {
	ret = 7;
	goto exit;
   }
  }
  I2C_Send7bitAddress(I2C1, slave_addr, I2C_Direction_Receiver);
  while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)) // check ADDR bit
  {
   if ((timeout--) == 0) 
   {
	ret = 8;
	goto exit;
   }
  }
	
  I2C_AcknowledgeConfig(I2C1, DISABLE);
				/* Send STOP Condition */
				I2C_GenerateSTOP(I2C1, ENABLE);
  
  while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED))
  {
   if ((timeout--) == 0) 
   {
	ret = 10;
	goto exit;
   }
  }
  
  *data = I2C_ReceiveData(I2C1);
  I2C_AcknowledgeConfig(I2C1, ENABLE);
  return ret;
  
exit:
  I2C_GenerateSTOP(I2C1, ENABLE);
  return ret;
}

////////////////////////////////////////////////////////////////////
//FOR COMFORTING WRITE AND READ FROM CAMERA 2 FUNCTION//////////////
////////////////////////////////////////////////////////////////////
int camera_read_reg(u8 reg, u8* data)
{ 
return i2c_receive_data(0x42, (u16) reg, data, ONE_BYTE_REG_ADDR);
}
/*******************************************************************************/
int camera_write_reg(u8 reg, u8 data)
{ 
return i2c_send_data(0x43, (u16) reg, data, ONE_BYTE_REG_ADDR);
}
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////

int WriteReg(int x, int y)
{
int ret = camera_write_reg(x, y);  
if(ret < 0)
return ret;
Delay(0xFFFF);
return ret;
}

//FOR CONFIG CAMERA VERY IMPORTANT FUNCTION...DATA FROM IT IN DATASHEET
int camera_config()
{
int ret = 0;
  
//RESET
ret = WriteReg(0x12, 0x80); 
ret = WriteReg(0x12, 0x80); 
// 
ret = WriteReg(REG_RGB444, 0x00);

ret = WriteReg(REG_COM10, 0x02);  
	
ret = WriteReg(REG_MVFP, 0x27);  
	 
ret = WriteReg(REG_CLKRC, 0x80);  
	 
ret = WriteReg(DBLV, 0x0a);  
	
ret = WriteReg(REG_COM11, 0x0A);  
	 
ret = WriteReg(REG_TSLB, 0x04);  
	
ret = WriteReg(REG_COM13, 0x88);  

//RGB565
	 
ret = WriteReg(REG_COM7, 0x04);  
	 
ret = WriteReg(REG_RGB444, 0x00);  
	 
ret = WriteReg(REG_COM15, 0x10);  
	
ret = WriteReg(REG_COM3, 0x04);  
	
ret = WriteReg(REG_CLKRC, 0x80);  

///
	 
ret = WriteReg(0x70, 0x3A);  
	 
ret = WriteReg(0x71, 0x35);  
	
ret = WriteReg(0xA2, 0x02);  

// 160*120
	 
ret = WriteReg(REG_COM14, 0x1a);  

ret = WriteReg(0x72, 0x22);  
	 
ret = WriteReg(0x73, 0xf2);  
	
ret = WriteReg(REG_HREF, 0xa4);  
	
ret = WriteReg(REG_HSTART, 0x16);  
	
ret = WriteReg(REG_HSTOP, 0x04);  
	
ret = WriteReg(REG_VREF, 0x0a);  
	 
ret = WriteReg(REG_VSTART, 0x02);  
	 
ret = WriteReg(REG_VSTOP, 0x7a);  


		WriteReg(0x7a, 0x20);
		WriteReg(0x7b, 0x1c);
		WriteReg(0x7c, 0x28);
		WriteReg(0x7d, 0x3c);
		WriteReg(0x7e, 0x5a);
		WriteReg(0x7f, 0x68);
		WriteReg(0x80, 0x76);
		WriteReg(0x81, 0x80);
		WriteReg(0x82, 0x88);
		WriteReg(0x83, 0x8f);
		WriteReg(0x84, 0x96);
		WriteReg(0x85, 0xa3);
		WriteReg(0x86, 0xaf);
		WriteReg(0x87, 0xc4);
		WriteReg(0x88, 0xd7);
		WriteReg(0x89, 0xe8);
		
		WriteReg(0x13, 0xe0);
		WriteReg(0x00, 0x00);
		WriteReg(0x10, 0x00);
		WriteReg(0x0d, 0x40);
		WriteReg(0x14, 0x18);
		WriteReg(0xa5, 0x05);
		WriteReg(0xab, 0x07);
		WriteReg(0x24, 0x95);
		WriteReg(0x25, 0x33);
		WriteReg(0x26, 0xe3);
		WriteReg(0x9f, 0x78);
		WriteReg(0xa0, 0x68);
		WriteReg(0xa1, 0x03);
		WriteReg(0xa6, 0xd8);
		WriteReg(0xa7, 0xd8);
		WriteReg(0xa8, 0xf0);
		WriteReg(0xa9, 0x90);
		WriteReg(0xaa, 0x94);
		WriteReg(0x13, 0xe5);
		
		WriteReg(0x0e, 0x61);
		WriteReg(0x0f, 0x4b);
		WriteReg(0x16, 0x02);

		WriteReg(0x21, 0x02);
		WriteReg(0x22, 0x91);
		WriteReg(0x29, 0x07);
		WriteReg(0x33, 0x0b);
		WriteReg(0x35, 0x0b);
		WriteReg(0x37, 0x1d);
		WriteReg(0x38, 0x71);
		WriteReg(0x39, 0x2a);
		WriteReg(0x3c, 0x78);
		WriteReg(0x4d, 0x40);
		WriteReg(0x4e, 0x20);
		WriteReg(0x69, 0x00);

		WriteReg(0x74, 0x10);
		WriteReg(0x8d, 0x4f);
		WriteReg(0x8e, 0x00);
		WriteReg(0x8f, 0x00);
		WriteReg(0x90, 0x00);
		WriteReg(0x91, 0x00);
		WriteReg(0x92, 0x00);

		WriteReg(0x96, 0x00);
		WriteReg(0x9a, 0x80);
		WriteReg(0xb0, 0x84);
		WriteReg(0xb1, 0x0c);
		WriteReg(0xb2, 0x0e);
		WriteReg(0xb3, 0x82);
		WriteReg(0xb8, 0x0a);
		
		WriteReg(0x43, 0x0a);
		WriteReg(0x44, 0xf0);
		WriteReg(0x45, 0x34);
		WriteReg(0x46, 0x58);
		WriteReg(0x47, 0x28);
		WriteReg(0x48, 0x3a);
		WriteReg(0x59, 0x88);
		WriteReg(0x5a, 0x88);
		WriteReg(0x5b, 0x44);
		WriteReg(0x5c, 0x67);
		WriteReg(0x5d, 0x49);
		WriteReg(0x5e, 0x0e);
		WriteReg(0x64, 0x04);
		WriteReg(0x65, 0x20);
		WriteReg(0x66, 0x05);
		WriteReg(0x94, 0x04);
		WriteReg(0x95, 0x08);

		WriteReg(0x6c, 0x0a);
		WriteReg(0x6d, 0x55);
		WriteReg(0x6e, 0x11);
		WriteReg(0x6f, 0x9f);
		WriteReg(0x6a, 0x40);
		WriteReg(0x01, 0x40);
		WriteReg(0x02, 0x40);
		WriteReg(0x13, 0xe7);
		WriteReg(0x15, 0x02);

		WriteReg(0x4f, 0x80);
		WriteReg(0x50, 0x80);
		WriteReg(0x51, 0x00);
		WriteReg(0x52, 0x22);
		WriteReg(0x53, 0x5e);
		WriteReg(0x54, 0x80);
		WriteReg(0x58, 0x9e);
		
		WriteReg(0x41, 0x08);
		WriteReg(0x3f, 0x00);
		WriteReg(0x75, 0x05);
		WriteReg(0x76, 0xe1);
		WriteReg(0x4c, 0x00);
		WriteReg(0x77, 0x01);
		WriteReg(0x3d, 0xc1);
		WriteReg(0x4b, 0x09);
		WriteReg(0xc9, 0x60);
		WriteReg(0x41, 0x38);
		WriteReg(0x56, 0x40);
		
		WriteReg(0x34, 0x11);
		WriteReg(0x3b, 0x02);
		WriteReg(0xa4, 0x88);
		WriteReg(0x96, 0x00);
		WriteReg(0x97, 0x30);
		WriteReg(0x98, 0x20);
		WriteReg(0x99, 0x30);
		WriteReg(0x9a, 0x84);
		WriteReg(0x9b, 0x29);
		WriteReg(0x9c, 0x03);
		WriteReg(0x9d, 0x4c);
		WriteReg(0x9e, 0x3f);
		WriteReg(0x78, 0x04);
		
		WriteReg(0x79, 0x01);
		WriteReg(0xc8, 0xf0);
		WriteReg(0x79, 0x0f);
		WriteReg(0xc8, 0x00);
		WriteReg(0x79, 0x10);
		WriteReg(0xc8, 0x7e);
		WriteReg(0x79, 0x0a);
		WriteReg(0xc8, 0x80);
		WriteReg(0x79, 0x0b);
		WriteReg(0xc8, 0x01);
		WriteReg(0x79, 0x0c);
		WriteReg(0xc8, 0x0f);
		WriteReg(0x79, 0x0d);
		WriteReg(0xc8, 0x20);
		WriteReg(0x79, 0x09);
		WriteReg(0xc8, 0x80);
		WriteReg(0x79, 0x02);
		WriteReg(0xc8, 0xc0);
		WriteReg(0x79, 0x03);
		WriteReg(0xc8, 0x40);
		WriteReg(0x79, 0x05);
		WriteReg(0xc8, 0x30);
		WriteReg(0x79, 0x26);
		WriteReg(0x09, 0x03);
		WriteReg(0x3b, 0x42);
		
		WriteReg(0xff, 0xff);   /* END MARKER */ 


return ret;  
}

//////////////////////////////////
//////////////////////////////////
//OTHER CONNECT   
	  /* B7: VSYNC*/
	/* A4: HSYNC*/
	/* A6: PCLK*/
	/* C6: data0*/
	/* C7: data1*/
	/* C8: data2*/ 
	/* C9: data3*/
	/* E4: data4*/
	/* B6: data5*/
	/* E5: data6*/
	/* E6: data7*/
///////////////////////////////////
void DCMI_Configure(void)
{
  DCMI_InitTypeDef DCMI_InitStructure;
  DMA_InitTypeDef  DMA_InitStructure; 
  NVIC_InitTypeDef NVIC_InitStructure;
   GPIO_InitTypeDef GPIO_InitStructure; 
  /* GPIOD Periph clock enable */
RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_DCMI, ENABLE);
		RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);

RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);

  /* Configure PD12, PD13, PD14 and PD15 in output pushpull mode */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOD, &GPIO_InitStructure);

   /* B7: VSYNC*/
	GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_DCMI);
	/* A4: HSYNC*/
	GPIO_PinAFConfig(GPIOA, GPIO_PinSource4, GPIO_AF_DCMI);
	/* A6: PCLK*/
	GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_DCMI);
	/* C6: data0*/
	GPIO_PinAFConfig(GPIOC, GPIO_PinSource6, GPIO_AF_DCMI);
	/* C7: data1*/
	GPIO_PinAFConfig(GPIOC, GPIO_PinSource7, GPIO_AF_DCMI);
	/* C8: data2*/  
	GPIO_PinAFConfig(GPIOC, GPIO_PinSource8, GPIO_AF_DCMI);
	/* C9: data3*/ 
	GPIO_PinAFConfig(GPIOC, GPIO_PinSource9, GPIO_AF_DCMI);
	/* E4: data4*/
	GPIO_PinAFConfig(GPIOE, GPIO_PinSource4, GPIO_AF_DCMI);
	/* B6: data5*/
	GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_DCMI);
	/* E5: data6*/
	GPIO_PinAFConfig(GPIOE, GPIO_PinSource5, GPIO_AF_DCMI);
	/* E6: data7*/
	GPIO_PinAFConfig(GPIOE, GPIO_PinSource6, GPIO_AF_DCMI);
/* DCMI GPIO configuration */

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
  
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_Init(GPIOA, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ;
	GPIO_Init(GPIOB, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ;
	GPIO_Init(GPIOC, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP ;
	GPIO_Init(GPIOE, &GPIO_InitStructure);


	  /* DCMI configuration */
   
	  DCMI_InitStructure.DCMI_CaptureMode = DCMI_CaptureMode_SnapShot;  
	  DCMI_InitStructure.DCMI_ExtendedDataMode = DCMI_ExtendedDataMode_8b; 
	  DCMI_InitStructure.DCMI_CaptureRate = DCMI_CaptureRate_All_Frame;   
	  DCMI_InitStructure.DCMI_VSPolarity = DCMI_VSPolarity_High;	
	  DCMI_InitStructure.DCMI_HSPolarity = DCMI_HSPolarity_Low;		   
	  DCMI_InitStructure.DCMI_PCKPolarity = DCMI_PCKPolarity_Rising;	   
	  DCMI_InitStructure.DCMI_SynchroMode = DCMI_SynchroMode_Hardware;	 
	  
	 
																			 
	  DCMI_Init(&DCMI_InitStructure);

	 
	 //DCMI_ITConfig(DCMI_IT_VSYNC, ENABLE);
	 //DCMI_ITConfig(DCMI_IT_LINE, ENABLE);
	 //DCMI_ITConfig(DCMI_IT_FRAME, ENABLE);
	 //DCMI_ITConfig(DCMI_IT_OVF, ENABLE);
	 //DCMI_ITConfig(DCMI_IT_ERR, ENABLE);
   


	  /* Configures the DMA2 to transfer Data from DCMI */

	  /* DMA2 Stream1 Configuration */
	  DMA_DeInit(DMA2_Stream1);
  
	  DMA_StructInit(&DMA_InitStructure);
  
	  DMA_InitStructure.DMA_Channel = DMA_Channel_1;
	  DMA_InitStructure.DMA_PeripheralBaseAddr =  (uint32_t)(&DCMI->DR);
	  DMA_InitStructure.DMA_Memory0BaseAddr =  (uint32_t)frame_buffer;
	  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
	  DMA_InitStructure.DMA_BufferSize = ROW*COLUMNS*BYTESPERPIX/4;/* size of image in bytes/4 */	 
		 DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
	  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
	  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
	  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
	  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
	  DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
	  DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
	  DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
	  DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
	  DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
	  DMA_Init(DMA2_Stream1, &DMA_InitStructure);
	  DMA_ITConfig(DMA2_Stream1, DMA_IT_TC, ENABLE);
	  DMA_ITConfig(DMA2_Stream1, DMA_IT_TE, ENABLE);
   
	  /* DMA2 IRQ channel Configuration */
	  
NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
   
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
NVIC_InitStructure.NVIC_IRQChannel = DCMI_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
   
DMA_Cmd(DMA2_Stream1, ENABLE);
   
DCMI_Cmd(ENABLE);
DCMI_CaptureCmd(ENABLE);
}

void DMA2_Stream1_IRQHandler(void)
{
static  int K;
  //Test on DMA2 Channel1 Transfer Complete interrupt
  if(DMA_GetITStatus(DMA2_Stream1,DMA_IT_TCIF1) ==  SET)
  {
  frame_flag = 1;//when frame_flag =1,all the data will be send through serial port in main function while loop
	DMA_ClearITPendingBit(DMA2_Stream1,DMA_IT_TCIF1);
  }
  if(DMA_GetITStatus(DMA2_Stream1,DMA_IT_TEIF1) ==  SET)
  {  
	DMA_ClearITPendingBit(DMA2_Stream1,DMA_IT_TEIF1);
  } 
}

void DCMI_IRQHandler(void)
{
static volatile int line,col,i,j = 0;
	if(DCMI_GetFlagStatus(DCMI_FLAG_FRAMERI) == SET)
	{
   DCMI_ClearFlag(DCMI_FLAG_FRAMERI);   
	}
   if(DCMI_GetFlagStatus(DCMI_FLAG_OVFRI) == SET)
	{
   DCMI_ClearFlag(DCMI_FLAG_OVFRI);   
	}
}

int main(void)
{
   MCO1_Init();
   Hardware_InitI2C(); 
   camera_config();
   DCMI_Configure();
   
  while (1)
  {
  if( frame_flag == 1)
  {
	SHOWIMAGE();
	frame_flag = 0;
  }   
  }
}

Раздел: STM32