Getting Started with chipKIT

The Arduino Compatible PIC32 Based Module

by Chuck Hellebuyck

Published by Electronic Products.

Copyright 2011, Electronic Products (USA).
All rights reserved.

This is a special sample version of the book Getting Started with

chipKIT by Chuck Hellebuyck. This is freely distributed to help
users get started with chipKIT.
For the full print version contact:
Electronic Products
P.O. Box 251
Milford, MI 48381
www.elproducts.com
chuck@elproducts.com
The publisher offers special discounts on bulk orders of this book.
The Microchip name and logo, MPLAB and PIC are registered
trademarks of Microchip Technology Inc. in the U.S.A. and other
countries. The Digilent name and logo are registered trademarks of
Digilent Incorporated.
chipKIT is a trademark of Microchip Technology Inc.
UNO32 and MAX32 are a trademark of Digilent Inc.
All other trademarks mentioned herein are the property of their
respective companies.
Getting Started with chipKIT is an independent book and is not
affiliated with, nor has it been authorized, sponsored, or otherwise
approved by Microchip.
Printed in the United States of America

Table of Contents
INTRODUCTION..............................................................................................5
CHAPTER 1 WHAT IS CHIPKIT................................................................7
CHIPKIT OVERVIEW .........................................................................................7
HARDWARE FOR PROJECTS .............................................................................19
HOW TO GET CHIPKIT RUNNING ON MAC.......................................................20
HOW TO GET CHIPKIT RUNNING ON WINDOWS ..............................................27

MPIDE...........................................................................................................37
CHIPKIT C COMPILER ....................................................................................42
CHAPTER 2 FLASH AN EXTERNAL LED .............................................49
HARDWARE ....................................................................................................49
SOFTWARE .....................................................................................................51
HOW IT WORKS ..............................................................................................51
NEXT STEPS ...................................................................................................54
CHAPTER 3 TRAIN CROSSING...............................................................55
HARDWARE ....................................................................................................55
HOW IT WORKS ..............................................................................................57
NEXT STEPS ...................................................................................................59
CHAPTER 4 LED TRAFFIC LIGHT.........................................................61
HARDWARE ....................................................................................................61
SOFTWARE .....................................................................................................63
HOW IT WORKS ..............................................................................................64
NEXT STEPS ...................................................................................................66
CHAPTER 5 SCROLL LEDS......................................................................67
HARDWARE ....................................................................................................67
SOFTWARE .....................................................................................................69
HOW IT WORKS ..............................................................................................70
NEXT STEPS ...................................................................................................72
CHAPTER 6 SENSING A SWITCH...........................................................75
HARDWARE ....................................................................................................76
SOFTWARE .....................................................................................................77
NEXT STEPS ...................................................................................................81
CHAPTER 7 - READ A POTENTIOMETER ..............................................83
HARDWARE ....................................................................................................83
SOFTWARE .....................................................................................................85

HOW IT WORKS ..............................................................................................86

NEXT STEPS ...................................................................................................88
CHAPTER 8 - SENSING LIGHT...................................................................91
HARDWARE ....................................................................................................91
SOFTWARE .....................................................................................................93
HOW IT WORKS ..............................................................................................93
NEXT STEPS ...................................................................................................95
CHAPTER 9 CREATING SOUND .............................................................97
HARDWARE ....................................................................................................97
SOFTWARE .....................................................................................................99
HOW IT WORKS ..............................................................................................99
NEXT STEPS .................................................................................................101
CHAPTER 10 DIMMING AN LED WITH PWM...................................103
HARDWARE ..................................................................................................103
SOFTWARE ...................................................................................................105
HOW IT WORKS ............................................................................................105
NEXT STEPS .................................................................................................107
CHAPTER 11 SERIAL COMMUNICATION .........................................109
HARDWARE ..................................................................................................109
SOFTWARE ...................................................................................................111
HOW IT WORKS ............................................................................................112
NEXT STEPS .................................................................................................114
CONCLUSION...............................................................................................115
APPENDIX A PARTS LIST FOR PROJECTS ........................................117
APPENDIX B UNO32 PIN MAP...............................................................119
APPENDIX C CHIPINO DEMO SHIELD...............................................121
INDEX.............................................................................................................123

