sparkfun Tinker Kit User manual

Experiment Guide for the SparkFun Tinker Kit


Introduction to the SparkFun Tinker Kit
This SparkFun Tinker Kit Experiment Guide is your map for navigating the
waters of beginning embedded electronics, robotics and citizen science
using the SparkFun RedBoard while sticking to a strict budget. This guide
contains all the information you will need to explore the 11 circuits of the
SparkFun Tinker Kit. At the center of this guide is one core philosophy –
that anyone can (and should) play around with cutting-edge electronics in a
fun and playful way while not breaking the bank.
When you’re done with this guide, you’ll have the know-how to start
creating your own projects and experiments. From building robots and
game controllers to data logging, the world will be your oyster. Now enough
talking – let’s start tinkering!
Included Materials
Here are all of the parts in the SparkFun Tinker Kit:
•SparkFun RedBoard – Our tried and true version of the Arduino
UNO.
•Breadboard – Excellent for making circuits and connections off the
Arduino.
•SparkFun Mini Screwdriver – To help you screw your RedBoard
onto the holder.
•Hobby Gearmotor Set – A set of hobby level motors with gearboxes
set to 120 RPM.
•Small Servo – Here is a simple, low-cost, high-quality servo for all
your mechatronic needs.
Page 1 of 6
3

•TMP36 Temp Sensor – A sensor for detecting temperature changes.
•USB A to B Cable – This 6-foot cable provides you with a USB-A
connector at the host end and standard B connector at the device
end.
•Male-to-Male Jumper Wires – These are high-quality wires that
allow you to connect the female headers on the Arduino to the
components and breadboard.
•Photocell – A sensor to detect ambient light. Perfect for detecting
when a drawer is opened or when nighttime approaches.
•Tri-Color LED – Because everyone loves a blinky.
•Red, Blue, Yellow and Green LEDs – Light-Emitting Diodes make
great general indicators.
•Red, Blue, Yellow and Green Tactile Buttons – Go crazy with
different colored buttons.
•10K Trimpot – Also known as a variable resistor, this is a device
commonly used to control volume and contrast, and makes a great
general user control input.
•330 Ohm Resistors – Great current-limiting resistors for LEDs, and
strong pull-up resistors.
•10K Ohm Resistors – These make excellent pull-ups, pull-downs
and current limiters.
•SN754410 H-Bridge IC – This nifty little Integrated Circuit (IC) is
perfect for controlling the speed and direction of up to two separate
motors.
•4xAA Battery Holder – Used to power the RedBoard without being
connected to your computer. Sorry! Batteries not included.
Experiment List
The following is a list of the experiements you will complete using this
Tinker Kit Experiment Guide. Alternatively, you can navigate around using
the buttons on the right.
• Experiment 1: Blinking an LED
• Experiment 2: Reading a Potentiometer
• Experiment 3: Driving an RGB LED
• Experiment 4: Driving Multiple LEDs
• Experiment 5: Reading a Button Press
• Experiment 6: Reading a Photoresistor
• Experiment 7: Reading a Temperature Sensor
• Experiment 8: Using a Servo Motor
• Experiment 9: Driving a Motor with an H-Bridge
• Experiment 10: Controlling a Motor with Inputs
• Experiment 11: Reading Serial Data
Suggested Reading
Before continuing with this guide, we recommend you be somewhat familiar
with the concepts in the following tutorials:
• Voltage, Current, Resistance, and Ohm’s Law - The most basic
concepts in electronics and electrical engineering. Get very familiar
with these concepts as they will be used throughout your electronics
adventure.
• What is a Circuit? - In this guide, we will be building a variety of
circuits. Understanding what that means is vital to understanding the
Inventor’s Kit.
• How to Use a Breadboard – First time working with a breadboard?
Please check out this tutorial! It will help you understand why the
breadboard is great for prototyping and how to use one.
Open Source!
Page 2 of 6
3

