Step 1: Writing the setup() Function

After starting MPIDE, you'll begin this project by creating the setup() function. The setup() function doesn't return anything, so its return type is void. Also, the setup() function has no inputs, so nothing should go between the parentheses that follow the function's name. Thus, a template for the setup() function in which the body is empty is simply:

        
                  void setup()
                  {
                    // Body of function goes here.
                  }
                

Within the setup() function, you will use the function pinMode() to tell the board that you wish to use a pin in a certain way. This function takes two input parameters, called arguments, corresponding to a pin (we must specify the pin number) and the mode for that pin. The mode is either INPUT or OUTPUT. When set to INPUT, we can “read” signals from the pin. Conversely, when the mode is set to OUTPUT, we can “write” to the pin. Keep in mind that the only output we can write is HIGH or LOW. When we write one of these values (using a function we'll describe below), that establishes the pin's state. If we write HIGH, the pin will be maintained at a “high” voltage of 3.3V. On the other hand, if we write LOW, the pin will be maintained at a “low” voltage of 0V. These voltages are maintained until a different value is written to the pin.

On the chipKIT boards, one of the on-board LEDs is tied to pin 13. When pin 13 is HIGH, this LED is illuminated. When pin 13 is LOW, this LED is off. We want to configure pin 13 for OUTPUT so that you can effectively “write” to the LED. Thus, we must have the following statement in the body of the setup() function:

				  pinMode(13, OUTPUT);
                

Within MPIDE, OUTPUT and INPUT are constants. Hidden from us is the fact that they have numerical values that cannot be changed while the program is running. Instead of using these named constants, we could use the underlying numerical values directly in our program. However, by using these named constants, the code is more descriptive, i.e., more readable and self-documenting. The use of named constants in this way is considered good programming style.

Note that we are using the numeric value 13 in our program and it might be difficult for a person reading this code to know what this particular number represents or means. In the Blink External LED project we demonstrate how we can provide our own names for numeric values.

Combining the pinMode() statement with the template of the setup() function, the complete function is as follows:

        
                  void setup()
                  {
                    pinMode(13, OUTPUT);
                  }
                

Be sure you have entered this function into MPIDE as it appears here. However, you are, of course, free to add comments as you see fit. Furthermore, since the amount of whitespace that is included in a sketch does not affect what it ultimately does, you could include or exclude blank spaces. Nevertheless, it is considered good programming style to indent the body of a function, as shown in line 3.

You may have noticed that the sketch we are writing is slightly different from the Blink sketch provided as an example with MPIDE. The example sketch uses a predefined label, i.e., a named constant (PIN_LED1), for the pin associated with the LED. Although we don't rely on that definition here, it is a good idea for you to be familiar with the way that named constants are created. This is accomplished with a preprocessor directive, specifically a #define statement.

Step 2: Writing the loop() Function

Now that you've finished writing the setup() function, you can focus on creating the loop() function that the board will run repeatedly (after first running the setup() function once). To make the LED blink, you will need two more functions. The first is digitalWrite() and the second is delay(). The digitalWrite() function requires two arguments. The first argument is the pin to which you're writing, and the second argument is the pin's state, which is either HIGH or LOW. Thus, the function call that sets pin 13 to HIGH should look like this:

                  digitalWrite(13, HIGH);
                

Similarly, to set pin 13 to LOW, it should look like this:

        
                  digitalWrite(13, LOW);
                

The delay() function has only a single argument, which specifies the amount of delay in milliseconds. By “delay” we mean the board simply does nothing for the specified amount of time. There are one thousand milliseconds in one second. Thus, to obtain a delay of one second, you would write:

                  delay(1000);
                

We can now combine these functions in the body of the loop() function such that the LED attached to pin 13 blinks at a two-second interval (i.e., it is on for one second, then off for one second):

        
                  void loop()
                  {
                    digitalWrite(13, HIGH); // Turn on the LED.
                    delay(1000);            // LED remains on for 1 second.
                    digitalWrite(13, LOW);  // Turn off the LED.
                    delay(1000);            // LED remains off for 1 second.
                  }
                

Step 3: Putting it all Together

At this point we have all the code necessary to obtain a blinking LED. The following is the complete sketch that is now ready to be uploaded to your chipKIT board:

                  void setup()
                  {
                    // Set pin 13, the LED, to OUTPUT.
                    pinMode(13, OUTPUT);
                  }
                  
                  void loop()
                  {
                    digitalWrite(13, HIGH); // Turn on the LED.
                    delay(1000);            // LED remains on for 1 second.
                    digitalWrite(13, LOW);  // Turn off the LED.
                    delay(1000);            // LED remains off for 1 second.
                  }
                

If you need a refresher on how to upload your sketch to the board, see the Introduction to MPIDE project.