The AirBoard – La mini-Arduino orientée Internet des Objets

Bonjour à toutes et à tous !

J’aimerais vous parler d’une toute petite carte dont je dispose depuis quelques années. Le but ici est de la présenter, d’effectuer un tour d’horizon de ce qu’elle permet ou non et de vous donner un avis dessus.

Historique

En 2015, un projet sur Kickstarter permettait de financer The AirBoard, une sorte d’Arduino de la taille d’une carte SD et destinée principalement au développement d’objets connectés. En plus de la carte de base, il était possible de commander des cartes d’extensions – on parle de shields ou de modules – pour ajouter une connectivité sans-fil au choix. Par exemple, du Bluetooth Low-Energy (ou BLE), du WiFi, du SigFox ou encore du LoRa.

L’objectif de financement fut atteint sans problème (65014€ récoltés pour un objectif de 10000€) et quelques mois plus tard, je recevais ma carte avec une extension BLE. Depuis, j’ai eu largement le temps de la tester – même si je ne l’ai jamais utilisée pour un projet quelconque – et voici les quelques points importants que j’ai pu retenir de sa prise en main.

Présentation

Taille

Tout d’abord, la carte est vraiment petite. Ces dernières années, j’avais même la fâcheuse tendance à l’emporter partout avec moi tellement j’étais séduit par l’idée d’avoir une espèce d’Arduino de poche. Cela ne m’a finalement servi que pour quelques petits tests logiciels, mais vous devez sûrement saisir l’idée derrière.

L’argument de sa petite taille vous rappelle peut-être ce qu’Intel promettait avec sa carte Edison, qui proposait des performances équivalentes à celles d’un nano-ordinateur – du genre Raspberry Pi – dans une puce de la taille d’une carte SD.

La forme de la carte et de ses extensions n’est pas anodine puisqu’elle épouse celle de modules sans fils qui existaient déjà, notamment pour la connectivité ZigBee. Ce sont d’ailleurs ces modules préexistants qui servent d’extensions pour la carte AirBoard – avec parfois quelques modifications comme pour le module BLE. C’est bien pratique !

Spécificités techniques

Carte AirBoard

https://camo.githubusercontent.com/4b5cea1de39469bc144b588fb25cb77e137d2b54a504af39f65ac515dd0a5c11/687474703a2f2f7777772e746865616972626f6172642e63632f77702d636f6e74656e742f75706c6f6164732f323031352f31312f70696e6f7574312e706e67

La carte embarque un microcontrôleur ATmega328P, le même que l’on peut trouver sur certaines cartes Arduino basiques – notamment le fâmeux Arduino UNO. Le composant est ici intégré sous sa forme réduite pour pouvoir tenir sur la carte et laisser de la place pour le reste.

Toutefois, on se retrouve ici avec un nombre très limité d’entrées/sorties : 7 GPIO, dont 4 pouvant servir pour un bus SPI et 2 pouvant servir comme entrées analogiques ou comme bus I²C. Les broches D3, D10 et D11 peuvent également servir pour une PWM si elles sont utilisées comme sorties numériques. D’ailleurs, la broche D3 peut également servir comme broche d’interruption – pour déclencher une interruption par un événement externe.

Nous avons également 3 broches d’alimentation (5V, 3.3V et la masse), en plus des GPIO. Les autres ports du microcontrôleur sont dédiées aux connexions avec les extensions. Il est théoriquement possible de les utiliser si aucun module n’est connecté, même si c’est compliqué étant donné qu’un module sans-fil est nécessaire pour pouvoir programmer la carte et communiquer avec.

On trouve également un port micro-USB destiné uniquement à la recharge de la batterie soudée sur la carte. En effet, une particularité de cette carte est d’être programmable Over-The-Air, c’est-à-dire ici par le biais d’un dongle et d’une des extensions sans fil compatibles avec cette fonctionnalité (dans mon cas, BLE). À côté du port micro-USB se trouve également un interrupteur pour allumer ou éteindre la carte.

À l’image de la DEL reliée à la broche 13 de la carte Arduino UNO, on peut également trouver une DEL RVB intégrée, que le programme Blink – équivalent du « Hello World! » – fait briller de milles feux. Sans rire, la DEL est très puissante en terme de luminosité. Faites-y attention si vous êtes amené.e.s à l’utiliser.

Carte et dongle BLE

En ce qui concerne le module BLE, il s’agit en fait d’une version modifiée d’une extension déjà existante : BLE-Link, développée par DFRobot (1). Ce module est commandé par un microcontrôleur de type 8051 : le CC2540 de Texas Instruments, qui est dédié à la connectivité BLE (2).

