标题: stm32成功驱动lcd12864液晶屏显示电压电流 [打印本页]

---

作者: 鸡米宝宝    时间: 2017-11-28 22:28
标题: stm32成功驱动lcd12864液晶屏显示电压电流
stm32_12864
单片机源程序如下:

1. #include <stdio.h>
   
2. #include "adc.h"
   
3. #include "tim.h"
   
4. #include "Systick.h"
   
5. #include "lcd1602.h"
   
6. #include "LCD12864.h"
   
7. //
   
8. /* Private function prototypes -----------------------------------------------*/
   
9. 
   
10. #define  LED_GPIO   GPIOB
    
11. #define  LED3  GPIO_Pin_8
    
12. #define  LED4  GPIO_Pin_9
    
13. #define  KEY_GPIO   GPIOB
    
14. #define  KEY1  GPIO_Pin_5
    
15. #define  KEY2  GPIO_Pin_6
    
16. #define  KEY3  GPIO_Pin_7
    
17. //
    
18. //#define Ture  0x00;
    
19. //#define False  0xFF;
    
20. //#define No_Key_Press 0x00;
    
21. //#define Key_Press 0xFF;
    
22. 
    
23. char LCD12864_STR[] = "OUT 12V Time=   ";
    
24. u8 LCD12864_DAT[] = {0x11,0x22};
    
25. 
    
26. ///*
    
27.         u8  Disp_Buf[] = {0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,\
    
28.                                                                     0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,0x60,\
    
29.                                                                     0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,0x70,\
    
30.                                                                     0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f};
    
31. 
    
32. void Delay(__IO uint32_t nCount);
    
33. u16 ua = 0;
    
34. u16 ub = 0;
    
35. u16 uc = 0;
    
36. u16 i = 678;
    
37. u16 uab,ubb,ucb,ib;
    
38. u16 T2_prescaler = 7200-1;
    
39. u16 T2_time = 100-1;
    
40. u8 time_sec;
    
41. char Time2_Flg = 0x00;
    
42. u32  Time_Cont ;        
    
43. u8 Key_Code=0x00;
    
44. u8 Fun_Code=0x00;
    
45. char Run_Code = 0x00;                                                                                
    
46. u8 Set_Val = 0x00;                                //电压或电流输出值
    
47. char Key_Press = 0xFF;
    
48. char No_Key_Press = 0x00;
    
49. char Ture = 0x00;
    
50. char False = 0xFF;
    
51. char RUN = 0x00;
    
52. char NO_RUN = 0xFF;
    
53. char Key_Release = 0x00;
    
54. //char LED3_Flg = 0x00;                                                                        
    
55. //char LED4_Flg = 0x00;
    
56. char Key_Flg  = 0x00;               
    
57. 
    
58.                                                                                 
    
59. /*
    
60. u8 u1buffer[4]={0};   //存放u1值 用于显示的缓冲数组
    
61. u8 u2buffer[4]={0};   //存放u2
    
62. */
    
63. //char u1buffer[4]={0};   //存放u1值 用于显示的缓冲数组
    
64. //char u2buffer[4]={0};   //存放u2
    
65. 
    
66. //static void SYS_init(void);
    
67. static void user_init(void);
    
68. void RCC_Config(void);
    
69. void NVIC_Config(void);
    
70. void GPIO_Config(void);
    
71. void USART1_IRQHandler(void);
    
72. void UART5_IRQHandler(void);
    
73. void LCD12864_init(void);
    
74. void Disp_Dat(u16 u1,u16 u2,u32 t);
    
75. static u16 Calculat_U(int k,int nux);
    
76. void Time2_config(u16 prescaler,u16 time);
    
77. void Time2_IRQHandler(void);
    
78. 
    
79. //按键状态处理函数
    
80. void Key_Code00( void);
    
81. void Key_Code01( void);
    
82. void Key_Code02( void);
    
83. void Key_Code03( void);
    
84. void Key_Code04( void);
    
85. void Key_Code05( void);
    
86. void Key_Code06( void);
    
87. void Key_Code07( void);
    
88. //功能编码处理函数
    
89. void Fun_Code00( void);
    
90. void Fun_Code01( void);
    
91. void Fun_Code02( void);
    
92. void Fun_Code03( void);
    
93. void Fun_Code04( void);
    
94. void Fun_Code05( void);
    
95. void Fun_Code06( void);
    
96. void Fun_Code07( void);
    
97. //************************************************************************************************
    
98. //
    
99. //
    
100. //
     
101. //************************************************************************************************
     
102. int main( )
     
