Communication entre un microcontrôleur (ESP8266/Arduino/...) et un ordinateur.

Dans cet article nous allons étudier comment utiliser la liaison série de nos microcontrôleurs préférés (8266 ou Arduino) afin qu'ils puissent communiquer avec un PC sous Windows ou tout autre ordinateur disposant de ports USB.

Je suis en train de préparer une série d'articles concernant la manière d'alimenter nos précieux microcontrôleurs (𝜇C pour les intimes) avec des piles ou des accus, afin d'en faire des objets connectés autonomes. Je n'en dirais pas plus à ce sujet top secret pour le moment, mais dans le cadre de mes expérimentations je me suis retrouvé confronté à un problème pour la mise au point de mes programmes sur un NodeMCU: comment envoyer des messages vers le moniteur série de mon PC, sans que le microcontrôleur ne soit raccordé au PC en direct par son port USB.

En cherchant des solutions je me suis rendu compte que cette question était comme une petite graine qui, une fois plantée, faisait germer plein d'idées et me permettait de récolter de nouvelles connaissances. Il ne m'en fallait pas plus pour reprendre ma bêche et mon râteau et rédiger ce nouvel article afin d'en partager les fruits.

Introduction

Comme toute personne normale sur cette planète, lorsque je développe un programme pour un microcontrôleur NodeMCU, je parsème mon croquis* de traces qui me permettent de suivre le bon déroulement du code ou les valeurs de certaines variables. Et comme tout le monde, j'utilise l'émulation de la liaison série via USB pour que ces messages soient affichés sur l'écran de mon PC dans un moniteur série**. Cette manière de faire pour mettre au point un programme est évidente lorsque l'on dispose d'un 𝜇C tel que le NoceMCU qui est intégré à une carte de développement disposant d'une connectique USB. Ce qui est le cas également des Arduino, des ESP8266 Wemos D1, .... en réalité la majorité des cartes de développement disposent d'un port USB (ou micro USB). Mais comment faire quand on dispose d'un microcontrôleur sans connectique USB? Et comment faire si nous ne souhaitions pas raccorder le microcontrôleur au PC en utilisant l'USB? C'est ce que nous allons voir.

*croquis est le nom que l'on donne à un programme dans le monde d'Arduino et par extension des microcontrôleurs ESP8266.

**Les moniteurs série les plus connus sont le moniteur lié à l'IDE Arduino ou (plus sportivement) l'application Putty. Vous pouvez d'ailleurs trouver une note expliquant l'utilisation de Putty en moniteur série dans mon article ICI.

Posons la problématique

Imaginons que nous souhaitons réaliser un circuit alimenté sur batterie en utilisant un microcontrôleur. Si notre microcontrôleur dispose d'une connectique USB, nous allons nous servir de cette dernière pour le connecter au PC. Ce raccordement va de manière native nous fournir 3 fonctionnalités:

Alimenter électriquement le microcontrôleur.
Permettre d'injecter le code du programme.
Permettre d'échanger des données avec le PC durant l’exécution du programme en simulant une liaison série entre les deux équipements.

Et comme nous imaginons que nous devons réaliser un montage sur batterie, nous imaginons facilement aussi, que nous allons avoir des soucis à cause de la fonctionnalité (1) ci-dessus. En effet, le raccordement en USB va apporter une source d'alimentation électrique et cette dernière va forcément venir perturber d'une manière ou d'une autre notre alimentation sur batterie.

Parmi ces soucis nous pouvons distinguer:

Impossibilité de connaitre la tension d'alimentation réelle.
Perturbation du régulateur de tension associé à la broche VIN.
Création de court-circuits possibles entre les différentes sources.
Etc ...

Ce que nous pouvons déduire est simple: il faudrait que nous puissions conserver les fonctions de téléversement du sketch et d'échange de données fournies par la connexion USB, mais sans utiliser la fonction d'alimentation électrique.

Imaginons maintenant que nous souhaitons programmer un microcontrôleur qui ne se trouve pas sur une carte fournissant une connectique USB. C'est le cas si vous réalisez vos propres montages à base de 𝜇C et c'est aussi le cas de certaines cartes telles que l'Esp01. Nous allons pouvoir alimenter les composants avec une alimentation électrique de notre choix. Par contre, nous n'allons plus avoir la possibilité naturelle de raccorder le microcontrôleur à l'ordinateur directement en USB. Dans ce cas, comment injecter facilement les programmes et surtout, comment échanger des données qui permettront le suivi et le débogage?

