Des yeux pour un robot ESP32

Notre robot aura des yeux, parce que c’est cool. Il n’y a pas besoin d’autre raison. Un robot doit en jeter et avoir de la personnalité : deux petits écrans sur sa face avant, un regard qui suit la manette, qui cligne, qui se fâche ou qui pleure, et il cesse d’être une boîte à roulettes.

La première idée était la plus évidente : dessiner les expressions sur un ordinateur, les ranger en images sur la carte microSD du robot, et les afficher. Elle tenait debout jusqu’à ce que nous comptions les images. Un œil qui regarde n’importe où, qui cligne à n’importe quel moment et qui passe doucement d’une expression à l’autre ne se range pas en quelques fichiers : il en faut des centaines. L’autre voie consiste à ne rien stocker du tout, et à calculer chaque pixel des deux yeux, une trentaine de fois par seconde, sur le microcontrôleur lui-même. Restait à savoir ce que cela coûte. Au premier essai, la réponse a été : trop. Cet article raconte comment le même dessin est passé de 8 à 31 images par seconde, et ce sur quoi nous avons buté en chemin.

Vidéo 1 — La version finale : les deux yeux sur leurs écrans de 1,44 pouce, l’écran d’information au milieu, les expressions choisies à la manette.

Ce que nous voulons

Ce projet fait suite à l’article Faire obéir une manette de jeu chinoise à un ESP32, qui a établi une liaison sans fil fiable entre la carte et sa manette. Les yeux s’appuient dessus. Voici ce qu’on attend d’eux :

  • deux yeux vivants : le regard bouge seul, les paupières clignent, la pupille respire un peu ;
  • des expressions : neutre, heureux, triste, en colère, surpris, endormi, méfiant, un clin d’œil, des larmes, et de la pluie sur la vitre avec son essuie-glace ;
  • la manette aux commandes : les palettes pour passer d’une expression à l’autre, les sticks pour diriger le regard, les gâchettes pour fermer les paupières ;
  • le câblage du robot, et pas un câblage d’essai : les deux yeux et l’écran d’information partagent le même bus ;
  • des chiffres pour le robot final : ce que coûtent les yeux en processeur, en mémoire et en temps de bus, mesuré à part de ce que coûte la liaison Bluetooth.

Le dernier point compte plus que les autres. Le robot devra aussi piloter quatre moteurs, lire ses capteurs et surveiller sa batterie, avec la même puce. Des yeux magnifiques qui volent le temps de calcul des moteurs seraient une mauvaise affaire.

Le matériel

La carte est la même que pour la manette : une ESP32-S31 Function-CoreBoard-1 d’Espressif, la carte de développement qui porte le microcontrôleur du robot. Une carte de développement est une petite carte vendue par le fabricant d’un microcontrôleur : elle porte la puce, son alimentation, ses prises USB et un connecteur où sortent ses broches, pour écrire et essayer un programme avant que la carte définitive n’existe. Son microcontrôleur, l’ESP32-S31, a deux cœurs RISC-V à 320 MHz : deux processeurs complets dans la même puce, capables de travailler en même temps. Il dispose aussi de 512 ko de mémoire vive interne et, sur cette carte, de 16 Mo de PSRAM (une mémoire vive externe, plus lente mais bien plus grande). Ces deux détails vont servir.

Trois écrans s’y branchent :

ÉcranPuceTailleRôle
Écran d’informationST77891,9 pouce, 170 × 320 pixelsl’état de la liaison, l’expression, les mesures, le mode d’emploi
Œil gaucheST7735S1,44 pouce, 128 × 128 pixelsl’œil
Œil droitST7735S1,44 pouce, 128 × 128 pixelsl’œil

Les trois parlent le SPI, une liaison série à horloge : la carte envoie ses ordres et ses pixels sur un fil de données, au rythme d’un fil d’horloge. Les yeux du robot auront la même taille, 128 × 128 pixels, avec la même puce.


Les décisions prises avant d’écrire une ligne

1. Les signaux sont communs, sauf la sélection. Sur le bus SPI, plusieurs écrans peuvent partager l’horloge, les données et la broche qui distingue une commande d’un pixel (DC). Chacun garde sa propre broche de sélection (CS, chip select) : la carte met à l’état bas la sélection de l’écran à qui elle parle, et cet écran seul écoute. Le robot pousse le partage plus loin : la remise à zéro (RES) et le rétroéclairage (BLK) sont communs aussi. Trois écrans tiennent donc sur huit broches du microcontrôleur, au lieu de dix-huit.

