Il y a un quart d’heure de cela, un livreur a déposé sur mon bureau deux exemplaires (pour limiter les frais de port) d’un nouveau terrain de jeu pour hackers de Linux embarqué : le BeagleBone Black. Je vous propose un petit tour de piste rapide…

Les dimensions hors-tout (y compris les connecteurs) du BeagleBone Black sont de 90x55mm pour une épaisseur de 19mm. Si l’on introduit une carte micro-SD dans le support prévu, la longueur hors-tout passe à 92 mm environ. Les dimensions sont approximativement les mêmes que celles du champion 2012 de Linux embarqué : le Raspberry Pi.

Comparaison inévitable

Les deux cartes évoluent dans la même gamme de prix : j’ai commandé mes exemplaires chez Mouser Electronics pour 37,13 €TTC chacun (le port est gratuit si le montant de la commande est supérieur à 65€ d’où l’intérêt d’en commander deux d’un coup).

Le BeagleBone Black se distingue visuellement de son concurrent par deux aspects principaux : la couleur du circuit imprimé bien entendu et sa forme de rectangle aux coins arrondis. Au fait, ce n’est pas breveté ça ?   😉

Les deux cartes proposent une sortie vidéo HDMI (connecteur micro-HDMI pour BeagleBone Black), une prise USB Host (deux sur les Raspberry Pi modèle B) et un connecteur Ethernet RJ45.Voyons à présent les différences.

Nous trouverons sur le Raspberry Pi uniquement :

• un connecteur vidéo composite (pratique pour connecter un petit écran de radar de recul automobile comme nous l’avons vu dans cet article)
• une sortie audio stéréo.
• un connecteur HE10 26 broches regroupant : des alimentations +3.3V et +5V, un port SPI, un port I²C, un port série et un PWM. Ces broches peuvent être utilisées directement sous forme de fonctions GPIO indépendantes (voir cet article par exemple).

Sur le BeagleBone Black :

• une prise micro-USB OTG (dont nous reparlerons plus bas) ; cette prise existe sur le Raspberry Pi mais ne sert qu’à l’alimenter
• une prise d’alimentation 5V continu.
• deux connecteurs HE10 2×23 broches, comportant : 4 ports série, 1 port SPI, 1 port I²C, 4 timers, 1 port CAN, 2 PWM, 7 entrées analogiques, un connecteur LCD, et une soixantaine de GPIO…

L’avantage serait donc plutôt au Raspberry Pi pour la création rapide d’un Media Player (grâce aux sorties audio et vidéo accessibles directement) et plutôt au BeagleBone Black pour les interfaces avec d’autres équipements en raison de la richesse des ports d’extension.

Premier branchement

À peine la carte sortie de sa boîte, on remarque qu’elle était accompagnée d’un petit câble USB (connecteur A – connecteur OTG) classique. Évidemment, la tentation est grande de brancher le câble sur un PC pour alimenter le BeagleBone et voir s’il s’allume. Allons-y !

Immédiatement la led Power s’allume, comme on s’y attendait. Plus surprenant, les trois autres leds clignotent, indiquant une activité du système. En effet, contrairement à son concurrent le Raspberry Pi et à son prédécesseur le BeagleBone blanc, le Black dispose d’une mémoire flash eMMC de 2Go intégrée et préchargée avec la distribution Ångström. Inutile donc de préparer une carte micro-SD pour booter.

Sur le PC auquel le BeagleBone Black est connecté, une fenêtre s’ouvre après la détection par l’automonteur du nouveau périphérique. Voyons son contenu.

[~]$ cd /media/BEAGLEBONE/
[BEAGLEBONE]$ ls
App          Docs     LICENSE.txt  README.md  u-boot.img
autorun.inf  Drivers  MLO          START.htm  uEnv.txt
[BEAGLEBONE]$ cat README.md 
beaglebone-getting-started
==========================

BeagleBone Getting Started Guide

Please open START.htm in your web browser to view the guide.

Please submit any improvements to https://github.com/jadonk/beaglebone-getting-started.

For bone101, see https://github.com/jadonk/bone101.
[BEAGLEBONE]$

Ouvrons donc le fichier /media/BEAGLEBONE/START.htm dans un navigateur. Une jolie page de présentation explique comment installer si besoin sur son PC les drivers pour dialoguer avec le BeagleBone Black. Ces drivers (usbnet, etc.) sont déjà inclus dans les noyaux Linux des distributions classiques pour lesquelles il n’y a donc rien à faire.

La page commence par conseiller de ne lire la documentation qu’en dernier ressort. Ça me convient parfaitement, je vais essayer l’exploration directe. Vérifions les interfaces réseau disponibles.

[BEAGLEBONE]$ ifconfig 
eth0      Link encap:Ethernet  HWaddr b0:48:7a:83:3f:86  
          inet adr:192.168.5.1  Bcast:192.168.5.255  Masque:255.255.255.0
          [...]

eth1      Link encap:Ethernet  HWaddr 00:1d:09:23:b5:8e  
          [...]

eth2      Link encap:Ethernet  HWaddr c8:a0:30:ab:96:79  
          inet adr:192.168.7.1  Bcast:192.168.7.3  Masque:255.255.255.252
          adr inet6: fe80::caa0:30ff:feab:9679/64 Scope:Lien
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          Packets reçus:4860 erreurs:0 :0 overruns:0 frame:0
          TX packets:2876 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 lg file transmission:1000 
          Octets reçus:6747591 (6.7 MB) Octets transmis:390120 (390.1 KB)

lo        Link encap:Boucle locale  
          inet adr:127.0.0.1  Masque:255.0.0.0
          [...]

tun0      Link encap:UNSPEC  HWaddr 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00  
          inet adr:192.168.4.1  P-t-P:192.168.4.2  Masque:255.255.255.255
          [...]
[BEAGLEBONE]$

La nouvelle interface apparue sur mon poste de travail est eth2 sur le sous-réseau 192.168.7. L’adresse 192.167.7.1 étant visiblement affectée à mon PC, j’essaye de « ping-er » la 192.168.7.2 (je l’ai également vue sur un lien de la page START.htm).

[BEAGLEBONE]$ ping 192.168.7.2
PING 192.168.7.2 (192.168.7.2) 56(84) bytes of data.
64 bytes from 192.168.7.2: icmp_req=1 ttl=64 time=0.781 ms
64 bytes from 192.168.7.2: icmp_req=2 ttl=64 time=0.382 ms
^C
--- 192.168.7.2 ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1000ms
rtt min/avg/max/mdev = 0.382/0.581/0.781/0.200 ms
[BEAGLEBONE]$

Le ping fonctionne, nous pouvons donc probablement nous connecter sur la BeagleBone Black par le réseau. Essayons telnet.

[BEAGLEBONE]$ telnet 192.168.7.2
Trying 192.168.7.2...
telnet: Unable to connect to remote host: Connection refused
[BEAGLEBONE]$

Pas de serveur telnetd ; ça vaut mieux, ce n’est pas très sûr. Essayons ssh en nous connectant sous root avec le mot de passe root (à tout hasard).

[BEAGLEBONE]$ ssh root@192.168.7.2
The authenticity of host '192.168.7.2 (192.168.7.2)' can't be established.
RSA key fingerprint is 1e:24:70:97:2d:56:e5:58:9a:95:3b:b3:07:e3:85:8a.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '192.168.7.2' (RSA) to the list of known hosts.
root@192.168.7.2's password: 
root@beaglebone:~#

Ça fonctionne, testons quelques commandes.

Exploration rapide

root@beaglebone:~# ls /
bin   dev  home  lost+found  mnt   run	 sys  usr
boot  etc  lib	 media	     proc  sbin  tmp  var
root@beaglebone:~# cat /proc/cpuinfo 
processor	: 0
model name	: ARMv7 Processor rev 2 (v7l)
BogoMIPS	: 990.68
Features	: swp half thumb fastmult vfp edsp thumbee neon vfpv3 tls 
CPU implementer	: 0x41
CPU architecture: 7
CPU variant	: 0x3
CPU part	: 0xc08
CPU revision	: 2

Hardware	: Generic AM33XX (Flattened Device Tree)
Revision	: 0000
Serial		: 0000000000000000
root@beaglebone:~# free
             total       used       free     shared    buffers     cached
Mem:        510644     145912     364732          0      10784      71988
-/+ buffers/cache:      63140     447504
Swap:            0          0          0
root@beaglebone:~# df
Filesystem     1K-blocks    Used Available Use% Mounted on
rootfs           1738184 1288896    359324  79% /
/dev/root        1738184 1288896    359324  79% /
devtmpfs          255216       0    255216   0% /dev
tmpfs             255320       0    255320   0% /dev/shm
tmpfs             255320     196    255124   1% /run
tmpfs             255320       0    255320   0% /sys/fs/cgroup
tmpfs             255320       4    255316   1% /tmp
root@beaglebone:~#

Nous voyons donc la présence d’un processeur Arm Cortex-A8 AM33XX (AM3359 d’après la documentation du BeagleBone Black), avec 512Mo de mémoire.

root@beaglebone:~# uname -a
Linux beaglebone 3.8.6 #1 SMP Sat Apr 13 09:10:52 CEST 2013 armv7l GNU/Linux
root@beaglebone:~# ls -l /proc/config*
-r--r--r-- 1 root root 24770 Jan  1 00:04 /proc/config.gz
root@beaglebone:~#

Le noyau fourni par la distribution Ångström est apparemment un kernel standard (vanilla) récent. L’option de configuration SMP (Symetrical Multi Processing) est un peu surprenante pour un système dont le CPU est uni-cœur, d’autant qu’il n’y a pas l’option PREEMPT. Le fichier de configuration du kernel étant présent, on pourra facilement le recompiler en modifiant les options qui nous intéressent (par exemple pour le rendre plus réactif dans une optique temps réel).

root@beaglebone:~# gcc --version
gcc (Linaro GCC 4.7-2013.02-01) 4.7.3 20130205 (prerelease)
Copyright (C) 2012 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

root@beaglebone:~#

Le compilateur gcc est présent, ce qui permettra de compiler rapidement de petites applications, même si on préférera probablement utiliser un hôte de développement plus puissant (avec une chaîne de compilation croisée) pour les projets importants.

Raspberry Pi vs BeagleBone Black : CPU

On peut réaliser quelques petits tests rapides depuis le shell pour comparer des puissances de calcul de deux CPU. L’un des plus simples consiste à demander à l’utilitaire bc de calculer π avec un nombre de décimales relativement élevé (ici j’ai choisi 5000 décimales) et de comparer le temps d’exécution.

root@beaglebone:~# time   echo "scale=5000; a(1)*4" | bc -l
3.141592653589793238462643383279502884197169399375105820974944592307\
81640628620899862803482534211706798214808651328230664709384460955058\
[...]
74351362222477158915049530984448933309634087807693259939780541934144\
73774418426312986080998886874132604720

real	2m2.431s
user	2m2.189s
sys	0m0.035s
root@beaglebone:~#

L’expression que l’on passe sur l’entrée standard de bc signifie : « utiliser des réels avec 5000 décimales » (bc travaille en virgule fixe, pas en virgule flottante) et « calculer arctangente de 1 (donc π/4) multiplié par 4« .
Essayons sur Raspberry Pi (distribution Raspbian).

pi@raspberrypi:~$ time   echo "scale=5000; a(1)*4" | bc -l
3.141592653589793238462643383279502884197169399375105820974944592307\
81640628620899862803482534211706798214808651328230664709384460955058\
[..]
74351362222477158915049530984448933309634087807693259939780541934144\
73774418426312986080998886874132604720

real    2m59.809s
user    2m58.970s
sys     0m0.040s
pi@raspberrypi:~$

Malgré son nom, le Raspberry Pi n’est pas avantagé pour ce calcul, il met 2’58 pour le calcul alors que le BeagleBone Black ne met que 2’02.

Un autre test simple est d’écrire un petit programme qui réalise des boucles actives (en n’utilisant que des compteurs entiers, pas de nombres réels). Par exemple celui-ci.

boucles.c:
#include 
#include 

int main(int argc, char * argv[])
{
	int n1, n2;
	int i, j;
	if (argc < 3) {
		fprintf(stderr, "usage: %s n1 n2\n", argv[0]);
		exit(EXIT_FAILURE);
	}
	if (sscanf(argv[1], "%d", & n1) != 1) {
		fprintf(stderr, "Wrong value: %s\n", argv[1]);
		exit(EXIT_FAILURE);
	}
	if (sscanf(argv[2], "%d", & n2) != 1) {
		fprintf(stderr, "Wrong value: %s\n", argv[2]);
		exit(EXIT_FAILURE);
	}
	for (i = 0; i < n1; i ++)
		for (j = 0; j < n2; j ++)
			;
	return EXIT_SUCCESS;
}

Ce code effectue deux boucles entières imbriquées (pour pouvoir compter plusieurs milliards sans être gêné par la taille des int sur 32 bits). Compilons-le et exécutons-le sur Raspberry Pi

pi@raspberrypi:~$ gcc boucles.c -o boucles -O0
pi@raspberrypi:~$ time  ./boucles 100000 100000

real    1m46.511s
user    1m46.350s
sys     0m0.010s
pi@raspberrypi:~$

Ce programme a réalisé dix milliards d’itérations en 1’46 sur le Raspberry Pi. Notez l’option -O0 (la lettre O majuscule suivie d’un zéro) de gcc afin de s’assurer qu’aucune optimisation n’a lieu qui pourrait amputer nos boucles.

Essayons maintenant sur le BeagleBone Black.

root@beaglebone:~# gcc boucles.c -o boucles -O0
root@beaglebone:~# time  ./boucles 100000 100000

real	1m10.834s
user	1m10.758s
sys	0m0.014s
root@beaglebone:~#

Le BeagleBone Black a mis 1’10 ce qui confirme notre première impression sur sa rapidité de calcul par rapport à son concurrent. Notons que sur un PC d’entrée de gamme actuelle, la même boucle active s’exécute en une trentaine de secondes, ce qui nous permet de situer les performances que l’on peut attendre de ces processeurs embarqués.

Conclusion

Le BeagleBone Black s’affirme comme un très sérieux concurrent pour le Raspberry Pi. Dans la même gamme de prix, il offre une puissance CPU un peu supérieure, et une connectivité plus riche. Il bénéficie également d’une compatibilité avec les « capes » (cartes d’extension qui s’empilent en se connectant sur les deux ports HE10) précédemment développées pour le premier BeagleBone.

Pour l’utilisation en Media Player, je pense que le Raspberry Pi est plus intéressant car il dispose directement d’une sortie Audio et d’une interface HDMI standard. En revanche pour les applications plus orientées vers le dialogue avec des périphériques et équipements hétérogènes (ce qui me concerne plus particulièrement), le BeagleBone Black va probablement s’imposer rapidement.