标题: 搞定OV7670摄像头的数据采集问题程序 图像发白，模糊 [打印本页]

---

作者: xuwei    时间: 2015-6-14 01:21
标题: 搞定OV7670摄像头的数据采集问题程序 图像发白，模糊


做摄像头快一个半月了，今天终于有了重大的进展，终于把图像搞出来了，可是图像是发白，模糊，我初步估计是数据lost ,所以还要继续努力！
加油吧


江苏无锡市第五项目部临时工棚
主程序

1. /* Includes ------------------------------------------------------------------*/
   
2. #include "main.h"
   
3. /*记住自己做完头文件别忘了在左上角的品字形图标的C/C++里设置一下include选项奥，负责要出错的*/
   
4. GPIO_InitTypeDef GPIO_InitStructure;
   
5. 
   
6. int main(void)
   
7. {
   
8.   
   
9.    uint32_t numb;
   
10.    uint16_t date1,date2;
    
11.    init_STM32(); //开机初始化
    
12. 
    
13. 
    
14. 
    
15. 
    
16.   // my_send_byte(0x00); //发送一个字节
    
17.    //my_send_byte(0x01); //发送一个字节
    
18.    //my_send_byte(0x02); //发送一个字节
    
19.    //my_send_byte(0x03); //发送一个字节
    
20. 
    
21.   CLK_init_ON();//开启PA8的输出时钟8MHZ
    
22. LCD9328_init();//9328初始化
    
23.     SCCB_IIC_INIT();//IIC初始化函数
    
24.   
    
25.    delay1ms(20);
    
26. 
    
27. init_OV7670_POWER_UP();//0V7670的初始化寄存器设置
    
28.      delay1ms(10);
    
29.       // wrOV7670Reg(0x40, 0xd0);   
    
30.     write_ov7670_sccb_twi(0x17, 0x16);  
    
31.     write_ov7670_sccb_twi(0x18, 0x04);  
    
32.     write_ov7670_sccb_twi(0x19, 0x02);  
    
33.     write_ov7670_sccb_twi(0x1A, 0x7B);
    
34.     write_ov7670_sccb_twi(0x32, 0x40);  
    
35.     write_ov7670_sccb_twi(0x03, 0x0a);
    
36.   //  wrOV7670Reg(0x3E, 0x1A);
    
37.    
    
38.     write_ov7670_sccb_twi(0x70, 0x3A);
    
39.     write_ov7670_sccb_twi(0x71, 0x35);
    
40.     write_ov7670_sccb_twi(0x72, 0x11);  
    
41.     write_ov7670_sccb_twi(0x73, 0xF9);
    
42.     write_ov7670_sccb_twi(0xA2, 0x02);
    
43.    delay1ms(10);
    
44. 
    
45. 
    
46. 
    
47. 
    
48. 
    
49.   CLR_CS;
    
50.   CLR_RS;
    
51.   SET_RD;
    
52.   CLR_WR;
    
53.   GPIOE->ODR=0x0022;//GPIO_Write(GPIOE, reg);// //写入命令
    
54.   SET_WR;
    
55.   SET_RS;
    
56. 
    
57. SET_FIFO_WE;
    
58.    CLR_FIFO_WRST; //复位写地址为0
    
59. delay1us(40);
    
60. SET_FIFO_WRST;//初始化完毕，将从0地址开始
    
61. CLR_FIFO_WE;//关闭写FIFO使能
    
62. 
    
63.      CLR_FIFO_CS;//使能读
    
64.   CLR_FIFO_RD;  //RCK时钟拉低
    
65. CLR_FIFO_RRST; //度地址复位
    
66. SET_FIFO_RD;//RCK拉高
    
67. CLR_FIFO_RD;  //RCK拉低
    
68. SET_FIFO_RD;  //RCK拉高
    
69. CLR_FIFO_RD;
    
70. SET_FIFO_RD;  //RCK拉高
    
71. CLR_FIFO_RD;
    
72. CLR_FIFO_RD;  
    
73.     SET_FIFO_RD;  //RCK拉
    
74.     delay1us(2);
    
75. SET_FIFO_RRST; //拉高复位结束
    
76. 
    
77. 
    
78. 
    
79. //SET_FIFO_CS;//关闭能读
    
80. 
    
81.     //  SET_FIFO_WE;//开启写FIFO使能
    
82.   
    
83. my_EXTI_int();//外部中断初始化
    
84.      while(1)
    
85.     {
    
86. 
    
87. 
    
88.      if(vsync_counter==2)
    
89.     {
    
90.        EXTI->IMR=0;
    
91.       NVIC->ISER[0]=0;
    
92. 
    
93.     for(numb=76800;numb;numb--)
    
94.        {
    
95.       CLR_FIFO_RD;
    
96.       SET_FIFO_RD;
    
97.                    date1=GPIOA->IDR;
    
98.            date1<<=8;
    
99. 
    
100.         CLR_FIFO_RD;
     
101.       SET_FIFO_RD;
     
102. 
     
103.       date2=GPIOA->IDR;
     
104. 
     
105.       
     
106.       GPIOE->ODR=((date1&0xff00)|(date2&0x00ff));
     
107.       CLR_WR;
     
108.                      SET_WR;
     
109. 
     
110. 
     
111.         }
     
112.          
     
113.   
     
114.             
     
115.        CLR_FIFO_RRST;    //读指针复位
     
116.     CLR_FIFO_RD;   
     
117.     SET_FIFO_RD;
     
118.     CLR_FIFO_RD;   
     
119.     SET_FIFO_RD;
     
120.        SET_FIFO_RRST;
     
121. 
     
122. 
     
123.    CLR_FIFO_WRST;      
     
124.        delay1us(2);   
     
125.    SET_FIFO_WRST;
     
126.    vsync_counter = 0;
     
127.     EXTI->IMR=0x00000001;
     
128.          NVIC->ISER[0]=0x00000040;
     
129.    
     
130. 
     
131.     }
     
132. 
     
133.       }
     
134. 
     
135. 
     
136. 
     
137. 
     
138. 
     
139. }
     