Et c’est exactement la même chose pour le dongle BLE. Il s’agit d’un Bluno Link, toujours développé par DFRobot, et il est commandé par un CC2540. Aussi, à l’instar des dongles accompagnant les souris ou claviers sans fil, ce dongle n’a qu’une seule utilité : permettre de communiquer avec le périphérique auquel il est associé. Ne comptez donc pas dessus pour ajouter une connectivité BLE à votre ordinateur et vous appairer aux autres appareils Bluetooth, ce dongle n’est pas fait pour ça.

La carte BLE-LINK dispose d’un interrupteur pour basculer entre le mode AT – pour le paramétrage du périphérique Bluetooth – et le mode de communication série. Nous pouvons également trouver un bouton poussoir au centre, avec la mention BOOT (concernant le dongle, son bouton BOOT est atteignable par un petit trou sur le côté, assez fin pour y passer un trombone). Ce bouton sert en fait lors de la mise-à-jour du micrologiciel du module, pour démarrer le microcontrôleur CC2540 dans une configuration prête à recevoir une mise-à-jour de son firmware (3).

Deux DEL servent à indiquer le statut de la connexion BLE : une DEL PAIR pour indiquer que le module BLE est appairé et LINK pour indiquer qu’il est connecté.

La carte dispose aussi d’un port micro-USB qui semble faire doublon avec celui de l’AirBoard mais nous allons voir par la suite que ce port a une utilité bien précise.

Prise en main et étude

Le site web de The Airboard est assez concis mais propose une bonne partie de ce qu’il est possible de fournir en termes d’informations concernant le produit. La prise en main qui y présentée est d’ailleurs assez simple : il suffit de brancher le dongle pour faire transiter un programme Arduino vers la carte AirBoard via BLE. Il faut donc que le module BLE soit connecté à la carte AirBoard pour pouvoir programmer cette dernière.

L’IDE Arduino reconnaît le dongle comme un Arduino UNO, mais le programme doit être compilé pour un Arduino Fio.

Note : là où le port USB de l’AirBoard sert uniquement à l’alimentation, celui du BLE-LINK peut servir à communiquer avec l’AirBoard via la connectivité USB du module BLE lui-même. L’IDE Arduino le reconnaîtra d’ailleurs comme un Arduino UNO, à l’instar du dongle. Il faudra également configurer la compilation pour un Arduino Fio. En tentant de transférer un programme directement au BLE-LINK via USB, j’ai été agréablement surpris de constater que cela a fonctionné. On peut donc programmer la carte via USB, sans passer par le dongle, à la seule condition de passer par le port micro-USB du module BLE.

Programmation de la carte

Pour programmer l’AirBoard, il faut avant tout récupérer la bibliothèque TheAirBoard sur la page GitHub dédiée. Cette bibliothèque s’installe, comme les autres bibliothèques Arduino, en décompressant l’archive dans le dossier libraries/ du sketchbook d’Arduino – le répertoire où sont créés les programmes Arduino par défaut. Après cela, il est possible d’avoir accès à la bibliothèque depuis le menu de l’IDE Arduino.

Cette bibliothèque fournit également quelques programmes d’exemple, ainsi que d’autres fichiers comme le dossier android/ qui fournit des applications Android qui vont de pair avec certains programmes d’exemple. Pour l’instant, nous ne nous concentrerons que sur un seul programme d’exemple : Blink, le programme d’exemple le plus simple.

Clignotement

Le programme présenté ici reprend le bon vieil exemple de la DEL qui clignote. Il y a cependant une différence notable : il s’agit ici d’une DEL RVB, c’est à dire qu’elle peut générer plusieurs couleurs par synthèse additive (4). Contrairement à une diode lumineuse qui n’aurait que deux broches + et -, nous avons ici une broche par couleur primaire. La broche ROUGE (sortie 9) ne donne que du rouge, VERT (sortie 5) donne du vert et BLEU (sortie 6)  donne du bleu. Si on alimente plusieurs de ces broches en même temps, on peut obtenir d’autres couleurs en fonction de le la valeur que l’on injecte en sortie analogique (de 0 à 255). Lorsque les trois sorties sont à la valeur maximale, on obtient un blanc éclatant – nos rétines.

Le programme d’exemple ci-dessous reprend le programme Blink proposé par la bibliothèque TheAirBoard, à quelques petites différences près qui sont tout à fait négligeables.

#define VERT 5
#define BLEU 6
#define ROUGE 9

void setup() {
    pinMode(BLEU, OUTPUT);
}