103. {
     
104. //
     
105.   u8 j;
     
106.         u8 Jmp_Code;
     
107.         Run_Code = RUN;
     
108. //        u8 LED_FLG=0;
     
109.                
     
110.         RCC_Config();
     
111.         delay_us(10);        
     
112.         GPIO_Config();
     
113.         delay_us(10);        
     
114. // NVIC_Config();
     
115. 
     
116.         //UART1_Config(115200);
     
117.   //UART5_Config(115200);        
     
118. 
     
119.         for(j=0;j<6;j++)
     
120.         {
     
121.                 GPIO_SetBits(LED_GPIO, LED3);// LED3亮         
     
122.                 GPIO_ResetBits(LED_GPIO, LED4);// LED4灭?
     
123.                 delay_ms(100);
     
124.                 GPIO_ResetBits(LED_GPIO, LED3);        //LED3灭
     
125.                 GPIO_SetBits(LED_GPIO, LED4);        //LED4灭
     
126.                 delay_ms(100);
     
127.         }
     
128.                 GPIO_ResetBits(LED_GPIO, LED3);        //LED3灭               
     
129.                 GPIO_ResetBits(LED_GPIO, LED4);        //LED4灭        
     
130.                
     
131.          //gpio_config();
     
132.         delay_us(10);
     
133.         ADC_Config();
     
134.         DMA_Config();
     
135.         Tim2_Config(T2_prescaler,T2_time );
     
136.         //Tim2_Config(TWENTYMS);
     
137.         delay_us(10);
     
138.                
     
139.         LCD12864_Init();        
     
140. //        LCD12864_ShowString(2,0,"ZIGBEE R 1C");
     
141. //        LCD12864_ShowString(3,0,"LCD12864");
     
142. //        user_init();
     
143.         
     
144.         while(1)
     
145.         {
     
146.                 u16 nad;
     
147.                 delay_ms(100);        
     
148.                 nad = read_adc(0);  //得到对应通道的adc值
     
149.                 ua = Calculat_U(5,nad);//求出对应的实际电压值
     
150.                 ua=(ua+uab)/2;
     
151.                 uab=ua;
     
152.                 nad = read_adc(1);//u2的ad值
     
153.                 ub = Calculat_U(1,nad);//u2的实际值
     
154.                 ub=(ub+ubb)/2;
     
155.                 ubb=ub;
     
156.                 uc=(uc+2)&0x0FFFF;
     
157.     //Time_Cont = Time_Cont++;
     
158.           Disp_Dat(ua,ub,Time_Cont);
     
159.                 LCD12864_Disp( );//显示u1和u2
     
160.           //如果有按键按下，依据按键组合编码转移到不同处理分支进行处理
     
161. //                if (Run_Code == RUN)
     
162. //                {
     
163. //                  Disp_Buf[0x0C] = ' ';
     
164. //                        Disp_Buf[0x0D] = 'R';
     
165. //                        Disp_Buf[0x0E] = 'U';
     
166. //                        Disp_Buf[0x0F] = 'N';
     
167.                         //按照设定的功能编码转移到不同处理分支。
     
168.                         switch(Fun_Code)
     
169.                   {
     
170.                         case 0x00:
     
171.                                 Fun_Code00();                        
     
172.                                 break;
     
173.                         case 0x01:
     
174.                                 Fun_Code01();
     
175.                                 break;
     
176.                         case 0x02:
     
177.                                 Fun_Code02( );
     
178.                                 break;
     
179.                         case 0x03:
     
180.                                 Fun_Code03( );
     
181.                                 break;                                
     
182.                         case 0x04:
     
183.                                 Fun_Code04( );
     
184.                                 break;
     
185.                         case 0x05:
     
186.                                 Fun_Code05( );
     
187.                                 break;
     
188.                         case 0x06:
     
189.                                 Fun_Code06( );
     
190.                                 break;
     
191.                         case 0x07:
     
192.                                 Fun_Code07( );
     
193.                                 break;
     
194.                         }
     
195. /*    }
     
196.     else
     
197.           {
     
198.             Disp_Buf[0x0C] = ' ';
     
199.                         Disp_Buf[0x0D] = 'S';
     
200.                         Disp_Buf[0x0E] = 'E';
     
201.                         Disp_Buf[0x0F] = 'T';
     
202.                 }
     
203. */
     
204. //*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               
     
205.                 if (Key_Flg == Key_Press)
     
206.                 {
     
207.                         Key_Flg = No_Key_Press;                //进入按键处理程序，清除按键标志。
     
208.                         Jmp_Code = Key_Code;
     
209.                         switch (Jmp_Code)
     
210.                         {
     
211.                                 case 0x00:
     
212.                                         Key_Code00();                        
     
213.                                         break;
     
214.                                 case 0x01:
     
215.                                         Key_Code01();
     
216.                                         break;
     
217.                                 case 0x02:
     
218.                                         Key_Code02( );
     
219.                                         break;
     
220.                                 case 0x03:
     
221.                                         Key_Code03( );
     
222.                                         break;                                
     
223.                                 case 0x04:
     
224.                                         Key_Code04( );
     
225.                                         break;
     
226.                                 case 0x05:
     
227.                                         Key_Code05( );
     
228.                                         break;
     
229.                                 case 0x06:
     
230.                                         Key_Code06( );
     
231.                                         break;
     
232.                                 case 0x07:
     
233.                                         Key_Code07( );
     
234.                                         Key_Release = False;
     
235.                                   break;
     
236.                           }
     
237.                   }        
     
238. //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/                        
     
239. //信号灯LED3闪烁。表明主函数运行               
     
240.                 if (GPIO_ReadInputDataBit(LED_GPIO,LED3) == Bit_SET)
     
241.                 {
     
242.                         GPIO_ResetBits(LED_GPIO, LED3);// LED3亮
     
243. //                        LED3_Flg = 0x55;
     
244.                 }
     
245.                 else
     
246.                 {
     
247.                                 GPIO_SetBits(LED_GPIO, LED3);        //LED3灭
     
248. //        LED3_Flg = 0x00;                                
     
249.                 }
     
250. //                Disp_Buf[0x0A]=' ';
     
251. //                Disp_Buf[0x0B]='F';
     
252. //                Disp_Buf[0x0C]='_';
     
253.                 Disp_Buf[0x0D]=' ';
     
254.                 Disp_Buf[0x0E]=' ';        
     
255.                 Disp_Buf[0x0F]=' ';               
     
256. //                Disp_Buf[0x0E]='F';
     
257. //                Disp_Buf[0x0F]=Fun_Code+0x30;
     
258.           delay_ms(50);
     
259.         }
     
260. 
     
261. }        
     
262. //************************************************************************************************
     
263. //函数功能：开启显示
     
264. //************************************************************************************************
     
265. static void user_init(){
     
266.         lcd_write_string(0,0,(u8*)"U1=");
     
267.         lcd_write_string(7,0,(u8*)"mV");
     
268.         lcd_write_string(0,1,(u8*)"U2=");
     
269.         lcd_write_string(4,1,(u8*)".");
     
270.         lcd_write_string(8,1,(u8*)"V");
     
271.         
     
272. }
     