Broche du moduleSignalBroche de l’ESP32Commune aux trois écrans ?
SCLhorloge SPIIO42oui
SDAdonnées SPIIO43oui
DCcommande ou pixelIO46oui
RESremise à zéroIO48oui
BLKrétroéclairageIO37oui
CSsélection de l’œil gaucheIO44non
CSsélection de l’œil droitIO45non
CSsélection de l’écran d’informationIO49non

SCL et SDA sont les noms que les vendeurs de modules donnent à l’horloge et aux données SPI ; ce n’est pas un bus I²C, malgré les noms. La remise à zéro étant commune, elle se fait une seule fois, au démarrage, et chaque écran se réinitialise ensuite par une commande qui ne touche que lui. Le rétroéclairage étant commun, les trois écrans s’allument et baissent ensemble.

2. D’abord dessiner sur l’ordinateur. Avant de toucher au microcontrôleur, nous avons dessiné les yeux sous forme d’un SVG animé : un fichier d’image vectorielle qui contient aussi un petit programme, et qui s’anime tout seul dans un navigateur. Le but était de choisir le dessin : le style de l’œil, les expressions, la vitesse des clignements. Modifier une ligne et recharger la page prend une seconde ; recompiler et téléverser un programme en prend une minute.

3. Un œil réaliste, avec des pistes de circuit imprimé. Le style de départ est celui des yeux animés qu’Adafruit a popularisés : un globe, un iris texturé, une pupille, des paupières. Nous y avons ajouté des expressions, et remplacé les veines rouges par des pistes de cuivre qui tournent à 45° et finissent sur un via. C’est un robot ; ses yeux peuvent le dire.

4. Calculer plutôt que stocker, et mesurer avant de trancher. La première décision du projet rangeait les images des yeux sur la carte microSD. Elle supposait des images. Quand le dessin s’est arrêté sur des yeux qui bougent en continu, nous avons choisi d’essayer le calcul et de le mesurer.

5. Le Bluetooth sur un cœur, les yeux sur l’autre. Chaque cœur fait un seul métier, et sa charge se lit à part. Le premier porte la radio, la liaison avec la manette et l’écran d’information ; le second ne fait que les yeux.


La maquette : choisir le regard dans un navigateur

Voici la maquette telle que nous l’avons utilisée pour décider du dessin. Elle est vivante : les yeux regardent, clignent et changent d’expression toutes les sept secondes. Les boutons choisissent une expression ; « Vrais pixels » montre l’œil à la résolution d’un écran de 160 × 80.

Fig. 1 — La maquette animée qui a servi à choisir le dessin des yeux, pour des écrans de 160 × 80 : cliquer sur une expression arrête le défilement automatique.

Tout tient dans un seul fichier : le dessin, le petit programme qui l’anime et les boutons. Vous pouvez le télécharger et l’ouvrir dans n’importe quel navigateur ; son code se lit avec un simple éditeur de texte. Plusieurs choix se sont faits en la regardant tourner : les changements d’expression ralentis, qui passaient pour des sursauts, le clin d’œil refait en vrai geste (fermeture rapide, un instant fermé, réouverture plus lente), et la vue « vrais pixels », qui a montré qu’un détail invisible à cette taille ne vaut pas d’être calculé.


De la maquette à la carte : calculer chaque pixel

Le navigateur dessine la maquette avec des courbes, des dégradés et des flous : il dispose pour cela d’un moteur graphique complet. Le microcontrôleur n’en a pas. Il ne sait que remplir un tableau de nombres, un nombre par pixel, et l’envoyer à l’écran. La traduction consiste donc à refaire, pour chaque pixel de chaque œil, le calcul que le navigateur faisait pour nous : suis-je dans l’iris ? sur une de ses fibres ? dans la pupille ? sous l’ombre d’une paupière ? dans la paupière ? Chaque réponse colore un peu le pixel, par-dessus la précédente.

Deux procédés rendent l’image propre. L’anticrénelage (le lissage des bords, qui évite les marches d’escalier) : un bord qui traverse un pixel ne le colore qu’en partie, selon la distance du centre du pixel au bord. Le tramage (une répartition régulière des erreurs d’arrondi) : l’écran n’a que 32 niveaux de rouge et de bleu, et sans lui le dégradé du blanc de l’œil se verrait en bandes. Et le programme tire ses pistes et les fibres de l’iris avec le même générateur de hasard que la maquette, avec la même graine : les yeux de la carte ont le dessin exact de ceux de l’ordinateur.