140. void init_STM32()
     
141. {
     
142.    delay1ms(10000);
     
143.           mysysinit();
     
144. 
     
145.    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//使能GPIOA时钟
     
146.    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);//使能GPIOB时钟
     
147.    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);//使能GPIOC时钟
     
148.    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);//使能GPIOD时钟
     
149.    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);//使能GPIOE时钟
     
150.    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);//使能AFIO复用时钟
     
151.    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能USART1时钟
     
152.    RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1,ENABLE); //使能IIC1时钟
     
153. 
     
154.   /* LED8-11设置为指示灯，设置为输出推挽 */
     
155.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9|GPIO_Pin_10 | GPIO_Pin_11;
     
156.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
157.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
158.   GPIO_Init(GPIOD, &GPIO_InitStructure);
     
159. 
     
160.    /*  设置IIC总线的 PB10 and PB11 in 开楼复用输出 mode */ //I2C的两条总线
     
161.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
     
162.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
163.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
     
164.   GPIO_Init(GPIOB, &GPIO_InitStructure);
     
165. 
     
166. /* 设置PD口用于控制LCD的控制总线 */
     
167.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
     
168.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
169.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
170.   GPIO_Init(GPIOD, &GPIO_InitStructure);
     
171. /* 设置PE口用于控制LCD的为输出 */
     
172.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1| GPIO_Pin_2| GPIO_Pin_3| GPIO_Pin_4|
     
173.                                 GPIO_Pin_5 | GPIO_Pin_6| GPIO_Pin_7| GPIO_Pin_8| GPIO_Pin_9|
     
174.                                 GPIO_Pin_10 | GPIO_Pin_11| GPIO_Pin_12| GPIO_Pin_13| GPIO_Pin_14|
     
175.                                 GPIO_Pin_15 ;
     
176.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
177.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
178.   GPIO_Init(GPIOE, &GPIO_InitStructure);
     
179.    /* 设置PA口的低8位用于控制7670的数据输出 */
     
180.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1| GPIO_Pin_2| GPIO_Pin_3| GPIO_Pin_4|
     
181.                                 GPIO_Pin_5 | GPIO_Pin_6| GPIO_Pin_7;
     
182.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
183.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
     
184.   GPIO_Init(GPIOA, &GPIO_InitStructure);
     
185. 
     
186.   /* 422B的操作设置，设置为输出推挽 */
     
187.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 | GPIO_Pin_14|GPIO_Pin_13 | GPIO_Pin_12| GPIO_Pin_11;
     
188.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
189.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
190.   GPIO_Init(GPIOB, &GPIO_InitStructure);
     
191. 
     
192.    /*串口初始化*/
     
193.   //my_USART_init();
     
194. 
     
195.          
     
196. 
     
197. }
     
198. 
     
199. 
     
200. 
     
201. void mysysinit()//系统初始化程序
     
202. {
     
203. ErrorStatus HSEStartUpStatus;//说明标志位
     
204. RCC_DeInit();//所有外设全部缺省设置
     
205. 
     
206. /* Enable HSE */
     
207. RCC_HSEConfig(RCC_HSE_ON);
     
208. /* Wait till HSE is ready and if Time out is reached exit */
     
209. HSEStartUpStatus = RCC_WaitForHSEStartUp();
     
210. if(HSEStartUpStatus == SUCCESS)//启动成功
     
211. {
     
212. /*这两条FLASH指令必须加上，不知为啥？不加上就运行几秒后出错，参照系统初始化*/
     
213. /* Enable The Prefetch Buffer */
     
214. FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);//FLASH缓存开启
     
215. /* Configure the Latency cycle: Set 2 Latency cycles */
     
216.   FLASH_SetLatency(FLASH_Latency_2);  //设置FLASH这些位表示SYSCLK(系统时钟)周期与闪存访问时间的比例,为010：两个等待状态，当 48MHz < SYSCLK ≤ 72MHz
     
217. /* Set PLL clock output to 72MHz using HSE (8MHz) as entry clock */
     
218. RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);//外部时钟为8M，PLL的输入时钟=8MHZ，倍频系数9，
     
219. 
     
220. /* Configure HCLK such as HCLK = SYSCLK */
     
221. RCC_HCLKConfig(RCC_SYSCLK_Div1);//设置了啦AHB分频器的分频系数=1，即HCLK=SYSCLK=72MHZ
     
222. /* Configure PCLK1 such as PCLK1 = HCLK/2 */
     
223. RCC_PCLK1Config(RCC_HCLK_Div2);//设置了APB1外设的时钟频率最大是36M这里是APB1的分频器设为2,PCLK1=HCLK/2=72/2=36MHZ正好是最大值
     
224. /* Configure PCLK2 such as PCLK2 = HCLK */
     
225. RCC_PCLK2Config(RCC_HCLK_Div1);//设置PLCK2=HCLK=72MHZ，的APB2分频器=1
     
226. /* Select the PLL as system clock source */
     
227. RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);//设置了SYSCLK的提供者为PLL，频率由上面算出=72MHZ
     
228. /* disable PLL Ready interrupt */
     
229. RCC_ITConfig(RCC_IT_PLLRDY, DISABLE);//PLL中断关闭
     
230. /* disable PLL Ready interrupt */
     
231. RCC_ITConfig(RCC_IT_HSERDY,DISABLE);//HSE中断关闭
     
232. /* disable PLL Ready interrupt */
     
233. RCC_ITConfig(RCC_IT_HSIRDY, DISABLE); //HSI中断关闭
     