273. 
     
274. //************************************************************************************************
     
275. //函数功能：计算对应通道的电压值
     
276. //入口参数：k 放大倍数 nux 对应ADC通道的AD值
     
277. //返回值：对应通道的实际电压值
     
278. //************************************************************************************************
     
279. static u16 Calculat_U(int k,int nux)
     
280.         {
     
281.         u32 temp;
     
282.         u16 u;
     
283.         temp = ((825*nux)*1/k)+1;
     
284.         u = temp >>10;
     
285.         return u;
     
286.         
     
287.   }
     
288. //************************************************************************************************
     
289. //
     
290. //
     
291. //************************************************************************************************
     
292. void Disp_Dat(u16 u1,u16 u2,u32 t)
     
293.         {
     
294.         u16 ux,uy;
     
295.         u32 tx;
     
296.         ux = u1;
     
297.         uy = u2;
     
298.         tx = t;
     
299.         Disp_Buf[0x20] = 'U';
     
300.         Disp_Buf[0x21] = 'a';
     
301.         Disp_Buf[0x22] = '=';
     
302.         Disp_Buf[0x23] = (ux/1000)+0x30;
     
303.         Disp_Buf[0x24] = (ux%1000/100)+0x30;
     
304.   Disp_Buf[0x25] = (ux%100/10)+0x30;
     
305.   Disp_Buf[0x26] = (ux%10)+0x30;
     
306.         Disp_Buf[0x27] = ' ';
     
307.         Disp_Buf[0x28] = 'm';
     
308.         Disp_Buf[0x29] = 'V';
     
309.         Disp_Buf[0x2A] = ' ';
     
310.         Disp_Buf[0x2B] = ' ';
     
311.         Disp_Buf[0x2C] = ' ';
     
312.         Disp_Buf[0x2D] = ' ';
     
313.         Disp_Buf[0x2E] = ' ';
     
314.         Disp_Buf[0x2F] = ' ';
     
315. /*
     
316. Disp_Buf[0x2B]='K';
     
317.         Disp_Buf[0x2C]='=';
     
318.         if (Key_Release == Ture)
     
319.         {
     
320.                 Disp_Buf[0x2D]='Y';
     
321.                 Disp_Buf[0x2E]='S';
     
322.                 Disp_Buf[0x2F]='F';
     
323.         }
     
324.         else
     
325.         {
     
326.                 Disp_Buf[0x2D]='W';
     
327.                 Disp_Buf[0x2E]='S';
     
328.                 Disp_Buf[0x2F]='F';
     
329.         }        
     
330. */        
     
331.         
     
332.         Disp_Buf[0x10] = 'U';
     
333.         Disp_Buf[0x11] = 'b';
     
334.         Disp_Buf[0x12] = '=';
     
335.         Disp_Buf[0x13] = (uy/1000)+0x30;
     
336.         Disp_Buf[0x14] = '.';
     
337.         Disp_Buf[0x15] = (uy%1000/100)+0x30;
     
338.   Disp_Buf[0x16] = (uy%100/10)+0x30;
     
339.   Disp_Buf[0x17] = (uy%10)+0x30;
     
340.         Disp_Buf[0x18] = ' ';
     
341.         Disp_Buf[0x19] = 'V';
     
342.         Disp_Buf[0x1A] = ' ';
     
343.         Disp_Buf[0x1B] = ' ';
     
344.         Disp_Buf[0x1C] = ' ';
     
345.         Disp_Buf[0x1D] = ' ';
     
346.         Disp_Buf[0x1E] = ' ';
     
347.         Disp_Buf[0x1F] = ' ';
     
348. /*
     
349.         Disp_Buf[0x1B]='K';
     
350.         Disp_Buf[0x1C]='=';
     
351.         if (Key_Flg == Key_Press)
     
352.         {
     
353.                 Disp_Buf[0x1D]='P';
     
354.                 Disp_Buf[0x1E]='R';
     
355.                 Disp_Buf[0x1F]='S';
     
356.         }
     
357.         else
     
358.         {
     
359.                 Disp_Buf[0x1D]='N';
     
360.                 Disp_Buf[0x1E]='O';
     
361.                 Disp_Buf[0x1F]='P';
     
362.         }
     
363. */
     
364.         
     
365. //        Disp_Buf[0x30] = ':';
     
366.   //tx = tx /50;
     
367.         Disp_Buf[0x30] = 'T';
     
368.         Disp_Buf[0x31] = '=';
     
369.         Disp_Buf[0x32] = (tx/360000)+0x30;        //时百位
     
370.         tx=tx%360000;
     
371.         Disp_Buf[0x33] = (tx/36000)+0x30;                //时十位
     
372.         tx=tx%36000;
     
373.         Disp_Buf[0x34] = (tx/3600)+0x30;                //时个位
     
374.         tx=tx%3600;
     
375.         Disp_Buf[0x35] = '-';
     
376.         Disp_Buf[0x36] = (tx/600)+0x30;                        //分十位
     
377.         tx=tx%600;
     
378.         Disp_Buf[0x37] = (tx/60)+0x30;                  //分个位
     
379.         tx=tx%60;
     
380.         Disp_Buf[0x38] = '-';         
     
381.   Disp_Buf[0x39] = (tx/10)+0x30;                        //秒十位
     
382.         tx=tx%10;
     
383.   Disp_Buf[0x3A] = tx+0x30;                                                //秒个位
     
384.         Disp_Buf[0x3B] = ' ';
     
385.         Disp_Buf[0x3C] = ' ';
     
386. //        Disp_Buf[0x3D] = ' ';
     
387. //        Disp_Buf[0x3E] = ' ';
     
388. //        Disp_Buf[0x3F] = ' ';
     
389.         Disp_Buf[0x3D]='F';
     
390.         Disp_Buf[0x3E]='=';
     
391.         Disp_Buf[0x3F]=Fun_Code+0x30;
     
392. //                Disp_Buf[0x3D]='K';
     
393. //                Disp_Buf[0x3E]='=';
     
394. //                Disp_Buf[0x3F]=Key_Code+0x30;
     
395. }
     
