标题: STM32的AD9959驱动源程序 [打印本页]

---

作者: ymf    时间: 2018-7-4 15:17
标题: STM32的AD9959驱动源程序
STM32的AD9959驱动程序

1. #include "led.h"
   
2. #include "delay.h"
   
3. #include "sys.h"
   
4. #include "usart.h"
   
5. #include "lcd.h"
   
6. #include "touch.h"
   
7. #include "picture.h"
   
8. #include "mygui.h"
   
9. #include "string.h"
   
10. #include "stmflash.h"
    
11. #include "math.h"
    
12. #include "string.h"
    
13. #include "task_manage.h"
    
14. #include "AD9959.h"
    
15. #include "timer.h"
    
16. #include "sys.h"
    
17. #include "adc.h"
    
18. #include "key.h"
    
19. #include "oled.h"
    
20. 
    
21. #define                    KEY_NUM 5                //键盘最大按键次数
    
22. #define                                KEY_MAX 10000
    
23. #define                                KEY_MIN 0
    
24. #define                                SLI_F_MAX 202            //最大200M,202是弥补滑条的差值 ，一下同理
    
25. #define                                SLI_A_MAX 1029           //最大1023
    
26. #define                                SLI_P_MAX 16466          //最大16383
    
27. 
    
28. #define                                SLI_SF_MAX 141           
    
29. #define                                SLI_SF_MIN 51         
    
30. #define                                SLI_STPF_MAX 102        
    
31. #define                                SLI_SWT_MAX 11         
    
32. 
    
33. #define                                CIRCLE_1        2
    
34. #define                                CIRCLE_2        4
    
35. void ALL_INIT(void);
    
36. void Main_Loop(void);
    
37. void Key_Deal(u8 key);
    
38. void Software_Circle_Memu_Test(void);
    
39. void Main_Memu_Show(void);
    
40. void TASK_MAIN_LOOP(void);
    
41. void sweep_clen_lcd(void);
    
42. void clen_ALL(void);
    
43. 
    
44. 
    
45. void CH1_CHANGE(void);
    
46. void CH2_CHANGE(void);
    
47. void CH3_CHANGE(void);
    
48. void CH4_CHANGE(void);
    
49. void Sweep_Set(void);
    
50. void Set_Point_Fre_Clen(void);
    
51. 
    
52. char                SHOW_BUFF[256];//显存buff
    
53. char                                buff[255];
    
54. unsigned char       Refresh_flag = 0;                                                              //按键值刷新当且仅当键盘确认被按下后，标志位置1
    
55. float               RETURN_KEY_VAULE = 0;                                                          //软件键盘的返回值;
    
56. u16                 RETURN_SLI_VAULE = 0;//软件滑条返回值
    
57. 
    
58. // ADC1转换的电压值通过MDA方式传到SRAM
    
59. extern __IO uint16_t ADC_ConvertedValue[macNOFCHANEL];
    
60. 
    
61. // 局部变量，用于保存转换计算后的电压值          
    
62. float ADC_ConvertedValueLocal[macNOFCHANEL];
    
63. 
    
64. u8 key_str[20][10] = {"开始","返回"}; //创建一个图片键盘,二维数组里面的内容为软件键盘的内容
    
65. KEYBOARD    key = {160, 280, 1, 2, 30, 20, 7, LIGHTBLUE, 1, 16, BLACK,0, gImage_1,LIGHTGREEN};      //软件键盘的设置
    
66. 
    
67. SLIDER      sli_F = {10,180,200,5,BLUE, 10,10,YELLOW,SLI_F_MAX};
    
68. SLIDER      sli_A = {10,220,200,5,BLUE, 10,10,YELLOW,SLI_A_MAX};
    
69. SLIDER      sli_P = {10,260,200,5,BLUE, 10,10,YELLOW,SLI_P_MAX};
    
70. 
    
71. SLIDER      sli_SFMX = {10,140,200,5,BLUE, 10,10,YELLOW,SLI_SF_MAX};
    
72. SLIDER      sli_SFMI = {10,180,200,5,BLUE, 10,10,YELLOW,SLI_SF_MIN};
    
