Le binaire ou Comment compter jusqu’à plus de 1000 avec ses dix doigts

Bonjour à toutes et à tous !

Il y a quelques temps, en parcourant le site Reddit, je suis tombé sur un post du subreddit r/Jokes où quelqu’un racontait la blague suivante :

"Je peux compter sur une main le nombre de fois où je suis allé à Tchernobyl. C'est douze"

« Je peux compter sur une main le nombre de fois où je suis allé à Tchernobyl. C’est douze »

Pour la plupart des gens, c’est une blague tout à fait valable. Je pense que j’aurais ri aussi, ou du moins souri, si je n’avais pas été au courant qu’il est parfaitement possible de compter jusqu’à douze, voire plus, sur une seule main – à condition d’avoir au moins quatre doigts à cette main.

Mais d’abord, comme d’habitude, un petit peu de mise en contexte.

Compter avec les doigts

Les bases

Une manière très naturelle de compter est simplement d’énumérer ce que l’on cherche à compter. Si j’ai cinq pommes devant moi, chaque pomme désignera un seul élément, un seul chiffre, et les cinq pommes formeront le nombre 5. En tout cas, en base 1 ou système unaire.

La base, en mathématiques, désigne le nombre de valeurs que peut prendre un chiffre qui compose un nombre. Notre système numérique utilise généralement la base 10, puisque nos chiffres prennent dix valeurs, allant de 0 à 9. C’est ce que l’on appelle communément le système décimal.

Qu’importe la base utilisée, lorsqu’un chiffre doit être incrémenté au-delà de sa valeur maximale, il revient à sa valeur minimale et l’on incrémente la valeur du chiffre suivant. C’est ainsi qu’en base 10 on passe, par exemple, du nombre 9 au nombre 10. (1)

En base 1, il n’y a qu’une valeur possible. Donc, pour rajouter un élément, on rajoute simplement un chiffre.

Un système pratique mais limité

C’est un système de comptage très rudimentaire, très simple. Les enfants apprennent à compter en utilisant leurs doigts. Seulement, comme vous avez dû vous en rendre compte au bout d’un moment, on se retrouve assez vite limité par le nombre de doigts : dix pour la plupart des gens, moins de dix pour les plus malchanceux et douze pour quelques rares personnes.

Les petits malins diront qu’il suffit d’utiliser ses doigts de pieds et les plus lourds diront qu’on peut ajouter encore autre chose… Mais je vais vous montrer qu’il est possible de repousser – voire carrément exploser – cette limite à deux chiffres en utilisant simplement la base 2, communément appelé le système binaire.

Compter MIEUX avec les doigts

Pour passer de la base 1 à la base 2, c’est très simple : il suffit de rajouter une valeur possible à nos chiffres. Pour un doigt, il suffit de prendre en compte l’état du doigt : baissé pour la valeur 0 et levé pour la valeur 1.

En pratique, cela donne ceci :

Décompte de 0 à 8, en binaire, avec les doigts d'une seule main

Décompte de 0 à 8, en binaire, avec les doigts d’une seule main

Notez que c’est déjà un peu plus optimal puisqu’en base 1 les doigts baissés sont tout simplement inutiles.

Si on se perd dans son comptage, il est possible de reconstituer le nombre en utilisant un peu de calcul mental. Chaque chiffre peut être multiplié par sa base portée à la puissance de sa position – si ce n’est pas clair, je vais expliquer, ne vous inquiétez pas – et, si l’on fait la somme de chaque résultat, on obtient le nombre final. Par exemple, en base 10, pour le nombre 123, nous avons :

1 × 102 + 2 × 101 + 3 × 100

=

1 × 100 + 2 × 10 + 3 × 1

=

100 + 20 + 3

=

123

Oui, ça a l’air ridicule de dire « 123 = 123 » mais je vous rappelle que c’est un système que l’on utilise couramment, au point que pour lire un nombre dans une base autre que 10, on ne peut s’empêcher de la convertir en base 10. Ainsi, pour un nombre en base 2, par exemple 101010, machinalement nous allons passer par une conversion en base 10 pour arriver à l’interpréter correctement. Et pour en revenir à la reconstitution d’un nombre binaire, ici nous avons :

1 × 25 + 1 × 23 + 1 × 21

=

1 × 32 + 1 × 8 + 1 × 2

=

32 + 8 + 2

=

42

Notez que, pour plus de clarté, j’ai ignoré les chiffres à valeur nulle, puisqu’une multiplication par 0 fait toujours 0.

Avec ce système, il est ainsi possible de compter jusqu’à 31 sur une main et 1023 sur deux mains ! Pour une main, on a multiplié notre résolution par 6 et pour deux mains par 100 ! Avouez que c’est quand même plus efficace ainsi !