396. 
     
397. //*/
     
398. //************************************************************************************************
     
399. //
     
400. //
     
401. //************************************************************************************************
     
402. void RCC_Config(void)
     
403.   {   
     
404.   u8 HSE_StartUp;
     
405.                 /* Setup the microcontroller system. Initialize the Embedded Flash Interface,  
     
406.      initialize the PLL and update the SystemFrequency variable. */
     
407. // SystemInit();
     
408.                 RCC_DeInit();
     
409. //                RCC_HSICmd(ENABLE);
     
410. //                while(RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET){}  //等待
     
411.                 HSE_StartUp = ERROR;
     
412.                 RCC_HSEConfig(RCC_HSE_ON);
     
413.                 while (HSE_StartUp == ERROR)
     
414.                         {
     
415.                         HSE_StartUp=RCC_WaitForHSEStartUp();
     
416.                         };
     
417.                         RCC_HSICmd(DISABLE);
     
418.                 if(1)
     
419.                   {
     
420.                         FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     
421.                         FLASH_SetLatency(FLASH_Latency_2);
     
422.                         RCC_HCLKConfig(RCC_SYSCLK_Div1);
     
423.                         RCC_PCLK2Config(RCC_HCLK_Div1);
     
424.                         RCC_PCLK1Config(RCC_HCLK_Div2);
     
425.                         RCC_ADCCLKConfig(RCC_PCLK2_Div2);
     
426.                         RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);  //PLL输入时钟=HSE,*9输出
     
427.                         RCC_PLLCmd(ENABLE);
     
428.                         while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET){}
     
429.                         RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     
430.                         while(RCC_GetSYSCLKSource() != 0x08){}
     
431.                         }
     
432.         
     
433.                         RCC_APB1PeriphClockCmd( RCC_APB1Periph_UART5,ENABLE);  
     
434.                         RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB |
     
435.                          RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD |RCC_APB2Periph_GPIOE,
     
436.                          ENABLE);        
     
437.   }
     
438. 
     
439. //************************************************************************************************
     
440. //
     
441. //
     
442. //************************************************************************************************
     
443. void GPIO_Config(void)
     
444. {
     
445.         GPIO_InitTypeDef GPIO_InitStructure;
     
446.         RCC_APB1PeriphClockCmd( RCC_APB1Periph_UART4|RCC_APB1Periph_UART5,ENABLE);  
     
447.   RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB |
     
448.                          RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD |
     
449.                          RCC_APB2Periph_GPIOE|RCC_APB2Periph_AFIO, ENABLE);        
     
450.   GPIO_InitStructure.GPIO_Pin = LED3|LED4;                                     //led3~led4
     
451.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
     
452.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
     
453.   GPIO_Init(LED_GPIO, &GPIO_InitStructure);        
     
454.         
     
455.   GPIO_InitStructure.GPIO_Pin = KEY1|KEY2|KEY3;                                     //KEY1,KEY2,KEY3
     
456.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
     
457.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
458.   GPIO_Init(KEY_GPIO, &GPIO_InitStructure);                                         
     
459.         
     
460.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;  //CTRL口，PA5，PA6，PA7
     
461.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
462.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
     
463.         GPIO_Init(GPIOA, &GPIO_InitStructure);        
     
464.                                  
     
465. }
     
466. 
     
467. //************************************************************************************************
     
468. //
     
469. //************************************************************************************************
     
470. void NVIC_Config(void)
     
471. {
     
472. //  NVIC_InitTypeDef NVIC_InitStructure;
     
473. //  /* Configure the NVIC Preemption Priority Bits */  
     
474. //  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
     
475. //  
     
476. //  /* Enable the UART5 Interrupt */
     
477. //  NVIC_InitStructure.NVIC_IRQChannel = UART5_IRQn;
     
478. //  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
     
479. //  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
     
480. //  NVIC_Init(&NVIC_InitStructure);
     
481. 
     
482. }
     
483. //************************************************************************************************
     
484. //
     
485. //
     
486. //************************************************************************************************
     
487. void TIM2_IRQHandler(void)
     