73. SLIDER      sli_STP = {10,220,200,5,BLUE, 10,10,YELLOW,SLI_STPF_MAX};
    
74. SLIDER      sli_SWT = {10,260,200,5,BLUE, 10,10,YELLOW,SLI_SWT_MAX};
    
75. 
    
76. 
    
77. u8 cir_str[CIRCLE_2][10] = {"CH1","CH2","CH3","CH4"};                                                   //圆圈菜单对应的名称                                                        
    
78. CIRCLE_MEMU cir_memu = {30,100,10,CIRCLE_2,40,3,16,BLUE,RED,WHITE};                                    //创建一个圆圈菜单。
    
79. int Cir_choose[CIRCLE_2] = {0};                                                                       //圆圈菜单数组，即圆圈菜单的状态记录数组            
    
80. u8 T_Cir = 0;                                                                                       //圆圈菜单是否发生更新的值
    
81. int Memu_Case = 0;                                                                                  //圆圈菜单状态值
    
82. 
    
83. u8 cir_str_memu[CIRCLE_1][10] = {"点频","扫频"};                                                   //圆圈菜单对应的名称                                                        
    
84. CIRCLE_MEMU cir_memu_m = {60,60,10,CIRCLE_1,100,3,16,BLACK,BLUE,WHITE};                                    //创建一个圆圈菜单。
    
85. u8 T_Cir_m = 0;                                                                                       //圆圈菜单是否发生更新的值
    
86. int Memu_Case_m = 0;                                                                                  //圆圈菜单状态值
    
87. int Cir_choose_m[CIRCLE_1] = {0};                                                                       //圆圈菜单数组，即圆圈菜单的状态记录数组            
    
88. 
    
89. 
    
90. u32 ch_f[4] = {2000,2000,50,50};
    
91. u32 ch_a[4] = {1023,1023,1023,1023};
    
92. u32 ch_p[4] = {0,0,0,0};
    
93. 
    
94.   //扫频定义
    
95. /******************************************************************************/
    
96. u32 SweepMinFre  = 10000000;                                   //最小10M
    
97. u32 SweepMaxFre  = 100000000;                                  //最大100M
    
98. u32 SweepStepFre = 1000000;                                    //扫面步进值，0.1M                              
    
99. u16 SweepTime    = 10;                                         //ms两步进频率之间的间隔 如果5s内完成50M带款扫秒那么最大两频点间隔为10ms                     
    
100. u8 SweepFlag     = 0;                                                                                        //扫描启动标志位
     
101. /******************************************************************************/
     
102. //注这里所有的汉字都来自于字库gb16.h，需要用到汉字就在字库添加即可
     
103. 
     
104. 
     
105. int main(void)
     
106. {
     
107.         ALL_INIT();
     
108.         ADCx_Init();
     
109.         while(1)
     
110.         {
     
111. //                Main_Loop();
     
112.                 ADC_ConvertedValueLocal[0] =(float) ADC_ConvertedValue[0]/4096*3.3;
     
113.                 ADC_ConvertedValueLocal[1] =(float) ADC_ConvertedValue[1]/4096*3.3;
     
114.                 ADC_ConvertedValueLocal[2] =(float) ADC_ConvertedValue[2]/4096*3.3;
     
115.                 ADC_ConvertedValueLocal[3] =(float) ADC_ConvertedValue[3]/4096*3.3;
     
116.                 sprintf(buff, "V1 = %.2f ", ADC_ConvertedValueLocal[0]);
     
117.                 OLED_ShowStr(0,0,(u8 *)buff,1);
     
118.                 sprintf(buff, "V2 = %.2f ", ADC_ConvertedValueLocal[1]);
     
119.                 OLED_ShowStr(0,1,(u8 *)buff,1);
     
120.                 sprintf(buff, "V3 = %.2f ", ADC_ConvertedValueLocal[2]);
     
121.                 OLED_ShowStr(0,2,(u8 *)buff,1);
     
122.                 sprintf(buff, "V4 = %.2f ", ADC_ConvertedValueLocal[3]);
     
123.                 OLED_ShowStr(0,3,(u8 *)buff,1);
     
124.         }
     
125. }
     