At SparkFun, our engineers and educators have been improving this kit and
coming up with new experiments for a long time. We would like to give
attribution to Oomlout, since we originally started working off the Arduino Kit
material many years ago. Both the Oomlout and SparkFun versions are
licensed under the Creative Commons Attribution Share-Alike 3.0 Unported
License.
To view a copy of this license visit this link, or write: Creative Commons,
171 Second Street, Suite 300, San Francisco, CA 94105, USA.
What is the RedBoard?
At SparkFun we use many Arduinos, and we’re always looking for the
simplest, most stable one. Each board is a bit different, and no one board
has everything we want, so we decided to make our own version that
combines all our favorite features. The SparkFun RedBoard combines the
simplicity of the UNO’s Optiboot bootloader (which is used in the Pro
series), the stability of the FTDI (which we all missed after the Duemilanove
was discontinued) and the R3 shield compatibility of the latest Arduino UNO
R3.
The RedBoard can be programmed over a USB Mini-B cable using the
Arduino IDE: Just plug in the board, select “Arduino UNO” from the board
menu, and you’re ready to upload code. RedBoard has all of the hardware
peripherals you know and love: 14 Digital I/O pins with 6 PWM pins, 6
Analog Inputs, UART, SPI and external interrupts. We’ve also broken out
the SDA, SCL and IOREF pins that showed up on the UNO R3, so the
RedBoard will be compatible with future shields. This version adds an SMD
ISP header for use with shields.
You can power the RedBoard over USB or through the barrel jack. The on-
board power regulator can handle anything from 7 to 15VDC. Check out the
related items below for a compatible wall-wart power supply.
Download and Set Up the Arduino Software
Before you plug the RedBoard into your computer, you’ll need to install
Arduino.
Installing Arduino
To begin, head over to Arduino’s download page and grab the most recent,
stable release of Arduino. Make sure you grab the version that matches
your operating system.
DOWNLOAD ARDUINO!
Page 3 of 6
3

The installation procedure is fairly straightforward, but it varies by OS. Here
are some tips to help you along. We’ve also written a separate Installing
Arduino tutorial if you get really stuck.
Windows Install Tips
The Windows version of Arduino is offered in two options: an installer or a
zip file. The installer is the easier of the two options; just download that,
and run the executable file to begin installation. If you’re prompted to install
a driver during installation, select “Don’t Install” (the RedBoard doesn’t use
the same drivers). Don’t forget which directory it installs to (defaults to
“Program Files/Arduino”).
Windows install steps. Click the image for a closer look.
If, instead, you choose to download the zip file version of Arduino, you’ll
need to extract the files yourself. Don’t forget which folder you extract the
files into! We’ll need to reference that directory when we install drivers.
Mac Install Tips
The Mac download of Arduino is only offered in a zip file version. After the
download is finished, simply double-click the .zip file to unzip it.
Following that, you’ll need to copy the Arduino application into your
applications folder to complete installation.
Linux Install Tips
As Linux users are no doubt aware, there are many flavors of Linux out
there, each with unique installation routines. Check out the Linux section of
the Installing Arduino tutorial for some helpful links for an assortment of
Linux distributions.
For Ubuntu and Debian users, installing Arduino should be as easy as
running a little “apt-get” magic, with a command like:
sudo apt-get update && sudo apt-get install arduino arduino-co
re
And other Linux distros aren’t too dissimilar from that.
With Arduino downloaded and installed, the next step is to plug the
RedBoard in and install some drivers! Pretty soon you’ll be blinking LEDs,
reading buttons, and doing some physical computing!
Install FTDI Drivers
Once you have downloaded and installed Arduino, it’s time to connect the
RedBoard to your computer! Before you can use the board, though, you’ll
need to install drivers.
Page 4 of 6
3

