Arduino IDE and Wiring Language

  • Manoel Carlos Ramon
Open Access


This chapter is an introduction to Arduino and its development environment. If you already have your IDE installed, know how to update the firmware using the IDE, understand the wiring libraries, know how to communicate with native Linux programs, and don’t have any problem with your development environment, this chapter is not for you and you should move to the next one.


Light Emit Diode Virtual Machine Duty Cycle Pulse Width Modulation Python Script 

This chapter is an introduction to Arduino and its development environment. If you already have your IDE installed, know how to update the firmware using the IDE, understand the wiring libraries, know how to communicate with native Linux programs, and don’t have any problem with your development environment, this chapter is not for you and you should move to the next one.

Arduino provides a cross-platform integrated development environment (IDE) based in Java and built to support different Arduino boards. It contains multiple code examples, a debug serial console, and is open source. With the IDE you can create your programs called sketches. You can download to Intel Galileo, run the sketches, and debug them using the serial console that’s integrated with the IDE.

Intel provides a special Arduino IDE release specific for Galileo boards that includes a firmware update, new APIs, and customization of existing libraries.

This chapter explains how to install Intel Galileo Arduino IDE on Mac, Linux, and Windows OS, covers the new functionalities added in the IDE, and explains how to solve any issues when you run the IDE on virtual machines.

This chapter also discusses how the Arduino framework works on top of embedded Linux OS and includes some basic examples to show how the Arduino libraries can be used for those who have never used Arduino before.

You’ll also develop a simple project that integrates POSIX calls and a Python script and create an alarm for unread Gmail emails in your inbox.

A Little Bit of History

You’ll often hear terms like “Arduino wiring language” or “Arduino language” and you might think Arduino has a special programming language.

In fact, the language used to program the Intel Galileo using the Arduino IDE is C/C++, so there is no real “wiring language” for Arduino.

In 2003, a student named Hernando Barragan created a hardware thesis describing an IDE and the integration with circuit boards powered by microcontrollers. With contributions from other researches the concept evolved allowing developers to write just a few lines of code in order to reproduce simple connections of hardware components. This allowed interactions such as turning on an LED, receiving events from buttons, emitting sounds, and so on.

Thus, even if the language used in IDE is C/C++, the IDE can provide APIs that enable that wiring, and the code is simple and based on how the electronics components are connected to the circuit.

The Intel Makers Community

If you have questions about Arduino IDE for Intel Galileo, or if you have ideas and projects to discuss, you can count on the maker community created by Intel at .

There are several forums that discuss the Arduino wiring libraries and project ideas and one of the best is .

It is very important to be involved with the community, because developers are always helping each other to solve unexpected problems, providing tutorials, and discussing great projects.

Installing the Arduino IDE for Intel Galileo

There are two locations where you can download the Arduino IDE for Intel Galileo:
You need to search for “Arduino IDE for Intel Galileo” and click the link provided. You will be redirected to the Intel web site.

Choose the best link for you and add the bookmark to your browser so you can easily update the IDE with subsequent releases.

You need to download the “Getting Started Guide” and the correct IDE according to the OS installed on your machine. Intel offers versions for Windows, MacOSX, and 32- and 64-bit Linux. It’s best to read the guide before you try to install.

Figure 3-1 shows the link to the “Getting Start Guide.”
Figure 3-1.

Location of the “Getting Started Guide”

The installation is usually very straightforward:
  • Windows: Just unzip the zip file using 7-zip, preferably to C:\. Open the folder that’s extracted and execute the arduino.exe file.

  • Linux 32/64 bits: Extract the tarball zipped file to a new directory and execute the ./arduino. Use the following command with the appropriate file name:

tgz file: tar –xvzf < filename >.tgz

  • MacOSX : Drag and drop the file into the /Applications folder to install the IDE. Launch it by double-clicking Arduino in the Applications folder.

There are different procedures you should check, depending on the OS you’re using, including if the gadget driver was properly installed, as well as several other details documented in the “Getting Started Guide” that don’t make sense to reproduce here.

A few things you need to know:
  • Windows: Never use Winzip! You should use the 7-zip tools (see ) because the cross-compiler used for Quark has long path names and several sub-directories. Winzip cannot handle these path names, which causes errors during the extraction.

  • When zip fails in Linux: If you are a Linux developer and the unzip command fails to extract the package, you can install 7-zip with the command sudo apt-get install p7zip- full for Ubuntu and Debian distributions or you can download the command-line tool from


Connecting Intel Galileo

There are two important rules regarding the board connection to your computer:
  • Check Figure 3-2 (left) if you have a Intel Galileo Generation 1. Always connect the 5V power supply (1) before the USB cable on client port (2) to avoid hardware damages.

  • Check Figure 3-2 (right) if you have a Intel Galileo Generation 2. Always connect the power supply (1) before the USB cable on client port (2) to avoid hardware damages. Remember, the Intel Galileo Gen 2 power supply must be between 7V and 12V DC. You cannot use 5V DC.

  • Always keep the power supply connected to Intel Galileo when transferring sketches or updating the firmware of your board. Developers are tempted to use the USB Client Port because it can boot the board and run the sketches but the 5V power supply is really recommended to keep connected in all occasions and to avoid hardware instability.

Figure 3-2.

Intel Galileo Generation 1 (left) and Intel Galileo Generation 2 (right)

Wait about 35 seconds and the Gadget Serial driver should be available.

Installing the Drivers and the Arduino IDE

Refer to the “Getting Started Guide” ( ) for the latest instructions on how to install the serial driver and Arduino IDE. For your convenience, a version of the steps is provided here as well.

Installing the Arduino IDE

For most OSs, the installation process is very simple. For Windows, though, there is a small detail regarding the installation.

Installing the IDE on Windows

When you download the files for Windows you will see that, according to the version of IDE you are using, the extension is either .7z or .zip.

Never use the WinZip tool because the toolchain that contains the cross-compiler, has files with long path names and WinZip is not able to decompress them.

Thus, for Windows it’s better to use a free tool called 7-zip, which you can download from . This web site contains the installers for downloading. It is very simple to install; just follow the recommendations on the site. You then simply extract the zip file on any directory using the 7-zip tool.

The current “Getting Started” guide (released December 23, 2013) says that it is necessary to extract the files to C:\, but this is wrong. You are free to install anywhere.

Installing the IDE on Linux