488.         {
     
489.                 u8 Key_In;
     
490.                 u8  Key_State = 0xFF;
     
491.                 TIM_ClearITPendingBit(TIM2, TIM_IT_Update );
     
492.     if (time_sec < 100)
     
493.                 {
     
494.                         time_sec++;
     
495.                 }
     
496.                 else
     
497.                 {
     
498.                         time_sec =0;
     
499.                         Time_Cont++;
     
500.             if (GPIO_ReadInputDataBit(LED_GPIO,LED4)== Bit_SET)
     
501.                         {
     
502.                         GPIO_ResetBits(LED_GPIO, LED4);// LED3亮
     
503.                         }
     
504.                   else
     
505.                         {
     
506.                                 GPIO_SetBits(LED_GPIO, LED4);        //LED3灭
     
507.                         }                                
     
508.                 }
     
509.                 Key_In = GPIO_ReadInputDataBit(KEY_GPIO,KEY3);
     
510.                 if (Key_In == Bit_RESET)
     
511.                 {        
     
512.                    Key_State =Key_State & 0xFB;  //D2=0,1111,1011,0xFB
     
513.                          Disp_Buf[0x3F] = '0';
     
514.                 }
     
515.                 Key_In = GPIO_ReadInputDataBit(KEY_GPIO,KEY2);                        
     
516.                 if (Key_In == Bit_RESET)
     
517.                 {        
     
518.                    Key_State =Key_State & 0xFD;    //D1=0, 1111,1101,0xFD
     
519.                          Disp_Buf[0x1F] = '0';
     
520.                 }        
     
521.                 Key_In = GPIO_ReadInputDataBit(KEY_GPIO,KEY1);
     
522.                 if (Key_In == Bit_RESET)
     
523.                 {        
     
524.                    Key_State =Key_State & 0xFE; //D0=0,1111,1110, 0xFE
     
525.                          Disp_Buf[0x2F] = '0';
     
526.                 }        
     
527.     Key_State=Key_State & 0x07;
     
528.                
     
529.                 if (Key_State == Key_Code )
     
530.                 {
     
531.             if (Key_State == 0x07)
     
532.                         {
     
533.                                 Key_Release = Ture;        //无按键按下（按键释放）
     
534.                                                                                                                 //维持原来的Key_Flg,等待主函数处理
     
535.                                 
     
536.                         }
     
537.                         else
     
538.                         {
     
539.                                 if(Key_Release == Ture)  //原来按键是释放的
     
540.                                 {
     
541.                                         Key_Code = Key_State;
     
542.                                         Key_Flg = Key_Press;
     
543.                                         Key_Release = False;                                       
     
544.                                 }
     
545.                         }
     
546.                 }
     
547.                 else
     
548.                 {
     
549.                   Key_Code = Key_State;    //相邻两次扫描的键状态不一致，是抖动状态
     
550.                                                  //        暂存当前键状态，等待下一次定时中断
     
551.                 }
     
552. //                Disp_Buf[0x3C]='K';
     
553. //                Disp_Buf[0x3E]='=';
     
554. //                Disp_Buf[0x3F]=Key_Code+0x30;
     
555.                
     
556. //                */
     
557.   }
     
558. 
     
559. //************************************************************************************************
     
560. //
     
561. //
     
562. //************************************************************************************************
     
563. void USART1_IRQHandler(void)
     
564.         {
     
565. 
     
566.         }
     
567. //************************************************************************************************
     
568. //串口5中断处理
     
569. //************************************************************************************************
     
570. void UART5_IRQHandler(void)
     
571.         {
     
572.                 ;//
     
573.         }
     
574.         
     
575.         
     
576. //*********************************************************************************************
     
577. // 按键处理程序
     
578. //*********************************************************************************************
     
579.         void Key_Code00(void)     //000:三个按键全按下,第一行最右端显示E-K0
     
580.         {
     
581.                 Disp_Buf[0x0C] = 'E';
     
582.                 Disp_Buf[0x0D] = '-';
     
583.                 Disp_Buf[0x0E] = 'K';
     
584.                 Disp_Buf[0x0F] = '0';
     
585.         }
     
586.         
     
587. //*********************************************************************************************
     
588. // 按键处理程序
     
589. //*********************************************************************************************
     
590.         void Key_Code01(void)     //001:K1,K2按下，第一行最右端显示E-K1
     
591.         {
     
592.                 Disp_Buf[0x0C] = 'E';
     
593.                 Disp_Buf[0x0D] = '-';
     
594.                 Disp_Buf[0x0E] = 'K';
     
595.     Disp_Buf[0x0F] = '1';               
     
596.         }        
     
597. //*********************************************************************************************
     
598. // 按键处理程序
     
599. //*********************************************************************************************
     
600.         void Key_Code02(void)     //010:K1,K3按下,在第一行最右端显示E-K2
     
601.         {
     
602.                 Disp_Buf[0x0C] = 'E';
     
603.                 Disp_Buf[0x0D] = '-';
     
604.                 Disp_Buf[0x0E] = 'K';
     
605.     Disp_Buf[0x0F] = '2';               
     
606.         }        
     
607. //*********************************************************************************************
     
608. // 按键处理程序，模式按键，每按一次，模式在 电压→电流→电压脉冲→电流脉冲→电压之间转换
     
609. //     Fun_Code值在 0→1→2→3→4→5→6→7→0之间转换。
     
610. //*********************************************************************************************
     
611.         void Key_Code03(void)     //011:K1按下
     
612.         {
     
613.                 Fun_Code = (Fun_Code +1)&0x07;
     
614.                 Disp_Buf[0x0C] = 'F';
     
615.                 Disp_Buf[0x0D] = 'C';
     
616.                 Disp_Buf[0x0E] = '=';
     
617.                 Disp_Buf[0x0F] = Fun_Code+0x30;
     
618. }        
     
619. //*********************************************************************************************
     
620. // 按键处理程序
     
621. //*********************************************************************************************
     
622.         void Key_Code04(void)     //100:K2,K3按下,在第一行最右端显示E-K4
     
623.         {
     
624.                 Disp_Buf[0x0C] = 'E';
     
625.                 Disp_Buf[0x0D] = '-';
     
626.                 Disp_Buf[0x0E] = 'K';
     
627.     Disp_Buf[0x0F] = '4';
     
628.         }        
     
629. //*********************************************************************************************
     
630. // 按键处理程序，设定值减小按键，每按一次，设定值Set_Val-1直到0
     
631. //*********************************************************************************************
     
632.         void Key_Code05(void)     //101:K2按下
     
633.         {
     
634.                 if(Set_Val != 0x00)
     
635.                 {
     
636.                         Set_Val = (Set_Val -1);
     
637.                 }
     
638.                 Disp_Buf[0x0A] = 'S';
     
639.                 Disp_Buf[0x0B] = 'E';
     
640.                 Disp_Buf[0x0C] = 'T';
     
641.                 Disp_Buf[0x0D] = '=';
     
642.     Disp_Buf[0x0E] = ' ';                                 
     
643.                 Disp_Buf[0x0F] = Set_Val+0x30;
     
644.         }        
     