void loop() {
    /* si la luminosité vous dérange, 
       vous pouvez mettre ici la valeur à 1 au lieu de 255, 
       c'est largement suffisant pour cet exemple
    */
    analogWrite(BLEU, 255);
    delay(1000);
    digitalWrite(BLEU, 0);
    delay(1000);
}

Notons aussi que, dans le programme d’exemple, l’allumage se fait avec analogWrite() mais l’extinction se fait avec digitalWrite(). C’est une manière de faire, relativement valable. On peut tout à fait utiliser ces sorties comme des sorties numériques, mais nous n’aurons que le choix de la valeur minimale et la valeur maximale, pas d’entre deux. Aussi, par souci de cohérence et de clarté du code, le programme suivant utilisera la fonction analogWrite() uniquement.

Lampe Morse

Pour tester un peu plus la carte et en faire quelque chose d’un peu plus concret, j’ai décidé de partir sur une sorte de balise de détresse en code Morse. La DEL RVB étant très vive, il est possible d’en faire un signal qui peut se voir très bien dans l’obscurité. Je prends soin également de respecter les règles de base du code Morse international en ce qui concerne les durées du code.

#define VERT 5
#define BLEU 6
#define ROUGE 9

#define TI              250
#define TAAH            (3 * TI)
#define ESPACE_SYMBOLES (TI)
#define ESPACE_LETTRES  (TAAH)
#define ESPACE_MOTS     (7 * TI)

typedef struct lettre_morse    // notez ce jeu de mot tout à fait nullissime
{
  int lettre;
  byte code;
  int taille;
} lettre_morse_t;

lettre_morse_t alphabet[36] = {
  { 'A', 0b01,    2 },
  { 'B', 0b1000,  4 },
  { 'C', 0b1010,  4 },
  { 'D', 0b100,   3 },
  { 'E', 0b0,     1 },
  { 'F', 0b0010,  4 },
  { 'G', 0b110,   3 },
  { 'H', 0b0000,  4 },
  { 'I', 0b00,    2 },
  { 'J', 0b0111,  4 },
  { 'K', 0b101,   3 },
  { 'L', 0b0100,  4 },
  { 'M', 0b11,    2 },
  { 'N', 0b10,    2 },
  { 'O', 0b111,   3 },
  { 'P', 0b0110,  4 },
  { 'Q', 0b1101,  4 },
  { 'R', 0b010,   3 },
  { 'S', 0b000,   3 },
  { 'T', 0b1,     1 },
  { 'U', 0b001,   3 },
  { 'V', 0b0001,  4 },
  { 'W', 0b011,   3 },
  { 'X', 0b1001,  4 },
  { 'Y', 0b1011,  4 },
  { 'Z', 0b1100,  4 },
  { '1', 0b01111, 5 },
  { '2', 0b00111, 5 },
  { '3', 0b00011, 5 },
  { '4', 0b00001, 5 },
  { '5', 0b00000, 5 },
  { '6', 0b10000, 5 },
  { '7', 0b11000, 5 },
  { '8', 0b11100, 5 },
  { '9', 0b11110, 5 },
  { '0', 0b11111, 5 },
};

#define TAILLE_ALPHABET (sizeof(alphabet) / sizeof(lettre_morse_t))

void point() {
  digitalWrite(ROUGE, HIGH);
  digitalWrite(VERT, HIGH);
  digitalWrite(BLEU, HIGH);
  delay(TI);
  digitalWrite(ROUGE, LOW);
  digitalWrite(VERT, LOW);
  digitalWrite(BLEU, LOW);
}

void trait() {
  digitalWrite(ROUGE, HIGH);
  digitalWrite(VERT, HIGH);
  digitalWrite(BLEU, HIGH);
  delay(TAAH);
  digitalWrite(ROUGE, LOW);
  digitalWrite(VERT, LOW);
  digitalWrite(BLEU, LOW);
}

void sendLetter(lettre_morse_t lm) {
  if (lm.taille <= 0)
    return;

  int b = lm.taille - 1;
  byte code = lm.code;
  for (; b >= 0; b--) {
    if ((code > b) == 0) {
      point();  // Point
    } else {
      trait();   // Trait
    }
    delay(ESPACE_SYMBOLES);
  }
  delay(ESPACE_LETTRES - ESPACE_SYMBOLES);
}

void sendLetter(int lettre) {
  lettre_morse_t *plm = &alphabet[0];
  while (plm != NULL) {
    if (plm->lettre == lettre) {
      sendLetter(*plm);
      plm = NULL;
    } else {
      plm++;
    }
  }
}

