Plum Geek Robotics Ringo User manual

Ringo Educational Guide Rev04.1 ~ Plum Geek
Ringo Educational Guide

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Overview
Thank you!!
Thank you for your support in purchasing a Ringo robot. Ringo
began as a project I started with my son and daughter. We wanted
to design a robot together as a fun family project and only planned
to make a couple of them. The idea evolved into a Kickstarter campaign which
became very successful. We have been overwhelmed with the incredible community
support and encouragement we received along the way. We are very hopeful to
continue designing and producing many more robots in the future.
Your Ringo robot was assembled with love and care near Portland, Oregon. We had
most of the components sent from over seas, but we actually populate all the parts
on the board, as well as program and test right here in our own little shop. Most of
the assembly was performed by students we hired from our local Clark Community
Collage. We thank you for supporting a small business run by people of the Maker
movement, and we hope Ringo will provide you a fun learning experience and many
hours of entertainment. Cheers!
Acknowledgements
This guide will give you a quick orientation of the Ringo robot and how to program
him, but first we want to give a few acknowledgements. Ringo is Open Source
Hardware, which means his design is open to study and learn from. He wouldn’t
have been possible without others before us sharing their own open source
creations with the world.
We have produced several of Ringo’s primary systems based on open designs
from SparkFun and AdaFruit, and Ringo’s brain and programming environment
were brought to the world by Massimo Banzi and the other fine people behind
the Arduino project. Arduino has grown to become one of the most popular open
source development platforms in history thanks to the wonderful user community
which sprang up around the platform. Ringo’s motor design was inspired by the
Solar Popper robot produced by Solarbotics. Solarbotics is known for producing
BEAM robotics kits, which are robots that carry out rather complex behaviors yet
are based on very simple analog circuitry. Robotics physicist Mark Tilden is largely
credited for the creation of the BEAM robot movement. I guess what we’re saying
is that creations like Ringo are possible thanks to the open sharing of knowledge
between creative people. These fine people and many more we haven’t mentioned
have their fingerprints on Ringo as much as the people at Plum Geek.
We hope you will join us and continue in this spirit as you write
interesting software and create behaviors for Ringo that can be
shared and built upon in the community. We’re very excited to have
you along for the ride!

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Overview
Overview of Ringo’s Parts:
Power Switch: This turns Ringo on and off. Click it forward to turn Ringo ON,
click it rearward to turn Ringo OFF.
Battery: Ringo contains a 240 mAh Lithium Polymer battery, sometimes called a
“LiPo” battery. LiPo batteries are awesome for a few reasons, but they do have a
down side. If the battery is discharged too far, it becomes permanently damaged.
Lucky for you, Ringo has a part onboard called a “voltage monitor”. It’s a little
part that looks at battery voltage all the time, and if that voltage drops below 3.0
volts, it will immediate turn Ringo off, and will allow him to turn back on once the
voltage is increased by charging the battery. All this to say, you don’t have to worry
about discharging Ringo too far. He will take care of himself if he is left on or run
too long without a charge. If you notice Ringo is tending to reset on his own, it is
likely because the battery voltage is getting low. Turn him off and plug him into a
charging source for a while and he’ll be happy again.
Charging Ringo: Ringo has a self contained battery charging circuit. Whenever
he is plugged into a power source via either the Charging USB Port or the
Programming Port, he will automatically charge his battery. This happens whether
the Power Switch is turned on or off. It is okay to run Ringo while charging. The
charger will automatically turn off when Ringo’s battery is full (about
4.2 volts), so you cannot over charge him. Just plug him in and let
him handle it. Whenever Ringo is charging, the RED Charging
Indicator will be lit.
Programming Port
User Button
Reset Button
Power Switch
Charging Indicator
Charging USB Port

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Overview
Charging USB Port: The USB port present on Ringo does not allow for
programming him. However, it is useful for charging his battery. USB cables provide
a 5 volt power source which is used for charging. Feel free to plug him into a USB
power source via this port for charging without the programming adaptor. (When the
Programming Adaptor is plugged into a USB power source, it will pass this 5 volt
power along the programming cable to Ringo’s Programming Port, and Ringo will
use this source whenever available to automatically begin charging his battery).
Reset Button: This button connects to a special pin on Ringo’s brain. Whenever
pressed, it will halt Ringo’s processing, and when released, Ringo will startup fresh
from the beginning of his program. This button does the same thing as turning the
power switch off then back on.
User Button: This is a button you can use for your own purposes. Ringo can be
programmed to look at this button and determine if it is being pressed, and if it
is being pressed, to carry out some action, to change his behavior in some way,
whatever you can think of. We’ll cover the use of this button later in this guide.
Programming Port: This port connects Ringo to the Plum Geek Programming
Adaptor. It is used to load Ringo with his programming. It can also charge Ringo’s
battery when the Programming Adaptor is plugged into a USB power source.

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Overview
The Programming Adaptor is used to communicate between your computer and
Ringo’s brain. We’ll go into more detail later in the installation section, but wanted
to provide a quick overview of the programmer here.
USB Port: Connect this to your computer. This requires a USB A to Mini-B cable.
Programming Port: This connects to Ringo via the programming cable.
Tx/Rx LEDs: These LEDs blink whenever data travels between Ringo and your
computer through the programmer.
Power Jumper: This jumper connects the power supplied by your computer via
the USB Port to the Programming Port, which allows Ringo to charge through
the Programming Adaptor. Normally this should be left in place. It is however
occasionally useful to remove this jumper. As the battery in Ringo reaches its
maximum charge level, the charging circuit will continue to cycle on and off while
Ringo is running, which causes minor voltage fluctuations in Ringo’s power system.
This is okay and normal, except that while taking readings from Ringo’s sensors
(like the light sensors), you’ll see these readings spiking a lot more while charging
is allowed. In this case, it may be useful to prevent Ringo from charging while still
allowing Ringo to communicate with your computer. Remove the jumper
to suspend charging. If you do remove the jumper, place it back on
one of the pins so the little jumper connector is not lost on your
desk.
Programming Port
Power Jumper
Tx/Rx LEDs
USB Port

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Software Installation
Access the Internet
user
•••••••••
Windows
Mac OS X
Linux: 32 bit, 64 bit
N
W
S
E
NW
SW
SE
NE
arduino.cc/en/main/software
Choose the appropriate Operating System installation package for your computer.
Download Click on your appropriate computer
operating system next to the “ + ” sign.
Windows
Mac OS X
source
Linux: 32 bit, 64 bit
1
In order to program your Ringo, you’ll need to download the
newest version of the Arduino software rst from
www.arduino.cc. (it’s free!). is software, known as the
Arduino IDE, will allow you to program your Ringo to do
exactly what you want. It’s like a word processor for writing
programs. With an internet-capable computer, open up your
favorite browser and type in the following URL into the address
bar:
Install the Arduino IDE (Integrated Development Environment)
This section has been largely reproduced from the SIK Guide for the SparkFun Inventor’s Kit.

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
2Visit www.plumgeek.com and follow the instructions to install the required
driver for the programming adaptor. It is super important that you do this
before connecting the programmer to your computer.

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Software Installation
3
Connect a USB cable between your computer and the Plum Geek Programming Adaptor. en
connect the Programming Adaptor to your Ringo robot using the supplied cable.
You will require a USB A to Mini B cable (commonly supplied with digital cameras and the like).
Red Stripe on Cable
Turn switch ON before programming
(ON is toward the front, OFF is toward
the back)
This section has been largely reproduced from the SIK Guide for the SparkFun Inventor’s Kit.

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Software Installation
Connector
Ribbon Cable
Connector
Ribbon Cable
Warning! It is rather easy to attach the programming connector to the top row
of pins only which is incorrect. Please look closely as you are attaching the
programming connector to be sure it engages both the upper and lower set of
pins at the same time.
Warning! Take care to not bend the pins when handling Ringo or attaching the
programming cable.
TIP: You don’t need to press the ribbon cable all the way onto Ringo’s
programming pins. Normally it’ll work fine if pressed on only half way. This
makes the ribbon cable easier to remove and is less likely to stress the cable.
Try not to pull the ribbon cable off of Ringo by the cable - try to use the black
plastic ends if possible. This again will help reduce stresses on the cable.
This section has been largely reproduced from the SIK Guide for the SparkFun Inventor’s Kit.

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Software Installation
Open the Arduino IDE software on your computer. Look around and get to
know the interface. We aren’t going to code right away, this is just an introduc-
tion. is step is to set your IDE to identify the Plum Geek Programming
Adaptor and the attached Ringo robot.
Open the Arduino IDE:
These are the most important buttons in the IDE:
12356
7
8
9
4
1
2
3
4
5
6
8
9
7
Verify: Compiles and approves your code. It will
catch errors in syntax (like missing semi-colons or
parenthesis).
Upload: Sends your code to the attached Ringo robot.
When you click it, you should see the red lights on the
Plum Geek Programming Adaptor blink rapid. IT IS
VERY IMPORTANT TO MAKE SURE YOUR RINGO IS
SWITCH ON PRIOR TO UPLOADING.
New: This button opens up a new code window tab.
Open: This button will let you open up an existing
sketch.
Save: This saves the currently active sketch. Note, the
sketch is not saved automatically when uploading or
verifying.
Serial Monitor: This will open a window that display any
serial information your Ringo is transmitting. It is useful
for debugging.
Sketch Name Tab: This shows the name of the sketch
you are currently working on. You will often see
extra tabs here also. The extra tabs represent extra
documents that contain some of the under-lying code
used by Ringo. Normally you won’t edit these extra
tabs. If you become a more advanced user we would encourage you to look around these tabs and feel free to modify. If
you come up with better ways to write or organize these background functions please share with us. This is an area we
would appreciate help with from the user community. Thanks!
Code Area: This is the area where you compose the code for your sketch.
Message Area: This is where the IDE tells you if there were any errors in your code, or if there are errors in the process
of uploading your code to your Ringo robot.
Verify Upload Serial Monitor
This section has been largely reproduced from the SIK Guide for the SparkFun Inventor’s Kit.

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Software Installation
File EditSketchTools Help
Auto Format
Archive Sketch
Fix Encoding & Reload
Serial Monitor
Arduino Uno
Arduino Duemilanove w/ ATmega328]
Arduino Diecimila or Duemilanove w/ ATmega168
Arduino Nano w/ ATmega328
Arduino Nano w/ ATmega168
Arduino Mega 2560 or MegaADK
Arduino Mega (ATmega1280)
Arduino Mini
Arduino Mini w/ATmega168
Arduino Ethernet
Arduino Fio
Arduino BT w/ ATmega328
Arduino BT w/ATmega168
LilyPad Arduino w/ ATmega328
LilyPad Arduino w/ ATmega168
Arduino Pro or Pro Mini (5V, 16 MHz) w/ATmega328
Arduino Pro or Pro Mini (5V, 16 MHz) w/ATmega168
Arduino Pro or Pro Mini (3.3V, 8 MHz) w/ATmega328
Arduino Pro or Pro Mini (3.3V, 8 MHz) w/ATmega168
Arduino NG orolder w/ ATmega168
Arduino NG orolder w/ ATmega8
Programmer
Burn Bootloader
Board
Serial Port
ToolsHelp
Auto Format
Archive Sketch
Fix Encoding & Reload
Serial Monitor
com 1
com12
Programmer
Burn Bootloader
Board
Serial Port
ToolsHelp
Auto Format
Archive Sketch
Fix Encoding & Reload
Serial Monitor
/dev/tty.usbmodem262471
/dev/cu.usbmodem262471
/dev/tty.Bluetooth-Modem
/dev/cu.Bluetooth-Modem
/dev/tty.FireFly-7256-SPP
/dev/cu.FireFly-7256-SPP
/dev/tty.tiPhone-WirelessiAP-1
/dev/cu.tiPhone-WirelessiAP-1
/dev/tty.Bluetooth-PDA-Sync
/dev/cu.Bluetooth-PDA-Sync
Programmer
Burn Bootloader
Board
Serial Port
4
Note:
The Ringo robot and the Arduino Fio
are interchangeable but you won’t
find “Ringo” in the board list. Select
the “Arduino Fio” instead.
Select the serial device of the Ringo robot from
the Tools | Serial Port menu. On the Mac, this
should be something with /dev/tty.usbmodem
or /dev/tty.usbserial in it.
For Linux, visit the web page:
http://www.arduino.cc/playground/Learning/Linux
Select the serial device of the Ringo robot
from the Tools | Serial Port menu. is is likely
COM3 or higher. It may take a few seconds for
a new COM port to show up after connecting
the PG Programmer. If a port doesn’t show
up, try disconnecting and re-connecting the
programmer. Make sure you have installed the
FTDI drivers in the earlier step.
Select your Serial Device
This section has been largely reproduced from the SIK Guide for the SparkFun Inventor’s Kit.

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
www.plumgeek.com
5
Visit the Plum Geek website
Software Installation
Visit the plumgeek.com website. Download libraries & examples, and
install them in your Arduino folder.
This section has been largely reproduced from the SIK Guide for the SparkFun Inventor’s Kit.
In order to easily program and use your Ringo robot, you will require several library
folders, as well as a folder full of examples. You will need to place the three library
folders (RingoMsTimer2, RingoWire, and Adafruit_NeoPixel) into your Arduino/
libraries folder. You will also want to place the Ringo_Examples folder into your
Arduino/examples folder. Please see the illustrations on the following page.
Note: The Ringo libraries require Arduino IDE version 1.0.6 or later.
Note: The location of your Arduino Libraries directory may be slightly
different than the path provided below. Follow the instructions for library
installation on the Plum Geek website for known alternate directory structures
you may encounter. The library install only needs to be done once.

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Find “Arduino” in your applications
folder. Right click(ctrl +click) on
“Arduino”. Select “Show Package
Contents”.
ProgramsStartarduinolibraries
Contents
Resources
Java
libraries
Arduino
Move toTrash
Open
Show Package Contents
Unzip the le “Ringo_Libraries”.
It should be located in your
browser’s “Downloads” folder.
Right clic the zipped folder and
choose “unzip”.
Unzip the le “Ringo_Libraries”.
It should be located in your
browser’s “Downloads” folder.
Right clic the zipped folder and
choose “unzip”.
Copy the following folders (contained inside the
.zip le) into Arduino’s folder named “libraries”.
RingoMsTimer2
RingoWire
Adafruit_NeoPixel
Copy the three folders RingoMsTimer2,
RingoWire, and Adafruit_NeoPixel into
Arduino’s folder named “examples”.
Find “Arduino” in your applications
folder. Right click(ctrl +click) on
“Arduino”. Select “Show Package
Contents”.
ProgramsStartarduinoexamples
Contents
Resources
Java
examples
Arduino
Move toTrash
Open
Show Package Contents
Unzip the le “Ringo_Examples”.
It should be located in your
browser’s “Downloads” folder.
Right clic the zipped folder and
choose “unzip”.
Unzip the le “Ringo_Examples”.
It should be located in your
browser’s “Downloads” folder.
Right clic the zipped folder and
choose “unzip”.
Copy the following folder “Ringo_Examples” into
Arduino’s folder named “examples”.
Copy the three folder “Ringo_Examples”
into Arduino’s folder named “examples”.
This section has been largely reproduced from the SIK Guide for the SparkFun Inventor’s Kit.
Software Installation

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Ringo_Example FunStuff.h FunStuff Navigation.h Navigation
This is the tab you’ll do most of your work in.
Ignore these extra tabs for now.
Drop down to see hidden tabs.
Software Installation
Arduino likes to store all the files associated with a sketch in a single folder. It
then opens the main sketch (the first tab) as well as any additional files it finds
in the folder. The additional files are opened in additional tabs across the top of
the IDE window.
Don’t let these extra tabs intimidate you. For now you can largely ignore them.
These extra tabs hide the background functions used by Ringo. Rather than
install them as a library (in which case they wouldn’t appear as tabs), we’ve
included them with each sketch so more advanced users can easily study and
edit them. As you are getting started, keep all your code in the first tab, which
has the same name as the file name of the sketch you are working on.
Those more experienced with coding are encouraged to have a look at these
extra tabs. Feel free to modify or improve them as the Ringo software is a work
in progress and we welcome the user community to add features and make
improvements. There are more tabs than are visible in the window (unless you
really stretch out the window). To access the hidden tabs, use the drop down
arrow circled above.
A quick note about tabs in the Arduino IDE...

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Code Basics
Let’s cover a few basics...
I know you’re itching to make Ringo do cool stuff, so play with some
of the pre-loaded behaviors for a while. Eventually, you’ll want
to customize how Ringo behaves. For this, you’ll need to learn a
few basics about the code. This guide is not intended to be a complete course in
programming. There are lots of great resources for this (see the end of this section
for some links!) However, we’ll try our best to start you off in the right direction.
Let’s dive right in.
Below you’ll see a box containing code. We’ll use boxes like this throughout the
guide to represent code you’ll write or edit in the Arduino IDE. The important parts
of the code in a given example are highlighted in purple.
/*
Opening Heading. This area includes basic information about the program.
It is not actually loaded onto Ringo. These are just notes for the reader.
*/
#include “RingoHardware.h” //this makes the IDE include some outside
//files when loading code into Ringo
void setup(){ //the setup() function configures Ringo on startup
HardwareBegin(); //Sets all of Ringo’s I/O pins correctly
o t h e r s t u ff( ); // there may be other lines of code inside setup()
} //this closing curley bracket is the end
//of the setup() function
void loop(){ //this is where the real action happens!
commandsToDoStuff(); //functions inside the loop() function make Ringo
doMoreCoolStuff(); //do all his cool stuff. You will write most of
evenMoreFun(); //your code inside the loop() function
} //this closing curley bracket is the end
//of the loop() function

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Code Basics
thisIsCode(); //this part is a comment. This part is ignored by the compiler.
/*
This is a comment block. You can write as much as you want inside a
code block and the comment can take up many lines. You do have to end
a code block eventually with closing characters.
*/
Each sketch includes code and comments. Comments are super important because
they give human readers important notes about what’s going on in the sketch.
Comments are ignored by the Arduino IDE when it compiles the code before
sending it to Ringo’s brain. Comments can be written two ways.
A pair of forward slashes denotes everything else following them on the same line
as a comment, and thus is ignored by the compiler.
But what if your comment is going to require more than one line to write? There’s a
solution for that. You can begin a comment block with a forward slash followed by
a asterisk. Then you can write as many lines of comment as you like. You then end
the comment block with an asterisk followed by a forward slash. Here is an example
of a comment block including the starting and ending characters.
Great. Now let’s talk about the #include “somefile” line. This tells the compiler
to copy and paste the referenced file at this point in the code. It is then compiled
in as if you had actually pasted it in this place. This is a good way to include some
external files (which may be really long) at the top of your code without making
your main code window look cluttered.
You’ll learn more about include files eventually. For now, just leave the existing
#include lines in the examples and be careful not to edit or delete them. If they are
altered, the Arduino IDE may refuse to compile your code sketch.
Code! Yay! Let’s talk about the above example...

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Code Basics
Now lets talk about the void setup() function. Everything between the opening
curley brace {and the closing curley brace }of this function is run one time when
Ringo first powers up (and also after you press and release the Reset user button
on Ringo’s body). This function is useful for “setting up” Ringo’s brain for operation.
You should include a function inside setup() called HardwareBegin(); which sets
up Ringo’s brain to use the electronic parts included on Ringo’s body.
The setup() function for many of the Ringo examples is shown below.
After setup() finishes, the loop() function runs over and over again, forever (or
until you turn off or reset Ringo, or until his battery runs too low and he shuts off
automatically). The loop() function is where the bulk of you program usually lives.
void setup(){
HardwareBegin(); //initialize Ringo’s brain to work with his circuitry
PlayStartChirp(); //play startup chirp and blink eyes
delay(1000); //wait 1 second
NavigationBegin(); //startup the gyro and accelerometer
RestartTimer(); //capture start time
}
Further learning...
You’ll learn a lot as you work your way though this guide which will show you how
to use all of Ringo’s parts on a basic level. However, this guide will not teach you
all the nuances of programming. If you’d like to learn more on your own, please
check out the following links.
Learn the basics about sketches and programming technique here:
http://www.arduino.cc/en/Tutorial/Foundations
Learn the core Arduino functions. This is the “go to” reference for functions:
http://www.arduino.cc/en/Tutorial/HomePage
(continued on next page)

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Code Basics
If you look around on YouTube you’ll find lots of great explanations as well as
awesome projects people around the world have created with Arduino. Here are
a few video courses we think you’ll enjoy. Remember that Ringo is basically an
Arduino board without connecting headers - we’ve just connected the electronics
directly to the microcontroller, so many of the examples you’ll find online are still
applicable to Ringo.
Arduino Course for Absolute Beginners
https://youtu.be/QNTaQ5qjniE?list=PLYutciIGBqC2rqlBw3wVX4LjFlcjtWjGP
Tutorial Series for Arduino by Jeremy Blum
https://youtu.be/fCxzA9_kg6s?list=PLA567CE235D39FA84
If you come across any other great resources you feel would be helpful to others,
please send us a link and we’ll add them to this guide.

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Using Ringo’s Color Lights
Ringo is fitted with six color lights. They are called "RGB" lights,
which stands for "Red, Green, and Blue". Each light actually
contains three small colored lights inside. You guess it - they are
red, green, and blue. It turns out you can create any color you can
think of by mixing different amounts of these three primary colors.
Your TV screen creates colors in the same way.
The RGB Lights in Ringo were made popular by Adafruit Industries, coining the
name “NeoPixels”. We owe them a huge high-five for writing the code required to
communicate with these awesome little lights.
Each light can have each of its red, green, and blue LEDs set to any level between
0 and 255. When set to 0, the given color is off, and when set to 255, the given
color is on at max brightness. The NeoPixel lights are extremely bright, so a value
from 100 to 150 is still plenty bright.
As stated, Ringo has six of these color lights. Computers like to number things
beginning with 0. So the lights are actually numbered 0 through 5 (not 1 through 6
as you may expect). This address number of each light is printed next to it on the
circuit board for easy reference. Check out the graphics below showing each light
with its address.
2
1
5 4
3
0