Windows Driver Installatio
n
After initially plugging your RedBoard in, your computer will try to search for
a compatible driver. It may actually succeed! The FTDI drivers are pretty
common, so Windows Update may know a little something about them. If
the drivers do automatically install, you should see a little bubble notification
saying so:
If your computer failed to find drivers, we’ll have to install them manually.
Check out our Windows FTDI Driver install guide for driver installation
instructions.
Mac Driver Installation
If you’re lucky, the FTDI drivers should automatically install on Mac OS X;
otherwise you’ll have to manually install the drivers. Check out the Mac
FTDI Driver install guide for help installing the drivers.
In short, the process involves heading over to the FTDI driver website, and
downloading the most up-to-date VCP drivers. Then you’ll simply run the
“FTDIUSBSerialDriver_v2_2_18.dmg” file you downloaded, and follow the
installation prompts.
Linux Driver Installation
Linux is actually pretty good about automatically installing the drivers. If you
have any trouble, check out our Linux FTDI Driver install guide.
Now it’s time to breathe easy! You’ll only have to run through this driver
installation process once, the first time you connect the board to your
computer. Now it’s time to upload a sketch!
Experiment 1: Blink an LED
Introduction
LEDs are small, powerful lights that are used in many different applications.
To start off, we will work on blinking an LED, the “Hello, World!” of
microcontrollers. That’s right – it’s as simple as turning a light on and off. It
might not seem like much, but establishing this important baseline will give
you a solid foundation as we work toward more complex experiments.
Parts Needed
You will need the following parts:
•1x Breadboard
•1x SparkFun RedBoard
•1x LED
Page 5 of 6
3

•1x 330ΩResistor
•3x Jumper Wires
Didn’t Get the Tinker Kit?
If you are conducting this experiment and didn’t get the Tinker Kit, we
suggest using these parts:
Suggested Reading
Before continuing with this experiment, we recommend you be familiar with
the concepts in the following tutorial:
• Light-Emitting Diodes – Learn more about LEDs!
Introducing the LED
SparkFun RedBoard -
Programmed with Arduin
o

DEV-12757
Breadboard - Self-Adhesive
(White)
PRT-12002
Jumper Wires - Connected
6" (M/M, 20 pack
)

PRT-12795
LED - Basic Red 5mm
COM-09590
Resistor 330 Ohm 1/6 Watt
PTH - 20 pack

COM-11507
Page 6 of 6
3

A Light-Emitting Diode (LED) will only let current through it in one direction.
Think of an LED as a one-way street. When current flows through the LED,
it lights up! When you are looking at the LED, you will notice that its legs
are different lengths. The long leg, the “anode,” is where current enters the
LED. This pin should always be connected to the current source. The
shorter leg, the “cathode,” is the current’s exit. The short leg should always
be connected to a pathway to ground.
LEDs are finicky when it comes to how much current you apply to them.
Too much current can lead to a burnt-out LED. To restrict the amount of
current that passes through the LED, we use a resistor in line with the
power source and the LED’s long leg; this is called a current-limiting
resistor. With the RedBoard, you should use a 330 Ohm resistor. We have
included a baggy of them in the kit just for this reason!
Hardware Hookup
Ready to start hooking everything up? Check out the wiring diagram and
hookup table below to see how everything is connected.
Polarized
Components
Pay special attention to the component’s markings
indicating how to place it on the breadboard.
Polarized components can only be connected to a
circuit in one direction.
Please note: Pay close attention to the LED. The negative side of the
LED is the short leg, marked with a flat edge.

Page 7 of 6
3

Components like resistors need to have their legs bent into 90° angles in
order to correctly fit the breadboard sockets. You can also cut the legs
shorter to make them easier to work with on the breadboard.
Wiring Diagram for the Experiment
Having a hard time seeing the circuit? Click on the wiring diagram for a
closer look.
Open Your First Sketch
Open the Arduino IDE software on your computer. Coding in the Arduino
language will control your circuit. Open the code for Circuit 1 by accessing
the “Tinker Kit Guide Code” you downloaded and placed into your
“Examples” folder earlier.
To open the code go to: File > Examples > Tinker Kit Guide Code >
Circuit_01
You can also copy and paste the following code into the Arduino IDE. Hit
upload, and see what happens!
Page 8 of 6
3

