Intel Galileo Board: Features, Programmierung & Projekte (Arduino-kompatibel, x86)

Sie suchen ein Entwicklerboard mit x86-Architektur (Intel Quark), Arduino-kompatiblem Pinout, Linux (Yocto) onboard und Mini-PCIe-Slot für Wi-Fi/Bluetooth/SSD? Das Intel Galileo (Gen 1 & Gen 2) war Intels Antwort auf Raspberry Pi & Arduino – 2014–2015 veröffentlicht, 2017 eingestellt (EOL), aber für Legacy-Projekte & Lernen noch relevant. Dieser Artikel deckt Specs, Programmierung, Projekte und Vergleich ab.

Hauptfeatures des Galileo Boards

Ethernet (kabelgebunden)

Onboard 10/100 Mbit/s Ethernet (RJ45) – für kabelgebundene Netzwerke, NTP-Zeitsync, Server-Dienste. Kein Wi-Fi onboard (via Mini-PCIe nachrüstbar).

Arduino-Kompatibilität (Pinout & Shields)

Galileo Gen 1/2 nutzen Arduino Uno Rev3 Pinout (14 Digital I/O, 6 Analog In, ICSP, UART, I²C, SPI). Viele Arduino-Shields funktionieren (5 V / 3,3 V Jumper beachten!). Erstes Arduino-zertifiziertes Board mit Intel-Architektur.

RTC (Real Time Clock) – Hardware-Uhr

Integrierte RTC mit Batteriepufferung (CR2032 Halter onboard). Ermöglicht Zeitsync ohne Netzwerk (NTP), GPS-Zeit, Logging mit Timestamps. Arduino Time Library nutzbar.

Intel Quark SoC X1000 (Application Processor)

• 32-Bit x86 (Pentium-Klasse, In-Order, Single Core, Single Thread)
• 400 MHz Takt
• 16 KB L1 Cache, 512 KB L2 Cache
• Für IoT/Embedded optimiert: kleiner, sparsamer als Atom
• Kein GPU, kein Video-Decode, kein AES-NI

Linux (Yocto Project / Poky)

Aufboard Flash (8 MB SPI) enthält Bootloader + minimales Linux. Volles Linux auf microSD (bis 32 GB) bootbar. Zugriff auf GPIO, SPI, I²C, UART, USB, PCIe via Linux-Treiber (sysfs, /dev/spidev, /dev/i2c-x). Programmiersprachen: Python, Node.js, C/C++, SSH, OpenCV, V4L2, ALSA.

Mini-PCIe Slot (Full-Size)

Für Standard Mini-PCIe Karten: Wi-Fi (Intel 7260, Atheros), Bluetooth, mSATA SSD, LTE/3G Modem, LoRa, CAN. Ermöglicht echte Konnektivität & Speichererweiterung.

Micro-SD Slot

Boot-Medium für Linux-Image (ohne SD: nur minimaler Sketch-Speicher im SPI-Flash, nicht persistent). Unterstützt bis 32 GB (SDHC). Library: SD.h (Arduino) / Linux mmcblk0.

Schlüsselkomponenten (Blockdiagramm)

• Eth PHY (RTL8211E)
• USB 2.0 Client (Micro-USB B – Serial/DFU)
• Micro-SD Slot (bis 32 GB)
• ICSP Header (6 Pin, AVR-kompatibel für Shield-Programmierung)
• Spannungsregler (3,3 V Out, 5 V In)
• JTAG Debug (10 Pin, für Firmware-Debug)
• 5 V DC-In (Barrel Jack, 2,1 mm, Center Positive)
• Ethernet RJ45
• GPIO Expander (CY8C9540A, I²C → 12 GPIOs + PWM) – nicht direkt am Quark!
• ADC (ADS7830, I²C, 8-Kanal, 8-Bit) – nicht im SoC!
• Arduino Interface (Pinout Rev3)
• Intel Quark SoC X1000 (400 MHz)
• 256 MB DDR3 RAM (on Package)
• Shield Interface (Rev3 kompatibel)
• RS-232 Serial (3,5 mm Klinke, 3 Pin: TX, RX, GND)
• SPI Flash (8 MB, Bootloader + Sketch)
• USB 2.0 Host (Micro-USB AB – OTG/Host)
• RS-232 Transceiver (MAX3232)
• SPI Flash Program Port (7 Pin, für externes Flash-Programming)

Spezifikationen (Gen 2)

Gen 1 vs Gen 2: Gen 2: 12 V → 5 V Regler onboard (kein externer 5 V Regler nötig), verbessertes Shield-Power-Management, schnellerer Boot, optionales PoE-Modul.

Beispielprojekte

1. DIY Bewegungsmelder-Licht (Galileo + PIR + Relais)

Material

• Intel Galileo Board (Gen 1 oder 2)
• PIR-Sensor (HC-SR501)
• Relais-Modul (5 V, Low-Active oder High-Active)
• Glühbirne + Fassung (E27)
• Schraubenzieher, Kabel, Netzteil (12 V DC für Galileo, 5 V für Relais)