126. //void Main_Loop(void)
     
127. //{
     
128. //        TASK_MAIN_LOOP();
     
129. //}
     
130. void ALL_INIT(void)
     
131. {
     
132.         NVIC_Configuration();                                                                                        //设置中断分组
     
133.         delay_init();        //延时函数初始化，用的是滴答定时器，较为精准的延时          
     
134.         uart_init(9600);        //串口初始化为9600
     
135.         key_init();
     
136.         LCD_Init();             //LCD初始化
     
137.         I2C_Configuration();
     
138.         OLED_Init();
     
139.         OLED_Fill(0x00);
     
140. //        TP_Init();
     
141. //        Timerx_Init( 99,71);
     
142. //        LCD_ShowString(20, 30, 24, RED, (u8 *)"DDS-AD9959");
     
143. //        LCD_ShowString(150, 23, 24, RED, (u8 *)"射频源");
     
144. //        Main_Memu_Show();
     
145. //        Circle_Memu_Init(cir_memu_m,cir_str_memu,10);
     
146.         Init_AD9959();
     
147. }
     
148. 
     
149. 
     
150. 
     
151. //void TASK_MAIN_LOOP(void)
     
152. //{
     
153. //        T_Cir_m = Circle_Memu_GetValue(cir_memu_m, Cir_choose_m,&Memu_Case_m);
     
154. //        if(Memu_Case_m == 1)
     
155. //        {
     
156. //                T_Cir = Circle_Memu_GetValue(cir_memu, Cir_choose,&Memu_Case);
     
157. //                Set_Point_Fre_Clen();               
     
158. //                switch (Memu_Case)
     
159. //                {
     
160. //                        case 1 : CH1_CHANGE(); break;
     
161. //                        case 2 : CH2_CHANGE(); break;
     
162. //                        case 3 : CH3_CHANGE(); break;
     
163. //                        case 4 : CH4_CHANGE(); break;
     
164. //                        default : Set_Point_Fre_Clen();break;
     
165. //                }
     
166. //        }
     
167. //        if(Memu_Case_m == 2)
     
168. //        {
     
169. //                 Sweep_Set();
     
170. //        }
     
171. //}
     
172. 
     
173. //void TASK_MAIN_LOOP(void)
     
174. //{
     
175. //        u8 t=0;
     
176. //        t=KEY_Scan(0);
     
177. //        switch(t)
     
178. //                {                                 
     
179. //                        case KEY0_PRES:
     
180. //                                CH1_CHANGE();
     
181. //                                break;
     
182. //                        case KEY1_PRES:
     
183. //                                CH2_CHANGE();
     
184. //                                break;
     
185. //                        default:
     
186. //                                delay_ms(10);
     
187. //                }                       
     
188. //       
     
189. //}
     
190. 
     
191. //void CH1_CHANGE(void)
     
192. //{
     
193. //          
     
194. //                                Write_frequence(0,ch_f[0]);                       
     
195. //                                Write_Amplitude(0,ch_a[0]);         
     
196. //                                Write_Phase(0, ch_p[0]);
     
197. //}
     
198. 
     
199. //void CH2_CHANGE(void)
     
200. //{
     
201. //          
     
202. //                                Write_frequence(1,ch_f[1]);                       
     
203. //                                Write_Amplitude(1,ch_a[1]);         
     
204. //                                Write_Phase(1, ch_p[1]);
     
205. //}
     
206. 
     
207. //void CH1_CHANGE(void)
     
208. //{
     
209. //        u32 A0_NEXT = ch_a[0];
     
210. //       
     
211. //        SLIDER_Init(sli_F);                                                                                 
     
212. //        SLIDER_Init(sli_A);                                                                                 
     
213. //        SLIDER_Init(sli_P);                                                                                 
     
214. //       
     
215. //       
     
216. //        while(Memu_Case == 1 && Memu_Case_m == 1)
     
217. //        {
     
218. //                T_Cir_m = Circle_Memu_GetValue(cir_memu_m, Cir_choose_m,&Memu_Case_m);
     
219. //                T_Cir = Circle_Memu_GetValue(cir_memu, Cir_choose,&Memu_Case);  
     