Introduction
New electronic based products are released daily. At the
heart of these electronic devices is typically a
microcontroller. Over the years many improvements in
the tools needed to develop microcontroller based
designs have been released. One of the more popular
development modules is the Arduino that is so easy to
program, artists, designers, hobbyists and even basement
engineers have created very interesting projects using this
development path. The design is open sourced so many
variations of the Arduino exist.
Microchip Technology Inc. and Digilent Inc. with
software help from Mark Sproul and Rick Anderson of
the FUBAR Hackerspace worked together and created a
Microchip PIC based Arduino compatible module
called the chipKIT. chipKIT comes in two versions; the
smaller chipKIT UNO32 and the larger chipKIT
MAX32. These modules are based on the Microchip
PIC32 microcontroller and offer many more features than
the typical Arduino module. Despite these added
features, the chipKIT platform is designed to work with
the same simplified programming language used by
Arduino and also uses the same type of bootloader
programming through a USB connection. The chipkit
makes it easy for anyone from beginner to experienced
professional to develop interesting projects and products.
In this book Ill show you how to get started with the
chipKIT UNO32 using some very simple example
sketches (sketch is a software program in the Arduino
5

world) that demonstrate how to use digital inputs/outputs

and analog inputs/outputs. From these simple examples
youll have the building blocks to get your electronic
project, gadget or product up and running quickly and
easily. If you have any questions regarding the content of
this book you can contact me via email at
chuck@elproducts.com.

Chapter 1 What is chipKIT

You can purchase many different microcontroller based
modules for electronic development but none as powerful
and still as easy to use as the chipKIT modules. chipKIT
uses a simplified form of C language based around the
popular Arduino module. This C compiler includes many
pre-written functions to make it easier for the beginner to
use. This accomplishes two tasks; it allows complete
beginners to get started and it also teaches them the
fundamentals of the C language that is used in industry.
The chipKIT in many ways was developed for the artist
or mechanical hacker crowds who arent your normal
electronics users. Its proven by the fact that software
written for the chipKIT is called a sketch (like an artists
drawing) rather than a program which is the typical name
used for software. The chipKIT platform is all open
source so all the electrical schematics, circuit board
layouts and software are all available to the end user.
There are two versions of the chipKIT board; the UNO32
and the MAX32. In this book Ill use the chipKIT
UNO32. To better understand the chipKIT UNO32 let
me detail what makes up the module.

chipKIT Overview
The chipKIT UNO32 is a microcontroller board based on
the PIC32MX320F128H microcontroller. The larger
7

chipKIT MAX32 is based on the PIC32MX795F512L.

They both offer Arduino shield (expansion boards are
called shields) compatible connections which include 14
digital input/output pins (of which 5 can be used as PWM
outputs), 6 analog inputs, and a power header with Reset,
5v, 3.3v, Vin and Ground connections. The chipKIT
modules include a USB connection, a power jack, an In
Circuit Serial Programming (ICSP) header, and a reset
button. The chipKIT modules also offer many extra
input/output (I/O) connections beyond the basic Arduino
connections but for this book Ill focus on the
Arduino/chipKIT common connections.
The chipKIT software is designed to be completely
compatible with Arduino. The same functions that
control the Arduino can control chipKIT. This means all
the Arduino sample files can be used with the chipKIT.
This also means the projects in this book will work with
Arduino.
The setup for chipKIT is the same as the setup for
Arduino. All you have to do is download the software
and connect the chipKIT module to a computer with a
USB cable to get started. The chipKIT modules can be
powered from the USB cable or separately from an ACto-DC adapter or battery. To program the board you need
the Arduino/chipKIT programming software which Ill
explain in a few pages. The UNO32and MAX32 are
shown in Figure 1-1.

Figure 1-1: chipKIT UNO32 and chipKIT MAX32

The PIC32 microcontrollers run at 3.3v but many of the
digital I/O are 5v tolerant. All the Arduino compatible
pins are 5v tolerant. The Analog pins are 3.3v as well but
have protection if 5v is applied. The PIC32 also runs 80
MIPS and has a total of 42 I/O on the UNO32 and 83 I/O
on the MAX32.

Module Details

The supporting documentation and details can be found

at:
www.microchip.com/chipkit
or
www.digilentinc.com/chipkit

Module Features
Feature
Core
Flash
Memory
(KB)
RAM (KB)
USB
CAN

chipKIT MAX32

chipKIT UNO32

80 Mhz, 3.3v, 32-bit

512

80Mhz,3.3v,32-bit
128

128
YES (FS Device/Host,
OTG)
2

16

Ethernet

YES

DMA

YES

PMP/PSP
RTCC
Timers
PWM
ADC
Comparators
I2C
SPI
UART

YES
YES
16/32-bit
16/32-bit
16 ch. 1Msps, 10-bit
2
5
4
6

10

YES
YES
16/32-bit
16/32-bit
16 ch. 1Msps, 10bit
2
2
2
2

Power

The chipKIT module can be powered via the USB

