8F328P-U 示波器

eddiewwm

8F328P-U 示波器
參考：https://create.arduino.cc/projec ... cilloscope&offset=5

更改後的程序：

1. #define bytesPerPackage 32
   
2. #define switch1 4               //sw1 pin
   
3. #define switch2 3               //sw2 pin
   
4. 
   
5. uint8_t bytesRead;
   
6. byte inputBuffer[bytesPerPackage];
   
7. byte outputBuffer[bytesPerPackage];
   
8. boolean sw1, sw2;
   
9. 
   
10. void setup() {
    
11.   analogReadResolution(8);
    
12.   pinMode(switch1, INPUT);
    
13.   digitalWrite(switch1, HIGH);  // enable internal pullup
    
14.   pinMode(switch2, INPUT);
    
15.   digitalWrite(switch2, HIGH);
    
16. ADMUX =  B01000000;         // select internal reference (Vcc - 5V) and port 5 (A0)
    
17. //  ADMUX =  B00000000;           // set external aref and port
    
18.   ADCSRA = B10101101;           // ADC enable, interrupt enable, set default prescaler
    
19.   ADCSRB = B00000000;           // free running mode
    
20.   sei();            // enable interrupts
    
21.   ADCSRA |=B01000000;           // start first conversion
    
22.   Serial.begin(115200);
    
23. }
    
24. 
    
25. void loop() {
    
26.   sw1 = digitalRead(switch1);
    
27.   sw2 = digitalRead(switch2);
    
28.   if (bytesRead >= bytesPerPackage) {  // Buffer full. Send the package.
    
29.     cli();
    
30.     bytesRead = 0;
    
31.    // for (uint8_t i = 0; i < bytesPerPackage; i += 2) {
    
32.    for (uint8_t i = 0; i < bytesPerPackage; i ++) {
    
33.       byte adch = inputBuffer[i];
    
34.       if (!sw1) adch |= B00001000;      // switch position in bits 10 & 11 of each byte pair
    
35.       if (!sw2) adch |= B00000100;
    
36.       outputBuffer[i] = adch;
    
37.     }
    
38.     sei();
    
39.     Serial.write(outputBuffer, bytesPerPackage);
    
40.   }
    
41.   
    
42.   if (Serial.available()) {                // incoming byte -> set prescaler
    
43.     byte inByte = (byte)Serial.read();
    
44.     cli();
    
45.     ADCSRA= B10101000|(inByte&B00000111);  // last 3 bytes of ADCSRA set the prescaler
    
46.     sei();
    
47.     ADCSRA |=B01000000;                    // start first conversion
    
48.   }
    
49. }
    
50. 
    
51. ISR(ADC_vect) {
    
52.   if (bytesRead < bytesPerPackage) {
    
53.     inputBuffer[bytesRead] = ADCL;
    
54.     byte temp = ADCH;
    
55.     bytesRead++;
    
56.   }
    
57. }

复制代码

配合使用的 Processing程序：

1. import processing.serial.*;
   
2. import java.awt.event.KeyEvent;
   
3. 
   
4. // Settings --------------------------------------------------------------------------
   
5. int serialBaudRate=115200;
   
6. int bufferSize=10000000;      // number of samples (memory use: 2 bytes per sample)
   
7. float samplesPerLine=1;       // increment 1 screen line for each [n] samples
   
8. boolean sync=true;            // sync to trig
   
9. float trigLevelLPF=.0001;     // trigLevel lowpass filter (exponential moving average)
   
10. boolean hold=false;           // pause
    
11. int prescaler=5;              // ADC prescaler: 3:8 | 4:16 | 5:32 | 6:64 | 7:128
    
12. // -----------------------------------------------------------------------------------
    
13. 
    
14. Serial serial;
    
15. byte[] buffer= new byte[bufferSize*2];
    
16. int writeIndex, prevWriteIndex, readIndex, trigIndex, trigCounter, loopCounter, windowWidth, windowHeight, offset;
    
17. float voltageRange, sps, frequency, trigLevel, timer;
    
18. int windowX=30;
    
19. int windowY=50;
    
20. boolean connected=false;
    
21. String serialPort;
    
22. 
    
23. void settings() {
    
24.   size(1000, 600);
    
25. }
    
26. 
    
27. void setup() {
    
28.   background(0);
    
29.   surface.setResizable(true);
    
30.   frameRate(50);
    
31. }
    
32. 
    