To install the IDE on Linux machines, follow the steps:
  1. 1.

    Open a terminal shell of your preference. If you are using Ubuntu, you can press Ctrl+Shift+T to open a terminal shell.

  2. 2.

    In your home directory, extract the package with the appropriate command:


tar -zxvf arduino-1.5.3-linux32.tar.gz


tar -zxvf arduino-1.5.3-linux64.tar.gz

for 32 or 64 bits, respectively.
  1. 3.

    Some Linux distributions include a package called “modem manager” that can affect the serial port communication. You should remove this package from your distribution. If you are using Ubuntu or Debian, you can remove this package by typing this command in the terminal shell:


sudo apt-get remove modemmanager

  1. 4.

    In the same directory where the package was downloaded, launch the Arduino IDE by executing the following:



If you execute the IDE and you can’t select the serial ports (see the section entitled “Checking the Port and Board Selected”), you did not execute the program with the appropriate access. If you are using Debian or Ubuntu, you have two ways to resolve the problem. You can use the following commands:

sudo arduino


sudo chmod 755 /dev/ttACM[X]

where [X] is the number of port enumerated in your machine, such as /dev/ttyACM0.

Installing the IDE on MacOS

To install the IDE on MacOS, follow these steps:
  1. 1.

    Download the zip file on the Mac hard drive and unzip it.

  2. 2.

    Drag and drop the Arduino application into the Applications folder on your Mac.


Installing the Drivers

The Intel Galileo boards use the gadget serial drivers called “Galileo” only.

The most problematic installation process with this serial gadget driver is in Windows. If you are a Windows user and you have problems communicating with the serial interface on your IDE, read the section entitled “Serial Communication Issues with IDE on Windows.”

The Common Step to Install the Driver

Before starting the driver installation, follow the steps recommended in the section entitled “Installing the Arduino IDE,” power on your Intel Galileo board, and then connect the USB cables as described in the “Connecting the Intel Galileo” section. This is the first and common step with all operation systems. You can then jump to the section that represents the operation system you are using.

Installing the Driver on Windows

  1. 1.

    Once the power and USB cables are connected, wait a few seconds and open the Device Manager by clicking on the Start menu. Open the Control Panel and then click on System. Once the System window is open, open the Device Manager.

  2. 2.

    Look under Ports (COM & LPT). You should see an open port named “Gadget Serial V2.4” if you using an old release like 0.7.5 or simply “Galileo” in newer releases. Figure 3-3 shows the serial driver.

Figure 3-3.

Galileo serial driver in Windows the Control Panel

If you do not see this open port, read the section called “Serial Communication Issues with IDE on Windows.”
  1. 3.

    Right-click on the Gadget Serial V2.4 port and choose the Update Driver Software option.

  2. 4.

    Choose the Browse My Computer for Driver Software Option.

  3. 5.

    Based in the location you extracted your IDE, navigate to the hardware/arduino/x86/tools directory. This allows the proper driver file called linux-cdc-acm.inf to be installed.

  4. 6.

    Once the driver is successfully installed, Device Manager will show a Galileo (COMx) device under Ports (COM & LPT). Note the COMx port number, as it will be needed in the IDE later. The example in this chapter shows COM5.


Installing the Driver on Linux

  1. 1.

    Check if an ACM port is available. If you are using Ubuntu, you can press Ctrl+Shift+T to open a terminal shell. Then type the following in the terminal:


ls /dev/ttyACM*

  1. 2.
    You should be able to see at least one serial port like ttyACM0 or any other ttyACM[X], where [X] represents an integer number. If you cannot see a serial port, follow these steps:
    1. a.

      Create a file called /etc/udev/rules.d/50-arduino.rules and add the following:


KERNEL=="ttyACM[0-9]*", MODE="0666"

  1. b.

    Restart the udev service with the following command:


sudo service udev restart

  1. 3.

    If you are using a virtual machine (VM), you may need to reboot Linux within the VM.


Installing the Driver on MacOS

Check the System Profiler ➤ USB setting to be sure that Gadget Serial is selected. If you are installing a new version of the IDE, you may need to re-select this setting.

Understanding the Arduino IDE

Once Intel Galileo is connected to your computer and you have the drivers properly set up, execute the IDE to access the window shown in Figure 3-4. Table 3-1 provides a description of each numbered item.

Explore the IDE a little bit by opening the example discussed at the beginning of this chapter and then selecting File ➤ Examples ➤ 01.Basic ➤ Blink.
Figure 3-4.

Arduino IDE graphical interface

Table 3-1.

Descriptions of Callouts in Figure 3-4




Area code where you develop the code.


Notification bar informing you if the code was saved and whether the compilation was successful.


Console message with details of compilation, file transfer messages, and error messages.








Informs the line number of the cursor in the editor. Verify icon: compile the code.

Transfer icon: compile the code and transfer to Intel Galileo.

Open a new sketch.

Open a sketch.

Save the edited sketch.

Open the serial debug console.

Checking the Port and Board Selected

Before you run the sketch, you need to check a couple of things in the IDE. First of all, make sure you selected the right board by choosing Tools ➤ Board, as shown in Figure 3-5.

Note that the port name varies according to the operational system:
  • Windows: The ports are named with the COM prefix, followed by an integer number, such as COM5.

  • Linux: The ports are named with the ttyACM prefix, followed by an integer number, such as ttyACM0.

  • MacOS: The ports are named with the /dev/cu.usbmodem prefix, followed by a sequence of numbers and/or alphabetic characters, such as /dev/cu.usbmodem0001 or /dev/cu.usbmodemfd021.

Figure 3-5.

Selecting the board

If you are installing to a MacOS, do not select ports preceded by /dev/tty, because although these ports have the same nomenclature used on Linux machines, they are not the right ones.

You also need to check the serial port that communicates with Intel Galileo. Do this by selecting Tools ➤ Serial Port, as shown in Figure 3-6.
Figure 3-6.

Selecting the right serial port

What Is a Sketch?

Before you run the first code, you need to know the meaning of the word “sketch” that’s regularly used in the Arduino development. When you develop code using the Arduino reference API and its libraries, you’ve created a sketch.

In order to understand how a sketch works, consider the Blink example mentioned in the previous section.



  Turns on an LED on for one second, then off for one second, repeatedly.

  This example code is in the public domain.


// Pin 13 has an LED connected on most Arduino boards.

// give it a name:

int led = 13 ;

// the setup routine runs once when you press reset:

void setup() {

  // initialize the digital pin as an output.

  pinMode(led, OUTPUT);


// the loop routine runs over and over again forever:

void loop() {

  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)

  delay(1000);               // wait for a second

  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW

  delay(1000);               // wait for a second


The sketch is composed by two main functions: setup() and loop().

The setup() function is executed one time, and this function establishes the initial setup of your hardware, including the pin directions, the speed of the serial ports, device initializations, and so on.

The loop() function is cyclic, which means it works like an infinite loop. It is on this function that you control your hardware.

As mentioned, the code is very close to how the hardware components are connected. For example, the previous code shows that:
  • There is an LED connected to pin number 13.

  • In the setup() function, the pin is configured as OUTPUT by the pinMode() function.

  • In the loop() function, the LED will be turned ON for one second and then turned OFF for one second again. The LED is turned on and off when the digitalWrite() function sets the pin to HIGH and LOW, respectively and the delay of one second is set by the delay() function, which received the number of milliseconds as an argument.

Looking to the code you can imagine there is an LED on pin 13 and you also can easily understand what the code does. Note that there is no assembler language involved and even with the code being compiled in C++, there are no complex function calls to access the GPIO, which makes the development easier.

The next section discusses how to run this sketch.

Compiling and Running the Sketch

Click the icon represented by the number 5 in Figure 3-4, select Sketch ➤ Verify/Compile from the menu bar, or press Control+R.

The concept of “verify” on Arduino IDE really means compile the code. That should report " Done compiling " in the area represented by the number 2 in Figure 3-3.

Do not be worried if the compilation takes a long time—the first compilation is always slow. The cross-compilers are installed during the first compilation in order to provide a transparent mechanism to the developers. After the install, the cross-compiler is related to the compilation of the wiring API to generate the object files. After the first compilation, all subsequent compilations will be faster.

Click the icon represented by the number 6 shown in Figure 3-4 to upload the file. If the transfer is successful, you should see the "Done uploading" message in the notification bar and the "Transfer complete" message in the console message area. These messages are represented by the numbers 2 and 3, respectively, in Figure 3-4.

You should see an LED blinking on Intel Galileo. This LED is connected internally to pin number 13, thus proving your system is properly configured and you are ready to explore the IDE. If you are using the first Intel Galileo release, this LED is close to the BATT terminal, as shown in Figure 3-7.
Figure 3-7.

Built-in LED connected to pin 13 on Intel Galileo

The blink example is similar to the “HELLO WORLD!” example you see in other programming environments, which is used to test if the development environment is working properly.

Persisted and Not Persisted Sketches

Intel Galileo can boot from SPI flash (SPI releases) or from an SD card. You can download both releases from the same web page where you downloaded the IDE.

Due to SPI flash part being very small (8MB), SPI flash releases contain only the very basic features. In order to take advantage of more advanced software, such as Python, WiFi capability, Node.js, OpenCV, V4L2, and other features, you have to use the SD card release.

The SD card releases contain all those features, plus the capability to persist the sketches.

If you have plans to keep your sketches after the system reboots, you need to use the SD card releases. Otherwise, when Intel Galileo reboots, the sketch will not run because it was not persisted.

Persisted Sketches and Long Time to Start

Intel Galileo is different from other Arduino boards because everything is controlled by the Quark SoC that runs Linux instead of by a simple microcontroller like the Atmel processors used in Arduino Uno, Due, Nano, and other boards.

Those microcontrollers do not have an OS, but they access a memory segment and execute specific opcodes to run the program.

Thus, the persisted sketches on Intel Galileo are executed only when Linux boots, all modules are loaded, and the user space is ready. This process takes around 50 seconds. The next section explains how to debug the sketches.

Debugging with Serial Console and Serial Communication

The Arduino reference API contains a serial terminal that’s used to print debug messages from the sketches. This causes the Arduino boards to transmit messages to your computer using the Arduino IDE serial console.

The communication occurs using a static class called Serial; however, if you need to communicate with external devices like XBee shields, you should use the 0 and 1 pins to connect to such devices. The communication in this case is done by a different object but with same class methods, called Serial1. Arduino Uno uses the Serial object to establish communication with the 0 and 1 pins, so if you are porting some sketch code created for Arduino Uno as the serial interface, you need to change the object from Serial to Serial1.

There are five Serial object methods used to establish a communication and transmit messages: begin(), print(), println(), available(), and read().

Serial.begin(int speed)

The speed argument indicates baud rate. The values typically are 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, and 115200.

If you are using the Serial object for debugging messages, this argument is irrelevant because the communication with Serial object is always 115200 bauds. If you set it to a different speed like 9600 bauds, the communication will still be 115200.

There is no impact on the development cycle. This was done because most of the Arduino examples were created for Atmel microcontrollers, and they have the sketches with the speed set to 9600 bauds by default. Trying to reduce the code changes and make the developer’s life easier, it is not necessary to change the baud rate to 115200 on each example provided by IDE.

But with other objects like Serial1, which uses pins 0 and 1, speed really does have an effect in the communication because this object was created to communicate with external devices.

Note that this method must be called before any serial method—before you transmit or receive data, you must call this method.


This method transmits the data argument through the serial port. The data argument might be a string, an integer, a char, a byte, a long, or any other standard type supported in the Arduino reference.


This has the same functionality of Serial.print() method except a carrier and return is added to the end of the data message.

Serial.available( )

Informs you if there is any data in the receiver buffer. It returns an integer representing the quantity of bytes in the receiving buffer that are ready to be read. )

Reads from the receiver buffer any available data. It’s best to use this method only after you check for data using the available() method.

The data read might be a simple integer, a single character, an array of characters, a string, or any serialized object.

The next example shows you how to use such Serial objects and how to invoke the serial console terminal.

Printing Debug Messages and Using the Serial Console

This section sketches the print messages on the serial console and transmits messages from IDE to Intel Galileo, as shown in Listing 3-1.

Listing 3-1. serialtest.ino

String inputString = "";         // a string to hold incoming data

boolean stringComplete = false;  // whether the string is complete

