设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › STM32的AD9959驱动源程序
返回列表 发新帖
查看: 4850|回复: 1
打印 上一主题 下一主题
收起左侧

STM32的AD9959驱动源程序

[复制链接]
跳转到指定楼层
楼主
ID:329807 发表于 2018-7-4 15:17 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
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"

  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

  28. #define                                SLI_SF_MAX 141           
  29. #define                                SLI_SF_MIN 51         
  30. #define                                SLI_STPF_MAX 102        
  31. #define                                SLI_SWT_MAX 11         

  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);


  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);

  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;//软件滑条返回值

  58. // ADC1转换的电压值通过MDA方式传到SRAM
  59. extern __IO uint16_t ADC_ConvertedValue[macNOFCHANEL];

  61. // 局部变量，用于保存转换计算后的电压值          
  62. float ADC_ConvertedValueLocal[macNOFCHANEL];

  64. u8 key_str[20][10] = {"开始","返回"}; //创建一个图片键盘,二维数组里面的内容为软件键盘的内容
  65. KEYBOARD    key = {160, 280, 1, 2, 30, 20, 7, LIGHTBLUE, 1, 16, BLACK,0, gImage_1,LIGHTGREEN};      //软件键盘的设置

  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};

  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};


  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;                                                                                  //圆圈菜单状态值

  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};                                                                       //圆圈菜单数组，即圆圈菜单的状态记录数组            


  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};

  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，需要用到汉字就在字库添加即可


  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. }



  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. //}

  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. //}

  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. //}

  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. //}

  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. //}

  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. //}

  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. //}

  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. //}


  384. //void Main_Memu_Show(void)
  385. //{
  386. //        Circle_Memu_Init(cir_memu,cir_str,5);
  387. //}

  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. //}

  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. //}

复制代码

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


评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶1 踩踩
回复

使用道具 举报

沙发
ID:767702 发表于 2020-9-10 14:06 | 只看该作者
想问下这个引脚是怎么连，我连的一直没有输出
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表