connection or with an external power supply. The power
source is selected automatically by sensing circuitry
within the chipKIT module. The module has a 5v
regulator and a 3.3v regulator. External power feeds the
5v regulator which then feeds the 3.3v regulator. The
external power can come either from a 7-15 volt AC-toDC adapter with a 2.1mm center-positive plug or a 9 volt
battery with a cable that ends in a 2.1mm plug. You can
also bypass the 5v regulator and power it direct from 5v
with a jumper selection on the circuit board.

Arduino Compatible Headers

The chipKIT UNO32 module was designed to be

compatible with the Arduino UNO module even though
the chipKIT has dual row connector headers. The
UNO32 circuit board dual row connection headers are
positioned to accept Arduino compatible shields on the
outer row. These outer rows include two 8-pin headers
that contain 14 digital I/O, a 6-pin analog header and a 6pin power header. There are some minor differences so
lets go through the header features.
Digital Pins

Each of the 14 Arduino compatible digital pins on the

chipKIT UNO32 can be used as inputs or outputs, using
11

pinMode(), digitalWrite(), and digitalRead() functions.

Each pin can provide or receive a maximum of 25 mA
and has protection so they are 5v compatible. The pins
are arranged to match the Arduino UNO with a few
minor differences noted below.
Serial: pin0 (RX) and pin1 (TX) These pins are used
to receive (RX) and transmit (TX) serial data and are
connected to the corresponding pins of the FTDI USB-toTTL Serial chip. Its through these pins that the sketch is
loaded into memory.
External Interrupts: pin2, (pin 7, 8) - These pins can
react to an external signal automatically if setup in
software to do so. It can be configured to trigger an
interrupt on a low value, a rising or falling edge, or a
change in value. The attachInterrupt() function is used to
set this up. (Arduino also uses pin 3 as an external
interrupt pin but UNO32 has extra external interrupts on
pin 7 and 8 instead)
PWM: pin3, pin5, pin6, pin9, pin10 (on UNO32 10 is
PWM via jumper JP4) - Provide PWM output with the
analogWrite() function. (Arduino has PWM on pin 11
but on UNO32 pin 11 is just digital I/O)
SPI: pin10 (SS via jumper JP4), pin11 (MOSI), pin12
(MISO), pin13 (SCK) - These pins support SPI Master
communication. (UNO32 allows these pins to be setup as
slave pins using jumpers).
12

LED: pin13 - There is a built-in LED connected to

digital pin13. When the pin is HIGH the LED is on, when
the pin is LOW it's off.

Analog Pins
The chipKIT UNO32 has 6 analog pins in the same
location as the Arduino UNO. There are some minor
differences that will be explained here.
Analog to Digital Conversion (ADC): A0 thru A5 Analog inputs with 10 bit resolution (i.e. 1024 different
values). UNO32 analog pins measure from ground to 3.3
volts. The reference voltage can be changed to a lower
voltage using the AREF pin and the analogReference()
function. (Arduino analog pins read from ground to 5v)
I2C: A4 (SDA), A5 (SCL) These pins support I2C
communication using the Wire library. On UNO32 you
need to move two jumpers on the circuit board to use
pins A4 and A5 as I2C pins.
Analog Reference: AREF - Reference voltage pin for
the analog inputs. Used with analogReference(). This pin
is on the digital header row.

Power Pins
The chipKIT UNO32 shares the same power connections
as the Arduino UNO. They are described here.
13

RESET This pin connects to the microcontrollers reset

pin and pulling this pin to ground will reset the UNO32
to run the sketch in its memory from the very beginning.
VIN This pin his connected to the center tap of the 2.1
mm connector and makes it easy to connect to the input
voltage of the UNO32 board.
5V - This pin has the regulated five volt power produced
by the UNO32s five volt regulator.
3V3 - A 3.3 volt supply is generated by the on-board 3.3v
regulator.
GND Two ground pins are on this header.
Special Note:
chipKIT modules have many extra digital and analog pins
outside of the normal core Arduino connections. These will be
considered an advanced topic and will not be covered in full
here since this book is dedicated to those just getting started.
Check the microchip.com/chipkit or digilentinc.com/chipkit
websites for more details on these extra I/O features.

Jumper Settings

The chipKIT UNO32 and chipKIT MAX32 have many

options due to its expanded I/O setup. There are several
jumpers that make a selection for certain pins on the
module. The UNO32 jumpers are explained next.
14

Note: These are UNO32 settings only (MAX32 are

different).

JP4
RD4PositionPIN10isPWMpin
RG9PositionPIN10isSPISlaveSelect(SS)pin

JP5
MasterPositionPIN12isSPISDO(MISO)
SlavePositionPIN12isSPISDI(MOSI)

JP7
MasterPositionPIN11isSPISDI(MOSI)
SlavePositionPIN11isSPISDO(MISO)