void setup() {

  // put your setup code here, to run once:

   Serial.begin (9600);  // does not matter for this object



void loop() {

  // transmitting something from Galileo to IDE

  Serial.println("Hi there!! type something and press SEND button!!! ");


  // if the developer sent something from IDE to Galileo

  while ( Serial.available()) {

    // get the new byte:

    char inChar = (char);

    // add it to the inputString:

    inputString += inChar;

    if (inChar == '\n' ) {

      stringComplete = true;



  if (stringComplete == true) {

    Serial.print ("\nCOOL!! RECEIVED YOUR MESSAGE: ");

    Serial.println (inputString);

    inputString = "";




Upload the board with this sketch and access the serial console.

The Serial console can be accessed if you click Tools ➤ Serial Monitor, press Ctrl+Shift+M, or click the #10 icon highlighted in Figure 3-4.

You’ll then see something similar to Figure 3-8.
Figure 3-8.

Arduino IDE serial monitor console

Note in the right-bottom corner there is the baud rate used in the communication (115200). You can also see the messages being displayed. At the top of the screen, there’s a text box followed by a Send button. This is used to transmit data from your computer to the Intel Galileo board.

Also in Figure 3-8, considering the code is detecting the newline "\n" character, it is necessary to change the list box in the right-bottom corner to Both NL & CR. That means both newline and carriage return characters.

Just type some text using the text box on the left of Send button and press this button or click the Enter key at the end of your message.

Intel Galileo will receive the message you typed and display it in the serial console for you. To understand how this “magic” happens, read the next section.

Understanding the serialtest.ino Code

In the setup() function, the serial object is initiated with 9600 bauds by Serial.begin(). This is irrelevant as explained before because the communication is always 115200 bauds for Serial.

Also in setup(), there is a delay of three seconds to give you time to access the serial monitor. For Intel Galileo, if you are creating sketches that immediately print something, it is recommended that you add a small delay; otherwise, you can miss some messages (Galileo is faster than you).

In the loop() function, there is a message being printed by Serial.println() followed by Serial.available() that will always return false if you do not type anything in the text box and press the Send button in the serial console.

If you send a message to the board, the Serial.available() will return true. Each character of your message will be read by and accumulated in the variable inputString until the newline character (\n) is encountered (this character is automatically added when you press the Send button or press Enter).

If the message is completed after it detects the newline feed character, the message that’s received is transmitted back using Serial.print() in the while loop block contained by Serial.available().

A message printed by Serial.print() and Serial.println() that asks to the user to transmit something is added to the end of the loop() function. There is a delay of 1000ms (1 second) initiated by the delay() function to avoid multiples messages running in the serial console.

The Arduino Language Reference and APIs

If you read this chapter from the beginning, you are already familiar with some references, including:
  • Structure: loop() and setup()

  • Digital I/0: pinMode() and digitalWrite()

  • Time: delay()

  • Communication: Serial.begin(), Serial.print(), Serial.println(), Serial.available(), and

These are only a small part of Arduino reference API. You can find the complete Arduino reference at , as shown in Figure 3-9.
Figure 3-9.

Arduino reference page

Let’s organize the most important and most commonly used functions by category: Structure, Digital I/O, Analog I/O, and Time.

Remember that there are several functions and data types in the Arduino reference web page and the functions mentioned on this chapter are just the most common ones. An entire book could be devoted just to the Arduino reference, which is not the intention of this book.


Each sketch has two mandatory functions—setup() and loop(). Even if your sketch doesn’t need these functions, you should at least keep them empty in your sketch to avoid compilations. Each of these items is discussed next.

setup( )

As mentioned, this function is called just once. It is the first function called during sketch execution and it is used to set up the pins manually as well as initialize the serial ports and external devices.

loop( )

This function was also discussed before. This function is called like a infinite loop while the sketch is executed and is basically responsible for the main state machine of the hardware.

Digital I/O

The digital I/O are related to pins 0 to 13 in the Intel Galileo headers, as explained in the section called “Arduino Headers on Intel Galileo” in  Chapter 1. The following functions manage the digital I/Os.

pinMode(int pin, int mode)

This function is normally used in the setup() function and sets the “pin” that means the pin number to a specific “mode,” which can be INPUT, OUTPUT, or INPUT_PULLUP.

If mode is INPUT, the pin is used as INPUT; for example, to read the state of a button.

If mode is OUTPUT, the pin is used as OUTPUT; for example, to turn on/off an LED.

Note that if mode is set to INPUT_PULLUP and the pullup resistor is around 20k ohms, that means if you use a pulldown resistor the logic will be inverted. If no pulldown resistor is used, the reading still will be 1 if you have 5 to 3.3V or 0 if it’s connected to the ground.

digitalWrite(int pin, int state)

This function sets the pin state according to the state argument that’s passed, which can be HIGH or LOW. It works only if pin was set as OUTPUT by the pinMode() function.

int digitalRead(int pin)

This reads the state of the pin number and returns HIGH or LOW (both are integers).

Analog I/O

The analog I/O are related to pins A0 to A5 in the Intel Galileo headers, as explained in the section called “Arduino Headers on Intel Galileo” in  Chapter 1. Remember that the AREF is unused on Intel Galileo boards so external references for analog input are not supported.

The following functions are used to manage the analog I/Os.

int analogRead(int pin)

This function reads the analog specified by pin that can assume the values A0 to A5, according to the six analog ports supported by Intel Galileo. The value returned is an integer between 0 and 1023 and refers to the scale of 0 to 5V, respectively. Intel Galileo has 12-bit maximum resolution in the ADC. Figure 3-10 shows the analog ports on the Intel Galileo board.
Figure 3-10.

Analog port A0 to A5

analogWrite(int pin, int value)—PWM

This function generates pulse width modulation (PWM) to control servos, create fading effects on LEDS, control DC motors, and so on.

The pin argument specifies which PIN must generate the PWM with a duty cycle set by value.

The PINs that can be set to use PWN on Intel Galileo are 3, 5, 6, 9, 10, and 11. You also can easily identify such pins because there is a small tilde () in front of the pins that support PWM, as shown in Figure 3-11.

The value must be an integer between 0 and 255, and this range is proportional to the percentage of 0% to 100% of the duty cycle to be generated. Thus, if the value is 0, the duty cycle is zero. 127 will generate a PWM with 50% of duty cycle and 255 a duty cycle with 100%.

This function does not return anything.
Figure 3-11.

The tilde (∼) identifies which pins support PWM


The following functions enable you to insert delays into sketch and obtain uptime—the amount of time the board was booted for.

long millis( )

This function returns the number of milliseconds from the time Intel Galileo was booted.

long micros( )

This function returns the number of microseconds from the time Intel Galileo was booted.

delay(int milliseconds)

Delay pauses sketch execution for the amount of time specified by milliseconds.

delayMicroseconds(int microseconds)

This function pauses the sketch during the time specified in the microseconds argument.

Running Some Examples

The next examples demonstrate the Arduino IDE and the intention is to cover the most common functions discussed previously. Note the code used in each example and compare it to the circuit. If you understood the reference functions  discussed thus far, you will realize that it was not necessary to show the example’s schematics because the reference functions used are simple. Looking just at the code, you can imagine the circuit and make this circuit interact with the exterior LEDs and buttons. This is the main purpose of the wiring platform.

Fade Example

Load the example in the IDE by accessing Files ➤ 01.Basics ➤ Fade and checking the materials list in Table 3-2.

This example demonstrates using the pinMode() function to set pin 9 to OUTPUT. It also shows how to generate a PWM to simulate a fading effect. The code varies the duty cycle applied in a pin port connect to an LED, which changes the intensity of the LED.

Fade Materials list

Table 3-2 provides the materials list for this example.
Table 3-2.

Materials List for the Fade Example






220 ohm resistor




Hook-up wires (assorted)

Fade Schematics

Connect the LED’s cathode to the ground and the LED’s anode to the 220 ohm resistor, as shown in Figure 3-11. The resistor is connected directly to pin 9.
Figure 3-12.

Schematic used in the Fade example

Fade Code

Listing 3-2 provides the code for the Fade example.

Listing 3-2. Fade.ino



This example shows how to fade an LED on pin 9

using the analogWrite() function.

This example code is in the public domain.


int led = 9;           // the pin that the LED is attached to

int brightness = 0;    // how bright the LED is

int fadeAmount = 5;    // how many points to fade the LED by

// the setup routine runs once when you press reset:

void setup()  {

  // declare pin 9 to be an output:

  pinMode(led, OUTPUT);


// the loop routine runs over and over again forever:

void loop()  {

  // set the brightness of pin 9:

  analogWrite(led, brightness);

  // change the brightness for next time through the loop:

  brightness = brightness + fadeAmount;

  // reverse the direction of the fading at the ends of the fade:

  if (brightness == 0 || brightness == 255) {

    fadeAmount = -fadeAmount ;


  // wait for 30 milliseconds to see the dimming effect

  delay(30) ;


Running the Fade Sketch

As soon the sketch runs, setup() is executed only once. It sets pin 9 to OUTPUT through the pinMode() function. In the loop() function, analogWrite() generates a PWM with a duty cycle of 0 stored in the brightness variable. The duty cycle increases by five, as defined by the variable fadeAmount, until it reaches 255. At this point, the duty cycle reduces by five again until it reaches 0. The logic then starts increasing the duty cycle again. This logic will create a PWM varying the duty cycle, causing a diming effect.

There is a 30-millisecond delay to allow you to see the dimming effect; otherwise, the code would run so fast you would think the LED is only turning ON and OFF.

Button Example

Load the example in the IDE by accessing Files ➤ 02.Digital ➤ Button and checking the materials needed in Table 3-3.

This example focuses on how to use the digitalRead() function to read the state of a working input method. It uses digitalWrite() to turn on an LED. Note that this example uses an LED on pin 13, which means you do not need to connect an LED to pin 13 because pin 13 is connected to the LED built in to the Intel Galileo, as shown in Figure 3-7. However, if you connect an LED to pin 13 similar as you connected on pin 2 in the fade example , you will see two LEDs working at same time you push the button or switch. In other words, you will see the built-in and the external LED having the same effect. The 10k ohm resistor is used to limit the current and then the button is opened. This prevents a short circuit between the 5V and the GND in the board.

The pinMode() function is used to set the pins to OUTPUT and INPUT.

Button Materials List

Table 3-3 provides the materials list for this example.
Table 3-3.

Materials List for the Button Example





10k ohm resistor

Pushbutton or switch




Hook-up wires (assorted)

Button Schematics

Use the pushbutton or switch connect to the 10k ohm and pin number 2, as shown in Figure 3-13.
Figure 3-13.

Schematic used in the Button example

Button Code

Listing 3-3 provides the code for the Button example.

Listing 3-3. Button.ino



Turns on and off a light emitting diode(LED) connected to digital

pin 13, when pressing a pushbutton attached to pin 2.

* LED attached from pin 13 to ground

* pushbutton attached to pin 2 from +5V

* 10K resistor attached to pin 2 from ground

* Note: on most Arduinos there is already an LED on the board

attached to pin 13.

created 2005

by DojoDave < >

modified 30 Aug 2011

by Tom Igoe

This example code is in the public domain.


// constants won't change. They're used here to

// set pin numbers:

const int buttonPin = 2;     // the number of the pushbutton pin

const int ledPin =  13;      // the number of the LED pin

// variables will change:

int buttonState = 0;         // variable for reading the pushbutton status

void setup() {

  // initialize the LED pin as an output:

  pinMode(ledPin, OUTPUT);

  // initialize the pushbutton pin as an input:

  pinMode(buttonPin, INPUT);


void loop(){

  // read the state of the pushbutton value:

  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed.

  // if it is, the buttonState is HIGH:

  if (buttonState == HIGH) {

    // turn LED on:

    digitalWrite(ledPin, HIGH);


  else {

    // turn LED off:

    digitalWrite(ledPin, LOW);



Running the Button Sketch

The setup() function is called once you’ve set pin 13 to OUTPUT and pin 2 to INPUT through pinMode().

In the loop() function, the variable buttonState receives the current state of the switch or pushbutton. When you press the button, digitalRead() returns HIGH and buttonState saves this value and the digitalWrite() function sets pin 13 (LED) to HIGH, thus turning ON the built-in LED.

Otherwise, if the pushbutton or switch is not pressed, digitalRead() returns LOW and the buttonState variable saves this value. Then the digitalWrite() function sets pin 13 (LED) to LOW, turning OFF the built-in LED.

ReadAnalogVoltage Example

Load the example in the IDE by accessing Files ➤ 01.Basics ➤ ReadAnalogVoltage and checking the materials list in Table 3-4.

This example uses the analogRead()function to convert the voltage over a potentiometer to a digital reading.

This example also uses the Serial object discussed previously to print the value read in the serial console terminal.

ReadAnalogVoltage Materials List

Table 3-4 provides the materials list for this example.
Table 3-4.

Materials List for ReadAnalogVoltage Example





Potentiometer (any!)



Hook-up wires (assorted)

ReadAnalogVoltage Schematics

Connect the potentiometer only to the 5V and the ground, and then connect the variable terminal to the A0 port, as shown in Figure 3-14.
Figure 3-14.

Schematic used in the ReadAnalogVoltage example

The ReadAnalogVoltage Code

Listing 3-4 provides the code for the ReadAnalogVoltage example.

Listing 3-4. ReadAnalogVoltage.ino



  Reads an analog input on pin 0, converts it to voltage, and prints the result to the serial monitor.

  Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.

This example code is in the public domain.


// the setup routine runs once when you press reset:

void setup() {

  // initialize serial communication at 9600 bits per second:



// the loop routine runs over and over again forever:

void loop() {

  // read the input on analog pin 0:

  int sensorValue = analogRead(A0);

  // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):

  float voltage = sensorValue * (5.0 / 1023.0);

  // print out the value you read:



Running the ReadAnalogVoltage Sketch

As soon as you run the sketch, press Ctrl+Shift+M to invoke the serial monitor console. Notice in the loop() function that the analogRead() command reads the analog port A0 and the variable sensor value saves it.

Remember when analogRead() was discussed previously, that the return value was between 0 and 1023. In this case, 0 means 0V and 1023 means 5V in the port A. This conversion is being done by the voltage variable that’s printed in the serial console terminal by Serial.println().

The Debounce Example

Load the example in the IDE by accessing Files ➤ 02.Digital ➤ Debounce. Check the materials list used in Table 3-3.

This example demonstrates the use of the millis() function to add logic based on time. It determines whether a button was pressed after a period of time, in order to avoid interpreting multiples presses. This is called debounce.

The example uses the same material and circuit used in the example button previously discussed in this chapter.

Debounce Materials List

You can use the same material from Table 3-3 from the Button example.

Debounce Schematics

Use the same circuit shown in Figure 3-12 from the Button example.

Debounce Code

Listing 3-5 provides the code for the Debounce example.

Listing 3-5. Debounce.ino

/* Listing 3-5 Debounce.ino.


Each time the input pin goes from LOW to HIGH (e.g. because of a push-button

press), the output pin is toggled from LOW to HIGH or HIGH to LOW. There's

a minimum delay between toggles to debounce the circuit (i.e. to ignore


The circuit:

* LED attached from pin 13 to ground

* pushbutton attached from pin 2 to +5V

* 10K resistor attached from pin 2 to ground

* Note: On most Arduino boards, there is already an LED on the board

connected to pin 13, so you don't need any extra components for this example.

created 21 November 2006

by David A. Mellis

modified 30 Aug 2011

by Limor Fried

modified 28 Dec 2012

by Mike Walters

This example code is in the public domain.


// constants won't change. They're used here to

// set pin numbers:

const int buttonPin = 2;   // the number of the pushbutton pin

const int ledPin = 13;     // the number of the LED pin

// Variables will change:

int ledState = HIGH;       // the current state of the output pin

int buttonState;           // the current reading from the input pin

int lastButtonState = LOW  // the previous reading from the input pin

// the following variables are long's because the time, measured in miliseconds,

// will quickly become a bigger number than can be stored in an int.

long lastDebounceTime = 0  // the last time the output pin was toggled

long debounceDelay = 50;   // the debounce time; increase if the output flickers

void setup() {

  pinMode(buttonPin, INPUT);

  pinMode(ledPin, OUTPUT);

  // set initial LED state

  digitalWrite(ledPin, ledState);


void loop() {

  // read the state of the switch into a local variable:

  int reading = digitalRead(buttonPin);

  // check to see if you just pressed the button

  // (i.e. the input went from LOW to HIGH),  and you've waited

  // long enough since the last press to ignore any noise:

  // If the switch changed, due to noise or pressing:

  if (reading != lastButtonState) {

    // reset the debouncing timer

    lastDebounceTime = millis();


  if ((millis() - lastDebounceTime) > debounceDelay) {

    // whatever the reading is at, it's been there for longer

    // than the debounce delay, so take it as the actual current state:

    // if the button state has changed:

    if (reading != buttonState) {

      buttonState = reading;

      // only toggle the LED if the new button state is HIGH

      if (buttonState == HIGH) {

        ledState = !ledState;




  // set the LED:

  digitalWrite(ledPin, ledState);

  // save the reading.  Next time through the loop,

  // it'll be the lastButtonState:

  lastButtonState = reading;


Running the Debounce Sketch

In this example, the setup() function sets pin 2 to INPUT because the button or switch should be connected to this pin. Pin 13 (the internal built-in LED) is set to OUTPUT.

The loop() function reads the button state through digitalRead() and the variable reading assumes the value. If the button state differs from the last read, the lastDebounceTime variable assumes the current millis(). Then the loop function keeps running and reading the button states, but when the debounceDelay interval is reached after the first button pressing, the state is checked again. If the code detects that the user was still pressing the button, the LED state is changed.

In the next section, you learn how to update the firmware.

Updating the Firmware Using the IDE

Besides the dediprog and the manual procedure to upload the firmware to the board, which was discussed in the  Chapter 2, there is a third option involving IDE and it is much simpler.

Every time Intel releases a new IDE, it typically comes with a new firmware for Intel Galileo. It’s recommended that you update it for the bug fixes and the new APIs.

The update process in the IDE is very simple:
  1. 1.

    Remove the USB cable and 5V power supply.

  2. 2.

    Remove the SD card or USB stick if you are using one.

  3. 3.

    Insert the 5V power supply.

  4. 4.

    Insert the USB cable.

  5. 5.

    Start the IDE and make sure the Intel Board and serial port is properly configured, as explained in the section entitled “Checking the Port and Board Selected” in this chapter.

  6. 6.

    Select Help ➤ Firmware Update, as shown in Figure 3-15.

Figure 3-15.

Firmware Update option in the Help menu

  1. 7.

    A warning dialog will show up to warn you that the 5V power supply must be connected. See Figure 3-16.

Figure 3-16.

5V power supply warning during the firmware update

  1. 8.

    Another dialog will ask you if you want to update the firmware. Just click Yes. You’ll then need to wait around six minutes.

If the firmware version in the Intel Galileo is newer than the IDE, you will be informed of this. But if you click yes, the firmware will be downgraded, as shown in Figure 3-17.
Figure 3-17.

You do have the option to downgrade

Updating the Firmware with Different Firmware

Sometimes Intel provides new firmware releases before a new IDE release comes out. In this case, you do not need to wait for a new IDE to upgrade your firmware. Just download the firmware provided using the same link you used before ( ) and then download the file with the .cap extension to the following locations:
  • Windows: .../Arduino<IDE VERSION>/hardware/tools/x86/bin/

  • Linux: .../Arduino<IDE VERSION>/hardware/tools/

  • MacOS:

After you copy the .cap file to one of these locations, make sure you delete or change the extension of the old .cap file because only one cap file can be present in this location.

Troubleshooting the Drivers

The Arduino IDE is designed to run in different operational systems with different versions. The operation system can also run on virtual machines like VMware and Virtual Box.

This variety of operation systems, with different versions and configurations, can impact how the serial driver works. There are some known problems. The intention of this section is to tell you how to get around those problems.

Serial Communication Issues with IDE on Windows

Sometimes after you plug the serial cable in several times or reboot your computer, the serial communication fails. This happens sometimes even when the COM port is present in the device manager and you have selected the right serial port and board in the IDE.

In the IDE console message (see Figure 3-4), the following error might appear:

C:\galileo-arduino-1.5.3/hardware/arduino/x86/tools/izmir/ line 40: /dev/ttyS8: No such file or directory

It means the IDE cannot communicate with Intel Galileo. If you connect the USB cable to a different port and the problem persists, you need to clean the serial ports in your computer using following steps:
  1. 1.

    Start the Command Prompt (cmd.exe). If you are using Windows 7, you must start the Command Prompt as the administrator. According to Figure 3-18, click in the Start icon (1) and type cmd, as shown in the figure (2). Don’t press Enter. As soon you type cmd, you will see the cmd.exe file available in Programs, as shown in Figure 3-18 (3).

Figure 3-18.

Starting the Command Prompt as an administrator on Windows 7

  1. 2.

    The Command Prompt will be shown. Type the following commands: set devmgr_show_nonpresent_devices=1 and start devmgmt.msc. See Figure 3-19.

Figure 3-19.

Starting the Device Manager via the Command Prompt

  1. 3.

    The Device Manager will show up. Choose View ➤ Show Hidden Devices. See Figure 3-20.

Figure 3-20.

Enabling the “Show Hidden Devices” option

After you enable the option to see the hidden devices, the Ports (COM & LPT) node will show all the hidden devices as faded icons, as shown in Figure 3-21.
Figure 3-21.

All hidden devices under Ports (COM & LPT) are grayed out

  1. 4.

    Select the COM port to be uninstalled. Right-click it and select Uninstall. See Figure 3-22.

Figure 3-22.

Right-click to uninstall hidden COM ports

  1. 5.

    In the uninstall dialog, check the Delete the Driver Software for This Device box to delete the driver. Click the OK button, as shown in Figure 3-23.

Figure 3-23.

Deleting the hidden COM port and driver

  1. 6.

    After deleting all the hidden COM ports, repeat the installation process mentioned in the “Installing the Drivers” section of this chapter.


IDE Problems with Virtual Machines and 64-Bit Linux

If you are using the Arduino IDE for Intel Galileo in a virtual machine or in a 64-bit Linux OS, there are some errors you’ll encounter that aren’t covered in the “Getting Started Guide.”

These errors are possible to resolve but they require some tricks. The following sections describe a few of them.

Warning Messages with 64-Bit Linux

If you see a warning message like /ibus/bus is not root, try starting the IDE using gksudo ./arduino instead of sudo ./arduino. To install the gksudo, use the sudo apt-get install gksu command.

Problems with VMware

If you installed the IDE into VMware, you might have issues detecting the /dev/ttySx where x is the port number. There is a bug in VMware if the comm port is automatically recognized and selected without any manual intervention. If that happens, disconnect the port as shown in Figure 3-24 and then reconnect it.
Figure 3-24.

Option to disconnect serial port

Problems with Oracle Virtual Box

If you encounter communication issues, make sure you have the Enable USB 2.0 (EHCI) Controller enabled by selecting Settings ➤ USB, as shown in Figure 3-25.
Figure 3-25.

USB setting for the Orable VM box

Communicating Sketches with Linux Native Programs

In  Chapter 2 you learned how to create a native application and transfer to Linux in your Intel Galileo board. You might be wondering if you can integrate programs that run in Linux with sketches.

Before we discuss how the sketches might communicate with Linux-native programs, it is important that you understand how the sketches work in conjunction with Linux OS.

All wiring libraries were created with the initiative to make Intel Galileo compatible with the Arduino reference, so they run in the Linux user space. In other words, the sketches are like any other program.

APIs like shared memory, sockets, signaling libraries, and a vastness of POSIX libraries can be used to establish communication as any other regular program in Linux OS.

It possible also to call direct programs like Python, curl, OpenSSL, bash scripts, start services, and so on.

The example provided in the next section integrates the unread email alarm with Python and POSIX. Considering Python is being used you should have an SD card image because SPI images are very tiny and do not contain additional software like Python. Additional examples are covered in future chapters.

is.Additionalfuture Project Example: Unread Email Alarm with Python and POSIX Functions

This project explains how to use regular Linux POSIX APIs to create a timer that asynchronously calls a function handler every 10 seconds. When this function handler is executed, it calls a Python script that counts the number of emails unread in a Gmail account. If the number of emails increased, an LED is ON, which informs you that there is new email in the inbox.

The connection to Gmail is made using WiFi or an Ethernet cable.

Materials List

Table 3-5 provides the materials list for this example. Table 3-6 provides an optional list.
Table 3-5.

Materials List for Fade Example






220 ohm resistor




Hook-up wires (assorted)

Table 3-6.

Optional Materials




Intel Centrino Wireless-N 135 or Ethernet cable


Dual band antennas 350mm cable 2118060-1 TE Connectivity (only if WiFi)






220 ohm resistor

Hook-up wires (assorted)


The Schematics

Use the same schematic in Figure 3-12. Note the WiFi card or Ethernet setup, and then follow the instructions in  Chapter 5.

The PythonP Code

The Python script is called emailCounter. py and it accepts two arguments wherein the first argument is your Gmail’s username or email and the second argument is your password.

You can execute this script manually to test the terminal serial:

python email.counter <your username or email> <your password>

The Python code is provided in Listing 3-6.

Listing 3-6.

# based in the discussion in:


# by

import imaplib

import sys

obj = imaplib.IMAP4_SSL('','993')


print len(,'UnSeen')[1][0].split())

The sketch code is provided in Listing 3-7.

Listing 3-7. gmailAlarm.ino

#include <signal.h>

#include <stdio.h>

#include <string.h>

#include <sys/time.h>

// the led

int led = 2;  // the built-in LED

// emails counters

int current_emails_counter = -1;

int last_emails_counter = -1;

// add here your credentials

String gmailUserName="";  // email or password

String gmailPassword="";  // your password

String script_name = "python /home/root/ ";

// this function calls a Python script to read the number of emails not read

int processEmailCounter ()


   char cmd_rsp[8];  // This buffer will containg the script response

   FILE *fpipe;

   String command = script_name;

   command += gmailUserName;

   command += " ";

   command += gmailPassword;

    // buffer to be used with popen

   char cmd_char[300];

   // clear message buffer

   memset((void *)cmd_char, sizeof(cmd_char), 0);

   // convert the message to char array

   command.toCharArray(cmd_char, sizeof(cmd_char), 0);

   if ( !(fpipe = (FILE*)popen((char *)cmd_char,"r")) )

      {  // If fpipe is NULL

      Serial.println("Problems with pipe");




     while ( fgets( cmd_rsp, sizeof(cmd_rsp), fpipe)) {}


     // let's print the serial result


     return atoi(cmd_rsp);


   return -1;


// this is my time handler...

void timerHandler (int signum)


    current_emails_counter = processEmailCounter();

    if (last_emails_counter == -1)


        last_emails_counter = current_emails_counter;

        Serial.println("I am ready to check now... ");


    if (current_emails_counter != last_emails_counter)


        // turn on the LED

        digitalWrite(led, HIGH);



int setAlarm ()


  struct sigaction sa;

  struct itimerval timer;

  /* Install timer_handler as the signal handler for SIGVTALRM.  */

  memset (&sa, 0, sizeof (sa));

  sa.sa_handler = &timerHandler;

  sigaction (SIGVTALRM, &sa, NULL);

  // Configure the timer to expire after 1 seconds

  timer.it_value.tv_sec = 1;

  timer.it_value.tv_usec = 0;

  // ... and every 10 seconds after that

  timer.it_interval.tv_sec = 10;

  timer.it_interval.tv_usec = 0;

  // Start a virtual timer. Counter while sketch runs

  setitimer (ITIMER_VIRTUAL, & timer, NULL);


void setup() {

   // only a small delay to allow you press CTRL+SHIT+M

   // and see the Serial Monitor


   // set the alarm


   pinMode(led, OUTPUT);

   digitalWrite(led, LOW);


void loop() {

  // put your main code here, to run repeatedly:


Preparing the Project to Run

The first thing to do is transfer the Python script to the Intel Galileo board using FTP, as described in the  Chapter 2, or any other method you prefer. Make sure you transferred to the correct path because the sketch searches for /home/root/ Otherwise, you have to change the sketch code to the path you want.

Make sure that you have the WiFi or Ethernet working properly, as explained in the  Chapter 2. Note that Sketch does not use a client for connection. You can use any connection since the board has an IP address and Internet connection available.

Before you run the sketch, you need to add your credentials to the beginning of the code:

// add your credentials here

String gmailUserName="";  // email or password

String gmailPassword="";  // your password

If your Python script is copied to the right path, your Internet connection is working, and your credentials are in the sketch's code, you are ready to run.

Running the Code

If everything is prepared, run the sketch. As soon it runs, press Ctrl+Shift+M to see the debug messages in the serial console.

If you are fast enough, you will see the following message:

I am ready to check now...

This means the code read the quantity of emails unread and is waiting for new ones. Using your browser, open your Gmail and send an email to yourself.

In a maximum of 10 seconds you should see the LED ON.

Reviewing the Code

The setup() function has a delay of three seconds in order to allow you to start the serial console and catch the first debug messages printed by Serial.print() and Serial.println(). The setup() function also initializes the timer setting by calling the setAlarm() function. It sets pin 2 to OUTPUT through pinMode() because the LED must be connected to this pin and then turns off the LED by having digitalWrite() pass LOW.

The setAlarm() function creates a timer using setitimer(), which in turn calls a function handler called timerHandler() in one second, as soon the sketch runs, and then every 10 seconds after that. With the regular Arduino reference you could control the seconds passed in the loop() function using millis(); however, using the POSIX functions is much easier. The timer that’s created is the ITIMER_VIRTUAL type, which means the function handler is called only while the sketch is running.

For more information on how setitimer() works, visit this link: .

When timerHandler() is called, it calls the processEmailCounter() function, which is responsible for executing the Python script. This script receives your credentials and returns the number of unread emails in your Gmail inbox. The sketch receives the response using the popen() function (ANSI C) and receives the number of emails in a char array, which is converted to an integer format using atoi().

In sequence, timerHandler() uses two variables called current_emails_counter and last_emails_counter. They determine if the number of unread email increased according to the processEmailCounter() function. If there was an increase, the LED connected to pin 2 is set to HIGH by digitalWire().

The project requires an Internet connection, so it is recommended that you use a WiFi card or Ethernet cable and set up the board as explained in the  Chapter 2.

When the Internet connection is established before the sketch is executed, you can avoid using WiFi or Ethernet libraries. This is discussed in  Chapter 4.


Check the function loop():

void loop() {

  // put your main code here, to run repeatedly:


It is empty! Most of the code was developed using Python and POSIX calls provided by the Linux libraries. Note that a few functions from the Arduino reference were used: pinMode() and digitalWrite() .

You can see how powerful Intel Galileo is and how easy it is to integrate the Arduino reference APIs into the Linux libraries.


At this point you are able to install and run the Arduino IDE, install the drives in different operational systems, and load, compile, and download sketches.

You were introduced to the wiring platform concept and to the most common functions used in the Arduino reference library in order to manage the digital and analog headers of Intel Galileo. With such headers, you were able to interface with LEDs and buttons, generate PWM signals, and debug the sketches using serial communication.

At the end of this chapter, you learned how to make the sketches communicate with the native Linux applications using POSIX functions and how to interface with Python scripts.

This chapter is very simple but one of most important because it provides basic concepts that will be used in the remainder of the book.

Copyright information

© Manoel Carlos Ramon 2014

Authors and Affiliations

  • Manoel Carlos Ramon
    • 1
  1. 1.CAUS

Personalised recommendations