645. //*********************************************************************************************
     
646. // 按键处理程序，设定增大按键，每按一次，设定值Set_Val+1直到7（档）
     
647. //*********************************************************************************************
     
648.         void Key_Code06(void)     //110:K3按下
     
649.         {
     
650.                 if(Set_Val < 0x07)
     
651.                 {
     
652.                         Set_Val = (Set_Val +1)&0x07;
     
653.                 }
     
654.                 Disp_Buf[0x0A] = 'S';
     
655.                 Disp_Buf[0x0B] = 'E';
     
656.                 Disp_Buf[0x0C] = 'T';
     
657.                 Disp_Buf[0x0D] = '=';
     
658.     Disp_Buf[0x0E] = ' ';                                 
     
659.                 Disp_Buf[0x0F] = Set_Val+0x30;
     
660.         }               
     
661. //*********************************************************************************************
     
662. // 按键处理程序，无按键按下，设置Key_on标识
     
663. //*********************************************************************************************
     
664.         void Key_Code07(void)     //111:无键按下
     
665.         {
     
666.                 Key_Release = Ture;
     
667.                 Disp_Buf[0x0E] = 'K';
     
668.     Disp_Buf[0x0F] = 'O';                                 
     
669.         }               
     
670. //--------------------------------------------------------------------------------------------
     
671. //********************************************************************************************
     
672. //--------------------------------------------------------------------------------------------
     
673.         //功能函数0: 直流电压输出，在第一行左边显示 DC,U=xx.yV
     
674. //           依据设定值Set_Val控制直流输出电压（PA7,PA6，PA5)三位控制DC-DC输出电压，
     
675. //
     
676. //********************************************************************************************        
     
677. //............................................................................................
     
678. void Fun_Code00(void)     //000:
     
679.         {
     
680.                 u8 Voltage;
     
681.                 Disp_Buf[0x00] = 'D';
     
682.                 Disp_Buf[0x01] = 'C';
     
683.                 Disp_Buf[0x02] = ':';
     
684.                 Disp_Buf[0x03] = 'U';
     
685.     Disp_Buf[0x04] = 's';                                 
     
686.                 Disp_Buf[0x05] = '=';
     
687.                 switch (Set_Val)
     
688.                 {                        
     
689.                         case 0x00:
     
690.                                 Voltage = 6;
     
691.                           GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
692.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
693.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);                        
     
694.                 //  DA_OUT(60};                                                                                                        //DA输出60。
     
695.                                 break;
     
696.                         case 0x01:
     
697.                                 Voltage = 9;
     
698.                                 GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
699.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
700.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);        
     
701.                 //  DA_OUT(90};                                                                                                        //DA输出60。                        
     
702.                           break;
     
703.                         case 0x02:
     
704.                                 Voltage = 12;
     
705.                                 GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
706.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
707.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);        
     
708.                 //  DA_OUT(120};                                                                                                        //DA输出60。                        
     
709.                           break;
     
710.                         case 0x03:
     
711.                                 Voltage = 15;
     
712.                                 GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
713.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
714.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);        
     
715.                 //  DA_OUT(15};                                                                                                        //DA输出60。                        
     
716.                           break;
     
717.                         case 0x04:
     
718.                                 Voltage = 18;
     
719.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
720.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
721.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);               
     
722.                 //  DA_OUT(180};                                                                                                        //DA输出60。                        
     
723.                           break;
     
724.                         case 0x05:
     
725.                                 Voltage = 20;
     
726.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
727.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
728.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);                        
     
729.                                         //  DA_OUT(200};                                                                                                        //DA输出60。
     
730.                           break;        
     
731.                         case 0x06:
     
732.                                 Voltage = 22;
     
733.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
734.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
735.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);               
     
736.                 //  DA_OUT(220};                                                                                                        //DA输出60。                        
     
737.                           break;        
     
738.                         case 0x07:
     
739.                                 Voltage = 25;
     
740.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
741.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
742.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);
     
743.                 //  DA_OUT(250};                                                                                                        //DA输出60。                        
     
744.                           break;                        
     
745.                 }        
     
746.                 Disp_Buf[0x06] = Set_Val+0x30;
     
747.                 Disp_Buf[0x07] = ' ';
     
748.                 Disp_Buf[0x08] = 'L';
     
749.                 Disp_Buf[0x09] = 'e';
     
750.                 Disp_Buf[0x0A] = 'v';
     
751.                 Disp_Buf[0x0B] = 'e';
     
752.                 Disp_Buf[0x0C] = 'l';
     
753.                 Disp_Buf[0x0D] = ' ';
     
754.                 Disp_Buf[0x0E] = ' ';
     
755.                 Disp_Buf[0x0F] = ' ';
     
756.         
     
757. /*               
     
758.                 Disp_Buf[0x06] = Voltage/10+0x30;
     
759.                 Disp_Buf[0x07] = Voltage%10+0x30;
     
760.                 Disp_Buf[0x08] = '.';
     
761.                 Disp_Buf[0x09] = '0';
     
762. */
     
763.         }               
     
764. //--------------------------------------------------------------------------------------------
     
765. //********************************************************************************************
     
766. //--------------------------------------------------------------------------------------------
     
767.         //功能函数0: 直流电压输出，在第一行左边显示 DC,U=xx.yV
     
768. //           依据设定值Set_Val控制直流输出电压（PA7,PA6，PA5)三位控制DC-DC输出电压，
     
769. //
     
770. //********************************************************************************************        
     
771. //............................................................................................
     
772. void Fun_Code01(void)     //000:
     