Pour répondre à toutes ces questions et problématiques, nous voyons que nous allons devoir trouver un moyen de raccorder à l'ordinateur n'importe quel type de microcontrôleur, qu'il soit sur carte de développement ou pas, qu'il dispose d'un port USB ou pas. Il faudra que ce mode de raccordement soit compatible avec les fonctions de liaison série fournies par le raccordement USB tout en donnant la possibilité de désactiver l'alimentation électrique en 5V.

Passons à la théorie

Pour comprendre comment la solution à notre problématique va fonctionner, nous allons avoir besoin de comprendre ce qu'est et comment fonctionne une liaison série.

Liaison série

La liaison série est une modalité de transmission de données dans laquelle les éléments d'information se succèdent les uns après les autres. En informatique ces éléments d'information sont les bits. Concrètement cela signifie que pour envoyer un message d'un équipement A vers un équipement B en passant par une liaison série, on va décomposer ce message en une suite de bits élémentaires et transmettre chacun d'eux, l'un à la suite de l'autre.

Une liaison série peut être half-duplex ou full-duplex.

Lorsqu'elle est half-duplex, la communication entre les deux équipement n'utilise qu'une seule ligne de liaison. Si A envoi des données à B, B devra attendre que A ait finit d’émettre pour pouvoir lui répondre. Alors qu'un full-duplex, la liaison dispose de deux lignes (Tx et Rx), chaque équipement peut donc à la fois émettre et recevoir des données.

La liaison série est un standard très utilisé car il permet à des équipements hétérogènes d'échanger des données.

Protocoles de communication

Les principes de la liaison série peuvent être implémentés de manières différentes.

Dans nos microcontrôleurs, il est en général implémenté sous la forme du protocole UART (Universal Asynchronous Receiver Transmitter ) qui est associé à des broches dédiées (Tx/Rx). Bien que je parle de "protocole", UART n'en est pas un comme les autres car il s'agit avant tout d'un circuit physique intégré dans un microcontrôleur ou d'un circuit imprimé spécifique.

Il est tout à fait possible de communiquer en UART en utilisant d'autres broches que Rx/Rx. En effet, il est possible de programmer de manière logicielle n'importe quelle autre broche de données pour que cette dernière se comporte comme une ligne série. En général il faut utiliser une librairie spécifique qui s'appelle "Software Serial".

De manière simplifiée, ceci signifie que lorsque le microcontrôleur envois des données sous forme d'octets au composant UART, ce dernier les transforme en forme d'une succession de bits unitaires et à chaque bit correspond une impulsion sur les la broche Tx. Et à l'inverse, lorsque l'UART reçoit des impulsion électriques sur la broche Rx, ce dernier est capable de les convertir en caractères sous forme d'octets pour les mettre à disposition du logiciel du microcontrôleur.

Communication entre circuits UART

Il existe d'autres manières d'implémenter les principes d'une liaison série. Parmi les plus connues nous pouvons trouver:

Des protocoles de liaisons point à point (comme UART) avec: RS232, Serial ATA ...
Des protocoles de liaisons multipoints avec Ethernet, PCI, SPI ou USB.

Focus sur UART

Comme nous venons de le voir dans les paragraphes précédents, pour échanger des données avec des équipements extérieurs et hétérogènes, nos microcontrôleurs peuvent s'appuyer sur l'UART (qu signifie récepteur / émetteur universel asynchrone).

L'un des avantages de l'UART est qu'il n'utilise que deux câbles pour transmettre des données entre périphériques.

Le fonctionnement est simple:

Le programme informatique envois les données sur le bus de données à destination du composant UART.
Le composant transforme ces données en série de bits.
Un bit de début et un bit de fin (bit de parité qui permet un contrôle d'erreur) sont ajoutés.
Chaque bit est envoyé par une impulsion électrique sur la broche physique Tx: signal haut = 0, signal bas = 0.
Le récepteur transforme les signaux reçus en bit correspondants (en supprimant les bits de début et de fin).
Lorsque tous les bits de la trame sont arrivés, la donnée peut être à nouveau écrite sur le bus de données du récepteur.

Schéma de fonctionnement:

La transmission est asynchrone, cela signifie qu'il n'y a pas de signal d'horloge (clock) entre l'émetteur et le récepteur. Le récepteur, pour identifier les différents bits d'un octet, se base sur la durée de ses bits qui doit être fixe et connue de l'émetteur et du récepteur: c'est le BAUDRATE (nombre de bits par secondes).

Ports USB

Du coté de l'ordinateur, nous ne disposons pas d'interfaces liaison série UART. A une époque, les PC disposaient d'un port série RS-232 qui standardisait les communications série. Ce port était communément appelé port "COM". Mais ces derniers ont ont été remplacés par l'USB qui, comme son nom l'indique (Universal Serial Bus) est un bus série universel.

Interface série de type DB9

Bien que l'UART et l'USB implémentent tous deux une forme de communication série, les deux ne sont pas directement compatibles. La raison principale est due au fait que UART est fait pour connecter deux équipements en direct. Les données envoyées par émetteur, arrivent directement sur le bus de données du récepteur. Hors en USB, il y a un bus de données unique qui est partagé par tous les programmes de l'ordinateur. Ceci va avoir deux conséquences:

Entre le microcontrôleur et l'interface USB, nous allons avoir besoin d'une puce spécifique qui sera capable de traduire les signaux UART en quelque chose qui sera compatible avec l'USB.
Et comme cette puce sera vue par l'ordinateur comme un périphérique USB, nous allons avoir besoin d'installer sur l'ordinateur un "driver" pour que ce dernier soit reconnu.

Traduction série UART to USB

Le schéma ci-dessus montre comment la puce UART envois à la fois les données sur les broches dédiées Tx/Rx mais aussi sur la puce qui va faire la traduction UART vers USB. Si le PC est équipé du bon driver, il va recevoir le message envoyé par l'UART.

Une fois connecté au PC sur un port USB, l'UART va être vu comme un port particulier appelé "port COM". Donc si nous arrivons à raccorder notre microcontrôleur à notre PC en USB, via une puce garantissant la traduction des échanges entre les deux équipements, le microcontrôleur sera détecté par Windows (ou Linux/Mac OS) comme un équipement connecté sur un port COM.

Traducteurs UART-USB

Nous venons de voir que pour communiquer vers un PC (ou un Raspberry) sur un port USB, le microcontrôleur a besoin d'une puce spécifique qui fera la traduction entre les signaux UART et le port série virtuel (port COM) sur USB.

Les cartes de développement qui disposent d'un port USB de manière native sur leur PCB (la carte plastique imprimée sur laquelle sont soudés tous les composants), comme les NodeMCU, embarquent forcément une de ces puces de traduction. On appel cela des puces UART TTL to USB (TTL signifie que le niveau 0V est associé au niveau logique bas).

Sur la photo ci-dessus vous pouvez observer le port micro USB située sur le PCB de la carte, ainsi qu'un composant nommé "USB to UART" qui permet de faire la traduction entre la communication en UART et le la communication série en USB. Cette carte NodeMCU aura la capacité de se connecter en direct sur un ordinateur et sera reconnue comme un équipement sur port "COM".

Si votre microcontrôleur ne dispose pas d'interface USB native, pas de puce de traduction embarquée, il faudra donc passer par un adaptateur externe. Il faudra connecter les broches Tx/Rx du microcontrôleur vers les ports d'entrée Rx/Tx du traducteur. Ce dernier devra délivrer un port USB en sortie.

Traducteur externe UART vers USB

Les puces les plus connues réalisant cette traduction sont appelées FTDI (Future Technology Devices International, ). FTDI est une marque qui fabrique des puces capables de traduire en USB des protocoles tels que UART TTL ou RS232. Les cartes qui utilisent les puces FTDI sont en général plus chères car la société écossaise impose un système de licence.
D'autres constructeurs on réalisé des contrefaçons ou ont construit leurs propres puces de traduction.
On trouvera couramment sur le marché des puce de type CH340/CH340G.

Différents type/marques de traducteur UART TTL - USB:

FTDI FT232RL
FTDI FT232R
FTDI FT232H
FTDI FT201XS
FTDI FT230X
FTDI FT231X
FTDI FT2232 D/H
Prolific PL2303
SiLabs CP210X range (CP2102 remplacée par CP2104).
CH340G / CH341G (Sur eBay adapté à l'ESP01: ICI).
STMicro Virtual Comms Port
UBlox USB GPS
Teensy Microcontrollers
Arduino Boards using CDC (UNO, Mega, Leonardo etc)
Microchip MCP2200 (CDC)
CDC Communications

A chaque type/marque de puce, il faudra faire attention d'avoir installé le bon driver sur l'ordinateur. Si cette condition est remplie, vous devriez normalement pouvoir échanger des données entre microcontrôleur et ordinateur via le port USB sans problème.

Mise en pratique

Après toute cette théorie nous sommes désormais suffisamment armés pour passer à la pratique.

Nous allons donc commencer par regarder le matériel qui va nous être nécessaire. Ensuite nous pourrons réaliser un prototype qui nous permettra de détailler comment câbler le montage. Pour finir nous écrirons un mini programme dont le seul but sera de montrer que l'échange de données entre le PC et le microcontrôleur fonctionne parfaitement.

Conseils en matériel

Philosophie commerciale

Les liens que je vous donne, pointent en général sur des équipements pour lesquels j'ai cherché le meilleur rapport qualité/prix. Je les ai même la plupart du temps commandés moi même et testés. Et bien que l’âme de ce blog est la culture et le partage de connaissances, n'hésitez pas à faire vos achats après avoir cliqué sur mes liens. Déjà parce que cela ne vous fera pas payer plus cher, bien au contraire, car souvent vous bénéficierez d'un prix plus compétitif et d'un équipement validé. Ensuite parce que les quelques centimes de commission qui me seront reversés, seront aussi utiles à m'aider pour investir dans du matériel et en faire profiter notre communauté, que dans les poches des grands sites marchands.

Un GRAND merci à tous ceux qui ont joué le jeu.

Les adaptateur UART to USB

L'équipement principal qui est concerné par cet article est le traducteur UART-USB. Comme nous l'avons vu, il en existe de nombreuses marques, à base de différents modèles de puces électroniques, nécessitant chacune son driver pour être reconnue par l'ordinateur.

Les traducteurs à base de matériel FTDI étant les plus chers à cause de leur système de licence que doivent verser les intégrateurs au fondeur, nous nous écarterons de ces derniers car le surcoût payé ici n'apporte pas vraiment de valeur ajoutée.

Toutefois, si malgré tout vous souhaitez vous orienter vers une puce FTDI, je vous conseille de choisir un adaptateur vous garantissant d'avoir un circuit original (les "faux" étant nombreux). La puce FTDI la plus répandue pour réaliser l'adaptation UART-USB est la FT232R. Voici quelques exemples d'adaptateurs que vous pouvez vous procurer, avec, celui du milieu à un prix très inférieur aux autres qui peut laisser à réfléchir!

Si vous ne voyez pas apparaître les liens et les images ci-dessus, il se peut que ce soit votre bloqueur de publicité qui les supprime. Dans ce cas, n'hésitez pas à mettre ce dernier en pause ou à le désactiver sur mon blog. Vous ne risquez rien!

Focus sur l'alimentation

Comme vous pourrez le constater, tous les adaptateurs disposent d'un port USB d'un coté et délivrent un ensemble de broches de l'autre coté. Ce sont ces broches qui vont servir à raccorder nos microcontrôleurs et autres circuits électroniques. Parmi ces broches nous devront au minimum retrouver Tx/Rx, GND et Vcc. Mais attention! La tension délivrée par cette dernière dépend du modèle d'adaptateur. Parfois nous allons trouver un +5V. Parfois un +3,3V, parfois une broche nommée Vcc dont la tension sera soit 5V, soit 3,3V en fonction du positionnement d'un cavalier sur la carte ...

En réalité il existe de nombreuses possibilités. Ce sera à vous de choisir en fonction de vos besoins et de vos moyens. Dans notre cas, nous n'avons pas besoin de cette fonctionnalité d'alimentation électrique fournie par l'adaptateur.

Focus sur la tension logique

Les broches gérant les signaux logiques (Rx, Tx, ...) ont dans les circuits TTL une tension de fonctionnement de +5V pour le signal haut et 0V pour le signal bas.

Mais attention, car certains microcontrôleurs, comme les ESP8266 (ou le Raspberry PI), ont des GPIO qui fonctionnent avec des tensions logiques à +3,3V. Si votre adaptateur envois un signal à +5V sur Tx vers l'ESP il y a un risque de surtension. Il faudra donc intercaler entre les deux un pont diviseur de tension (par exemple diviser par deux la tension sera un bon compromis) ou un convertisseur de niveau logique. Par contre vous pouvez continuer à recevoir un signal logique de 3,3V sur une broche prévue pour recevoir du 5V: cela fonctionnera.

Focus sur les broches de données
Certains adaptateurs, en plus des broches Tx et Rx fournissent d'autres broches de données spécifiques. Ces dernières portent le nom de:

DTR: utile pour l'auto-reset d'un Arduino après le téléversement d'un programme.
CTS/RTS: utilisées par le standard RS232 pour le contrôle de flux.
Header 2*4P: adapté aux broches d'un ESP01.

Pour conclure, tous les modules conviendront pour assurer la communication entre un microcontrôleur et un ordinateur. En fonction du contexte (broches, tensions, ...) il faudra parfois mieux s'orienter sur un modèle qui sera adapté à votre besoin si vous ne souhaitez pas avoir certaines adaptations à réaliser lors du montage.

Mis à part les FTDI, les adaptateurs les plus courants utilisent des puces CH340G ou CP2102. On trouve parfois des articles sur internet qui prétendent que CH340 est moins stable que CP2102. Personnellement je ne fais pas ce constat. CH340 étant ce que l'on trouve de moins cher et de plus répandu chez les constructeurs chinois, je me suis équipé de ces derniers et je n'ai jamais eu aucun problème de stabilité ou de driver.

Etant plutôt neutre sur ce choix, je ne peux que vous conseiller de prendre les deux et de vous faire vous même un avis. Voici une sélection d'adaptateurs. Personnellement j'utilise le premier sur lequel j'ai fait une petite adaptation pour pouvoir mettre l'ESP en mode programmation. Cette adaptation est décrite dans mon article ICI. Avec le second, vous n'aurez pas cette soudure à réaliser car le mode programmation se sélectionne avec un bouton directement présent sur la carte. Ces deux adaptateurs sont spécialisés pour l'ESP01 mais s'adaptent aussi très bien aux NodeMCU et tous les microcontrôleurs ESP8266. La tension logique des broches est en 3,3V. Il n'y aura pas besoin de diviser la tension, contrairement aux autres modèles.

En complément de l'adaptateur, voici une liste de petit matériel qui sera très utile:

Des cables dupont. Il en existe de plusieurs sortes, longueurs, couleurs. Le mieux pour être paré à toute éventualité est d'en prendre un lot tel que celui CI.
Le NodeMCU est la plateforme idéale pour programmer un microcontrôleur ESP8266.
Pour réaliser tous ces raccordements et tests plus facilement, je vous conseil également de vous procurer quelques connecteurs rapides à ressorts comme CECI.
Si vous n'avez pas envie de monter un pont diviseur de tension à la main pour convertir les signaux logiques 5V en 3,3V et réciproquement, CES convertisseur de niveau vous permettront de raccorder 8 broches sans avoir à vous préoccuper du sens. Sur eBay vous en trouverez également de différentes sortes ICI.
Pour finir dans les petits équipements, nous aurons besoin d'accu, j'ai choisi des 18650, ainsi que leurs boîtiers d'utilisation.

Le câblage

Maintenant que nous avons tout le matériel nécessaire, nous allons voir comment raccorder les différents éléments. Etant donné le nombre de configurations possibles, je vais vous présenter le montage que j'ai réalisé avec mon matériel. Il vous faudra l'adapter à votre contexte mais si vous avez compris la logique tout cela sera particulièrement simple et rapide.

Je suis parti d'un NodeMCU ESP12E que j'ai alimenté par une pile 18650 logée dans son boitier. L'objectif ici était de rendre le microcontrôleur indépendant de l'alimentation USB.

Concernant le module de conversion UART-USB, j'ai utilisé du matériel que j'avais: un modèle adaptateur-convertisseur ESP01. Le circuit qui gère la traduction UART est de type CH340. Il faudra donc s'assurer que les drivers sont correctement installés sur l'ordinateur cible afin que l'USB soit bien reconnu comme port COM.

Voici quelques explications:

Tx sur l'adaptateur se raccorde sur Tx de l'ESP (ne pas inverser).
Rx de l'adaptateur se connecte sur Rx de l'ESP.
Il est très important de raccorder les masses ensembles sinon vous constaterez des comportements étranges: GND de l'adaptateur sur GND de l'ESP.
le GPIO0 de l'ESP doit être connecté au GPIO0 de l'adaptateur. Dans le cas d'un ESP12e (le NodeMCU), le GPIO0 correspond à la broche D3. Cette connexion est utile si vous souhaitez placer le NodeMCU en mode "flash" pour téléverser un programme.
Cette connexion correspond à l'adaptation que j'ai réalisée sur l'adaptateur: j'ai soudé les PIN correspondant au GPIO0 et au GND à des fils (le bleu et le noir). Lorsque l'on souhaite injecter un programme dans le NodeMCU, il faut démarrer ce dernier avec son GPIO0 sur GND. Donc concrètement on procède de la manière suivante:

Mettre l'adaptateur USB dans un port USB du PC.
Raccorder entre eux les deux fils soudés (au point 5: le bleu sur le noir).
Alimenter le NodeMCU: ce dernier démarre donc avec sa broche GPIO0 à GND.
Séparer les deux cables du point 5: le GPIO0 du NodeMCU se trouve à nouveau libre.
Lancer le téléversement du programme depuis l'IDE Arduino sur votre PC.

Correspond à l'alimentation du NodeMCU. J'ai souligné ce point car RST est raccordé au pole positif. Ce n'est pas obligatoire dans tous les cas mais cela garanti de la stabilité. Dans mon cas, sans faire cela, j'avais la liaison série qui générait plein de caractères aléatoires pendant plusieurs secondes avant de se stabiliser.

Et pour finir une photo de mon montage:

Sur la photo ci-dessus on distingue le montage que j'ai réalise. Pour plus de confort vous pouvez observer que j'ai connecté le NodeMCU sur deux mini breadboards. Et pour la connexion USB vers le PC, je suis passé par un HUB USB de base uniquement pour une question de longueur de câble.

Le code

Voici un petit programme de test que j'ai réalisé dont le seul but est d'afficher en permanence un compteur sur la liaison série.
Je ne donnerais pas d'explications sur ce code.
J'attire juste votre attention sur la manière dont je le structure. Ce sont des conventions que je me force à utiliser et qui sont très utiles quand on se lance dans le développement.

En début de programme une zone permet d'indiquer à quoi sert le programme, sa version et aussi des idées d'évolutions possibles.
Vous remarquerez la forme de "séparations" que j'utilise pour identifier différentes parties du code.
Remarquez aussi l'utilisation de la variable stVersion qui est de type String. Ce type de variable est plus facile à utiliser que les autres types car compatible avec des opérateurs tels que le "+".
J'initialise la vitesse de transmission série à 74880 bauds. Cette vitesse doit être aussi spécifiée coté moniteur série sur le PC. Vous pouvez utiliser toute autre vitesse mais j'ai remarqué qu'avec celle-ci, les caractères qui sont transmis par la liaison série au démarrage de l'ESP s'affichent correctement.

/********************************************************************
* Ce programme est destiné à tout microcontroleur disposant d'une liaison série.
*
* Réalise des essais de suivi de tension de l'alimentation interne
* ou depuis la broche A0.
*
* Evolutions possible :
*
* Versions :
* 03/03/2019 - v1 : Création
*
* (c) acampeaux@gmail.com
*********************************************************************/

/*====================================================================
* CONSTANTES & VARIABLES
* ==================================================================*/
String stVersion = "v4";
int iNombre = 0;

/*====================================================================
* Fonction setup
* Initialisation de la liaison série
* ==================================================================*/
void setup() {
Serial.begin(74880);
delay( 100 );
Serial.println( "\nInitialisation liaison serie OK" );
Serial.println( "Prog version " + stVersion );
}

/*====================================================================
* Fonction loop
* Affiche un entier incrémenté à chaque passage
====================================================================*/
void loop() {
String stChaine = "Loop number: ";
Serial.println( stChaine + iNombre++ );
delay( 3000 );
}

Dans cet article j'ai réalisé tous mes montages, codes et tests avec un ESP8266 NodeMCU Lolin V3. Mais la majorité de ce qui est écrit sera compatible ou très facilement adaptable avec tout type de carte disposant de broches portant les fonctions de liaison série TX/RX.

Soutenez la blogoculture ...

Le plus simplement du monde, si vous avez un achat à faire sur Amazon, accédez au site à partir de ce lien (que vous pouvez ajouter dans vos favoris) : https://amzn.to/2nbe4sm

Soutenez la blogoculture ...

Le plus simplement du monde, si vous avez un achat à faire sur Amazon, accédez au site à partir de ce lien (que vous pouvez ajouter dans vos favoris) : https://amzn.to/2nbe4sm

... mais aussi ...

Vous appréciez les articles frais et vitaminés de ce blog et vous voulez faire un geste pour encourager ce partage, saluer le travail, ou parce que vous y avez trouvé des choses utiles ( et que vous êtes sympa ) ?

... c'est possible et vous avez le choix !