/*
SparkFun Tinker Kit
Example sketch 01
BLINKING AN LED
Turn an LED on for one second, off for one second,
and repeat forever.
This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK informatio
n.
Visit http://www.arduino.cc to learn about Arduino.
*/
//The setup function runs once upon your Arduino being powere
d or once upload is //complete.
void setup()
{
//set pin 13 to OUTPUT
pinMode(13, OUTPUT);
}
//The loop function runs from the top down and repeats itself
until you upload new //code or power down your Arduino
void loop()
{
//Turn pin 13 HIGH (ON).
digitalWrite(13, HIGH);
//wait 1000 milliseconds (1 second)
delay(1000);
//Turn pin 13, LOW (OFF)
digitalWrite(13, LOW);
//wait 1000 milliseconds
delay(1000);
}
Code to Note
pinMode(13, OUTPUT);
Before you can use one of the RedBoards' pins, you need to tell the board
whether it is an INPUT or OUTPUT. We use a built-in “function” called
pinMode() to do this.
digitalWrite(13, HIGH);
When you’re using a pin as an OUTPUT, you can command it to be HIGH
(output 5 volts), or LOW (output 0 volts).
What You Should See
You should see your LED blink on and off. If it doesn’t, make sure you have
assembled the circuit correctly and verified and uploaded the code to your
board, or see the Troubleshooting section.
Page 9 of 6
3

Troubleshooting
Program Not Uploading
This happens sometimes; the most likely cause is a confused serial port.
You can change this in Tools > Serial Port >
Also, if you get a Timeout error or the IDE could not find your 101 board, try
pressing the Master Reset button on the 101, wait around 10 seconds and
try re-uploading your sketch.
Still No Success
A broken circuit is no fun. Send us an email, and we will get back to you as
soon as we can: [email protected]
Experiment 2: Reading a Potentiometer
Introduction
In this circuit you will work with a potentiometer. You will learn how to use a
potentiometer to control the timing of a blinking LED by reading a sensor
and storing it as a variable, then using it as your delay timing.
Parts Needed
You will need the following parts:
•1x Breadboard
•1x SparkFun RedBoard
•1x LED
•1x 330ΩResistor
•7x Jumper Wires
•1x Potentiometer
Didn’t Get the Tinker Kit?
If you are conducting this experiment and didn’t get the Tinker Kit, we
suggest using these parts:
SparkFun RedBoard -
Programmed with Arduin
o

DEV-12757
Breadboard - Self-Adhesive
(White)
PRT-12002
Page 10 of 6
3

Suggested Reading
Before continuing with this experiment, we recommend you be familiar with
the concepts in the following tutorial:
• Analog to Digital Conversion
Introducing the Potentiometer
A potentiometer is a resistance-based analog sensor that changes its
internal resistance based on the rotation of its knob. The potentiometer has
an internal voltage divider enabling you to read the change in voltage on
the center pin with a microcontroller (the RedBoard). To hook up the
potentiometer, attach the two outside pins to a supply voltage (5V in this
circuit) and ground. It doesn’t matter which is connected where, as long as
Trimpot 10K with Knob

COM-09806
Jumper Wires - Connected
6" (M/M, 20 pack)
PRT-12795
LED - Basic Red 5m
m

COM-09590
Resistor 330 Ohm 1/6 Watt
PTH - 20 pack
COM-11507
Page 11 of 6
3