234. /* disable PLL Ready interrupt */
     
235. RCC_ITConfig(RCC_IT_LSERDY, DISABLE); //LSE中断关闭
     
236. /* disable PLL Ready interrupt */
     
237. RCC_ITConfig(RCC_IT_LSIRDY, DISABLE); //LSI中断关闭
     
238. 
     
239. /* PLL clock divided by 1.5 used as USB clock source */
     
240. RCC_USBCLKConfig(RCC_USBCLKSource_PLLCLK_1Div5);//设置USB的时钟为=72、1.5=48mhz
     
241. /* Configure ADCCLK such as ADCCLK = PCLK2/2 */
     
242. RCC_ADCCLKConfig(RCC_PCLK2_Div2);//设置ADC时钟=PCLK2/2= 36MHZ
     
243. /* disable the LSE */
     
244. RCC_LSEConfig(RCC_LSE_OFF);//外部低速晶振关闭
     
245. 
     
246. /*DISable the RTC clock */
     
247. RCC_RTCCLKCmd(DISABLE);
     
248. /* DISable the Clock Security System */
     
249. RCC_ClockSecuritySystemCmd(DISABLE);
     
250. /* Enable the PLL */
     
251. RCC_PLLCmd(ENABLE);//使能PLL
     
252. 
     
253. 
     
254. 
     
255. 
     
256. 
     
257. 
     
258. 
     
259. /* PLL ans system clock config */
     
260. }
     
261. else
     
262. {
     
263. /* Add here some code to deal with this error */
     
264. }
     
265. 
     
266. 
     
267. 
     
268. 
     
269. 
     
270. }
     
271. 
     
272. 中断程序
     
273. 
     
274. #include "stm32f10x_it.h"
     
275. uint8_t vsync_counter=0;
     
276. 
     
277. void EXTI0_IRQHandler(void)//场中断 PC0
     
278. { EXTI->PR|=0x00000001;
     
279. // EXTI->IMR=0;
     
280.    vsync_counter++;
     
281.      if(2==vsync_counter)
     
282.     {
     
283.        CLR_FIFO_CS;//使能读
     
284.        CLR_FIFO_WE;//禁止写入FIFO数据
     
285.       
     
286.       
     
287.       
     
288.   
     
289.     }
     
290.     else
     
291.     {SET_FIFO_WE;//开启写FIFO使能
     
292.     }
     
293. 
     
294. 
     
295.    //EXTI->IMR=0x00000001;
     
296. 
     
297. }
     
298. 
     
299. 7670程序
     
300. 
     
301. void init_OV7670_POWER_UP()//0V7670的初始化寄存器设置
     
