According to HotHardware.com there are signs that Microsoft will start supporting Galileo with a new “Windows on Devices” version that targets IoT and other smart devices. Why is this noteworthy? Well, this would in fact mean that the PC-era “Wintel” team is entering the Maker scene with their newly paired product offerings supporting an Arduino Maker platform.
This is certainly a welcome move as it broadens the choice of platforms and products Makers have to use in their project.
Galileo
Galileo in the Doghouse?
In one of my previous blogs I compared the Galileo board against the Raspberry Pi Today we are looking at how the Galileo board compares to the affordable Beaglebone Black board. The Beaglebone is an initiative by Texas Instruments (TI). Unlike the Raspberry PI the Beaglebone board is all open source. Anyway let’s look at the key technical data:
Beaglebone Black | Intel Galileo | |
Target price: | US$45 | US$69 |
SoC: | Texas Instruments Sitara AM3359 | Intel Quark X1000 |
CPU: | 1GHz ARM® Cortex-A8, NEON floating-point accelerator, 2x PRU 32-bit microcontrollers | 400MHz 32-bit x86 Pentium Class CPU |
GPU: | SGX530 3D graphics accelerator | none |
Memory (DRAM): | 512MB DDR3 RAM | 256 Mbyte |
PCIe ports: | none | PCIe 2.0 |
USB 2.0 ports: | 1 Host, 1 Device |
1 Host, 2 Device |
Video input: | none | |
Video outputs: | HDMI (rev 1.3 & 1.4) | none |
Audio outputs: | stereo via HDMI | none |
Onboard storage: | 2GB 8-bit eMMC on-board flash storage SD/MMC/SDIO 3.3V card slot |
SD/MMC/SDIO 3.3V card slot |
Onboard network: | 10/100 Ethernet | 10/100 Ethernet |
Low-level peripherals: | Power 5V, 3.3V , VDD_ADC(1.8V) 3.3V I/O on all signals McASP0, SPI1, I2C, GPIO(69 max), LCD, GPMC, MMC1, MMC2, 7 AIN(1.8V MAX), 4 Timers, 4 Serial Ports, CAN0, EHRPWM(0,2),XDMA Interrupt, Power button, Expansion Board ID |
16 × GPIO, UART, I²C bus, SPI |
Power ratings: | 210-460 mA @ 5V | 550 mA (1.9-2.2W) |
Power source: | 5 Volt | 5 Volt |
Size: | 86.36 mm x 53.34 mm (3.4 in x 2.1 in) | 106.68 mm x 71.12 mm (4.2 in x 2.8 in) |
Both boards offer pretty similar technical data. One of the main difference is the absence of a graphics engine and HDMI interfaces in the Galileo’s X1000 Quark processor. This obviously makes the Galileo less of a choice for graphics application. The Beaglebone also offers a higher CPU clock speed which will give you additional punch. However, if you need a miniPCIe slot Galileo is the way to go.
To close the triangle I also recommend the detailed comparison of the Raspberry Pi vs. the Beaglebone published in Make Magazine.
Galileo goes Wireless
The Galileo is a great single board computer. However one thing that makes the board even more attractive is the simple support for WiFi. This blog outlines the steps necessary to get Galileo with WiFi working.
According to post in the Intel forum Galileo will work with the Intel Centrino N135 and N6205. However after reading the great post from Sergy I could not resist the temptation and got a Intel® Centrino® Advanced-N 6235 card from a local computer store. I then also had to get a pair of antennas and the half mPCI card extender.
Here are a few things you need before you start:
- A computer with the Arduino IDE for Galileo installed
- A network router with a DHCP server running
- An Ethernet cable to connect the Galileo board to your network
- An empty SD card or USB thumb drive
As my WiFi card is not supported out of the box I had to add the driver and firmware support. Here are the steps to do this:
(Note: instead of booting from a microSD card, you can also use a USB thumb drive and a USB-to-microUSB OTG-adapter cable). This is not advertised widely, but see Galileo forum post for details
- Head over to Wireless Linux site and download the Linux diver for the Intel Centrino Advanced-N 6235. The file name is iwlwifi-6000g2b-ucode-18.168.6.1.tgz
- Attach your Galileo to your network router with a standard Ethernet cable
- Download the sketch source code below. Modify the MAC address in the sketch to match you Galileo board’s MAC address printed on the label on the Ethernet plug.
#include SPI.h #include Ethernet.h // the media access control (ethernet hardware) address for the Galileo: byte mac[] = { 0x98, 0x4F, 0xEE, 0x00, 0x08, 0x2D}; //the IP address for the Galileo: byte ip[] = { 192, 168, 0, 2 }; void setup() { Serial.begin(9600); Serial.println("Attempting to start Ethernet"); if (Ethernet.begin(mac) == 0) { Serial.println("Failed to configure Ethernet using DHCP"); Serial.println("Attempting to configure Ethernet using Static IP"); Ethernet.begin(mac, ip); } Serial.print("Your IP address: "); Serial.println(Ethernet.localIP()); } void loop () {}
- Compile and upload the sketch.
- Open the Serial Console in the Arduino IDE. You should see a Message that reports the IP address assigned by your DHCP server “Attempting to start Ethernet” “Your IP address: 192.168. 1. 49”
- Do a full format of a microSD Card (no Quickformat)
- Copy all the files from Prepare the microSD Card
- Plug the micro SD card into the SD card slot on the Galileo Board
- Boot your Gallileo board by pushing the REBOOT switch and wait until you see the board dectected by your computers USB port.
- Use SSH (mindterm or scp) to copy the file iwlwifi-6000g2b-6.ucode WiFI firmware to the /lib/firmware/ folder of you Galileo
- Generate the WPA credentials:
%wpa_passphrase NETWORK_NAME << EOF > /etc/wpa_supplicant.conf > YOUR_PASSWORD > EOF
- Start the network with:
%/etc/init.d/networking restart
- Shut down the WiFi with:
%ifdown wlan0
- Start up the WiFi
%ifup wlan0
Using the IP address that the Galileo reported in the Serial Terminal you should be able to telnet into the board. This will give you a Galileo Linux terminal prompt.
What shields are working with Galileo
In my last post I touched on Galileo’s shield interface implementation. Having experimented with a few shields sitting in my drawer, I realized that the implementation of the Arduino shield interface creates a bit of a challenge. So before you assume that a shield is plug-and-play do your homework. Like with a vintage car they may need some tender loving care.
Here are a few key criteria that you want to check:
- Hardware
- Does my shield draw a lot of current: the Cypress CY8C9540A 40-Bit I/O Expander is only capable of driving 15/25mA instead of 40/50mA
- Are you accessing some of the shield pins at a high rate? Without special tricks, the Galileo can only toggle an IO pin at 477 kHz (see also Galileo FAQ and Forum post on this subject).
- Software
- Does the driver directly access Atmel’s registers? This can be either the IO-port registers, Interrupt, Pulse Width Modulator (PWM) or Timer registers.
- Does it use any AVR libraries? These libraries are exposing the Atmel AVR hardware to the programmer and are therefore a sure sign that you are in for some work to port the Arduino software libraries to the Galileo platform. Search for “#include <avr/” to see how many AVR hardware specific libraries are used.
Well written software libraries only use the official Arduino application programmers Interface (API). However, many of the existing shield libraries directly manipulating AVR hardware registers. This is either done out of ignorance for software portability or out of necessity as to push the hardware to its limits. I expect that with the transition away from the 8-bit AVR (ATmega328) micro controller to the more powerfule 32-bit CPUs ( Arduino Due, Arduino Tre, Galileo and Olimex-STM32) this problem will gradually subside.
Also note that as of this writing the following Arduino Libraries are supported:
- SPI
- EEPROM
- UART
- GPIO
- WiFi
Check the Release Notes on Intel’s site for the latest status.
Galileo is different, is it?
There a quite a number of Arduino boards available. The original Arduinos all used 8-bit AVR micro-controllers from Atmel. Recently Arduino adopted 32-bit ARM cores. In this post I want to look at the features of the Galileo board. The Board is about double the size of an original Arduino board and built around the Intel Quark X1000 controller. The Quark family of Intel chips are the new low cost line of x86 controllers that are positioned below the Atom cores. Quarks are elementary particles that make up the atomic nucleus. Intel positions the Quark family for Internet of Things (IoT) applications. The X1000 controller is the first member of this line. The X1000 offers:
- 400 MHz 32-bit x86 CPU
- 512 Kbyte ECC protected embedded SRAM
- Up to 2Gbyte external ECC protected DDR3 memory
- 10 /100 Mbps Ethernet port with RMI interface
- 2 x PCI Express Rev 2.0 ports offering up to 2.5 GT/s data transfer rates
- 2 x USB 2.0 Host ports
- 1 x USB 2.0 Device port
- SDIO card interface
- 2 x I2C Master interfaces up to 400 Kbit/s
- 16 x GPIO
- 2 x SPI Master controllers
- 2 x 16550 compliant UART supporting baud rates from 300 to 2764800
- Real Time Clock (RTC)
The controller is packed into a Flip-Chip Ball Grid Array (FCBGA) package with 393 solder balls that come with a 0.593 mm ball pitch. The package dimensions are 15mm x 15mm. With this kind of a package hand soldering is out of the picture.
Noteworthy is the implementation of the Arduino shield interface. The interface is pretty much designed with external components. For the GPIO/PWM digital shield pins a Cypress CY8C9540A 40-Bit I/O Expander with EEPROM is used. The analog shield pins use an Analog Device AD7298 8-Channel, 1 MSPS, 12-Bit SAR Analog to Digital Converter (ADC) with Temperature Sensor . The Quark controller uses I2C serial interface to control the PGIO/PWM CY8C9540A device and the SPI for the ADC AD7298.
Galileo is coming to town
Today I received my Intel Galileo board that I ordered sometimes in October from Mouser. The shipment date was initially mid November but got pushed back a few times. Anyway, I was planning to toy around with it over the holidays and was thrilled when it shipped December 24th. Galileo must have called Santa and put in a good word.
The board comes in a nice box together with a power supply. I wish it had stand-offs to provide some support when sitting on a table. This would prevent the board from resting on the mini-PCI card slot tips mounted on the back-side of the board. Those tips look like they could easily break off.
Anyway I will try to document the journey to get the board up and running.
For the documentation and software just head over to www.intel.com/support/go/galileo and download the related build for your OS. Intel supports 32/64 bit Linux, Windows and MacOS-X. The release as of this writing is 1.5.3 and gets delivered as a Zip-archive.
Downloading the Windows version and unzipping it with the stock Windows un-zipper produced an error because of too long file names in git related files. Using 7-Zip however completed without a hick-up (see also the Galileo Getting Started Guide) .
The next step is to plug in the power supply and connect the Client-USB port with a micro USB cable to your computer. Once the Galileo USB port is detected by your computer (it shows up under “Gadget 2.4”) you must install the related serial drive. It can be found in the IDE installation directory under ./hardware/arduino/x86/tools/linux-cdc-acm.inf . Now it is time to start the arduino IDE and perform a firmware update. You can find the menu entry under Help->Firmware Update.