one is connected to power, and the other to ground. The center pin is then
connected to an analog input pin so the RedBoard can measure the change
in voltage. When you twist the knob, the sensor reading will change!
Note: The potentiometer included in the kit has three marks on it that
will help you figure out which breadboard rows the pins are plugged
into.
Hardware Hookup
Ready to start hooking everything up? Check out the wiring diagram and
hookup table below to see how everything is connected.
Polarized
Components
Pay special attention to the component’s markings
indicating how to place it on the breadboard.
Polarized components can only be connected to a
circuit in one direction.
Wiring Diagram for the Experiment
Having a hard time seeing the circuit? Click on the wiring diagram for a
closer look.
Open the Sketch
Open the Arduino IDE software on your computer. Coding in the Arduino
language will control your circuit. Open the code for Circuit 2 by accessing
the “Tinker Kit Guide Code” you downloaded and placed into your
“Examples” folder earlier.
To open the code go to: File > Examples > Tinker Kit Guide Code >
Circuit_02
Copy and paste the following code into the Arduino IDE. Hit upload, and
see what happens!

Page 1
2
of 6
3

/*SparkFunTinkerKit
Examplesketch02
POTENTIOMETER
Measurethepositionofapotentiometeranduseitto
controltheblinkrateofanLED.Turntheknobtomake
itblinkfasterorslower!
ThissketchwaswrittenbySparkFunElectronics,
withlotsofhelpfromtheArduinocommunity.
Thiscodeiscompletelyfreeforanyuse.
Visithttp://learn.sparkfun.com/products/2forSIKinformatio
n.
Visithttp://www.arduino.cctolearnaboutArduino.
*/
//Createglobalvariables(variablesthatcanbeusedanywher
einoursketch)
//Herewe'recreatingavariablecalled"sensorPin"oftype
"int"
//andinitializingittohavethevalue"0,"whichistheana
loginputpinthepotis//conectedto.
int sensorPin=0;
//VariableforstoringthepinnumberthattheLEDisconnect
edto
int ledPin= 13;
//thisfunctionrunsoncewhenthesketchstartsup
void setup()
{
//setledPin(13)asanOUTPUT
pinMode(ledPin,OUTPUT);
}
//thisfunctionrunsrepeatedlyaftersetup()finishes
void loop()
{
//createalocalvariable(variablethatcanonlybeusedin
sideofloop()tostore//asensorvaluecalledsensorVa
lue
int sensorValue;
//usetheanalogRead()functiontoreadsensorPinandstore
thevalueinsensorValue
sensorValue= analogRead(sensorPin);
//TurntheLEDon
digitalWrite(ledPin,HIGH);
delay(sensorValue);
//TurntheLEDoff
digitalWrite(ledPin,LOW);
//delayforthevalueofsensorValue
delay(sensorValue);
Page 1
3
of 6
3

//loopbacktothetop
}
Code to Note
intsensorValue;
A “variable” is a placeholder for values that may change in your code. You
must introduce, or “declare,” variables before you use them; here you are
declaring a variable called sensorValue, of type “int” (integer). Don’t forget
that variable names are case sensitive!
sensorValue=analogRead(sensorPin);
Use the analogRead() function to read the value on an analog pin.
analogRead() takes one parameter, the analog pin you want to use
(“sensorPin”), and returns a number (“sensorValue”) between 0 (0 volts)
and 1023 (3.3 volts).
delay(sensorValue);
Microcontrollers are very fast, capable of running thousands of lines of code
each second. To slow it down so that we can see what it’s doing, we’ll often
insert delays into the code. delay() counts in milliseconds; there are 1,000
ms in one second.
What You Should See
You should see the LED blink faster or slower in accordance with your
potentiometer. If it isn’t working, make sure you have assembled the circuit
correctly and verified and uploaded the code to your board, or see the
Troubleshooting section.
Troubleshooting
Sporadically Working
This is most likely due to a slightly dodgy connection with the
potentiometer’s pins. This can usually be conquered by holding the
potentiometer down or moving the potentiometer circuit somewhere else on
your breadboard.
Not Working
Make sure you haven’t accidentally connected the wiper (center pin), the
resistive element in the potentiometer, to digital pin 0 rather than analog pin
0 (the row of pins beneath the power pins).
LED Not Lighting Up
LEDs will only work in one direction. Double check your connections.
Experiment 3: Driving an RGB LED
Introduction
Page 1
4
of 6
3