33. void draw() {
    
34.   windowWidth=width-100;
    
35.   windowHeight=height-100;
    
36.   if (!connected) {
    
37.     background(0, 0, 0);
    
38.     text("ARDUINO OSCILLOSCOPE\n\nSelect serial port:", 25, 25);
    
39.     for (int i=0; i<Serial.list().length; i++)
    
40.       text("F"+(i+1)+" - "+Serial.list()[i], 25, 80+i*20);
    
41.   } else {
    
42.     background(0, 0, 0);
    
43. 
    
44.     // update frequency counters every second
    
45.     loopCounter++;
    
46.     if (loopCounter>frameRate) {  
    
47.       loopCounter=0;
    
48.       float elapsedSeconds=(millis()-timer)/1000;
    
49.       timer=millis();
    
50.       sps=(writeIndex-prevWriteIndex)/elapsedSeconds;  // sample rate
    
51.       if (sps<0)sps+=bufferSize;
    
52.       prevWriteIndex=writeIndex;
    
53.       frequency=trigCounter/elapsedSeconds;            // signal frequency
    
54.       trigCounter=0;
    
55.     }
    
56. /*
    
57.     // read switch position & set voltage range
    
58.     boolean switch1=((buffer[writeIndex*2]&(byte)8)==8);                                                
    
59.     boolean switch2=((buffer[writeIndex*2]&(byte)4)==4);
    
60.     if (!switch1&&!switch2) voltageRange=20;
    
61.     if (!switch1&&switch2) voltageRange=10;
    
62.     if (switch1&&!switch2) voltageRange=6.64;
    
63.     if (switch1&&switch2) voltageRange=5;
    
64. */
    
65. voltageRange=5;
    
66. 
    
67.     // print voltage scale
    
68.     for (int n=0; n<=10; n++)                                                                           
    
69.       text(nf(voltageRange/10*n, 2, 2)+"V", windowX+windowWidth+5, windowY+windowHeight-(n*windowHeight/10));
    
70. 
    
71.     // print interface and statistics
    
72.     text("[F1-F2] ZOOM | [F3] SYNC: "+sync+" | [F4] HOLD: "+hold+" | [F5-F6] TRIG LPF | [F7-F8] PRESCALER: "+nf((pow(2, prescaler)), 1, 0)+" | [<--->] OFFSET", 25, 25);
    
73.     text("frequency: "+nf(frequency, 5, 2)+"Hz"
    
74.       +" | average DCV: "+nf(trigLevel/256*voltageRange, 2, 2)+"V"
    
75.       +" | samplerate: "+nf(sps, 5, 2)+"Hz"
    
76.       +" | samples per line: "+samplesPerLine
    
77.       +" | division: "+samplesPerLine/sps*(float)width*100+"ms", 25, height-20);
    
78. 
    
79.     // draw trigLevel (= average voltage) line
    
80.     stroke(0, 0, 100);                                                                                   
    
81.     int trigLevelHeight=(int)(trigLevel*(float)windowHeight/256);
    
82.     line(windowX, windowY+windowHeight-trigLevelHeight, windowX+windowWidth, windowY+windowHeight-trigLevelHeight);  
    
83. 
    
84.     // draw grid
    
85.     stroke(50);                                                                                          
    
86.     for (float n=0; n<=windowWidth; n+=(float)windowWidth/10)
    
87.       line(n+windowX, windowY, n+windowX, windowHeight+windowY);
    
88.     for (float n=0; n<=windowHeight; n+=(float)windowHeight/10)
    
89.       line(windowX, n+windowY, windowX+windowWidth, n+windowY);
    
90. 
    
91.     // ------------------------------
    
92.     // DRAW WAVEFORM
    
93.     // ------------------------------
    
94.     stroke(255);
    
95.     float prevSampleValue=0;
    
96.     if (sync) readIndex=trigIndex;                               // sync: start reading from last trig position
    
97.     if (!sync) readIndex=writeIndex;                             // no sync: start reading from last sample we received
    
98.     readIndex+=offset;
    
99.     float lineIncr=(float)1/samplesPerLine;
    
100.     if (lineIncr<1) lineIncr=1;
     
101.     for (float line=0; line<windowWidth; line+=lineIncr) {                                          // cycle screen lines (from right to left)
     
102.       float sampleValue=(float)getValueFromBuffer((int)((float)readIndex-line*samplesPerLine));     // get the value for the screen line
     
103.       sampleValue*=(float)windowHeight/256;                                                        // scale to windowHeight
     
104.       if (line>0)
     
105.         line(windowX+windowWidth-line,
     
106.           windowY+windowHeight-prevSampleValue,
     
107.           windowX+windowWidth-line-lineIncr,
     
108.           windowY+windowHeight-sampleValue);
     
109.       prevSampleValue=sampleValue;
     
110.     }
     
111. 
     
112.     // ------------------------------
     
113.     // BUFFER INCOMING BYTES & TRIG
     
114.     // ------------------------------
     
115.     if (hold) {
     
116.       serial.clear();                                                                                      // HOLD: don't receive samples; clear serial buffer
     
117.     } else {
     
118.       while (serial.available ()>0) {                                                                      // RUN: receive samples
     
119.         writeIndex++;  
     
120.         if (writeIndex>=bufferSize) writeIndex=0;                                                          // handle overflow
     
121.         //buffer[writeIndex+writeIndex]=(byte)serial.read();                                                 // add 1 sample (2 bytes) to buffer
     
122.         buffer[writeIndex]=(byte)serial.read();                                                 // add 1 sample (2 bytes) to buffer
     
123.      //   buffer[writeIndex+writeIndex+1]=(byte)serial.read();
     
124.         trigLevel=trigLevel*(1-trigLevelLPF)+(float)getValueFromBuffer(writeIndex)*trigLevelLPF;           // level for trigger intersection = exponential moving average of voltage
     
125.         if (getValueFromBuffer(writeIndex)>=trigLevel&& getValueFromBuffer(writeIndex-1)<trigLevel) {      // rising intersect detected
     
126.           trigIndex=writeIndex;                                                                            // set trigIndex (index of buffer that corresponds to last trig)
     
127.           trigCounter++;                                                                                   // count trigs (to calculate the frequency)
     
128.         }
     
129.       }
     
130.     }
     
131.   }
     
132. }
     
133. 
     
134. 
     
135. // Read value from buffer
     
136. int getValueFromBuffer(int index) {                                                                     
     
137.   while (index<0) index+=bufferSize;                                                                       // handle overflow of circular buffer
     
138. //  return((buffer[index*2]&3)<<8 | buffer[index*2+1]&0xff);                                                 // convert bytes to int
     
139.   return(buffer[index]&0xff);                                                 // convert bytes to int
     
140. }
     
141. 
     
142. // Handle keys
     
143. void keyPressed() {  
     
144.   if (key == CODED) {
     
145.     if (connected) {
     
146.       if (keyCode == KeyEvent.VK_F1) {
     
147.         samplesPerLine*=1.1;
     
148.         if (samplesPerLine*windowWidth>bufferSize) samplesPerLine=bufferSize/windowWidth;
     
149.       }
     
150.       if (keyCode == KeyEvent.VK_F2) {
     
151.         samplesPerLine/=1.1;
     
152.         if (samplesPerLine<1/(float)windowWidth) samplesPerLine=1/(float)windowWidth;
     
153.       }
     
154.       if (keyCode == KeyEvent.VK_F3) {
     
155.         sync=!sync;
     
156.       }
     
157.       if (keyCode == KeyEvent.VK_F4) {
     
158.         hold=!hold;
     
159.       }
     
160.       if (keyCode == KeyEvent.VK_F5) {
     
161.         if (trigLevelLPF<.01) trigLevelLPF*=10;
     
162.       }
     
163.       if (keyCode == KeyEvent.VK_F6) {
     
164.         if (trigLevelLPF>.000001) trigLevelLPF/=10;
     
165.       }
     
166.       if (keyCode == KeyEvent.VK_F7) {
     
167.         if (prescaler>3) prescaler--;
     
168.         serial.write((byte)prescaler);
     
169.       }
     
170.       if (keyCode == KeyEvent.VK_F8) {
     
171.         if (prescaler<7) prescaler++;
     
172.         serial.write((byte)prescaler);
     
173.       }
     
174.       if (keyCode == LEFT) {
     
175.         offset-=samplesPerLine*20;
     
176.         if (offset<-bufferSize) offset=-bufferSize;
     
177.       }
     
178.       if (keyCode == RIGHT) {
     
179.         offset+=samplesPerLine*20;
     
180.         if (offset>0) offset=0;
     
181.       }
     
182.     } else {
     
183.       serial = new Serial(this, Serial.list()[keyCode-112], serialBaudRate);
     
184.       serial.write((byte)prescaler);
     
185.       connected=true;
     
186.     }
     
187.   }
     
188. }

复制代码

eddiewwm