Verdrahtung & Code

1. PIR: VCC→3,3 V (Galileo), GND→GND, OUT→Digital Pin 0
2. Relais: VCC→5 V, GND→GND, IN→Digital Pin 7
3. Netzkabel: Phase → Relais COM, Relais NO → Lampe Mitte, Lampe Außen → Neutralleiter
4. Relais-Schrauben festziehen, Glühbirne einsetzen
5. Alle USB/Netzteile anschließen, Netzstecker rein
6. Sketch hochladen (Arduino IDE / VS Code + PIO):

const int pirPin = 0;
const int relayPin = 7;

void setup() {
  pinMode(pirPin, INPUT);
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, HIGH); // Relais Low-Active? Anpassen!
}

void loop() {
  if (digitalRead(pirPin) == HIGH) {
    digitalWrite(relayPin, LOW); // Licht AN
    delay(30000); // 30 s an
  } else {
    digitalWrite(relayPin, HIGH); // Licht AUS
  }
}

Programmiersprachen & Frameworks

• Arduino IDE / PlatformIO (Sketch, C++ Arduino Core)
• Linux (Yocto) Native: Python 2/3, Node.js, C/C++ (GCC), OpenCV, ALSA, V4L2, SSH
• Kein .NET Mono, kein Java (Standard), kein Go (Standard) – aber nachinstallierbar über OPKG

Weitere Projektideen

Greeny – Smart Greenhouse (Complex)

Ferngesteuertes Mini-Gewächshaus: Galileo Gen 2, Arduino Uno, Wasserpumpe, Acrylbox, Sensoren (Bodenfeuchte, Temp, Licht), Kamera, Web-Interface.

Simple Weather Station

DHT11 (Temp/Feuchte) an Galileo → Anzeige auf Webserver / LCD / MQTT.

Sigma Reading Watch (Wearable)

E-Ink Display, 3D-gedrucktes Gehäuse, Galileo Gen 2 – E-Book Reader am Handgelenk.

Vergleich: Galileo Gen 1 vs. Gen 2

Gen 1: Externer 5 V Regler nötig, Shield-Stromversorgung problematisch, langsamer Boot, keine PoE-Option.
Gen 2: Onboard 12 V→5 V Regler, 12 V DC-In, verbesserte Shield-Power, schnellerer Boot, PoE-HAT Support, GPIO-Expander & ADC per I²C (wie Gen 1).

Raspberry Pi vs. Intel Galileo

Merkmal	Raspberry Pi 3 Model B	Intel Galileo Gen 2
CPU	4× Cortex-A53 @ 1,2 GHz (ARM)	1× Quark X1000 @ 400 MHz (x86)
RAM	1 GB LPDDR2	256 MB DDR3
OS	Raspberry Pi OS (Linux), diverse	Yocto Linux (minimal), Arduino Sketch
GPIO	40 Pin (3,3 V, direkt am SoC)	Arduino Rev3 (via I²C Expander, langsamer!)
ADC	Kein onboard (via MCP3008)	I²C ADC (8-Kanal, 8-Bit, langsam)
Video/GPU	VideoCore IV (H.264, OpenGL ES)	Kein
PCIe / Mini-PCIe	Nein (Compute Module nur)	Ja (Full-Size Mini-PCIe)
Arduino Shields	Via Adapter (z. B. AlaMode)	Nativ (Pinout & 5 V/3,3 V Jumper)

Fazit Vergleich: Pi 3 ist schneller, mehr RAM, Video, günstiger, riesige Community. Galileo: x86, Arduino-Shields nativ, Mini-PCIe, RTC, deterministisches Echtzeit-Verhalten (kein Linux-Jitter im Sketch-Mode). Nischenanwendung.

FAQ

Welchen Prozessor nutzt Galileo?

Intel Quark X1000 (32-bit x86, 400 MHz).

Welches OS läuft auf Galileo?

Yocto Linux (Poky) – minimal, embedded. Arduino Sketches laufen auf Bare-Metal (ohne Linux) oder unter Linux (mit Overhead).

Was kostet ein Galileo Board?

Neu: nicht mehr produziert (EOL 2017). Gebraucht: 40–100 € (Gen 2). Für Einsteiger: Raspberry Pi 4 / ESP32 / Arduino Uno deutlich besser.

Zusammenfassung

Das Intel Galileo Board war ein einzigartiges Hybrid-Board: x86-CPU + Arduino-Pinout + Linux + Mini-PCIe. Es adressierte Nischen (x86-Code-Reuse, PCIe, Shields, deterministisches I/O), scheiterte aber an Performance/Preis vs. ARM (Pi) und mangelnder Software-Reife. Heute: Legacy-Support nur. Für neue Projekte: Raspberry Pi 4/5, ESP32, Arduino Portenta, STM32, RP2040. Historisch interessant für x86-Embedded-Geschichte. Fragen? Gerne!