Trois composants font le travail, rangés à part pour resservir sur le robot :

  • yeux : le dessin et la vie des yeux. Il ne connaît aucun matériel : il remplit des tableaux de pixels, et rien d’autre ;
  • ecran_st7735 : le pilote des écrans des yeux. ESP-IDF, l’environnement de développement d’Espressif, fournit un pilote pour le ST7789 de l’écran d’information, mais aucun pour le ST7735S ; il a fallu l’écrire ;
  • liaison_manette : la liaison de l’article précédent, sortie du programme de l’essai 04 dans un composant ESP-IDF, c’est-à-dire un dossier de code réutilisable que plusieurs programmes incluent sans le recopier. Le programme n’en voit que trois fonctions : manette::demarrer() lance la liaison, manette::situation() dit où elle en est, et manette::commandes() rend les boutons, les sticks et les gâchettes. Deux copies d’un même code finissent toujours par diverger, la première fois qu’on en corrige une ; un composant n’existe qu’une fois.

Là où nous avons buté

Premier allumage : du bruit

Les trois écrans câblés, l’écran d’information s’est allumé normalement. Les deux yeux ont affiché ceci.

Premier allumage : l'écran d'information marche, les deux yeux montrent des bandes bleues bruitées. Quelque chose y bouge quand on touche la manette, mais l'image n'a aucun sens.
Fig. 2 — Premier allumage : l’écran d’information marche, les deux yeux montrent des bandes bleues bruitées. Quelque chose y bouge quand on touche la manette, mais l’image n’a aucun sens.

Quelque chose bougeait quand on touchait la manette : le programme tournait, et les écrans recevaient des pixels. Les fils de sélection étaient justes. La réponse était écrite sur les modules : le pilote avait été réglé pour les écrans de 0,96 pouce d’abord prévus pour le robot, et les modules du banc étaient des 1,44 pouce. La puce, elle, est bien la même.

Le dos du module de 1,44 pouce : DRIVER IC ST7735S, et la nappe de la dalle, marquée HD14008H14.
Fig. 3 — Le dos du module de 1,44 pouce : DRIVER IC ST7735S, et la nappe de la dalle, marquée HD14008H14.

Même puce, autre dalle : c’est tout le problème. Le ST7735S a une mémoire de 132 × 162 pixels, et une dalle n’en montre qu’une partie, à un emplacement qui dépend du modèle. Le pilote écrivait au mauvais endroit, et demandait l’inversion des couleurs que réclament les dalles IPS et pas celle-ci. L’astuce qui a ensuite rendu chaque essai lisible : au démarrage, le pilote noircit toute la mémoire de la puce, et pas seulement la zone qu’il croit visible. Un réglage faux décale ou coupe alors l’image, mais ne laisse plus de bruit pour la cacher. Une grille numérotée, affichée jusqu’à l’appui sur A, dit ensuite au pixel près ce que l’écran montre.

La grille de réglage sur l'œil gauche : des cases de 16 pixels numérotées, et un L rouge dans le coin pour savoir quel œil on regarde. Ici, la grille n'occupe pas encore toute la dalle : le réglage n'est pas fini.
Fig. 4 — La grille de réglage sur l’œil gauche : des cases de 16 pixels numérotées, et un L rouge dans le coin pour savoir quel œil on regarde. Ici, la grille n’occupe pas encore toute la dalle : le réglage n’est pas fini.

Carré, malgré les apparences

L’image de contrôle, des bandes de couleur dans un cadre, n’occupait qu’une partie de l’écran.

L'image de contrôle sur l'œil gauche : trois bandes bleue, verte et rouge dans un cadre étroit, au milieu d'une dalle restée noire de part et d'autre.
Fig. 5 — L’image de contrôle sur l’œil gauche : trois bandes bleue, verte et rouge dans un cadre étroit, au milieu d’une dalle restée noire de part et d’autre.

L’écran nous paraissait rectangulaire. Nous avons donc essayé de le traiter en 160 × 128, pour que l’œil de la maquette y tienne entier.