另一個初學型示波器範例：
Arduino - Oscilloscope (poor Man's Oscilloscope)
https://www.instructables.com/id ... -mans-Oscilloscope/

1. // Oscilloscope
   
2. // Input defined by ANALOG_IN
   
3. // SIG_OUT true puts a 2kHz wave on DIGITAL_OUT for testing.
   
4. 
   
5. #define ANALOG_IN 0
   
6. #define DIGITAL_OUT 13
   
7. bool SIG_OUT = true;
   
8. 
   
9. void setup() {
   
10.   analogReadResolution(10);
    
11.   Serial.begin(9600);
    
12.   //Serial.begin(115200);
    
13. 
    
14.   // Generate a signal to examine (testing)
    
15.   if (SIG_OUT) {
    
16.     pinMode(DIGITAL_OUT, OUTPUT);
    
17. 
    
18.     // initialize timer1
    
19.     noInterrupts();           // disable all interrupts
    
20.     TCCR1A = 0;
    
21.     TCCR1B = 0;
    
22.     TCNT1  = 0;
    
23. 
    
24.     OCR1A = 31250;            // compare match register 16MHz/256/2Hz
    
25.     TCCR1B |= (1 << WGM12);   // CTC mode
    
26.     TCCR1B |= (1 << CS12);    // 256 prescaler
    
27.     TIMSK1 |= (1 << OCIE1A);  // enable timer compare interrupt
    
28.     interrupts();             // enable all interrupts
    
29.   }
    
30. }
    
31. 
    
32. // Interrupt based
    
33. ISR(TIMER1_COMPA_vect) {
    
34.   digitalWrite(DIGITAL_OUT, digitalRead(DIGITAL_OUT) ^ 1);   // Toggle
    
35. }
    
36. 
    
37. void loop() {
    
38.   int val = analogRead(ANALOG_IN);
    
39.   Serial.write( 0xff );
    
40.   Serial.write( (val >> 8) & 0xff );
    
41.   Serial.write( val & 0xff );
    
42. }
    

复制代码

配合使用的Processing程序：

1. /*
   
2. * Oscilloscope
   
3. * Gives a visual rendering of analog pin in realtime.
   
4. *
   
5. * ---------------- IMPROVEMENTS ------------------
   
6. * Updates by John Porter, 2/7/2014
   
7. * Added ability to move waveform left or right.
   
8. * Added gridlines (bounds and minor).
   
9. * Added ability to pause/resume.
   
10. * Added ability to measure time.
    
11. * General usability improvements.
    
12. *
    
13. * --------------- ORIGINAL PROJECT ---------------
    
14. * This project is part of Accrochages
    
15. * See http://accrochages.drone.ws
    
16. * (c) 2008 Sofian Audry ([email protected])
    
17. * ------------------------------------------------
    
18. *
    
19. * This program is free software: you can redistribute it and/or modify
    
20. * it under the terms of the GNU General Public License as published by
    
21. * the Free Software Foundation, either version 3 of the License, or
    
22. * (at your option) any later version.
    
23. *
    
24. * This program is distributed in the hope that it will be useful,
    
25. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
26. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    
27. * GNU General Public License for more details.
    
28. *
    
29. * You should have received a copy of the GNU General Public License
    
30. * along with this program. If not, see <http://www.gnu.org/licenses/>.
    
31. */
    
32. 
    
33. // * ------------------ HOT KEYS ------------------
    
34. final char T_UP       = 'w'; // Translate waveform up
    
35. final char T_DOWN     = 's'; //                    down
    
36. final char T_LEFT     = 'a'; //                    left
    
37. final char T_RIGHT    = 'd'; //                    right
    
38. final char Z_IN       = 'c'; // Horizontal zoom in
    
39. final char Z_OUT      = 'z'; //                 out
    
40. final char S_IN       = 'e'; // Vertical scale in
    
41. final char S_OUT      = 'q'; //                out
    
42. final char MGL_UP     = 'r'; // Minor grid lines increase
    
43. final char MGL_DOWN   = 'f'; //                  decrease
    
44. final char TOG_PAUSE  = 'p'; // Toggle pause (unpause resets waveform)
    
45. final char RESET_AXIS = ' '; // Reset axis settings
    
46. final char MEAS_TIME  = 'x'; // Adds and/or highlights vertical bars (time measurement)
    
47. final char BAR_LEFT   = ','; // Move highlighted vertical bar left (can also mouse click)
    
48. final char BAR_RIGHT  = '.'; //                               right
    
49. // * ----------------------------------------------
    
50. 
    
51. // * --------------- STARTING STATE ---------------
    
52. float zoom    = 1.0;
    
53. float scale   = 0.5;
    
54. int centerV   = 0;
    
55. int centerH   = 0;
    
56. int gridLines = 0;
    
57. int com_port  = 0;   // Index number in Serial.list
    
58. // * ----------------------------------------------
    
59. 
    
60. // Global vars
    
61. import processing.serial.*;
    
62. Serial port;                    // Create object from Serial class
    
63. int val;                        // Data received from the serial port
    
64. long valTime;                   // Time data was received
    
65. int[] values;
    
66. long[] times;
    
67. float voltage;
    
68. float measTime = 0;
    
69. int   timeMode = 0;
    
70. int[] timeBars = {0, 0};
    
71. PFont f;
    
72. boolean pause;
    
73. 
    
74. // Setup
    
75. void setup() {
    
76.   size(1280, 480);
    
77.   port = new Serial(this, Serial.list()[com_port], 9600);    // Com port specified here
    
78.   values = new int[width];
    
79.   times = new long[width];
    
80.   timeBars[0] = width/3;
    
81.   timeBars[1] = 2*width/3;
    
82.   pause = false;
    
83.   smooth();
    
84.   f = createFont("Arial", 16, true);
    
85. }
    
86. 
    
87. // Read value from serial stream
    
88. int getValue() {
    
89.   int value = -1;
    
90.   while (port.available () >= 3) {
    
91.     if (port.read() == 0xff) {
    
92.       value = (port.read() << 8) | (port.read());
    
93.     }
    
94.   }
    
95.   return value;
    
96. }
    
97. 
    
98. // Get a y-value for the datapoint, varies based on axis settings
    
99. int getY(int val) {
    
100.   return (int)(height/2 -(val-512+centerV)*scale / 1023.0f * (height - 1));
     
101. }
     
102. 
     
103. // Push the values in the data array
     
104. void pushValue(int value) {
     
105.   for (int i=0; i<width-1; i++)
     
106.     values[i] = values[i+1];
     
107.   values[width-1] = value;
     
108. }
     
109. 
     
110. // Push the timestamps in the time array
     
111. void pushTime(long time) {
     
112.   for (int i=0; i<width-1; i++)
     
113.     times[i] = times[i+1];
     
114.   times[width-1] = time;
     
115. }
     
116. 
     
117. // Draw waveform
     
118. void drawLines() {
     
119.   int x0 = 0, x1 = 0, y0 = 0, y1 = 0;
     
120.   stroke(255,255,0);
     
121.   for (int i=0; i<width; i++) {
     
122.     x1 = round(width - ((width-i) * zoom) + centerH);
     
123.     y1 = getY(values[i]);
     
124.     if(i > 1)
     
125.       line(x0, y0, x1, y1);
     
126.     x0 = x1;
     
127.     y0 = y1;
     
128.   }
     
129. }
     
130. 
     
131. // Draw gridlines (bounds, minor)
     
132. void drawGrid() {
     
133.   // Get scaled values for bounds
     
134.   int pFive = getY(1023);
     
135.   int zero  = getY(0);
     
136. 
     
137.   // Draw voltage bounds
     
138.   stroke(255, 0, 0);
     
139.   line(0, pFive-1, width, pFive-1);
     
140.   line(0, zero+1, width, zero+1);
     
141. 
     
142.   // Add voltage bound text
     
143.   textFont(f, 10);
     
144.   fill(255, 0, 0);
     
145.   text("+5V", 5, pFive+12);
     
146.   text(" 0V", 5, zero-4);
     
147. 
     
148.   // Draw minor grid lines
     
149.   int gridVal = 0;
     
150.   stroke(75, 75, 75);
     
151.   for (int i = 0; i < gridLines; i++) {
     
152.     gridVal = getY(round((i+1.0)*(1023.0 / (gridLines+1.0))));
     
153.     line(0, gridVal, width, gridVal);
     
154.   }
     
155. 
     
156.   // Add minor grid line text
     
157.   if (gridLines > 0) {
     
158.     textFont(f, 16);
     
159.     fill(204, 102, 0);
     
160.     float scaleVal = truncate(5.0f / (gridLines+1), 3);
     
161.     text("Grid: " + scaleVal + "V", 1170, height-12);
     
162.   }
     
163.   
     
164.   // Print difference between vertical 'time' bars
     
165.   if (timeMode > 0) {
     
166.     textFont(f, 16);
     
167.     fill(204, 102, 0);
     
168.    
     
169.     int idx0 = round(width + (timeBars[0] - width - centerH)/zoom);
     
170.     int idx1 = round(width + (timeBars[1] - width - centerH)/zoom);
     
171.    
     
172.     // Ensure time bars are over a recorded portion of the waveform
     
173.     if(idx1 < 0 || idx0 < 0 || idx1 > (width-1) || idx0 > (width-1) || times[idx1] == 0 || times[idx0] == 0)
     
174.       text("Time: N/A", 30, height-12);
     
175.     else{
     
176.       float timeDiff = truncate((times[idx1] - times[idx0])/2000000.0,2);
     
177.       text("Time: " + timeDiff + "ms", 30, height-12);
     
178.     }
     
179.   }
     
180. }
     
181. 
     
182. // Draw vertical 'time bars' (seperate from above for better layering)
     
183. void drawVertLines(){
     
184.   stroke(75, 75, 75);
     
185.   if (timeMode == 1) {
     
186.     line(timeBars[1], 0, timeBars[1], height);
     
187.     stroke(100, 100, 255);
     
188.     line(timeBars[0], 0, timeBars[0], height);
     
189.   }
     
190.   else if (timeMode == 2) {
     
191.     line(timeBars[0], 0, timeBars[0], height);
     
192.     stroke(100, 255, 100);
     
193.     line(timeBars[1], 0, timeBars[1], height);
     
194.   }
     
195. }
     
196. 
     
197. // Truncate a floating point number
     
198. float truncate(float x, int digits) {
     
199.   float temp = pow(10.0, digits);
     
200.   return round( x * temp ) / temp;
     
201. }
     
202. 
     
203. // When a key is pressed down or held...
     
204. void keyPressed() {
     
205.   switch (key) {
     
206.   case T_UP: centerV += 10/scale; break;                     // Move waveform up
     
207.   case T_DOWN: centerV -= 10/scale; break;                   // Move waveform down
     
208.   case T_RIGHT: centerH += 10/scale; break;                  // Move waveform right
     
209.   case T_LEFT: centerH -= 10/scale; break;                   // Move waveform left
     
210.   case MGL_UP:                                               // Increase minor grid lines
     
211.     if (gridLines < 49)
     
212.       gridLines += 1;
     
213.     break;
     
214.   case MGL_DOWN:                                             // Decrease minor grid lines
     
215.     if (gridLines > 0)
     
216.       gridLines -= 1;
     
217.     break;
     
218.   case BAR_LEFT:                                             // Move the time bar left (also mouse click)
     
219.     if (timeMode == 1 && timeBars[0] > 0)
     
220.       timeBars[0] -= 1;
     
221.     else if (timeMode == 2 && timeBars[1] > 0)
     
222.       timeBars[1] -= 1;
     
223.     break;
     
224.   case BAR_RIGHT:                                            // Move the time bar right (also mouse click)
     
225.     if (timeMode == 1 && timeBars[0] < width-1)
     
226.       timeBars[0] += 1;
     
227.     else if (timeMode == 2 && timeBars[1] < width-1)
     
228.       timeBars[1] += 1;
     
229.     break;
     
230.   }
     
231. }
     
232. 
     
233. // When a key is released...
     
234. void keyReleased() {
     
235.   println(key+": "+(int)key);
     
236.   switch (key) {
     
237.   case Z_IN:                                                 // Zoom horizontal
     
238.     zoom *= 2.0f;
     
239.     if ( (int) (width / zoom) <= 1 )
     
240.       zoom /= 2.0f;
     
241.     break;
     
242.   case Z_OUT:                                                // Zoom horizontal
     
243.     zoom /= 2.0f;
     
244.     if (zoom < 1.0f)
     
245.       zoom *= 2.0f;
     
246.     break;
     
247.   case S_IN: scale*=2; break;                                // Scale vertical
     
248.   case S_OUT: scale /= 2; break;                             // Scale vertical
     
249.   case RESET_AXIS:                                           // Reset all scaling
     
250.     centerV = 0; centerH = 0;
     
251.     scale = 0.5; zoom  = 1; gridLines = 0;
     
252.     break;
     
253.   case MEAS_TIME: timeMode = (timeMode + 1) % 3; break;      // Change the vertical bars (off, left bar, right bar)
     
254.   case TOG_PAUSE:                                            // Toggle waveform pausing
     
255.     if (pause) {
     
256.       centerH = 0;
     
257.       for (int i=0; i<width; i++){
     
258.         values[i] = 0;                                       // Clear data on resume
     
259.         times[i] = 0;
     
260.       }
     
261.     }
     
262.     pause = !pause;
     
263.   }
     
264. }
     
265. 
     
266. // Use mouse clicks to quickly move vertical bars (if highlighted)
     
267. void mousePressed() {
     
268.   if(timeMode == 1)
     
269.     timeBars[0] = mouseX;
     
270.   else if(timeMode == 2)
     
271.     timeBars[1] = mouseX;
     
272. }
     
273. 
     
274. // Primary drawing function
     
275. void draw()
     
276. {
     
277.   background(0);
     
278.   drawGrid();
     
279.   // Get current voltage, time of reading
     
280.   val = getValue();
     
281.   valTime = System.nanoTime();
     
282.   
     
283.   // If not paused
     
284.   if (!pause && val != -1) {
     
285.     // Push value/time onto array
     
286.     pushValue(val);
     
287.     pushTime(valTime);
     
288.    
     
289.     // Print current voltage reading
     
290.     textFont(f, 16);
     
291.     fill(204, 102, 0);
     
292.     voltage = truncate(5.0*val / 1023, 1);
     
293.     text("Voltage: " + voltage + "V", 1170, 30);
     
294.   }
     
295.   drawLines();
     
296.   drawVertLines();
     
297. }

复制代码

eddiewwm

把以上範例改以VUSB代替串口：

Arduino程序：

1. // Oscilloscope
   
2. // Input defined by ANALOG_IN
   
3. // SIG_OUT true puts a 2kHz wave on DIGITAL_OUT for testing.
   
4. 
   
5. #include <HIDSerial.h>
   
6. 
   
7. HIDSerial serial;
   
8. 
   
9. #define ANALOG_IN 0
   
10. #define DIGITAL_OUT 13
    
11. bool SIG_OUT = true;
    
12. 
    
13. void setup() {
    
14.   analogReadResolution(8); //use 1-byte A/D
    
15.   serial.begin(); //HID
    
16. 
    
17.   //Serial.begin(9600);
    
18.   //Serial.begin(115200);
    
19. 
    
20.   // Generate a signal to examine (testing)
    
21.   if (SIG_OUT) {
    
22.     pinMode(DIGITAL_OUT, OUTPUT);
    
23. 
    
24.     // initialize timer1
    
25.     noInterrupts();           // disable all interrupts
    
26.     TCCR1A = 0;
    
27.     TCCR1B = 0;
    
28.     TCNT1  = 0;
    
29. 
    
30.     OCR1A = 31250;            // compare match register 16MHz/256/2Hz
    
31.     TCCR1B |= (1 << WGM12);   // CTC mode
    
32.     TCCR1B |= (1 << CS12);    // 256 prescaler
    
33.     TIMSK1 |= (1 << OCIE1A);  // enable timer compare interrupt
    
34.     interrupts();             // enable all interrupts
    
35.   }
    
36. }
    
37. 
    
38. // Interrupt based
    
39. ISR(TIMER1_COMPA_vect) {
    
40.   digitalWrite(DIGITAL_OUT, digitalRead(DIGITAL_OUT) ^ 1);   // Toggle
    
41. }
    
42. 
    
43. //byte val = 0;
    
44. void loop() {
    
45.   byte val = analogRead(ANALOG_IN);
    
46. /*
    
47.     Serial.write( 0xff );
    
48.     Serial.write( (val >> 8) & 0xff );
    
49.     Serial.write( val & 0xff );
    
50.   */
    
51.   if (val==0) val=1; //use 1-byte only and reserve 0 for special use
    
52.   serial.write( val );
    
53.   serial.poll();
    
54. }
    

复制代码

配合使用的Processing程序：

1. /*
   
2. * Oscilloscope
   
3. * Gives a visual rendering of analog pin in realtime.
   
4. *
   
5. * ---------------- IMPROVEMENTS ------------------
   
6. * Updates by John Porter, 2/7/2014
   
7. * Added ability to move waveform left or right.
   
8. * Added gridlines (bounds and minor).
   
9. * Added ability to pause/resume.
   
10. * Added ability to measure time.
    
11. * General usability improvements.
    
12. *
    
13. * --------------- ORIGINAL PROJECT ---------------
    
14. * This project is part of Accrochages
    
15. * See http://accrochages.drone.ws
    
16. * (c) 2008 Sofian Audry ([email protected])
    
17. * ------------------------------------------------
    
18. *
    
19. * This program is free software: you can redistribute it and/or modify
    
20. * it under the terms of the GNU General Public License as published by
    
21. * the Free Software Foundation, either version 3 of the License, or
    
22. * (at your option) any later version.
    
23. *
    
24. * This program is distributed in the hope that it will be useful,
    
25. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
26. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    
27. * GNU General Public License for more details.
    
28. *
    
29. * You should have received a copy of the GNU General Public License
    
30. * along with this program. If not, see <http://www.gnu.org/licenses/>.
    
31. */
    
32. 
    
33. // * ------------------ HOT KEYS ------------------
    
34. final char T_UP       = 'w'; // Translate waveform up
    
35. final char T_DOWN     = 's'; //                    down
    
36. final char T_LEFT     = 'a'; //                    left
    
37. final char T_RIGHT    = 'd'; //                    right
    
38. final char Z_IN       = 'c'; // Horizontal zoom in
    
39. final char Z_OUT      = 'z'; //                 out
    
40. final char S_IN       = 'e'; // Vertical scale in
    
41. final char S_OUT      = 'q'; //                out
    
42. final char MGL_UP     = 'r'; // Minor grid lines increase
    
43. final char MGL_DOWN   = 'f'; //                  decrease
    
44. final char TOG_PAUSE  = 'p'; // Toggle pause (unpause resets waveform)
    
45. final char RESET_AXIS = ' '; // Reset axis settings
    
46. final char MEAS_TIME  = 'x'; // Adds and/or highlights vertical bars (time measurement)
    
47. final char BAR_LEFT   = ','; // Move highlighted vertical bar left (can also mouse click)
    
48. final char BAR_RIGHT  = '.'; //                               right
    
49. // * ----------------------------------------------
    
50. 
    
51. // * --------------- STARTING STATE ---------------
    
52. float zoom    = 1.0;
    
53. float scale   = 0.5;
    
54. int centerV   = 0;
    
55. int centerH   = 0;
    
56. int gridLines = 0;
    
57. int com_port  = 1;   // Index number in Serial.list
    
58. // * ----------------------------------------------
    
59. 
    
60. int val;                        // Data received from the serial port
    
61. long valTime;                   // Time data was received
    
62. int[] values;
    
63. long[] times;
    
64. float voltage;
    
65. float measTime = 0;
    
66. int   timeMode = 0;
    
67. int[] timeBars = {0, 0};
    
68. PFont f;
    
69. boolean pause;
    
70. 
    
71. /*****************************************************
    
72. Host software for HID-class USB serial communication.
    
73. It allows connecting to a HID serial device (16c0:05df),
    
74. sending (up to 32 bytes per packet) and receiving
    
75. strings from the device. The code uses a slightly modified
    
76. version of the g4p library for user interface, and the
    
77. HIDAPI library for handling HID requests.
    
78. 
    
79. The code was initially written by Chaniel Chadowitz
    
80. and modified by Ray Wang (Rayshobby LLC). The code is published
    
81. under Creative Commons Attribution-ShareAlike 3.0 license.
    
82. *************************************************************/
    
83. import g4p_controls.*;
    
84. import com.codeminders.hidapi.HIDDeviceInfo;
    
85. import com.codeminders.hidapi.HIDManager;
    
86. import com.codeminders.hidapi.HIDDevice;
    
87. import java.io.IOException;
    
88. import java.util.List;
    
89. import java.util.ArrayList;
    
90. import java.util.LinkedList;
    
91. import java.awt.Font;
    
92. 
    
93. GButton connectButton;
    
94. 
    
95. boolean paused;
    
96. String serialText = new String();
    
97. 
    
98. int VENDOR_ID = 0x16c0;
    
99. int PRODUCT_ID = 0x05df;
    
100. HIDDevice device = null;
     
101. Boolean device_initialized = false;
     
102. byte value1 = 0;
     
103. int value = 0;
     
104. 
     
105. // Setup
     
106. void setup() {
     
107.   size(1280, 480);
     
108.   G4P.setGlobalColorScheme(5);  
     
109. 
     
110.   connectButton = new GButton(this, 10, 15, 100, 20, "Connect");
     
111.   connectButton.setTextBold();
     
112. 
     
113.   device_initialized = false;
     
114.   values = new int[width];
     
115.   times = new long[width];
     
116.   timeBars[0] = width/3;
     
117.   timeBars[1] = 2*width/3;
     
118.   pause = false;
     
119.   smooth();
     
120.   f = createFont("Arial", 16, true);
     
121. }
     
122. 
     
123. 
     
124. // Get a y-value for the datapoint, varies based on axis settings
     
125. int getY(int val) {
     
126.   return (int)(height/2 -(val-512+centerV)*scale / 1023.0f * (height - 1));
     
127. }
     
128. 
     
129. // Push the values in the data array
     
130. void pushValue(int value) {
     
131.   for (int i=0; i<width-1; i++)
     
132.     values[i] = values[i+1];
     
133.   values[width-1] = value;
     
134. }
     
135. 
     
136. // Push the timestamps in the time array
     
137. void pushTime(long time) {
     
138.   for (int i=0; i<width-1; i++)
     
139.     times[i] = times[i+1];
     
140.   times[width-1] = time;
     
141. }
     
142. 
     
143. // Draw waveform
     
144. void drawLines() {
     
145.   int x0 = 0, x1 = 0, y0 = 0, y1 = 0;
     
146.   stroke(255, 255, 0);
     
147.   for (int i=0; i<width; i++) {
     
148.     x1 = round(width - ((width-i) * zoom) + centerH);
     
149.     y1 = getY(values[i]*4);
     
150.     if (i > 1)
     
151.       line(x0, y0, x1, y1);
     
152.     x0 = x1;
     
153.     y0 = y1;
     
154.   }
     
155. }
     
156. 
     
157. // Draw gridlines (bounds, minor)
     
158. void drawGrid() {
     
159.   // Get scaled values for bounds
     
160.   int pFive = getY(1023);
     
161.   int zero  = getY(0);
     
162. 
     
163.   // Draw voltage bounds
     
164.   stroke(255, 0, 0);
     
165.   line(0, pFive-1, width, pFive-1);
     
166.   line(0, zero+1, width, zero+1);
     
167. 
     
168.   // Add voltage bound text
     
169.   textFont(f, 10);
     
170.   fill(255, 0, 0);
     
171.   text("+5V", 5, pFive+12);
     
172.   text(" 0V", 5, zero-4);
     
173. 
     
174.   // Draw minor grid lines
     
175.   int gridVal = 0;
     
176.   stroke(75, 75, 75);
     
177.   for (int i = 0; i < gridLines; i++) {
     
178.     gridVal = getY(round((i+1.0)*(1023.0 / (gridLines+1.0))));
     
179.     line(0, gridVal, width, gridVal);
     
180.   }
     
181. 
     
182.   // Add minor grid line text
     
183.   if (gridLines > 0) {
     
184.     textFont(f, 16);
     
185.     fill(204, 102, 0);
     
186.     float scaleVal = truncate(5.0f / (gridLines+1), 3);
     
187.     text("Grid: " + scaleVal + "V", 1170, height-12);
     
188.   }
     
189. 
     
190.   // Print difference between vertical 'time' bars
     
191.   if (timeMode > 0) {
     
192.     textFont(f, 16);
     
193.     fill(204, 102, 0);
     
194. 
     
195.     int idx0 = round(width + (timeBars[0] - width - centerH)/zoom);
     
196.     int idx1 = round(width + (timeBars[1] - width - centerH)/zoom);
     
197. 
     
198.     // Ensure time bars are over a recorded portion of the waveform
     
199.     if (idx1 < 0 || idx0 < 0 || idx1 > (width-1) || idx0 > (width-1) || times[idx1] == 0 || times[idx0] == 0)
     
200.       text("Time: N/A", 30, height-12);
     
201.     else {
     
202.       float timeDiff = truncate((times[idx1] - times[idx0])/2000000.0, 2);
     
203.       text("Time: " + timeDiff + "ms", 30, height-12);
     
204.     }
     
205.   }
     
206. }
     
207. 
     
208. // Draw vertical 'time bars' (seperate from above for better layering)
     
209. void drawVertLines() {
     
210.   stroke(75, 75, 75);
     
211.   if (timeMode == 1) {
     
212.     line(timeBars[1], 0, timeBars[1], height);
     
213.     stroke(100, 100, 255);
     
214.     line(timeBars[0], 0, timeBars[0], height);
     
215.   } else if (timeMode == 2) {
     
216.     line(timeBars[0], 0, timeBars[0], height);
     
217.     stroke(100, 255, 100);
     
218.     line(timeBars[1], 0, timeBars[1], height);
     
219.   }
     
220. }
     
221. 
     
222. // Truncate a floating point number
     
223. float truncate(float x, int digits) {
     
224.   float temp = pow(10.0, digits);
     
225.   return round( x * temp ) / temp;
     
226. }
     
227. 
     
228. 
     
229. // When a key is pressed down or held...
     
230. void keyPressed() {
     
231.   switch (key) {
     
232.   case T_UP:
     
233.     centerV += 10/scale;
     
234.     break;                     // Move waveform up
     
235.   case T_DOWN:
     
236.     centerV -= 10/scale;
     
237.     break;                   // Move waveform down
     
238.   case T_RIGHT:
     
239.     centerH += 10/scale;
     
240.     break;                  // Move waveform right
     
241.   case T_LEFT:
     
242.     centerH -= 10/scale;
     
243.     break;                   // Move waveform left
     
244.   case MGL_UP:                                               // Increase minor grid lines
     
245.     if (gridLines < 49)
     
246.       gridLines += 1;
     
247.     break;
     
248.   case MGL_DOWN:                                             // Decrease minor grid lines
     
249.     if (gridLines > 0)
     
250.       gridLines -= 1;
     
251.     break;
     
252.   case BAR_LEFT:                                             // Move the time bar left (also mouse click)
     
253.     if (timeMode == 1 && timeBars[0] > 0)
     
254.       timeBars[0] -= 1;
     
255.     else if (timeMode == 2 && timeBars[1] > 0)
     
256.       timeBars[1] -= 1;
     
257.     break;
     
258.   case BAR_RIGHT:                                            // Move the time bar right (also mouse click)
     
259.     if (timeMode == 1 && timeBars[0] < width-1)
     
260.       timeBars[0] += 1;
     
261.     else if (timeMode == 2 && timeBars[1] < width-1)
     
262.       timeBars[1] += 1;
     
263.     break;
     
264.   }
     
265. }
     
266. 
     
267. // When a key is released...
     
268. void keyReleased() {
     
269.   println(key+": "+(int)key);
     
270.   switch (key) {
     
271.   case Z_IN:                                                 // Zoom horizontal
     
272.     zoom *= 2.0f;
     
273.     if ( (int) (width / zoom) <= 1 )
     
274.       zoom /= 2.0f;
     
275.     break;
     
276.   case Z_OUT:                                                // Zoom horizontal
     
277.     zoom /= 2.0f;
     
278.     if (zoom < 1.0f)
     
279.       zoom *= 2.0f;
     
280.     break;
     
281.   case S_IN:
     
282.     scale*=2;
     
283.     break;                                // Scale vertical
     
284.   case S_OUT:
     
285.     scale /= 2;
     
286.     break;                             // Scale vertical
     
287.   case RESET_AXIS:                                           // Reset all scaling
     
288.     centerV = 0;
     
289.     centerH = 0;
     
290.     scale = 0.5;
     
291.     zoom  = 1;
     
292.     gridLines = 0;
     
293.     break;
     
294.   case MEAS_TIME:
     
295.     timeMode = (timeMode + 1) % 3;
     
296.     break;      // Change the vertical bars (off, left bar, right bar)
     
297.   case TOG_PAUSE:                                            // Toggle waveform pausing
     
298.     if (pause) {
     
299.       centerH = 0;
     
300.       for (int i=0; i<width; i++) {
     
301.         values[i] = 0;                                       // Clear data on resume
     
302.         times[i] = 0;
     
303.       }
     
304.     }
     
305.     pause = !pause;
     
306.   }
     
307. }
     
308. 
     
309. // Use mouse clicks to quickly move vertical bars (if highlighted)
     
310. void mousePressed() {
     
311.   if (timeMode == 1)
     
312.     timeBars[0] = mouseX;
     
313.   else if (timeMode == 2)
     
314.     timeBars[1] = mouseX;
     
315. }
     
316. 
     
317. 
     
318. // Primary drawing function
     
319. void draw() {
     
320.   background(0);
     
321. 
     
322.   if ( device != null && !paused ) {
     
323.     deviceRead();
     
324.   }
     
325. 
     
326.   drawGrid();
     
327.   // Get current voltage, time of reading
     
328.   val = value;
     
329. 
     
330.   //  valTime = System.nanoTime();
     
331. 
     
332.   // If not paused
     
333.   if (!pause && val != -1) {
     
334.     // Push value/time onto array
     
335.     pushValue(val);
     
336.     pushTime(valTime);
     
337. 
     
338.     // Print current voltage reading
     
339.     textFont(f, 16);
     
340.     fill(204, 102, 0);
     
341.     voltage = truncate(3.3*val / 256, 2);
     
342.     text("Voltage: " + voltage + "V", 1170, 30);
     
343.   }
     
344.   drawLines();
     
345.   drawVertLines();
     
346. }
     
347. 
     
348. public void deviceInitialize() {
     
349.   if (!device_initialized) {
     
350.     device_initialized = true;
     
351.     com.codeminders.hidapi.ClassPathLibraryLoader
     
352.       .loadNativeHIDLibrary();
     
353.   }
     
354. }
     
355. 
     
356. public void deviceFindFirst() {
     
357.   deviceInitialize();
     
358.   HIDDeviceInfo[] infos = deviceFindAllDescriptors();
     
359. 
     
360.   if (infos.length > 0) {
     
361.     try {
     
362.       device = infos[0].open();
     
363.     }
     
364.     catch (Exception e) {
     
365.       device = null;
     
366.     }
     
367.   }
     
368. }
     
369. 
     
370. public HIDDeviceInfo[] deviceFindAllDescriptors() {
     
371.   deviceInitialize();
     
372. 
     
373.   List<HIDDeviceInfo> devlist = new ArrayList<HIDDeviceInfo>();
     
374. 
     
375.   try {
     
376.     HIDManager hidManager = HIDManager.getInstance();
     
377. 
     
378.     HIDDeviceInfo[] infos = hidManager.listDevices();
     
379. 
     
380.     for (HIDDeviceInfo info : infos) {
     
381.       if (info.getVendor_id() == VENDOR_ID
     
382.         && info.getProduct_id() == PRODUCT_ID) {
     
383.         devlist.add(info);
     
384.       }
     
385.     }
     
386.   }
     
387.   catch (Exception e) {
     
388.   }
     
389. 
     
390.   return devlist.toArray(new HIDDeviceInfo[devlist.size()]);
     
391. }
     
392. 
     
393. public void deviceRead() {
     
394.   try {
     
395.     device.disableBlocking();
     
396.     byte[] data = new byte[10];
     
397.     int read = device.read(data);
     
398.     if (read > 0) {
     
399.       for (int i=0; i<read; i++) {
     
400.         if (data[i]!=0) {
     
401.           value1 = data[i];
     
402.           //convert signed byte to unsigned byte
     
403.           if (value1 >=0)
     
404.           {
     
405.             value = value1;
     
406.           } else {
     
407.             value = int (value1 + 255);
     
408.           }
     
409.         }
     
410.       }
     
411.     }
     
412.   }
     
413.   catch(IOException ioe) {
     
414.     //ioe.printStackTrace();
     
415.     System.out.println("deviceRead error");
     
416.   }
     
417. }
     
418. 
     
419. public void handleButtonEvents(GButton button, GEvent event) {
     
420.   if ( event == GEvent.CLICKED ) {
     
421.     if ( button.equals(connectButton) ) {
     
422.       if (device!=null) {
     
423.         try {
     
424.           device.close();
     
425.         }
     
426.         catch (IOException ioe) {
     
427.           ioe.printStackTrace();
     
428.         }
     
429.         device = null;
     
430.         connectButton.setText("Connect");
     
431.         connectButton.setTextBold();
     
432.         value = 0;
     
433.       } else {
     
434.         deviceFindFirst();
     
435.         connectButton.setText("Disconnect");
     
436.         connectButton.setTextBold();
     
437.       }
     
438.     }
     
439.   }
     
440. }
     

复制代码

eddiewwm

以上的範例的實用性不大，但可作程序操練之用！

弘毅

有高清无码大图嘛

eddiewwm

效果確實差得不能見人！

在網上看同一些用聲卡的示波器程序，這兩款看來很好：
虚拟示波器 0.94(利用声卡虚拟示波器)绿色版
http://www.7edown.com/xiazai/1562.html


Soundcard Oscilloscope
https://www.zeitnitz.eu/scope_en

eddiewwm

按書本《玩轉Arduino電子制作 - 吳漢清 編著》P.227範例更改後的程序：

1. #include "U8glib.h"
   
2. 
   
3. // setup u8g object, please remove comment from one of the following constructor calls
   
4. // IMPORTANT NOTE: The following list is incomplete. The complete list of supported
   
5. // devices with all constructor calls is here: https://github.com/olikraus/u8glib/wiki/device
   
6. U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE | U8G_I2C_OPT_DEV_0); // I2C / TWI
   
