提供一下MD_AD9833.h下库文件

提供一下MD_AD9833.h下库文件

对学习有很大的帮助哦，赞一个

下载了，没有提供有MD_AD9833.h头文件

我的AD9833没有输出波形，各个引脚电压也正常，晶振输出波形也正常，到底啥原因？

努力自己也制作一个！！！

真的对自己学习有很大的帮助哦

高度赞扬！真是好实践！！！

没有注释看得脑壳疼

关于您在“Arduino+ad9833制作DDS信号发生器代码和原理图 实测成功”的帖子
拜读了您的Arduino+ad9833大做，收获不小。

关于您在“Arduino+ad9833制作DDS信号发生器代码和原理图 实测成功”的帖子
拜读了您的Arduino+ad9833大做，收获不小。现有个问题请教。关于频率设置方法好像和常规函数发生器不一样。不知为什么不采用常规的设置方法，盼望回复。

拜读了您的Arduino+ad9833大做，收获不小。现有个问题请教。关于频率设置方法好像和常规函数发生器不一样。不知为什么不采用常规的设置方法，盼望回复。

关于您在“Arduino+ad9833制作DDS信号发生器代码和原理图 实测成功”的帖子
拜读了您的Arduino+ad9833大做，收获不小。现有个问题请教。关于频率设置方法好像和常规函数发生器不一样。不知为什么不采用常规的设置方法，盼望回复。

代码和原理图 9833.zip (252.89 KB, 下载次数: 227)

2019-4-24 10:48 上传

点击文件名下载附件

1. // include the library code:
   
2. #include <LiquidCrystal.h>
   
3. #include <SPI.h>
   
4. #include <MD_AD9833.h>
   
5. #include "pins_arduino.h"
   
6. 
   
7. /* Digital potentiometer constants */
   
8. #define DP_nINC 4 // D4
   
9. #define DP_UnD  3 // D3
   
10. #define DP_nCS  2 // D2
    
11. 
    
12. /* LCD Constants */
    
13. #define LCD_D7 14 // A0
    
14. #define LCD_D6 15 // A1
    
15. #define LCD_D5 16 // A2
    
16. #define LCD_D4 17 // A3
    
17. #define LCD_E  19 // A5
    
18. #define LCD_RS 5 // D5
    
19. 
    
20. /* Function generator constants */
    
21. #define DATA 11 // D11
    
22. #define CLK 13 // D13
    
23. #define FSYNC 10 // D10
    
24. 
    
25. /* Other pin definition constants */
    
26. #define VBAT 21 // A7
    
27. #define CAP_ON 18 // A4
    
28. #define CATHODE_PWM 9 // D9
    
29. 
    
30. /* Boolean Constants */
    
31. #define OFF false
    
32. #define ON true
    
33. 
    
34. /* Encoder constants */
    
35. #define ENC_A 8   // D8
    
36. #define ENC_B 7   // D7
    
37. #define ENC_SW 6  // D6
    
38. 
    
39. /* Encoder States */
    
40. #define UP 1
    
41. #define DOWN -1
    
42. #define SAME 0
    
43. 
    
44. /* Sequential state machine constants */
    
45. enum OutputConstants { NOFF = 1, SINE, TRIG, SQUARE };
    
46. enum States { StateOut = 1, StateAmplitude, Coupling, StateFreqHz, StateFreqKhz, StateFreqMhz, Brightness};
    
47. 
    
48. /* Custom LCD battery characters */
    
49. byte Bat0[8] = {0b01110, 0b11011, 0b10001, 0b10001, 0b10001, 0b10001, 0b10001, 0b11111};
    
50. byte Bat1[8] = {0b01110, 0b11011, 0b10001, 0b10001, 0b10001, 0b11111, 0b11111, 0b11111};
    
