ov5642.cpp

00001 
00002 #include "mbed.h"
00003 #include "i2cconfig.h"
00004 #include "ov5642_regs.h"
00005 #include "ov5642.h"
00006 #include "camera_app.h"
00007 #include "app_config.h"
00008 
00009 
00010 extern DCMI_HandleTypeDef phdcmi;
00011  
00012 void check_camId(){
00013     uint8_t vid, pid;
00014     
00015     rdSensorReg16_8(OV5642_CHIPID_HIGH, &vid);
00016     rdSensorReg16_8(OV5642_CHIPID_LOW, &pid);
00017     if((vid != 0x56) || (pid != 0x42)){
00018         printf("Can't find OV5642 module! vid 0x%x pid 0x%x\r\n",vid, pid);      
00019         HAL_DCMI_MspDeInit (&phdcmi);
00020         while(1);
00021     }else{
00022       printf("OV5642 detected\r\n");
00023     }
00024 }
00025 void init_cam(){
00026 #if defined OV5642_CAM
00027             wrSensorReg16_8(0x3008, 0x80);
00028             wait_ms(100);
00029 #ifdef ENABLE_JPEG             
00030             wrSensorRegs16_8(ov5642_dvp_fmt_global_init); 
00031             wait_ms(100);
00032             OV5642_set_JPEG_size(); 
00033 //            wrSensorRegs16_8(ov5642_dvp_fmt_jpeg_vga);
00034             wrSensorRegs16_8(ov5642_dvp_fmt_jpeg_qvga); 
00035             wrSensorReg16_8(0x4407,0x0C);                
00036 #else                        
00037             wrSensorRegs16_8(OV5642_RGB_QVGA);
00038             rdSensorReg16_8(0x3818, &reg_val);
00039             wrSensorReg16_8(0x3818, (reg_val | 0x60) & 0xff);
00040             rdSensorReg16_8(0x3621, &reg_val);
00041             wrSensorReg16_8(0x3621, reg_val & 0xdf);
00042             
00043 #endif//ENABLE_JPEG 
00044 #endif//OV5642_CAM                  
00045 }
00046 
00047 void OV5642_set_JPEG_size(){
00048     
00049     wrSensorRegs16_8(ov5642_dvp_fmt_global_init);
00050     wait_ms(100);        
00051     wrSensorRegs16_8(ov5642_dvp_fmt_jpeg_qvga);
00052     wrSensorReg16_8(0x4407, 0x04);
00053     wrSensorReg16_8(0x3818, 0xA8); 
00054     wrSensorReg16_8(0x3621, 0x10); 
00055     wrSensorReg16_8(0x3801, 0x98);
00056     wait_ms(100); 
00057 }
00058 
00059 //I2C Write 8bit address, 8bit data
00060 uint8_t wrSensorReg8_8(int regID, int regDat)
00061 {
00062     uint8_t buff[20];
00063     buff[0] = regID;
00064     buff[1] = regDat;
00065     I2CBufferWrite(sensor_addr,buff,2, I2C_SEND_STOP);
00066 
00067 //    wait_ms(1);
00068   return(1);
00069 }
00070 
00071 //I2C Read 8bit address, 8bit data
00072 uint8_t rdSensorReg8_8(uint8_t regID, uint8_t* regDat)
00073 {
00074     uint8_t buff[20];
00075     buff[0] = regID;
00076     
00077     I2CBufferWrite(sensor_addr,buff,1, I2C_SEND_STOP);
00078     I2CBufferRead(sensor_addr+1,buff,1, I2C_SEND_STOP);
00079     *regDat = buff[0];
00080 
00081  //   wait_ms(1);
00082   return(1);
00083 }
00084 
00085 //I2C Write 8bit address, 16bit data
00086 uint8_t wrSensorReg8_16(int regID, int regDat)
00087 {
00088     uint8_t buff[20];
00089     buff[0] = regID;
00090     buff[1] = regDat >> 8;
00091     buff[2] = regDat & 0x00FF;
00092     I2CBufferWrite(sensor_addr,buff,3, I2C_SEND_STOP);
00093 
00094 //    wait_ms(1);
00095     return(1);
00096 }
00097 
00098 //I2C Read 8bit address, 16bit data
00099 uint8_t rdSensorReg8_16(uint8_t regID, uint16_t* regDat)
00100 {
00101 //    uint8_t temp;
00102     uint8_t buff[20];
00103     buff[0] = regID;
00104     
00105     I2CBufferWrite(sensor_addr,buff,1, I2C_SEND_STOP);
00106     I2CBufferRead(sensor_addr+1,buff, 2, I2C_SEND_STOP);
00107     *regDat = (buff[0] << 8) | buff[1];
00108 
00109 //    wait_ms(1);
00110     return(1);
00111 }
00112 
00113 //I2C Write 16bit address, 8bit data
00114 uint8_t wrSensorReg16_8(int regID, int regDat)
00115 {
00116     uint8_t buff[20];
00117     buff[0] = regID >> 8;
00118     buff[1] = regID & 0x00FF;
00119     buff[2] = regDat;
00120     I2CBufferWrite(sensor_addr,buff,3, I2C_SEND_STOP);
00121 
00122 //    wait_ms(1);
00123   return(1);
00124 }
00125 
00126 //I2C Read 16bit address, 8bit data
00127 uint8_t rdSensorReg16_8(uint16_t regID, uint8_t* regDat)
00128 {
00129     uint8_t buff[20];
00130     buff[0] = regID >> 8;
00131     buff[1] = regID & 0x00FF;
00132     I2CBufferWrite(sensor_addr,buff,2, I2C_SEND_STOP);
00133     I2CBufferRead(sensor_addr+1,buff, 1, I2C_SEND_STOP);
00134     *regDat = buff[0];
00135 
00136 //    wait_ms(1);
00137   return(1);
00138 }
00139 
00140 //I2C Write 16bit address, 16bit data
00141 uint8_t wrSensorReg16_16(int regID, int regDat)
00142 {
00143     uint8_t buff[20];
00144     buff[0] = regID >> 8;
00145     buff[1] = regID & 0x00FF;
00146     buff[2] = regDat >> 8;
00147     buff[3] = regID & 0x00FF;
00148     I2CBufferWrite(sensor_addr,buff,4, I2C_SEND_STOP);
00149 
00150 //    wait_ms(1);
00151   return(1);
00152 }
00153 
00154 //I2C Read 16bit address, 16bit data
00155 uint8_t rdSensorReg16_16(uint16_t regID, uint16_t* regDat)
00156 {
00157 //    uint8_t temp;
00158     uint8_t buff[20];
00159     buff[0] = regID >> 8;
00160     buff[1] = regID & 0x00FF;
00161     I2CBufferWrite(sensor_addr,buff,2, I2C_SEND_STOP);
00162     I2CBufferRead(sensor_addr+1,buff, 1, I2C_SEND_STOP);
00163     *regDat = (buff[0] << 8) | buff[1];
00164 
00165 //    wait_ms(1);
00166   return(1);
00167 }
00168 
00169 //I2C Array Write 8bit address, 8bit data
00170 int wrSensorRegs8_8(const struct sensor_reg reglist[])
00171 {
00172 //    int err = 0;
00173     uint16_t reg_addr = 0;
00174     uint16_t reg_val = 0;
00175     const struct sensor_reg *next = reglist;
00176     
00177     while ((reg_addr != 0xff) | (reg_val != 0xff))
00178     {       
00179         reg_addr = next->reg;
00180         reg_val = next->val;
00181         wrSensorReg8_8(reg_addr, reg_val);
00182     next++;
00183         
00184     } 
00185     
00186     return 1;
00187 }
00188 
00189 //I2C Array Write 8bit address, 16bit data
00190 int wrSensorRegs8_16(const struct sensor_reg reglist[])
00191 {
00192 //    int err = 0;
00193     
00194     uint32_t reg_addr = 0;
00195     uint32_t reg_val = 0;
00196     const struct sensor_reg *next = reglist;
00197     
00198     while ((reg_addr != 0xff) | (reg_val != 0xffff))
00199     {       
00200         reg_addr = next->reg;
00201         reg_val = next->val;
00202         wrSensorReg8_16(reg_addr, reg_val);
00203         //  if (!err)
00204         //return err;
00205         next++;
00206     }  
00207     
00208     return 1;
00209 }
00210 
00211 //I2C Array Write 16bit address, 8bit data
00212 int wrSensorRegs16_8(const struct sensor_reg reglist[])
00213 {
00214 //    int err = 0;
00215     
00216     uint32_t reg_addr = 0;
00217     uint8_t reg_val = 0;
00218     const struct sensor_reg *next = reglist;
00219     
00220     while ((reg_addr != 0xffff) | (reg_val != 0xff))
00221     {       
00222         reg_addr = next->reg;
00223         reg_val = next->val;
00224         wrSensorReg16_8(reg_addr, reg_val);
00225         //if (!err)
00226         //return err;
00227        next++;
00228     } 
00229     
00230     return 1;
00231 }
00232 
00233 //I2C Array Write 16bit address, 16bit data
00234 int wrSensorRegs16_16(const struct sensor_reg reglist[])
00235 {
00236 //    int err = 0;
00237     
00238     uint32_t reg_addr = 0;
00239     uint32_t reg_val = 0;
00240     const struct sensor_reg *next = reglist;
00241     
00242     while ((reg_addr != 0xffff) | (reg_val != 0xffff))
00243     {       
00244         reg_addr = next->reg;
00245         reg_val = next->val;
00246         wrSensorReg16_16(reg_addr, reg_val);
00247         //if (!err)
00248         //   return err;
00249        next++;
00250     } 
00251     
00252     return 1;
00253 }
00254 
00255 
00256