Selamlar
Stm32f1xx ile ov7670 yada herhangi bir kamera kullanan hiç oldu mu?
Bu kamera için örnek programlar arıyorum.Ancak henüz düzgün bir kaynağa erişemedim.
Bir de sscb protokolü var.Baya ilginç geldi.Stm32f4 de bulunan dcmi ile bu iki arkadaşı nasıl bir araya getirebiliriz?
Önerisi olan var mı?
Merhaba, ben STM32F4 ile ov9655 camerası ile çalışıyorum ama donanımı kullanmıorum DCMI yi.Bu DCMI ile LCD yi kullanarak güzel resimler çekenler olmuş ama ben camera dan aldıgım görüntüleri PC de görmek istediğimden tam işimi görmüyor.Daha dogrusu harici bi flash veya ram e DMA kullaranarak dataları yazmam daha sonrada bunları PCye aktarmam lazım bende bu işi yazılımsal olarak yapmaya karar verdim.Bunun için yazılımsal olarak seri dataları okuyup resim elde ettim ama çok hızlı data akşı oldugu için bit kaçması olmalı ki resimlerde kırmızı veya yeşil renk karışıyor.Bunun için AL422b FIFO dan sipariş verdim daha elime geçmedi.Bakalım geçince neler olacak.Örnek bulamadım demişssiniz ben size bir kaç örnek yolluyorum belki bunları bulmuşda olabilrisniz.Ama yine de bakarsınız.
http://yadi.sk/d/opOLsCav5Dmnh
Merhaba Arkadaşlar,
OV9655 Kamera modülünü kullanmaya çalışıyorum. Kamerayla bir türlü iletişime geçemedim. I2C1 donanımını Kamerayı init etmek için kurdum. I2C'nin çalıştığını doğruladım fakat kamera I2C den gönderdiğim hiçbir komuta cevap vermiyor. Ölü gibi resmen...
Bağlantılarıda defalarca kontrol ettim. Problem yok yani sıkıntı çıkarmaması gerekir.
Sizce olası problemler nelerdir?
@ mucit23 buspirate gibi bir cihazla i2c adres taraması yapabilirseniz modülün sağlamlığını görmüş olursunuz. Modül bozuk olabilir.
Uğraşmadım ancak araştırmama göre fifo olan modelde kamera seçmek yada harici fifo kullanmak alınacak görüntü için önem arzetmekte.
yakın zamanda fifolu bir modül edinmeyi düşünüyorum.
hocam öyle bir cihazım yok ama modül sağlam olması gerek. Aldığımdan beri ilk defa kullanıyorum. Kullanıcı kaynaklı herhangi bir hasar görmedi.
Şuanda FIFO'ya ihtiyaç yok çünkü zaten donanımsal olarak veri çekeceğim. DCMI den data alıp direk LCD ye yollanacak. Belki ileride gelen datalarla oynamam gerekirse fifoya ihtiyaç olabilir. Ozamanda DMA ile hallederim herhalde.
Anlamadığım nokta şu, nedense I2C rutinlerinde hep timeout yaşanıyor. Bunu çözmeye çalışıyorum.
Hıza mı yetişemiyor desem böyle bir modülün en yüksek hızı sağlaması gerek. Modülü sağlam olarak düşünürsek:
Kullandığınız adresler yanlış olabilir mi? Ya da kullanmanız gereken bir adresi es geçmiş olabilir misiniz?
Hocam yok daha o aşamalara gelemedim. Henüz kamera ile iletişime geçemiyorum. I2C kodlarımda problem var.
Akşam kullandığım kütüphaneleri ekleyeceğim. I2C kütüphanesinde timeout yaşanıyor. Yani Start biti gönderiliyor ardından 7 bitlik adres gönderiliyor sonra program gönderilip gönderilmediğini denetlerken timeout yaşanıp gönderme işleminden vazgeçiliyor. Skop ile SDA hattına baktığımda start bitini görüyorum. Ondan sonra birşeyler daha gönderiliyor fakat sonrasında kesiliyor.
Şuanda zaten kendi yazdığım bir kod yok. Örnek programlar üzerinden gidiyorum.
i2c donanımının doğru init edildiğini veya kodlarını test edebilmek için farklı bir i2c ic deneyebilir msin?eeprom vs gibi?Veya start bitinden sonraki verilerin doğu olduğuna emin olabilir misin?Gönderdiğin adres verisi mi doğru mu değil mi?
I2C hattını ben pull-up yapmadım. Yeni aklıma geldi. Bundan kaynaklanabilir değilmi? Ben direk SDA, SCL bağlantı yaptım.
Alıntı yapılan: Mucit23 - 27 Şubat 2014, 10:35:12
I2C hattını ben pull-up yapmadım. Yeni aklıma geldi. Bundan kaynaklanabilir değilmi? Ben direk SDA, SCL bağlantı yaptım.
Yapılması gerekir genelde modüllerin kendisinde pull up bulunur ancak bulunmama ihtimali de var.
Bi açık buldum diye sevinmiştim ama galiba modül üzerinde bulunuyor. Şemada gördüm pull-up dirençlerini.
Hocam yok gerçektende modül üzerinde pull-up dirençleri varmış. SDA hattı zaten sürekli 1 konumunda bekliyor.
OV9655 için kullandığım kütüphane budur.
ov9655.c
/**
******************************************************************************
* @file DCMI/OV9655_Camera/dcmi_ov9655.c
* @author MCD Application Team
* @version V0.0.3
* @date 10/15/2010
* @brief This file includes the driver for OV9655 Camera module mounted on
* STM3220F-EVAL board RevA.
******************************************************************************
* @copy
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* <h2><center>© COPYRIGHT 2010 STMicroelectronics</center></h2>
*/
/* Includes ------------------------------------------------------------------*/
#include "OV9655.h"
#include "stm32f4xx.h"
#include "main.h"
/** @addtogroup DCMI_OV9655_Camera
* @{
*/
/* Private typedef -----------------------------------------------------------*/
RCC_ClocksTypeDef RCC_Clocks;
/* Private define ------------------------------------------------------------*/
#define TIMEOUT 2
#define DCMI_DR_ADDRESS 0x50050028
#define FSMC_LCD_ADDRESS 0x60020000
#define CAMERA_RST_PIN GPIO_Pin_12
#define CAMERA_RST_PORT GPIOD
#define CAMERA_PWR_EN_PIN GPIO_Pin_6
#define CAMERA_PWR_EN_PROT GPIOD
/* Bits definitions ----------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
/* Pin Map -------------------------------------------------------------------*/
/*
DCMI D0 = PC6
DCMI D1 = PC7
DCMI D2 = PE0
DCMI D3 = PE1
DCMI D4 = PE4
DCMI D5 = PB6
DCMI D6 = PE5
DCMI D7 = PE6
DCMI HSYNC = PA4
DCMI VSYNC = PB7
DCMI PXCLK = PA6
I2C_SCL = PB8
I2C_SDA = PB9
*/
/**
* @brief Configures the OV9655 DCMI
* @param None
* @retval None
*/
void DCMI_Control_IO_Init(void)
{
int i=0;
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIOD clocks */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
/* camera RST pin configuration */
GPIO_InitStructure.GPIO_Pin = CAMERA_RST_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(CAMERA_RST_PORT, &GPIO_InitStructure);
/*Reset camera*/
GPIO_ResetBits(CAMERA_RST_PORT, CAMERA_RST_PIN);
for(i=0;i<10000;i++){}
GPIO_SetBits(CAMERA_RST_PORT, CAMERA_RST_PIN);
/* camera PWR EN pin configuration */
GPIO_InitStructure.GPIO_Pin = CAMERA_PWR_EN_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(CAMERA_PWR_EN_PROT, &GPIO_InitStructure);
GPIO_ResetBits(CAMERA_PWR_EN_PROT, CAMERA_PWR_EN_PIN);
}
/**
* @brief Configures the OV9655 DCMI
* @param None
* @retval None
*/
uint8_t DCMI_OV9655_Configuration(void){
int i=0;
/*DCMI Control pins configuration*/
DCMI_Control_IO_Init();
/* I2C1 configuration */
OV9655_I2C_Configuration();
for(i=0;i<10000;i++){}
/* Reset and check the presence of the OV9655 camera module */
if (DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x12, 0x80)==0xFF)
{
return (0xFF);
}
for(i=0;i<10000;i++){}
/* OV9655 Camera size setup */
DCMI_OV9655_QVGASizeSetup();
/* Set the RGB565 mode */
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM7, 0x63);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM15, 0x10);
/* Invert the HRef signal*/
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM10, 0x08);
/* DCMI configuration */
OV9655_DCMI_Configuration();
return (0x00);
}
/**
* @brief Configures the I2C1.
* @param None
* @retval None
*/
void OV9655_I2C_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
I2C_InitTypeDef I2C_InitStruct;
/* I2C1 clock enable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
/* GPIOB clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
/* Configure the I2C GPIOs */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_I2C1);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource8, GPIO_AF_I2C1);
/* I2C DeInit */
I2C_DeInit(I2C1);
/* Enable the I2C peripheral */
I2C_Cmd(I2C1, ENABLE);
/* Set the I2C structure paramaeters */
I2C_InitStruct.I2C_Mode = I2C_Mode_I2C;
I2C_InitStruct.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStruct.I2C_OwnAddress1 = 0xFE;
I2C_InitStruct.I2C_Ack = I2C_Ack_Enable;
I2C_InitStruct.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStruct.I2C_ClockSpeed = 30000;
/* Initialize the I2C peripheral w/selected parameters */
I2C_Init(I2C1, &I2C_InitStruct);
}
/**
* @brief Configures the DCMI to interface with the OV9655 camera module.
* @param None
* @retval None
*/
void OV9655_DCMI_Configuration(void)
{
DCMI_InitTypeDef DCMI_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
/* Enable DCMI GPIOs clocks */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOE |
RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOA, ENABLE);
/* Enable DCMI clock */
RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_DCMI, ENABLE);
/* Connect DCMI pins to AF13 ************************************************/
/* PCLK */
GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_DCMI);
/* D0-D7 */
GPIO_PinAFConfig(GPIOC, GPIO_PinSource6, GPIO_AF_DCMI);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource7, GPIO_AF_DCMI);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource0, GPIO_AF_DCMI);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource1, GPIO_AF_DCMI);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource4, GPIO_AF_DCMI);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_DCMI);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource5, GPIO_AF_DCMI);
GPIO_PinAFConfig(GPIOE, GPIO_PinSource6, GPIO_AF_DCMI);
/* VSYNC */
GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_DCMI);
/* HSYNC */
GPIO_PinAFConfig(GPIOA, GPIO_PinSource4, GPIO_AF_DCMI);
/* DCMI GPIO configuration **************************************************/
/* D0 D1(PC6/7) */
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(GPIOC, &GPIO_InitStructure);
/* D2..D4(PE0/1/4) D6/D7(PE5/6) */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1
| GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6;
GPIO_Init(GPIOE, &GPIO_InitStructure);
/* D5(PB6), VSYNC(PB7) */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* PCLK(PA6) HSYNC(PA4)*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* DCMI configuration *******************************************************/
DCMI_InitStructure.DCMI_CaptureMode = DCMI_CaptureMode_Continuous;
DCMI_InitStructure.DCMI_SynchroMode = DCMI_SynchroMode_Hardware;
DCMI_InitStructure.DCMI_PCKPolarity = DCMI_PCKPolarity_Falling;
DCMI_InitStructure.DCMI_VSPolarity = DCMI_VSPolarity_High;
DCMI_InitStructure.DCMI_HSPolarity = DCMI_HSPolarity_High;
DCMI_InitStructure.DCMI_CaptureRate = DCMI_CaptureRate_All_Frame;
DCMI_InitStructure.DCMI_ExtendedDataMode = DCMI_ExtendedDataMode_8b;
DCMI_Init(&DCMI_InitStructure);
/* Configures the DMA2 to transfer Data from DCMI to the LCD ****************/
/* Enable DMA2 clock */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);
/* DMA2 Stream1 Configuration */
DMA_DeInit(DMA2_Stream1);
DMA_InitStructure.DMA_Channel = DMA_Channel_1;
DMA_InitStructure.DMA_PeripheralBaseAddr = DCMI_DR_ADDRESS;
DMA_InitStructure.DMA_Memory0BaseAddr = FSMC_LCD_ADDRESS;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
DMA_InitStructure.DMA_BufferSize = 1;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
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);
}
/**
* @brief Reset the OV9655 SCCB registers.
* @param None
* @retval None
*/
void DCMI_OV9655_Reset(void)
{
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM7, SCCB_REG_RESET);
}
/**
* @brief Configures the OV9655 to interface with the DCMI.
* @param None
* @retval None
*/
void DCMI_OV9655Configuration(void)
{
u16 j;
/* SysTick end of count event each 10ms */
RCC_GetClocksFreq(&RCC_Clocks);
SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);
for(j=0;j<60000;j++); // for(j=0;j<60000;j++);
#ifdef QQVGA_SIZE
/* Reset the OV9655 module */
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x12, 0x80);
/* OV9655 Camera size setup */
DCMI_OV9655_QQVGASizeSetup();
/* Set the RGB565 mode */
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM7, 0x63);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM15, 0x10);
/* Invert the HRef signal*/
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM10, 0x08);
#endif
#ifdef QVGA_SIZE
/* Reset the OV9655 module */
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x12, 0x80);
/* OV9655 Camera size setup */
DCMI_OV9655_QVGASizeSetup();
/* Set the RGB565 mode */
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM7, 0x63);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM15, 0x10);
/* Invert the HRef signal*/
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM10, 0x08);
#endif
}
/**
* @brief Set the QVGA size(240*320).
* @param None
* @retval None
*/
void DCMI_OV9655_QVGASizeSetup(void)
{
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x00, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x01, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x02, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x03, 0x02);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x04, 0x03);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x09, 0x01);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x0b, 0x57);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x0e, 0x61);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x0f, 0x40);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x11, 0x01);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x12, 0x62);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x13, 0xc7);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x14, 0x3a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x16, 0x24);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x17, 0x18);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x18, 0x04);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x19, 0x01);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x1a, 0x81);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x1e, 0x00); /*0x20*/
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x24, 0x3c);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x25, 0x36);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x26, 0x72);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x27, 0x08);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x28, 0x08);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x29, 0x15);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x2a, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x2b, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x2c, 0x08);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x32, 0x12);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x33, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x34, 0x3f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x35, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x36, 0x3a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x38, 0x72);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x39, 0x57);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x3a, 0x8c);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x3b, 0x04);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x3d, 0x99);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x3e, 0x02);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x3f, 0xc1);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x40, 0xc0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x41, 0x41);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x42, 0xc0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x43, 0x0a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x44, 0xf0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x45, 0x46);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x46, 0x62);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x47, 0x2a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x48, 0x3c);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x4a, 0xfc);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x4b, 0xfc);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x4c, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x4d, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x4e, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x4f, 0x98);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x50, 0x98);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x51, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x52, 0x28);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x53, 0x70);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x54, 0x98);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x58, 0x1a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x59, 0x85);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x5a, 0xa9);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x5b, 0x64);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x5c, 0x84);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x5d, 0x53);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x5e, 0x0e);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x5f, 0xf0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x60, 0xf0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x61, 0xf0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x62, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x63, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x64, 0x02);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x65, 0x20);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x66, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x69, 0x0a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x6b, 0x5a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x6c, 0x04);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x6d, 0x55);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x6e, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x6f, 0x9d);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x70, 0x21);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x71, 0x78);
Delay(TIMEOUT);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x72, 0x11);
Delay(TIMEOUT);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x73, 0x01);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x74, 0x10);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x75, 0x10);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x76, 0x01);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x77, 0x02);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x7A, 0x12);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x7B, 0x08);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x7C, 0x16);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x7D, 0x30);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x7E, 0x5e);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x7F, 0x72);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x80, 0x82);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x81, 0x8e);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x82, 0x9a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x83, 0xa4);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x84, 0xac);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x85, 0xb8);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x86, 0xc3);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x87, 0xd6);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x88, 0xe6);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x89, 0xf2);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x8a, 0x24);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x8c, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x90, 0x7d);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x91, 0x7b);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x9d, 0x02);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x9e, 0x02);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x9f, 0x7a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa0, 0x79);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa1, 0x40);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa4, 0x50);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa5, 0x68);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa6, 0x4a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa8, 0xc1);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa9, 0xef);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xaa, 0x92);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xab, 0x04);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xac, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xad, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xae, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xaf, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xb2, 0xf2);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xb3, 0x20);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xb4, 0x20);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xb5, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xb6, 0xaf);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xb6, 0xaf);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xbb, 0xae);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xbc, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xbd, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xbe, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xbf, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xbf, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc0, 0xaa);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc1, 0xc0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc2, 0x01);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc3, 0x4e);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc6, 0x05);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc7, 0x81);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc9, 0xe0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xca, 0xe8);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xcb, 0xf0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xcc, 0xd8);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xcd, 0x93);
Delay(TIMEOUT);
}
/**
* @brief Set the QQVGA size(120*160).
* @param None
* @retval None
*/
void DCMI_OV9655_QQVGASizeSetup(void)
{
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x00, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x01, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x02, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x03, 0x02);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x04, 0x03);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x09, 0x01);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x0b, 0x57);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x0e, 0x61);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x0f, 0x40);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x11, 0x01);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x12, 0x62);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x13, 0xc7);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x14, 0x3a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x16, 0x24);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x17, 0x18);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x18, 0x04);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x19, 0x01);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x1a, 0x81);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x1e, 0x20);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x24, 0x3c);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x25, 0x36);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x26, 0x72);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x27, 0x08);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x28, 0x08);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x29, 0x15);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x2a, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x2b, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x2c, 0x08);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x32, 0xa4);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x33, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x34, 0x3f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x35, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x36, 0x3a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x38, 0x72);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x39, 0x57);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x3a, 0x8c);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x3b, 0x04);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x3d, 0x99);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x3e, 0x0e);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x3f, 0xc1);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x40, 0xc0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x41, 0x41);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x42, 0xc0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x43, 0x0a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x44, 0xf0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x45, 0x46);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x46, 0x62);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x47, 0x2a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x48, 0x3c);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x4a, 0xfc);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x4b, 0xfc);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x4c, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x4d, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x4e, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x4f, 0x98);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x50, 0x98);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x51, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x52, 0x28);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x53, 0x70);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x54, 0x98);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x58, 0x1a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x59, 0x85);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x5a, 0xa9);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x5b, 0x64);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x5c, 0x84);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x5d, 0x53);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x5e, 0x0e);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x5f, 0xf0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x60, 0xf0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x61, 0xf0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x62, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x63, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x64, 0x02);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x65, 0x20);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x66, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x69, 0x0a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x6b, 0x5a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x6c, 0x04);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x6d, 0x55);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x6e, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x6f, 0x9d);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x70, 0x21);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x71, 0x78);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x72, 0x22);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x73, 0x02);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x74, 0x10);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x75, 0x10);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x76, 0x01);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x77, 0x02);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x7A, 0x12);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x7B, 0x08);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x7C, 0x16);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x7D, 0x30);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x7E, 0x5e);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x7F, 0x72);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x80, 0x82);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x81, 0x8e);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x82, 0x9a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x83, 0xa4);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x84, 0xac);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x85, 0xb8);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x86, 0xc3);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x87, 0xd6);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x88, 0xe6);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x89, 0xf2);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x8a, 0x24);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x8c, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x90, 0x7d);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x91, 0x7b);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x9d, 0x02);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x9e, 0x02);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0x9f, 0x7a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa0, 0x79);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa1, 0x40);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa4, 0x50);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa5, 0x68);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa6, 0x4a);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa8, 0xc1);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xa9, 0xef);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xaa, 0x92);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xab, 0x04);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xac, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xad, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xae, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xaf, 0x80);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xb2, 0xf2);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xb3, 0x20);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xb4, 0x20);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xb5, 0x00);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xb6, 0xaf);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xb6, 0xaf);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xbb, 0xae);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xbc, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xbd, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xbe, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xbf, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xbf, 0x7f);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc0, 0xaa);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc1, 0xc0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc2, 0x01);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc3, 0x4e);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc6, 0x05);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc7, 0x82);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xc9, 0xe0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xca, 0xe8);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xcb, 0xf0);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xcc, 0xd8);
Delay(TIMEOUT);
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS,0xcd, 0x93);
Delay(TIMEOUT);
}
/**
* @brief Read the OV9655 Manufacturer identifier.
* @param OV9655ID: pointer to the OV9655 Manufacturer identifier.
* @retval None
*/
void DCMI_OV9655_ReadID(OV9655_IDTypeDef* OV9655ID)
{
OV9655ID->Manufacturer_ID1 = DCMI_SingleRandomRead(OV9655_DEVICE_WRITE_ADDRESS, OV9655_MIDH);
OV9655ID->Manufacturer_ID2 = DCMI_SingleRandomRead(OV9655_DEVICE_WRITE_ADDRESS, OV9655_MIDL);
OV9655ID->Version = DCMI_SingleRandomRead(OV9655_DEVICE_WRITE_ADDRESS, OV9655_VER);
OV9655ID->PID = DCMI_SingleRandomRead(OV9655_DEVICE_WRITE_ADDRESS, OV9655_PID);
}
/**
* @brief Set the Internal Clock Prescaler.
* @param OV9655_Prescaler: the new value of the prescaler.
* This parameter can be a value between 0x0 and 0x1F
* @retval None
*/
void DCMI_OV9655_SetPrescaler(uint8_t OV9655_Prescaler)
{
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_CLKRC, OV9655_Prescaler);
}
/**
* @brief Select the Output Format.
* @param OV9655_OuputFormat: the Format of the ouput Data.
* This parameter can be a value between 0x0 and 0x1F
* @arg OUTPUT_FORMAT_RAWRGB_DATA
* @arg OUTPUT_FORMAT_RAWRGB_INTERP
* @arg OUTPUT_FORMAT_YUV
* @arg OUTPUT_FORMAT_RGB
* @retval None
*/
void DCMI_OV9655_SelectOutputFormat(uint8_t OV9655_OuputFormat)
{
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM7, OV9655_OuputFormat);
}
/**
* @brief Select the Output Format Resolution.
* @param OV9655_FormatResolution: the Resolution of the ouput Data.
* This parameter can FORMAT_CTRL_15fpsVGA a value between 0x0 and 0x1F
* @arg FORMAT_CTRL_15fpsVGA
* @arg FORMAT_CTRL_30fpsVGA_NoVArioPixel
* @arg FORMAT_CTRL_30fpsVGA_VArioPixel
* @retval None
*/
void DCMI_OV9655_SelectFormatResolution(uint8_t OV9655_FormatResolution)
{
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM7, OV9655_FormatResolution);
}
/**
* @brief Set the new value of OV9655 registers
* @param OV9655_Register: the OV9655 Register to be configured.
* @param Register_Val: The new value to be set
* @retval None
*/
void DCMI_OV9655_SetRegister(uint8_t OV9655_Register, uint8_t Register_Val)
{
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_Register, Register_Val);
}
/**
* @brief Select the HREF Control signal option
* @param OV9665_HREFControl: the HREF Control signal option.
* This parameter can FORMAT_CTRL_15fpsVGA a value between 0x0 and 0x1F
* @arg OV9665_HREFControl_Opt1: HREF edge offset to data output.
* @arg OV9665_HREFControl_Opt2: HREF end 3 LSB
* @arg OV9665_HREFControl_Opt3: HREF start 3 LSB
* @retval None
*/
void DCMI_OV9655_HREFControl(uint8_t OV9665_HREFControl)
{
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_HREF, OV9665_HREFControl);
}
/**
* @brief Select the RGB format option
* @param OV9665_RGBOption: the RGB Format option.
* This parameter can FORMAT_CTRL_15fpsVGA a value between 0x0 and 0x1F
* @arg RGB_NORMAL
* @arg RGB_565
* @arg RGB_555
* @retval None
*/
void DCMI_OV9655_SelectRGBOption(uint8_t OV9665_RGBOption)
{
DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OV9655_COM15, OV9665_RGBOption);
}
/**
* @brief Writes a byte at a specific Camera register
* @param Device: OV9655 write address.
* @param Addr: OV9655 register address.
* @param Data: data to be written to the specific register
* @retval None
*/
uint8_t DCMI_SingleRandomWrite(uint8_t Device, uint16_t Addr, uint8_t Data)
{
uint32_t timeout = DCMI_TIMEOUT_MAX;
/* Generate the Start Condition */
I2C_GenerateSTART(I2C1, ENABLE);
/* Test on I2C1 EV5 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Send DCMI selcted device slave Address for write */
I2C_Send7bitAddress(I2C1, Device, I2C_Direction_Transmitter);
/* Test on I2C1 EV6 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Send I2C1 location address LSB */
I2C_SendData(I2C1, (uint8_t)(Addr));
/* Test on I2C1 EV8 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
STM_EVAL_LEDOn(LED3);
}
/* Send Data */
I2C_SendData(I2C1, Data);
/* Test on I2C1 EV8 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Send I2C1 STOP Condition */
I2C_GenerateSTOP(I2C1, ENABLE);
/* If operation is OK, return 0 */
return 0;
}
/**
* @brief Reads a byte from a specific Camera register
* @param Device: OV9655 write address.
* @param Addr: OV9655 register address.
* @retval data read from the specific register
*/
uint8_t DCMI_SingleRandomRead(uint8_t Device, uint16_t Addr)
{
uint8_t Data = 0;
/* Generate the Start Condition */
I2C_GenerateSTART(I2C1, ENABLE);
/* Test on I2C1 EV5 and clear it */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT));
/* Send DCMI selcted device slave Address for write */
I2C_Send7bitAddress(I2C1, Device, I2C_Direction_Transmitter);
/* Test on I2C1 EV6 and clear it */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
/* Send I2C1 location address LSB */
I2C_SendData(I2C1, (uint8_t)(Addr));
/* Test on I2C1 EV8 and clear it */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
/* Clear AF flag if arised */
I2C1->SR1 |= (uint16_t)0x0400;
/* Generate the Start Condition */
I2C_GenerateSTART(I2C1, ENABLE);
/* Test on I2C1 EV6 and clear it */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT));
/* Send DCMI selcted device slave Address for write */
I2C_Send7bitAddress(I2C1, Device, I2C_Direction_Receiver);
/* Test on I2C1 EV6 and clear it */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
/* Prepare an NACK for the next data received */
I2C_AcknowledgeConfig(I2C1, DISABLE);
/* Test on I2C1 EV7 and clear it */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED));
/* Prepare Stop after receiving data */
I2C_GenerateSTOP(I2C1, ENABLE);
/* Receive the Data */
Data = I2C_ReceiveData(I2C1);
/* return the read data */
return Data;
}
/**
* @}
*/
/******************* (C) COPYRIGHT 2010 STMicroelectronics *****END OF FILE****/
Ne varsa I2C kodlarımda var. Oldum olalı bu I2C de sorun yaşadım. Özellikle STnin kütüphanesinde. STM32F10x de de lov level I2C rutinlerini kullanıyordum. Hiç problem yaşamadım şimdiye kadar. Bizdemi problem var anlayamadım.
I2C hattını lojik analyser ile takip ediyorum sonuç aşağıdaki gibi.
(http://s29.postimg.cc/5erqamezr/screenshot.png) (http://postimg.cc/image/wclncczmr/full/)
birşeyler oluyor fakat devamı gelmiyor.
örneğin yukarıdaki programda I2C rutinleri böyle,
/**
* @brief Writes a byte at a specific Camera register
* @param Device: OV9655 write address.
* @param Addr: OV9655 register address.
* @param Data: data to be written to the specific register
* @retval None
*/
uint8_t DCMI_SingleRandomWrite(uint8_t Device, uint16_t Addr, uint8_t Data)
{
uint32_t timeout = DCMI_TIMEOUT_MAX;
/* Generate the Start Condition */
I2C_GenerateSTART(I2C1, ENABLE);
/* Test on I2C1 EV5 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Send DCMI selcted device slave Address for write */
I2C_Send7bitAddress(I2C1, Device, I2C_Direction_Transmitter);
/* Test on I2C1 EV6 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Send I2C1 location address LSB */
I2C_SendData(I2C1, (uint8_t)(Addr));
/* Test on I2C1 EV8 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Send Data */
I2C_SendData(I2C1, Data);
/* Test on I2C1 EV8 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Send I2C1 STOP Condition */
I2C_GenerateSTOP(I2C1, ENABLE);
/* If operation is OK, return 0 */
return 0;
}
Burada I2C_SendData(I2C1, (uint8_t)(Addr)); komutundan sonra program while içerisine giriyor ve cevap gelmediği için timeout süresi dolup fonksiyondan çıkılıyor.
Bunu araştırıyorum. Sizce ne olabilir? I2C kodlarındamı problem var yoksa kameradamı?
Mucit23 benzer problemi bende NXP CMSIS kodlarında yaşamıştım i2c benzer bir while döngüsünde takılı kalıyordu. Buradaki timeout değerini kısaltıp sorundan kurtulmuş sağlıklı bir iletişim kurmuştum. Clock sinyaline bakarsak donanımsal değilde yazılımsal problem var gibi duruyor. ACK biti beklemeyip doğrudan adres ve dataları göndermeyi/okumayı dener misin?
Lojik analizörde sürekli olarak clock sinyali görmen lazım.
Hemen Deneyeyim.
---
Denedim,
Time out süresini çok kısaltınca direk fonksiyondan çıkılıyor. Lojik analyser'da gördüğüm tek şey start biti. Bekleme işlemlerini komple kaldırınca program takılıp kalıyor. Lojik analyserda sadece start ve stop biti görüyorum.
if ((timeout--) == 0) return 0xFF;
satırını tamamen kapatıp dener misin birde. Sonuca ulaştırmayabilir ama ben NXP böyle bişeyle halletmiştim.
Yok yok bu başka yerlere gidiyormuş. O takıldığı yerden kurtarıp devam etmesini sağlarsan belki bişey çıkabilir. while ı kapat.
Hocam sadece dediğiniz satırı kapatsam program sürekli while içerisinde takıldığı için fonkisyondan çıkarmıyor. Bütün While'leri kapatsam yine program fonksiyondan çıkamıyor fakat bu sefer nerede takılıyor bilmiyorum. Büyük ihtimal I2C_SendData içerisinde takılıyor.
Bildiğiniz başka I2C kütüphanesi varmı? Low level felan farketmez benim için. Yani ST kütüphanesi kullanılmasada olur. Ben ciddi ciddi I2C kütüphanesinde problem olduğunu düşünüyorum. STM32F10x de de çünkü aynı problemleri yaşamıştım.
Sayfanın altında http://www.expkits.com/?s=ex33ds.htm (http://www.expkits.com/?s=ex33ds.htm)
Stm32f107 için olan örnek dosyasını indirin içerisinde eeprom örneğini inceleyin. Low level i2c var içerisinde.
Evet hocam 10x için low level rutinleri bende var. Acaba 4x ilede çalışırmı? Registerler aynımıdır.
Konu başlığı f10 olunca kafam oraya gitti. Emin değilim bir takım farklılıklar olabilir.
Anladım hocam,
Bari eeprom devresi kurup onun üzerinde i2c donanımını test edeyim.
Anlam veremiyorum. Send7Bit_Adress fonkdiyonundan sonra program while içerisinde takılıp kalıyor. Bu kameranın çalışmadığı anlamınamı gelir? Yani sanki i2cde birşeyler gönderiyor sonra alındımı alınmadımı bunun cevabı için bekliyor. Cevap gelmeyince takılıp kalıyor... Birçok I2C rutini inceledim mantık olarak hep aynı. Başkada aklıma gelen birşey yok. :'(
Örnek ararken aynı fonksiyonla başkalarınında problem yaşadığını gördüm(detaylı bakmadım sadece başlıkları benzerdi) muhtemelen çözüm oralarda biyerdedir.
Modül arızalı olma ihtimali var mı? I2C donanımı adresi gönderip ACK-NACK bekliyor olabilir NACK cevabı gelince muhtemelen boşuna çalışmayalım deyip kapatıyor.
keil stm32 i2c example
keil stm32f1 i2c example
keil stm32f4 i2c example
stm32f4 i2c lib
gibi aramalar yapmışım.
Hocam modülün arızalı olduğunu düşünmüyorum çünkü aldığımdan beri ilk defa kullanıyorum. Bozuk ürün gelmediyse sağlam olması gerek..
Yarın akşama kadar araştırma yapayım. Umarım çözüm bulabilirim.
Bu I2C beni çıldırtacak. Eepromla denedim ondada benzer problemlerle karşılaşıyorum. Hep While içerisinde tıkanıp kalıyor program.... Problemin çözümüne dair her türlü görüş ve önerileri deneyebilirim.. Kamerayı geçtim, I2C yi çalıştırmak ilk hedefim.. Yardıma ihtiyacım var.
ZIOS ile e2rom calismasini bir dene.
Hocam ziosu birazdan deneyeceğim. Ama ilk önce şu soruyu cevaplamam gerekiyor.
Resimden bakalım.
(http://s15.postimg.cc/4sgfyremz/Ekran_Al_nt_s.jpg) (http://postimg.cc/image/tyhe5lfx3/full/)
resim yükle (http://postimg.cc/index.php?lang=turkish)
Kameraya I2C_Send7bitAddress fonksiyonuyla 0xAA değerini gönderdim. Hattı lojik anayser ile izliyorum. Sonuç yukarıdaki gibi
Gönderdiğim adres datasını gördüm. Fakat başında ve sonunda anlam veremediğim hareketlilikler görülüyor. Özellikle Adresin başında oluşan şey nedir? En baştaki bir anlık low olma start biti olsa diğerleri neler? Adresin sonunda neden 1 adet fazla clock sinyali var? Birde biz 7 bit adres gönderiyoruz ama hatta gönderdiğim 8 bitlik datanın 8'ini birden görüyorum. Bu yanlış değilmi.
Belkide kamera bunlara anlam veremiyor? Tamam start biti geliyor. Sonra bir şekilde adreste yollanıyor ama kamera gönderilen adres bilgisini anlamadığı için ack yollamıyor. Sonra program while içerisinde ACK beklesin. Ben böyle yorumluyorum...
1 bit de R/W sinyali var. Ondan dolayi 8 ediyor.
ADRES+R/W biti göndermen lazım. Yani sen kameraya onu okumak veya yazmak istediğini söylemiyor musun?
i2c 8 bit olarak veri aktarır. 7 bit adres + 1 bit Okuma/yazma bildirici.
8 clock darbesinden sonra 9. clockta data hattında ACK belirmesi lazım yani low olması gerekiyor ama kamera cevap vermemiş.
İlk baştaki kısa süreli low high nedir bilmiyorum ama hemen sonra gelen Data hattı 0 iken clock hattının 1 olması start anlamına geliyor. Start biti yani. Tam terside olabilir. İletişimin başladığı yer en soldaki dikey kırmızı çizginin olduğu yer.
Sondaki ACK ama baştakine bende anlam veremiyorum..
Hiç software i2c ile denemeler yaptınızmı? nette kütüphaneler vardır diye tahmin ediyorum ve bu öneriyi kamera ile bir an önce konuşabilmeniz için tavsiye ediyorum. Öncelikle bir kameradan bilgiler gelsin, sonra donanımsal i2c ye geçersiniz.
Evet bende onu söylüyorum işte. Benim Bildiğim Adres+RW toplam 8 bit etmesi gerekir. Bunda sıkıntı yok galiba. Çünkü gönderdiğim data 0XAA(10101010) olduğu için 0. bit zaten lojik sıfır. Ben Transmitter modunda data gönderdiğim için 0. bit otomatikmen 0 olması gerekiyor. Doğrulamak için adres gönderme işlemin Reciever modunda yaptım sonuç aşağıdaki gibi.
(http://s4.postimg.cc/y4f191rkt/Ekran_Al_nt_s.jpg) (http://postimg.cc/)
gif upload (http://postimg.cc/index.php?lang=turkish)
Dikkat ederseniz 0. bit lojik bir oldu. Yani adreste sıkıntı yok. Benim çözemediğim konu en baştaki kısa süreli lojik sıfır sinyali, Bu hiçbir kitaba kurala uymuyor. Sanırım kamera bunu bir sinyal olarak algılayıp sonrasında şaşırıyor...
Birde hattın uzaktan görünüşüne bakın.
(http://s21.postimg.cc/k4h4b5vtj/Ekran_Al_nt_s.jpg) (http://postimg.cc/)
gif upload (http://postimg.cc/index.php?lang=turkish)
Kırmızı ile işaretlediğim noktalar hareketliliğin olduğu yerler. En son neden SCL hattı lojik sıfırda kalıp belli bir süre sonra lojik bir oluyor onuda anlayamadım.
Bence en baştaki kısa süreli lojik sıfır sinyalden kurtulursam kameradan ack alabilirim. Bunun sebebi ne olabilir. Start vermeden önce başka birşeymi yapmam gerekiyor?
@Ramiz onuda düşünmüyor değilim. Herhalde en sonunda öyle yapacam. Kayışın atmasını bekliyorum.
@Mucit peki eeprom denemelerinde de aynı paraziti alıyor musun?(en baştaki iniş çıkışları kastediyorum) Bir de işin ilginç yanı, dikkat edilirse her veri gönderme gerçekleştiğinde tekrarlayan bir periyodu var..
Ekleme:Mucit sen o sinyali gördüğünde fonksiyona tekrar girmiş mi oluyor?Çünkü bu durum pic ile olan maceralarımdan hatırladığım kadarıyla restart condution durumunda oluyordu.Tam olarak restart con olmayabilir fakat senaryo şöyle;
i2cstart,i2cwrite,i2cstop,i2cstart,x byte i2cread,i2cstop.
Bu cycle içinde o sinyali sürekli gördüğümü hatırlıyorum.
Hocam Aynı kodu eepromda deniyorum hiç çalışmıyor. Sadece Start biti görüyorum.
Bu durumdayken sizce Start bitine kamera ACK gönderiyormu?
2 saykıllık bir resim ekleyebilir misin? En az 2 yazma saykılı olsun.Hatta uzaklaştırıp 3 4 tane göster.Bir de 2 adet için yakınlaşarak göster, bir resim de sadece birini ele alalım.Bu arada hard i2c değilmi?
kodlarında yalnızca şunları yapsın;
while(1){
i2c start,i2cwrite(adres),i2cstop.
i2cstart,
if(ack geldiyse)
x byte i2cread
else
i2cwrite(adres)
i2cstop
delay_ms(100)
}
Hocam tezgahı topladım. Artık Yarın deneyip sonucu yazayım.
Hocam şimdiye kadar hep donanımsal i2c kullandım. Sizin verdiğiniz kodları deneyemiyorum yalnız. Çünkü kameradan ACK gelmediği için donup kalıyor. Benim Soft I2C kullanmam lazım. Burada bir örnek buldum.
https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Flat.aspx?RootFolder=%2Fpublic%2FSTe2ecommunities%2Fmcu%2FLists%2Fcortex_mx_stm32%2Fsoftware%20i2c%20not%20working&FolderCTID=0x01200200770978C69A1141439FE559EB459D7580009C4E14902C3CDE46A77F0FFD06506F5B¤tviews=1432
STM32'deki GPIO_IDR hakkında sormak istediğim bir konu var.
Ben kullandığım pinleri open drain olarak ayarladım. Bu durumdayken GPIO_IDR den pinin konumunu okuyabilirmiyim. (Giriş yapmadan) Linkteki örnekte öyle yapmış görünüyor.
Bilgisayarınızda mikroc for arm var ise, soft i2c yi in temiz bir şekilde deneyebilirsiniz. Yok ise, size tavsiyem indirip, deneyin. Open source librarylerdede sorun yaşamanız yüksek bir olasılık. Cam i çalıştırdıktan sonra keil a geri dönersiniz.
@Ramiz yok sanmıyorum. Ben şuanda Soft I2C yi denedim. Aynı sonucu aldım. Mikroc'de de farklı bir sonuç alacağımı sanmıyorum.
Ben yine Keildeki problemi çözmem lazım.
Bi arkadaşımda OV7670 modülü vardı. Onunda deneme yapmayı düşünüyorum. Birde şimdilik farklı I2C modüllerini deneyelim. Hep I2C1 ile çalışıyordum. I2C2 veya I2C3 ile denemek lazım.
mikroc yi önermemin nedeni, içersindeki soft i2c library si idi. Netten bulduğunuz i2c library si ilede sorun yaşamanız yüksekti. Bunu sorunlarınları minimuma indirip, cam ile iletişimi başarın diye önermiştim..
MikroC deki Soft I2C kodlarını alıp keilde kullanabilirmiyim?
Oturdum philips'in I2C Manualini alıp soft I2C kütüphanemi düzenledim. Şimdi DS1307 ile denemeler yaptım. Kendi Device Adresine ACK gönderiyor. Benim kamera Start bitinden sonra kendi device adresine ACK göndermiyor. Kamera bozuk çıktı herhalde. Birde OV7670 ile denemeler yapacağım..
Alıntı yapılan: Mucit23 - 01 Mart 2014, 23:18:05
MikroC deki Soft I2C kodlarını alıp keilde kullanabilirmiyim?
Hayır kullanamazsınız. MikroC kütüphaneleri kapalıdır.
Kamera modülünüzün bozuk olacağını sanmıyorum. Tabiki bağlantıları düzgün yapıp, sadece i2c hattı ile çalıştıysanız. Bence direnmeyin ya mikroc kütüphanelerini kullanın, yada pic e geçip, öncelikle bir şu modülü çalıştırın ve çalıştığından kesin emin olun, sonra yine keil a ve stm e geri dönersiniz.
İyi çalışmalar.
Bir zamanlar kamera ile calismistim ama devami gelmedi.
Reset sinyali varsa bunu bir de tersine cevir. Boyle bir sorun yasadim diye hatirliyorum.
Hocam Reset pini varama sürekli lojik 1 konumunda. Birde PowerDown var oda sürekli enable konumunda. Bunların bağlantıları kamera üzerindeki Header'e çıkartılmış ama aktif değil. Bağlantılar kamera üzerindeki jumperlerla sabit olarak ayarlanmış. Hiç oynamadım ben.
Kullandığım kamera budur.
http://www.ebay.com/itm/OV9655-Camera-Board-CMOS-SXGA-1-3-MegaPixel-CameraChip-Module-Development-Kit-/251194076066?pt=LH_DefaultDomain_0&hash=item3a7c556ba2 (http://www.ebay.com/itm/OV9655-Camera-Board-CMOS-SXGA-1-3-MegaPixel-CameraChip-Module-Development-Kit-/251194076066?pt=LH_DefaultDomain_0&hash=item3a7c556ba2)
Buradan almıştım.
Stm32'nin donanımsal I2C ayarları yapılırken(GPIO ve I2C) GPIO pinleri Bir anlık lojik 0 olup tekrar lojik 1'e yükseliyor. Sonra start, adres... vs başlıyor.
Ben diyorumki kamera I2C init edilirken hatta oluşan hareketlilikleri start olarak algılıyor. Acaba Kamerayı tekrar sıfırlamak için Start bitinden önce Stop bitimi göndereyim. Kendini resetlesin.
Yada Kameranın Reset pinini dışarı çıkartıp I2C hattı stabil konuma gelene kadar kamerayı resette tutayım. Bunları bi denemek lazım.
@Ramiz dediğin gibi Kameranın bozuk olduğuna hiç inanasım gelmiyor. Birde pic ve CCS ile deneme yapayım. Sadece I2C ve Besleme bağlantılarını yapıp init etmeye çalışayım bakalım ne olacak.
MikroC ile daha önce hiç kod yazmadım. Kütüphanelerinin kapalı olması beni gıcık ediyor.
Bu kameraları çalıştırmak için doğa üstü bir güce sahip olmak gerekiyor herhalde. Şimdiye kadar hiç birşey beni bukadar uğraştırmamıştı. Şimdi OV7670 ile denemeler yapıyorum. Aldığım sonuçlar OV9655 ile tamamen aynı. Bu kamerada Kendi Device Adresine ACK göndermiyor. Elimde lojik analyser hattı adım adım takip ediyorum. Yani Start, device adres, ACK bekleme vs hepsi gerçekleşiyor.
İki adet kamera ile denedim. İkisinide çinden almıştık. İkiside aynı anda arızalı olmaz herhalde. Ya ben I2C protokolünü bilmiyorum yada bu kameralar şimdiye kadar keşfedilmemiş kendilerine has bir protokolle haberleşiyorlar.
Artık en dip seviyeye ineceğim. Hiçbir döngü felan kullanmadan alt alta yazarak yani 1-0-1-0-1-0 vererek Start, Adres yollama ve ACK bekleme işlemlerini yapacağım.
Ciddi Ciddi ben bunların I2C ile haberleştiklerinden emin değilim. Birisi beni kekliyor olabilir.
Datasheete bakın, http://www.surveyor.com/blackfin/OV9655-datasheet.pdf (http://www.surveyor.com/blackfin/OV9655-datasheet.pdf)
SCCB interface (Serial Camera Control Bus)yazıyor. Bu farklı bir protokolmü?
Denemediğim yöntem kalmadı gibi yinede başka fikri olan varsa söylesin, Hemen deneyebilirim.
I couldn't get my STM32 microcontroller's I2C module to work with the OV7670's SCCB interface, so I implemented a bit bang version of the SCCB specification. This implementation is my peripheral library libstm32pp.
After making sure the SCCB is working, we can tweak the OV7670.
http://embeddedprogrammer.blogspot.com.tr/2012/07/hacking-ov7670-camera-module-sccb-cheat.html (http://embeddedprogrammer.blogspot.com.tr/2012/07/hacking-ov7670-camera-module-sccb-cheat.html)
@Leblebitozu teşekkürler,
Keşke bunu başta bileydim. Çalıştırmak için bu kadar uğraşmazdım.
Ama internetteki örnek uygulamalara bakıyorum. Hep donanımsal I2C kullanılmış. SCCB ile I2C arasındaki ark nedir. Çok merak ediyorum doğrusu. Büyük farklar olmaması gerek.
Kamerayı üreten firma kendi oluşturdukları protokol için user manual vermişler. Buna bakıyorum.
http://www.ovt.com/download_document.php?type=document&DID=63 (http://www.ovt.com/download_document.php?type=document&DID=63)
http://yadi.sk/d/zYw2edg0JtURu (http://yadi.sk/d/zYw2edg0JtURu)
Buradaki kodlarda hard i2c mi kullanılıyor.Bana mı öyle geliyor?
Hocam bende de birçok kod var. Birçoğunda hard i2c kullanılıyor. İşte anlamadığım olayda bu. Madem SCCB ile I2C arasında farklılıklar var nasıl oluyor hard I2C kullanıyorlar.
Gerçi aradaki farkı bilmeden bu soruyu sormak uygun olmaz. Ben yarın bunu araştıracağım.
Belkide bu fark yüzünden kameradan cevap alamıyorum. Çünkü Philips in manual'ine bakarak yazdığım low level I2C kodları Ds1307 ile çalışıyor. Yani çalışıyor dediğim kendi device adresine ack gönderiyor. Dolayısıyla yazdığım kodların I2C ye uyduğundan eminim. Arada mutlaka fark olmalı. Yoksa çalışması gerek
Buradaki adamda benim gibi dert yakınıyor.
http://thecodeartist.blogspot.com.tr/2012/04/omnivison-ov3640-i2c-sccb.html (http://thecodeartist.blogspot.com.tr/2012/04/omnivison-ov3640-i2c-sccb.html)
Son kısımları okumanızı tavsiye ederim.
http://www.rpg.fi/desaster/blog/2012/05/07/ov7670-camera-sensor-success/ (http://www.rpg.fi/desaster/blog/2012/05/07/ov7670-camera-sensor-success/)
Şurada bir yazı okudum. Kameranın XCLK girişinden 10Mhz sinyal uyguluyor.
İncelediğim hiçbir uygulamada böyle birşey görmemiştim. Kamera içerisindeki DSP nin kendi osilatörü yokmu yani? Ben dışarıdan clock uygulamasam çalışmayacakmı?
O linkteki kamera jpg çıkışlı kamera. Yani doğrudan pinlerden jpg görüntü alıyorsunuz.
Kamera alırken aslında fifolu almak daha mantıklı yada kamerayla birlikte harici fifo almak.
Hocam fifonun amacı farklı. Daha öncede söyledim ben dcmi kullanacağım için fifoya ihtiyacım yok.
Elimde hem ov9655 hemde ov7670 var. İkiside yazılımla jpeg formatında çıkıi verecek şekilde ayarlanabiliyor.
OV7670 linktekinin aynısı. Zaten piyasada fazla modül çeşitliliği yok. Ama genelde ov7670 kullanıldığı için OV9655 i şimdilik kenera bıraktım. I2C ile iletişim kurana kadarda bakmam.
Yarın XCLK için kameradan discoveriye hat çekeyim. Sonra PWM ile 10Mhz sinyal uygulayacam. Bakalım ne olacak..
Saat'te ikiye geliyor.
Arkadaşlar merhaba;
bende şu anda stm32f4 discovery ve ssd1963 bağlantısına ov7670 bağladım qcif olarak ekrana görüntü aktarmaya çalışıyorum.
lcd üzerine ayarladığım pencerede sadece karıncalı karışık görüntüler oluşuyor ışık tuttuğunda yada nesne hareketi yaptığımda ekrandaki görüntüde değişiyor ama hala net görüntü alamadım.
elinizde şuanda ov7670için çalışan kodunuz mevcutmu. günlerdir denemediğim kalmadı sizin kodlarınızla karşılaştırmak isterim
Hocam elimde birçok kütüphane var. Ama henüz kamera ile iletişime geçemediğim için çalışıp çalışmadığını bilmiyorum. Bu akşam XCLK bağlantısını yapıp I2C çalışmalarına kaldığım yerden devam edeceğim.
Karıncalıda olsa görüntü aldığınıza göre kamera ile iletişim sağlamışsınız.
XCLK konusunu sorayım. Sizin kullandığınız kameranın kendi osilatörü varmı yoksa kendiniz mi kameraya clock uyguluyorsunuz?
Birde DCMI kullandınızmı?
DCMI kullanıyorum
elimde wvsahre'in genişleme kartı var discoveryi bunun üzerine takıyorum. http://www.wvshare.com/product/Open407V-D-Standard.htm (http://www.wvshare.com/product/Open407V-D-Standard.htm)
xclock için gpio üzerinden 50mhz clock veriyorum ve o şekilde kullanıyorum
lcd üzerinde frame olarak da176X144 bir pencere açıyorum ve dma ile veriyi direk ssd1963 ramie gonderiyorum
ama sadece çapraz çapraz hareketli çizgiler çıkıyor ışık yada farklı renkde nesnelerin önüne tutuğum zaman çizgilerin rengi değişiyor
Hocam 50mhz Çok değilmi. Bildiğim kadarıyla 24 mhz uygulanması gerekiyor. Hatta bazı ov7670 modullerinde dahili olarak 24 mhz osilator bulunuyor.
Bence hızı biraz düşürüp deneyin.
Umarım bende sizinki kadar ilerleme kaydedebilirim.
orada aslında şöyle bir kod kullanmışım
sanırm 48mhz veriyorum datasheetden inceleyip yeniden yazacağım
static ErrorStatus OV7670_XCLK_Conf(void)
{
__IO uint32_t startupcounter = 0;
ErrorStatus status = ERROR;
FlagStatus HSI_Status = RESET;
GPIO_InitTypeDef GPIO_InitStructure;
// Enable high speed internal 16MHz oscillator *******************************
RCC_HSICmd(ENABLE);
// Wait till HSI is ready and if Time out is reached exit
do
{
HSI_Status = RCC_GetFlagStatus(RCC_FLAG_HSIRDY);
startupcounter++;
}while((startupcounter != HSI_STARTUP_TIMEOUT) && (HSI_Status == RESET));
if (RCC_GetFlagStatus(RCC_FLAG_HSIRDY) != RESET)
{
status = SUCCESS;
}
else
{
status = ERROR;
}
// Output HSI clock on MCO1 pin(PA8) ****************************************
// Enable the GPIOA peripheral
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
// Connect MCO1 pin to AF0
// Connect to AF0 is default after reset
// GPIO_PinAFConfig(GPIOA, GPIO_PinSource8, GPIO_AF_MCO);
// Configure MCO1 pin(PA8) in alternate function
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);
// HSI clock selected to output on MCO1 pin(PA8)
RCC_MCO1Config(RCC_MCO1Source_HSI, RCC_MCO1Div_1);
return(status);
}
void XCLK_ON(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
// Output HSI clock on MCO1 pin(PA8) ****************************************/
// Enable the GPIOA peripheral
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
// Connect MCO1 pin to AF0
// Connect to AF0 is default after reset
// GPIO_PinAFConfig(GPIOA, GPIO_PinSource8, GPIO_AF_MCO);
// Configure MCO1 pin(PA8) in alternate function
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
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);
// HSI clock selected to output on MCO1 pin(PA8)
RCC_MCO1Config(RCC_MCO1Source_HSI, RCC_MCO1Div_1);
mesaj birleştirme:: 07 Mart 2014, 13:52:36
dahasheetden incelediğim kadarı ile
HSI clocku div 1 ile gönderiyorum yani 16MHZ gidiyor
aksam osiloskop ile ölçer yeniden bakarım
ama bu durumda acaba benim sorunum nerede :(
sanırım registerleri hatalı ayarladım hepsinin üzerinden bir kere daha geçmem gerekli
Bu kamera ile başım dertte.
XCLK uygulamaya başladım. Şimdilikte Frekansı düşük tutum. 8Mhz deniyorum. Kameradan yine I2C cevabı gelmiyor. Ama PXCLK sinyalinden 4Mhz lik bir sinyal çıkıyor. Ayrıca HSYNC ucundanda bir yaklaşık1,5Khz bir sinyal çıkıyor.
Hattaki durum bu şekilde
(http://s21.postimg.cc/9vj6i3w4n/Ekran_Al_nt_s.jpg) (http://postimg.cc/image/3ulhl19ib/full/)
resim yükle (http://postimg.cc/index.php?lang=turkish)
Resim üzerinde I2C hattınında oluşan olayları yazdım. Mavi Kısımda ACK bekleniyor. ACK geleceği sırada Clock Uygulandığında Hata low konumuna inse tamam ilerleyebileceğim.
Şuanda en düşük seviyede I2C kodu yazıyorum. Donanımsal I2C kullansamda değişen birşey olmayacak. ACK gelmediği için Program donacak.
Gerçekten yardıma ihtiyacım var. Başka ne yapabilirim fikri olan varmı?
Clock sinyalini neden durduruyorsun?
Sürekli clock sinyali gönderilsin sürekli device adresi yazılsın. İletişimi durdurma clock yoksa ACK'da gelmez.
@Mucit i2c kodların soft i2c ise yanlış ypıyorsun.Değilse sebebine odaklanmalısın.!
Çünkü i2c de data değişimi clokc lowda iken izin verilir.!Senin sinyalinde gözüktüğü kadarıyla sen clock ile birlikte data değiştirmeye kalkıyorsun.Bu da hatalı data alımına sebep oluyor olabilir.
Ayrıca halen anlamış değilim.Sana gönderdiğim kodlar bizzat denediğim çalıştırdığım kodlardı.Hatta o kodlar ile sd karta resimi de bmp olarak yazıyordu.Sende neden çalışmadı?
Hocam dediğim gibi o kodları denedim I2C de problem yaşıyorum. I2C Hattında ACK sinyali gelmediği için Program donup kalıyordu. Gerçi XCLK uygulandıktan sonra hardware I2C kütüphanesini hiç denemedim. Bu akşam bir deneyelim bakalım.
@Mistek
Hocam Benim yaptığım işlem sırası şöyle
Start gönder
Device Adres yaz
ACK bekle, Eğer ACK geldiyse Data gönder yoksa Stop gönder hattan çık.
ACK gelmediği için hattan çıkıyorum. Normalde böyle olması gerekiyor ama
Data hattini open collector + pull up tipi seciyorsun degilmi?
Evet hocam pull-up ve OD yapıyorum.
I2C ile farklı birşey deniyeyim. Dediğiniz gibi I2C rutini sorunlu olabilir. Döngülerle data gönderiyorum çünkü.
Alıntı yapılan: Mucit23 - 08 Mart 2014, 10:51:56
Hocam Benim yaptığım işlem sırası şöyle
Start gönder
Device Adres yaz
ACK bekle, Eğer ACK geldiyse Data gönder yoksa Stop gönder hattan çık.
ACK gelmediği için hattan çıkıyorum. Normalde böyle olması gerekiyor ama
Start Gönder - Clock başlat en az 20 periyot olsun
Adres gönder
ACK bekle.
9. clock darbesinde ACK biti gelir.
ACK gelecek diye beklemeyin siz ona clock gönderin ki oda geri bişey göndersin burada master cihaz işlemci çünkü.
ACK Geldi çok şükür.
I2C rutinini aşağıdaki gibi yaptım.
GPIO_SetBits(GPIOD,GPIO_Pin_12); //Reset Pini Lojik 1 Yapiliyor
I2C_Delay();
/*Start islemi Yapiliyor*/
SDAH;
SCLH;
I2C_Delay();
SDAL;
I2C_Delay();
SCLL;
I2C_Delay();
/*Start islemi Bitti Sira Adres Göndermede
Yazma islemi icin 0x42 gönderilecek */
SDAL; //7.Bit Gönderilir.
I2C_Delay();
SCLH;I2C_Delay();SCLL;I2C_Delay();//Clock Uygulaniyor
SDAH; //6.Bit Gönderilir.
I2C_Delay();
SCLH;I2C_Delay();SCLL;I2C_Delay();//Clock Uygulaniyor
SDAL; //5.Bit Gönderilir.
I2C_Delay();
SCLH;I2C_Delay();SCLL;I2C_Delay();//Clock Uygulaniyor
SDAL; //4.Bit Gönderilir.
I2C_Delay();
SCLH;I2C_Delay();SCLL;I2C_Delay();//Clock Uygulaniyor
SDAL; //3.Bit Gönderilir.
I2C_Delay();
SCLH;I2C_Delay();SCLL;I2C_Delay();//Clock Uygulaniyor
SDAL; //2.Bit Gönderilir.
I2C_Delay();
SCLH;I2C_Delay();SCLL;I2C_Delay();//Clock Uygulaniyor
SDAH; //1.Bit Gönderilir.
I2C_Delay();
SCLH;I2C_Delay();SCLL;I2C_Delay();//Clock Uygulaniyor
SDAL; //0.Bit Gönderilir.
I2C_Delay();
SCLH;I2C_Delay();SCLL;I2C_Delay();//Clock Uygulaniyor
/*ACK Bakiyoruz.*/
SDAH;
I2C_Delay();
SCLH;I2C_Delay(); //Clock Uygulaniyor
if(SDAR) return (0xFF);
;SCLL;I2C_Delay();
STM_EVAL_LEDOn(LED3);
Hard I2C yi de bi deneyelim. Eğer olursa onu kullanırım. Yoksa yukarıdaki kodları fonksiyonlaştırıp kullanacağım
Hard I2C yi denedim onda sonuç alamadım. Nedense Start bitinin başında SCL hattı anlık olarak lojik 0 olup tekrar lojik 1 oluyor. Tahminimce bundan dolayı çalışmıyorlar. Bu kameralar I2C de çok hassas. Hata kabul etmiyorlar.
Ama yukarıda verdiğim kodları fonksiyonlaştırdım. Şimdi Hem OV9655 ile hemde OV7670 ile harbi harbi konuşabiliyorum.
arkadaşlar bir yol gösterme amacı ile anlatıyorum belki faydalı olur. şu an elimde mikromediaplus for stm32 kartı var ve bu kartta ssd1963 sürücüsü kullanılmış. aynı zamanda mikroc nin de hazır initial kodları var ve tft sürmek çok kolay oluyor. bununla ilgili eğer kurulumda sıkıntı yaşıyorsanız bu kodların ve devre şemasının incelenmesinde fayda olabilir. aşağıdaki linkte download edilebilir şema ve örnek programlar mevcut.
http://www.mikroe.com/mikromedia/plus/stm32/ (http://www.mikroe.com/mikromedia/plus/stm32/)
Düzgün olmasada Kameradan görüntü almayı başardım. Fakat neden bilmiyorum görüntüde renk problemleri var ayrıca görüntü kırık.
İlk başlarda hiç görüntü alamamıştım. Sonradan DCMI_Frame kesmesini aktif ettim. Her bir frame alındığında kesme oluşuyor. Bende kesme içerisinde gidip LCD nin kordinatlarını 0,0 noktasına çekiyorum. Sonrasında DMA, DCMI den dataları alıp FSMCye yolluyor. Ekran dolunca tekrar kesme oluşuyor.
Şuanda XCLK Hızı 24Mhz. Eğer Görünütüyü düzeltebilirsem FPS değeri iyi gibi.
Ufak bir test videosu çektim.
Stm32f407 OV9655 Camera Test (Vol 1) (http://www.youtube.com/watch?v=kA6b5L885sM#ws)
Congratulations! :)
Renk paleti ile ilgili bir sorun var gibi. Yani stm32 nin atıyorum red2 nolu kamera girişine, kameranın blue3 nolu çıkışı bağlanmış gibi duruyor. Kameranın paralel bağlantısından emin olun :)
işte bendeki görüntüde buna çok benziyor.
sanırım artık aynı noktada takıldık.
ben register ayarlarında sorun var diye düşünüyorum. ancak
pll 24mhz görüntü qcif ve renk olarak rgb565 ayarladığıma cok eminim
bir türlü işin içinden çıkamadım
@Ramiz, kamerada öyle bir bağlantı yok. :o
@Mnemonic
Hocam daha registerleri hiç karıştırmadım. Problem olduğunu da pek sanmıyorum açıkçası. Bana kalırsa ya sıralamada problem var yada lcd de sorun var. Lcd de renk farklı olarak görüntü düzgün çıksa derim tamam renk ayarlarıyla ilgili sorun var Ama görüntü de kırık çıkıyor. Bu yüzden lcd ayarları ile ilgili olabileceğini düşünüyorum.
Geçenler de resim basmada da sorun yaşamıştım. Düzgün bir şekilde ekrana resim basabilmem gerekir.
Birde ben frame kesmesini aktif etmiştim. Her bir görüntü geldiğinde kesme oluşuyor bende gidip lcd'nin başlangıç kordinatlarını veriyorum. Normalde birkere başlangıç kordinatını verdinmi lcd tamamen dolduğunda tekrar baştan başlaması gerekiyor. Yani ekran her dolduğunda gidip yeniden başlangıç kordinatlarına adres vermeye gerek kalmaması lazım.
Lcd de bu işlerin nasıl yürüdüğünü çözmek gerekiyor.
@mucit23 sorun neymiş ? Clock'la ilgisi varmıymış?
Ayrıca sabrınızı takdir ettim ben uğraşıyor olsaydım 5. günün şafağında pert olurdu. :)
@Mucit23 hocam selamlar;
ben lcd olarak ssd1963 kullanıyorum dcmi frame interrupt kullanıyorum bende interraupta her girdiğimde lcd üzrerinde window set yapıyorum ondan kaynaklı olabilir bir kere ayarlamayı hiç denemedim. ov7670 çözünürlüğü için qcif(176X144) kullandığımdan lcd üzerinde window vermem gerekiyor ama daha sonra ayarladığım windowu kapatmazsam ekrana başka şey basamıyorum ve lcd kararıyor. ama yazıları kaldırıp sadece görüntü basmayı deneyeceğim. ayrıca lcdyi rgb565 sürdüğüm için kamera üzerinden yuv yerine rgb565 veri olacak şekilde registerleri set ediyorum. dediğin gibi sorun veriyi lcdye göndermekle alakalı olabilir. bu kendi projem olduğu için ben sadece akşamları ilgilenebiliyorum. senden güzel haberler bekliyoruz
sevgiler
Alıntı yapılan: mistek - 10 Mart 2014, 10:33:30
@mucit23 sorun neymiş ? Clock'la ilgisi varmıymış?
Ayrıca sabrınızı takdir ettim ben uğraşıyor olsaydım 5. günün şafağında pert olurdu. :)
Teşekkürler.
Clockla ilgisi var. XCLK den mutlaka sinyal uygulamak gerekiyor. Ben şuanda 24Mhz veriyorum. Sonuç test videosundaki gibi(Bu daha çok kristal olmadan mcu'yu çalıştırmaya benziyor.) Bana vakit kaybettiren zaten bu oldu.
Diğer bir yandan Hardware I2C ile çalışmıyor sistem. Kameralar I2C konusunda okadar hassaski hiç hata kabul etmiyor. Bu yüzden I2C rutinlerini kendim yazdım. Harware I2C'de start bitinden önce SCL ve SDA hattı anlık olarak Low oluyor. Bundan dolayı kamera çalışmıyordu. Ama şuanda I2C iletişimde sıkıntı yok. Hem OV9655, Hemde OV7670 Çalışıyor.
@Mnemonic, Çözeceğim bu meseleyi. Okul ve işten dolayı bende sadece akşamları çalışabiliyorum. Bu yüzden yavaş ilerliyorum.
SSD1963 veya 1289 olsun. İksindede çok problem yaşadım. Heleki SSD1963'de 4.3'LCD çalıştırabilmek için SSD1963'ün Datasheetini yalayıp yutmam gerekti. SSD1289 da abisi kadar olmasa canımı sıkmıştı. En son FSMC'deki AddressSetupTime, DataSetupTime gibi değerler ile oynayınca lcdyi stabil hale getirdirdim. Bu değerleri düşürmek gerekiyor. Mesela SSD1289'da Siyah arka planın üzerine Beyaz renk basınca lcd saçmalamaya başlıyordu. FSMC deki delay sürelerini aşağı çekerek düzelttim.
Buna rağmen SSD1963'e beyaz renk datası(0xFFFF) gönderince SSD1963 donuyordu. Hala çözemedim.
3.2" LCD'de ili9325 çipsetli bir lcd almak lazım.
Bu geğerleri atıyorum,
TFT rgb565 (16 bit), kamera 8 bit ve rgb332. Sizin bu veriyi işleyip, Tft ye göre düzenlemeniz gerekir. Büyük ihtimalle kameradan gelen veriyi direk tft ye basıyorsunuz ve renk paletleri bir birine giriyor.
@Ramiz,
Kamerada rgb332 diye bir çıkış seçeneği yok. Kamera modülü RGB565 Formatına ayarlı. DCMI modülü doğrudan 16bit 565 formatında pixel datası vermesi gerekir.
Eğer konuya müdahil olacaksan lütfen kameranın datasheetini açıp nasıl çalıştığına birazcık bak.
Datasheet Sayfa 9'da 1 pixel için çıkış format şekli gösterilmiş.
(http://s12.postimg.cc/9phxlorbx/Ekran_Al_nt_s.jpg) (http://postimg.cc/)
resim yuklemek (http://postimg.cc/index.php?lang=turkish)
Resimde görüldüğü üzere her bir pixelin renk datası 2 paket halinde geliyor. DCMI bunları birleştirmesi lazım.
LCD'de kırıklık vardı onu çözdüm. Şuan ekranda tam bir görüntü alıyorum fakat renk problemi devam ediyor. LCD'ye tam bir resim bastım yani LCD nin çalışmasında sıkıntı yok.
Sabahtan beri kameranın Registerlerine bakıyorum. Renkle veya çıkış formatı ile ilgili olan bütün registerleri elden geçirdim ama çözüm olmadı.
Datasheet çok kıt yazılmış. Hangi registerin, hangi bitin ne işe yaradığı çok kısa bilgilerle açıklanmış. Eğer sorun kameranın ayarlarıyla ilgili ise doğru çözümü bulmak bize çok vakit kaybettirecek gibi görünüyor.
Ayrıca OV9655 ile ilgili neredeyse bütün örnek programlara baktım. İnit kodları neredeyse hepsinde aynı. Yani Adamlar aynı init kodlarıyla kamerayı çalıştırıyorlarsa bende aynı init kodlarıyla kameradan net bir görüntü almam gerek.
Sorun renkle ilgili. Dedim ya DCMI gelen iki paketlik renk datasını birleştirmesi gerekiyor. İşte DCMI'nin bunu yaptığından emin değilim. Belki Sadece yüksek 8 bit bana geliyor. Belki bu yüzden renkler kırmızı ve mor ağırlıklı.
Aslında bir şekilde DMA ile FSMC arasındaki Data hattını izleyebilsem güzel olacak. Gelen datalar kaç bit olduğu belli olur.
Aklıma başka birşey gelmiyor. Başka fikri olan varsa söylesin test edeyim.
mesaj birleştirme:: 10 Mart 2014, 23:05:35
Kameranın Registerlerini kurcalarken ne gördüm.
0x8D nolu registerin 4. bitini enable yapınca color test özelliği aktif oluyormuş. Aktif ettim ekrana şöyle bir görüntü geldi.
(http://s24.postimg.cc/9mgjuzkqd/DSC_0007_1632_x_1224.jpg) (http://postimg.cc/image/kyt5crtf5/full/)
resim gönder (http://postimg.cc/index.php?lang=turkish)
Belliki ekranda renk renk barlar var. Fakat biraz kayık çıkmış Acaba senkronizasyonmu yakalanamıyor.
Evet bende OV7670 modülün çıkışını RGB565'e göre ayarladım ve öyle kullanıyorum. elimde 16bit RGB datası var ve bunu SSD1963 üzerinde direk window (176X144) üzerine gönderiyorum.
sorunun bende bu durumda kaynaklandığını düşünmüyorum Mucit23 hocamında dediği gibi onlarca örnek inceledim hiç biri bu konuda kodunda bir şey yapmamış ve datayı direk olarak ekrana basmış. hatta YUV data alıp direk ekrana basan bile var. Bende bir tülü tam sorunun nereden kaynaklandığını bulamadım.
@Mucit23 hocam sendeki kodları paylaşman mümkünmü farklı LCD'ler kullanıyoruz bende SSD1963 üzerinde görüntü konusunda testler yapmak isterim
Mucit bir yerde goruntuyu direk seri porttan basildigini gordum oyle bir test yapabilirsin ama nasil yapildigini bilmiyorum Bir de sd kart baglayabilirsen sisteme gelen goruntuyu direk jpg olarak kaydet veya bmp olarak pcden goruntuye bir bak Sikintinin dmci ile ilgili olup olmadigi belli olur Ben meselenin lcd ile ilgili oldugnu dusunuyorum Bu arada kirikligi nasil giderdin_
@Mnemonic
Hocam Bendeki kodlar OV9655'e göre. İkimizde aynı sorunu yaşadığımıza göre bence kameralarda problem yok. Çünkü iki farklı kamera kullanmamıza rağmen ikimizde STM32F4 Discovery kullanıyoruz. Bence stm32f407 üzerine yoğunlaşalım.
Günün Sorusu: DCMI modülünün görevini doğru bir şekilde yaptığını nasıl anlarım?
@yldzelektronik
Hocam aslında DMA yı FSMC yerine direk Usarta bağlayarak görüntüyü usarttan basabilirim. Bunun için C# da bir form hazırlamam gerekli ama Seri portun bu hıza yetişeceğini sanmıyorum.
30FPS de çalışsa kamera 320x240 bir görüntü için saniyede 30x320x240=2,304,000 Data eder. Tabi bunlar 16 bit. Usartan 8 bit halinde göndereceğimiz için bu sayıyı tekrardan 2 ile çarpmak gerekir. Saniyede 4,6 Mbyte veri ediyor.(Akan verinin bu derece yüksek olması şarşırttı açıkçası. )
LCD bence çalışıyor. Çünkü RGB565 formatında gönderdiğim resim datalarını problemsiz bir şekilde ekrana basıyor. LCD'deki kırıklık ise basit bir hatadan kaynaklanıyordu. Normalde Ekrana pencere açarken Ekran boyutlarını 320,240 şeklinde vermiştim. Fakat 1 eksiğini vermek gerektiğini unutmuşum.
Ben biraz DCMI modülüne bakacağım.
Alıntı yapılan: Mucit23 - 11 Mart 2014, 10:56:50
...
Günün Sorusu: DCMI modülünün görevini doğru bir şekilde yaptığını nasıl anlarım?
...
Daha önce de söyledim.Ya jpeg formatlayıp yada bmp formatlayıp kayıt edebilirsin veya seri portu çıkabildiğin en yüksek hız ile test edersin.
Ekleme:
Alıntı yapılan: Mucit23 - 11 Mart 2014, 10:56:50
Hocam aslında DMA yı FSMC yerine direk Usarta bağlayarak görüntüyü usarttan basabilirim. Bunun için C# da bir form hazırlamam gerekli ama Seri portun bu hıza yetişeceğini sanmıyorum.
30FPS de çalışsa kamera 320x240 bir görüntü için saniyede 30x320x240=2,304,000 Data eder. Tabi bunlar 16 bit. Usartan 8 bit halinde göndereceğimiz için bu sayıyı tekrardan 2 ile çarpmak gerekir. Saniyede 4,6 Mbyte veri ediyor.(Akan verinin bu derece yüksek olması şarşırttı açıkçası. )
Demişsin.Ancak ben şimdi data sheet açıp baktım ve gördüm ki - ilk sayfada-
"Up to 4 USARTs/2 UARTs (10.5 Mbit/s, ISO 7816 interface, LIN, IrDA, modem control)" demiş.?
Alıntı YapHocam Bendeki kodlar OV9655'e göre. İkimizde aynı sorunu yaşadığımıza göre bence kameralarda problem yok. Çünkü iki farklı kamera kullanmamıza rağmen ikimizde STM32F4 Discovery kullanıyoruz. Bence stm32f407 üzerine yoğunlaşalım.
@Mucit23 hocam bendeki camera modulunun arızalı olmadığından net eminim çünkü ben alırken 2 adet OV7670 aldım
her ikisinde de aynışeyi yaşıyorum
her halde ikisi bir arızalı olamaz :)
dediğin gibi DCMI ve DMA üzerine yoğunlaşmakta fayda var ancak benim aklıma takılan bir noktada daha var kullandığım SSD1963 driveri ne kadar doğru acaba ?
Alıntı yapılan: yldzelektronik - 11 Mart 2014, 11:28:50
"Up to 4 USARTs/2 UARTs (10.5 Mbit/s, ISO 7816 interface, LIN, IrDA, modem control)" demiş.?
Hocam yanlışınız olacak. Benim bildiğim 10.5 Mbit/sn = 1.25Mbyte/sn
Her neyse Dediğiniz gibi DCMI dan gelen dataları direk resim olarak kaydetmem gerekecek anlaşılan. Aslında bununla ilgili bir örnek var elimde ama o örnekte ilk önce DCMI'dan gelen dataları LCD ye gönderiyor. Resim kaydedeceği zaman Kamerayı durdurup LCD deki Görüntüyü tekrar çekip SD karta kaydediyor. Yani LCD yi ram alanı olarak kullanıyor.
Ben bunun aynısını işlemcinin ram alanıyla yapmaya çalışacağım.
DCMI modülüne bakıyorum ama ondada fazla bir ayar yokki? Nedir neyin nesidir anlamadım.
Şu anda kesin olarak eminimki benim SCCB protokolümde sıkıntı var.
okuduğum bir dökümanda SCCB'nin kesinlikle doğru çalıştığından emin olun ve 0X01 adresini okuyun demiş veriyi 0X80(default değer) görmeniz gerekli demiz
ben register read yaptığım zaman bam başka birşey görüyorum
ve artık kesinlikle sccbyi doğru kullanamadığımı ve istediğim şekilde rgisterleri ayarlayamadığım için çalışmadığını biliyorum
sccbnin doğru çalışan bir driveri üzerinde çalıştıkdan sonra kamera ayarlarına geri döneceğim
Benim SCCB Write Kodlarım çalışıyor. Ama Read Meselesini hiç bakmadım.
Çalıştığını nerden anlıyorum diye sorarsan eğer 8D nolu adresten Kamera test modunu aktif etmiştim.Ekrana colorbar çıkmıştı. Ayrıca init kodlarıyla oynayınca farklı sonuclar alıyorum. Demekki Yazma işleminde sıkıntı yok.
Kamera init bölümünde herhangi bir okuma yapılmıyor. Bu yüzden okuma kısmına hiç uğraşmadım.
Bu arada en sonki çalışan uygulama videosu böyle.
https://www.youtube.com/watch?v=yTBqYgAgdZQ (https://www.youtube.com/watch?v=yTBqYgAgdZQ)
Alıntı yapılan: Mucit23 - 10 Mart 2014, 23:13:06
@Ramiz,
Kamerada rgb332 diye bir çıkış seçeneği yok. Kamera modülü RGB565 Formatına ayarlı. DCMI modülü doğrudan 16bit 565 formatında pixel datası vermesi gerekir.
Eğer konuya müdahil olacaksan lütfen kameranın datasheetini açıp nasıl çalıştığına birazcık bak.
Bunu yapmak için ne vaktim var nede internetim. Yalnız siz türkçe bilmiyorsunuz anlaşılan. Orada karartarak yazmışım ki,
Alıntı yapılan: Ramiz - 10 Mart 2014, 20:45:55
Bu geğerleri atıyorum,
Konuya müdahil olma gibi bir amacım yok. Sorun sizin sorununuz. Çözüm için buradan medet umuyorsunuz. Yalnız tavrınız çok enteresan. Sanki ben cevap yazmaya mecburmuşum gibi konuşuyorsunuz.
2 sene önce fpga ve vga ile çalışmıştım. Ramdeki resim bilgisini, fpga in vga dac ına direk bastığımda, renk paletleri uyuşmadığı için renkler karışıyordu ama görüntü sorunsuz oluşuyordu. Basit bir aritmetik işlemden geçirince düzelttim. Bu konu hakkında böyle bir deneyimim oldu ve büyük ihtimal ile sizin sorununuzda renk paletinden kaynaklandığını düşünüyorum.
Alıntı YapAyrıca init kodlarıyla oynayınca farklı sonuclar alıyorum. Demekki Yazma işleminde sıkıntı yok.
@Mucit23 hocam böyle demişsin ama bende de aynı durum var bu kodun doğru çalıştığını göstermez. Zira sen değerleri değiştirdiğin zaman hatalı iden değerlerde değişecektir.
senden rica etsem kodu paylaşabilirmisin ? seninkiyle benimkini karşılaştırmak isterim
@Ramiz birgün sana internette nekadar PDF datasheet varsa toplayıp birkaç dvd'ye çekip yollayacağım. PDF Download Problemini çözmüş olursun en azından. :-X
Herneyse
@Mnemonic,
Hocam valla ben lojik analyser ile hattı takip ediyordum. Oradan giden datalar belli. Bu yüzden SCCB çalışıyor dedim. Ama kodları vereyim. Bu kodlarla kamerayı init etmeye çalışın. Umarım problem dediğiniz gibidir.
I2C.c
/**
******************************************************************************
* @file I2C.c
* @author Ferhat YOL
* @version V0.0.3
* @date 1/3/2014
* @brief Software I2C Program
*
******************************************************************************/
/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx.h"
#include "I2C.h"
#include "main.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define I2C_Port GPIOB
#define I2C_SDA GPIO_Pin_9
#define I2C_SCL GPIO_Pin_8
/* Bits definitions ----------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
#define SDAH GPIO_SetBits(GPIOB,GPIO_Pin_9)
#define SDAL GPIO_ResetBits(GPIOB,GPIO_Pin_9)
#define SCLH GPIO_SetBits(GPIOB,GPIO_Pin_8)
#define SCLL GPIO_ResetBits(GPIOB,GPIO_Pin_8)
#define SDAR GPIOB->IDR & GPIO_Pin_9
#define SCLR GPIOB->IDR & GPIO_Pin_8
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
void Soft_I2C_Configuration(void){
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIOB clocks */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
/*SDA Pin Configuration*/
GPIO_InitStructure.GPIO_Pin = I2C_SDA;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(I2C_Port, &GPIO_InitStructure);
/*SCL Pin Configuration*/
GPIO_InitStructure.GPIO_Pin = I2C_SCL;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(I2C_Port, &GPIO_InitStructure);
}
void I2C_Delay(void)
{
unsigned int i=I2C_Delay_Time;
while(i)
{
i--;
}
}
uint8_t I2C_Start(void)
{
SDAH;
SCLH;
I2C_Delay();
SDAL;
I2C_Delay();
SCLL;
I2C_Delay();
return (0x00);
}
void I2C_Stop(void)
{
SDAL;
I2C_Delay();
SCLH;
I2C_Delay();
SDAH;
I2C_Delay();
}
void I2C_Ack(void)
{
SCLL;
I2C_Delay();
SDAL;
I2C_Delay();
SCLH;
I2C_Delay();
SCLL;
I2C_Delay();
}
void I2C_NoAck(void)
{
SCLL;
I2C_Delay();
SDAH;
I2C_Delay();
SCLH;
I2C_Delay();
SCLL;
I2C_Delay();
}
uint8_t I2C_WaitAck(void)
{
SDAH;
I2C_Delay();
SCLH;I2C_Delay(); //Clock Uygulaniyor
if(SDAR) return (0xFF);
;SCLL;I2C_Delay();
return(0x00);
}
void I2C_SendByte(unsigned char SendByte)
{
unsigned char i=0;
for(i=0;i<8;i++)
{
if ((SendByte << i) & 0x80)
{
SDAH;
}
else
{
SDAL;
}
I2C_Delay();
SCLH;
I2C_Delay();
SCLL;
I2C_Delay();
}
}
unsigned char I2C_ReceiveByte(void)
{
unsigned char i=8;
unsigned char ReceiveByte=0;
SDAH;
while(i--)
{
ReceiveByte<<=1;
SCLL;
I2C_Delay();
SCLH;
I2C_Delay();
if(SDAR)
{
ReceiveByte|=0x01;
}
}
SCLL;
return ReceiveByte;
}
unsigned char I2C_ReadByte( unsigned char DeviceAddress,unsigned int ReadAddress)
{
unsigned char temp;
if(!I2C_Start())return (0xFF);
I2C_SendByte((DeviceAddress & 0xFF));
if(!I2C_WaitAck()){I2C_Stop(); return 0xFF;}
I2C_SendByte((unsigned char)((ReadAddress>>8) & 0xFF));
I2C_WaitAck();
I2C_SendByte((unsigned char)((ReadAddress) & 0xFF));
I2C_WaitAck();
I2C_Start();
I2C_SendByte((DeviceAddress & 0xFE)|0x01);
I2C_WaitAck();
temp = I2C_ReceiveByte();
I2C_NoAck();
I2C_Stop();
return temp;
}
I2C.h
/********************************************************************************
* @file I2C.h
* @author Ferhat YOL
* @version V0.0.3
* @date 01/3/2014
* @brief Software I2C Program
*
******************************************************************************/
#ifndef I2C_H
#define I2C_H
/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define I2C_Delay_Time 500
/* Bits definitions ----------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
void Soft_I2C_Configuration(void);
void I2C_Delay(void);
uint8_t I2C_Start(void);
void I2C_Stop(void);
void I2C_Ack(void);
void I2C_NoAck(void);
uint8_t I2C_WaitAck(void);
void I2C_SendByte(unsigned char SendByte);
unsigned char I2C_ReceiveByte(void);
unsigned char I2C_ReadByte(unsigned char DeviceAddress,unsigned int ReadAddress);
#endif
Fakat dediğim gibi okuma komutları çalışmayabilir. Hiç üzerinde çalışmadım.
ekleme:
Bu adamda aynı problemi yaşıyor sanırım.
https://www.youtube.com/watch?v=e-I7UyxRZlk (https://www.youtube.com/watch?v=e-I7UyxRZlk)
Şimdi Teker Teker Registerleri kurcalıyordumki ilginç bir durumla karşı karşıya geldim.
Ov9655'in 0x69 nolu registerine bakın. Datasheet'te reserved yazıyor. Yani boş olması gerekir.
Benim init kodlarımda 0x69 nolu registere 0x0A yazmışlar. Boş registere neden boşu boşuna yazma yapıyorlar diyip bu satırı kapatınca kamera çalışmadı.
Aynı şekilde bir iki durumla daha karşılaştım. Bence Kamerayı ben RGB565 Moduna sokamıyorum. Kamera Hala YUV modunda. Çünkü YUV ile ilgili Registerler ile oynuyorum doğrudan görüntü değişiyor veya bozuluyor.
Bakalım daha neler çıkacak...
Selam mucit23;
sende benle aynı fikire gelmeye başladın :)
hadi bakalım nerede çözeceğiz işi
@Mnemonic Hocam bendeki ov7670 ile ilgili topladığım Kaynak kodları ve dökümanları göndereyim. Onlarıda bir deneyin.
Öyle birşeyki elim kolum bağlandı resmen. Farklı kütüphaneleri denemekten başka şuanda elimden birşey gelmiyor. Dün akşam kameranın ayarlarıyla bayağı bi oynadım. Ne yaptıysam artık bilmiyorum kamera daha koyu göstermeye başladı. Ama beyaz ışığa tutunca yine mor gösteriyor. ilk başlarda DCMI da felan olabileceğini düşünüyordum ama DCMI modülünün fazla bir ayarı yok. DMA'nında ne olduğunu biliyoruz zaten.
İnternette ov9655 ile ilgili nekadar kaynak varsa okudum. Google 'un bütün "o" larına baktım. Kimse bizim yaşadığımız problemlerle uğraşmamış. Genelde XCLK yı uygulayan herkes ikinci denemesinde kamerayı düzgün bir şekilde çalıştırmış. Anlamıyorum işte aynı kodları bende kullanıyorum. Bizde renkler düzgün çıkmıyor.
Ne yapayım bilmiyorum :'(
@Mucit23
teşekkür ederim kodları aldım inceleyip sonuçları bildiricem ama bir iki gün alabilir.
ben inatla sorunun SCCB'yi doğru kullaamadığımız için olduğunu düşünüyorum
Konuyu okudum, ben şahsen kameranın yuv modunda kalmış olabileceğini düşünüyorum.
Kamera -> Ekran arasında işlem yapabiliyorsanız YUV 422 yi önce RGB 888 e sonra onu da RGB 565 e dönüştürüp ekranda göstermeyi deneyebilirsiniz, sorunsuz görünürse YUV modundan çıkamadığı kesinleşecektir.
Belki de kamerayı init ettikten sonra reset alıp tekrar eski ayarlarına geri dönüyordur?
Sırayla aşağıdaki registerlara doğru değerleri yazdığınızı da kontrol etmelisiniz.
static struct regval_list ov7670_fmt_rgb565[] = {
{ REG_COM7, COM7_RGB }, /* Selects RGB mode */
{ REG_RGB444, 0 }, /* No RGB444 please */
{ REG_COM1, 0x0 }, /* CCIR601 */
{ REG_COM15, COM15_RGB565 },
{ REG_COM9, 0x38 }, /* 16x gain ceiling; 0x8 is reserved bit */
{ 0x4f, 0xb3 }, /* "matrix coefficient 1" */
{ 0x50, 0xb3 }, /* "matrix coefficient 2" */
{ 0x51, 0 }, /* vb */
{ 0x52, 0x3d }, /* "matrix coefficient 4" */
{ 0x53, 0xa7 }, /* "matrix coefficient 5" */
{ 0x54, 0xe4 }, /* "matrix coefficient 6" */
{ REG_COM13, COM13_GAMMA|COM13_UVSAT },
{ 0xff, 0xff },
};
http://www.cs.fsu.edu/~baker/devices/lxr/http/source/linux/drivers/media/video/ov7670.c (http://www.cs.fsu.edu/~baker/devices/lxr/http/source/linux/drivers/media/video/ov7670.c)
Hocam Cevabınız için Teşekkürler.
Ben şu okuma I2C okuma işini halledeyim. Sonrasında dediğiniz testleri teker teker yapıp sonuçlandıracağım. İlk önce ilgili Registere yazma yapıp sonradan ilgili registerden yazdığım değer yazılmışmı yazılmamışmı onu anlamak için okuma yapacağım...
Mucit23 hocam
yazmadanda direk okuma yapabilirsin. sonuç olarak registerlerin default değerleri var
bu arada bir sitede mutlaka yazma yapmadan önce okuma yapın şeklinde bir uyarı vermiş bence bunuda değerlendirebiliriz.
site adresi : http://embeddedprogrammer.blogspot.com.tr/2012/07/hacking-ov7670-camera-module-sccb-cheat.html (http://embeddedprogrammer.blogspot.com.tr/2012/07/hacking-ov7670-camera-module-sccb-cheat.html)
sayfanın sonuda verdiği uyarılar
Alıntı YapTROUBLESHOOTING
SCCB:
Make sure the SCCB is working properly, the OV7670 will answer with an ACK, after it has been address properly.
The 7 bit SCCB/I2C address is 0x21, this translates to 0x42 for write address and 0x43 for read address.
For debugging purposes, try reading some registers and check that they contain their default values. e.g. reading the 0x01 register should return 0x80.
Always read a register first, modify the desired bits and then write it back to the OV7670.
Image sensor
Check wiring, pin configuration and clock configuration.
Start only grabbing a snapshot (only one frame), this is from VSYNC falling edge to VSYNC rising edge. Repeat this procedure multiple times, and make sure the number of bytes per snapshot, is constant.
Cover the camera lens, and verify that the snapshot have the following information (in bytes): 128 0 128 0 128 0 128 0 ... i.e. every even byte should be 128 and every odd byte should be 0. This correspond to a pitch black image.
If the two previous experiments fail, your uC might be too slow to grab the OV7670 stream, either increase its clock speed or get a faster uC. If you are using a DMA controller, then give it high priority, clock it as fast as possible and/or dedicate it to this task.
If you are visualizing the grabbed snapshot in a PC, for starters only use the luminance (Y) channel, i.e. only use the even bytes of the snapshot. On the PC, assign R = G = B = Y for each pixel.
At this point, all the electrical/software part should be working. The only remaining issue is the camera focus (distance from the camera lens to the image sensor), you will have to vary the camera focus by trial and error until you get a clear image.
Hocam oradaki yazıları okudum. Yazılımla ilgili olan bütün kısımları ben halletmişim.
Okuma işinide yaptım. 0x01 nolu adresi okuyorum 0x80 cevabını alıyorum.
0x0A yani PID registerini okuyorum 0x96 değerini alıyorum.
0x0B yani Rev Registerini okuyorum 0x57 değerini alıyorum. Benim kamera en son çıkan versiyonmuş. OV9655(Rev5). OV9657 de denilebilir.
Okumaya devam.
hocam bravo;
bazı farklı işlerim olduğu için ben henüz üzerine düşemedim. bu aralar bakamıyorum. senin gönderdiğin kodları deniycem.
bu arada dün bende farklı verisyonlar olduğunu farkettim. bendeki OV7670 lerin versiyonları nedir bilmiyorum onu bulup uygun datasheetle devam edeceğim
sanırım bu önemli bir kriter farklı versiyonların registerlerinde farklılık var.
ayrıca ben şöyle bir şeye takıldım biz RGB565 datayı 8 bitlik 2 blok halinde okuyoruz sonra bunu 16bit olarak lcdye gönderiyoruz acaba lcdye gönderirken ilk 8biti gönderip sonraki 8biti boş gönderiyor olabilirmi yada kameradan okurken 8 bitlik veriyi word olarak atıp worun son 8 bitini boş bırakıyor olabilirmi belkıde datayı pars etmemiz gerekiyordur
bu düşüncem için ne diyorsun ?
Okudum Renkle ilgili olan her yeri okudum. Yazılan değerlerde sıkıntı yok.
Ben ilk başta aynen sizin dediğiniz gibi Yüksek veya düşük 8 bitin gelmediğini düşünüyordum bence öyle değil.(Daha onun testini yapmadım) Niye derseniz 16 bit RGB565 formatı aşağıdaki gibi
RRRRRGGGGGGBBBBB
Biz ekranda Kırmızı ve Mor ağırlıklı renkler görüyoruz. Demekki Kırmızı rengin gelmesinde sıkıntı yok. Mor'un oluşması içinde Mavininde geliyor olması gerekir. (Mavi+Kırmızı=Mor) Ekrana bakara neyin gelip gelmediğini tahmin edebiliriz. LCD ye yüksek 8 Bit gelmese Kırmızı renkler görünmez. Düşük 8 bit gelmese mavi renkler görünmez. Yani Bence 16 bit data geliyor.
Ben galiba sorunu tespit ettim. Bizim kameralarda(Özellikle benimkinde) yeşil körlüğü var. Yeşil Renkler çok az görünüyor. Görüntüde sıkıntı yok net çıkıyor ama görüntü çok karanlık ve mavi ağırlıklı.
Yaptığım testlerin sonucu şöyle;
Kameraya Mavi bir nesne gösterdğimde Nesnenin rengi mavi görünüyor. Problem yok.
Kırmızı bir nesne tutarsam kırmızı görüyorum ama mavi kadar canlı değil
Yeşil Renk tuttuğumda ise genellikle mavi bazen azıcıkta olsa yeşil görünüyor.
Gün ışığında veya kameraya beyaz ışık tuttuğumda ise mavi ağırlıklı renkler görüyorum.
Kameranın registerlerinde kesinlikle problem yok. Eğer datasheet doğru ise Kesinlikle RGB565 Formatına ayarlı. Çünkü yazdığım değerleri okuyabiliyorum. Farklı bir değer yazsam yazdığım farklı değeride okuyarak görüyorum. Zaten farklı bir formata ayarlasam(YUV gibi) Görüntü çok berbatlaşıyor. Şuanda görüntü net ama son derece karanlık ve mavi ağırlıklı.
Sanki böyle kontrast ayarı olurda sonuna kadar kısarsınya aynen öyle.
Hocam sizde durum nasıl hiç fotoğraf göndermediniz
Selam hocam;
tespit etmiş olduğun sonuca göre şöyle bir kanıya varıyorum. senin kameranda sorun yok ama LCD de sorun var yanlış hatırlamıyorsam sen IL serisi LCD kullanıyorsn ben SSD1963 kulanıyorum SSD'de ya driverdan kaynaklı yada benim DCMI ayarlarımdan kaynaklı full ekran FFFF gönderdiğimde ucuk mavi bir ekran ekran geliyo ve bazı renklerde de sorun yaşıyorum senin sorununda bu tarz birşey olabilir.
Ben hiç resim göndermedim çekmeye ihtiyaç duymadım benim elde ettiğim görüntü soldan sağa doğru kayan hafif çapraz çizgiler kamera önünden nesne geçirdiğim zamanda renklerde değişiklik oluyor. kameraya beyaz ışık tutarsam komple beyaz elimle kapatırsam görüntü komple siyah oluyor ama çapraz çizgiler durmaya devam ediyor
birde bu aralar başıma iş geldi evde ciddi bir tadilat var o yüzden 2 gündür ilgilenemiyorum. sanırım bir kaç gün daha bakamayacağım konuştuğumuz testlerin hepsini sıradan yapıp sonucu bildiricem
karar verdiğim yapılacak test sıralaması şu şekilde
Registerden okuma yap default değeri gör
aldığın datayı 176X144 matris bir değişkene at ve üzerinde 16bit datalardanmı oluşuyor kontrol yap
buraya kadar sorun yoksa tek sorun kalıyor registerler
tğm registerleri tek tek gözden geçir
Hocam ben hiç QQVGA yı denemedim Şimdiye kadar hep 320x240 ile deneme yaptım. Birde 160x120'yi deneyim.
Sizdeki LCD büyük. Siz neden 320x240 ile çalışmıyorsunuz?
Edit; QQVGA da aynı.
benim kamerada 160X120 diye bir değer zaten yok
ben qcif deniyorum 172X144 değerde
ama qvga deneyebilirim 320X240 alan kullanmış olurum
haklısın testlerimi bu şekilde devam edeceğim
Renk paletinde bir bit bile kayık olursa, renkler allak bullak olur.
RRRRRGGGGGGBBBBB Bu örneği vermişsin.
RRRRRGGGGGGBBBBB :kamera
RRRRGGGGGGBBBBBR :TFT
Eğer renk paletini yukarıdaki gibi bir bit sola kaydırın, tüm renkler bir birine girecektir. İşin en zor kısmını halletmişsiniz bence. Kameradan görüntüyü alabilmek en zor kısmı olmalı.
Size tavsiyem,
Kameranın önüne mucit inde yaptığı gibi kırmızı bir cisim yerleştirin ve gelen 0,0 pixelini ya debug ile yada uart vs aracılığı ile okuyup, yorumlayın. Göreceksiniz ki, kırmızı cisimde, mavi cisimde veya yeşil cisimde, istenmeyen bitler (özellikle R,G,yada B nin high bitleri) lojik 1 olacak. Yorumunuza göre gelen cam verilerini işleyip, LCD ye basın.
Az kaldı kafayı yedirtecek bana.
Ramiz muhtemelen dediğin gibi bir durum var ama neden böyle birşey yaşansın onu anlamıyorum. Gelen datalar üzerinde ben herhangi bir işlem yapmıyorumki. Gelen olduğu gibi işlemciye bile uğramadan LCD ye gidiyor.
En iyisi senin dediğin gibi ramde dizi oluşturup anlık olarak 1 kare alıp diziye yerleştireyim. Sonra dizi üzerinde çalışırız.
Hatta sana daha iyi bir tavsiyede şu ki,
Cam in test sinyali varmış. Data sheetinde hangi renklerin kullanıldığı yazıyordur. Renklerin içlerinde büyük ihtimalle Max değerde olarak R, G ve B vardır. (Sütun halinde)
Direk bunları yorumla. Daha kesin ve doğru sonuç elde edersin.
Çünkü diğer türlü cam önüne tutuğun renk atıyorum açık yeşilse,
Yeşil renklerinin bitleri aktif olacak ama, parklaklık(açıklık) sağlanabilmesi için, diğer renk bitleride aktif olacak(ama en yüksek değeri yeşilin alması gerekir) ve bu kafanı karıştıracak. Test yayını üzerinden max R,G,B üzerine çalışmak daha mantıklıdır.
Çözdüm. :) :) Herkese benden çay :) :D :D
Tamam olacak... İnternette farklı bir datasheet buldum ov9655 için Bir arkadaş Datasheeti editlemiş. Datasheetin en sonunda doğru init kodlarını vermiş. Şuan sırayla registerleri düzeltiyorum orada verilenlere göre yeni değerleri giriyorum. 0x00 ile 0x0F arasını girdim. Görüntü düzeldi. Şimdi diğer adreslerdeki init kodlarınıda gireyim.
Mucit23 helal olsun
çok çabuk senden farklı olarak ne yaptın bekliyoruz.
bu arada bendeki kamera OV7670 onun içinde bu tarz bir datasheet varmı acaba ?
Bahsettiğim datasheetin linki budur.
http://yadi.sk/d/bywuJlcAKTkF9 (http://yadi.sk/d/bywuJlcAKTkF9)
Hocam datasheetin en sonunda init kodları verilmiş. Bu OV9655 için. Şuan renklerde problem yok ama aydınlık seviyesi biraz az gibi. Çokda önemli değil.
Kodları sizde bir deneyin. %80 sizdede çalışır.
Devamına akşam bakacağım.
bir denerim ama ben 7670 kullandığım için farklı olacaktır büyük ihtimalle
Kamerayı çalıştırdık çok şükür. Ama O editlenmiş datasheet olmasaydı mümkün değil çalıştıramazdım. Datasheet'te birçok register Reserved olarak ayrılmış. Normalde bu alanlar boş olması gerekirken belliki kameranın çalışmasını etkileyen ayarları kontrol ediyor. Neden böyle birşeye ihtiyaç duymuşlar anlamıyorum. Kameranın PID ve VER registerlerini okuduğumda Kameranın OV9657 olduğu anlaşılıyor. Ama bununla ilgili hiçbir kaynak döküman vs birşey bulamadım. Belliki kamerayı Rev5 diye güncellemişler ama döküman verilmemiş.
Diğer bir yandan kamera omnivision firmasının olmasına rağmen kendi sitesinde böyle bir ürüne denk gelmedim. Firmaya durumla ilgili 2 defa mail attım hiç bir tanesine cevap vermediler. Bu yüzden omnivision firmasında iyice soğudum. Ovt nin yeni ürünlerinde döküman durumu nedir bilmiyorum ama bir daha kamera ile uğraşmam gerekirse teknik döküman problemi yaşamayacağım bir firmanın ürününü kullanırım kesinlikle.
Şerefsiz kamera tam iki haftamı aldı. >:( >:(
O editlenmiş datasheetide nerden buldum bilmiyorum. Sanki birisi halimi gördüde "yeter uğraştın al şunuda adam akıllı çalıştır kamerayı" dercesine birden çıktı karşıma. Nerden indirdiğime dair hiçbir fikrim yok.
Kameranın çalışmasına gelince Görüntüde bozukluk yok. Renklerde iyi fakat kamera ortamdaki ışık değişimlerine geç adapte oluyor. Birtek bu hoşuma gitmiyor ama sanırım yapacak birşey yok. Günümüz kameralarıyla karşılaştırmamak gerekir.
Aslında döküman bulabilsem elimde bir hurda tabletlerden söktüğüm kameralar var. Onları bile kullanırız.
Son Test videosu
https://www.youtube.com/watch?v=z7-FOgELcbE (https://www.youtube.com/watch?v=z7-FOgELcbE)
Bu arada Kullandığım TFT 3.5" SSD1289 lu bir TFT. Önceki Testlerde LCD de kaymalar felan oluyordu. Düzgün görüntü elde edebilmek için 3-4 defa kartı resetlemem gerekiyordu. Kamera düzelince buda düzeldi.
@Mnemonic,
Hocam kodları deneyin. Datasheetleri karşılaştırırsanız eğer göreceksinizki birçok register aynı.
@mucit23 hayırlı olsun :)
Mucit23 hayırlı olsun.
renk tepkilerini geç verme olayını pll değerlerini değiştirerek ayarlayabilirsin diye düşünüyorum ayrıca agc ayarları ile oyna istersen
bende bugün musaitim kodlar üzerinde çalışıcam
öncelikle registerleri doğru okuyabilirsem akabinde senin register tablonu deniycem
@mucit23 hocam
ben hala reg okuma kısmında takıldım
bir yerde sorun var ama anlamıyorum debug yapıyorum değişkene attığı değer her seferinde farklı okuyor
senin kodları benimle bir paylaşırmısın
nerede hata yapıyorum bir türlü bulamadım
Alıntı yapılan: Mnemonic - 14 Mart 2014, 09:47:48
Mucit23 hayırlı olsun.
renk tepkilerini geç verme olayını pll değerlerini değiştirerek ayarlayabilirsin diye düşünüyorum ayrıca agc ayarları ile oyna istersen
bende bugün musaitim kodlar üzerinde çalışıcam
öncelikle registerleri doğru okuyabilirsem akabinde senin register tablonu deniycem
Hocam evet contrast parlaklık ayarlarını buldum. Ortalama bir değer yakaladım. Şuan kamera gayet iyi görüntü veriyor.
XCLK frekansı 24Mhz deydi. 40Mhz ye çıkardım. Görüntüler dahada akıcılaştı ama ara sıra kameranın şarşırdığı oluyordu. Yine en iyisi 24Mhz.
Alıntı yapılan: Mnemonic - 14 Mart 2014, 12:58:40
@mucit23 hocam
ben hala reg okuma kısmında takıldım
bir yerde sorun var ama anlamıyorum debug yapıyorum değişkene attığı değer her seferinde farklı okuyor
senin kodları benimle bir paylaşırmısın
nerede hata yapıyorum bir türlü bulamadım
Muhtemelen I2C kodlarında problem var. Ben Soft I2C kullanıyorum. Kullandığım kütüphaneyi baştan sona elden geçirdim. Okuma ve yazmada sıkıntı yok.
I2C.c
/**
******************************************************************************
* @file I2C.c
* @author Ferhat YOL
* @version V0.0.3
* @date 10/15/2010
* @brief Software I2C Program
*
******************************************************************************/
/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx.h"
#include "I2C.h"
#include "main.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define I2C_Port GPIOB
#define I2C_SDA GPIO_Pin_9
#define I2C_SCL GPIO_Pin_8
/* Bits definitions ----------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
#define SDAH GPIO_SetBits(I2C_Port,I2C_SDA)
#define SDAL GPIO_ResetBits(I2C_Port,I2C_SDA)
#define SCLH GPIO_SetBits(I2C_Port,I2C_SCL)
#define SCLL GPIO_ResetBits(I2C_Port,I2C_SCL)
#define SDAR GPIO_ReadInputDataBit(I2C_Port,I2C_SDA)//GPIOB->IDR & I2C_SDA
#define SCLR GPIO_ReadInputDataBit(I2C_Port,I2C_SCL)//GPIOB->IDR & I2C_SDA
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
void Soft_I2C_Configuration(void){
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIOB clocks */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
/*SDA Pin Configuration*/
GPIO_InitStructure.GPIO_Pin = I2C_SDA;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(I2C_Port, &GPIO_InitStructure);
/*SCL Pin Configuration*/
GPIO_InitStructure.GPIO_Pin = I2C_SCL;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(I2C_Port, &GPIO_InitStructure);
}
void I2C_Delay(void)
{
unsigned int i=I2C_Delay_Time;
while(i)
{
i--;
}
}
uint8_t I2C_Start(void)
{
SDAH;
SCLH;
I2C_Delay();
SDAL;
I2C_Delay();
SCLL;
I2C_Delay();
return (0x00);
}
void I2C_Stop(void)
{
SDAL;
I2C_Delay();
SCLH;
I2C_Delay();
SDAH;
I2C_Delay();
}
void I2C_Ack(void)
{
SCLL;
I2C_Delay();
SDAL;
I2C_Delay();
SCLH;
I2C_Delay();
SCLL;
I2C_Delay();
}
void I2C_NoAck(void)
{
SCLL;
I2C_Delay();
SDAH;
I2C_Delay();
SCLH;
I2C_Delay();
SCLL;
I2C_Delay();
}
uint8_t I2C_WaitAck(void)
{
SDAH;
I2C_Delay();
SCLH;I2C_Delay(); //Clock Uygulaniyor
if(SDAR) return (0xFF);
;SCLL;I2C_Delay();
return(0x00);
}
void I2C_SendByte(unsigned char SendByte)
{
unsigned char i=0;
for(i=0;i<8;i++)
{
if ((SendByte << i) & 0x80)
{
SDAH;
}
else
{
SDAL;
}
I2C_Delay();
SCLH;
I2C_Delay();
SCLL;
I2C_Delay();
}
}
unsigned char I2C_ReceiveByte(void)
{
unsigned char i=8;
unsigned char ReceiveByte=0;
SDAH;
while(i--)
{
ReceiveByte<<=1;
SCLL;
I2C_Delay();
SCLH;
I2C_Delay();
if(SDAR)
{
ReceiveByte|=0x01;
}
}
SCLL;
return ReceiveByte;
}
unsigned char I2C_ReadByte( unsigned char DeviceAddress,unsigned int ReadAddress)
{
unsigned char temp;
if(!I2C_Start())return (0xFF);
I2C_SendByte((DeviceAddress & 0xFF));
if(!I2C_WaitAck()){I2C_Stop(); return 0xFF;}
I2C_SendByte((unsigned char)((ReadAddress>>8) & 0xFF));
I2C_WaitAck();
I2C_SendByte((unsigned char)((ReadAddress) & 0xFF));
I2C_WaitAck();
I2C_Start();
I2C_SendByte((DeviceAddress & 0xFE)|0x01);
I2C_WaitAck();
temp = I2C_ReceiveByte();
I2C_NoAck();
I2C_Stop();
return temp;
}
I2C.h
/********************************************************************************
* @file I2C.h
* @author Ferhat YOL
* @version V0.0.3
* @date 10/15/2010
* @brief Software I2C Program
*
******************************************************************************/
#ifndef I2C_H
#define I2C_H
/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define I2C_Delay_Time 500
/* Bits definitions ----------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
void Soft_I2C_Configuration(void);
void I2C_Delay(void);
uint8_t I2C_Start(void);
void I2C_Stop(void);
void I2C_Ack(void);
void I2C_NoAck(void);
uint8_t I2C_WaitAck(void);
void I2C_SendByte(unsigned char SendByte);
unsigned char I2C_ReceiveByte(void);
unsigned char I2C_ReadByte(unsigned char DeviceAddress,unsigned int ReadAddress);
#endif
SCL Pini Olarak PB8, SDA olarakda PB9 kullanılıyor. Eğer değiştirmek isterseniz Kütüphanenin başındaki tanımlamarı değiştirin.
Kameraya Yazma ve Okuma rutinlerinide bu şekilde yapın.
/**
* @brief Writes a byte at a specific Camera register
* @param Device: OV9655 write address.
* @param Addr: OV9655 register address.
* @param Data: data to be written to the specific register
* @retval None
*/
uint8_t DCMI_SingleRandomWrite(uint8_t Device, uint16_t Addr, uint8_t Data)
{
I2C_Delay();
I2C_Start();
I2C_SendByte(Device);
if(I2C_WaitAck()==0xFF) return(0xFF);
I2C_SendByte(Addr);
if(I2C_WaitAck()==0xFF) return(0xFF);
I2C_SendByte(Data);
if(I2C_WaitAck()==0xFF) return(0xFF);
I2C_Stop();
return(0x00);
}
/**
* @brief Reads a byte from a specific Camera register
* @param Device: OV9655 write address.
* @param Addr: OV9655 register address.
* @retval data read from the specific register
*/
uint8_t DCMI_SingleRandomRead(uint8_t Device, uint16_t Addr)
{
unsigned char Recieved_Data=0;
I2C_Delay();
I2C_Start();
I2C_SendByte(Device);
if(I2C_WaitAck()==0xFF) return(0xFF);
I2C_SendByte(Addr);
if(I2C_WaitAck()==0xFF) return(0xFF);
I2C_Stop();
I2C_Start();
I2C_SendByte(Device+1);
if(I2C_WaitAck()==0xFF) return(0xFF);
Recieved_Data=I2C_ReceiveByte();
I2C_Stop();
return Recieved_Data;
}
Bu kodları bir deneyin muhtemelen problem çözülecektir.
mucit23 hocam
allah senden razı olsun
şu anda registerleri okuyabiliyorum :)
sonraki adımlarla devam edicem
24Mhz de 30FPS de çalıştığını sanıyordum ama öyle değilmiş. 24Mhz de tam olarak 15FPS alabiliyorum. XCLK frekansını 48'e çıkarınca 30FPS yi gördüm.
mucit hocam
registerlerini ve register yukleme rutinini gonderebilirmisin ?
ayrıca dcmi interruptı nasıl yazdın ?
Edit;
Buraya yükleyecektim ama olmuyor nedense. Yazının yarısı çıkmıyor.
http://yadi.sk/d/BcjDHq9aKZW82 (http://yadi.sk/d/BcjDHq9aKZW82)
Neyse kütüphaneyi buradan indirebilirsiniz.
Hocam Kesme oluşması için DCMI modülünün init edildiği bölümde DCMI frame kesmesini aktif ettim. Kesmenin oluşması içinde stm32f4xx_it.c içerisine aşağıdaki kodları ekleyin
void DCMI_IRQHandler(void)
{
if (DCMI_GetITStatus(DCMI_IT_VSYNC) != RESET)
{
DCMI_ClearITPendingBit(DCMI_IT_VSYNC);
}
if (DCMI_GetITStatus(DCMI_IT_LINE) != RESET)
{
STM_EVAL_LEDToggle(LED3);
DCMI_ClearITPendingBit(DCMI_IT_LINE);
}
if (DCMI_GetITStatus(DCMI_IT_FRAME) != RESET)
{
LCD_SetDisplayWindow(0, 0, 319, 239);
LCD_WriteRAM_Prepare();
DCMI_ClearITPendingBit(DCMI_IT_FRAME);
}
if (DCMI_GetITStatus(DCMI_IT_ERR) != RESET)
{
DCMI_ClearITPendingBit(DCMI_IT_ERR);
}
}
Ben dediğim gibi frame kesmesini aktif ettim. Görüntünün tamamı geldiğinde kesme oluşuyor. Bende kesmeye gidip ekranın başlangıç kordinatlarını veriyorum.
Edit; Dosyaları Güncelledim. İndirdiyseniz tekrar indirin.
hocam teşekkür ederim
büyük ihtimalle registerler farklıdır ama birşeyler bulmaya çalışıcaz artık
ben henüz net bir görüntü elde edemedim
Hocam sizinde %98 ihtimalle ayarlarınızda problem var. Yani şuanda farklı init kodları denemekten başka çareniz yok gibi. Arduinocuların kütüphanelerinede bakın hocam.
Birde şunu söyliyeyim. DCMI ile görünütüyü direk ekrana gönderirken kesme kullanıp her kesme geldiğinde yeni pencere açmaya gerek yoktur. Siz Capture_Start işlemini yapmadan önce pencerenizi açarsınız sonra gelen datalar sırasıyla ekrana dizili. Ekran dolunca zaten baştan yazmaya başlanır. Benim kesme kullandım çünkü bendeki geri zekalı SSD1289'a beyaz pixel gelince eli ayağı birbirine dolanıyor. Herzaman olmuyor ama ara sıra oluyor. Durum böyle olunca ekranın toparlanması için yeniden pencere açmak gerekiyor. Bende her görüntü geldiğinde kesme oluşturup yeniden pencere açıyorum.
Daha önce verdim sanırım tekrar vereyim proje dosyasını. 3.2" lcd ve OV7670 keil proje dosyası :
http://dfiles.eu/files/59w15afkf (http://dfiles.eu/files/59w15afkf)
kamera dcmi'den bağlanıyor. Dosya içinde geliştirme kartına ait pin bağlatı şeması da var. LCD ve DCMI port pinlerine bakarak gerekli bacak bağlantıları yapabilirsiniz. Kendim denedim, çalışıyor.
mucit23 hocam
LCD_WriteRAM_Prepare(); içeriği nedir ben ssd1963 kullandığım için benim kütüphanede bu komut yok
benim kendi lcdme uyarlama yapayım
mesaj birleştirme:: 15 Mart 2014, 14:25:10
@kimlenbu
aynı kart bende de var bende discovery kartı ve ov7670i bu geliştirme kartına takıyorum ama
cdsinden çıkan bu dosyalar doğru çalışmadı
Sıralı yazmadan önce LCD ye aşağıdaki komutu gönderin.
LCD_WriteCommand(0x002c);
Ben SSD1963 Kütüphanemde bunu kullanıyorum. Siz Window fonksiyonun içine bir bakın. Fonksiyonun sonunda bu komut olması gerekir. Eğer varsa tekrardan göndermenize gerek yok.
Merhaba Arkadaşlar;
uzun süredir uğraşamadığım OV7670 ayarlarını zamansız yıkılan mutfak fayansları ve zamanlı beklediğimiz eşimin yaptığı doğum ve oğlumuzun dünyaya gelmesi ardından anca vakit bulabildim ve yeniden üzerinde uğraşmaya başladım. 10larca farklı register kombinasyonu denemesi sonucu hep aynı renk hatalarını aldığımı farkedince gpio ayarlarına odaklandım ve bir şekilde ayarlar doğru olmasına rağmen D0,D3 ve D4 pinlerinin MCU'ya gelmediğii fakettim ve bu pinleri alternatif pinler üzerinden vererek sorunu giderdim.
herkese hayırlı olsun :)
Alıntı yapılan: Mnemonic - 29 Mart 2014, 22:25:57
zamanlı beklediğimiz eşimin yaptığı doğum ve oğlumuzun dünyaya gelmesi
Hayırlı olsun hocam Allah analı babalı büyütsün.
(Yeri değil kusura bakmayın ama boş geçmeyeyim dedim :) )
Hocam Allah analı babalı büyütsün
Kamerayı çalıştırdığınıza sevindim gerçekten. Hazır bende donanım kurulu iken Eğer OV7670 ile ilgili init kodlarınızı paylaşırsanız bende elimdeki ov7670 modülünü test edebilirim.
hocam benim lcd büyük olduğu için ben 640X480 kullandım init kodlarım ona göre
Delay_ms(0xfff);
if(SCCB_Write(OV7670_COM7, SCCB_REG_RESET)!=0)
return 0xff;
Delay_ms(0xfff);
//SCCB_Write (0x3a, 0x04);
SCCB_Write (0x40, 0xd0);
SCCB_Write (0x12, 0x04);
SCCB_Write (0x32, 0x80);
SCCB_Write (0x17, 0x16);
SCCB_Write (0x18, 0x04);
SCCB_Write (0x19, 0x02);
SCCB_Write (0x1a, 0x7b);//0x7a,
SCCB_Write (0x03, 0x06);//0x0a,
SCCB_Write (0x0c, 0x30);
SCCB_Write (0x3e, 0x00);//
SCCB_Write (0x70, 0x00);
SCCB_Write (0x71, 0x00);
SCCB_Write (0x72, 0x11);
SCCB_Write (0x73, 0x00);//
SCCB_Write (0xa2, 0x02);
SCCB_Write (0x11, 0x01);
SCCB_Write (0x7a, 0x20);
SCCB_Write (0x7b, 0x1c);
SCCB_Write (0x7c, 0x28);
SCCB_Write (0x7d, 0x3c);
SCCB_Write (0x7e, 0x55);
SCCB_Write (0x7f, 0x68);
SCCB_Write (0x80, 0x76);
SCCB_Write (0x81, 0x80);
SCCB_Write (0x82, 0x88);
SCCB_Write (0x83, 0x8f);
SCCB_Write (0x84, 0x96);
SCCB_Write (0x85, 0xa3);
SCCB_Write (0x86, 0xaf);
SCCB_Write (0x87, 0xc4);
SCCB_Write (0x88, 0xd7);
SCCB_Write (0x89, 0xe8);
SCCB_Write (0x13, 0xe0);
SCCB_Write (0x00, 0x00);//AGC
SCCB_Write (0x10, 0x00);
SCCB_Write (0x0d, 0x00);
SCCB_Write (0x14, 0x20);//0x38, limit the max gain
SCCB_Write (0xa5, 0x05);
SCCB_Write (0xab, 0x07);
SCCB_Write (0x24, 0x75);
SCCB_Write (0x25, 0x63);
SCCB_Write (0x26, 0xA5);
SCCB_Write (0x9f, 0x78);
SCCB_Write (0xa0, 0x68);
SCCB_Write (0xa1, 0x03);//0x0b,
SCCB_Write (0xa6, 0xdf);//0xd8,
SCCB_Write (0xa7, 0xdf);//0xd8,
SCCB_Write (0xa8, 0xf0);
SCCB_Write (0xa9, 0x90);
SCCB_Write (0xaa, 0x94);
SCCB_Write (0x13, 0xe5);
SCCB_Write (0x0e, 0x61);
SCCB_Write (0x0f, 0x80);
SCCB_Write (0x16, 0x02);
SCCB_Write (0x1e, 0x37);//0x07,
SCCB_Write (0x21, 0x02);
SCCB_Write (0x22, 0x91);
SCCB_Write (0x29, 0x07);
SCCB_Write (0x33, 0x0b);
SCCB_Write (0x35, 0x0b);
SCCB_Write (0x37, 0x1d);
SCCB_Write (0x38, 0x71);
SCCB_Write (0x39, 0x2a);//
//SCCB_Write (0x3c, 0x78);
SCCB_Write (0x4d, 0x40);
SCCB_Write (0x4e, 0x20);
//SCCB_Write (0x69, 0x0c);///////////////////////
SCCB_Write (0x6b, 0x60);//PLL
SCCB_Write (0x74, 0x19);
SCCB_Write (0x8d, 0x4f);
SCCB_Write (0x8e, 0x00);
SCCB_Write (0x8f, 0x00);
SCCB_Write (0x90, 0x00);
SCCB_Write (0x91, 0x00);
SCCB_Write (0x92, 0x00);//0x19,//0x66
SCCB_Write (0x96, 0x00);
SCCB_Write (0x9a, 0x80);
SCCB_Write (0xb0, 0x84);
SCCB_Write (0xb1, 0x0c);
SCCB_Write (0xb2, 0x0e);
SCCB_Write (0xb3, 0x82);
SCCB_Write (0xb8, 0x0a);
SCCB_Write (0x43, 0x14);
SCCB_Write (0x44, 0xf0);
SCCB_Write (0x45, 0x34);
SCCB_Write (0x46, 0x58);
SCCB_Write (0x47, 0x28);
SCCB_Write (0x48, 0x3a);
SCCB_Write (0x59, 0x88);
SCCB_Write (0x5a, 0x88);
SCCB_Write (0x5b, 0x44);
SCCB_Write (0x5c, 0x67);
SCCB_Write (0x5d, 0x49);
SCCB_Write (0x5e, 0x0e);
SCCB_Write (0x64, 0x04);
SCCB_Write (0x65, 0x20);
SCCB_Write (0x66, 0x05);
SCCB_Write (0x94, 0x04);
SCCB_Write (0x95, 0x08);
SCCB_Write (0x6c, 0x0a);
SCCB_Write (0x6d, 0x55);
SCCB_Write (0x6e, 0x11);
SCCB_Write (0x6f, 0x9e);//0x9e for advance AWB
SCCB_Write (0x6a, 0x40);
SCCB_Write (0x01, 0x40);
SCCB_Write (0x02, 0x40);
SCCB_Write (0x13, 0xe7);
SCCB_Write (0x15, 0x00);
SCCB_Write (0x4f, 0x80);
SCCB_Write (0x50, 0x80);
SCCB_Write (0x51, 0x00);
SCCB_Write (0x52, 0x22);
SCCB_Write (0x53, 0x5e);
SCCB_Write (0x54, 0x80);
SCCB_Write (0x58, 0x9e);
SCCB_Write (0x41, 0x08);
SCCB_Write (0x3f, 0x00);
SCCB_Write (0x75, 0x05);
SCCB_Write (0x76, 0xe1);
SCCB_Write (0x4c, 0x00);
SCCB_Write (0x77, 0x01);
SCCB_Write (0x3d, 0xc2); //0xc0,
SCCB_Write (0x4b, 0x09);
SCCB_Write (0xc9, 0x60);
SCCB_Write (0x41, 0x38);
SCCB_Write (0x56, 0x40);//0x40, change according to Jim's request
SCCB_Write (0x34, 0x11);
SCCB_Write (0x3b, 0x00);//0x00,//0x02,
SCCB_Write (0xa4, 0x88);//0x88,
SCCB_Write (0x96, 0x00);
SCCB_Write (0x97, 0x30);
SCCB_Write (0x98, 0x20);
SCCB_Write (0x99, 0x30);
SCCB_Write (0x9a, 0x84);
SCCB_Write (0x9b, 0x29);
SCCB_Write (0x9c, 0x03);
SCCB_Write (0x9d, 0x4c);
SCCB_Write (0x9e, 0x3f);
SCCB_Write (0x78, 0x04);
SCCB_Write (0x79, 0x01);
SCCB_Write (0xc8, 0xf0);
SCCB_Write (0x79, 0x0f);
SCCB_Write (0xc8, 0x00);
SCCB_Write (0x79, 0x10);
SCCB_Write (0xc8, 0x7e);
SCCB_Write (0x79, 0x0a);
SCCB_Write (0xc8, 0x80);
SCCB_Write (0x79, 0x0b);
SCCB_Write (0xc8, 0x01);
SCCB_Write (0x79, 0x0c);
SCCB_Write (0xc8, 0x0f);
SCCB_Write (0x79, 0x0d);
SCCB_Write (0xc8, 0x20);
SCCB_Write (0x79, 0x09);
SCCB_Write (0xc8, 0x80);
SCCB_Write (0x79, 0x02);
SCCB_Write (0xc8, 0xc0);
SCCB_Write (0x79, 0x03);
SCCB_Write (0xc8, 0x40);
SCCB_Write (0x79, 0x05);
SCCB_Write (0xc8, 0x30);
SCCB_Write (0x79, 0x26);
SCCB_Write (0x09, 0x03);
SCCB_Write (0x55, 0x00);
SCCB_Write (0x56, 0x40);
SCCB_Write (0x3b, 0x42);
Bebek simdiden hayirli olmus. (Bebek aynen soyle demistir, baba get ote kac aydir beceremedim ben gelince hallederim)
Allah anali babali buyutsun.