302. {
     
303. uint16_t  i;
     
304. 
     
305. 
     
306. for(i=0;i<176;i++)
     
307. {
     
308.   write_ov7670_sccb_twi(change_reg[i][0],change_reg[i][1]);
     
309.   
     
310. }
     
311. 
     
312. 
     
313. /*PA8的MCO时钟输出为关闭，切换到普通IO*/
     
314. void CLK_init_OFF(void)
     
315. {
     
316. 
     
317.     GPIO_InitTypeDef GPIO_InitStructure;
     
318.     //时钟的输出txz
     
319.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
     
320.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
     
321.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
322.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
323.     GPIO_Init(GPIOA, &GPIO_InitStructure);
     
324.     RCC->CFGR&=0xf8ffffff;//RCC_MCOConfig(RCC_MCO_HSE  );//hsi
     
325. }
     
326. void write_ov7670_sccb_twi(uint8_t add,uint8_t date)
     
327. {  uint8_t a;
     
328. 
     
329. delay1ms(500);
     
330.    I2C1->CR1=1;//开启IIC
     
331. 
     
332. //my_send_byte(0x80);
     
333.   I2C1->CR1=0x0101;//发送起始位
     
334. 
     
335.    while(1)
     
336.   { a=I2C1->SR1;
     
337.     a=(a&0x0001);
     
338.   delay1ms(1);
     
339. //my_send_byte(0x11);
     
340.    if(a==0x0001)
     
341.    break;
     
342.   
     
343.       
     
344.   }//EV5是向下
     
345. 
     
346.   I2C1->DR=0x42;//写入地址
     
347.   delay1ms(10);
     
348. 
     
349.   while(1)
     
350.   { a=I2C1->SR1;
     
351.     a=(a&0x0002);
     
352.   delay1ms(1);
     
353. // my_send_byte(0x22);
     
354.    if(a==0x0002)
     
355.    break;
     
356.   
     
357.       
     
358.   }//EV6ADDR发送？是向下，否等待
     
359. a=I2C1->SR1;
     
360.   a=I2C1->SR2;
     
361. //my_send_byte((I2C1->SR1));
     
362. //my_send_byte((I2C1->SR2)); //必须读SR1
     
363. 
     
364.   I2C1->DR=add;//写入寄存地址
     
365. 
     
366.    while(1)
     
367.   { a=I2C1->SR1;
     
368.     a=(a&0x0080);
     
369.   delay1ms(1);
     
370. //my_send_byte(0x33);
     
371.    if(a==0x0080)
     
372.    break;
     
373.   
     
374.       
     
375.   }//EV8寄存器为空？是向下，否等待
     
376.   a=I2C1->SR1;
     
377.   a=I2C1->SR2;
     
378. //my_send_byte((I2C1->SR1));
     
379. //my_send_byte((I2C1->SR2)); //必须读SR1
     
380. 
     
381.   I2C1->DR=date;//写数据
     
382. 
     
383.    while(1)
     
384.   { a=I2C1->SR1;
     
385.     a=(a&0x0080);
     
386.   delay1ms(1);
     
387. // my_send_byte(0x44);
     
388.    if(a==0x0080)
     
389.    break;
     
390.   
     
391.       
     
392.   }//EV8寄存器为空？是向下，否等待
     
393. 
     
394.     delay1ms(1);
     
395.    while(1)
     
396.   {a=I2C1->SR1;
     
397.    a=(a&0x0084);
     
398.     delay1ms(1);
     
399. // my_send_byte(0x55);
     
400.    if(a==0x0084)
     
401.    break;
     
402.   
     
403.       
     
404.   }//EV8-2发送完成，寄存器为空？是向下，否等待
     
405. 
     
406. 
     
407.    
     
408.   
     
409. I2C1->CR1=0x0201;//STOP
     
410. 
     
411. 
     
412. 
     
413. }
     
414. 
     
415. /******************************
     
416. 
     
417. SCCB底层操作函数利用硬件模块IIC读取一个指定地址的数据
     
418. 
     
419. 返回值：为读取的数据
     
420. 形参：为将要读取的寄存器地址
     
421. 
     
422. *****************************8*/
     
423. uint8_t SCCB_IIC_READ(uint8_t add)//读一个字节数据
     
424. {
     
425. uint8_t date;
     
426. uint16_t a;
     
427. 
     
428. delay1ms(3000);
     
429.   I2C1->CR1=1;//开启IIC
     
430. 
     
431. //my_send_byte(0x80);
     
432.   I2C1->CR1=0x0101;//发送起始位
     
433. 
     
434.    while(1)
     
435.   { a=I2C1->SR1;
     
436.     a=(a&0x0001);
     
437.   delay1ms(2);
     
438. // my_send_byte(0x11);
     
439.    if(a==0x0001)
     
440.    break;
     
441.   
     
442.       
     
443.   }//EV5是向下
     
444. 
     
445.   I2C1->DR=0x42;//写入地址
     
446. 
     
447. 
     
448.   delay1ms(10);
     
449. 
     
450.   while(1)
     
451.   { a=I2C1->SR1;
     
452.     a=(a&0x0002);
     
453.   delay1ms(1);
     
454. // my_send_byte(0x22);
     
455.    if(a==0x0002)
     
456.    break;
     
457.   
     
458.       
     
459.   }//EV6ADDR发送？是向下，否等待
     
460. 
     
461.   a=I2C1->SR1;
     
462.   a=I2C1->SR2;
     
463. //my_send_byte((I2C1->SR1));
     
464. //my_send_byte((I2C1->SR2)); //必须读SR1
     
465. 
     
466.   I2C1->DR=add;//写入寄存地址
     
467. 
     
468.    while(1)
     
469.   { a=I2C1->SR1;
     
470.     a=(a&0x0080);
     
471.   delay1ms(1);
     
472. // my_send_byte(0x33);
     
473.    if(a==0x0080)
     
474.    break;
     
475.   
     
476.       
     
477.   }//EV8寄存器为空？是向下，否等待
     
478. 
     
479. 
     
480.   delay1ms(1);
     
481.    while(1)
     
482.   {a=I2C1->SR1;
     
483.    a=(a&0x0084);
     
484.     delay1ms(1);
     
485. // my_send_byte(0x44);
     
486.    if(a==0x0084)
     
487.    break;
     
488.   
     
489.       
     
490.   }//EV8-2发送完成，寄存器为空？是向下，否等待
     
491. 
     
492. 
     
493.    
     
494.   
     
495. I2C1->CR1=0x0201;//STOP
     
496.   //delay(1000000);
     
497. ///delay(10000);
     
498.   delay1ms(10);
     
499.   //my_send_byte(0x88);
     
500. 
     
501. I2C1->CR1=0x0101;//发送起始位
     
502. 
     
503.    while(1)
     
504.   { a=I2C1->SR1;
     
505.     a=(a&0x0001);
     
506. delay1ms(2);
     
507. //my_send_byte(0x55);
     
508.    if(a==0x0001)
     
509.    break;
     
510.   
     
511.       
     
512.   }//EV5是向下
     
513. 
     
514.   I2C1->DR=0x43;//写入地址
     
515. 
     
516. 
     
517.   delay1ms(1);
     
518. 
     
519.   while(1)
     
520.   { a=I2C1->SR1;
     
521.     a=(a&0x0002);
     
522.   delay1ms(1);
     
523. // my_send_byte(0x66);
     
524.    if(a==0x0002)
     
525.    break;
     
526.   
     
527.       
     
528.   }//EV6ADDR发送？是向下，否等待
     
529. 
     
530.   a=I2C1->SR1;
     
531.   a=I2C1->SR2;
     
532.    delay1ms(1);
     
533.    // my_send_byte(I2C1->SR1);
     
534.   // my_send_byte(I2C1->SR2);
     
535. 
     
536.    
     
537.   while(1)
     
538.   { a=I2C1->SR1;
     
539.     a=(a&0x0040);
     
540.   delay1ms(1);
     
541. //my_send_byte(0x77);
     
542.    if(a==0x0040)
     
543.    break;
     
544.   
     
545.       
     
546.   }//EV7ARXEN发送？是向下，否等待
     
547.   date=I2C1->DR;
     
548. 
     
549.   I2C1->CR1=0x0201;//STOP
     
550. 
     
551.    return date;
     
552. 
     
553. }
     
554. void SCCB_IIC_INIT()//IIC初始化函数
     
555. {
     
556.    delay1ms(5000);
     
557.      I2C1->CR1=0;//关闭I2C
     
558.   I2C1->CR2=2;//IIC的时钟源设为8MHZ，但是这不是总线上的时钟，他是由CCR1，分频后作为SCL时钟 的，见手册，
     
559.      I2C1->CCR=400;//标准IIC模式，对IIC时钟源的分频系数是40，用来产生10KHZ的SCL时钟
     
560.   I2C1->TRISE=3;//SCL的上升沿时间宽度为300NS
     
561.   I2C1->CR1=1;//开启IIC；
     
562. 
     
563. }
     
564. void delay1ms(uint32_t a)
     
565. {
     
566. for(a=23980;a;a--);
     
567. 
     
568. }
     
569. 
     
570. 9328程序
     
571. 
     
572. #include "ili9328.h"
     
573. uint8_t tab[]={/*--  文字:  王  --*/
     
574. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
     
575. 0x00,0x00,0x7F,0xFC,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x3F,0xF8,
     
576. 0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0xFF,0xFE,0x00,0x00};
     
577. 
     
578. void write_LCD_CHINA_WRODS()
     
579. {
     
580. uint8_t i,val,n;
     
581. 
     
582. 
     
583. 
     
584. wr_cmd_date(0x0050,0);//行开始坐标
     
585.   wr_cmd_date(0x0051,15); //行结束坐标
     
586.   wr_cmd_date(0x0052,0);//场开始地址坐标
     
587.   wr_cmd_date(0x0053,15); //场结束地址坐标
     
588.   wr_cmd_date(0x0020,0); //行地址计数器
     
589.   wr_cmd_date(0x0021,0);//场地址计数器
     
590. 
     
591.   for(n=0;n<32;n++)
     
592. {
     
593.   for(i=0;i<8;i++)
     
594.   {
     
595.      val=tab[n];
     
596.      if(((val<<i)&0x80)==0x80)
     
597.      {
     
598.        wr_cmd_date(0x22,0x0000 );//bloke
     
599.      }
     
600.      else
     
601.      {
     
602.    
     
603.          wr_cmd_date(0x22,0xf800 );//red
     
604.    
     
605.      }
     
606.   
     
607.   
     
608.   
     
609.   }
     
610. 
     
611.   
     
612.    
     
613. }
     
614. 
     
615.   
     
616.   
     
617. 
     
618. 
     
619. }
     
620. 
     
621. void lcm_coordinate(uint16_t x1,uint16_t y1 )//扫描地 写一个像素
     
622. {
     
623. 
     
624.   wr_cmd_date(0x0050,x1);//行开始坐标
     
625.   wr_cmd_date(0x0051,x1); //行结束坐标
     
626.   wr_cmd_date(0x0052,y1);//场开始地址坐标
     
627.   wr_cmd_date(0x0053,y1); //场结束地址坐标
     
628.   wr_cmd_date(0x0020,x1); //行地址计数器
     
629.   wr_cmd_date(0x0021,y1);//场地址计数器
     
630. 
     
631. }
     
632. void LCD9328_init()//横屏初始
     
633. {
     
634.    uint32_t a;
     
635. delay1us(150000);
     
636.   wr_cmd_date(0x0001,0x0100); //s1-s720
     
637.   wr_cmd_date(0x0002,0x0700);
     
638.   wr_cmd_date(0x0003,0x1038);//默认0x1030,现在设为0X1038.1018
     
639.    wr_cmd_date(0x0004,0x0000);
     
640.   wr_cmd_date(0x0008,0x0404);
     
641.   wr_cmd_date(0x0009,0x0000);
     
642.   wr_cmd_date(0x000A,0x0000);
     
643.   wr_cmd_date(0x000C,0x0000);
     
644.   wr_cmd_date(0x000D,0x0000);
     
645. wr_cmd_date(0x000F,0x0000);
     
646. //power on sequence VGHVGL
     
647.   wr_cmd_date(0x0010,0x0080);  
     
648.   wr_cmd_date(0x0011,0x0007);
     
649.   wr_cmd_date(0x0012,0x0000);
     
650.   wr_cmd_date(0x0013,0x0000);
     
651. //vgh
     
652.   wr_cmd_date(0x0010,0x1590);  
     
653.   wr_cmd_date(0x0011,0x0227);
     
654. delay1us(800000);
     
655. //vregiout
     
656.   wr_cmd_date(0x0012,0x001F); //0x001b
     
657. delay1us(800000);
     
658. //vom amplitude
     
659.   wr_cmd_date(0x0013,0x1500);
     
660. delay1us(800000);
     
661. //vom H
     
662.   wr_cmd_date(0x0029,0x0022);
     
663.   wr_cmd_date(0x002B,0x000F);
     
664. 
     
665. //gamma
     
666.   wr_cmd_date(0x0030,0x0004);
     
667.   wr_cmd_date(0x0031,0x0307);
     
668.   wr_cmd_date(0x0032,0x0002);// 0006
     
669.   wr_cmd_date(0x0035,0x0206);
     
670.   wr_cmd_date(0x0036,0x0408);
     
671.   wr_cmd_date(0x0037,0x0507);
     
672.   wr_cmd_date(0x0038,0x0204);//0200
     
673.   wr_cmd_date(0x0039,0x0707);
     
674.   wr_cmd_date(0x003C,0x0405);// 0504
     
675.   wr_cmd_date(0x003D,0x0F02);
     
676. //ram
     
677.   /*wr_cmd_date(0x0050,0x0000);
     
678.   wr_cmd_date(0x0051,0x00B0);
     
679.   wr_cmd_date(0x0052,0x0000);
     
680.   wr_cmd_date(0x0053,0x00DC);*/
     
681.    wr_cmd_date(0x0050,0x0000);
     
682.   wr_cmd_date(0x0051,0x00EF);
     
683.   wr_cmd_date(0x0052,0x0000);
     
684.   wr_cmd_date(0x0053,0x0013F);
     
685.   wr_cmd_date(0x0060,0xA700);
     
686.   wr_cmd_date(0x0061,0x0001);
     
687.   wr_cmd_date(0x006A,0x0000);
     
688. //
     
689.   wr_cmd_date(0x0080,0x0000);
     
690.   wr_cmd_date(0x0081,0x0000);
     
691.   wr_cmd_date(0x0082,0x0000);
     
692.   wr_cmd_date(0x0083,0x0000);
     
693.   wr_cmd_date(0x0084,0x0000);
     
694.   wr_cmd_date(0x0085,0x0000);
     
695. //
     
696.   wr_cmd_date(0x0090,0x0010);
     
697.   wr_cmd_date(0x0093,0x0003);
     
698.   wr_cmd_date(0x0095,0x0110);
     
699.   wr_cmd_date(0x0097,0x0000);
     
700.   wr_cmd_date(0x0098,0x0000);
     
701.   wr_cmd_date(0x0007,0x0173);
     
702.    for(a=76800;a;a--)
     
703.    {
     
704.   wr_cmd_date(0x22,0xF800);//红色刷屏
     
705.   }
     
706. }
     
707. 
     
708. 
     
709. void wr_cmd_date(uint16_t reg,uint16_t date)
     
710. {
     
711. 
     
712.   GPIOE->CRL=0x33333333; //数据口转换成输出
     
713.   GPIOE->CRH=0x33333333; //数据口转换成输出
     
714. 
     
715.   CLR_CS;
     
716.   CLR_RS;
     
717.   SET_RD;
     
718.   CLR_WR;
     
719.   GPIOE->ODR=reg;//GPIO_Write(GPIOE, reg);// //写入命令
     
720.   SET_WR;
     
721.   SET_RS;
     
722.   //delay_1us(1);
     
723.   CLR_WR;
     
724. GPIOE->ODR=date;//GPIO_Write(GPIOE, date); // //写入命令
     
725.   SET_WR;
     
726.   SET_CS;
     
727. 
     
728. }
     
729. uint16_t read_LCD_register(uint16_t reg)
     
730. {
     
731.    uint16_t date;
     
732. GPIOE->CRL=0x33333333; //数据口转换成输出
     
733. GPIOE->CRH=0x33333333; //数据口转换成输出
     
734.    CLR_CS;
     
735.    //delay_1us(1);
     
736.    CLR_RS;
     
737.    //delay_1us(1);
     
738.    SET_RD;
     
739.    CLR_WR;
     
740.    GPIO_Write(GPIOE, reg); //写入命令
     
741.    SET_WR;
     
742.    //delay_1us(1);
     
743.    CLR_RD;
     
744.    GPIOE->CRL=0x88888888; //数据口转换成输入
     
745.    GPIOE->CRH=0x88888888; //数据口转换成输入
     
746.   // for(n=200;n;n--);
     
747.    date=(GPIOE->IDR);//读出数据
     
748.    SET_RD;
     
749.    SET_CS;
     
750.   
     
751. 
     
752.   return (date);
     
753. 
     
754. 
     
755. }
     
756. void delay1us(uint32_t time)
     
757. {   uint32_t b,c;
     
758.         for(c=time;c;c--) //定时=time*3*333.6=time*1000.8ns
     
759.          {     
     
760.    for(b=8;b;b--); //8*13.9*3= 333.6     
     
761.          }
     
762. 
     
763. 
     
764. 
     
765. }
     
766. 终端配置
     
767. 
     
768. #include "EXTI.h"
     
769. /***********************
     
770. 外部中断初始化
     
771. **************************/
     
772. void my_EXTI_int()
     
773. {
     
774. /*  PC0 被我设置成输入模式,上拉、下拉 */
     
775. GPIOC->CRL=0x00000008;
     
776. 
     
777. /*配置PC0作为中断输入线*/
     
778. AFIO->EXTICR[0]=2;
     
779. 
     
780. /*设置开启外部中断线0中断请求，其他的都关闭*/
     
781. EXTI->IMR=0x00000001;
     
782. 
     
783. /*PC0开启上升沿触发*/
     
784. EXTI->RTSR=0x00000001;
     
785. 
     
786. 
     
787.    /*设置PC0中断的优先级为5*/
     
788. NVIC->IP[6]=5;//VSYNC
     
789. /*开启号中断即EXTI0，关闭其他所有外部的中断*/
     
790. NVIC->ISER[0]=0x00000040; //开启PC0中断EXTI0 VSYNC中断
     
791. 
     
792. 
     
793. 
     
794. 
     
795. 
     
796. 
     
797. }
     
798. 
     

复制代码

---

作者: xuwei    时间: 2015-6-14 01:21


  呵呵就在刚才我又解决一个摄像头问体，就是以前出的图像有是有，但是有许多白色的线，想干扰一样，现在我的做法是提高了摄像头的输入XCLK频率到18MHZ，无意中竟然破天荒的解决了这个问题哈哈，现在的图像稳定，只是很模糊，所以找到什么导致模糊的原因就搞定了！哈哈哈，原来是8MHZ的速度，可能是写的过程中太慢，导致采集错误造成的吧！哈哈，高兴啊，虽然没有完全解决，但是只要向前进我就高兴啊，呼呼，继续搞图像，图像的颜色也是对的，轮廓也正常，说明了我的摄像头输出的行场同步和TFT彩色液晶是吻合的，没有问题的，关键现在问题锁定到了显存的读写时序和像素的数据正确读，像素应改是大部分对，肯定是某个地方的数据要吗丢失，要吗引入不正确的数据位，这是个头疼的问题，现在的现象是白的地方发绿，这个RGB信号啊！愁人，加油吧！
     这一个月来一直在搞摄像头，因为我决的摄像头对我来说非常重要。知道现在也没搞好，总结来看，摄像头的底层通信驱动早已轻车熟路，关键是速度匹配问题。因此我昨天买了显存，准备数据缓冲，可是昨天腾经理说要我去无锡工地，我问了爸爸，爸爸说可以去，我无话可说，只有应承，所以很遗憾摄像头的驱动要放一放，因为一方面SOP封装转DIP是头疼的，另一个即将要去一个陌生的遥远的地方，心下很是忐忑，有点飘！感觉，不知道未来在哪里，低头走我的小路吧！今天玩了一天游戏，没有心情干任何事，为什么当我要离开一个地方时，心情总是不爽。但是我会继续。。。人年少就是要学习，不断地充实自己，不断地积累，就算以后一事无成，我也不后悔，因为我没去挥霍这宝贵的青春，而是学了自己喜欢的东西！我总是相信知识是相通的，我不会放弃的，我想这就是我的理想所在吧！

---

作者: xuwei    时间: 2015-6-14 01:22
       搞图像采集搞了没有2个月也差不多了，我买32的最大的目的就是做摄像头，想当年，和老海商量盗墓的事，我那时候就幻想什么时候能做个机器人小车带摄像头的就好了，我们遥控小车进去抓宝贝，今天虽然这个梦想没有实现，但是我有掌握了一项核心的东西，图像采集，其实现在看来这个图像传感器并不复杂，主要是加了一块缓存器，使她的速度一下子成了一个无关项，不论你的速度有多慢，都可以采集图像，32的主频运行在72MHZ下我大概测试的帧率在8-15之间，其实如果排出硬件的问题我完全可以更早的解决，只是期间我不懂买了不好的原件，导致我的实验一直不成功，最近的一次是图像模糊，现在终于大白了，原来是显存问题，导致的，我说啊我反反复复的检查测试，检查测试，数据链路根本没问题，就是很模糊，问了很多人，又说时序不对的，又说数据比特错误，总之我是昏了头，直到我买了这一块，才解决了，第一次看到我自己的图像，真是高兴啊，这也就对于32来说也值了，我写了多少次啊，不知道，大概得有56百次，为此我还担心32的FLASH是不是受得了，几乎每天都要写个78十次，我有没有LINK仿真器，只有看现象，所以还是不易的，多少个日日夜夜，看到图像啥也没有了，兴趣，也许这就是我的动力吧！加油吧！不骄不躁，继续加油，以后就可以给他加上个无线，和把它存储，就成了简易说的录相机了！呵呵，上程序：由于程序太大，只上主函数
2011年10月10日
于江苏无锡第五项目部工棚内
王均伟
图像采集程序
硬件接口
CPU:contex-m3内核
主频：72MHZ
数据总线：PA0-PA7对应D0-D7
控制总线：OE:PB15/RRST:PB14/WRST:PB13/RCK:PB12/WE:PB11/VSYNC:PC0
SCCB总线：SCL:PB6/SDA:PB7，硬件实现

*/

/* Includes ------------------------------------------------------------------*/
#include "main.h"
/*记住自己做完头文件别忘了在左上角的品字形图标的C/C++里设置一下include选项奥，负责要出错的*/
GPIO_InitTypeDef GPIO_InitStructure;

int main(void)
{
   
   uint32_t numb;
   uint16_t date1,date2;
   init_STM32(); //开机初始化


  // my_send_byte(0x00); //发送一个字节
   //my_send_byte(0x01); //发送一个字节
   //my_send_byte(0x02); //发送一个字节
   //my_send_byte(0x03); //发送一个字节

  
LCD9328_init();//9328初始化
SCCB_IIC_INIT();//IIC初始化函数
   delay1ms(20);
init_OV7670_POWER_UP();//0V7670的初始化寄存器设置  
  CLR_CS;
  CLR_RS;
  SET_RD;
  CLR_WR;
  GPIOE->ODR=0x0022;//GPIO_Write(GPIOE, reg);// //写入命令
  SET_WR;
  SET_RS;
  SET_FIFO_WE;
  CLR_FIFO_OE;

/*


  CLR_FIFO_RCLK;  //RCK时钟拉低
CLR_FIFO_RRST; //度地址复位
SET_FIFO_RCLK;//RCK拉高
CLR_FIFO_RCLK;  //RCK拉低
SET_FIFO_RCLK;  //RCK拉高
CLR_FIFO_RCLK;
    delay1us(100);
SET_FIFO_RRST; //拉高复位结束
     
  
my_EXTI_int();//外部中断初始化
  while(1)
{
  
    if(vsync==2)
    { EXTI->IMR=0;
          CLR_FIFO_RRST;    //读指针复位
    CLR_FIFO_RCLK;    //至少需要一个时钟周期的跳变才能复位
  
    SET_FIFO_RCLK;
   
    CLR_FIFO_RCLK;;
      //至少需要一个时钟周期的跳变才能复位
       SET_FIFO_RRST;
    SET_FIFO_RCLK;
        // NVIC->ISER[0]=0;
      
    for(numb=76800;numb;numb--)
       {
      CLR_FIFO_RCLK;
     date1=GPIOA->IDR;
      SET_FIFO_RCLK;
                  
           date1<<=8;
        CLR_FIFO_RCLK;
        date2=GPIOA->IDR;
      SET_FIFO_RCLK;
     
   
        
      GPIOE->ODR=(date1&0xff00)|(date2&0x00ff);
      CLR_WR;
                     SET_WR;
       }
   /* while(1);
   //SET_FIFO_WE;   
   CLR_FIFO_WRST;      
       delay1us(150);   
   SET_FIFO_WRST;
     //CLR_FIFO_CS;
       CLR_FIFO_RRST;    //读指针复位
    CLR_FIFO_RCLK;    //至少需要一个时钟周期的跳变才能复位
  
    SET_FIFO_RCLK;
   
    CLR_FIFO_RCLK;;
      //至少需要一个时钟周期的跳变才能复位
    SET_FIFO_RCLK;
    delay1us(100);
       SET_FIFO_RRST;
   */
   EXTI->IMR=0x00000001;
        // NVIC->ISER[0]=0x00000040;
   vsync= 0;
  
  
  
  
  
  
  
   }
        

           
      
   
  
  }


}
void init_STM32()
{
   delay1ms(10000);
          mysysinit();
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//使能GPIOA时钟
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);//使能GPIOB时钟
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);//使能GPIOC时钟
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);//使能GPIOD时钟
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);//使能GPIOE时钟
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);//使能AFIO复用时钟
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能USART1时钟
   RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1,ENABLE); //使能IIC1时钟
  /* LED8-11设置为指示灯，设置为输出推挽 */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9|GPIO_Pin_10 | GPIO_Pin_11;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(GPIOD, &GPIO_InitStructure);
   /*  设置IIC总线的 PB10 and PB11 in 开楼复用输出 mode */ //I2C的两条总线
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
/* 设置PD口用于控制LCD的控制总线 */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(GPIOD, &GPIO_InitStructure);
/* 设置PE口用于控制LCD的为输出 */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1| GPIO_Pin_2| GPIO_Pin_3| GPIO_Pin_4|
                                GPIO_Pin_5 | GPIO_Pin_6| GPIO_Pin_7| GPIO_Pin_8| GPIO_Pin_9|
                                GPIO_Pin_10 | GPIO_Pin_11| GPIO_Pin_12| GPIO_Pin_13| GPIO_Pin_14|
                                GPIO_Pin_15 ;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(GPIOE, &GPIO_InitStructure);
   /* 设置PA口的低8位用于控制7670的数据输出 */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1| GPIO_Pin_2| GPIO_Pin_3| GPIO_Pin_4|
                                GPIO_Pin_5 | GPIO_Pin_6| GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  /* 422B的操作设置，设置为输出推挽 */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 | GPIO_Pin_14|GPIO_Pin_13 | GPIO_Pin_12| GPIO_Pin_11;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
   /*串口初始化*/
