Перейти к содержанию

Stm32F4Discovery+Ov7670(Camera)

Гость slavaSTM32F$

Автор Гость slavaSTM32F$,
в STM32

 Поделиться

Рекомендуемые сообщения

Гость slavaSTM32F$

Гость slavaSTM32F$

Опубликовано
Опубликовано (изменено)

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

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;
 }   
 }
}

Изменено пользователем admin
BBCode не учили пользоваться?
0
Ссылка на комментарий
Поделиться на другие сайты

Реклама: ООО ТД Промэлектроника, ИНН: 6659197470, Тел: 8 (800) 1000-321

  • 2 месяца спустя...

20% скидка на весь каталог электронных компонентов в ТМ Электроникс!

Акция "Лето ближе - цены ниже", успей сделать выгодные покупки!

Плюс весь апрель действует скидка 10% по промокоду APREL24 + 15% кэшбэк и бесплатная доставка!

Перейти на страницу акции

Реклама: ООО ТМ ЭЛЕКТРОНИКС, ИНН: 7806548420, info@tmelectronics.ru, +7(812)4094849

  • 1 месяц спустя...

Выбираем схему BMS для заряда литий-железофосфатных (LiFePO4) аккумуляторов

Обязательным условием долгой и стабильной работы Li-FePO4-аккумуляторов, в том числе и производства EVE Energy, является применение специализированных BMS-микросхем. Литий-железофосфатные АКБ отличаются такими характеристиками, как высокая многократность циклов заряда-разряда, безопасность, возможность быстрой зарядки, устойчивость к буферному режиму работы и приемлемая стоимость. Но для этих АКБ очень важен контроль процесса заряда и разряда для избегания воздействия внешнего зарядного напряжения после достижения 100% заряда. Инженеры КОМПЭЛ подготовили список таких решений от разных производителей. Подробнее>>

Реклама: АО КОМПЭЛ, ИНН: 7713005406, ОГРН: 1027700032161

Присоединяйтесь к обсуждению

Вы можете написать сейчас и зарегистрироваться позже. Если у вас есть аккаунт, авторизуйтесь, чтобы опубликовать от имени своего аккаунта.
Примечание: Ваш пост будет проверен модератором, прежде чем станет видимым.

Гость
Unfortunately, your content contains terms that we do not allow. Please edit your content to remove the highlighted words below.
Ответить в этой теме...

×   Вставлено с форматированием.   Восстановить форматирование

  Разрешено использовать не более 75 эмодзи.

×   Ваша ссылка была автоматически встроена.   Отображать как обычную ссылку

×   Ваш предыдущий контент был восстановлен.   Очистить редактор

×   Вы не можете вставлять изображения напрямую. Загружайте или вставляйте изображения по ссылке.

Загрузка...
×
 Поделиться
Перейти к списку тем

  • Последние посетители   0 пользователей онлайн

    • Ни одного зарегистрированного пользователя не просматривает данную страницу
×
×
  • Создать...