You know what’s even more fun than a blinking LED? Changing colors with
one LED. In this circuit, you’ll learn how to use an RGB LED to create
unique color combinations. Depending on how bright each diode is, nearly
any color is possible!
Parts Needed
You will need the following parts:
•1x Breadboard
•1x SparkFun RedBoard
•1x Common Cathode RGB LED
•3x 330ΩResistors
•6x Jumper Wires
Didn’t Get the Tinker Kit?
If you are conducting this experiment and didn’t get the Tinker Kit, we
suggest using these parts:
SparkFun RedBoard -
Programmed with Arduin
o

DEV-12757
Breadboard - Self-Adhesive
(White)
PRT-12002
LED - RGB Clear Common
Cathode

COM-00105
Jumper Wires - Connected
6" (M/M, 20 pack)
PRT-12795
Resistor 330 Ohm 1/6 Watt
PTH - 20 pack

COM-11507
Page 1
5
of 6
3

Introducing the Red Green Blue (RGB) LED
The Red Green Blue (RGB) LED is 3 LEDs in one. The RGB has four pins
with each of the three shorter pins controlling an individual color: red, green
or blue. The longer pin of the RGB is the common ground pin. You can
create a custom colored LED by turning different colors on and off to
combine them. For example, if you turn on the red pin and green pin, the
RGB will light up as yellow.
But which pin is which color? Pick up the RGB so that the longest pin
(common ground) is aligned to the left as shown in the graphic below. The
pins are Red, Ground, Green and Blue – starting from the far left.
Note: When wiring the RGB, each colored pin still needs a current-
limiting resistor in line with the RedBoard pin that you plan to use to
control it, as with any standard LED.
Hardware Hookup
Ready to start hooking everything up? Check out the wiring diagram and
hookup table below to see how everything is connected.
Polarized
Components
Pay special attention to the component’s markings
indicating how to place it on the breadboard. Polarized
components can only be connected to a circuit in one
direction. Polarized components are highlighted with a
yellow warning triangle in the table below.

Page 1
6
of 6
3

Wiring Diagram for the Experiment
Having a hard time seeing the circuit? Click on the wiring diagram for a
closer look.
Open the Sketch
Open the Arduino IDE software on your computer. Coding in the Arduino
language will control your circuit. Open the code for Circuit 3 by accessing
the “Tinker Kit Guide Code” you downloaded and placed into your
“Examples” folder earlier.
To open the code go to: File > Examples >Tinker Kit Guide Code >
Circuit_03
You can also copy and paste the following code into the Arduino IDE. Hit
upload, and see what happens!
Page 1
7
of 6
3