Conclusion

Voilà, j’espère que cette astuce vous sera utile. Personnellement, j’utilise ce système tous les jours, c’est beaucoup plus pratique même si cela demande un peu d’entraînement pour avoir le réflexe d’utiliser ce système et pour arriver à transposer mentalement un nombre binaire en nombre décimal. C’était aussi l’occasion pour moi d’expliquer le principe du binaire de manière ludique.

N’hésitez pas à partager cette astuce si elle vous a plu.

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

Nicolas SAN AGUSTIN

(1) Je fais ici une parenthèse pour rappeler une notion élémentaire : il ne faut pas confondre chiffre et nombre. Un nombre est composé d’un ou plusieurs chiffres. 1 est un chiffre et accessoirement un nombre, 10 est un nombre mais pas un chiffre – c’est un nombre à deux chiffres. Cette confusion est probablement dû à cause de l’usage abusif du terme « chiffre » dans les milieux financiers et commerciaux.

Arduino Esplora et écran TFT

Bonjour à toutes et à tous !

J’espère que vous allez bien en ces temps difficiles. Aujourd’hui, nous allons aborder un autre matériel de l’écosystème Arduino – officiel cette fois-ci. Il s’agit de l’Arduino Esplora et de l’écran Arduino LCD.

Alors, je vous préviens tout de suite, il s’agit, là encore, de matériel qui n’est plus produit par Arduino. Mais, comme pour l’AirBoard, les plans sont disponibles ouvertement et il nous est possible de faire fabriquer nous-mêmes ces cartes, en les adaptant à nos besoins le cas échéant. Le gros point noir de l’AirBoard, c’était sa dépendance – pour le BLE en tout cas – à un module qui embarquait un composant propriétaire et au code fermé, à savoir le Bluno Bee de DFRobot et son CC2540. Ici, nous n’avons heureusement pas ce problème.

Commençons donc sans plus attendre par la présentation de ces deux cartes.

Présentation de l’Arduino Esplora

L’Arduino Esplora est une carte conçue par le projet Arduino et se présente sous la forme d’une manette de jeu nue et bardée de capteurs et actionneurs de différentes sortes. Elle est pilotée par un ATmega32u4 et basée en partie sur le modèle de l’Arduino Leonardo, une carte Arduino qui a la particularité de gérer nativement l’USB, via l’ATmega32u4 justement, ce qui dispense d’un composant intermédiaire pour programmer la carte puisque le bootloader peut tout gérer tout seul.

Côté capteurs, nous avons droit à :

  • un accéléromètre 3 axes MMA7361LC de chez NXP situé au beau milieu de la carte ;
  • un capteur de température TMP36 de chez Analog Devices, en-dessous de l’accéléromètre ;
  • une photorésistance pour détecter la luminosité, en haut à droite ;
  • un microphone, en bas à gauche.

Modulo l’accéléromètre, tous ces composants sont assez génériques et encore trouvables dans n’importe quel magasin d’électronique.

Côté actionneurs, nous avons :

  • quatre boutons à droite disposés en diamant de manière assez classique ;
  • un joystick, à gauche, avec deux axes et un bouton ;
  • un potentiomètre linéaire horizontal, en bas ;
  • un buzzer piézoélectrique, en haut à gauche ;
  • une DEL RGB, à droite du potentiomètre ;
  • un bouton Reset, en haut à gauche.

Là encore, nous avons affaire à des composants assez génériques et trouvable facilement dans des boutiques d’électronique.

Pour ce qui est de la connectivité, la carte dispose d’un port micro-USB, de 2 entrées et 2 sorties sur le dessus pour relier des modules TinkerKit, un connecteur ICSP pour la programmation avec une sonde et, enfin, un bornier destiné à l’écran Arduino LCD.

Tous les composants intégrés à la carte sont utilisables via la bibliothèque Arduino Esplora, téléchargeable directement via l’IDE Arduino. Cette bibliothèque fournit également un bon nombre d’exemples intéressants pour la prise en main de la carte. Certains de ces exemples utilisent d’ailleurs l’écran TFT que nous allons voir tout de suite.

Présentation de l’Arduino LCD

Il s’agit d’un petit écran TFT 1.77″, d’une définition d’écran de 160 x 128 pixels, et piloté par un ST7735. Ce composant est un contrôleur d’écran très répandu dans les écrans TFT bas de gamme – avec le ILI9341 – et que j’ai eu plusieurs fois l’occasion d’utiliser dans des projets professionnels. Pour l’utiliser, il suffit d’utiliser la bibliothèque TFT d’Arduino, qui dépend des bibliothèques Adafruit GFX – pour les routines de dessin – et Adafruit ST7735 – qui est le pilote du contrôleur d’écran.

