x86

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.

Is Edison competing with Galileo

Last summer at the Maker Fair in Rome Intel announced the Galileo single board computer . This week at CES 2014 in Las Vegas Intel followed up with another initiative that carries an inventors name. This time it is Edison. The Edison board is more advanced take on the Quark System on a Chip (SoC) based single board. The board is only the size of an industry standard SD card. So don’t expect to solder it yourself.
edison
However the card is a full featured single board computer that will offer support for multiple operating systems (OS).  The integrated WiFi will turn any device equipped with an Edison into an IoT solution.
Intel also promised to release design files that will make it easy to  integrate Edison into your own project.  Among the tool vendors that will support Edison is Autodesk. The company just announced the  acquisition of circuit.io. This online PCB design tool is now a part of Autodesk’s 123D design suite.
For those that cannot wait and want something today the Electric Imp Wireless SD-CARD is an interesting alternative. This card is clearly not as powerful as an Edison. However given the creativity that innovators have displayed around the meager Arduino 8-bit AVR CPU  it may still be plenty.
El_Imp

What shields are working with Galileo

In my last post I touched on Galileo’s shield interface implementation. 010511_0750_0082_nsmsHaving 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
    1. 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
    2. 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
    1. Does the driver directly access Atmel’s  registers? This can be either the IO-port registers, Interrupt, Pulse Width Modulator (PWM) or Timer registers.
    2. 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 TreGalileo 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.Galileo-circuitry_610x534 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.