7. //U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_DEV_0|U8G_I2C_OPT_NO_ACK|U8G_I2C_OPT_FAST); // Fast I2C / TWI
   
8. //U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NO_ACK);  // Display which does not send AC
   
9. 
   
10. int Input = A0;
    
11. int Key_add = 8;
    
12. int Key_sub = 9;
    
13. int Key_hold = 10;
    
14. int x, y;
    
15. int i, i1, i2, V_min, V_max, V_mid, t, t0, t1, sta, Key = 1, hold = 0;
    
16. long Freq;
    
17. float Vpp;
    
18. int Y[96];
    
19. int Buffer[192];
    
20. 
    
21. void sample() {
    
22.   for (i = 0; i < 192; i++) {
    
23.     Buffer[i] = ADCH;
    
24.     switch (Key) {
    
25.       case 1: delayMicroseconds(3); //__asm__("nop\n\t");  //0.02 ms/div
    
26.         break;
    
27.       case 2: delayMicroseconds(10);  //0.05 ms/div
    
28.         break;
    
29.       case 3: delayMicroseconds(21);  //0.1 ms/div
    
30.         //__asm__("nop\n\t");
    
31.         break;
    
32.       case 4: delayMicroseconds(43);  //0.2 ms/div
    
33.         break;
    
34.       case 5: delayMicroseconds(110);  //0.5 ms/div
    
35.         break;
    
36.       case 6: delayMicroseconds(222);  //1 ms/div
    
37.         break;
    
38.       case 7: delayMicroseconds(444);  //2 ms/div
    
39.         break;
    
40.       case 8: delayMicroseconds(1130);  //5 ms/div
    
41.         break;
    
42.       case 9: delayMicroseconds(2220);  //10 ms/div
    
43.         break;
    
44.       default: break;
    
45.     }
    
46.   }
    
47.   for (i = 0; i < 192; i++) {
    
48.     Serial.write(Buffer[i]);
    
49.   }
    
50. }
    
