Intel Galileo Installation instructions

Hardware Guide
For Intel Galileo
1
2
3
4
5
6
7
8
9
10
inches

2
Contents
Hardware Guide
Make your Galileo Blink3
Make your Galileo Blink Some More   10
Using Inputs 13
Using Motors22
Guide to Debugging31

Hardware 3
Hardware
1.1: Overview
The Intel Galileo is a microcontroller which is a small computer that is meant to control other electron-
ics. A computer is something you can program to do math or logical sequences. Programming is just
how you tell a computer what to do. You can tell your computer “make a game” but it won’t know what that
means. You have to go through and tell the computer what to do in a language the computer understands
and give it step-by-step instructions.
But, if you learn how to program, you can make your microcontroller do all kinds of things. People have made
robots, cool lighting projects, and much more, do a search for ‘arduino projects’ and you’ll see all kinds of
cool things. (Arduino is another example of a microcontroller that is used commonly. There are a lot of open
source codes and resources available for Arduinos and you can use many of them with your Galileo!)
Learning programming is like learning a new language, however, you have to start simple. This activity is a
rst start. We will make a light blink on and o on your microcontroller board.
1.2: Installing / Setting Up
Follow these three sections to properly install your Galileo and have it communicate with your computer:
• Installing Software
• Driver Installation
• Firmware
Now you are ready to get started!
At this point, plug your Galileo into a power source (Lesson 1, Figure 1), the power light should turn on. Wait a
few seconds and the light labeled “usb” will turn on. Once it is turned on, connect the Galileo to the computer
using a micro usb cable. Make sure you connect the power before connecting the USB cable.
1: Make your Galileo Blink
Lesson 1 Figure 1

Hardware 4
Hardware
In order to program your Galileo, we are going to use the Arduino program (which can also communicate
with your Galileo board). Open the Arduino program. On the top bar go to tools -> board and select Intel Gali-
leo (Gen 2 if you are using Gen 2), this tells your computer what type of microcontroller you are using. Then,
go to tools -> serial port and make sure something is selected.
Lesson 1 Figure 2
1.3: Basic Programming Structure
Now that your Galileo and computer are ready to go, we can start thinking about programming. The Arduino
program is something called an IDE or Interactive Development Environment. It is a software that
is meant to help you program. Interactive means that you, the user, can interact or use it. Develop-
ment is a word which can mean ‘to program’. The Environment means the stu around your program
which can help you. The IDE oers an easier way to connect to the Galileo, highlighting, example codes
(Under le->examples) and a lot of other nice things. For our Galileo, we are going to use Arduino IDE. Lets
get started!
When you opened this program you should see the following code already written for you:
voidsetup(){
//putyoursetupcodehere,torunonce:
}
voidloop(){
//putyourmaincodehere,torunrepeatedly:

}

