Virtual Oscilloscope using PIC Microcontroller

private void button2_Click(object sender, System.EventArgs e)
{
Console.WriteLine("Start");
for (int i = 0; i < 10; i++)
{
// light the LED for a 1/2 second
this.axGP3IO1.led = true;
this.axGP3IO1.pwm(1, 128, 500);
// turn off the LED for a 1/2 second
this.axGP3IO1.led = false;
this.axGP3IO1.pwm(1, 128, 500);
}
Console.WriteLine("Stop");
}

I suppose I should have stopped there with the challenge of controlling hardware. After all, here I am a software programmer trying to control hardware and somehow this act goes against the laws of physics. Nevertheless, I became curious about looking at some of the signals produced by the PIC, so I decided to try to create a virtual oscilloscope on the pc that takes advantage of the A/D Converter Channels on the PIC itself. I figured, I can use these channels on the PIC to measure the signals outputted from the PIC.

private void RefreshScope (Graphics g)
{
int xmax = 450; // number of sample points
int ymax = 225; // maximum y value
int xlast = -1;
int ylast = 0;
int xDraw = 0;
int yDraw = 0;
// put the a/d readings into repeat mode for 450 readings
axGP3IO1.repeat(xmax + 1);
int n = 0;
// read the values on channel #0 of the A/D converter
n = axGP3IO1.a2d(0);
// read each value from the buffer and plot the sample on the scope
for (int xpos = 0; xpos <xmax; xpos++)
{
// if the storage scope is set, use the values in the storage array to plot the voltage
if (StorageOn)
n = StorageArray[xpos];
else // otherwise just save the a/d values in the storage array for later
StorageArray[xpos] = n;
// n between 0 and 1023
System.Single y = 0;
System.Single volt = 0;
int yint = 0;
// normalize the voltage reading
y = (float)n/ 1024.0f;
if (n > 64000)
y = 0;
// scale the voltage reading to 5 volts
y = y * 5.0f;
// scale the voltage according to the voltage scale control
yint = (int)((float)y/(float)numericUpDown1.Value);
// offset the voltage based on the y position dial
if (this.volumeControl1.Volume < 5)
yint += (this.volumeControl1.Volume % 5);
else
yint -= (this.volumeControl1.Volume % 5);
// place the y reading into the correct coordinate system
// by subtracting from the maximum value
yint = ymax - yint * ymax/5;
yDraw = yint;
// don't draw the first sample point, use it as
// a starting sample point
if (xlast != -1)
{
// scale the x-value based on the TimeScale control
// translate the x-position by the x-position congrol
xDraw = xpos * (int)this.TimeScaleControl.Value + this.XPositionControl.Volume * 5;
// Draw the scaled sample point by connecting
// the previous scaled sample point to the current
// scaled sample point
if (xDraw < kScopeWidth)
g.DrawLine(Pens.LawnGreen, xlast, ylast, xDraw, yint);
}
// remember the current sample point to allow for connecting
// the next sample point
xlast = xDraw;
ylast = yDraw;
// read the next a/d value from the buffer
if (xpos != xmax)
{
n = axGP3IO1.readword();
}
}
}

PWM Signal

private void button4_Click(object sender, System.EventArgs e)
{
// set up the continous pwm wave at 50% duty cycle, 5 KHz
this.axGP3IO1.pwm(-1, 128, 5000);
}

Scope Sampling Rate

A PWM wave of 5000hz produces a wave with period 1/5000 = .0002 seconds or 200 ms. If we look at figure 1 at the beginning of this article, we see that a wave has a full cycle after about 3 horizontal units. That means each unit is about 200 ms / 3 or 70 ms. It appears from the diagram that the scope is capable of sampling at least every 70 ms in repeat sampling mode. (That is, if we are not aliasing and missing samples). The wave below in figure 3 is a measurement of the pwm wave set at 100 Hz. As you can see, the samples are more clearly visible at the lower sampling rate. It is more likely that we are actually sampling at a rate closer to this frequency (a sample every 1 millesecond)

if (nToggleColor % 2 == 0)
g.DrawLine(Pens.LawnGreen, xlast, ylast, xDraw, yint);
else
g.DrawLine(Pens.Red, xlast, ylast, xDraw, yint);
nToggleColor++;

This produces the 100Hz PWM signal graph shown below in figure 4. We can calculate from the now distinct samples how quickly we are sampling data. There are approximately 14 samples in 1 full 100 Hz cycle or a period of 1/100 = 10 ms. If we divide the 14 samples into 10 milliseconds, we get a sampling rate of 1 sample every .71 ms or 710 ms (which is a magnitude of 10 greater than we originally predicted).