51. 
    
52. void Measure() {
    
53.   V_max = Buffer[0];
    
54.   V_min = Buffer[0];
    
55.   for (i = 0; i < 192; i++) {
    
56.     if (Buffer[i] > V_max)   V_max = Buffer[i];
    
57.     if (Buffer[i] < V_min)   V_min = Buffer[i];
    
58.   }
    
59.   V_mid = (V_max + V_min) / 2;
    
60.   Vpp = (V_max - V_min) * 5.0 / 255;
    
61.   for (i = 0; i < 197; i++) {
    
62.     if (Buffer[i] < V_mid && Buffer[i + 1] >= V_mid) {
    
63.       i1 = i;
    
64.       break;
    
65.     }
    
66.   }
    
67.   for (i = i1 + 1; i < 98 + i1; i++) {
    
68.     if (Buffer[i] < V_mid && Buffer[i + 1] >= V_mid) {
    
69.       i2 = i;
    
70.       break;
    
71.     }
    
72.   }
    
73.   t = i2 - i1;
    
74.   if (t > 0) Freq = 8000 / t;
    
75.   else  Freq = 0;
    
76. }
    
77. 
    
78. void Transform() {
    
79.   for (sta = 0; sta < 96; sta++) {
    
80.     if (Buffer[sta] < 128 && Buffer[sta + 2] > 128)   break;
    
81.   }
    
82.   for (i = 0; i < 96; i++) {
    
83.     Y[i] = 63 - (Buffer[i + sta] >> 2);
    
84.   }
    
85. }
    
