Debug Output

Visual Studio supports an interesting and very powerful feature that permits you to insert print statements (and more!) in the code to help you debug your code. It is similar in some ways to the old school print statement trace (a log of statements written to a file), which are written as the code runs. However, in this case, the statements appear in the Output window of Visual Studio. To use the feature, add the following namespace to your code.

using System.Diagnostics;          // add this for debugging

You use the Debug class from this namespace to write out values so you can see them in the output window as you run the code in debug. The following code shows some examples of the methods you use to report data. Some are informational (the proverbial, “I’m here!”), while others show how you can print out the values of variables.

Debug.WriteLine("Sorry, the GPIO cannot be initialized. Drat.");
Debug.Write("Val read = ");
Debug.WriteLine(valRead);

Here I use two methods: Write(), which writes a string without a carriage return/line feed (CRLF) symbol (sometimes called a newline), and Writeline(), which writes the CRLF.

The output of this code is shown in the output window. The following shows an excerpt of the output from this project. It is to see the progress of the code. There is much more to this class, but this gives you a taste for what is possible with this alternative debugging technique.

...
GPIO ready.
Setting up GPIO pin 21.
Setting up GPIO pin 20.
Setting up GPIO pin 19.
Setting up GPIO pin 18.
Setting up GPIO pin 17.
Setting up the MCP3008.
...

You must compile your code in debug mode and run the debugger to see the output. If you compile in release mode, the debug code is ignored automatically and not included in the executable code (binary file).

New Project

You will use the same project template as the last project—the Blank App (Universal Windows) template. Use the name PowerMeter for the project name. You can save the project wherever you like or use the default location. Once the project opens, double-click the MainPage.xaml.cs file. This is where you put most of the code for the project. There are three namespaces you need to include. Go ahead and add those now, as shown next.

using Windows.Devices.Gpio;        // add this for GPIO pins
using System.Diagnostics;          // add this for debugging
using Windows.UI.Core;             // DispatcherTimer

Next, you need to add some variables and constants. You add constants for the number of LEDs and maximum potentiometer value (1023). You also add variables for the meter pin numbers and the GPIO pin variables. Finally, you add a variable for the timer.

 // Power meter pins, variables
private const int numLEDs = 5;
private const float maxPotVal = 1023;
private int[] METER_PINS = { 21, 20, 19, 18, 17 };
private GpioPin[] Meter = new GpioPin[numLEDs];

// Add a Dispatch Timer
private DispatcherTimer meterTimer;

Next, you’ll add a variable for the MCP3008 and instantiate an instance for the new class. In this case, you create a new class to encapsulate the code for the ADC. You’ll see this in a later section.

// Instantiate the new ADC Chip class
ADC_MCP3008 adc = new ADC_MCP3008();

Last, you’ll add a constant for the channel on the ADC that you will use. In this case, you use channel zero.

// Channel to read the potentiometer
private const int POT_CHANNEL = 0;

The code in the MainPage() function initializes the components, the GPIO, and the new ADC class. You also set up the timer. In this case, you use a value of 500, which is one-half a second. If you adjust this lower, the solution is a bit more responsive. You can try this once you’ve got it to work and tested. Listing 10-1 shows the complete MainPage() method.

Listing 10-1. MainPage Method

public MainPage()
{                                                                                                    
    this.InitializeComponent();  
    InitGPIO();                  // Initialize GPIO
    adc.Initialize();            // Call initialize() method for ADC

    // Setup the timer
    this.meterTimer = new DispatcherTimer();
    this.meterTimer.Interval = TimeSpan.FromMilliseconds(500);
    this.meterTimer.Tick += meterTimer_Tick;
    this.meterTimer.Start();
}                                                                                                    

Finally, you must add the reference to the Windows 10 IoT Extensions from the project property page. You do this by right clicking the References item on the project item in the Solution Explorer.

Initialize GPIO

As usual, you must provide the InitGPIO() method you called in the MainPage() method.⁴ Recall, you want to set up the GPIO controller and initialize the pins you are going to use. In this case, you must initialize the five LED pins and since you have them in an array, you can use a for loop to accomplish the task.

While you are at it, you’ll also use a few diagnostic statements to record whether the GPIO controller succeeds or not and the state of the pins. You can see these calls are made using the Debug.Write(), which does not write an end of line and Debug.Writeline(), which does write the end of line character. Listing 10-2 shows the completed InitGPIO() method.

Listing 10-2. Initialize GPIO Method

// Setup the GPIO initial states
private void InitGPIO()
{
    var gpio = GpioController.GetDefault();

    // Show an error if there is no GPIO controller
    if (gpio == null)
    {
        Debug.WriteLine("Sorry, the GPIO cannot be initialized. Drat.");
        return;
    }
    Debug.WriteLine("GPIO ready.");
    // Initialize the GPIO pins
    for (int i = 0; i < numLEDs; i++)
    {
        this.Meter[i] = gpio.OpenPin(METER_PINS[i]);
        this.Meter[i].SetDriveMode(GpioPinDriveMode.Output);
        this.Meter[i].Write(GpioPinValue.Low);
        Debug.Write("Setting up GPIO pin ");
        Debug.Write(METER_PINS[i]);
        Debug.WriteLine(".");
    }
}                                                                              