L'image de contrôle envoyée pour une dalle de 160 × 128 : les bandes sont dans le désordre, la bande bleue du bas réapparaît en haut, et des pixels parasites parsèment l'image.
Fig. 6 — L’image de contrôle envoyée pour une dalle de 160 × 128 : les bandes sont dans le désordre, la bande bleue du bas réapparaît en haut, et des pixels parasites parsèment l’image.

L’image de contrôle en sort repliée sur elle-même : la dalle est bien carrée, 128 × 128, et ce qui est écrit au-delà se perd. D’où la décision qui a changé le dessin : calculer les yeux à la taille de l’écran, au lieu de réduire ou de couper l’œil de la maquette. Ce qui se place sur l’écran (les paupières, la position de l’iris, les reflets) suit l’écran, en largeur et en hauteur séparément. Ce qui a une forme (l’iris, la pupille, les gouttes, l’essuie-glace, l’épaisseur des pistes) suit une échelle unique, la moyenne géométrique des deux. Sur l’écran carré, l’œil s’ouvre donc plus haut, et l’iris grandit sans s’écraser. Le même programme s’adapte à toute autre taille d’écran.

Trop lent : 8 images par seconde

Une fois l’œil à l’écran, l’écran d’information a donné les premiers chiffres.

Les premiers yeux, encore recadrés. L'écran d'information donne les premières mesures : 9 images par seconde, 122,5 ms de calcul par image, le cœur des yeux à 100 %, celui de la radio à 2 %.
Fig. 7 — Les premiers yeux, encore recadrés. L’écran d’information donne les premières mesures : 9 images par seconde, 122,5 ms de calcul par image, le cœur des yeux à 100 %, celui de la radio à 2 %.
MesurePremier relevéVersion finale
Images par seconde8 à 1431
Calcul des deux yeux, par image66 à 136 ms17 à 28 ms
Pixels calculés par image2 × 12 8002 × 16 384
Cœur des yeux98 à 100 %56 à 89 %
Cœur de la radio et de l’écran d’information1 à 2 %3 %

Le premier relevé disait trois choses. Le calcul était deux à quatre fois trop lent : il faut 33 ms au plus pour tenir trente images par seconde. Le bus n’y était pour rien : il n’attendait jamais. Le Bluetooth ne coûte presque rien : 2 % d’un cœur, ce que la séparation des cœurs devait permettre de voir. Les astuces qui ont fait passer de la première colonne à la seconde tiennent toutes dans une idée : ne calculer qu’une fois ce qui ne change pas, et ne calculer qu’une fois ce que les deux yeux ont en commun.

  • L’iris est précalculé. Sa texture (120 fibres, 14 petites taches, une collerette, deux anneaux) ne bouge pas avec lui : elle se calcule au démarrage en une petite image par œil, posée à la place de l’iris à chaque image. Il ne reste en direct que la pupille, qui respire, et la couleur, qui vire au rouge avec la colère.
  • Toutes les couches d’un dessin se résument en deux nombres. Peindre une couleur par-dessus une autre avec une transparence est une opération linéaire : enchaînées, les couches de l’iris se résument à « dessous × m + a ». On trouve m et a en composant une fois sur du noir et une fois sur du blanc, et l’iris se pose ensuite en une multiplication et une addition par pixel. Le même procédé sert aux gouttes de pluie et à l’essuie-glace.
// Composer sur du noir donne a ; sur du blanc, 255·m + a.
const Couleur noir = composer(dx, dy, NOIR, 0), blanc = composer(dx, dy, BLANC, 0);
p.m = octet(blanc.r - noir.r);   // la part du dessous qui reste
p.a_calme[0] = octet(noir.r);    // ce que l'iris ajoute (et de même en vert et en bleu)
// À chaque image, pour chaque pixel de l'iris :
c = {c.r * m + p.a_calme[0] + (p.a_colere[0] - p.a_calme[0]) * colere, /* … */};
  • Les deux yeux se dessinent en un seul passage. Ils regardent dans la même direction : la position de l’iris, la pupille, le halo de colère et les reflets sont les mêmes, et ne se calculent qu’une fois pour les deux. L’essuie-glace aussi : il ne se recalcule que quand il bouge, et seulement près de son bras.
  • On ne peint que ce qui touche le pixel. Loin du bord des paupières, l’ombre, le liseré et la paupière ne changent rien : un test les saute. Le flou des ombres se lit dans une table au lieu de demander deux exponentielles par pixel.
  • La PSRAM reçoit les dessins précalculés (fonds, iris, calques, environ 250 ko), et laisse la mémoire interne au Bluetooth et aux envois vers les écrans.