86. 
    
87. void draw() {
    
88.   for (x = 0; x < 95; x++)   u8g.drawLine(x, Y[x], x, Y[x + 1]);
    
89.   u8g.drawFrame(0, 0, 97, 64);
    
90.   u8g.drawLine(48, 0, 48, 63);
    
91.   u8g.drawLine(0, 32, 96, 32);
    
92.   for (x = 0; x < 96; x += 8)   u8g.drawLine(x, 31, x, 33);
    
93.   for (y = 0; y < 64; y += 8)   u8g.drawLine(47, y, 49, y);
    
94.   for (x = 8; x < 96; x += 8) {
    
95.     for (y = 8; y < 64; y += 8)   u8g.drawPixel(x, y);
    
96.   }
    
97.   u8g.drawStr(98, 7, "MS/div");
    
98.   u8g.drawStr(98, 23, "V/div");
    
99.   u8g.drawStr(98, 30, "0.625");
    
100.   u8g.drawStr(98, 40, "Vpp");
     
101.   u8g.setPrintPos(98, 47);
     
102.   u8g.print(Vpp);
     
103.   u8g.drawStr(118, 47, "V");
     
104.   u8g.drawStr(98, 55, "F(Hz)");
     
105.   switch (Key) {
     
106.     case 1:
     
107.       u8g.drawStr(98, 14, "0.02");
     
108.       u8g.setPrintPos(98, 62);
     
109.       u8g.print(Freq * 50);
     
110.       break;
     
111.     case 2:
     
112.       u8g.drawStr(98, 14, "0.05");
     
113.       u8g.setPrintPos(98, 62);
     
114.       u8g.print(Freq * 20);
     
115.       break;
     
116.     case 3:
     
117.       u8g.drawStr(98, 14, "0.1");
     
118.       u8g.setPrintPos(98, 62);
     
119.       u8g.print(Freq * 10);
     
120.       break;
     
121.     case 4:
     
122.       u8g.drawStr(98, 14, "0.2");
     
123.       u8g.setPrintPos(98, 62);
     
124.       u8g.print(Freq * 5);
     
125.       break;
     
126.     case 5:
     
127.       u8g.drawStr(98, 14, "0.5");
     
128.       u8g.setPrintPos(98, 62);
     
129.       u8g.print(Freq * 2);
     
130.       break;
     
131.     case 6:
     
132.       u8g.drawStr(98, 14, "1");
     
133.       u8g.setPrintPos(98, 62);
     
134.       u8g.print(Freq);
     
135.       break;
     
136.     case 7:
     
137.       u8g.drawStr(98, 14, "2");
     
138.       u8g.setPrintPos(98, 62);
     
139.       u8g.print(Freq / 2);
     
140.       break;
     
141.     case 8:
     
142.       u8g.drawStr(98, 14, "5");
     
143.       u8g.setPrintPos(98, 62);
     
144.       u8g.print(Freq / 5);
     
145.       break;
     
146.     case 9:
     
147.       u8g.drawStr(98, 14, "10");
     
148.       u8g.setPrintPos(98, 62);
     
149.       u8g.print(Freq / 10);
     
150.       break;
     
151.     default: break;
     
152.   }
     
153. }
     