1
SKILL
LEVEL Ringo Educational Guide Rev04.1 ~ Plum Geek
Using Ringo’s Color Lights
#include “RingoHardware.h”
void setup(){
HardwareBegin(); //Sets all of Ringo’s I/O pins correctly
SwitchButtonToPixels(); //set shared line to control NeoPixel lights
// (it’s okay if there is more stuff below here)
}
SetPixelRGB(address,red,green,blue); //example formatting of function
You need a few lines of code in your project to tell the Arduino IDE to compile in
the super special Adafruit NeoPixel driver software. This code is already present
in the example projects, so don’t let this part scare you. The code belongs in your
main project page above the line: void setup(){
Like this:
This include line will insert the RingoHardware.h file, which itself includes a special
line: #include <Adafruit_NeoPixel.h> By including RingoHardware.h, the IDE will
automatically include the Adafruit_NeoPixel.h file which allows Ringo to talk to his
lights.
Now we’re ready to make the lights go! You will control the lights with the function
SetPixelRGB(); Here is an example of how the function is formatted.
You’ll replace the word “address” with the address of the pixel you want to adjust.
Remember this is a number between 0 and 5. Then you’ll place a number between
0 and 255 in place of the words “red”, “green”, and “blue”. The number you use will
correspond to how bright or dim each of the three colors are.
A few setup steps...
Time for fun! Let’s Do This!