Controlling the LEDs

Next, you need code to control the LEDs. You’re using the timer class to fire an event every 500 milliseconds (one half of a second). In the MainPage() method, you assigned the name meterTimer_Tick() to the event. In this method, you must read the value from the potentiometer via the new ADC class (explanation is in the next section), and then calculate how many LEDs to turn on.

Since you are using five LEDs, you convert the value read from the potentiometer as a percentage, and then convert it to a scale from 0–5. You do this so you can use two loops: one to turn on those LEDs that should be on and another to turn the remainder off. Check the code to ensure that you understand how this works. You also see a copious amount of Debug.Write* methods to display the state of this method. Listing 10-3 shows the complete code for the meterTimer_Tick() method .

Listing 10-3. Controlling the LEDs

private void meterTimer_Tick(object sender, object e)
{
    float valRead = 0;
    int numLEDs_On = 0;

    Debug.WriteLine("Timer has fired the meterTimer_Tick() method.");

    // Read value from the ADC
    valRead = adc.getValue(POT_CHANNEL);
    Debug.Write("Val read = ");
    Debug.WriteLine(valRead);

    float percentCalc = (valRead / maxPotVal) * (float)10.0;
    numLEDs_On = (int)percentCalc / 2;
    Debug.Write("Number of LEDs to turn on = ");
    Debug.WriteLine(numLEDs_On);

    // Adjust power meter LEDs On or Off based on value read
    for (int i = 0; i < numLEDs_On; i++)
    {
        this.Meter[i].Write(GpioPinValue.High);
        Debug.Write("Setting pin ");
        Debug.Write(METER_PINS[i]);
        Debug.WriteLine(" HIGH.");
    }
    for (int i = numLEDs_On; i < numLEDs; i++)
    {
        this.Meter[i].Write(GpioPinValue.Low);
        Debug.Write("Setting pin ");
        Debug.Write(METER_PINS[i]);
        Debug.WriteLine(" LOW.");
    }
}

Now that you’ve seen all the code for the main code file, let’s look at how the methods are placed in the class. Listing 10-4 shows the skeleton of the MainPage class. Use this as a guide to place the code in the right places. I omit the details of the methods for brevity.

Listing 10-4. MainPage Code Layout

...

namespace PowerMeter
{
    public sealed partial class MainPage : Page
    {
...
        public MainPage()
        {
...
        }

        // Setup the GPIO initial states
        private void InitGPIO()
        {
...
        }

        private void meterTimer_Tick(object sender, object e)
        {
...
        }
    }
}

In the next section, you learn how to write the code to communicate with the ADC chip.

Code for the MCP3008

While you can write the code in this section in the project class MainPage, you’ll discover an example of making your code easier to maintain using a class module to group the code for the ADC. You’ve already seen a couple of references to this in the previous code, including the constructor (ADC_MCP3008 adc = new ADC_MCP3008();), initialization (adc.Initialize();), and reading a value on a channel (valRead = adc.getValue(POT_CHANNEL);). Thus, you will need these functions, at the minimum.

This class is pretty simple in scope but for larger classes and the objects they model, you want to create a design for the class. That is, you should consider everything the class needs to do to model the object or concept.

To add a new class, right-click the project and choose Add ä New Item.... Name the class ADC_MCP3008, as shown in Figure 10-4.

Figure 10-4. Adding a new class

When you create a class, you create a new file, as shown in Figure 10-4. Inside this new code file, you see a familiar skeleton. Of note is the same namespace as the main code and a list of namespaces that you will use. Open the file now and add the following namespaces. The need for each is shown in the comments.

using Windows.Devices.Spi;         // add this for SPI communication
using System.Diagnostics;          // add this for debugging
using Windows.Devices.Enumeration; // add this for DeviceInformation

Next, you need some variables and constants. You need a variable for the SPI device and constants for the MCP3008. In this case, you set constants for helping you read data as you shall see later in this section.

// SPI controller interface
private SpiDevice mcp_var;
const int SPI_CHIP_SELECT_LINE = 0;  
const byte MCP3008_SingleEnded = 0x08;
const byte MCP3008_Differential = 0x00;

Next, you create the constructor method. You don’t need to do anything here so you’ll use a debug statement to indicate the class has been instantiated as follows .

public ADC_MCP3008()
{
    Debug.WriteLine("New class instance of ADC_MCP3008 created.");
}

Now that the preliminaries are set up, you can concentrate on the Initialize() and getValue() methods. The Initialize() method is used to set up the SPI interface for communicating with the ADC. I provide all the code that you need, but it is good to know what is going on. Listing 10-5 shows the Initialize() method .

Listing 10-5. Initializing the SPI Interface