JP6
A4PositionPINA4isAnalogInput
RG3PositionPINA4isI2CSDApin

JP8
A5PositionPINA5isAnalogInput
RG2PositionPINA5isI2CSCLpin

15

JP2
BYPPositionPoweratJ4PowerInput(alsoVINpin)bypasses5v
regulatorgoesdirectinto3.3vregulator(Max6vinwheninthismode!)

REGPositionPoweratJ4PowerInput(alsoVINpin)goesto5v
Regulatorinputbefore3.3vregulator(Max15vinwheninthismode!)

Communication

The chipKIT UNO32 has a number of options for

communicating with a computer, another chipKIT, or
other microcontrollers. The chipKIT chip has an internal
UART serial communication peripheral which is
available on digital pins 0 (RX) and 1 (TX). An FTDI
FT232RL chip on the board converts this serial
communication to USB. The FTDI drivers (included with
the chipKIT software) provide a virtual com port to
software on the computer. The chipKIT MPIDE software
also includes a serial monitor which allows simple ASCII
data to be sent to and from the chipKIT board.
The FTDI chip has RX and TX LEDs on the board that
flash when data is being transmitted via the FTDI chip.
The Arduino Software Serial library is also available that
offers software functions for serial communication on
any of the UNO32's digital pins.

16

The chipKIT software also supports I2C and SPI

communication through the chipKIT/Arduino software
libraries.
Programming

The chipKIT UNO32 control code is written using the

chipKIT programming software running on a PC or
MAC (Linux is also supported but not covered in this
book) which is also called the chipKIT MPIDE which
stands for Multi-Purpose Integrated Design Environment.
MPIDE can be used to program chipKIT modules or any
Arduino module.
The UNO32s PIC32 microcontroller is programmed
using a bootloader or software method so you dont need
a separate hardware programmer. The chipKIT software
has an editor for writing the sketches and then a built in
compiler and bootloader interface. With a single click of
the mouse, your software will be compiled into 1s and
0s and then sent to the flash memory of the UNO32.
For advanced users you can also bypass the bootloader
and program the microcontroller through the ICSP (InCircuit Serial Programming) header with an extra
hardware programmer.

17

Automatic (Software) Reset

Besides the physical reset button, the chipKIT UNO32

can be reset by software running on a connected
computer. One of the hardware flow control lines (DTR)
of the FT232RL is connected to the reset line of the
chipKIT chip through a 100 nanofarad capacitor. When
this line is pulled low, the reset line drops long enough to
reset the chip. The chipKIT software uses this capability
to allow you to upload code by simply clicking on the
upload icon in the MPIDE.
This setup has other implications. When the UNO32 is
connected to either a computer running Windows, Mac
OS X or Linux, it resets each time a connection is made
to it from software (via USB). When reset, the UNO32
bootloader will run for a half-second or so to look for
new code to download. If your application trying to
communicate with the UNO32 starts off by sending data
bytes, the bootloader may intercept the first few bytes of
data sent to the board after a connection is opened. Its
best to make sure that the software communicating with
the UNO32 waits a few seconds after opening the
connection before sending any data.

Physical Characteristics

The UNO32 PCB is about 2.7 and 2.1 inches with the
USB connector and power jack extending beyond these
18

dimensions. Three screw holes on the UNO32 align with

the Arduino UNO and allow the board to be attached to a
surface or case. If you want to make your own stack on
board (known as a shield in the Arduino/chipKIT world)
then note that the distance between digital pins 7 and 8 is
not a standard 0.100 spacing. This non-standard
connection layout makes it a little more difficult to create
a shield board from a standard 0.100 spacing
protoboard. There are offset connectors available that
allow you to plug a standard protoboard into an UNO or
UNO32 module. There are also many proto-shields
available with the required spacing to fit the
UNO/UNO32 layout.

Hardware for Projects

The hardware for the projects in this book can all be built
on the breadboard. Each chapter project includes a
drawing of the setup on a breadboard layout. For those
that dont have much hardware experience, the projects
were also written to work with the CHIPINO demo
shield. You can get this from chipaxe.com or several
other sources. Email me (chuck@elproducts.com) or
google search for a complete list of sources. More details
on this shield is in the appendix of this book.

19

CHIPINO Demo Shield

How to get chipKIT running on Mac

These are the fundamental steps to get chipKIT running
on a MAC:

Download the chipKIT MPIDE

Install the USB driver
Connect the board
Run the MPIDE
Create a Blink LED project
Run the Blink project on a chipKIT module

20

1 | Download the MPIDE environment

The software can be downloaded by clicking on the

