开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
IIC.c
资源名称：SMDK2440.rar　[点击查看]
上传用户：qiulin1960
上传日期：2013-10-16
资源大小：2844k
文件大小：15k
源码类别：

Windows CE

开发平台：

Windows_Unix

IIC.c：源码内容
  1. #include <windows.h>
  2. #include <s2440.h>
  3. #include <nkintr.h>
  4. #include <oalintr.h>
  5. #include <p2.h>
  6. #include "IIC_OV7620.h"
  8. #define ERRORMSG(a,b) RETAILMSG(1,b)
  10. //#define U8 unsigned char
  11. //#define U16 unsigned short
  12. //#define U32 unsigned int
  14. #define CAM_ID (0x42)
  16. // GP9:SCL, GP8:SDA
  17. #define SCL (1<<14)
  18. #define SDA (1<<15)
  20. #define SCL0 (s2440IOP->rGPEDAT &= ~SCL)
  21. #define SCL1 (s2440IOP->rGPEDAT |= SCL)
  22. #define SDA0 (s2440IOP->rGPEDAT &= ~SDA)
  23. #define SDA1 (s2440IOP->rGPEDAT |= SDA)
  24. //#define SDAOUT  SDA
  25. #define GetSDA (s2440IOP->rGPEDAT)
  27. static U8 _iicData[IICBUFSIZE];
  28. static volatile int _iicDataCount;
  29. static volatile int _iicStatus;
  30. static volatile int _iicMode;
  31. static int _iicPt;
  33. const unsigned char Ov7620_YCbCr8bit_TV[][2] = {
  35. {0x12, 0x80}, // Camera Soft reset. Self cleared after reset.
  36. {0x00, 0x00},
  37. {0x01, 0x80}, // set blue gain
  38. {0x02, 0x80}, // set red gain
  39. {0x03, 0xb0},
  40. {0x06, 0x60}, // set brightness
  41. {0x0c, 0x24}, // set blue background
  42. {0x0d, 0x24}, // set red background
  43. {0x10, 0xff}, // set exposure time, brightness control
  44. {0x11, 0x80}, // set frame rate CLK_input = PCLK
  45. {0x12, 0x34}, // set 8 Bit YUV mode, enable AGC/AWB, mirror image.
  46. {0x13, 0x21},   // 8bit Data, CCIR601 Format
  47. {0x15, 0x01}, // Use PCLK falling edge to latch data, 8 Bit UYVY....
  48. {0x16, 0x03}, //
  49. {0x17, 0x2f}, //
  50. {0x18, 0xcf},        // (207-47)*4 = 640
  51. {0x19, 0x06}, //
  52. {0x1a, 0xf5},        // ((244-5)+1)*2=480
  53. {0x1b, 0x00},
  54. {0x20, 0x00},
  55. {0x21, 0x80},
  56. {0x22, 0x80},
  57. {0x23, 0x00},
  58. {0x26, 0xa2},
  59. {0x27, 0xea},
  60. {0x29, 0x00},
  61. {0x2a, 0x00},
  62. {0x2b, 0x00},
  63. {0x2c, 0x88},
  64. {0x2e, 0x80},
  65. {0x2f, 0x44},
  66. {0x60, 0x27},
  67. {0x61, 0x82},
  68. {0x62, 0x5f},
  69. {0x63, 0xd5},
  70. {0x64, 0x57},
  71. {0x65, 0x83},
  72. {0x66, 0x55},
  73. {0x68, 0xcf},
  74. {0x69, 0x76},
  75. {0x6a, 0x22},
  76. {0x6b, 0x00},
  77. {0x6c, 0x08},
  78. {0x6d, 0x48},
  79. {0x6e, 0x80},
  80. {0x6f, 0x0c},
  81. {0x70, 0x89},
  82. {0x71, 0x00},
  83. {0x72, 0x14},
  84. {0x73, 0x54},
  85. {0x75, 0x0e},
  86. {0x76, 0x00},
  87. {0x77, 0xff},
  88. {0x78, 0x80},
  89. {0x79, 0x80},
  90. {0x7a, 0x80},
  91. {0x7b, 0xe6},
  92. {0x7c, 0x00},
  93. {0x13, 0x21},
  94. {0x14, 0x94},
  95. {0x24, 0x10},
  96. {0x25, 0x8a},
  97. {0x28, 0x20}, // Progressive mode.
  98. {0x2d, 0x95}, //
  99. {0x67, 0x92}, // 
  100. {0x74, 0x00}, // -CJH
  102. {0x12, 0x34} // set 8 Bit YUV mode, enable AGC/AWB, mirror image.
  103. };
  105. // Change GP8(I2CSDA) as input/output mode.
  106. #define SET_SDA_INPUT (s2440IOP->rGPECON &= ~(3<<30))
  107. #define SET_SDA_OUTPUT (s2440IOP->rGPECON = (s2440IOP->rGPECON & ~(2<<30)) |(1<<30) )
  109. volatile IOPreg *s2440IOP = (IOPreg *)IOP_BASE;
  110. volatile IICreg *s2440IIC = (IICreg *)IIC_BASE;
  112. extern void Camera_Initialize(void);
  114. void Init_Sccb_Port(void);
  115. void Camera_Initialize(void);
  116. void Init_Camera_Module_YCbCr_VGA(void);
  117. void setCIS(unsigned char bSubAddr, unsigned char bData);
  118. void outSCCB(unsigned char *bpData, unsigned char bSize);
  119. void Sccb_Start(void);
  120. void loopn(U32 wCount);
  121. void Sccb_Write_8bit(U8 Write_Byte);
  122. void Sccb_Ack(void);
  123. void Sccb_Stop(void);
  124. void Delay(int time);
  125. void SetCAMClockDivider(int divn);
  127. void OV7620_WriteBlock(void);
  128. void Wr_OV7620(U32 slvAddr, U32 addr, U8 data);
  129. void Run_IicPoll(void);
  130. void IicPoll(void);
  132. void Init_Sccb_Port(void)
  133. {
  134. // GP9:SCL, GP8:SDA, set all GPIO output.
  135. s2440IOP->rGPECON = (s2440IOP->rGPECON & ~(0xA<<28)) | (5<<28); //GPE 14, 15
  136. }
  138. void outSCCB(unsigned char *bpData, unsigned char bSize)
  139. {
  140. int i;
  141. int j;
  142. unsigned char bTemp, bCombineMode;
  144. SET_SDA_OUTPUT;
  146. Sccb_Start();
  148. while(bSize--){
  149. Sccb_Write_8bit(*bpData);
  150. bpData++;
  151. Sccb_Ack();
  152. //SET_SDA_INPUT;
  153. //while(GetSDA & SDA); // check ACK
  154. } //while(bSize--)
  156. Sccb_Stop();
  158. }
  160. void setCIS(unsigned char bSubAddr, unsigned char bData)
  161. {
  162. unsigned char bTemp[3];
  164. bTemp[0] = CAM_ID; // slave Address ( Omni)
  165. bTemp[1] = bSubAddr;
  166. bTemp[2] = bData;
  167. //while(1)
  168. outSCCB(bTemp, 3);
  169. }
  171. void loopn(U32 wCount)
  172. {
  173. int i, j;
  175. for (i=0; i<wCount; i++);
  176. for(j=0; j<1000; j++); // 451Mhz
  177. // for(j=0; j<1500; j++); // 531Mhz
  178. }
  180. void Sccb_Start(void)
  181. {
  182. SET_SDA_OUTPUT;
  183. // start
  184. SCL1;
  185. loopn(4);
  186. SDA1;
  187. loopn(8);
  188. SDA0; //start point
  189. loopn(4);
  190. }
  192. void Sccb_Ack(void)
  193. {
  194. SET_SDA_OUTPUT;
  195. SCL0;
  196. loopn(4);
  197. SDA1;
  198. loopn(4);
  199. SCL1;
  200. loopn(4);
  201. }
  203. void Sccb_Write_8bit(U8 Write_Byte)
  204. {
  205. int i;
  207. SET_SDA_OUTPUT;
  208. for(i=0;i<8;i++){
  209. SCL0;
  210. loopn(4);
  211. if(Write_Byte & 0x80) SDA1;
  212. else SDA0;
  213. loopn(4);
  214. Write_Byte <<= 1;
  215. SCL1;
  216. loopn(4);
  217. } //for(i=0;i<8;i++){
  218. }
  220. void Sccb_Stop(void)
  221. {
  222. // stop
  223. SET_SDA_OUTPUT;
  224. SCL0;
  225. loopn(4);
  226. SDA0;
  227. loopn(4);
  228. SCL1;
  229. loopn(4);
  230. SDA1; // stop point
  231. }
  233. static int delayLoopCount = 100;
  235. void Delay(int time)
  236. {
  237.     int i;
  238.     
  239.     for(;time>0;time--)
  240.         for(i=0;i<delayLoopCount;i++);
  241. }
  243. void Init_Camera_Module_YCbCr_VGA(void)
  244. {
  246. setCIS(0x12, 0x80); // Camera Soft reset. Self cleared after reset.
  247. Delay(10);
  249. // From Omnivision...
  250. setCIS(0x00, 0x00); // 
  252. // setCIS(0x01, 0x40); // set blue gain
  253. // setCIS(0x02, 0x40); // set red gain
  255. setCIS(0x01, 0x80); // set blue gain
  256. setCIS(0x02, 0x80); // set red gain
  257. setCIS(0x03, 0xb0); // saturation control
  259. //setCIS(0x03, 0xb0); // saturation control
  260. //setCIS(0x06, 0x80); // set brightness
  261. setCIS(0x06, 0x60); // set brightness - CJH
  262. //setCIS(0x07, 0x00); // Sharpness control : Threshold-0, Magnitude-0
  264. setCIS(0x0c, 0x24); // set white balance blue background
  265. setCIS(0x0d, 0x24); // set white balance red background
  266. //setCIS(0x10, 0xb0); // set auto exposure time, brightness control
  267. setCIS(0x10, 0xff); // set auto exposure time, brightness control - CJH
  268. setCIS(0x11, (1<<7)+(0<<6)+(0x0)); // HSYNC positive, CHSYNC negative, VSYNC posigive
  269. // 16 Bit : PCLK = CLK_in/((1+x)*2)
  270. //  8 Bit : PCLK = CLK_in/(1+x)
  272. setCIS(0x12, 0x34); // mirror image, enable AGC/AWB
  274. // precise A/D black level compensation
  275. setCIS(0x13, (0x1<<5)+(0x0<<4)+(0x1));  // 8bit Data, CCIR601 Format
  276. setCIS(0x15, 0x01); // Use PCLK rising edge to latch data
  277. // UV data output: 16 Bit - UVUV..., 8 Bit - UYVY...
  278. setCIS(0x16, 0x03); // Field mode : 00-OFF mode, 01-ODD mode, 10-EVEN mode, 11-FRAME mode 
  280. //setCIS(0x17, CAM_STX); // 
  281. //setCIS(0x18, CAM_ENDX); // (207-47)*4 = 640
  282. //setCIS(0x19, CAM_STY); // 
  283. //setCIS(0x1a, CAM_ENDY); // ((244-5)+1)*2=480 
  285. setCIS(0x17, 0x2f);
  286. setCIS(0x18, 0xcf);
  287. setCIS(0x19, 0x06);
  288. setCIS(0x1a, 0xf5);
  291. setCIS(0x1b, 0x00); // Pixel Shift
  292. // setCIS(0x1b, 0x00); // Pixel Shift - 0
  293. setCIS(0x20, 0x00); // limit vertical size to 480, second stage aperture correction enable
  294. // AWB smart mode disable, AWB is slow mode
  296. setCIS(0x21, 0x80); // Y Channel Offset Adjustment - 0 , direction - Subtract
  297. setCIS(0x22, 0x80); // U Channel Offset Adjustment - 0
  298. setCIS(0x23, 0x00); // Crystal Current control : maximum current
  300. setCIS(0x26, 0xa2); // Digital sharpness threshold, magnitude.
  301. setCIS(0x27, 0xea); // Disable CCIR rang clip
  302. //setCIS(0x27, 0xe0); // Disable CCIR rang clip - CJH
  303. setCIS(0x29, 0x00); // 
  304. //setCIS(0x2a, 0x10); // frame rate high, 60Hz, 50Hz:0x80, UV delay 2 pixel.
  305. setCIS(0x2a, 0x00); // frame rate high, 60Hz, 50Hz:0x80, UV delay 2 pixel. - CJH
  306. setCIS(0x2b, 0x00); // frame rate low, 60Hz, 50Hz:0xac
  307. setCIS(0x2c, 0x88); // 
  308. setCIS(0x2e, 0x80); // 
  309. setCIS(0x2f, 0x44); // 
  310. setCIS(0x60, 0x27); // 
  311. setCIS(0x61, 0x82); // 02?x.........................................
  312. setCIS(0x62, 0x5f); // 
  313. //setCIS(0x63, 0xcc); // 
  314. setCIS(0x63, 0xd5); // 
  315. setCIS(0x64, 0x57); // Enable Y Gamma
  316. setCIS(0x65, 0x83); // 
  317. setCIS(0x66, 0x55); // 
  319. setCIS(0x68, 0xcf); // 
  320. //setCIS(0x68, 0xca); // -CJH
  321. setCIS(0x69, 0x76); // 
  322. setCIS(0x6a, 0x22); // 
  323. setCIS(0x6b, 0x00); // 
  324. setCIS(0x6c, 0x08); // 
  325. //setCIS(0x6d, 0x44); // 
  326. setCIS(0x6d, 0x48); // 
  327. setCIS(0x6e, 0x80); // 
  328. //setCIS(0x6f, 0x0d); // 
  329. setCIS(0x6f, 0x0c); // -CJH
  330. //setCIS(0x70, 0x8b); // 
  331. setCIS(0x70, 0x89); // -CJH
  332. setCIS(0x71, 0x00); //  freerun PCLK
  333. setCIS(0x72, 0x14); // 
  334. setCIS(0x73, 0x54); // 
  336. //setCIS(0x75, 0x8e); // 
  337. setCIS(0x75, 0x0e); // -CJH
  338. setCIS(0x76, 0x00); // 
  339. setCIS(0x77, 0xff); // 
  340. setCIS(0x78, 0x80); // 
  341. setCIS(0x79, 0x80); // 
  342. setCIS(0x7a, 0x80); // 
  343. //setCIS(0x7b, 0xe2); // 
  344. setCIS(0x7b, 0xe6); // -CJH
  345. setCIS(0x7c, 0x00); // 
  347. setCIS(0x13, 0x21); // YUV 8-bit format, Enable AEC/AGC/AWB 
  348. //setCIS(0x14, 0x04); // turn off GAMMA
  349. setCIS(0x14, 0x94); // turn off GAMMA - CJH
  350. //setCIS(0x24, 0x3a); // 
  351. setCIS(0x24, 0x10); // -CJH
  352. //setCIS(0x25, 0x60); // 
  353. setCIS(0x25, 0x8a); // -CJH
  354. setCIS(0x28, 0x20); // Progressive mode.
  355. setCIS(0x2d, 0x95); //
  356. setCIS(0x67, 0x92); // 
  357. //setCIS(0x74, 0x00); // 
  358. setCIS(0x74, 0x00); // -CJH
  360. setCIS(0x12, 0x34); // mirror image, enable AGC/AWB
  361. }
  363. void Camera_Initialize(void)
  364. {
  365. // Use GPIO as IIC
  366. /*
  367. RETAILMSG(1,(TEXT("Camera_Initializen")));
  368. SetCAMClockDivider(1);
  369. Init_Sccb_Port(); //Initializing GPIO for Serial Camera Control Bus
  370. Init_Camera_Module_YCbCr_VGA(); //Initializing Camera Processor.  Using SCCB interface
  371. */
  372. SetCAMClockDivider(1); // for 24M Camera, set to 1 if it's 24M camera
  373. RETAILMSG(1,(TEXT("Use IIC for initializationn")));
  374. // Use IIC for initialization
  375. OV7620_WriteBlock();
  376. }
  378. void SetCAMClockDivider(int divn) // divn is even number 0~15
  379. {
  380. volatile CLKPWRreg *s2440PWR = (CLKPWRreg *)CLKPWR_BASE;
  382. // s2440PWR->rCLKDIVN |= (1<<3); // UCLK 48MHz setting
  383. s2440PWR->rCAMDIVN = (s2440PWR->rCAMDIVN & ~(0xf))|(0x10)|(divn); // CAMCLK is divided..
  384. // RETAILMSG(1,(TEXT("s2440PWR->rCLKCON:0x%xrn"),s2440PWR->rCLKCON));
  385. }
  387. void OV7620_WriteBlock(void)
  388. {
  389.     unsigned int i, j, save_E, save_PE, RegAddr, RegData;
  390.     static U8 rdata[256]; 
  391.       
  392.     save_E   = s2440IOP->rGPECON;
  393.     save_PE  = s2440IOP->rGPEUP;
  395.     s2440IOP->rGPEUP  &= ~0xc000;                   //Pull-up disable
  396.     s2440IOP->rGPEUP  |=  0xc000;                   //Pull-up disable
  397.     s2440IOP->rGPECON &= ~(0xF<<28);                //GPE15:IICSDA , GPE14:IICSCL    
  398.     s2440IOP->rGPECON |=  (0xa<<28);                //GPE15:IICSDA , GPE14:IICSCL    
  400.     //Enable ACK, Prescaler IICCLK=PCLK/16, Enable interrupt, Transmit clock value Tx clock=IICCLK/16
  401.     s2440IIC->rIICCON  = (1<<7) | (0<<6) | (1<<5) | (0xf);
  403.     s2440IIC->rIICADD  = 0x10;                     //2440 slave address = [7:1]. this is avialable when 240 is slave.
  404.     s2440IIC->rIICSTAT = 0x10;                     //IIC bus data output enable(Rx/Tx)
  405.     s2440IIC->rIICLC = (1<<2)|(3);   // Filter enable, 15 clocks SDA output delay     added into 2440
  406.     
  407.     for(i=0; i<(sizeof(Ov7620_YCbCr8bit_TV)/2); i++){
  408.      RETAILMSG(1,(TEXT("number:%drn"),i));
  409. Wr_OV7620(SlaveID, Ov7620_YCbCr8bit_TV[i][0], Ov7620_YCbCr8bit_TV[i][1]);
  410. }
  412.     RETAILMSG(1,(TEXT("Block TX Ended...rn")));
  414.     s2440IOP->rGPEUP  = save_PE;
  415.     s2440IOP->rGPECON = save_E;
  416. }
  418. void Wr_OV7620(U32 slvAddr, U32 addr, U8 data)
  419. {
  420.     _iicMode      = WRDATA;
  421.     _iicPt        = 0;
  422.     _iicData[0]   = (U8)addr;
  423.     _iicData[1]   = data;
  424.     _iicDataCount = 2;
  425.     // write slave address
  426.     s2440IIC->rIICDS = slvAddr;  //0x42: OV7620 Slave ID 
  427.     // After this time, timing is critical, because IIC start.
  428.     s2440IIC->rIICSTAT = 0xf0;  //Start Master TX Condition    
  429.     s2440IIC->rIICCON = 0xaf;    //Clearing the pending bit isn't needed because the pending bit has been cleared.
  431.     while(_iicDataCount!=-1)
  432.        Run_IicPoll();
  433.     
  434. }
  436. void Run_IicPoll(void)
  437. {
  438.     if(s2440IIC->rIICCON & 0x10)                  //Tx/Rx Interrupt Enable
  439.         IicPoll();
  440. }       
  442. void IicPoll(void)
  443. {
  444.     U32 iicSt,i;
  445. /*    
  446.     iicSt = s2440IIC->rIICSTAT; 
  447.     if(iicSt & 0x8){}                   //When bus arbitration is failed.
  448.     if(iicSt & 0x4){}                   //When a slave address is matched with IICADD
  449.     if(iicSt & 0x2){}                   //When a slave address is 0000000b
  450.     if(iicSt & 0x1){}                   //When ACK isn't received
  451. */
  452.     switch(_iicMode)
  453.     {
  454.         case RDDATA:
  455.             if((_iicDataCount--)==0)
  456.             {
  457.                 _iicData[_iicPt++] = s2440IIC->rIICDS;
  458.             
  459.                 s2440IIC->rIICSTAT = 0x90;      //Stop MasRx condition 
  460.                 s2440IIC->rIICCON  = 0xaf;      //Resumes IIC operation.
  461.                 Delay(1);                 //Wait until stop condtion is in effect., Too long time... 
  462.                                                 //The pending bit will not be set after issuing stop condition.
  463.                 break;    
  464.             }      
  465.             _iicData[_iicPt++] = s2440IIC->rIICDS;     //The last data has to be read with no ack.
  467.             if((_iicDataCount)==0)
  468.                 s2440IIC->rIICCON = 0x2f;                 //Resumes IIC operation with NOACK in case of OV7620 Cameara  
  469.             else 
  470.                 s2440IIC->rIICCON = 0xaf;                 //Resumes IIC operation with ACK
  471.             break;
  473.         case WRDATA:
  474.             
  475.             if((_iicDataCount--)==0)
  476.             {
  477.                 s2440IIC->rIICSTAT = 0xd0;                //stop MasTx condition 
  478.                 s2440IIC->rIICCON  = 0xaf;                //resumes IIC operation.
  479.                 Delay(10);                        // we should adjust this time.
  480.                 //The pending bit will not be set after issuing stop condition.
  481.                 break;    
  482.             }
  483.             
  484.             s2440IIC->rIICDS = _iicData[_iicPt++];         //_iicData[0] has dummy.
  485.             
  486. //            for(i=0;i<20;i++);                   //for setup time until rising edge of IICSCL. we have to adjust this time.
  487. RETAILMSG(1,(TEXT("B")));
  488.             
  489.             s2440IIC->rIICCON = 0xaf;                      //resumes IIC operation.
  490.             
  491.             break;
  493.         case SETRDADDR:
  494.           RETAILMSG(1,(TEXT("[S%d]",_iicDataCount)));
  495.             if((_iicDataCount--)==0)
  496.             {
  497.                   s2440IIC->rIICSTAT = 0xd0;                //stop MasTx condition 
  498.          s2440IIC->rIICCON  = 0xaf;                //resumes IIC operation.
  499.                   Delay(1);      //wait until stop condtion is in effect.
  501.                   break;                  //IIC operation is stopped because of IICCON[4]    
  502.             }
  504.             s2440IIC->rIICDS = _iicData[_iicPt++];
  505.             for(i=0;i<10;i++);          //for setup time until rising edge of IICSCL
  506.             s2440IIC->rIICCON = 0xaf;             //resumes IIC operation.
  507.             break;
  509.         default:
  510.             break;      
  511.     }
  512. }