David Fletcher
TI's CC3100 websocket camera demo with Arducam mini ov5642 and freertos. Should work with other M3's. Work in progress test demo.
Embed:
(wiki syntax)
Show/hide line numbers
ArduCAM.cpp
00001 /* 00002 ArduCAM.cpp - Arduino library support for CMOS Image Sensor 00003 Copyright (C)2011-2015 ArduCAM.com. All right reserved 00004 00005 Basic functionality of this library are based on the demo-code provided by 00006 ArduCAM.com. You can find the latest version of the library at 00007 http://www.ArduCAM.com 00008 00009 Now supported controllers: 00010 - OV7670 00011 - MT9D111 00012 - OV7675 00013 - OV2640 00014 - OV3640 00015 - OV5642 00016 - OV7660 00017 - OV7725 00018 - MT9M112 00019 - MT9V111 00020 - OV5640 00021 - MT9M001 00022 00023 We will add support for many other sensors in next release. 00024 00025 Supported MCU platform 00026 - Theoretically support all Arduino families 00027 - Arduino UNO R3 (Tested) 00028 - Arduino MEGA2560 R3 (Tested) 00029 - Arduino Leonardo R3 (Tested) 00030 - Arduino Nano (Tested) 00031 - Arduino DUE (Tested) 00032 - Arduino Yun (Tested) 00033 - Raspberry Pi (Tested) 00034 00035 If you make any modifications or improvements to the code, I would appreciate 00036 that you share the code with me so that I might include it in the next release. 00037 I can be contacted through http://www.ArduCAM.com 00038 00039 This library is free software; you can redistribute it and/or 00040 modify it under the terms of the GNU Lesser General Public 00041 License as published by the Free Software Foundation; either 00042 version 2.1 of the License, or (at your option) any later version. 00043 00044 This library is distributed in the hope that it will be useful, 00045 but WITHOUT ANY WARRANTY; without even the implied warranty of 00046 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00047 Lesser General Public License for more details. 00048 00049 You should have received a copy of the GNU Lesser General Public 00050 License along with this library; if not, write to the Free Software 00051 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 00052 */ 00053 00054 /*------------------------------------ 00055 Revision History: 00056 2012/09/20 V1.0.0 by Lee first release 00057 2012/10/23 V1.0.1 by Lee Resolved some timing issue for the Read/Write Register 00058 2012/11/29 V1.1.0 by Lee Add support for MT9D111 sensor 00059 2012/12/13 V1.2.0 by Lee Add support for OV7675 sensor 00060 2012/12/28 V1.3.0 by Lee Add support for OV2640,OV3640,OV5642 sensors 00061 2013/02/26 V2.0.0 by Lee New Rev.B shield hardware, add support for FIFO control 00062 and support Mega1280/2560 boards 00063 2013/05/28 V2.1.0 by Lee Add support all drawing functions derived from UTFT library 00064 2013/08/24 V3.0.0 by Lee Support ArudCAM shield Rev.C hardware, features SPI interface and low power mode. 00065 Support almost all series of Arduino boards including DUE. 00066 2014/02/06 V3.0.1 by Lee Minor change to the library, fixed some bugs, add self test code to the sketches for easy debugging. 00067 2014/03/09 V3.1.0 by Lee Add the more impressive example sketches. 00068 Optimise the OV5642 settings, improve image quality. 00069 Add live preview before JPEG capture. 00070 Add play back photos one by one after BMP capture. 00071 2014/05/01 V3.1.1 by Lee Minor changes to add support Arduino IDE for linux distributions. 00072 2014/09/30 V3.2.0 by Lee Improvement on OV5642 camera dirver. 00073 2014/10/06 V3.3.0 by Lee Add OV7660,OV7725 camera support. 00074 2015/02/27 V3.4.0 by Lee Add the support for Arduino Yun board, update the latest UTFT library for ArduCAM. 00075 2015/06/09 V3.4.1 by Lee Minor changes and add some comments 00076 2015/06/19 V3.4.2 by Lee Add support for MT9M112 camera. 00077 2015/06/20 V3.4.3 by Lee Add support for MT9V111 camera. 00078 2015/06/22 V3.4.4 by Lee Add support for OV5640 camera. 00079 2015/06/22 V3.4.5 by Lee Add support for MT9M001 camera. 00080 --------------------------------------*/ 00081 00082 #include "ArduCAM.h" 00083 #include "cli_uart.h" 00084 #include "HttpDebug.h" 00085 #include "memorysaver.h" 00086 00087 ArduCAM::ArduCAM(uint8_t model, PinName cam_cs, SPI cam_spi, I2C cam_i2c) 00088 :_cam_cs(cam_cs), _cam_spi(cam_spi), _cam_i2c(cam_i2c) 00089 { 00090 _cam_spi.format(8,0); 00091 _cam_spi.frequency(8000000); 00092 _cam_i2c.frequency(100000); 00093 _cam_cs = 1; 00094 00095 // flush_fifo(); 00096 00097 sensor_model=model; 00098 switch(sensor_model) 00099 { 00100 case OV7660: 00101 case OV7670: 00102 case OV7675: 00103 case OV7725: 00104 sensor_addr = 0x42; 00105 break; 00106 case MT9D111_A: //Standard MT9D111 module 00107 sensor_addr = 0xba; 00108 break; 00109 case MT9D111_B: //Flex MT9D111 AF module 00110 sensor_addr = 0x90; 00111 break; 00112 case MT9M112: 00113 sensor_addr = 0x90; 00114 break; 00115 case MT9M001: 00116 sensor_addr = 0xba; 00117 break; 00118 case OV3640: 00119 case OV5640: 00120 case OV5642: 00121 sensor_addr = 0x78; 00122 break; 00123 case OV2640: 00124 case OV9650: 00125 case OV9655: 00126 sensor_addr = 0x60; 00127 break; 00128 case MT9V111: 00129 sensor_addr = 0xB8; 00130 break; 00131 default: 00132 sensor_addr = 0x42; 00133 break; 00134 } 00135 } 00136 00137 ArduCAM::~ArduCAM() 00138 { 00139 00140 } 00141 00142 //Assert CS signal 00143 void ArduCAM::cs_low(void) 00144 { 00145 _cam_cs = 0; 00146 } 00147 00148 //Disable CS signal 00149 void ArduCAM::cs_high(void) 00150 { 00151 _cam_cs = 1; 00152 } 00153 00154 //Set corresponding bit 00155 void ArduCAM::set_bit(uint8_t addr, uint8_t bit) 00156 { 00157 uint8_t temp; 00158 temp = read_reg(addr); 00159 write_reg(addr, temp | bit); 00160 00161 } 00162 00163 //Clear corresponding bit 00164 void ArduCAM::clear_bit(uint8_t addr, uint8_t bit) 00165 { 00166 uint8_t temp; 00167 temp = read_reg(addr); 00168 write_reg(addr, temp & (~bit)); 00169 } 00170 00171 //Get corresponding bit status 00172 uint8_t ArduCAM::get_bit(uint8_t addr, uint8_t bit) 00173 { 00174 uint8_t temp; 00175 temp = read_reg(addr); 00176 temp = temp & bit; 00177 return temp; 00178 } 00179 00180 //Set ArduCAM working mode 00181 //MCU2LCD_MODE: MCU writes the LCD screen GRAM 00182 //CAM2LCD_MODE: Camera takes control of the LCD screen 00183 //LCD2MCU_MODE: MCU read the LCD screen GRAM 00184 void ArduCAM::set_mode(uint8_t mode) 00185 { 00186 switch(mode) 00187 { 00188 case MCU2LCD_MODE: 00189 write_reg(ARDUCHIP_MODE, MCU2LCD_MODE); 00190 break; 00191 case CAM2LCD_MODE: 00192 write_reg(ARDUCHIP_MODE, CAM2LCD_MODE); 00193 break; 00194 case LCD2MCU_MODE: 00195 write_reg(ARDUCHIP_MODE, LCD2MCU_MODE); 00196 break; 00197 default: 00198 write_reg(ARDUCHIP_MODE, MCU2LCD_MODE); 00199 break; 00200 } 00201 } 00202 00203 //Low level SPI write operation 00204 int ArduCAM::bus_write(int address, int value) { 00205 // take the SS pin low to select the chip: 00206 cs_low(); 00207 // send in the address and value via SPI: 00208 _cam_spi.write(address); 00209 _cam_spi.write(value); 00210 // take the SS pin high to de-select the chip: 00211 cs_high(); 00212 00213 return 0; 00214 } 00215 00216 //Low level SPI read operation 00217 uint8_t ArduCAM::bus_read(int address) { 00218 uint8_t value = 0; 00219 // take the SS pin low to select the chip: 00220 cs_low(); 00221 // send in the address and value via SPI: 00222 // printf("addr = 0x%x\r\n",address); 00223 _cam_spi.write(address); 00224 value = _cam_spi.write(0x00); 00225 // take the SS pin high to de-select the chip: 00226 cs_high(); 00227 return value; 00228 } 00229 00230 //Write ArduChip internal registers 00231 void ArduCAM::write_reg(uint8_t addr, uint8_t data) 00232 { 00233 bus_write(addr | 0x80, data); 00234 } 00235 00236 //Read ArduChip internal registers 00237 uint8_t ArduCAM::read_reg(uint8_t addr) 00238 { 00239 uint8_t data; 00240 data = bus_read(addr);//(addr & 0x7F) 00241 // printf("len = 0x%x\r\n",data); 00242 return data; 00243 } 00244 00245 //Reset the FIFO pointer to ZERO 00246 void ArduCAM::flush_fifo(void) 00247 { 00248 write_reg(ARDUCHIP_FIFO, FIFO_CLEAR_MASK); 00249 } 00250 00251 //Send capture command 00252 void ArduCAM::start_capture(void) 00253 { 00254 write_reg(ARDUCHIP_FIFO, FIFO_START_MASK); 00255 } 00256 00257 //Clear FIFO Complete flag 00258 void ArduCAM::clear_fifo_flag(void) 00259 { 00260 write_reg(ARDUCHIP_FIFO, FIFO_CLEAR_MASK); 00261 } 00262 00263 //Read FIFO single 00264 uint8_t ArduCAM::read_fifo(void) 00265 { 00266 uint8_t data; 00267 data = bus_read(SINGLE_FIFO_READ); 00268 return data; 00269 } 00270 00271 //Read Write FIFO length 00272 //Support ArduCAM Mini only 00273 uint32_t ArduCAM::read_fifo_length(void) 00274 { 00275 uint32_t len1,len2,len3=0; 00276 uint32_t length=0; 00277 len1 = read_reg(FIFO_SIZE1); 00278 len2 = read_reg(FIFO_SIZE2); 00279 len3 = read_reg(FIFO_SIZE3) & 0x07; 00280 length = ((len3 << 16) | (len2 << 8) | len1);// & 0x07ffff; 00281 return length; 00282 } 00283 00284 //Send read fifo burst command 00285 //Support ArduCAM Mini only 00286 void ArduCAM::set_fifo_burst() 00287 { 00288 // _cam_cs = 0; 00289 _cam_spi.write(BURST_FIFO_READ); 00290 // _cam_cs = 1; 00291 } 00292 00293 //I2C Write 8bit address, 8bit data 00294 uint8_t ArduCAM::wrSensorReg8_8(int regID, int regDat) 00295 { 00296 uint8_t buff[20]; 00297 buff[0] = regID; 00298 buff[1] = regDat; 00299 _cam_i2c.write(sensor_addr,(char*)buff,2); 00300 00301 // wait_ms(1); 00302 return(1); 00303 } 00304 00305 //I2C Read 8bit address, 8bit data 00306 uint8_t ArduCAM::rdSensorReg8_8(uint8_t regID, uint8_t* regDat) 00307 { 00308 uint8_t buff[20]; 00309 buff[0] = regID; 00310 00311 _cam_i2c.write(sensor_addr,(char*)buff,1); 00312 _cam_i2c.read(sensor_addr+1,(char*)buff,1); 00313 *regDat = buff[0]; 00314 00315 // wait_ms(1); 00316 return(1); 00317 } 00318 00319 //I2C Write 8bit address, 16bit data 00320 uint8_t ArduCAM::wrSensorReg8_16(int regID, int regDat) 00321 { 00322 uint8_t buff[20]; 00323 buff[0] = regID; 00324 buff[1] = regDat >> 8; 00325 buff[2] = regDat & 0x00FF; 00326 _cam_i2c.write(sensor_addr,(char*)buff,3); 00327 00328 // wait_ms(1); 00329 return(1); 00330 } 00331 00332 //I2C Read 8bit address, 16bit data 00333 uint8_t ArduCAM::rdSensorReg8_16(uint8_t regID, uint16_t* regDat) 00334 { 00335 // uint8_t temp; 00336 uint8_t buff[20]; 00337 buff[0] = regID; 00338 00339 _cam_i2c.write(sensor_addr,(char*)buff,1); 00340 _cam_i2c.read(sensor_addr+1,(char*)buff, 2); 00341 *regDat = (buff[0] << 8) | buff[1]; 00342 00343 // wait_ms(1); 00344 return(1); 00345 } 00346 00347 //I2C Write 16bit address, 8bit data 00348 uint8_t ArduCAM::wrSensorReg16_8(int regID, int regDat) 00349 { 00350 uint8_t buff[20]; 00351 buff[0] = regID >> 8; 00352 buff[1] = regID & 0x00FF; 00353 buff[2] = regDat; 00354 _cam_i2c.write(sensor_addr,(char*)buff,3); 00355 00356 // wait_ms(1); 00357 return(1); 00358 } 00359 00360 //I2C Read 16bit address, 8bit data 00361 uint8_t ArduCAM::rdSensorReg16_8(uint16_t regID, uint8_t* regDat) 00362 { 00363 uint8_t buff[20]; 00364 buff[0] = regID >> 8; 00365 buff[1] = regID & 0x00FF; 00366 _cam_i2c.write(sensor_addr,(char*)buff,2); 00367 _cam_i2c.read(sensor_addr+1,(char*)buff, 1); 00368 *regDat = buff[0]; 00369 00370 // wait_ms(1); 00371 return(1); 00372 } 00373 00374 //I2C Write 16bit address, 16bit data 00375 uint8_t ArduCAM::wrSensorReg16_16(int regID, int regDat) 00376 { 00377 uint8_t buff[20]; 00378 buff[0] = regID >> 8; 00379 buff[1] = regID & 0x00FF; 00380 buff[2] = regDat >> 8; 00381 buff[3] = regID & 0x00FF; 00382 _cam_i2c.write(sensor_addr,(char*)buff,4); 00383 00384 // wait_ms(1); 00385 return(1); 00386 } 00387 00388 //I2C Read 16bit address, 16bit data 00389 uint8_t ArduCAM::rdSensorReg16_16(uint16_t regID, uint16_t* regDat) 00390 { 00391 // uint8_t temp; 00392 uint8_t buff[20]; 00393 buff[0] = regID >> 8; 00394 buff[1] = regID & 0x00FF; 00395 _cam_i2c.write(sensor_addr,(char*)buff,2); 00396 _cam_i2c.read(sensor_addr+1,(char*)buff, 1); 00397 *regDat = (buff[0] << 8) | buff[1]; 00398 00399 // wait_ms(1); 00400 return(1); 00401 } 00402 00403 //I2C Array Write 8bit address, 8bit data 00404 int ArduCAM::wrSensorRegs8_8(const struct sensor_reg reglist[]) 00405 { 00406 // int err = 0; 00407 uint16_t reg_addr = 0; 00408 uint16_t reg_val = 0; 00409 const struct sensor_reg *next = reglist; 00410 00411 while ((reg_addr != 0xff) | (reg_val != 0xff)) 00412 { 00413 reg_addr = next->reg; 00414 reg_val = next->val; 00415 wrSensorReg8_8(reg_addr, reg_val); 00416 next++; 00417 00418 } 00419 00420 return 1; 00421 } 00422 00423 //I2C Array Write 8bit address, 16bit data 00424 int ArduCAM::wrSensorRegs8_16(const struct sensor_reg reglist[]) 00425 { 00426 // int err = 0; 00427 00428 uint32_t reg_addr = 0; 00429 uint32_t reg_val = 0; 00430 const struct sensor_reg *next = reglist; 00431 00432 while ((reg_addr != 0xff) | (reg_val != 0xffff)) 00433 { 00434 reg_addr = next->reg; 00435 reg_val = next->val; 00436 wrSensorReg8_16(reg_addr, reg_val); 00437 // if (!err) 00438 //return err; 00439 next++; 00440 } 00441 00442 return 1; 00443 } 00444 00445 //I2C Array Write 16bit address, 8bit data 00446 int ArduCAM::wrSensorRegs16_8(const struct sensor_reg reglist[]) 00447 { 00448 // int err = 0; 00449 00450 uint32_t reg_addr = 0; 00451 uint8_t reg_val = 0; 00452 const struct sensor_reg *next = reglist; 00453 00454 while ((reg_addr != 0xffff) | (reg_val != 0xff)) 00455 { 00456 reg_addr = next->reg; 00457 reg_val = next->val; 00458 wrSensorReg16_8(reg_addr, reg_val); 00459 //if (!err) 00460 //return err; 00461 next++; 00462 } 00463 00464 return 1; 00465 } 00466 00467 //I2C Array Write 16bit address, 16bit data 00468 int ArduCAM::wrSensorRegs16_16(const struct sensor_reg reglist[]) 00469 { 00470 // int err = 0; 00471 00472 uint32_t reg_addr = 0; 00473 uint32_t reg_val = 0; 00474 const struct sensor_reg *next = reglist; 00475 00476 while ((reg_addr != 0xffff) | (reg_val != 0xffff)) 00477 { 00478 reg_addr = next->reg; 00479 reg_val = next->val; 00480 wrSensorReg16_16(reg_addr, reg_val); 00481 //if (!err) 00482 // return err; 00483 next++; 00484 } 00485 00486 return 1; 00487 } 00488 00489 void ArduCAM::OV5642_set_JPEG_size(uint8_t size) 00490 { 00491 #if defined OV5642_CAM 00492 // uint8_t reg_val; 00493 wrSensorRegs16_8(ov5642_dvp_fmt_global_init); 00494 wait_ms(100); 00495 switch(size) 00496 { 00497 case OV5642_320x240: 00498 wrSensorRegs16_8(ov5642_dvp_fmt_jpeg_qvga); 00499 wrSensorReg16_8(0x4407,0x04); 00500 wrSensorReg16_8(0x3818, 0xA8); 00501 wrSensorReg16_8(0x3621, 0x10); 00502 wrSensorReg16_8(0x3801 , 0x98); 00503 break; 00504 case OV5642_640x480: 00505 wrSensorRegs16_8(ov5642_dvp_fmt_jpeg_vga); 00506 wrSensorReg16_8(0x3818, 0xA8); 00507 wrSensorReg16_8(0x3621, 0x10); 00508 wrSensorReg16_8(0x3801 , 0x98); 00509 break; 00510 case OV5642_1280x720: 00511 wrSensorRegs16_8(ov5642_dvp_fmt_jpeg_qvga); 00512 wrSensorRegs16_8(ov5642_res_720P); 00513 wrSensorReg16_8(0x3818, 0xA8); 00514 wrSensorReg16_8(0x3621, 0x10); 00515 wrSensorReg16_8(0x3801 , 0x98); 00516 break; 00517 case OV5642_1920x1080: 00518 wrSensorRegs16_8(ov5642_dvp_fmt_jpeg_qvga); 00519 wrSensorRegs16_8(ov5642_res_1080P); 00520 wrSensorReg16_8(0x3818, 0xA8); 00521 wrSensorReg16_8(0x3621, 0x10); 00522 wrSensorReg16_8(0x3801 , 0x98); 00523 break; 00524 case OV5642_2048x1563: 00525 wrSensorRegs16_8(ov5642_dvp_fmt_jpeg_qxga); 00526 wrSensorReg16_8(0x3818, 0xA8); 00527 wrSensorReg16_8(0x3621, 0x10); 00528 wrSensorReg16_8(0x3801 , 0x98); 00529 break; 00530 case OV5642_2592x1944: 00531 wrSensorRegs16_8(ov5642_dvp_fmt_jpeg_5M); 00532 wrSensorReg16_8(0x4407,0x08); 00533 wrSensorReg16_8(0x3818, 0xA8); 00534 wrSensorReg16_8(0x3621, 0x10); 00535 wrSensorReg16_8(0x3801 , 0x98); 00536 break; 00537 default: 00538 wrSensorRegs16_8(ov5642_dvp_fmt_jpeg_qvga); 00539 break; 00540 } 00541 00542 #endif 00543 } 00544 00545 void ArduCAM::set_format(uint8_t fmt) 00546 { 00547 if(fmt == BMP){ 00548 m_fmt = BMP; 00549 printf("Format = BMP\r\n"); 00550 }else{ 00551 m_fmt = JPEG; 00552 printf("Format = JPEG\r\n"); 00553 } 00554 } 00555 00556 void ArduCAM::InitCAM() 00557 { 00558 uint8_t rtn = 0; 00559 uint8_t reg_val; 00560 switch(sensor_model) 00561 { 00562 case OV7660: 00563 { 00564 #if defined OV7660_CAM 00565 wrSensorReg8_8(0x12, 0x80); 00566 wait_ms(100); 00567 rtn = wrSensorRegs8_8(OV7660_QVGA); 00568 #endif 00569 break; 00570 } 00571 case OV7725: 00572 { 00573 #if defined OV7725_CAM 00574 wrSensorReg8_8(0x12, 0x80); 00575 wait_ms(100); 00576 rtn = wrSensorRegs8_8(OV7725_QVGA); 00577 rdSensorReg8_8(0x15,®_val); 00578 wrSensorReg8_8(0x15, (reg_val | 0x02)); 00579 #endif 00580 break; 00581 } 00582 case OV7670: 00583 { 00584 #if defined OV7670_CAM 00585 wrSensorReg8_8(0x12, 0x80); 00586 wait_ms(100); 00587 rtn = wrSensorRegs8_8(OV7670_QVGA); 00588 #endif 00589 break; 00590 } 00591 case OV7675: 00592 { 00593 #if defined OV7675_CAM 00594 wrSensorReg8_8(0x12, 0x80); 00595 wait_ms(100); 00596 rtn = wrSensorRegs8_8(OV7675_QVGA); 00597 00598 #endif 00599 break; 00600 } 00601 case MT9D111_A: 00602 case MT9D111_B: 00603 { 00604 #if defined MT9D111_CAM 00605 wrSensorRegs8_16(MT9D111_QVGA_30fps); 00606 wait_ms(1000); 00607 wrSensorReg8_16(0x97, 0x0020); 00608 wrSensorReg8_16(0xf0, 0x00); 00609 wrSensorReg8_16(0x21, 0x8403); //Mirror Column 00610 wrSensorReg8_16(0xC6, 0xA103);//SEQ_CMD 00611 wrSensorReg8_16(0xC8, 0x0005); //SEQ_CMD 00612 #endif 00613 break; 00614 00615 } 00616 case OV5642: 00617 { 00618 #if defined OV5642_CAM 00619 wrSensorReg16_8(0x3008, 0x80); 00620 00621 wait_ms(100); 00622 if(m_fmt == JPEG) 00623 { 00624 wrSensorRegs16_8(ov5642_dvp_fmt_global_init); 00625 wait_ms(100); 00626 // OV5642_set_JPEG_size(OV5642_640x480); 00627 OV5642_set_JPEG_size(OV5642_320x240); 00628 // wrSensorRegs16_8(ov5642_dvp_fmt_jpeg_vga); 00629 // wrSensorRegs16_8(ov5642_dvp_fmt_jpeg_qvga); 00630 wrSensorReg16_8(0x4407,0x0C); 00631 00632 } 00633 else 00634 { 00635 wrSensorRegs16_8(OV5642_RGB_QVGA); 00636 rdSensorReg16_8(0x3818,®_val); 00637 wrSensorReg16_8(0x3818, (reg_val | 0x60) & 0xff); 00638 rdSensorReg16_8(0x3621,®_val); 00639 wrSensorReg16_8(0x3621, reg_val & 0xdf); 00640 } 00641 00642 #endif 00643 break; 00644 } 00645 case OV3640: 00646 { 00647 #if defined OV3640_CAM 00648 rtn = wrSensorRegs16_8(OV3640_QVGA); 00649 #endif 00650 break; 00651 } 00652 case OV2640: 00653 { 00654 #if defined OV2640_CAM 00655 wrSensorReg8_8(0xff, 0x01); 00656 wrSensorReg8_8(0x12, 0x80); 00657 wait_ms(100); 00658 if(m_fmt == JPEG) 00659 { 00660 wrSensorRegs8_8(OV2640_JPEG_INIT); 00661 wrSensorRegs8_8(OV2640_YUV422); 00662 wrSensorRegs8_8(OV2640_JPEG); 00663 wrSensorReg8_8(0xff, 0x01); 00664 wrSensorReg8_8(0x15, 0x00); 00665 wrSensorRegs8_8(OV2640_320x240_JPEG); 00666 //wrSensorReg8_8(0xff, 0x00); 00667 //wrSensorReg8_8(0x44, 0x32); 00668 } 00669 else 00670 { 00671 wrSensorRegs8_8(OV2640_QVGA); 00672 } 00673 #endif 00674 break; 00675 } 00676 case OV9655: 00677 { 00678 00679 break; 00680 } 00681 case MT9M112: 00682 { 00683 #if defined MT9M112_CAM 00684 wrSensorRegs8_16(MT9M112_QVGA); 00685 #endif 00686 break; 00687 } 00688 case MT9V111: 00689 { 00690 #if defined MT9V111_CAM 00691 //Reset sensor core 00692 wrSensorReg8_16(0x01, 0x04); 00693 wrSensorReg8_16(0x0D, 0x01); 00694 wrSensorReg8_16(0x0D, 0x00); 00695 //Reset IFP 00696 wrSensorReg8_16(0x01, 0x01); 00697 wrSensorReg8_16(0x07, 0x01); 00698 wrSensorReg8_16(0x07, 0x00); 00699 wait_ms(100); 00700 wrSensorRegs8_16(MT9V111_QVGA); 00701 //wait_ms(1000); 00702 wrSensorReg8_16(0x97, 0x0020); 00703 wrSensorReg8_16(0xf0, 0x00); 00704 wrSensorReg8_16(0x21, 0x8403); //Mirror Column 00705 wrSensorReg8_16(0xC6, 0xA103);//SEQ_CMD 00706 wrSensorReg8_16(0xC8, 0x0005); //SEQ_CMD 00707 #endif 00708 break; 00709 } 00710 case OV5640: 00711 { 00712 #if defined OV5640_CAM 00713 wrSensorReg16_8(0x3008, 0x80); 00714 wait_ms(100); 00715 wrSensorRegs16_8(OV5640YUV_Sensor_Dvp_Init); 00716 wrSensorRegs16_8(ov5640_vga_preview); 00717 wrSensorRegs16_8(OV5640_RGB_QVGA); 00718 #endif 00719 break; 00720 } 00721 case MT9M001: 00722 { 00723 #if defined MT9M001_CAM 00724 wrSensorRegs8_16(MT9M001_QVGA_30fps); 00725 #endif 00726 break; 00727 } 00728 default: 00729 00730 break; 00731 } 00732 }
Generated on Wed Jul 13 2022 15:58:45 by
1.7.2