220. //                if(!T_Cir)
     
221. //                {
     
222. //                        ch_f[0] =  SLIDER_GetValue(sli_F,SLI_F_MAX);
     
223. //                        ch_a[0] =  SLIDER_GetValue(sli_A,SLI_A_MAX);
     
224. //                        ch_p[0] =  SLIDER_GetValue(sli_P,SLI_P_MAX);                       
     
225. //                        if(ch_f[0] != (SLI_F_MAX+1))                                                                                                   
     
226. //                        {
     
227. //                                sprintf((char*)SHOW_BUFF, "Frequency: %09d Hz", ch_f[0] * 1000000);               
     
228. //                                LCD_ShowString(10, 200, 16, BLACK, (u8 *)SHOW_BUFF);                       
     
229. //                                Write_frequence(0,ch_f[0] * 1000000);
     
230. //                        }
     
231. //                       
     
232. //                        if(ch_a[0] != (SLI_A_MAX+1))                                                                                            
     
233. //                        {
     
234. //                                sprintf((char*)SHOW_BUFF, "Amplitude: %.3f Mv", (double)ch_a[0] * 500 / 1023);            
     
235. //                                LCD_ShowString(10, 240, 16, BLACK, (u8 *)SHOW_BUFF);                        
     
236. //                                Write_Amplitude(0,ch_a[0]);
     
237. //                                A0_NEXT = ch_a[0];
     
238. //                        }
     
239. //                       
     
240. //                        if(ch_p[0] != (SLI_P_MAX+1))                                                        
     
241. //                        {
     
242. //                                sprintf((char*)SHOW_BUFF, "Phase: %.3fT", (double)  ch_p[0] / 16383);               
     
243. //                                LCD_ShowString(10, 280, 16, BLACK, (u8 *)SHOW_BUFF);                        
     
244. //                                Write_Phase(0, ch_p[0]);               
     
245. //                                Write_Amplitude(0,A0_NEXT);
     
246. //                        }
     
247. //                }
     
248. //        }
     
249. //}
     
250. 
     
251. //void CH2_CHANGE(void)
     
252. //{
     
253. //        u32 A1_NEXT = ch_a[1];
     
254. //       
     
255. //        SLIDER_Init(sli_F);                                                                                 
     
256. //        SLIDER_Init(sli_A);                                                                                 
     
257. //        SLIDER_Init(sli_P);                                                                                 
     
258. //       
     
259. //       
     
260. //        while(Memu_Case == 2  && Memu_Case_m == 1)
     
261. //        {
     
262. //                T_Cir_m = Circle_Memu_GetValue(cir_memu_m, Cir_choose_m,&Memu_Case_m);
     
263. //                T_Cir = Circle_Memu_GetValue(cir_memu, Cir_choose,&Memu_Case);  
     
264. //                if(!T_Cir)
     
265. //                {
     
266. //                        ch_f[1] =  SLIDER_GetValue(sli_F,SLI_F_MAX);
     
267. //                        ch_a[1] =  SLIDER_GetValue(sli_A,SLI_A_MAX);
     
268. //                        ch_p[1] =  SLIDER_GetValue(sli_P,SLI_P_MAX);                       
     
269. //                        if(ch_f[1] != (SLI_F_MAX+1))                                                                                                   
     
270. //                        {
     
271. //                                sprintf((char*)SHOW_BUFF, "Frequency: %09d Hz", ch_f[1] * 1000000);               
     
272. //                                LCD_ShowString(10, 200, 16, BLACK, (u8 *)SHOW_BUFF);                       
     
273. //                                Write_frequence(1,ch_f[1] * 1000000);
     
274. //                        }
     
275. //                       
     
276. //                        if(ch_a[1] != (SLI_A_MAX+1))                                                                                            
     
277. //                        {
     
278. //                                sprintf((char*)SHOW_BUFF, "Amplitude: %.3f Mv", (double)ch_a[1] * 500 / 1023);            
     
279. //                                LCD_ShowString(10, 240, 16, BLACK, (u8 *)SHOW_BUFF);                        
     
280. //                                Write_Amplitude(1,ch_a[1]);
     
281. //                                A1_NEXT = ch_a[1];
     