Le piège de l’attente qui tourne à vide

Après ces allègements, le cœur des yeux restait pourtant à 100 %. Le calcul des deux yeux était fini, mais l’envoi de l’œil droit devait attendre que le bus ait fini d’envoyer l’œil gauche, une quinzaine de millisecondes. Deux surprises s’additionnaient.

La première : cette attente bloquait la tâche des yeux, qui ne pouvait pas commencer l’image suivante. L’envoi est donc passé à une tâche à part, qui attend le bus pendant que les yeux calculent ; le pilote recopie d’abord chaque image dans son propre tampon, pour que le programme puisse redessiner la sienne aussitôt.

La seconde : le pilote SPI d’ESP-IDF envoie les commandes « en scrutation », c’est-à-dire qu’il attend la fin du bus en tournant, en vérifiant sans cesse s’il est libre. Pendant ce temps, le cœur paraît plein alors qu’il ne fait rien d’utile. La tâche d’envoi attend désormais la fin de l’œil gauche sur un signal, en dormant, et ne lance l’œil droit qu’ensuite. La mesure elle-même trompait : elle comptait cette attente dans le calcul, et affichait « 33,6 ms de calcul » avec un cœur à moitié libre. Calcul et envoi se mesurent maintenant à part.

L'écran d'information à ce moment-là : 30 images par seconde, « CALC 33.6 MS » et « ATTENTE BUS 0.0 MS », alors que le cœur des yeux n'est occupé qu'à 54 %. Les 33,6 ms comptaient l'attente du bus dans le calcul.
Fig. 8 — L’écran d’information à ce moment-là : 30 images par seconde, « CALC 33.6 MS » et « ATTENTE BUS 0.0 MS », alors que le cœur des yeux n’est occupé qu’à 54 %. Les 33,6 ms comptaient l’attente du bus dans le calcul.

Cet écran montre aussi la liste des expressions, qu’on ne lisait pas à deux pas. Dans la version finale, elle a laissé la place à une seule ligne, l’expression choisie en gros caractères noirs sur fond jaune.

Des marches sur les paupières

Les paupières qui clignent montraient des marches à leur bord quand elles bougeaient vite. C’est un déchirement d’image : l’écran se redessine tout seul, à son propre rythme, pendant qu’on lui écrit l’image suivante. Pendant un balayage, il montre donc un morceau de l’ancienne image et un morceau de la nouvelle. La parade habituelle est un signal de l’écran qui annonce le début de chaque balayage, mais ces modules à huit broches ne le sortent pas.

L'œil sur une dalle montée de côté, broches à gauche. Ses lignes de balayage sont verticales : quand une paupière monte ou descend, la coupure entre l'ancienne et la nouvelle image tranche son bord et y dessine des marches.
Fig. 9 — L’œil sur une dalle montée de côté, broches à gauche. Ses lignes de balayage sont verticales : quand une paupière monte ou descend, la coupure entre l’ancienne et la nouvelle image tranche son bord et y dessine des marches.

Ce qui a marché est d’une simplicité vexante : monter la dalle dans son sens d’origine. Une dalle se redessine le long de SES lignes. Les écrans étaient montés de côté, l’image tournée d’un quart de tour par le programme : leurs lignes étaient alors verticales pour nous, et la coupure entre ancienne et nouvelle image tranchait en travers le bord d’une paupière qui monte ou descend. Dans leur sens, la coupure devient parallèle au bord de la paupière, et la marche disparaît.

La même dalle remontée broches en haut, dans son sens d'origine : l'œil pleut, l'essuie-glace attend en haut à droite, et le bord des paupières reste net.
Fig. 10 — La même dalle remontée broches en haut, dans son sens d’origine : l’œil pleut, l’essuie-glace attend en haut à droite, et le bord des paupières reste net.

Sur le robot, les écrans devront donc être montés dans ce même sens, broches en haut.

Le regard qui ne revenait pas