MAC OS X link on the software download page at either
of the locations below:
www.microchip.com/chipkit
www.digilentinc.com/chipkit
You will have two files, the MPIDE programming
software and the FTDI drivers. Slide the MPIDE icon
over the applications folder to install the MPIDE
programming software.

Figure 1-2: chipKIT Files for MAC

2 | Install the USB drivers

Unless youve already used a product with a USB to

RS232 FTDI chip, you will need to install the drivers for
the FTDI chip on the chipKIT board. Click on the FTDI
Drive icon to install the driver. Follow all the steps until
installed.

21

Figure 1-3: Install FTDI Drivers

3 | Connect the board

Connect the USB cable to one of the MACs USB ports

and then to the USB connector of your chipKIT board.
The chipKIT module uses a mini-A USB cable which is
different from the cable Arduino uses.

4 | Run the MPIDE environment

Click on the MPIDE icon to launch the environment and

you should see a screen similar to the one in Figure 1-4.

22

Figure 1-4: Arduino/chipKIT Programming Environment

5 | Create a Blink LED project

First select your UNO32 board from the Tools>Board

menu. In this books examples well use the UNO32
(Figure 1-5). Then select the serial port you have the
chipKIT connected to under the Tools>Serial Port menu
(Figure 1-6). On the MAC, this should be something with
usbserial in the name. Now you are ready to create your
first sketch.
23

Figure 1-5: Select chipKIT module

Figure 1-6: Select Serial Port

Many pre-written example sketches are included with the

chipKIT environment so its easier to start with a
working example to get your first sketch running. Open
the LED blink example sketch: by clicking on the
24

following menu option: File > Sketchbook > Examples >

Digital > Blink (shown in Figure 1-7).

Figure 1-7: Blink LED Sketch

25

6 | Run the Blink project on UNO32

Click the "Upload" button in the environment which is

the sideways arrow shown highlighted in Figure 1-8.
Wait a few seconds and you should see the RX and TX
LEDs on the board flashing. If the upload is successful,
the message "Done uploading." will appear in the status
bar at the bottom.

Figure 1-8: Upload sketch to chipKIT board

A few seconds after the upload finishes, you should see

the pin 13 (LD4) LED on the board start to blink. If it
does, congratulations! You've successfully programmed
your UNO32. If not, go back through the steps to see if
you missed something.
Note: For user help visit the chipKIT forum at:
www.chipkit.org/forum
The UNO32 has an LED already wired to pin 13 so you
didnt need to connect any circuitry to the chipKIT
board. In future projects you will need to connect the
proper components to get the sketch to work.

26

How to get chipKIT running on Windows

These are the fundamental steps to get chipKIT running
on a PC:

Download the MPIDE environment

Install the USB driver
Connect the board
Run the MPIDE
Create a Blink LED project
Run the Blink project on a UNO32

1 | Download the MPIDE

The MPIDE programming software can be downloaded

by clicking on the windows link on the software
download page at either of the locations below:
www.microchip.com/chipkit
www.digilentinc.com/chipkit
Its a .zip file that you unzip to a location on your hard
drive. When the download finishes, unzip the
downloaded file. Youll end up with a file structure as
shown.

27

2 | Connect the board

Connect the USB cable to one of the PCs USB ports and
then to the USB connector of your chipKIT UNO32
board. The chipKIT module uses a mini-A USB cable
which is different than the Arduino.

3 | Install the USB drivers

The installation process will depend on what operating

system you are running. The chipKIT modules use an
FTDI USB interface chip so its best to follow the
installation instructions at specific to your operating
system. The location is at the following address.

28

http://www.ftdichip.com/Support/Documents/InstallGuides.htm

Here is a typical step by step installation on a PC running

XP.

Figure 1-9: FTDI Wizard Screen

29

Figure 1-10: Select Specific Location Option

Figure 1-11: Click on Browse to Locate Drivers

30

Figure 1-12: Select the FTDI USB Drivers Folder

Figure 1-13: Driver Installation

31

Figure 1-14: FTDI Driver Installation Complete

4 | Run the MPIDE

Click the
icon in the chipKIT environment
folder and you should see a screen similar to the one in
Figure 1-15.

32

Figure 1-15: Arduino/chipKIT Environment

5 | Create a Blink LED Project

Select the UNO32 board from the Tools | Board menu.

33

Figure 1-16: Select chipKIT Board

Next, select the proper COM port. To verify, open the

Windows Device Manager in the Hardware tab of
System control panel.

Figure 1-17: Select the COM Port

Open the LED blink example sketch:

File > Sketchbook > Examples > Digital > Blink

34

Figure 1-18: Select Blink Sketch

Figure 1-19: Blink Sketch Window

35