Hardware 5
Hardware
These are two functions that are the basic structure of Arduino programming. A function is a piece of code
that does something.
The rst function is ‘setup’. The word “void” before it just tells you that it doesn’t return anything or give
something back. The ‘setup’ function is what the microcontroller knows to do rst. Anything you put in be-
tween the rst two brackets{} will be done rst.
The second function is ‘loop’. It also doesn’t return anything. Theloop function happens right afterset-
up, and runs over and over, until you reset the microcontroller or load a new program.
Without you telling the microcontroller to do something dierent, it will run:
setup
loop
loop
loop
loop
...
That’s how the microcontroller works. If you program something else, it might be dierent.
The sentences that are after the two forward slashes (//) are called comments. They are used by the
programmer to remember what they were doing. The microcontroller completely ignores anything after the
two slashes on the same line. It is always good practice to comment in your code, because it is often hard
to remember what you were doing, or other people might need to look at your code and gure out what you
were trying to do.
1.4: Using pinMode
The program that opens up when you start the IDE automatically doesn’t do anything. You, the programmer,
has to type something to make things happen. For this example, we want to tell the Galileo to blink the light
emitting diode (LED) that it has on board (Lesson 1, Figure 3).
Lesson 1 Figure 3

Hardware 6
Hardware
Before you start programming, you have to know a few things. The Galileo is not very smart, you have
to type very carefully for it to understand what you want it to do. It has trouble with capitalization, as in it
knows what the word ‘OUTPUT’ means, but not the word ‘Output’. It also needs every bracket to match, ev-
ery ‘{‘ needs to have a ‘}’ somewhere. Every line of code inside a function needs to end with a semicolon
(‘;’), or else the Galileo won’t know where the line ends. Look a the Guide to Debugging for information
on how to avoid and resolve these syntax errors.
The microcontroller interacts with the world by using “pins”, (Lesson 1 Figure 4) which are the slots labeled
1, 2, 3, … ,A0, A1, A2,... those are spots where the microcontroller can turn on and o power to, and can read
information from.
Lesson 1 Figure 4
The built-in LED is attached to pin 13. We are going to be outputting to that pin, in other words we are writ-
ing to that pin.
The way we tell the microcontroller to use Pin 13, the LED, as an output is using a function called “pin-
Mode”. It is used like this:
pinMode(13,OUTPUT);
pinMode is the function name. It means that you should assign some pin a certain mode.
‘13’ and ‘OUTPUT’ are arguments. They are numbers/words/characters that give the function some in-
formation about what it is going to do. They are separated by a comma, so the microcontroller knows when
one argument stops, and another begins. They are surrounded by parentheses, which tells the microcon-
troller that this is a function, and what things are the arguments.
13 is the pin number, it can be whatever number pin you want to use. OUTPUT tells the microcontroller
what you are going to do with the pin. It has to be in all caps, or the microcontroller won’t know what it is.
The line ends with a semicolon (;), which tells the microcontroller that this line of code is over.

Hardware 7
Hardware
Notice that I wrote a comment after the code I wrote. This helps me know what I was doing when I wrote it,
and it makes it easier to come back to the program.
At this point it is a good idea to check for mistakes. A quick way to do that is press the “verify” button
which is the checkmark in the upper left-hand corner. This checks your code and sees if there are any very
large mistakes. Those errors will show up in the bottom console screen, where it will let you know if there is
anything wrong. Since you’ve only wrote one line of code, the problem is most likely there.
After making sure there aren’t any errors, try to make a few errors. See what shows up in the bottom black
window if you change something around (Lesson 1 Figure 5). Then go back to the working code.
You only need to tell the microcontroller the pin’s mode once, so it should go in your setup function.
Your code should now look like this:
voidsetup(){
//putyoursetupcodehere,torunonce:
pinMode(13,OUTPUT);
//setpin13tooutput,pin13isthebuilt-in
led
}
voidloop(){
//putyourmaincodehere,torunrepeatedly:

}
Lesson 1 Figure 5

Hardware 8
Hardware
1.5: Using digitalWrite
Okay, so our program still doesn’t actually do anything. (So far, we have only ‘setup the pin’.) We need to tell
the microcontroller to actually interact with the LED. A way to do this is a function “digitalWrite”.
The word ‘digital’, in computers, means it can be on or o, low or high, 1 or 0. There are no in betweens
(later you’ll see analogWrite, which has in-between values). ‘Writing’ is computer-speak for output-
ting, or making something do something.
Here’s how digitalWrite might look:
digitalWrite(13,HIGH);
digitalWrite is the function name.
‘13’ is the pin number
‘HIGH’ is the output, which usually means to turn that pin on. The other option is ‘LOW’, which means to turn
the pin o.
Again, we have similar parentheses, commas and semi-colons.
Our overall goal is to get the LED to turn on and o repeatedly so this will go in our “loop” function.
voidsetup(){
//putyoursetupcodehere,torunonce:
pinMode(13,OUTPUT);
//setpin13tooutput,pin13isthebuilt-in
LED
}
voidloop(){
//putyourmaincodehere,torunrepeatedly:
 digitalWrite(13,HIGH);//turnontheled
}
This is another good time to verify our program. As you get more experience, you can write more without
having to check, but it can get harder to gure out where errors come from.
After making sure the program is correct, we can upload, which is the arrow button next to verify. The
“upload” button moves the program onto the Galileo, from your computer, so that the microcontroller actu-
ally does something.
Some things may blink on the microcontroller as it is uploading, but you should see “upload complete” in
the bottom black window and your LED should turn on.

Hardware 9
Hardware
1.6: Using delay
We want our microcontroller to blink, but right now it just stays on. We have to tell the microcontroller to
turn on and o. But, we have to leave some time in between so that we can actually see the blinking.
One way to do this is to use the “delay” function. Delay means to wait, or to stop for a time. You use it like
this:
delay(500);
The arguments for delay are the time in milliseconds (1/1000th of a second) that you want to wait for. I’m
telling it to wait 500 milliseconds, or half of a second.
In our program we want to turn on the LED, then wait, then turn it o, then wait. This means our program
will look like this:
voidsetup(){
//putyoursetupcodehere,torunonce:
pinMode(13,OUTPUT);
//setpin13tooutput,pin13isthebuilt-in
led
}
voidloop(){
//putyourmaincodehere,torunrepeatedly:
digitalWrite(13,HIGH);//turnontheled
delay(500);//wait
digitalWrite(13,LOW);//turnotheled
delay(500);//wait
}
Now we can try verifying again. If there are errors try putting slashes before a line, making it a comment,
and verifying again. If the error goes away, you know it was in the line you commented out, otherwise you
can look at other lines.
We can upload again. If everything is correct, you should see your microcontroller’s LED blinking once a
second. (Refer to Lesson 1 Figure 3)
Try changing things around in the program, such as the blinking time. See what works, and what doesn’t.
(You can also look at the program under le->examples->01.Basics->Blink.

Hardware 10
Hardware
2.1: External Outputs
When using a Galileo, the chip itself doesn’t have a lot ways to interact with the outside world. In order to
make your Galileo do some more interesting things, you have to be able to connect external outputs.
‘External’ means it is separate from the microcontroller. The opposite word is ‘internal’. In the previous
lesson, you made the ‘internal’ LED (on the physical Galileo board) blink.
‘Output’ is something that the microcontroller can tell to do something. You can see an output light up,
move, or do something else. Outputs include motors, LEDs, and light bulbs. It is the opposite of an input,
which tells the microcontroller information based upon something in the outside world.
2.2: Connecting an LED
We have made an onboard (internal) LED light on and o on our Galileo, but now we have to start going ‘o
the board’. This means we have to provide a path from the microcontroller to the external LED and back. If we
were going to move cars back and forth, we would build a road. If we were moving water, we would make a
pipe. We are moving electricity so we need a path made of metal, which electricity can travel across. Metal
is a great conductor like you learned in Circuitry Lessons.
An easy way to connect electronic components is to use rubber-coated electrical wire. The
rubber prevents electricity going in a way we don’t expect. And the metal wire conducts
electricity across it.
To connect things we rst have to take a piece of wire, however long makes sense to you, and remove the
rubber from the ends of both sides. Take o enough to work with easily. This is called “stripping the wire”.
We are going to use the Blink program again (If you lost it or don’t have it, open le->examples->01. Basic-
>Blink). This program communicates through pin 13. That means we have to insert our wire into pin 13 (Lesson
2, Figure 1).
2: Make your Galileo Blink Some More
Lesson 2 Figure 1
metalwires
rubber