标题: ov2640 IO口读取驱动源码 [打印本页]
作者: dbh625    时间: 2018-10-28 20:33
标题: ov2640 IO口读取驱动源码
ov2640 IO口读取驱动源码，具体看压缩包。

单片机源程序如下:
  1. /*
  2. * OV2640 driver.
  3. *
  4. */
  5. #include <config.h>
  6. #ifdef CAM2640
  7. #include <devices/ov2640.h>
  8. #include <devices/sensor.h>

  10. #include "ov2640_regs.h"


  13. const static uint8_t OV2640_AUTOEXPOSURE_LEVEL0[]=
  14. {
  15.         0xFF,        0x01,        0xff,
  16.         0x24,        0x20,        0xff,
  17.         0x25,        0x18,        0xff,
  18.         0x26,        0x60,        0xff,
  19.         0x00,        0x00,        0x00
  20. };

  22. const static uint8_t OV2640_AUTOEXPOSURE_LEVEL1[]=
  23. {
  24.         0xFF,        0x01,        0xff,
  25.         0x24,        0x34,        0xff,
  26.         0x25,        0x1c,        0xff,
  27.         0x26,        0x70,        0xff,
  28.         0x00,        0x00,        0x00
  29. };
  30. const static uint8_t OV2640_AUTOEXPOSURE_LEVEL2[]=
  31. {
  32.         0xFF,        0x01,        0xff,
  33.         0x24,        0x3e,        0xff,
  34.         0x25,        0x38,        0xff,
  35.         0x26,        0x81,        0xff,
  36.         0x00,        0x00,        0x00
  37. };
  38. const static uint8_t OV2640_AUTOEXPOSURE_LEVEL3[]=
  39. {
  40.         0xFF,        0x01,        0xff,
  41.         0x24,        0x48,        0xff,
  42.         0x25,        0x40,        0xff,
  43.         0x26,        0x81,        0xff,
  44.         0x00,        0x00,        0x00
  45. };
  46. const static uint8_t OV2640_AUTOEXPOSURE_LEVEL4[]=
  47. {
  48.         0xFF,        0x01,        0xff,
  49.         0x24,        0x58,        0xff,
  50.         0x25,        0x50,        0xff,
  51.         0x26,        0x92,        0xff,
  52.         0x00,        0x00,        0x00
  53. };

  55. static void SCCB_WriteRegs(sensor_t *sensor, const uint8_t * pbuf)
  56. {
  57.         uint8_t reg_addr;
  58.         uint8_t reg_data;
  59.    
  60.    
  61.         if (sensor == NULL) {
  62.                 return;
  63.         }
  64.    
  65.    
  66.     while(1)
  67.         {
  68.                 if((*pbuf == 0) && (*(pbuf + 1) == 0))
  69.                 {
  70.                         break;
  71.                 }
  72.                 else
  73.                 {
  74.             reg_addr = *pbuf++;
  75.             reg_data = *pbuf++;
  76.                         sal_fiic_write_slave_std(sensor->iic_dev, OV2640_IIC_ADDR, reg_data, reg_addr);
  77.                 }
  78.         }
  79. }

  81. static int set_auto_exposure_level(sensor_t *sensor, int level)
  82. {
  83.         if (sensor == NULL) {
  84.                 return SAL_ERR_P_NULL;
  85.         }

  87.         switch (level) {
  88.                 case 0:
  89.                         SCCB_WriteRegs(sensor, OV2640_AUTOEXPOSURE_LEVEL0);
  90.                         break;
  91.                 case 1:
  92.                         SCCB_WriteRegs(sensor, OV2640_AUTOEXPOSURE_LEVEL1);
  93.                         break;
  94.                 case 2:
  95.                         SCCB_WriteRegs(sensor, OV2640_AUTOEXPOSURE_LEVEL2);
  96.                         break;
  97.                 case 3:
  98.                         SCCB_WriteRegs(sensor, OV2640_AUTOEXPOSURE_LEVEL3);
  99.                         break;
  100.                 case 4:
  101.                         SCCB_WriteRegs(sensor, OV2640_AUTOEXPOSURE_LEVEL4);
  102.                         break;
  103.                 default:
  104.                         SCCB_WriteRegs(sensor, OV2640_AUTOEXPOSURE_LEVEL0);
  105.                         break;
  106.         }

  108.         return 0;
  109. }

  111. static int probe(sensor_t *sensor)
  112. {
  113.     if (sensor == NULL) {
  114.         return SAL_ERR_P_NULL;
  115.     }
  116.    
  117.     sal_fiic_read_slave_std(sensor->iic_dev, OV2640_IIC_ADDR, OV_CHIP_ID, &sensor->chip_id);
  118.    
  119.     if (sensor->chip_id == OV2640_ID) {
  120.         sal_info("OV2640 probe OK, OV2640 ID = 0x%02x.\r\n", sensor->chip_id);
  121.         sensor->slv_addr = OV2640_IIC_ADDR;
  122.         return SAL_OK;
  123.     }
  124.    
  125.     sal_err("OV2640 not found! chip_id read: %02x.\r\n", sensor->chip_id);
  126.     return SAL_ERR;
  127. }

  129. static int reset(sensor_t *sensor)
  130. {
  131.         if (sensor == NULL) {
  132.                 return SAL_ERR_P_NULL;
  133.         }

  135.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, OV2640_DSP_RA_DLMT, 0x01);
  136.     sensor->iic_dev->delay_us(2);
  137.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, OV2640_SENSOR_COM7, 0x80);
  138.     sensor->iic_dev->delay_us(2);
  139.         return 0;
  140. }

  142. static int set_bandw (sensor_t *sensor, uint8_t black_white)
  143. {
  144.         if (sensor == NULL) {
  145.                 return SAL_ERR_P_NULL;
  146.         }

  148.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0xff, 0x00);
  149.     sensor->iic_dev->delay_us(2);
  150.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7c, 0x00);
  151.     sensor->iic_dev->delay_us(2);
  152.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, black_white);
  153.     sensor->iic_dev->delay_us(2);
  154.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7c, 0x05);
  155.     sensor->iic_dev->delay_us(2);
  156.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, 0x80);
  157.     sensor->iic_dev->delay_us(2);
  158.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, 0x80);
  159.     sensor->iic_dev->delay_us(2);

  161.         return SAL_OK;
  162. }

  164. static int set_auto_whitebal(sensor_t *sensor, int enable)
  165. {
  166. #define CTRL1               0xC3
  167. #define CTRL1_AWB           0x08 /* Enable AWB */

  169.     uint8_t reg;
  170.     int ret = SAL_OK;
  171.     sal_fiic_read_slave_std(sensor->iic_dev, sensor->slv_addr, 0xFF, ®);
  172.     sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0xFF, reg & (~0x01));
  173.     sal_fiic_read_slave_std(sensor->iic_dev, sensor->slv_addr, CTRL1, ®);
  174.     ret = sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, CTRL1, (reg & (~CTRL1_AWB)) | ((enable != 0) ? CTRL1_AWB : 0));

  176.     return ret;
  177. }

  179. static int set_color_effects (sensor_t *sensor, uint8_t value1, uint8_t value2)
  180. {
  181.         if (sensor == NULL) {
  182.                 return SAL_ERR_P_NULL;
  183.         }

  185.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0xff, 0x00);
  186.     sensor->iic_dev->delay_us(2);
  187.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7c, 0x00);
  188.     sensor->iic_dev->delay_us(2);
  189.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, 0x18);
  190.     sensor->iic_dev->delay_us(2);
  191.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7c, 0x05);
  192.     sensor->iic_dev->delay_us(2);
  193.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, value1);
  194.     sensor->iic_dev->delay_us(2);
  195.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, value2);
  196.     sensor->iic_dev->delay_us(2);

  198.         return SAL_OK;
  199. }

  201. static int set_contrast (sensor_t *sensor, uint8_t value1, uint8_t value2)
  202. {
  203.         if (sensor == NULL) {
  204.                 return SAL_ERR_P_NULL;
  205.         }

  207.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0xff, 0x00);
  208.     sensor->iic_dev->delay_us(2);
  209.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7c, 0x00);
  210.     sensor->iic_dev->delay_us(2);
  211.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, 0x04);
  212.     sensor->iic_dev->delay_us(2);
  213.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7c, 0x07);
  214.     sensor->iic_dev->delay_us(2);
  215.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, 0x20);
  216.     sensor->iic_dev->delay_us(2);
  217.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, value1);
  218.     sensor->iic_dev->delay_us(2);
  219.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, value2);
  220.     sensor->iic_dev->delay_us(2);
  221.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, 0x06);
  222.     sensor->iic_dev->delay_us(2);

  224.         return SAL_OK;
  225. }

  227. static int set_brightness (sensor_t *sensor, uint8_t brightness)
  228. {
  229.         if (sensor == NULL) {
  230.                 return SAL_ERR_P_NULL;
  231.         }

  233.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0xff, 0x00);
  234.     sensor->iic_dev->delay_us(2);
  235.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7c, 0x00);
  236.     sensor->iic_dev->delay_us(2);
  237.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, 0x04);
  238.     sensor->iic_dev->delay_us(2);
  239.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7c, 0x09);
  240.     sensor->iic_dev->delay_us(2);
  241.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, brightness);
  242.     sensor->iic_dev->delay_us(2);
  243.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x7d, 0x00);
  244.     sensor->iic_dev->delay_us(2);

  246.         return SAL_OK;
  247. }


  250. const unsigned char OV2640_JPEG_INIT[][2]=
  251. {
  252.         {0xff, 0x00},
  253.         {0x2c, 0xff},
  254.         {0x2e, 0xdf},
  255.         {0xff, 0x01},
  256.         {0x3c, 0x32},
  257.         {0x11, 0x00},
  258.         {0x09, 0x02},
  259.         {0x04, 0x28},
  260.         {0x13, 0xe5},
  261.         {0x14, 0x48},
  262.         {0x2c, 0x0c},
  263.         {0x33, 0x78},
  264.         {0x3a, 0x33},
  265.         {0x3b, 0xfB},
  266.         {0x3e, 0x00},
  267.         {0x43, 0x11},
  268.         {0x16, 0x10},
  269.         {0x39, 0x92},
  270.         {0x35, 0xda},
  271.         {0x22, 0x1a},
  272.         {0x37, 0xc3},
  273.         {0x23, 0x00},
  274.         {0x34, 0xc0},
  275.         {0x36, 0x1a},
  276.         {0x06, 0x88},
  277.         {0x07, 0xc0},
  278.         {0x0d, 0x87},
  279.         {0x0e, 0x41},
  280.         {0x4c, 0x00},
  281.         {0x48, 0x00},
  282.         {0x5B, 0x00},
  283.         {0x42, 0x03},
  284.         {0x4a, 0x81},
  285.         {0x21, 0x99},
  286.         {0x24, 0x40},
  287.         {0x25, 0x38},
  288.         {0x26, 0x82},
  289.         {0x5c, 0x00},
  290.         {0x63, 0x00},
  291.         {0x61, 0x70},
  292.         {0x62, 0x80},
  293.         {0x7c, 0x05},
  294.         {0x20, 0x80},
  295.         {0x28, 0x30},
  296.         {0x6c, 0x00},
  297.         {0x6d, 0x80},
  298.         {0x6e, 0x00},
  299.         {0x70, 0x02},
  300.         {0x71, 0x94},
  301.         {0x73, 0xc1},
  302.         {0x12, 0x40},//0x40
  303.         /*SensorWindow */
  304.         {0x17, 0x11},// HREFST[10:3]
  305.         {0x18, 0x43},// HREFEND[10:3]
  306.         {0x19, 0x00},// VSTRT[9:2]
  307.         {0x1a, 0x4b}, // VEND[9:2]
  308.         {0x32, 0x09},// Bit7..6--PCLK分频设置,10二分频,11四分频; Bit[5:3]: HREFEND[2:0]; Bit[2:0]: HREFST[2:0][===zm.li==>定义Window(H*W):400*300]
  309.         // {0x03, 0x0f}, Bit[3:2]: VEND[1:0]; Bit[1:0]: VSTRT[1:0]
  310.         {0x37, 0xc0},
  311.         {0x4f, 0x60},
  312.         {0x50, 0xa8},
  313.         {0x6d, 0x00},
  314.         {0x3d, 0x38},
  315.         {0x46, 0x3f},
  316.         {0x4f, 0x60},
  317.         {0x0c, 0x3c},
  318.         {0xff, 0x00},
  319.         {0xe5, 0x7f},
  320.         {0xf9, 0xc0},
  321.         {0x41, 0x24},
  322.         {0xe0, 0x14},
  323.         {0x76, 0xff},
  324.         {0x33, 0xa0},
  325.         {0x42, 0x20},
  326.         {0x43, 0x18},
  327.         {0x4c, 0x00},
  328.         {0x87, 0xd5},
  329.         {0x88, 0x3f},
  330.         {0xd7, 0x03},
  331.         {0xd9, 0x10},
  332.         {0xd3, 0x82},
  333.         {0xc8, 0x08},
  334.         {0xc9, 0x80},
  335.         {0x7c, 0x00},
  336.         {0x7d, 0x00},
  337.         {0x7c, 0x03},
  338.         {0x7d, 0x48},
  339.         {0x7d, 0x48},
  340.         {0x7c, 0x08},
  341.         {0x7d, 0x20},
  342.         {0x7d, 0x10},
  343.         {0x7d, 0x0e},
  344.         {0x90, 0x00},
  345.         {0x91, 0x0e},
  346.         {0x91, 0x1a},
  347.         {0x91, 0x31},
  348.         {0x91, 0x5a},
  349.         {0x91, 0x69},
  350.         {0x91, 0x75},
  351.         {0x91, 0x7e},
  352.         {0x91, 0x88},
  353.         {0x91, 0x8f},
  354.         {0x91, 0x96},
  355.         {0x91, 0xa3},
  356.         {0x91, 0xaf},
  357.         {0x91, 0xc4},
  358.         {0x91, 0xd7},
  359.         {0x91, 0xe8},
  360.         {0x91, 0x20},
  361.         {0x92, 0x00},
  362.         {0x93, 0x06},
  363.         {0x93, 0xe3},
  364.         {0x93, 0x05},
  365.         {0x93, 0x05},
  366.         {0x93, 0x00},
  367.         {0x93, 0x04},
  368.         {0x93, 0x00},
  369.         {0x93, 0x00},
  370.         {0x93, 0x00},
  371.         {0x93, 0x00},
  372.         {0x93, 0x00},
  373.         {0x93, 0x00},
  374.         {0x93, 0x00},
  375.         {0x96, 0x00},
  376.         {0x97, 0x08},
  377.         {0x97, 0x19},
  378.         {0x97, 0x02},
  379.         {0x97, 0x0c},
  380.         {0x97, 0x24},
  381.         {0x97, 0x30},
  382.         {0x97, 0x28},
  383.         {0x97, 0x26},
  384.         {0x97, 0x02},
  385.         {0x97, 0x98},
  386.         {0x97, 0x80},
  387.         {0x97, 0x00},
  388.         {0x97, 0x00},
  389.         {0xc3, 0xed},
  390.         {0xa4, 0x00},
  391.         {0xa8, 0x00},
  392.         {0xc5, 0x11},
  393.         {0xc6, 0x51},
  394.         {0xbf, 0x80},
  395.         {0xc7, 0x10},
  396.         {0xb6, 0x66},
  397.         {0xb8, 0xA5},
  398.         {0xb7, 0x64},
  399.         {0xb9, 0x7C},
  400.         {0xb3, 0xaf},
  401.         {0xb4, 0x97},
  402.         {0xb5, 0xFF},
  403.         {0xb0, 0xC5},
  404.         {0xb1, 0x94},
  405.         {0xb2, 0x0f},
  406.         {0xc4, 0x5c},
  407.         /*ImageSize定义*/
  408.         {0xc0, 0x64},
  409.         {0xc1, 0x4B},
  410.         {0x8c, 0x00},/*H*W=800*600*/

  412.         {0x86, 0x3D},
  413.         {0x50, 0x00},
  414.         /*ImageWindow 定义*/
  415.         {0x51, 0xC8},
  416.         {0x52, 0x96},
  417.         {0x53, 0x00},
  418.         {0x54, 0x00},
  419.         {0x55, 0x00},
  420.         /*OutSize定义*/
  421.         {0x5a, 0xC8},
  422.         {0x5b, 0x96},
  423.         {0x5c, 0x00},

  425.         {0xd3, 0x7f},
  426.         {0xc3, 0xed},
  427.         {0x7f, 0x00},
  428.         {0xda, 0x00},
  429.         {0xe5, 0x1f},
  430.         {0xe1, 0x67},
  431.         {0xe0, 0x00},
  432.         {0xdd, 0x7f},
  433.         {0x05, 0x00},

  435.         {0x12, 0x40},//0x40
  436.         {0xd3, 0x7f},
  437.         /*ImageSize定义*/
  438.         {0xc0, 0x16},/*Image HSize[10..3]*/
  439.         {0xC1, 0x12},/*Image VSize[10..3]*/
  440.         {0x8c, 0x00},/*Bit6--HSize[11]?, Bit5..3--HSize[2..0], Bit2..0--VSize[2..0]*//*H*V= 176*144 */

  442.         {0x86, 0x3d},
  443.         {0x50, 0x00},
  444.         /*ImageWindow 定义*/
  445.         {0x51, 0x2C},/*HSize[7..0]*/
  446.         {0x52, 0x24},/*VSize[7..0]*/
  447.         {0x53, 0x00},/*Offerset_X[7..0]*/
  448.         {0x54, 0x00},/*Offerset_Y[7..0]*/
  449.         {0x55, 0x00},/*Bit7-VSize[8], Bit6..4-Offerset_Y[10..8],Bit3-HSize[8], Bit2..0-Offerset_Y[10..8]*/
  450.         /*OutSize定义*/
  451.         {0x5A, 0x2c},/*OutW[7..0]*/
  452.         {0x5b, 0x24},/*OutH[7..0]*/
  453.         {0x5c, 0x00},/*Bit7..4-Zoom Spead, Bit2-OutH[8], Bit1..0-OutW[9..8]*/
  454. };

  456. const unsigned char OV2640_YUV422[][2]=
  457. {
  458.         {0xFF, 0x00},/*选中DSP[寄存器bank选择0--DSP, 1--Sensor]*/
  459.         {0x05, 0x00},/*bit0 = 0-->DSP处理采集图像(非Bypass DSP直接将Sensor数据输出)*/
  460.         {0xDA, 0x10},/*bit4=1-->JPEG输出，bit3..2=0-->YUV422格式,bit1=0-->HREF与sensor相同,bit0=0-->High byte first YUYV(C2[4]=0复位缺省)*/
  461.         {0xD7, 0x03},/*芯片保留寄存器*/
  462.         {0xDF, 0x00},/*芯片保留寄存器*/
  463.         {0x33, 0x80},/*芯片保留寄存器*/
  464.         {0x3C, 0x40},/*芯片保留寄存器*/
  465.         {0xe1, 0x77},/*芯片保留寄存器*/
  466.         {0x00, 0x00},/*芯片保留寄存器*/
  467. };

  469. const unsigned char OV2640_RGB565[][2]=
  470. {
  471.         {0xFF, 0x00},/*选中DSP[寄存器bank选择0--DSP, 1--Sensor]*/
  472.         {0x05, 0x00},/*bit0 = 0-->DSP处理采集图像(非Bypass DSP直接将Sensor数据输出)*/
  473.         {0xDA, 0x1C},/*bit4=1-->JPEG输出，bit3..2=11-->RGB565格式,bit1=0-->HREF与sensor相同,bit0=0-->High byte first YUYV(C2[4]=0复位缺省)*/
  474.         {0xD7, 0x03},/*芯片保留寄存器*/
  475.         {0xDF, 0x00},/*芯片保留寄存器*/
  476.         {0x33, 0x80},/*芯片保留寄存器*/
  477.         {0x3C, 0x40},/*芯片保留寄存器*/
  478.         {0xe1, 0x77},/*芯片保留寄存器*/
  479.         {0x00, 0x00},/*芯片保留寄存器*/
  480. };

  482. const unsigned char OV2640_JPEG[][2]=
  483. {
  484.         {0xe0, 0x14},/*芯片保留寄存器*/
  485.         {0xe1, 0x77},/*芯片保留寄存器*/
  486.         {0xe5, 0x1f},/*芯片保留寄存器*/
  487.         {0xd7, 0x03},/*芯片保留寄存器*/
  488.         {0xda, 0x10},/*芯片保留寄存器*/
  489.         {0xe0, 0x00},/*芯片保留寄存器*/
  490.         {0xFF, 0x01},
  491.         {0x04, 0x08},
  492. };

  494. /* JPG 160x120 */
  495. const unsigned char OV2640_160x120_JPEG[][2]=
  496. {
  497.         {0xff, 0x01},
  498.         {0x12, 0x40},
  499.         {0x17, 0x11},
  500.         {0x18, 0x43},
  501.         {0x19, 0x00},
  502.         {0x1a, 0x4b},
  503.         {0x32, 0x09},
  504.         {0x4f, 0xca},
  505.         {0x50, 0xa8},
  506.         {0x5a, 0x23},
  507.         {0x6d, 0x00},
  508.         {0x39, 0x12},
  509.         {0x35, 0xda},
  510.         {0x22, 0x1a},
  511.         {0x37, 0xc3},
  512.         {0x23, 0x00},
  513.         {0x34, 0xc0},
  514.         {0x36, 0x1a},
  515.         {0x06, 0x88},
  516.         {0x07, 0xc0},
  517.         {0x0d, 0x87},
  518.         {0x0e, 0x41},
  519.         {0x4c, 0x00},
  520.         {0xff, 0x00},
  521.         {0xe0, 0x04},
  522.         {0xc0, 0x64},
  523.         {0xc1, 0x4b},
  524.         {0x86, 0x35},
  525.         {0x50, 0x92},
  526.         {0x51, 0xc8},
  527.         {0x52, 0x96},
  528.         {0x53, 0x00},
  529.         {0x54, 0x00},
  530.         {0x55, 0x00},
  531.         {0x57, 0x00},
  532.         {0x5a, 0x28},
  533.         {0x5b, 0x1e},
  534.         {0x5c, 0x00},
  535.         {0xe0, 0x00},
  536. };

  538. /* JPG 176x144 */
  539. const unsigned char OV2640_176x144_JPEG[][2]=
  540. {
  541.         {0xff, 0x01},
  542.         {0x11, 0x05},/*摄像头晶振6MHz、主控MCU工作频率16MHz时，此寄存器可设为0x05(6分频)、0x0B(12分频)*/
  543.         {0x12, 0x00}, // Bit[6:4]: Resolution selection//0x02为彩条
  544.         {0x17, 0x11}, // HREFST[10:3]
  545.         {0x18, 0x75}, // HREFEND[10:3]
  546.         {0x32, 0x36}, // Bit[5:3]: HREFEND[2:0]; Bit[2:0]: HREFST[2:0]
  547.         {0x19, 0x01}, // VSTRT[9:2]
  548.         {0x1a, 0x97}, // VEND[9:2]
  549.         {0x03, 0x0f}, // Bit[3:2]: VEND[1:0]; Bit[1:0]: VSTRT[1:0]
  550.         {0x37, 0x40},
  551.         {0x4f, 0xbb},
  552.         {0x50, 0x9c},
  553.         {0x5a, 0x57},
  554.         {0x6d, 0x80},
  555.         {0x3d, 0x34},
  556.         {0x39, 0x02},
  557.         {0x35, 0x88},
  558.         {0x22, 0x0a},
  559.         {0x37, 0x40},
  560.         {0x34, 0xa0},
  561.         {0x06, 0x02},
  562.         {0x0d, 0xb7},
  563.         {0x0e, 0x01},

  565.         //176x144
  566.         {0xff, 0x00},
  567.         {0xc2, 0xcc},
  568.         {0xc0, 0xc8},
  569.         {0xc1, 0x96},
  570.         {0x8c, 0x00},
  571.         {0x86, 0x3d},
  572.         {0x50, 0x9b},
  573.         {0x51, 0x90},
  574.         {0x52, 0x2c},
  575.         {0x53, 0x00},
  576.         {0x54, 0x00},
  577.         {0x55, 0x88},
  578.         {0x5a, 0x2c},
  579.         {0x5b, 0x24},
  580.         {0x5c, 0x00},
  581.         {0xd3, 0x7F},
  582. };


  585. /* JPG 320x240 */
  586. const unsigned char OV2640_320x240_JPEG[][2]=
  587. {
  588.         {0xff, 0x01},
  589.         {0x11, 0x05},/*摄像头晶振6MHz、主控MCU工作频率16MHz时，此寄存器可设为0x05(6分频)、0x0B(12分频)*/
  590.         {0x12, 0x00}, // Bit[6:4]: Resolution selection//0x02为彩条
  591.         {0x17, 0x11}, // HREFST[10:3]
  592.         {0x18, 0x75}, // HREFEND[10:3]
  593.         {0x32, 0x36}, // Bit[5:3]: HREFEND[2:0]; Bit[2:0]: HREFST[2:0]
  594.         {0x19, 0x01}, // VSTRT[9:2]
  595.         {0x1a, 0x97}, // VEND[9:2]
  596.         {0x03, 0x0f}, // Bit[3:2]: VEND[1:0]; Bit[1:0]: VSTRT[1:0]
  597.         {0x37, 0x40},
  598.         {0x4f, 0xbb},
  599.         {0x50, 0x9c},
  600.         {0x5a, 0x57},
  601.         {0x6d, 0x80},
  602.         {0x3d, 0x34},
  603.         {0x39, 0x02},
  604.         {0x35, 0x88},
  605.         {0x22, 0x0a},
  606.         {0x37, 0x40},
  607.         {0x34, 0xa0},
  608.         {0x06, 0x02},
  609.         {0x0d, 0xb7},
  610.         {0x0e, 0x01},

  612.         //320*240
  613.         {0xff, 0x00},
  614.         {0xe0, 0x04},
  615.         {0xc0, 0xc8},
  616.         {0xc1, 0x96},
  617.         {0x86, 0x3d},
  618.         {0x50, 0x92},
  619.         {0x51, 0x90},
  620.         {0x52, 0x2c},
  621.         {0x53, 0x00},
  622.         {0x54, 0x00},
  623.         {0x55, 0x88},
  624.         {0x57, 0x00},
  625.         {0x5a, 0x50},
  626.         {0x5b, 0x3c},
  627.         {0x5c, 0x00},
  628.         {0xd3, 0x7F},
  629.         {0xe0, 0x00}
  630. };

  632. /* JPG 352x288 */
  633. const unsigned char OV2640_352x288_JPEG[][2]=
  634. {
  635.         {0xff, 0x01},
  636.         {0x12, 0x40},
  637.         {0x17, 0x11},
  638.         {0x18, 0x43},
  639.         {0x19, 0x00},
  640.         {0x1a, 0x4b},
  641.         {0x32, 0x09},
  642.         {0x4f, 0xca},
  643.         {0x50, 0xa8},
  644.         {0x5a, 0x23},
  645.         {0x6d, 0x00},
  646.         {0x39, 0x12},
  647.         {0x35, 0xda},
  648.         {0x22, 0x1a},
  649.         {0x37, 0xc3},
  650.         {0x23, 0x00},
  651.         {0x34, 0xc0},
  652.         {0x36, 0x1a},
  653.         {0x06, 0x88},
  654.         {0x07, 0xc0},
  655.         {0x0d, 0x87},
  656.         {0x0e, 0x41},
  657.         {0x4c, 0x00},

  659.         {0xff, 0x00},
  660.         {0xe0, 0x04},
  661.         {0xc0, 0x64},
  662.         {0xc1, 0x4b},
  663.         {0x86, 0x35},
  664.         {0x50, 0x89},
  665.         {0x51, 0xc8},
  666.         {0x52, 0x96},
  667.         {0x53, 0x00},
  668.         {0x54, 0x00},
  669.         {0x55, 0x00},
  670.         {0x57, 0x00},
  671.         {0x5a, 0x58},
  672.         {0x5b, 0x48},
  673.         {0x5c, 0x00},
  674.         {0xe0, 0x00}
  675. };


  678. static int set_jpeg_img_format (sensor_t *sensor, image_format_e img_format)
  679. {
  680.         uint32_t i;

  682.         if (sensor == NULL) {
  683.                 return SAL_ERR_P_NULL;
  684.         }

  686.         reset(sensor);
  687.         HAL_Delay(200);

  689.         /* Initialize OV2640 */
  690.         for (i = 0; i < (sizeof(OV2640_JPEG_INIT) / 2); i++) {
  691.                 sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, OV2640_JPEG_INIT[i][0], OV2640_JPEG_INIT[i][1]);
  692.                 HAL_Delay(2);
  693.         }

  695.         /* Set to output OV2640_RGB565 (2560bytes size vs 3072 in YUV422 mode.) OV2640_YUV422 */
  696.         for (i = 0; i < (sizeof(OV2640_YUV422) / 2); i++) {
  697.                 sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, OV2640_YUV422[i][0], OV2640_YUV422[i][1]);
  698.                 HAL_Delay(2);
  699.         }

  701.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0xff, 0x01); /*选中Sensor寄存器bank*/
  702.         sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, 0x15, 0x00); /*设置结果:bit5=0-->PCLK持续输出；bit4=0-->数据在PCLK降沿时更新好；
  703.                                                                                                    bit3=0-->HRef正极性输出；bit1=0-->VSYNC正极性输出；*/

  705.         /* Set to output JPEG */
  706.         for (i = 0; i < (sizeof(OV2640_JPEG) / 2); i++) {
  707.                 sal_fiic_write_slave_std(sensor->iic_dev, sensor->slv_addr, OV2640_JPEG[i][0], OV2640_JPEG[i][1]);
  708.                 HAL_Delay(2);
  709.         }
  710.    
  711.         HAL_Delay(100);
  712.    
  713.     uint8_t data = 0;

  715. ……………………

  717. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

下载：
ov2640.zip (4.68 KB, 下载次数: 32)






欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1