/*
SparkFunTinkerKit
Examplesketch03
RGBLED
MakeanRGBLEDdisplayarainbowofcolors!
ThissketchwaswrittenbySparkFunElectronics,
withlotsofhelpfromtheArduinocommunity.
Visithttp://learn.sparkfun.com/products/2forSIKinformatio
n.
Visithttp://www.arduino.cctolearnaboutArduino.
*/
//createvariablesforpinnumbers.Wearemakingthemconstan
tshere,becausethey//neverchange.
const int RED_PIN=5;
const int GREEN_PIN=6;
const int BLUE_PIN=9;
//Howfastweplantocyclethroughcolorsinmilliseconds
int DISPLAY_TIME= 10;
void setup()
{
//setthethreepinvariablesasoutputs
pinMode(RED_PIN,OUTPUT);
pinMode(GREEN_PIN,OUTPUT);
pinMode(BLUE_PIN,OUTPUT);
}
void loop()
{
//We'vewrittenacustomfunctioncalledmainColors()thatst
eps
//throughalleightofthesecolors.We'reonly"calling"the
//functionhere(tellingittorun).Theactualfunctioncode
//isfurtherdowninthesketch.
mainColors();
}
//Here'sthemainColors()customfunctionwe'vewritten.
void mainColors()
{
//Off(allLEDsoff):
digitalWrite(RED_PIN,LOW);
digitalWrite(GREEN_PIN,LOW);
digitalWrite(BLUE_PIN,LOW);
//wait1second
delay(1000);
//Red(turnjusttheredLEDon):
digitalWrite(RED_PIN,HIGH);
digitalWrite(GREEN_PIN,LOW);
digitalWrite(BLUE_PIN,LOW);
Page 18 of 6
3

//wait1seconds
delay(1000);
//Green(turnjustthegreenLEDon):
digitalWrite(RED_PIN,LOW);
digitalWrite(GREEN_PIN,HIGH);
digitalWrite(BLUE_PIN,LOW);
//wait1second
delay(1000);
//Blue(turnjusttheblueLEDon):
digitalWrite(RED_PIN,LOW);
digitalWrite(GREEN_PIN,LOW);
digitalWrite(BLUE_PIN,HIGH);
//wait1second
delay(1000);
//Yellow(turnredandgreenon):
digitalWrite(RED_PIN,HIGH);
digitalWrite(GREEN_PIN,HIGH);
digitalWrite(BLUE_PIN,LOW);
//wait1second
delay(1000);
//Cyan(turngreenandblueon):
digitalWrite(RED_PIN,LOW);
digitalWrite(GREEN_PIN,HIGH);
digitalWrite(BLUE_PIN,HIGH);
//wait1second
delay(1000);
//Purple(turnredandblueon):
digitalWrite(RED_PIN,HIGH);
digitalWrite(GREEN_PIN,LOW);
digitalWrite(BLUE_PIN,HIGH);
//wait1second
delay(1000);
//White(turnalltheLEDson):
digitalWrite(RED_PIN,HIGH);
digitalWrite(GREEN_PIN,HIGH);
digitalWrite(BLUE_PIN,HIGH);
//wait1second
delay(1000);
}
Code to Note
for (x=0;x< 768;x++)
{}
A for() loop is used to repeat an action a set number of times across a
range, and repeatedly runs code within the brackets {}. Here the variable “x”
starts at 0, ends at 767, and increases by one each time (“x++”).
Page 1
9
of 6
3

if (x<= 255)
{}
else
{}
“If/else” statements are used to make choices in your programs. The
statement within the parentheses ( ) is evaluated; if it’s true, the code within
the first brackets { } will run. If it’s not true, the code within the second
brackets { } will run.
What You Should See
You should see your LED turn on, but this time in new, crazy colors! If it
doesn’t, make sure you have assembled the circuit correctly and verified
and uploaded the code to your board, or see the Troubleshooting section.
Troubleshooting
LED Remains Dark or Shows Incorrect Color
With the four pins of the LED so close together, it’s sometimes easy to
misplace one. Double check that each pin is where it should be.
Seeing Red
The red diode within the RGB LED may be a bit brighter than the other two.
To make your colors more balanced, use a higher ohm resistor.
Experiment 4: Driving Multiple LEDs
Introduction
Now that you’ve gotten your LED to blink on and off, it’s time to up the
stakes a little bit – by connecting six LEDs at once. We’ll also give your
RedBoard a little test by creating various lighting sequences. This
experiment is a great setup to start practicing writing your own programs
and getting a feel for the way your RedBoard works.
Along with controlling the LEDs, you’ll learn a few programming tricks that
keep your code neat and tidy!
You will need the following parts:
•1x Breadboard
•1x SparkFun RedBoard
•6x LEDs
•6x 330ΩResistors
•7x Jumper Wires
Didn’t Get the Tinker Kit?
If you are conducting this experiment and didn’t get the Tinker Kit, we
suggest using these parts:
Page 20 of 6
3