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.
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:
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
210-460 mA @ 5V
550 mA (1.9-2.2W)
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.
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
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:
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).
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:
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.
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.