Galileo

Windows for Galileo

Wintel
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 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:

  1. A computer with the Arduino IDE for Galileo installed
  2. A network router with a DHCP server running
  3. An Ethernet cable to connect the Galileo board to your network
  4. 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

    1. 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
    2. Attach your Galileo to your network router with a standard Ethernet cable
    3. 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 () {}
    4. Compile and upload the sketch.
    5. 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”
    6. Do a full format  of a microSD Card (no Quickformat)
    7. Copy all the files from Prepare the microSD Card
    8. Plug the micro SD card into the SD card slot on the Galileo Board
    9. Boot your Gallileo board by pushing the REBOOT switch and wait until you see the board dectected by your computers USB port.
    10. Use SSH (mindterm or scp) to copy the file iwlwifi-6000g2b-6.ucode WiFI firmware  to the /lib/firmware/ folder of you Galileo
    11. Generate the WPA credentials:
      %wpa_passphrase NETWORK_NAME << EOF > /etc/wpa_supplicant.conf
      > YOUR_PASSWORD
      > EOF
    12. Start the network with:
      %/etc/init.d/networking restart
    13. Shut down the WiFi with:
      %ifdown wlan0
    14. 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.

How does Galileo Stack up against Raspberry PI

I am interested is to compare Galileo and other DIY single board computers. In this post I want to analyze the Galileo board against the popular Rasberry PI. The first thing to note is that the Rasberry PI is not an Arduino compatible platform. However, there are now extension boards available that allow to use Arduino shields with Raspberry PI. Here are to examples: The first is the AlaMode for Raspberry Pi  the second is the GertDuino: Add-On Board for Raspberry PI . Both boards are priced in the range of a Rasberry PI. So the combination of a Raspberry PI with an Arduino shield extension puts this solution right where the Galileo board is.
Have a look at the table below. It compares the two single board computer’s hardware. The technical data for the Raspberry PI are taken from WikiPedia.

Rasberry PI Model A Rasberry PI Model B Intel Galileo
Target price: US$ 25 US$ 35 US$69
SoC: Broadcom BCM2835 (CPU, GPU, DSP, SDRAM, and single USB port) Intel Quark X1000
CPU: 700 MHz ARM1176JZF-S CPU 400MHz 32-bit x86 Pentium Class CPU
GPU: Broadcom VideoCore IV @ 250 MHz none
Memory (DRAM): 256 MBytes (shared with GPU) 512 MBytes (shared with GPU) as of 15 October 2012 256 Mbyte
PCIe ports: none PCIe 2.0
USB 2.0 ports: 1 Host 2 Host (from LAN9512) 1 Host,
2 Device
Video input: A CSI input connector allows for the connection of a RPF designed camera module none
Video outputs: Composite RCA (PAL and NTSC), HDMI (rev 1.3 & 1.4), raw LCD Panels via DSI none
Audio outputs: 3.5 mm jack, HDMI, and, as of revision 2 boards, I²S audionull none
Onboard storage: SD/MMC/SDIO 3.3V card slot SD/MMC/SDIO 3.3V card slot
Onboard network: None 10/100 Ethernet (from LAN9512) 10/100 Ethernet
Low-level peripherals: 8 × GPIO, UART, I²C bus, SPI bus with two chip selects, I²S audio +3.3 V, +5 V, ground 16 × GPIO,
UART, I²C bus, SPI
Power ratings: 300 mA (1.5 W) 700 mA (3.5 W) 550 mA (1.9-2.2W)
Power source: 5 volt via MicroUSB or GPIO header 5 Volt
Size: 85.60 mm × 53.98 mm (3.370 in × 2.125 in) 106.68 mm x 71.12 mm (4.2 in x 2.8 in)

The Raspberry PI uses a SoC chip that was originally designed for the set-top box market. Therefore it shows a nice lineup of features on the video side. The integrated HDMI port and on-chip graphics accelerator are testimony to this. However for IoT applications the Quark X1000 SoC used by Galileo offers a really nice selection of interfaces.

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.