282. //                        }
     
283. //                       
     
284. //                        if(ch_p[1] != (SLI_P_MAX+1))                                                        
     
285. //                        {
     
286. //                                sprintf((char*)SHOW_BUFF, "Phase: %.3fT", (double)  ch_p[1] / 16383);               
     
287. //                                LCD_ShowString(10, 280, 16, BLACK, (u8 *)SHOW_BUFF);                        
     
288. //                                Write_Phase(1, ch_p[1]);               
     
289. //                                Write_Amplitude(1,A1_NEXT);
     
290. //                        }
     
291. //                }
     
292. //        }
     
293. //}
     
294. 
     
295. //void CH3_CHANGE(void)
     
296. //{
     
297. //        u32 A2_NEXT = ch_a[2];
     
298. //       
     
299. //        SLIDER_Init(sli_F);                                                                                 
     
300. //        SLIDER_Init(sli_A);                                                                                 
     
301. //        SLIDER_Init(sli_P);                                                                                 
     
302. //       
     
303. //       
     
304. //        while(Memu_Case == 3  && Memu_Case_m == 1)
     
305. //        {
     
306. //                T_Cir_m = Circle_Memu_GetValue(cir_memu_m, Cir_choose_m,&Memu_Case_m);
     
307. //                T_Cir = Circle_Memu_GetValue(cir_memu, Cir_choose,&Memu_Case);  
     
308. //                if(!T_Cir)
     
309. //                {
     
310. //                        ch_f[2] =  SLIDER_GetValue(sli_F,SLI_F_MAX);
     
311. //                        ch_a[2] =  SLIDER_GetValue(sli_A,SLI_A_MAX);
     
312. //                        ch_p[2] =  SLIDER_GetValue(sli_P,SLI_P_MAX);                       
     
313. //                        if(ch_f[2] != (SLI_F_MAX+1))                                                                                                   
     
314. //                        {
     
315. //                                sprintf((char*)SHOW_BUFF, "Frequency: %09d Hz", ch_f[2] * 1000000);               
     
316. //                                LCD_ShowString(10, 200, 16, BLACK, (u8 *)SHOW_BUFF);                       
     
317. //                                Write_frequence(2,ch_f[2] * 1000000);
     
318. //                        }
     
319. //                       
     
320. //                        if(ch_a[2] != (SLI_A_MAX+1))                                                                                            
     
321. //                        {
     
322. //                                sprintf((char*)SHOW_BUFF, "Amplitude: %.3f Mv", (double)ch_a[2] * 500 / 1023);            
     
323. //                                LCD_ShowString(10, 240, 16, BLACK, (u8 *)SHOW_BUFF);                        
     
324. //                                Write_Amplitude(2,ch_a[2]);
     
325. //                                A2_NEXT = ch_a[2];
     
326. //                        }
     
327. //                       
     
328. //                        if(ch_p[2] != (SLI_P_MAX+1))                                                        
     
329. //                        {
     
330. //                                sprintf((char*)SHOW_BUFF, "Phase: %.3fT", (double)  ch_p[2] / 16383);               
     
331. //                                LCD_ShowString(10, 280, 16, BLACK, (u8 *)SHOW_BUFF);                        
     
332. //                                Write_Phase(2, ch_p[2]);               
     
333. //                                Write_Amplitude(2,A2_NEXT);
     
334. //                        }
     
335. //                }
     
336. //        }
     
337. //}
     
338. 
     
339. //void CH4_CHANGE(void)
     
340. //{
     
341. //        u32 A3_NEXT = ch_a[3];
     
342. //       
     
343. //        SLIDER_Init(sli_F);                                                                                 
     
344. //        SLIDER_Init(sli_A);                                                                                 
     
345. //        SLIDER_Init(sli_P);                                                                                 
     
346. //       
     
347. //       
     
348. //        while(Memu_Case == 4  && Memu_Case_m == 1)
     
349. //        {
     
350. //                T_Cir_m = Circle_Memu_GetValue(cir_memu_m, Cir_choose_m,&Memu_Case_m);
     
351. //                T_Cir = Circle_Memu_GetValue(cir_memu, Cir_choose,&Memu_Case);  
     