773.         {
     
774.                 u8 Voltage;
     
775.                 Disp_Buf[0x00] = 'D';
     
776.                 Disp_Buf[0x01] = 'C';
     
777.                 Disp_Buf[0x02] = ':';
     
778.                 Disp_Buf[0x03] = 'I';
     
779.     Disp_Buf[0x04] = 's';                                 
     
780.                 Disp_Buf[0x05] = '=';
     
781.                 switch (Set_Val)
     
782.                 {                        
     
783.                         case 0x00:
     
784.                                 Voltage = 6;
     
785.                           GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
786.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
787.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);        
     
788.                 //  DA_OUT(60};                                                                                                        //DA输出60。                        
     
789.                                 break;
     
790.                         case 0x01:
     
791.                                 Voltage = 9;
     
792.                                 GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
793.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
794.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);               
     
795.                 //  DA_OUT(90};                                                                                                        //DA输出90。                        
     
796.                           break;
     
797.                         case 0x02:
     
798.                                 Voltage = 12;
     
799.                                 GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
800.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
801.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);                        
     
802.                 //  DA_OUT(120};                                                                                                        //DA输出120。
     
803.                           break;
     
804.                         case 0x03:
     
805.                                 Voltage = 15;
     
806.                                 GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
807.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
808.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);        
     
809.                 //  DA_OUT(150};                                                                                                        //DA输出150。                        
     
810.                           break;
     
811.                         case 0x04:
     
812.                                 Voltage = 18;
     
813.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
814.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
815.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);               
     
816.                 //  DA_OUT(180};                                                                                                        //DA输出180。                        
     
817.                           break;
     
818.                         case 0x05:
     
819.                                 Voltage = 20;
     
820.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
821.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
822.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);               
     
823.                 //  DA_OUT(200};                                                                                                        //DA输出200。                        
     
824.                           break;        
     
825.                         case 0x06:
     
826.                                 Voltage = 22;
     
827.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
828.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
829.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);               
     
830.                 //  DA_OUT(220};                                                                                                        //DA输出220。                        
     
831.                           break;        
     
832.                         case 0x07:
     
833.                                 Voltage = 25;
     
834.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
835.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
836.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);        
     
837.                 //  DA_OUT(250};                                                                                                        //DA输出250。                        
     
838.                           break;                        
     
839.                 }        
     
840.                 Disp_Buf[0x06] = Set_Val+0x30;
     
841.                 Disp_Buf[0x07] = ' ';
     
842.                 Disp_Buf[0x08] = 'L';
     
843.                 Disp_Buf[0x09] = 'e';
     
844.                 Disp_Buf[0x0A] = 'v';
     
845.                 Disp_Buf[0x0B] = 'e';
     
846.                 Disp_Buf[0x0C] = 'l';
     
847.                 Disp_Buf[0x0D] = ' ';
     
848.                 Disp_Buf[0x0E] = ' ';
     
849.                 Disp_Buf[0x0F] = ' ';
     
850. /*               
     
851.                 Disp_Buf[0x06] = Voltage/10+0x30;
     
852.                 Disp_Buf[0x07] = Voltage%10+0x30;
     
853.                 Disp_Buf[0x08] = '.';
     
854.                 Disp_Buf[0x09] = '0';
     
855. */
     
856.         }        
     
857. //--------------------------------------------------------------------------------------------
     
858. //********************************************************************************************
     
859. //--------------------------------------------------------------------------------------------
     
860.         //功能函数0: 直流电压输出，在第一行左边显示 DC,U=xx.yV
     
861. //           依据设定值Set_Val控制直流输出电压（PA7,PA6，PA5)三位控制DC-DC输出电压，
     
862. //
     
863. //********************************************************************************************        
     
864. //............................................................................................
     
865. void Fun_Code02(void)     //010:
     
866.         {
     
867.                 u8 Voltage;
     
868.                 Disp_Buf[0x00] = 'P';
     
869.                 Disp_Buf[0x01] = 'V';
     
870.                 Disp_Buf[0x02] = ':';
     
871.                 Disp_Buf[0x03] = 'U';
     
872.     Disp_Buf[0x04] = 's';                                 
     
873.                 Disp_Buf[0x05] = '=';
     
874.                 switch (Set_Val)
     
875.                 {                        
     
876.                         case 0x00:
     
877.                                 Voltage = 6;
     
878.                           GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
879.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
880.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);               
     
881.                 //  DA_OUT(60};                                                                                                        //DA输出60。                                                
     
882.                                 break;
     
883.                         case 0x01:
     
884.                                 Voltage = 9;
     
885.                                 GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
886.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
887.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);               
     
888.                 //  DA_OUT(90};                                                                                                        //DA输出90。                                                
     
889.                           break;
     
890.                         case 0x02:
     
891.                                 Voltage = 12;
     
892.                                 GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
893.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
894.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);               
     
895.                 //  DA_OUT(120};                                                                                                        //DA输出120。                                                
     
896.                           break;
     
897.                         case 0x03:
     
898.                                 Voltage = 15;
     
899.                                 GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
900.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
901.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);        
     
902.                 //  DA_OUT(150};                                                                                                        //DA输出150。                                                
     
903.                           break;
     
904.                         case 0x04:
     
905.                                 Voltage = 18;
     
906.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
907.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
908.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);               
     
909.                 //  DA_OUT(180};                                                                                                        //DA输出180。                                                
     
910.                           break;
     
911.                         case 0x05:
     
912.                                 Voltage = 20;
     
913.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
914.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
915.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);               
     
916.                 //  DA_OUT(200};                                                                                                        //DA输出200。                                                
     
917.                           break;        
     
918.                         case 0x06:
     
919.                                 Voltage = 22;
     
920.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
921.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
922.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);                        
     
923.                 //  DA_OUT(220};                                                                                                        //DA输出220。                        
     
