Embedded Files
Introduction
Introduction
I first came across the Intel Galileo (first generation) at Maplin around 2018 and bought it on the spot for about £30 as they did not have the pcDuino in stock that I had been after (I did get hold of the pcDuino from Maplin later on). The Galileo was originally released in October 2013 as a hybrid of a Linux computer and an Arduino but rather than it just be another single board computer for Arduino users the Galileo is officially certified as an Arduino compatible board (although that doesn't quite mean you can, for example just plug in an Arduino shield and expect it to work). The first generation Galileo was discontinued as of June 2017 and was replaced by the generation 2 but only gen 1 will be covered on this page, as that's what I own.
I bought a second Intel Galileo first generation in 2023 from eBay for £13 in brand new condition, which I had a slightly difference experience with, also documented on this page. I have updated any links I've come across that no longer work, as often happens when revisiting pages I wrote when first using a product.
Please see this video for a detailed introduction to the Galileo:
You may also be interested in the Interfacing page.
You can email me at james.boshikoopa@gmail.com
To return to the main Computers Exposed page please click here.
Before going over the specifics of the Galileo let's talk about why you would want to use a Galileo as opposed to the Raspberry Pi which sells for a similar price. While the Rasp is great if you want to be able to hook up a TV or monitor, sometimes there is a need for a computer with no audio or video socket which runs a minimal version of Linux as is the case of the Galileo. Other advantages of the Galileo over the Rasp is that it has support for mini PCIe cards, it has a Real-Time Clock with support for a battery to keep the time when the board is powered off, and the Galileo also has analog inputs as part of its GPIO. But like the Rasp, because the Galileo runs a version of Linux it's much more difficult to get predictable GPIO timing than with using a real Arduino and sketches won't run immediately at power on or reset. There is also the issue that the Galileo's GPIO is slow - about 230Hz - but it is possible to get speed in MHz for most pins through hacks.
Let's look at some useful links:
The Galileo on the Arduino site:
https://web.archive.org/web/20200110134114/https://www.arduino.cc/en/ArduinoCertified/IntelGalileo
For further information about the Galileo there is an FAQ at:
Firmware updater tool and drivers:
A lot of useful info and a tutorial can be found on Sparkfun's site:
https://learn.sparkfun.com/tutorials/galileo-getting-started-guide
Schematic:
http://www.mouser.com/pdfdocs/GalileoSchematic.PDF
Specification
Time to talk about the parts that make the Galileo tick:
Quark SoC x1000 32-bit (i586 instruction set, single core/single thread) at 400MHz. 16KB L1 cache.
512KB SRAM.
256MB DRAM.
8MB SPI flash for firmware (256 - 512KB for sketches).
11KB EEPROM programmable via EPROM library.
Micro SD card socket (32GB max). Can be used to boot the system off a larger Linux image.
10/100Mb ethernet
USB 2.0 host and client, both micro. Client to connect to a PC to program the board. Host for supporting devices (keyboard, mouse, etc.).
RS-232 (3.5mm 'stereo' socket, labelled UART) for accessing the Linux terminal.
Mini PCI express (wi-fi, storage, etc.) on bottom of the board.
Arduino Uno 3.3/5V compatible shield support (must set jumper for shield voltage).
Built-in RTC (requires battery to be fitted, header pins are provided).
10-pin JTAG for debugging.
On-board 'Arduino pin 13' LED (labelled 'GP').
ICSP header (2x3)
Reboot button to reboot Linux (not needed after uploading sketch to start the sketch).
Arduino reset button (as with traditional Arduino reset button, resets just the Arduino part of the board).
5V barrel jack, centre-positive, 2.1mm. Connect regulated 5V power supply recommended up to 3A.
Getting started with the Galileo
Getting started with the Galileo
The boxed product comes with the Galileo board, a 5V/2.1A USB power supply with a number of plug heads and a special cable with a barrel jack on one end and full size USB on the other.
Intel did not seem to know what they were doing with powering the Galileo as they warn enough times to always power the board via the barrel connector before connecting to a PC via USB. To disconnect the board from a PC, first remove the USB cable and then disconnect the power; this seems like a very bad design.
It was not straightforward for me in getting the Galileo to work so I will walk you through what I had to do.
The first thing I knew I had to do was to download and install a special version of the Arduino IDE for the Galileo and then install the drivers:
Or so I thought; the link just ends up going to the main Arduino site. However, I did find a link that has the correct IDE version:
Extract the file using 7-zip (or similar), connect power to the Galileo using the barrel connector, then connect to your PC through the client micro USB connector. Go to the device manager and select to update software for 'Gadget serial v2.4' (the name may be something else, such as 'COMx'): click Browse my computer, select Browse and navigate to:
arduino-1.5.3-intel.1.0.4/hardware/arduino/x86.
The Galileo will then show up as 'Galileo' with its port name under Ports.
To write code for the Galileo supposedly you must use the Arduino IDE that was downloaded with the other files in the link above, we'll get back to that shortly. Before writing a sketch it's a good idea to update the board's firmware; in fact I couldn't get a sketch to run on the Galileo until after the firmware was updated. Go to Help -> Galileo firmware update (it will about five minutes). Alternatively you could try using the Firmware updater tool I linked to earlier on.
When I first got a Galileo I was unsuccessful in getting sketches working for it using the standard Arduino IDE (V1.x) even though it has support for Galileo 'Intel i586' board (Tools->Board->Boards Manager: search for 'Intel Galileo' and install). When I got a second Galileo I updated the board's firmware using the special version of the IDE as recommended but was able to successful get a sketch working on the Galileo using Arduino IDE V2.1.1, which was the most recent version I had installed. I still had to add the board in the usual way using the Boards Manager.
Whichever IDE you use: when you select Intel Galileo as the board to use, specific examples become available for the Galileo but it would be a good idea to test you board by trying out some simple examples, with the classic Blink example being a good choice, which in the case of the Galileo flashes the on board 'GP' LED. It should be pointed out that by default sketches are temporary stored on the Galileo which does have the advantage they're transferred very quickly but are lost when you power cycle.
I tried the KeyboardController example (File->Examples->USBHost->KeyboardController) and connected a wireless Logitech keyboard by plugging the receiver into a USB OTG adapter which was plugged into the USB host port. Although the serial monitor showed responses to the keyboard keys being pressed the keys displayed didn't seem to be correct. The MouseController example didn't work for me using a Logitech mouse that connects wirelessly with the same dongle as the keyboard.
The Linux terminal
The Linux terminal
By gaining access to the Linux terminal you can monitor the boot process and issue commands to the O/S but it's hit-and-miss getting it to work. First of these are the settings you will need for your computer's serial port:
speed=115200
data bits=8
stop bits=1
Parity=None
flow control=XON/XOFF
The Galileo strangely makes use of a 3.5mm stereo jack for RS232 communication but after making up my own cable connected to a ft232rl USB to serial adapter I only got garbled text in Putty even after trying another cable. I then tried an RS232 to USB adapter but that did nothing. What I did get working was to upload a custom Arduino sketch as explained at the following site (section 'Custom Arduino sketch):
https://learn.sparkfun.com/tutorials/galileo-getting-started-guide#linux-commands
After uploading the sketch, open Putty, select serial and enter the Galileo port number, set speed to 115200 and start session. You will be met with a blank screen so press return and you should get something like the following:
Poky 9.0.2 (Yocto Project 1.4 Reference Distro) 1.4.2 clanton /dev/ttyGS0
Type 'root' and press enter. By default there is no password. However, whenever I issued commands I got no response.
Next I chanced a desktop with a real COM port and a put together a null modem cable (swaps RX and TX) with RX of null modem cable connected to RX of Galileo and TX to TX and that worked perfectly in Putty; I got the boot options screen and once logged in was able to issue commands.
Here is a capture of the boot options:
To interface with Linux you can also write an Arduino sketch and execute a Linux command by using the 'system' keyword (it takes a single, string, param.) which executes a command-line operation in Linux. To direct a response from a system command to the serial monitor use '&>' along with '/dev/ttyGS0'.
The version of Linux on the Galileo contains BusyBox which is a collection of commands and utilities, more information of which can be read at:
For command help:
https://busybox.net/downloads/BusyBox.html
Some commands, however, aren't available; type busybox in the terminal for the full list.
Now we have access to the terminal we can do some investigations. Running the 'free' command reports 238068 total memory which should be the amount of DRAM (i.e. ~256MB).
It takes 15 seconds to reach the boot menu from power on, 47 seconds to start a sketch (if have micro SD inserted so the sketch auto boots) from power on, and 50 seconds to reach the login prompt from power on.
Advanced use of the Galileo
Advanced use of the Galileo
By default sketches uploaded to the Galileo do not run at start like with an actual Arduino. I followed a guide at:
I tested with a TDK 4GB micro SD card and after following the instructions linked above I powered the Galileo on with a micro SD inserted and it took about 1 min 8 secs to reach the login screen. Now when I upload a sketch it auto runs after pressing reboot/powering off and on again. Interestingly, after uploading a sketch, 'sketch.elf' is now stored in the sketch folder. The sketch will only remain persistent if the SD card is kept in. Without the SD card inserted there is no 'sketch.elf' file but there is with the SD card present so the SD card must always be in the Galileo for the sketch to start at power up/reboot.
Tips and tricks
Tips and tricks
If you have a problem getting the Galileo to be recognised by the Arduino IDE after the drivers were installed try changing the port number to something lower (<10) in the device manager.
If you get an error similar to the following:
Intel.1.0.4/hardware/arduino/x86/tools/izmir/clupload_win.sh: line 40:
/dev/ttyS12: No such file or directory
Try restarting your computer and then try uploading the sketch again:
The default Linux image stored on the on-board flash does not support Wifi so you will need to use the bigger Linux version which is booted off an SD card.
In the Linux terminal if you find ls returns nothing you need to change directory (e.g. cd /).
Oddly you cannot output anything to the serial monitor in setup() using an Arduino sketch but works fine in loop().
There is no problem having the Galileo connected to a PC via both RS232 and USB.
Recommended book:
INTEL GALILEO AND INTEL GALILEO GEN 2, Sander, Van Vugt.
The book covers both Gen 1 and Gen 2 and is a great introduction to the Galileo.
All content of this and related pages is copyright (c) James S. 2018-2024
Google Sites
Report abuse