51. byte Bat2[8] = {0b01110, 0b11011, 0b10001, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
    
52. byte Bat3[8] = {0b01110, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
    
53. 
    
54. /* AD9833 & LCD Library objects definition */
    
55. MD_AD9833  AD(FSYNC);
    
56. MD_AD9833::channel_t chan;
    
57. MD_AD9833::mode_t mode;  
    
58. LiquidCrystal lcd(LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7);
    
59. 
    
60. /* Global state machine in-used variables */
    
61. unsigned char MenuState = StateOut;   // Initial state
    
62. volatile uint8_t OutType = NOFF;      // Output waveform type
    
63. volatile uint8_t DigiPotState = 0;    // Digital potentiometer wiper state
    
64. volatile bool CouplingOn = true;      // AC or DC coupling state
    
65. volatile uint8_t BrightnessState = 0; // LCD Backlight brightness state
    
66. 
    
67. /* Encoder pins state */
    
68. volatile bool encoder_A = false;
    
69. volatile bool encoder_B = false;
    
70. volatile bool encoder_A_prev = false;
    
71. 
    
72. /* Frequency states */
    
73. volatile uint32_t FreqHz = 0;
    
74. volatile uint32_t FreqKhz = 0;
    
75. volatile uint32_t FreqMhz = 0;
    
76. 
    
77. 
    
78. /* Function prototypes */
    
79. volatile uint8_t *port_to_pcmask[] = { &PCMSK0, &PCMSK1,&PCMSK2 };
    
80. static int PCintMode[24];
    
81. typedef void (*voidFuncPtr)(void);
    
82. volatile static voidFuncPtr PCintFunc[24] = { NULL };
    
83. volatile static uint8_t PCintLast[3];
    
84. void EnableInterrupts();
    
85. void DisableInterrupts();
    
86. void InitEncoder();
    
87. void InitOther();
    
88. void InitDigipot();
    
89. void CreateLcdChars();
    
90. byte ProcessBatteryVoltage();
    
91. void SetLcdBrightness(int brightness);
    
92. void PotDown();
    
93. void PotUp();
    
94. void InitPotState();
    
95. void InitDevice();
    
96. void SetADFrequency();
    
97. void SetADOutput();
    
98. void SetADOutType();
    
99. void BrightnessUp();
    
100. void BrightnessDown();
     
101. volatile int GetEncoderPos();
     
102. void EncoderPositionChanged();
     
103. void MainMenu();
     
104. 
     
105. /* Pin-change interrupts block */
     
106. /* /////////////////////////// */
     
107. void PCattachInterrupt(uint8_t pin, void (*userFunc)(void), int mode)
     
108. {
     
109.   uint8_t bit = digitalPinToBitMask(pin);
     
110.   uint8_t port = digitalPinToPort(pin);
     
111.   uint8_t slot;
     
112.   volatile uint8_t *pcmask;
     
113. 
     
114.   // map pin to PCIR register
     
115.   if (port == NOT_A_PORT) return;
     
116.   else {
     
117.     port -= 2;
     
118.     pcmask = port_to_pcmask[port];
     
119.   }
     
120.   if (port == 1) slot = port * 8 + (pin - 14);
     
121.   else slot = port * 8 + (pin % 8);
     
122.   PCintMode[slot] = mode;
     
123.   PCintFunc[slot] = userFunc;
     
124.   *pcmask |= bit;
     
125.   PCICR |= 0x01 << port;
     
126. }
     
127. 
     
128. void PCdetachInterrupt(uint8_t pin) {
     
129.   uint8_t bit = digitalPinToBitMask(pin);
     
130.   uint8_t port = digitalPinToPort(pin);
     
131.   volatile uint8_t *pcmask;
     
132.   // map pin to PCIR register
     
133.   if (port == NOT_A_PORT) return;
     
134.   else {
     
135.     port -= 2;
     
136.     pcmask = port_to_pcmask[port];
     
137.   }
     
138.   *pcmask &= ~bit;
     
139.   if (*pcmask == 0)  PCICR &= ~(0x01 << port);
     
140. }
     
141. 
     
142. static void PCint(uint8_t port) {
     
143.   uint8_t bit;
     
144.   uint8_t curr;
     
145.   uint8_t mask;
     
146.   uint8_t pin;
     
147.   curr = *portInputRegister(port+2);
     
148.   mask = curr ^ PCintLast[port];
     
149.   PCintLast[port] = curr;
     
150.   if ((mask &= *port_to_pcmask[port]) == 0) return;
     
151.   for (uint8_t i=0; i < 8; i++) {
     
152.     bit = 0x01 << i;
     
153.     if (bit & mask) {
     
154.       pin = port * 8 + i;
     
155.       // Trigger interrupt if mode is CHANGE, or if mode is RISING and
     
156.       // the bit is currently high, or if mode is FALLING and bit is low.
     
157.       if ((PCintMode[pin] == CHANGE
     
158.           || ((PCintMode[pin] == RISING) && (curr & bit))
     
159.           || ((PCintMode[pin] == FALLING) && !(curr & bit)))
     
160.           && (PCintFunc[pin] != NULL)) {
     
161.         PCintFunc[pin]();
     
162.       }
     
163.     }
     
164.   }
     
165. }
     
166. 
     
167. /* Interrupt masking functions */
     
168. SIGNAL(PCINT0_vect) { PCint(0); }
     
169. SIGNAL(PCINT1_vect) { PCint(1); }
     
170. SIGNAL(PCINT2_vect) { PCint(2); }
     
171. /* End of pin-change interrupts block */
     
172. /* ////////////////////////////////// */
     
173. 
     
174. /* Enable/disable encoder pin interrupts */
     
175. void EnableInterrupts()
     
176. {
     
177.   PCattachInterrupt(ENC_A, EncoderPositionChanged, CHANGE);
     
178.   PCattachInterrupt(ENC_B, EncoderPositionChanged, CHANGE);
     
179. }
     
180. 
     
181. void DisableInterrupts()
     
182. {
     
183.   PCdetachInterrupt(ENC_A);
     
184.   PCdetachInterrupt(ENC_B);
     
185. }
     
186. 
     
187. void InitEncoder()
     
188. {
     
189.   pinMode(ENC_A, INPUT);
     
190.   pinMode(ENC_B, INPUT);
     
191.   pinMode(ENC_SW, INPUT);
     
192. }
     
193. 
     
194. void InitOther()
     
195. {
     
196.   pinMode(VBAT, INPUT_PULLUP);
     
197.   pinMode(CAP_ON, OUTPUT);
     
198.   pinMode(CATHODE_PWM, OUTPUT);
     
199. }
     
200. 
     
201. 
     
202. void InitDigipot()
     
203. {
     
204.   pinMode(DP_nINC, OUTPUT);
     
205.   pinMode(DP_UnD, OUTPUT);
     
206.   pinMode(DP_nCS, OUTPUT);
     
207. }
     
208. 
     
209. void CreateLcdChars()
     
210. {
     
211.   lcd.createChar(1, Bat0);
     
212.   lcd.createChar(2, Bat1);
     
213.   lcd.createChar(3, Bat2);
     
214.   lcd.createChar(4, Bat3);
     
215. }
     
216. 
     
217. /* Process Li-ion battery voltage state and return appropriate character */
     
218. byte ProcessBatteryVoltage()
     
219. {
     
220.   int BatVoltage  = analogRead(VBAT);
     
221.   //Serial.println(BatVoltage);
     
222.   if (BatVoltage >= 950 && BatVoltage <= 1023) return (byte)4;
     
223.   else if (BatVoltage >= 900 && BatVoltage < 950) return (byte)3;
     
224.   else if (BatVoltage >= 850 && BatVoltage < 900) return (byte)2;
     
225.   else {
     
226.     //Serial.println("Encoder came here");
     
227.     return (byte)1;
     
228.   }
     
229. }
     
230. 
     
231. 
     
232. 
     
233. 
     
234. void SetLcdBrightness(int brightness)
     
235. {
     
236.   analogWrite(CATHODE_PWM, brightness);
     
237. }
     
238. 
     
239. 
     
240. void PotDown()
     
241. {
     
242.   for (uint8_t i = 0; i < 4; i++) {
     
243.   digitalWrite(DP_UnD, LOW);
     
244.   digitalWrite(DP_nINC, LOW);
     
245.   delayMicroseconds(100);
     
246.   digitalWrite(DP_nINC, HIGH);
     
247.   delayMicroseconds(100);
     
248.   if (DigiPotState <= 0) DigiPotState = 0;
     
249.   else DigiPotState--;
     
250.   }
     
251. }
     
252. 
     
253. 
     
254. 
     
255. void PotUp()
     
256. {
     
257.   for (uint8_t i = 0; i < 4; i++) {
     
258.   digitalWrite(DP_UnD, HIGH);
     
259.   digitalWrite(DP_nINC, LOW);
     
260.   delayMicroseconds(100);
     
261.   digitalWrite(DP_nINC, HIGH);
     
262.   delayMicroseconds(100);
     
263.   if (DigiPotState >= 255) DigiPotState = 255;
     
264.   else DigiPotState++;
     
265.   }
     
266. }
     
267. 
     
268. void InitPotState()
     
269. {
     
270.   digitalWrite(DP_nCS, LOW);
     
271.   _delay_ms(10);
     
272.   for (uint8_t i = 0; i < 255; i++) PotDown();  
     
273. }
     
274. 
     
275. 
     
276. 
     
277. 
     
278. void InitDevice()
     
279. {
     
280.   InitEncoder();
     
281.   InitDigipot();
     
282.   InitPotState();
     
283.   InitOther();
     
284.   Serial.begin(57600);
     
285.   Serial.println("Serial logger is enabled");
     
286.   lcd.begin(16, 2);
     
287.   AD.begin();
     
288. }
     
289. 
     
290. void SetADFrequency()
     
291. {
     
292.   uint32_t u1 = FreqHz + (FreqKhz * 1000) + (FreqMhz * 1000000);
     
293.   chan = MD_AD9833::CHAN_0;
     
294.   AD.setFrequency(chan, u1);
     
295. }
     
296. 
     
297. void SetADOutput()
     
298. {
     
299.   chan = MD_AD9833::CHAN_0;
     
300.   AD.setActiveFrequency(chan);
     
301. }
     
302. 
     
303. void SetADOutType()
     
304. {
     
305. switch (OutType)
     
306.       {
     
307.       case NOFF: mode = MD_AD9833::MODE_OFF;    break;
     
308.       case SINE: mode = MD_AD9833::MODE_SINE;   break;
     
309.       case TRIG: mode = MD_AD9833::MODE_TRIANGLE;  break;
     
310.       case SQUARE: mode = MD_AD9833::MODE_SQUARE1;  break;
     
311.       default: break;
     
312.       }  
     
313. AD.setMode(mode);
     
314. }
     
315. 
     
316. void setup() {
     
317.   InitDevice();
     
318.   CreateLcdChars();
     
319.   SetADOutput();
     
320.   pinMode(A4,OUTPUT);
     
321.   digitalWrite(A4,HIGH);
     
322.   mode = MD_AD9833::MODE_OFF;
     
323.   AD.setMode(mode);
     
324.   SetADFrequency();
     
325.   BrightnessState = 127;
     
326.   SetLcdBrightness(BrightnessState);
     
327. }
     
328. 
     
329. void BrightnessUp() {
     
330.   if (BrightnessState >= 250) BrightnessState = 255;
     
331.   else BrightnessState += 4;
     
332.   SetLcdBrightness(BrightnessState);
     
333. }
     
334. 
     
335. void BrightnessDown() {
     
336.   if (BrightnessState <= 5) BrightnessState = 0;
     
337.   else BrightnessState -= 4;
     
338.   SetLcdBrightness(BrightnessState);
     
339. }
     
340. 
     
341. volatile int GetEncoderPos()
     
342. {  
     
343.     volatile int RetVal = 0;
     
344.     encoder_A = digitalRead(ENC_A);
     
345.     encoder_B = digitalRead(ENC_B);   
     
346.     delay(10);
     
347.     if((!encoder_A) && (encoder_A_prev)){
     
348.       if(encoder_B) RetVal = 1;            
     
349.       else RetVal = -1;
     
350.     }   
     
351.     else RetVal = 0;
     
352.     encoder_A_prev = encoder_A;     // Store value of A for next time
     
353.     return RetVal;
     
354. }
     
355. 
     
356. void EncoderPositionChanged()
     
357. {
     
358.    switch(MenuState) {
     
359.     case StateFreqHz:
     
360.       switch(GetEncoderPos()) {  
     
361.             case UP:
     
362.               if (FreqHz >= 900) FreqHz = 900;
     
363.               else FreqHz += 10;
     
364.               break;
     
365.             case DOWN:
     
366.                if (FreqHz < 10) FreqHz = 0;
     
367.                else FreqHz-= 10;
     
368.                break;
     
369.             default: break;
     
370.           }
     
371.           SetADFrequency();
     
372.           break;
     
373.   case StateFreqKhz:
     
374.     switch(GetEncoderPos()) {  
     
375.             case UP:
     
376.               if (FreqKhz >= 900) FreqKhz = 900;
     
377.               else FreqKhz += 1;
     
378.               break;
     
379.             case DOWN:
     
380.                if (FreqKhz <= 10) FreqKhz = 0;
     
381.                else FreqKhz -= 1;
     
382.                break;
     
383.             default: break;
     
384.           }
     
385.           SetADFrequency();
     
386.           break;
     
387.   case StateFreqMhz:
     
388.     switch(GetEncoderPos()) {  
     
389.             case UP:
     
390.               if (FreqMhz >= 10) FreqMhz = 10;
     
391.               else FreqMhz++;
     
392.               break;
     
393.             case DOWN:
     
394.                if (FreqMhz <= 0) FreqMhz = 0;
     
395.                else FreqMhz--;
     
396.                break;
     
397.             default: break;
     
398.           }
     
399.           SetADFrequency();
     
400.           break;
     
401.   case StateAmplitude:
     
402.     switch(GetEncoderPos()) {  
     
403.             case UP: PotUp(); break;
     
404.             case DOWN: PotDown(); break;
     
405.             default: break;
     
406.           }
     
407.           break;
     
408.   case StateOut:
     
409.     switch(GetEncoderPos()) {  
     
410.             case UP:
     
411.               if (OutType >= SQUARE) OutType = SQUARE;
     
412.               else OutType++;
     
413.               break;
     
414.             case DOWN:
     
415.               if (OutType <= NOFF) OutType = NOFF;
     
416.               else OutType--;
     
417.               break;
     
418.             default: break;
     
419.           }
     
420.           SetADOutType();
     
421.           break;
     
422.    case Coupling:
     
423.       switch(GetEncoderPos()) {
     
424.         case UP: CouplingOn = true; break;
     
425.         case DOWN: CouplingOn = false; break;
     
426.         default: break;
     
427.       }
     
428.       digitalWrite(CAP_ON,CouplingOn);
     
429.       break;
     
430.     case Brightness:
     
431.         switch(GetEncoderPos()) {  
     
432.             case UP: BrightnessUp(); break;
     
433.             case DOWN: BrightnessDown(); break;
     
434.             default: break;
     
435.           }
     
436.           break;
     
437.   default: break;   
     
438.    }
     
439. }
     
440. 
     
441. void MainMenu()
     
442. {
     
443.   MenuState = StateOut;
     
444.   EnableInterrupts();
     
445.   bool OutConfirm = false;
     
446.   while(!OutConfirm)
     
447.   {
     
448.     switch(MenuState)
     
449.     {
     
450.       case StateFreqHz:
     
451.         lcd.setCursor(0,0);
     
452.         lcd.print("<Frequency: Hz >");
     
453.         lcd.setCursor(0,1);
     
454.         lcd.print("<Val:");
     
455.         lcd.setCursor(5,1);
     
456.         lcd.print(FreqHz);
     
457.         if (FreqHz <= 9) {
     
458.           lcd.setCursor(6,1);
     
459.           lcd.print("  ");         
     
460.         }
     
461.         else if (FreqHz > 9 && FreqHz <= 99) {
     
462.           lcd.setCursor(7,1);
     
463.           lcd.print(" ");         
     
464.         }
     
465.         lcd.setCursor(8,1);
     
466.         lcd.print("[Hz]   >");
     
467.           if (!digitalRead(ENC_SW)) {
     
468.             while(!digitalRead(ENC_SW));
     
469.             MenuState = StateFreqKhz;
     
470.           }
     
471.         break;
     
472. 
     
473.       case StateFreqKhz:
     
474.         lcd.setCursor(0,0);
     
475.         lcd.print("<Frequency:KHz >");
     
476.         lcd.setCursor(0,1);
     
477.         lcd.print("<Val:");
     
478.         lcd.setCursor(5,1);
     
479.         lcd.print(FreqKhz);
     
480.         if (FreqKhz <= 9) {
     
481.           lcd.setCursor(6,1);
     
482.           lcd.print("  ");         
     
483.         }
     
484.         else if (FreqKhz > 9 && FreqKhz <= 99) {
     
485.           lcd.setCursor(7,1);
     
486.           lcd.print(" ");         
     
487.         }
     
488.         lcd.setCursor(8,1);
     
489.         lcd.print("[KHz]  >");
     
490.           if (!digitalRead(ENC_SW)) {
     
491.             while(!digitalRead(ENC_SW));
     
492.             MenuState = StateFreqMhz;
     
493.           }
     
494.         break;
     
495.         
     
496.       case StateFreqMhz:
     
497.         lcd.setCursor(0,0);
     
498.         lcd.print("<Frequency:MHz >");
     
499.         lcd.setCursor(0,1);
     
500.         lcd.print("<Val:");
     
501.         lcd.setCursor(5,1);
     
502.         lcd.print(FreqMhz);
     
503.         if (FreqMhz <= 9) {
     
504.           lcd.setCursor(6,1);
     
505.           lcd.print("  ");         
     
506.         }
     
507.         else if (FreqMhz > 9 && FreqMhz <= 99) {
     
508.           lcd.setCursor(7,1);
     
509.           lcd.print(" ");         
     
510.         }
     
511.         lcd.setCursor(8,1);
     
512.         lcd.print("[MHz]  >");
     
513.           if (!digitalRead(ENC_SW)) {
     
514.             while(!digitalRead(ENC_SW));
     
515.             MenuState = Brightness;
     
516.           }
     
517.         break;
     
518.    
     
519.       case StateAmplitude:
     
520.         lcd.setCursor(0,0);
     
521.         lcd.print("<Amplitude in %>");
     
522.         lcd.setCursor(0,1);
     
523.         lcd.print("<Value:");
     
524.         lcd.setCursor(7,1);
     
525.         lcd.print((DigiPotState*100)/255);
     
526.         if ((DigiPotState*100)/255 <= 9) {
     
527.           lcd.setCursor(8,1);
     
528.           lcd.print("  ");         
     
529.         }
     
530.         else if ((DigiPotState*100)/255 > 9 && (DigiPotState*100)/255 < 100) {
     
531.           lcd.setCursor(9,1);
     
532.           lcd.print(" ");         
     
533.         }
     
534.         lcd.setCursor(10,1);
     
535.         lcd.print(" [%] >");
     
536.           if (!digitalRead(ENC_SW)) {
     
537.             while(!digitalRead(ENC_SW));
     
538.             MenuState = Coupling;
     
539.           }
     
540.         break;
     
541.          
     
542.       case StateOut:
     
543.         lcd.setCursor(0,0);
     
544.         lcd.print("<   Out Type   >");
     
545.         lcd.setCursor(0,1);
     
546.         lcd.print("<Out:");
     
547.         lcd.setCursor(5,1);
     
548.         switch (OutType)
     
549.         {
     
550.           case NOFF:   lcd.print("Off       >"); break;
     
551.           case SINE:   lcd.print("Sine      >"); break;
     
552.           case TRIG:   lcd.print("Triangle  >"); break;
     
553.           case SQUARE: lcd.print("Square    >"); break;
     
554.           default: break;
     
555.         }
     
556.           if (!digitalRead(ENC_SW)) {
     
557.             while(!digitalRead(ENC_SW));
     
558.             MenuState = StateAmplitude;
     
559.             }
     
560.         break;
     
561. 
     
562.      case Coupling:
     
563.         lcd.setCursor(0,0);
     
564.         lcd.print("< Out Coupling >");
     
565.         lcd.setCursor(0,1);
     
566.         lcd.print("<Type:");
     
567.         lcd.setCursor(6,1);
     
568.         switch (CouplingOn)
     
569.         {
     
570.           case true:   lcd.print(" [DC]    >"); break;
     
571.           case false:   lcd.print(" [AC]    >"); break;
     
572.           default: break;
     
573.         }
     
574.           if (!digitalRead(ENC_SW)) {
     
575.             while(!digitalRead(ENC_SW));
     
576.             MenuState = StateFreqHz;
     
577.             }
     
578.         break;     
     
579. 
     
580. case Brightness:
     
581.         lcd.setCursor(0,0);
     
582.         lcd.print("<  Brightness  >");
     
583.         lcd.setCursor(0,1);
     
584.         lcd.print("<Value:");
     
585.         lcd.setCursor(7,1);
     
586.         lcd.print((BrightnessState*100)/255);
     
587.         if ((BrightnessState*100)/255 <= 9) {
     
588.           lcd.setCursor(8,1);
     
589.           lcd.print("  ");         
     
590.         }
     
591.         else if ((BrightnessState*100)/255 > 9 && (BrightnessState*100)/255 < 100) {
     
592.           lcd.setCursor(9,1);
     
593.           lcd.print(" ");         
     
594.         }
     
595.         lcd.setCursor(10,1);
     
596.         lcd.print(" [%] >");
     
597.           if (!digitalRead(ENC_SW)) {
     
598.             while(!digitalRead(ENC_SW));
     
599.             OutConfirm = true;
     
600.             }
     
601.         break;     
     
602.       }
     
603.       delay(50);
     
604.     }
     
605.     DisableInterrupts();
     
606. }
     
607. 
     
608. void loop() {                  
     
609.   /* Battery Character */
     
610.   lcd.setCursor(15, 0);
     
611.   lcd.write(ProcessBatteryVoltage());
     
612.   /* Out State */
     
613.   lcd.setCursor(0,0);
     
614.   lcd.print("<Output:");
     
615.   lcd.setCursor(8,0);
     
616.   if (OutType != NOFF) lcd.print("ON ");
     
617.   else lcd.print("OFF");
     
618.   lcd.setCursor(11,0);
     
619.   lcd.print(" > ");
     
620.   /* Output Type */
     
621.   lcd.setCursor(0,1);
     
622.   lcd.print("<Y:");
     
623.   lcd.setCursor(3,1);
     
624.   switch(OutType) {
     
625.     case NOFF:    lcd.print("OFF "); break;
     
626.     case SINE:    lcd.print("SIN "); break;
     
627.     case TRIG:    lcd.print("TRN "); break;
     
628.     case SQUARE:  lcd.print("SQR "); break;
     
629.     default: break;
     
630.   }
     
631.   /* Amplitude */
     
632.   lcd.setCursor(7,1);
     
633.   lcd.print("[A]:");
     
634.   lcd.print((DigiPotState*100)/255);
     
635.         if ((DigiPotState*100)/255 <= 9) {
     
636.           lcd.setCursor(12,1);
     
637.           lcd.print("  ");         
     
638.         }
     
639.         else if ((DigiPotState*100)/255 > 9 && (DigiPotState*100)/255 < 100) {
     
640.           lcd.setCursor(13,1);
     
641.           lcd.print(" ");         
     
642.         }
     
643.         lcd.setCursor(14,1);
     
644.         lcd.print("%>");
     
645.   if (!digitalRead(ENC_SW)) {
     
646.     while(!digitalRead(ENC_SW));
     
647.     MainMenu();
     
648.   }
     
649.   delay(50);
     
650. }

复制代码