Un dernier défaut est apparu en jouant avec la version finale : lâché d’un coup, le stick laissait la pupille près du bord de l’œil au lieu de la ramener au centre. Deux suspects. D’abord la manette : renvoie-t-elle bien la position de repos quand le stick revient brutalement ? Pour le savoir sans deviner, l’écran d’information affiche désormais les valeurs brutes des deux sticks, en orange dès que l’un sort de la zone morte (la petite zone autour du centre où le stick est tenu pour lâché). Ensuite le programme. C’est lui qui était en faute. Quand le stick rentre dans sa zone morte, le regard cesse d’être imposé, mais sa cible restait la dernière position reçue. Lâché doucement, ce dernier relevé est presque au centre et rien ne se voit ; lâché vite, il est encore au bord. Il a suffi de ramener la cible au centre à l’instant où le stick est lâché ; la vie automatique reprend 0,8 seconde plus tard. Que la pupille revienne maintenant au centre prouve du même coup que la manette, elle, renvoyait bien sa position de repos.


Le programme final

Il se compile avec ESP-IDF 6.1 (option --preview, l’ESP32-S31 étant encore en avant-première) : yeux-esp32-s31.zip. L’archive contient :

  • main/essai_yeux.cpp : le programme, avec ses deux tâches (les yeux sur le cœur 1, l’écran d’information sur le cœur 0) et la tâche d’envoi ;
  • components/yeux : le dessin et la vie des yeux, à la taille de l’écran qu’on lui donne ;
  • components/ecran_st7735 : le pilote des yeux, avec les réglages des deux dalles dans son en-tête (DALLE_0_96_POUCE, DALLE_1_44_POUCE) ;
  • components/ecran_st7789 et components/liaison_manette : l’écran d’information et la liaison de l’article précédent ;
  • sdkconfig.defaults : le Bluetooth sur le cœur 0, la PSRAM, et la mesure du temps passé dans chaque tâche.

Câblez comme dans le tableau des décisions, les écrans de 1,44 pouce montés broches en haut. Au démarrage, une grille s’affiche sur les deux yeux jusqu’à l’appui sur A. Ensuite :

CommandeEffet
LB, RBl’expression précédente, la suivante ; l’écran d’information l’affiche en gros
A, B, X, Y, croix haut et basheureux, en colère, surpris, triste, neutre, endormi
L3, R3 (sticks enfoncés)larmes, pluie
sticksle regard ; au bout de la course, la moitié de l’iris passe sous le bord
gâchettes LT, RTferment l’œil gauche, l’œil droit, à proportion de l’appui
croix gauche et droitela lumière, de 5 à 100 %
SELle défilement automatique, une expression toutes les 7 s
START (tenu)la grille de réglage

La version finale des yeux

Voici, pour finir, les yeux tels que la carte les dessine : écran carré, pistes plus visibles, iris qui passe à moitié sous le bord au bout de sa course (bouton « Regard »), pluie à grosses gouttes et essuie-glace toujours en place. C’est la maquette refaite d’après le programme final ; vous pouvez la télécharger comme la première.

Fig. 11 — Les yeux dans leur version finale, sur des écrans de 128 × 128 : expressions, regard au bout de sa course, pluie et essuie-glace.

Les yeux tiennent leurs trente images par seconde, avec un cœur occupé entre la moitié et les neuf dixièmes selon l’expression, et la radio presque oisive à côté. Reste une question pour le robot : il n’a que deux cœurs, et le second est promis aux moteurs. Les yeux iront-ils sur le premier, avec la radio, une fois encore allégés, ou trouveront-ils de l’aide dans l’accélérateur graphique de la puce ? C’est le prochain chantier.


Sources et filiation

Le style des yeux s’inspire des yeux animés popularisés par Adafruit sur ses cartes (projet « Uncanny Eyes »).

Les réglages de départ des écrans de 0,96 pouce viennent du programme de démonstration de LCDWiki pour ce module ; ceux du module de 1,44 pouce ont été trouvés sur le banc, à la grille de réglage.

La puce ST7735S : fiche technique de Sitronix, pour les commandes (sens de balayage MADCTL, fenêtre d’écriture, fréquence de rafraîchissement).

Les programmes des archives sont publiés sous la licence PolyForm Noncommercial 1.0.0 : vous pouvez les utiliser, les modifier et les partager pour un usage personnel, éducatif, de recherche ou associatif ; tout usage commercial demande l’accord écrit de l’auteur. Les fichiers d’Espressif qu’ils contiennent gardent leur propre licence.

© Sébastien Debucquoi — Tous droits réservés.