Le site d’Arduino fournit une image représentant le brochage de l’écran.

La première chose qui saute aux yeux, c’est que l’autre côté du bornier n’est relié à rien. S’il dispose de broches de ce côté-là, c’est uniquement pour soutenir l’écran. On peut voir l’absence de connexions de ce côté de l’écran sur l’image ci-dessous.

L’écran dispose également d’un port pour carte micro SD, utilisable depuis l’Esplora via la bibliothèque Arduino SD. Pour communiquer avec l’écran et la carte SD, on utilise le protocole SPI – qu’on peut ici reconnaître aux broches MOSI et MISO pour les données, SCK (Serial Clock) pour la broche d’horloge et CS (Chip Select) pour sélectionner le périphérique avec lequel on souhaite communiquer – ici nous trouvons une broche CS par périphérique.

Usages

Le but affiché de l’Arduino Esplora est de fournir une carte de développement prête à l’emploi pour les personnes qui n’ont pas la patience ni l’envie d’apprendre l’électronique. Contrairement aux cartes Arduino plus classiques, celle-ci intègre déjà différents composants électroniques pour lesquels l’utilisateur n’aura qu’à se soucier de voir comment communiquer avec eux au niveau logiciel. Je vous avoue que cette explication est assez floue, car elle n’explique rien sur le choix des composants intégrés à la carte ni sur la forme de la carte.

Ce qui est sûr, c’est que nous avons affaire à une carte qui adopte la forme d’une manette de jeu, ne serait-ce que par la présence d’un joystick à gauche et de quatre boutons à droite. Sur certaines manettes, on peut également trouver un accéléromètre, un microphone voire un haut-parleur – comme celui de la Wiimote. Le reste des composants peut également servir à tester différents types de contrôle – par la lumière, la température, un potentiomètre – qui ne sont pas présents sur une manette mais l’utilisation possible de l’Esplora en tant que souris suggère que l’on peut l’utiliser pour contrôler autre chose que des jeux.

Mais ce qui frappe le plus c’est vraiment l’aspect contrôleur de jeu. Je dirais même console portable, une fois que l’on ajoute l’écran LCD, car la carte permet entre autres d’initier au développement de petits jeux vidéos – je dirais bien du type jeu électronique Tiger, mais ce serait être mauvaise langue étant donné que l’Esplora est très probablement bien plus puissante. Un des exemples fournis permet d’ailleurs de jouer à un jeu Pong très, très sommaire.

L’écran est également utilisable avec une carte autre qu’Esplora. Il suffit de relier les broches à une carte Arduino quelconque et d’utiliser la bibliothèque TFT pour l’affichage ou SD pour la gestion de la carte SD. Il est même possible de sortir de l’écosystème Arduino et utiliser la carte directement en SPI depuis n’importe quel microcontrôleur, mais cela oblige à utiliser une autre bibliothèque voire à développer ses propres bibliothèques et pilotes.

Comme je l’ai déjà précisé, cette carte écran n’est plus produite aujourd’hui, mais il est tout à fait possible de trouver des alternatives utilisant le même contrôleur d’écran – le ST7735 – ou un autre contrôleur en adaptant le pilote Adafruit_ST7735. Je ne saurais trop vous conseiller de regarder le code source de ce pilote pour vous familiariser avec l’architecture d’un contrôleur d’écran générique et comprendre comment il s’interface avec une bibliothèque graphique comme Adafruit_GFX. À plusieurs reprises, j’ai dû m’inspirer de ce genre de pilotes pour écrire un pilote maison adapté à d’autres cartes mais utilisant le même genre de contrôleur d’écran. Et heureusement, car ces composants ont la fâcheuse tendance à n’être pas très clairement documentés.

Conclusion

Je n’ai pas beaucoup explicité l’usage de ce matériel de manière concrète parce que les exemples fournis par les bibliothèques Esplora, SD et TFT sont déjà largement suffisants pour apprendre pas mal de choses. D’autant qu’il s’agit de cartes qui ne sont plus du tout produites, donc il y a peu de chances que vous soyez amenés à les découvrir aujourd’hui.

Une autre raison est que la carte dispose de beaucoup de capteurs et qu’il est difficile de trouver un projet facile à développer qui exploiterait toutes les capacités de la carte. Si je trouve une idée exploitable, je ferai un autre article pour la présenter. ;-)

Promis, la prochaine fois j’essaierai de parler d’une carte encore produite – probablement de STMicroelectronics.

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

Nicolas SAN AGUSTIN

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.