void setup() {
  pinMode(ROUGE, OUTPUT);
  pinMode(VERT, OUTPUT);
  pinMode(BLEU, OUTPUT);
  Serial.begin(115200);
}

bool espace = false;

void loop() {
  if (Serial.available() > 0) {
    espace = true;
    int letter = Serial.read();
    if (isspace(letter) == 0) {
      if (islower(letter)) {
        letter = toupper(letter);
      }
      if (isupper(letter)) {
        Serial.print("Sending... ");
        sendLetter(letter);
        Serial.write(letter);
        Serial.println("");
      }
    } else {
      delay(ESPACE_MOTS);
    }
  } else {
    if (espace) {
      delay(ESPACE_MOTS);
      espace = false;
    }
  }
}

Sans doute me direz-vous que ce programme ne semble pas si différent d’un programme assez classique pour toute carte Arduino qui disposerait d’une DEL RVB et d’une liaison série ? Et vous auriez parfaitement raison. Pour communiquer avec l’AirBoard via BLE, il nous faut utiliser une application capable de fournir un terminal série via Bluetooth. Il en existe plein et par principe on pourrait se dire que n’importe laquelle suffirait. Dans la pratique, ce n’est pas du tout le cas.

En fait, la seule chose que l’on puisse faire c’est utiliser l’application Bluno Basic Demo – ici pour Android, mais il existe une version pour iOS. Cette application Android est développée par DFRobot et apparemment c’est la seule application qui fonctionne avec le BLE-LINK ! Les autres applications ne parviennent même pas à se connecter à la carte et le wiki de DFRobot lui-même explique que le module BLE-LINK est incompatible avec la plupart des applications Serial Bluetooth !

En plus, il a fallu que je bataille un moment à reparamétrer le module BLE-LINK via le mode AT, parce que l’application refusait de se connecter au BLE-LINK. En fin de compte, j’ai finalement pu communiquer avec l’AirBoard via l’application et envoyer un message qui a bien été retransmis en Morse.

Et maintenant ? (Que vais-je faire ?)

C’est là tout le potentiel de cette carte. Et c’est malheureusement assez décevant.

À l’heure où j’écris ces lignes, le site de The AirBoard existe encore mais cette carte n’est plus vendue. Le revendeur désigné par le site, Seeed Studio, indique en effet être en rupture de stock, et je doute fort qu’il soit à nouveau approvisionné à l’avenir. Il n’est donc plus possible de s’en procurer, sauf si vous trouvez un revendeur qui en a encore en stock, mais je ne vous recommande pas son achat. Une carte qui n’est plus vendue n’est pas viable pour produire quoi que ce soit. Elle devient une curiosité technologique, voire un objet de collection, mais rien de plus.

The AirBoard promettait pas mal de choses mais, en toute franchise, elle n’a pas su tenir ses engagements. Faire une carte dans l’esprit d’Arduino tout en se reposant sur des composants tout ce qu’il y a de plus propriétaire, c’est casse-gueule. Si quelqu’un voulait reprendre le projet aujourd’hui, ce serait impossible, à moins de reprendre toute la partie ouverte et remplacer les parties fermées par autre chose plus en accord avec la philosophie Arduino – exit donc le module BLE-LINK qui repose sur un composant propriétaire.

Mais même en admettant que quelqu’un veuille effectivement reprendre le projet, est-ce que cela réussirait ? Probablement pas.

L’autre facteur qui fait que ça n’a pas fonctionné – et c’est très probablement le plus important – c’est que le marché des objets connectés est une chimère. Depuis 2012, l’âge d’or des startups nous a survendu du rêve avec des objets connectés de toutes sortes pour faciliter notre quotidien – parfois à outrance. Mais soyons honnêtes : qui a réellement besoin d’une cafetière connectée, d’un frigo connecté, d’un grille-pain connecté, d’un auto-cuiseur connecté, etc connecté ? Et surtout, où sont-ils aujourd’hui ces objets ?

Au même titre que certains profitent de YouTube pour vendre des VPN, la plupart des startups a essayé – et essaye encore parfois – de nous vendre des objets dont on n’a pas vraiment besoin. Et c’est pour ça que la plupart des projets qui tournaient autour de l’Internet des Objets n’ont jamais vu le jour, sinon pour avoir une très courte vie. C’est le cas de The AirBoard, mais c’est aussi le cas de Intel Edison qui promettait plus ou moins la même chose (5).

En clair, en résumé : il n’y a pas de vrai marché pour les objets connectés – sauf peut-être pour un public de niche, et encore.

Conclusion