6 | Run the Blink project on UNO32

Click the "Upload" button in the environment which is

the sideways arrow shown highlighted in Figure 1-20.
Wait a few seconds and you should see the RX and TX
LEDs on the board flashing. If the upload is successful,
the message "Done uploading." will appear in the status
bar.

Figure 1-20: Upload sketch to chipKIT board

Figure 1-21: Uploading to chipKIT Board

Figure 1-22: Sketch is Loaded in chipKIT

36

A few seconds after the upload finishes, you should see

the pin 13 (LD4) LED on the board start to blink. If it
does, congratulations! You've successfully programmed
the chipKIT module. If not, go back through the steps to
see if you missed something.
Note: For user help visit the chipKIT forum at:
www.chipkit.org/forum
The chipKIT has an LED already wired to pin 13 so you
didnt need to connect any circuitry to the chipKIT
board. In future projects you will need to connect the
proper
components
to
get
the
sketch to work.

MPIDE
The MPIDE is the same for MAC, Windows and Linux
and contains a text editor where you write your chipKIT
sketch. A toolbar with buttons for common functions is
at the top of the screen along with a series of menus.
There is a message area at the bottom to give feedback
when saving or exporting a file. It also displays any code
errors. The toolbar functions are explained below.

37

Verify/Compile

Checks your code for errors.

Stop

Stops the serial monitor, or unhighlight other buttons.

New

Creates a new sketch.

Open

Presents a menu of all the sketches in your sketchbook.

Save

Saves your sketch.

Upload to I/O Board

Compiles your code and uploads it to the chipKIT board.

Serial Monitor

Opens the Serial Communication Window.

Additional commands are found within the five menus:

File, Edit, Sketch, Tools, Help. The menus are context
sensitive which means only those items relevant to the
work currently being carried out are available The menu
options are as follows:

File
Here you can open existing sketches or create and save
new ones.
Edit
Copies the code of your sketch to the clipboard in a
forum suitable for posting to a forum, complete with
syntax coloring.
Copies the code of your sketch to the clipboard as
HTML, suitable for embedding in web pages.
38

Sketch
Verify/Compile

Checks your sketch for errors.

Import Library

Adds a library to your sketch by inserting #include

statements at the code of your code.
Show Sketch Folder

Opens the sketch folder on the desktop.

Add File...

Adds a source file to the sketch (it will be copied from its
current location). The new file appears in a new tab in the
sketch window. Files can be removed from the sketch
using the tab menu.
Tools
Auto Format

This formats your code nicely: i.e. indents it so that

opening and closing curly braces line up, and that the
statements instead curly braces are indented more.
Board

Select the board that you're using.

Serial Port

This menu contains all the serial devices (real or virtual)

on your machine. It should automatically refresh every
time you open the top-level tools menu.
Burn Bootloader

The items in this menu allow you to burn a bootloader

onto the microcontroller on an chipKIT board. This is not

39

required for normal use of a chipKIT board but is useful

if you want to build your own chipKIT.
Help
This selection allows you to look up help topics that may
not be in the manual or this book.
Sketchbook

The chipKIT environment uses a folder to contain all the

files in a project. The first time you run the chipKIT
software, it will automatically create a folder for your
sketch. You can view or change the location of the sketch
location from with the Preferences option under the file
menu selection.
Tabs, Multiple Files, and Compilation

The environment allows you to break up your sketch into

multiple files that get combined into one big file when
you are ready to program the chipKIT hardware. The
environment has tabs so each file can appears in its own
tab. These can be normal chipKIT code files (no
extension), C files (.c extension), C++ files (.cpp), or
header files (.h).
Uploading

As described in the blink example earlier, to upload your

sketch, you need to select the correct items from the
40

Tools > Board and Tools > Serial Port menus. Once
you've selected the correct serial port and board, press the
upload button in the toolbar or select the Upload to I/O
Board item from the File menu. Current chipKIT boards
will reset automatically and begin the upload. Youll see
the RX and TX LEDs blink as the sketch is uploaded.
The MPIDE will display a message when the upload is
complete, or show an error.
Libraries

Libraries are the heart of what makes the chipKIT easy to

use with the hardware. The functionality in the
microcontroller is easily controlled by these prewritten
sections of code you can include in your sketch. To use a
library in a sketch, select it from the Sketch > Import
Library menu. This will insert one or more #include
statements at the top of the sketch and compile the library
with your sketch. Because libraries are uploaded to the
board with your sketch, they increase the amount of
space it takes up. If a sketch no longer needs a library,
simply delete its #include statements from the top of your
code.
Some libraries are included with the chipKIT software
while others can be downloaded from a variety of
sources. To install a custom library, create a directory
called libraries within your sketchbook directory. Then
copy the library there. For example, to install the
DateTime library, its files should be in the
/libraries/DateTime sub-folder of your sketchbook folder.
41

Serial Monitor

The chipKIT module can send back serial data through

the same programming connections of the USB cable.
The data sent can be displayed on the Serial Monitor
built into the chipKIT Environment. To use the Serial
Monitor you need to choose the baud rate from the dropdown that matches the rate passed to Serial.begin in your
sketch. To send data to the board, enter text and click on
the "send" button or press enter.
Preferences

Some preferences can be set in the preferences dialog

(found under the chipKIT menu on the Mac, or File on
Windows and Linux). The rest can be found in the
preferences file, whose location is shown in the
preference dialog.

chipKIT C Compiler
The chipKIT uses a programming language based on C.
The chipKIT uses names that are not typical to C
programming and also has pre-built commands to make it
easier for the beginner to get started quicker. The C
language gets converted into the 1s and 0s the chipKIT
microcontroller needs by the chipKIT C compiler. To use
it properly its best to know the basics and this chapter
will cover those details.
42

Sketch

A sketch is the name that chipKIT uses for a program. It's

the software that is loaded and run on a chipKIT board.
The software below is a sample sketch for flashing the
pin 13 LED. Ill describe the various sections as we go
through this chapter.
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
The circuit:
LED connected from digital pin 13 to ground.
Note: On most chipKIT boards, there is already an LED on the board
connected to pin 13, so you don't need any extra components for this example.
*/
int ledPin = 13; // LED connected to digital pin 13
// The setup() runs once, when the sketch starts
void setup()
{
pinMode(ledPin, OUTPUT); //initialize the digital pin as an output
}
// The main loop runs over and over again until power is removed
void loop()
{
digitalWrite(ledPin, HIGH); // set the LED on
delay(1000);
// wait for a second
digitalWrite(ledPin, LOW); // set the LED off
delay(1000);
// wait for a second
}

43

Comments

The first few lines of the Blink sketch are a comment

block:
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
The circuit:
LED connected from digital pin 13 to ground.
Note: On most chipKIT boards, there is already an LED on the board
connected to pin 13, so you don't need any extra components for this example.
*/

Everything between the /* and */ is considered a

comment block and does not get compiled for the
chipKIT when it runs the sketch. Comment blocks are
used to describe what the sketch does, how it works, or
why it's written the way it is. It's a good practice to
comment your sketches, and to keep the comments up-todate when you modify the code.
There's another style for comments. They start with // and
continue only until the end of the line.
int ledPin = 13;

// LED connected to digital pin 13

The section "LED connected to digital pin 13" is a treated

as a comment and not compiled into the chipKIT.
Sketch Variables

A variable is a place for storing a piece of data in RAM.

It has a name, a type, and a value. For example, the line
from the Blink sketch declares a variable with the name
44

ledPin. It is created as a type int and initialized with

the value of 13. It's used to indicate which chipKIT pin
the LED is connected to. Every time the name ledPin
appears in the code, its value will be retrieved. In this
case, the person writing the sketch could have chosen not
to bother creating the ledPin variable and instead have
simply written 13 everywhere but then later if they
wanted to change the pin connection they would have to
replace it multiple times. Using the ledPin label allows
you to change the LED at one spot. Variables are
declared before the setup section.
int ledPin = 13; // LED connected to digital pin 13
// The setup() runs once, when the sketch starts
void setup() {
}

setup() and loop()

There are two special functions that are a part of every

chipKIT sketch: setup() and loop(). The setup() is called
once, when the sketch starts. It's a good place to do setup
tasks like setting pin modes or initializing libraries. The
loop() function is called over and over and is heart of
most sketches. You need to include both functions in
your sketch, even if you don't need them for anything.
void setup() {
// put your setup code here, to run once:
}
45

void loop() {
// put your main code here, to run repeatedly:
}

{ } Curly Braces

Curly braces or curly brackets are important characters in

any C programming language which the chipKIT
software is based on. An opening curly brace "{" must
always be followed by a closing curly brace "}" or you
will get an error when you compile. Beginning
programmers, and programmers coming to C from the
BASIC language often find using braces confusing. After
all, the curly braces replace the RETURN statement in a
subroutine, the ENDIF statement in a conditional IF
statement and the NEXT statement in a FOR loop. So
think of curly braces as the beginning and end of any
function.

; semicolon

A command line inside your sketch is called a statement

in the C language. Each statement needs to mark the end
with a semicolon. A statement line can extend multiple
lines in your sketch and end with a semi-colon to let the
compiler know where to end. The most common error a
beginner will see is a missing semi-colon. Two
statements will be combined by the compiler and youll

46

get an unrecognized statement error because of that

missing semi-colon.
//Simple example of how to end a statement.
int a = 13;

const

The chipKIT software offers the const keyword and is the

preferred method for defining constants. The const
keyword is short for constant and really just a modifier to
a variable that makes it read only and cannot be changed
at any time in the program.
//
constants
won't
// set pin numbers:
const int ledPin =

12;

change.

Used

here

to

// the number of the LED pin

#include

#include is used to insert external files that contain

definitions of pre-built functions. This is also known as
including a library. A library will have a header file or .h
file with library. The #include directive is used to include
that header file within your sketch. The #include allows
you to include both chipKIT libraries and standard C
language libraries. The #include in excercised before the
compiler is run so the #include line does not end with a
semi-colon. Its placed above the setup section.
47

#include "pitches.h"
// notes in the melody:
int melody[] = { NOTE_C4, NOTE_G3,NOTE_G3, NOTE_A3,
NOTE_G3,0, NOTE_B3, NOTE_C4};
// note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = { 4, 8, 8, 4,4,4,4,4 };
void setup() {

This covers the basics of programming for the chipKIT

but its plenty of information for you to start creating
your own sketches for running on the chipKIT. Well
start by modifying the Blink example and drive an LED
from a header pin.

48

Chapter 2 Flash an External LED

The first project every beginner needs to do is get an
LED to flash. This proves out many things: 1) The
hardware is connected properly 2) The software compiles
without errors 3) The module can communicate and be
programmed from the computer thru a USB connection.
4) We are ready to move on to more complex projects.
If at any point you cant get a project to run on the
chipKIT, flashing an LED is always a good indicator that
the basic setup is working properly.

Hardware
Connect the chipKIT UNO32 per the drawing in Figure
2-1. The long lead of the LED is connected to pin 12, the
short lead is connected to the 220 ohm resistor. The other
end of the resistor is connected to the Gnd pin of the
chipKIT UNO32

49

Figure 2-1: Final Flash LED Project

50

Software
/*
Blink
Turns on an LED on for one second,
then off for one second, repeatedly.
*/
void setup() {
// initialize the digital pin 12 as an output.
pinMode(12, OUTPUT);
}
void loop() {
digitalWrite(12, HIGH);
delay(1000);
digitalWrite(12, LOW);
delay(1000);
}

//
//
//
//

set the LED on

wait for a second
set the LED off
wait for a second

How It Works
The software is quite simple but still requires some
explanation.
The top of the software contains a header block that
describes what the sketch will do. Any time you want to
add a block of text that goes over many lines, just place
the text between the /* and */ characters. This indicates
to the compiler that the text is just comments and not
code.
/*
Blink
Turns on an LED on for one second,
then off for one second, repeatedly.
*/

51

The first code section of any chipKIT sketch is the setup

section where any commands are placed that need to run
only once before running the main loop. Typically this
will be setting up the digital I/O pins and presetting any
variable values. Everything between the curly brackets
are part of the setup routine.
void setup() {
}

Within the setup section we can place comments that are

ignored by the compiler but allow us to make notes for
future reference. A double backslash before the comment
is all you need to add to make any text a comment. You
have to keep it in one line though. If the text wraps
around to a second line then the /* and */ should be
used.
The digital pins need to be setup to either be an input or
an output. This is done with the pinMode function. The
parameters in the parenthesis select the pin and the
direction. We want to control the LED with a high or low
output signal from pin 12 so we set pin 12 to an output
using the line below.
pinMode(12, OUTPUT);

The main sketch loop is the section of code that runs over
and over again. All the command lines need to be
contained within the curly brackets. The main loop will

52

run continuously as long as power is not removed from

the chipKIT or the reset switch is pressed.
void loop() {
}

The first control is the digitalWrite function that drives

pin 12 high which lights the LED.
digitalWrite(12, HIGH);

// set the LED on

The next line is the delay function. This just creates a one
second delay as the value 1000 represents 1000
milliseconds or one second.
delay(1000);

// wait for a second

The sketch then turns the LED off by setting the same pin
low.
digitalWrite(12, LOW);

// set the LED off

An additional delay function line delays another second.

delay(1000);

// wait for a second

The sketch then jumps back to the top of the loop since
the second curly bracket is encountered. This operation
will repeat over and over again to create a simple
blinking light.

53

Next Steps
Simple next steps are to change the pause value to a
lower number to flash the LED faster. You could also
connect the LED to a different pin and then change the
number in the high and low command lines to make that
new connection pin flash the LED. You could also
control two LEDs at once with a second digitalWrite line.
In fact the next project uses three to create a traffic light.

54