my_USART_init();

}

void mysysinit()//系统初始化程序
{
ErrorStatus HSEStartUpStatus;//说明标志位
RCC_DeInit();//所有外设全部缺省设置
/* Enable HSE */
RCC_HSEConfig(RCC_HSE_ON);
/* Wait till HSE is ready and if Time out is reached exit */
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if(HSEStartUpStatus == SUCCESS)//启动成功
{
/*这两条FLASH指令必须加上，不知为啥？不加上就运行几秒后出错，参照系统初始化*/
/* Enable The Prefetch Buffer */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);//FLASH缓存开启
/* Configure the Latency cycle: Set 2 Latency cycles */
  FLASH_SetLatency(FLASH_Latency_2);  //设置FLASH这些位表示SYSCLK(系统时钟)周期与闪存访问时间的比例,为010：两个等待状态，当 48MHz < SYSCLK ≤ 72MHz
/* Set PLL clock output to 72MHz using HSE (8MHz) as entry clock */
RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);//外部时钟为8M，PLL的输入时钟=8MHZ，倍频系数9，
/* Configure HCLK such as HCLK = SYSCLK */
RCC_HCLKConfig(RCC_SYSCLK_Div1);//设置了啦AHB分频器的分频系数=1，即HCLK=SYSCLK=72MHZ
/* Configure PCLK1 such as PCLK1 = HCLK/2 */
RCC_PCLK1Config(RCC_HCLK_Div2);//设置了APB1外设的时钟频率最大是36M这里是APB1的分频器设为2,PCLK1=HCLK/2=72/2=36MHZ正好是最大值
/* Configure PCLK2 such as PCLK2 = HCLK */
RCC_PCLK2Config(RCC_HCLK_Div1);//设置PLCK2=HCLK=72MHZ，的APB2分频器=1
/* Select the PLL as system clock source */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);//设置了SYSCLK的提供者为PLL，频率由上面算出=72MHZ
/* disable PLL Ready interrupt */
RCC_ITConfig(RCC_IT_PLLRDY, DISABLE);//PLL中断关闭
/* disable PLL Ready interrupt */
RCC_ITConfig(RCC_IT_HSERDY,DISABLE);//HSE中断关闭
/* disable PLL Ready interrupt */
RCC_ITConfig(RCC_IT_HSIRDY, DISABLE); //HSI中断关闭
/* disable PLL Ready interrupt */
RCC_ITConfig(RCC_IT_LSERDY, DISABLE); //LSE中断关闭
/* disable PLL Ready interrupt */
RCC_ITConfig(RCC_IT_LSIRDY, DISABLE); //LSI中断关闭
/* PLL clock divided by 1.5 used as USB clock source */
RCC_USBCLKConfig(RCC_USBCLKSource_PLLCLK_1Div5);//设置USB的时钟为=72、1.5=48mhz
/* Configure ADCCLK such as ADCCLK = PCLK2/2 */
RCC_ADCCLKConfig(RCC_PCLK2_Div2);//设置ADC时钟=PCLK2/2= 36MHZ
/* disable the LSE */
RCC_LSEConfig(RCC_LSE_OFF);//外部低速晶振关闭
/*DISable the RTC clock */
RCC_RTCCLKCmd(DISABLE);
/* DISable the Clock Security System */
RCC_ClockSecuritySystemCmd(DISABLE);
/* Enable the PLL */
RCC_PLLCmd(ENABLE);//使能PLL



/* PLL ans system clock config */
}
else
{
/* Add here some code to deal with this error */
}


}

---

作者: xuyuhaoa    时间: 2015-10-26 10:36
带FIFO的7670驱动早有了，何必这么费劲自己写？

---

作者: huahuajihj    时间: 2016-5-28 17:20
少年，现在的我就像当初的你，无论搞了多少次，图像永远不对，真心难受，麻烦你拯救拯救我吧

---

作者: fefen0    时间: 2017-4-14 22:02
好帖子，也很励志。

---

作者: CrlikenNN    时间: 2018-11-11 10:35
好帖子，顶一个！

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1