Je pense qu’on a fait le tour du sujet en ce qui concerne l’AirBoard. La carte est assez minimaliste, bien qu’elle permette pas mal de choses sans pour autant se démarquer de n’importe quelle autre carte Arduino. Cela reste un objet sympathique, empreint de nostalgie pour ma part puisqu’il me rappelle une époque d’insouciance. C’est aussi et surtout une carte encore relativement fonctionnelle – même s’il y a probablement moins cher et mieux foutu, je peux très bien me contenter de ce que j’ai à disposition si c’est suffisant.

J’espère que cet article vous aura appris des choses et vous aura inspiré. Quant à moi, je retourne bidouiller et j’espère vous retrouver pour d’autres articles. On ne sera probablement pas sans reparler de Bluetooth. C’est un sujet assez vaste et il y a d’autres pistes que j’aimerais explorer.

Sur ce, je vous laisse et je vous dis à bientôt.

Nicolas SAN AGUSTIN

 

(1) DFRobot est un revendeur asiatique qui fabrique ses propres cartes et modules Arduino. Je possède quelques-uns de leurs produits qui sont globalement corrects. Ils sont parmi les premiers à s’être implantés sur ce marché, disposent d’une communauté active et proposent une documentation assez fournie, à l’instar d’autres revendeurs importants du même genre comme Adafruit, Seed Studio ou Sparkfun.

(2) C’est un composant que je connais assez bien puisque je me suis fait la main dessus lors d’une de mes expériences professionnelles entre 2012 et 2015. Il avait alors le mérite d’être LE composant incontournable pour quiconque voulait intégrer du Bluetooth Low Energy, tout fraîchement arrivé sur le marché. Mais, pour programmer le CC2540, il faut utiliser un IDE propriétaire, IAR Embedded Workbench, qui coûte cher, ainsi que la stack BLE propriétaire de Texas Instruments. C’est certes un bon composant, même s’il existe désormais mieux pour moins cher, mais cela met un sacré coup à toute la philosophie d’ouverture du système Arduino.

(3) La carte BLE-LINK ainsi que le dongle Bluno Link peuvent tous les deux être mis à jour en suivant les instructions de la page dédiée sur le wiki de DFRobot. Mais cela fait des années qu’il n’y a pas eu de nouvelle version du firmware. On ne peut pas en tirer grand chose de plus, étant donné que le CC2540 est une vraie boîte noire et le code source n’est même pas mis à disposition – ce qui m’aurait étonné cela dit. On peut juste supposer que le programme du dongle fait transiter le sketch Arduino vers le module BLE, qui va ensuite se charger de programmer la carte AirBoard.

(4) La conception de l’AirBoard ne permet pas de programmer la carte directement, probablement à cause de l’absence d’un microcontrôleur intermédiaire gérant l’USB nativement. Sur un Arduino UNO, c’est un ATmega16u2 qui se charge de faire le relais entre l’IDE Arduino et l’ATmega328P. À noter qu’il n’est pas possible non plus d’utiliser le port micro-USB de la carte AirBoard afin d’avoir une communication Serial, pour faire du debug par exemple. Ce port micro-USB est uniquement là pour l’alimentation, ce qui est bien dommage.

(5) Je règle ici quelques comptes en expliquant ce qu’est la synthèse additive par rapport à la synthèse soustractive. On a coutume généralement de dire que les trois couleurs primaires – et non pas quatre comme le prétendait un certain Bruno Vandelli – sont le rouge, le jaune et le bleu. En réalité, il s’agit du magenta, du jaune et du cyan, et elles ne sont primaires que dans le cas de la synthèse dite soustractive, c’est-à-dire qu’en partant d’un blanc immaculé on peut mélanger des couleurs jusqu’à obtenir du noir. Dans la synthèse additive, c’est l’inverse. Les qu… trois couleurs primaires sont le rouge, le vert et le bleu, et on part du noir pour arriver vers le blanc. C’est d’ailleurs ce dernier modèle qui est le plus conforme à la réalité : le noir est l’absence de lumière visible et le blanc est la combinaison de toutes les ondes lumineuses visibles par l’œil humain – qui sont le rouge, le vert et le bleu.
Je préfère le préciser parce que j’ai déjà vu des gens s’énerver – à tort – en voyant désigner le rouge, le vert et le bleu comme les trois couleurs primaires.

(6) D’ailleurs, j’ai aussi une Intel Edison dans les cartons, avec un ensemble de composants de Seeed Studio – encore eux -, que j’ai obtenus gratuitement lors d’un hackathon. Il faudra peut-être que j’en parle un de ces jours, ce serait bête de ne pas profiter de presque 150€ de matos gratos.

Previous Post

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *