Code Walkthrough

1. Library Setup
2. Adding Variables to the Watch List
3. Adding a Breakpoint
   1. Main Menu
      1. Hardware Pins
         1. Setting a Digital Pin’s State
      2. Variables
         1. Handling Arrays
4. Example Program

Library Setup

To use the Arduino Debugger library, you must:

1. Download the code’s zipped folder: link here
2. Install the zipped library via the Arduino IDE
3. Include the library at the top of your program

   #include <Debugger.h>
   

4. Create an Arduino debugger object:

//initialize method signature
static ArduinoDebugger initialize(bool usingFloat, bool isAvr, bool usingTerminal);

//Example configuration for Ardunio Uno
ArduinoDebugger debugger = Debugger::initialize(false, true, false);

After you have included the library and created your debugger, you’ll be set to add your variables to the watch list.

Adding Variables to the Watch List

The Arduino Debugger is able to display the current value of your program’s variables AND update their values, while the Arduino program is still running. But in order for the debugger to do that, you must first tell it which variables you are instead in “watching”. To do this, you will need to call the add() method:

  //add method signature
  void add(void* var_ptr, Type type, char var_name[]);
  
  //example call to the add method
  debugger.add(&var, TYPE, "var");

The add method requires three parameters:

Adding a Breakpoint

In order to debug your program, you’ll need to add in a breakpoint. The breakpoint will pause your Arduino program and allow you to check on the current state of your variables & hardware pins. To do this you’ll need to add a call to the breakpoint method:

  //breakpoint method signature
  void breakpoint(char name[]);
  
  //example call to the breakpoint method
  debugger.breakpoint("Identifier");

The breakpoint method has an optional parameter, char name[]. The name is used to identify each breakpoint. So if your program has mutliple breakpoints added, you’ll be able to tell which one you have stopped at.

Main Menu

Once the Arduino program reaches a breakpoint, you will see the debugger’s main menu, via the Arduino Serial Monitor. The menu will allow you to check on the microcontroller’s hardware pins (1) or the variables inside the watch list (2).

Hardware Pins

Selecting “Hardware Pins” will display the current state of your boards digital & analog pins. For digital pins, there are three potential states:

HIGH

This means the pin is ON and providing POWER OUT

LOW

This means the pin is OFF

HIGH(Power In)

This means the pin is receiving POWER IN from an external power source

The analog pins will be displayed next to their current analogRead() values. The resolution or range for these values is dependent on the microcontroller you are using. For example, the Arduino Uno has a potential value between 0 to 1023 and the Arduino Due has a potential value between of 0 - 4095.

Setting a Digital Pin’s State

Besides viewing the current state, you can update a digital pin to either HIGH or LOW. Please note, that you can only update a digital pin’s value. The library does not support modifying analog output (PWM). In the example below you can see digital pin 4 being updated from LOW to HIGH.

Variables

Selecting “Variables” will display the current value of each variable currently on the watch list.

long frequency = 253;
char selection = 'A';

debugger.add(&frequency, LONG, "frequency");
debugger.add(&selection, CHAR, "selection");

If the above variables had been added to the watch list, then the debugger would display the following:

You can update the value of any variable listed by entering it’s index in the watch list. For example, to update frequency you would enter 0

Handling Arrays

The debugger does allow for arrays to be displayed and updated. As noted in the “Adding Variables” section, you will need to format the variable name to denote the array’s size (number of elements).

byte pins[] = {0,1,2};
bool valid[] = {false, true};

debugger.add(&pins, BYTE_ARRAY, "pins_3"};
debugger.add(&valid, BOOL_ARRAY, "valid_2"};

If the above variables had been added to the watch list, then the debugger will display the following:

The debugger will display each value within the array. To update a specific value inside an array, you must first select the array variable. For example, to update valid[1] to false you would enter 1 (select the variable) and then enter 1 (to select the array index):

Example Program

Listed below is an example program using the Arduino Debugger. The program is intended to turn on a series of LEDS connected to an Arduino device, but there is an error located within the for loop that prevents all of the LEDs from turning on. By placing breakpoints within the FOR loop, one can see that the variable i is being incorrectly updated and also see that pins[1] & pins[3] (Digital Pins 4 & 6) are never set to HIGH. The example code should run on any Arduino Board, but you may have to update the pin numbers listed in the variable pins.

#include <Debugger.h>
//Standard debugger configuration for Arduino Uno.  If using an ARM processor, set to (false, false, false).
ArduinoDebugger debugger = Debugger::initialize(false, true, false);
void setup() {
  Serial.begin(9600);
  while(!Serial) {}
}
void loop() {
  byte pins[] = {3,4,5,6};//Pins connected to LEDs
  byte i = 0;//for loop counter 
  debugger.add(&i, BYTE, "i");//Add i to variable watch
  debugger.add(&pins, BYTE_ARRAY, "pins_4");//add pins to variable watch, Arrays require unique syntax
  debugger.breakpoint("Before For Loop");
  for(i; i < sizeof(pins)/sizeof(pins[0]); i++){
    debugger.breakpoint("Start For Loop");  
    digitalWrite(i, HIGH);//Turn on the chosen LED
    i++;//Error!
    debugger.breakpoint("End For Loop");
  }
}