Intel Galileo

De LOAD.

Sommaire

Intro

Avec l'aide de françois et waldeck nous avons découvert les nouvelles cartes intel Galileo :
une carte un peut plus grosse qu'un raspeberry qui combine la puissance d'un coeur x86 à 400mhz / 256mb ram à la facilité de mise en oeuvre d'arduino.
Au moment du déballage le marketing nous rappel win95 et son "where do you want to go today ?", nous avons droit à "what will you make ?"

Photos

Fichier:galileo_boite1.jpg
Fichier:galileo_boite2.jpg
Fichier:galileo_boite3.jpg
Fichier:galileo_carte1.jpg
Fichier:galileo_carte2.jpg
Fichier:galileo_ensemble.jpg
Fichier:galileo_carte3.jpg
Fichier:galileo_carte4.jpg

Composants

Nous voyons les différents composants de la carte :

- le proc x86 intel quark SOC X1000
- 2 puces pour 256mb de ram
- les IOs compatibles shield arduino et 3.3 / 5V par jumper
- un port prog ICSP
- un port debug JTAG
- GPIO expander
- un CAN
- un port dediprog pour les 8mb de flash
- un RJ45 100mbps
- un "coin HDR" permettant de brancher une pile lithium 3V pour alimenter la RTC
- un port PCI-E 1x
- le port µSD
- un USB Host
- un USB arduino, mais aussi utilisable pour créer un slave usb
- un jack contenant du rs232
- une led gpio intégré sur la carte
- la prise d'alimentation 5V (Toujours alimenter la carte en 5V avant de brancher l'usb slave)

Prise en main

Après avoir déballé la carte, brancher l'alimentation (fournie) le cable micro-usb (non fournit :-/) et décompressé la suite arduino (spécialement conçue pour cette carte par intel : https://communities.intel.com/docs/DOC-22226 mais la version normale d'arduino est sensé supporté cette carte)
Nous avons sélectionné l'exemple "blink", compilé (48 ko de code pour faire clignoter une led!) / transféré et HOP! la led clignotte.
S'en suit une phase de tests divers où nous avons découvert que suite à un reset ou une coupure d'alimentation (notez d'ailleurs qu'il est fortement déconseillé/interdit de brancher le micro USB sans alimenter la carte en 5V) le sketch arduino est perdu !
Il s’avère que les 8 MB de flash présent sur la carte servent à un GRUB préinstallé qui se charge de booter une distrib linux ou un sketch arduino éventuellement présent sur une carte µSD.
En l'absence de carte SD le sketch est uploadé en ram.
D'autre part 512ko de static-ram sont présent et doivent permettre le stockage du sketch mais la doc n'étant pas très claire sur ce point nos recherches vont continuer.

Nous avons également testé le programme d’accès au CAN par serveur web, et on retrouve la "convivialité" arduino : en 3 clics l'ensemble est fonctionnel et nous pouvions remonter la valeur des pattes d'IO analogique sur une page web.

Pérennité des sketchs

La carte intel galileo comporte 8Mb de flash dédié à grub.
Le seul moyen de rendre un sketch arduino permanent est de le copier sur une carte µSD La S-ram intégré au SOC ne peut pas être utilisé pour cela : c'est une ram static capable de fonctionner à n'importe quelle fréquence (y compris 0Hz) mais qui perd son contenu lors d'un reset ou d'une coupure d'alimentation.

Evaluation des perfs

Les GPIO sont lentes (230Hz maxi dixit la doc intel) car pour chaque changement d'état il faut passer par l'expandeur SPI.
Nous avons créer un code permettant d'évaluer les perfs sur des calculs d'entier et de flotant

const int ledPin =  13;      // the number of the LED pin

int ledState = LOW;             // ledState used to set the LED
long previousMillis = 0;        // will store last time LED was updated
long interval = 3000;           // interval at which to blink (milliseconds)
unsigned long currentMillis;    //temps actuel
unsigned long fin_bench;        //temps du bench
unsigned long debut_test, var1, var2;
float flo1, flo2;
float flo_res[11];
unsigned long result[10];