// Setup the MCP3008 chip
public async void Initialize()
{
    Debug.WriteLine("Setting up the MCP3008.");
    try
    {
        // Settings for the SPI bus
        var SPI_settings = new SpiConnectionSettings(SPI_CHIP_SELECT_LINE);
        SPI_settings.ClockFrequency = 3600000;
        SPI_settings.Mode = SpiMode.Mode0;

        // Get the list of devices on the SPI bus and get a device instance
        string strDev = SpiDevice.GetDeviceSelector();
        var spidev = await DeviceInformation.FindAllAsync(strDev);

        // Create an SpiDevice with our bus controller and SPI settings          
        mcp_var = await SpiDevice.FromIdAsync(spidev[0].Id, SPI_settings);

        if (mcp_var == null)
        {
            Debug.WriteLine("ERROR! SPI device {0} may be in used.", spidev[0].Id);
            return;
        }

    }
    catch (Exception e)
    {
        Debug.WriteLine("EXEPTION CAUGHT: " + e.Message + "
" + e.StackTrace);
        throw;
    }
}                                                                                                    

First, you set some variables of the SPI device class, including the line you will use (chip select = 0), the clock frequency (3.6 MHz) or 3.6 million times a second, and the mode (0), which is the default. Mode defines how the values are sampled.⁵ Next, you get the device name (string) and then call a system method named await() that spawns a thread to wait for the chip’s SPI interface to wake and set up. You do this because the SPI device is actually running on a separate thread.

You place all of this code in a try block in case the SPI bus fails (say if you misconnect one or more wires) using debug statements to track the progress and report success or failure. Don’t worry too much if this code seems very strange. I should note that this may not be the only way to set up an SPI communication, but it is compact and captures a failed initialization.

Now you’re ready to learn how to get data from the ADC. While the last method was a bit complex, reading a value is a bit more complex. Recall that you must write before you can read. In this case, you send an array of three bytes and you get back an array of three bytes, where the first byte sets the start bit, the second byte contains the command (shifted 4 bits to the left) and the channel select, and the third byte doesn’t matter.

How did I discover this information? I read the data sheet! While it takes a bit of patience because many data sheets are written in a style known as “by engineers for engineers,” which means that they can be a bit terse and not very easy to read. However, in this case you see a very good explanation of the data needed for reading and writing data. Figure 10-5 shows an excerpt from the data sheet.

Figure 10-5. Communicating with the MCP_3008

I highlight the relevant portion for sending data to the chip in a solid box and the portion for receiving data in the dashed box. Here you see that the second byte for sending data holds the information for the single ended command and the command (0x8) shifted to the upper 4 bits (the order of bytes in memory is called endianness ⁶).

Notice the data you get back from the chip. Here you see you get 10 bits followed by a 0 (null) that are returned in the third and part of the second byte. Thus, you need to write code to capture the 10 bits in the second and third byte, and then mask out the bits starting with the null bit. Since the bits in the second byte are the higher bits, you need to mask out the bits that you don’t need, and then shift them so that you can interpret the two bytes as an integer (a common trick when working with byte streams). Listing 10-6 shows the completed getValue() method .

Listing 10-6. Reading Data from the ADC

// Communicate with the chip via the SPI bus. You must encode the command
// as follows so that you can read the value returned (on byte boundaries).
public int getValue(byte whichChannel)
{
    byte command = whichChannel;
    command |= MCP3008_SingleEnded;
    command <<= 4;

    byte[] commandBuf = new byte[] { 0x01, command, 0x00 };
    byte[] readBuf = new byte[] { 0x00, 0x00, 0x00 };

    mcp_var.TransferFullDuplex(commandBuf, readBuf);

    int sample = readBuf[2] + ((readBuf[1] & 0x03) << 8);
    int s2 = sample & 0x3FF;
    return sample;
}

The first thing you may notice is the method takes the channel number as a parameter. This allows you to use the method to read other channels and indeed you do so in the next project.

Notice also how you perform the byte manipulations to set up the command, transmit it with the TransferFullDuplex() method , which returns three bytes to the read buffer. You then shift bytes and mask out the parts that you don’t need, and then shift the remaining bytes so that you can read the value as an integer.

Once again, don’t worry too much if this code seems overly complex. You can find out more about the chip from the data sheet at https://cdn-shop.adafruit.com/datasheets/MCP3008.pdf .

Now that you’ve seen the individual methods of this class, let’s see how they are placed in context in the class. Listing 10-7 shows the skeleton for the ADC_MCP3008 class. I omit the details of the methods for brevity.

Listing 10-7. ADC_MCP3008 Class Layout

...

namespace PowerMeter
{
    class ADC_MCP3008
    {
...
        public ADC_MCP3008()
        {
            Debug.WriteLine("New class instance of ADC_MCP3008 created.");
        }

        public async void Initialize()
        {
...
        }

        public int getValue(byte whichChannel)
        {
...
        }
    }
}

OK, the code is ready for compilation! Be sure to check the earlier listings to ensure that you have all the code in the right place. Once you have entered all the code, you should now attempt to compile the code. Correct any errors that you find until the code compiles without errors or warnings .