352. //                if(!T_Cir)
     
353. //                {
     
354. //                        ch_f[3] =  SLIDER_GetValue(sli_F,SLI_F_MAX);
     
355. //                        ch_a[3] =  SLIDER_GetValue(sli_A,SLI_A_MAX);
     
356. //                        ch_p[3] =  SLIDER_GetValue(sli_P,SLI_P_MAX);                       
     
357. //                        if(ch_f[3] != (SLI_F_MAX+1))                                                                                                   
     
358. //                        {
     
359. //                                sprintf((char*)SHOW_BUFF, "Frequency: %09d Hz", ch_f[3] * 1000000);               
     
360. //                                LCD_ShowString(10, 200, 16, BLACK, (u8 *)SHOW_BUFF);                       
     
361. //                                Write_frequence(3,ch_f[3] * 1000000);
     
362. //                        }
     
363. //                       
     
364. //                        if(ch_a[3] != (SLI_A_MAX+1))                                                                                            
     
365. //                        {
     
366. //                                sprintf((char*)SHOW_BUFF, "Amplitude: %.3f Mv", (double)ch_a[3] * 500 / 1023);            
     
367. //                                LCD_ShowString(10, 240, 16, BLACK, (u8 *)SHOW_BUFF);                        
     
368. //                                Write_Amplitude(3,ch_a[3]);
     
369. //                                A3_NEXT = ch_a[3];
     
370. //                        }
     
371. //                       
     
372. //                        if(ch_p[3] != (SLI_P_MAX+1))                                                        
     
373. //                        {
     
374. //                                sprintf((char*)SHOW_BUFF, "Phase: %.3fT", (double)  ch_p[3] / 16383);               
     
375. //                                LCD_ShowString(10, 280, 16, BLACK, (u8 *)SHOW_BUFF);                        
     
376. //                                Write_Phase(3, ch_p[3]);               
     
377. //                                Write_Amplitude(3,A3_NEXT);
     
378. //                        }
     
379. //                }
     
380. //        }
     
381. //}
     
382. 
     
383. 
     
384. //void Main_Memu_Show(void)
     
385. //{
     
386. //        Circle_Memu_Init(cir_memu,cir_str,5);
     
387. //}
     
388. 
     
389. //void Sweep_Set(void)
     
390. //{
     
391. //       
     
392. //        u8 KEY_vaule = 0;
     
393. //        u32 sweep_arr[4] = {0};
     
394. //       
     
395. //        SLIDER_Init(sli_SFMX);                                                                                 
     
396. //        SLIDER_Init(sli_SFMI);                                                                                 
     
397. //        SLIDER_Init(sli_STP);                                                                                 
     
398. //        SLIDER_Init(sli_SWT);
     
399. //        sweep_clen_lcd();
     
400. //        KeyBaord_Init(key,key_str);
     
401. //        KEY_vaule = KeyBaord_GetValue(key,key_str);
     
402. //        T_Cir_m = Circle_Memu_GetValue(cir_memu_m, Cir_choose_m,&Memu_Case_m);
     
403. //        while((KEY_vaule == 0) && (Memu_Case_m == 2))
     
404. //        {
     
405. //                T_Cir_m = Circle_Memu_GetValue(cir_memu_m, Cir_choose_m,&Memu_Case_m);
     
406. //                KEY_vaule = KeyBaord_GetValue(key,key_str);
     
407. //                sweep_arr[0] =  SLIDER_GetValue(sli_SFMX,SLI_SF_MAX);
     
408. //                sweep_arr[1] =  SLIDER_GetValue(sli_SFMI,SLI_SF_MIN);
     
409. //                sweep_arr[2] =  SLIDER_GetValue(sli_STP,SLI_STPF_MAX);                       
     
410. //                sweep_arr[3] =  SLIDER_GetValue(sli_SWT,SLI_SWT_MAX);
     
411. //                if(sweep_arr[0] != (SLI_SF_MAX+1))                                                                                                   
     
412. //                {
     
413. //                        SweepMaxFre = sweep_arr[0] * 1000000;
     