154. 
     
155. void Key_scan() {
     
156.   if (digitalRead(Key_add) == LOW) {
     
157.     while (digitalRead(Key_add) == LOW);
     
158.     Key ++;
     
159.     if (Key == 10)  Key = 9;
     
160.     delay(10);
     
161.   }
     
162. 
     
163.   if (digitalRead(Key_sub) == LOW) {
     
164.     while (digitalRead(Key_sub) == LOW);
     
165.     Key --;
     
166.     if (Key == 0)  Key = 1;
     
167.     delay(10);
     
168.   }
     
169. 
     
170.   if (digitalRead(Key_hold) == LOW) {
     
171.     while (digitalRead(Key_hold) == LOW);
     
172.     hold == ~ hold;
     
173.     delay(10);
     
174.   }
     
175. }
     
176. 
     
177. void setup() {
     
178.   //for 32MHz clock only
     
179.   sysClock(INT_OSC); //use internal 32MHz RC clock
     
180.   CLKPR = 0x80;
     
181.   CLKPR = 0x00;   //Divider=1, =>32MHz/1 = 32MHz
     
182.   //
     
183.   pinMode(Key_add, INPUT_PULLUP);
     
184.   pinMode(Key_sub, INPUT_PULLUP);
     
185.   pinMode(Key_hold, INPUT_PULLUP);
     
186.   ADMUX = 0x60; // use Vcc reference, 8-bit left align
     
187.   //ADMUX = 0xa0; // use 2.048V reference, 8-bit left align
     
188.   //ADMUX = 0xe0; // use 1.024V reference, 8-bit left align
     
189.   Serial.begin(115200);
     
190. 
     
191.   ADCSRA = 0xe2;
     
192.   u8g.setFont(u8g_font_5x7);
     
193. }
     
194. 
     
195. void loop() {
     
196.   sample();
     
197.   Measure();
     
198.   Transform();
     
199.   Key_scan();
     
200.   if (hold == 0) {
     
201.     u8g.firstPage();
     
202.     do {
     
203.       draw();
     
204.     }
     
205.     while ( u8g.nextPage());
     
206.   }
     
207. }

复制代码