#define duree_cpu  520000
#define duree_fpu  57000
  
void setup() {
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);      
  Serial.begin(57600);
  previousMillis = millis();
}
//-------------------------------------------------------------
unsigned long int compute(unsigned long int var)
{
  var++;
  return var;  
}
//-------------------------------------------------------------
void loop()
{
  currentMillis = millis();                      //temps actuel
  if(currentMillis - previousMillis >= interval) {    //intervalle dépassé
    // save the last time you blinked the LED
    previousMillis = currentMillis;  

    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW)
    {
      ledState = HIGH;
    }
    else
      ledState = LOW;
      
    // set the LED with the ledState of the variable:
    digitalWrite(ledPin, ledState);
  //boucle de test CPU
    Serial.print("debut test CPU \n");
    debut_test = millis();
    for (var2=0; var2 < duree_cpu; var2++)
    {
      for (var1=0; var1 < 10; var1++)
      {
        result[var1] = compute(var1);
      }
    }
    fin_bench = millis();
        for (var1=0; var1 < 10; var1++)
    {
      Serial.print(result[var1]);
      Serial.print(" ");
    }
    Serial.print("\nfin, perf : ");
    Serial.print((duree_cpu * 10) / (fin_bench - debut_test));
    Serial.print("\n\n");

  //boucle test FPU
    Serial.print("debut test FPU \n");
    debut_test = millis();
    for (var2=0; var2 < duree_fpu; var2++)
    {
      for (var1=0; var1 < 10; var1++)
      {
        flo1 = var1;
        flo2 = flo1 / 102;
        flo_res[var1] = flo2;
        flo_res[var1+1] = flo2 / 1004;
      }
    }
    fin_bench = millis();
    for (var1=0; var1 < 11; var1++)
    {
      Serial.print(flo_res[var1]);
      Serial.print(" ");
    }
    Serial.print("\nfin, perf : ");
    Serial.print((duree_fpu * 100) / (fin_bench - debut_test));
    Serial.print("\n\n");
  }
}

Résultat de perfs

Sur Galileo

debut test CPU 
1 2 3 4 5 6 7 8 9 10 
fin, perf : 42622

debut test FPU 
0.00 0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.00 
fin, perf : 20357

Sur ATmega2560 @ 16mhz

debut test CPU
1 2 3 4 5 6 7 8 9 10
fin, perf : 799

debut test FPU
0.00 0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.00
fin, perf : 162


=> par rapport à un atmega2560 @ 16mhz : rapport de 53 en faveur de galileo sur des additions et branchement entier.
rapport de 125 sur les calculs en flottant (galileo dispose d'une FPU)

Sur pic 18f2550 @48mhz (12 MHz effectif), compilateur xc8 en version free / pro

CPU : 130 / 180
FPU : 63 / 74

Résultat plutôt catastrophique sur cette architecture (Harward RISC) dont j’espérais une meilleure efficacité des instructions mono-cycle... Le compilo coute 1000$ en version PRO

Sur ESP8266 core Xtensa LX106 32bits 80MHZ compilé avec arduino

CPU : 10600
FPU : 1461

>10fois la puissance d'un AVR 16Mhz, pour une carte à prix équivalente.(avec du wifi et de la flash)

Les tests suivants ont étés fait sous archlinux/ubuntu avec g++
Sur Raspeberry Pi (700Mhz arm)

CPU : 9 700
FPU : 46 000

La Fpu du rapsberry à l'air plus puissante, la partie entier moins.

Sur Intel x86 ATOM N450 (1.66Ghz)

CPU : 70 000
FPU : 90 000


Sur AMD x86 Phenom X4 (3.9Ghz)

CPU : 294 000
FPU : 750 000
Outils personnels