414. //                        sprintf((char*)SHOW_BUFF, "Fre_Max: %09d Hz", SweepMaxFre);               
     
415. //                        LCD_ShowString(10, 160, 16, BLACK, (u8 *)SHOW_BUFF);                       
     
416. //                }
     
417. //                if(sweep_arr[1] != (SLI_SF_MIN+1))                                                                                                   
     
418. //                {
     
419. //                        SweepMinFre = sweep_arr[1] * 1000000;
     
420. //                        sprintf((char*)SHOW_BUFF, "Fre_Min: %09d Hz", SweepMinFre);               
     
421. //                        LCD_ShowString(10, 200, 16, BLACK, (u8 *)SHOW_BUFF);                       
     
422. //                }
     
423. //                if(sweep_arr[2] != (SLI_STPF_MAX+1))                                                                                                   
     
424. //                {
     
425. //                        SweepStepFre = sweep_arr[2] * 100000;
     
426. //                        sprintf((char*)SHOW_BUFF, "Fre_Stp: %09d Hz", SweepStepFre);               
     
427. //                        LCD_ShowString(10, 240, 16, BLACK, (u8 *)SHOW_BUFF);                       
     
428. //                }
     
429. //                if(sweep_arr[3] != (SLI_SWT_MAX+1))                                                                                                   
     
430. //                {
     
431. //                        SweepTime = sweep_arr[3];
     
432. //                        sprintf((char*)SHOW_BUFF, "Fre_Tim: %02d ms", SweepTime);               
     
433. //                        LCD_ShowString(10, 280, 16, BLACK, (u8 *)SHOW_BUFF);                       
     
434. //                }
     
435. //        }
     
436. //        if (ADC_ConvertedValueLocal[0] == 0)
     
437. //        {
     
438. //                Memu_Case_m = 0;
     
439. //                clen_ALL();
     
440. //                SweepFlag = 0;
     
441. //        }
     
442. //        if(KEY_vaule == 2)
     
443. //        {
     
444. //                Memu_Case_m = 0;
     
445. //                clen_ALL();
     
446. //                SweepFlag = 0;
     
447. //        }
     
448. //        if(KEY_vaule == 1)
     
449. //        {
     
450. ////                Memu_Case_m = 0;
     
451. ////                clen_ALL();
     
452. //                SweepFlag = 1;
     
453. //        }       
     
454. //}
     
455. 
     
456. //void sweep_clen_lcd(void)
     
457. //{     
     
458. //        LCD_ShowString(10, 160, 16, BLACK, (u8 *)"                                ");                        
     
459. //        LCD_ShowString(10, 200, 16, BLACK, (u8 *)"                                ");                        
     
460. //        LCD_ShowString(10, 240, 16, BLACK, (u8 *)"                                ");                                
     
461. //        LCD_ShowString(10, 280, 16, BLACK, (u8 *)"                                ");                        
     
462. //}
     
463. //void Set_Point_Fre_Clen(void)
     
464. //{
     
465. //        sweep_clen_lcd();
     
466. //        LCD_ShowString(10, 138, 16, BLACK, (u8 *)"                                  ");
     
467. //        LCD_ShowString(10, 272, 16, BLACK, (u8 *)"                                ");
     
468. //        LCD_ShowString(10, 288, 16, BLACK, (u8 *)"                                ");                                        
     
469. //}
     
470. //void clen_ALL(void)
     
471. //{
     
472. //        Set_Point_Fre_Clen();
     
473. //        LCD_ShowString(10, 178, 16, BLACK, (u8 *)"                                  ");
     
474. //        LCD_ShowString(10, 218, 16, BLACK, (u8 *)"                                  ");
     
475. //        LCD_ShowString(10, 258, 16, BLACK, (u8 *)"                                  ");
     
476. //}
     
477. 
     

复制代码

全部资料51hei下载地址：
AD9959_Sweep_point_fre.rar (389.9 KB, 下载次数: 119)

2018-7-5 01:22 上传

点击文件名下载附件
下载积分: 黑币 -5

---

作者: xwstu    时间: 2020-9-10 14:06
想问下这个引脚是怎么连，我连的一直没有输出

---

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

Powered by Discuz! X3.1