924.                           break;        
     
925.                         case 0x07:
     
926.                                 Voltage = 25;
     
927.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
928.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
929.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);                        
     
930.                 //  DA_OUT(250};                                                                                                        //DA输出250。                        
     
931.                           break;                        
     
932.                 }        
     
933.                 Disp_Buf[0x06] = Set_Val+0x30;
     
934.                 Disp_Buf[0x07] = ' ';
     
935.                 Disp_Buf[0x08] = 'L';
     
936.                 Disp_Buf[0x09] = 'e';
     
937.                 Disp_Buf[0x0A] = 'v';
     
938.                 Disp_Buf[0x0B] = 'e';
     
939.                 Disp_Buf[0x0C] = 'l';
     
940.                 Disp_Buf[0x0D] = ' ';
     
941.                 Disp_Buf[0x0E] = ' ';
     
942.                 Disp_Buf[0x0F] = ' ';
     
943. /*               
     
944.                 Disp_Buf[0x06] = Voltage/10+0x30;
     
945.                 Disp_Buf[0x07] = Voltage%10+0x30;
     
946.                 Disp_Buf[0x08] = '.';
     
947.                 Disp_Buf[0x09] = '0';
     
948. */
     
949.         }                        
     
950. //--------------------------------------------------------------------------------------------
     
951. //********************************************************************************************
     
952. //--------------------------------------------------------------------------------------------
     
953.         //功能函数0: 直流电压输出，在第一行左边显示 DC,U=xx.yV
     
954. //           依据设定值Set_Val控制直流输出电压（PA7,PA6，PA5)三位控制DC-DC输出电压，
     
955. //
     
956. //********************************************************************************************        
     
957. //............................................................................................
     
958. void Fun_Code03(void)     //011:
     
959.         {
     
960.                 u8 Voltage;
     
961.                 Disp_Buf[0x00] = 'P';
     
962.                 Disp_Buf[0x01] = 'C';
     
963.                 Disp_Buf[0x02] = ':';
     
964.                 Disp_Buf[0x03] = 'I';
     
965.     Disp_Buf[0x04] = 's';                                 
     
966.                 Disp_Buf[0x05] = '=';
     
967.                 switch (Set_Val)
     
968.                 {                        
     
969.                         case 0x00:
     
970.                                 Voltage = 6;
     
971.                           GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
972.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
973.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);        
     
974.                 //  DA_OUT(60};                                                                                                        //DA输出60。                                                
     
975.                                 break;
     
976.                         case 0x01:
     
977.                                 Voltage = 9;
     
978.                                 GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
979.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
     
980.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);               
     
981.                 //  DA_OUT(90};                                                                                                        //DA输出90。                                                
     
982.                           break;
     
983.                         case 0x02:
     
984.                                 Voltage = 12;
     
985.                                 GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
986.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
987.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);        
     
988.                 //  DA_OUT(120};                                                                                                        //DA输出120。                                                
     
989.                           break;
     
990.                         case 0x03:
     
991.                                 Voltage = 15;
     
992.                                 GPIO_ResetBits(GPIOA,GPIO_Pin_5);
     
993.                           GPIO_SetBits(GPIOA,GPIO_Pin_6);
     
994.                           GPIO_SetBits(GPIOA,GPIO_Pin_7);                        
     
995.                 //  DA_OUT(150};                                                                                                        //DA输出150。                        
     
996.                           break;
     
997.                         case 0x04:
     
998.                                 Voltage = 18;
     
999.                                 GPIO_SetBits(GPIOA,GPIO_Pin_5);
     
1000.                           GPIO_ResetBits(GPIOA,GPIO_Pin_6);
      
1001.                           GPIO_ResetBits(GPIOA,GPIO_Pin_7);               
      
1002.                 //  DA_OUT(180};                                                                                                        //DA输出180。                                                
      
1003.                           break;
      
1004.                         case 0x05:
      
1005.                                 Voltage = 20;
      
1006. ……………………
      
1007. 
      
1008. …………限于本文篇幅 余下代码请从51黑下载附件…………
      

复制代码

所有资料51hei提供下载:
STM32_12864(ok).rar (390.64 KB, 下载次数: 207)

2017-11-29 03:44 上传

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

---

作者: 红心拾箭    时间: 2018-8-5 15:46
代码很好,给楼主赞一个

---

作者: e电动小马达e    时间: 2018-12-13 17:38
谢谢楼主

---

作者: lanhua520    时间: 2018-12-13 19:24
用KEIL运行“ET_PRG”时，怎么头文件都没有装进去？
要自己装入么，怎么装？

---

作者: lanhua520    时间: 2018-12-13 21:30


编译时出错：
请帮解决！
谢谢！！

---

作者: lanhua520    时间: 2018-12-13 21:45


用KEIL运行“ET_PRG”时，怎么头文件都没有装进去？
要自己装入么，怎么装？

---

作者: vv00707    时间: 2018-12-15 11:41
学习一下

---

作者: 调戏巴雷特    时间: 2019-2-9 11:02
谢谢楼主

---

作者: 长尾巴大熊    时间: 2019-4-9 16:49

代码很好,给楼主赞一个

---

作者: hilam    时间: 2019-9-25 12:59
有人验证过吗？PSB是决定使用并行还是串行通信吧，这样能行吗？
#define LCD12864_PSB_1  GPIO_SetBits(LCD12864_GPIO_PSB, LCD12864_GPIO_PSB_PIN)        //PBS Ö¸áî êä3ö1
#define LCD12864_PSB_0  GPIO_ResetBits(LCD12864_GPIO_PSB, LCD12864_GPIO_PSB_PIN)//         êä3ö0

---

作者: jk859    时间: 2019-12-29 12:50
头文件问题怎么解决楼主

---

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

Powered by Discuz! X3.1