{"id":2522,"date":"2020-04-16T11:46:35","date_gmt":"2020-04-16T09:46:35","guid":{"rendered":"http:\/\/www.ardpylab.fr\/?page_id=2522"},"modified":"2020-05-10T16:42:10","modified_gmt":"2020-05-10T14:42:10","slug":"envoi-de-donnees","status":"publish","type":"page","link":"https:\/\/www.ardpylab.fr\/?page_id=2522","title":{"rendered":"Envoi de donn\u00e9es"},"content":{"rendered":"\n

(du moniteur s\u00e9rie vers l\u2019Arduino)<\/strong><\/em><\/h2>\n

 <\/p>\n

 <\/p>\n

L\u2019Arduino peut \u00e9galement recevoir des donn\u00e9es depuis le moniteur s\u00e9rie.<\/p>\n

 <\/p>\n

<\/a>. Programme pour la r\u00e9ception d\u2019un caract\u00e8re par l’Arduino<\/u> <\/a>

<\/strong><\/span><\/h4>\n\n\n\n
\n
\"\"<\/a><\/figure>\n<\/div>\n\n\n\n


Dans ce programme, on demande \u00e0 l\u2019utilisateur de saisir un caract\u00e8re dans le moniteur s\u00e9rie.
Une fois, la saisie effectu\u00e9e, le nombre d’octets (caract\u00e8res) disponible pour lecture dans la file d’attente du port s\u00e9rie n\u2019est plus nul (Serial.available() > 0<\/strong>)<\/strong>, le caract\u00e8re envoy\u00e9 est alors lu \u00e0 l\u2019aide de la fonction \u201dread()\u201d <\/strong>et stock\u00e9 dans la variable \u201dc\u201d<\/strong> d\u00e9finie comme \u00e9tant un caract\u00e8re.<\/p>\n

La variable \u201dc\u201d<\/strong> est alors affich\u00e9e dans le moniteur s\u00e9rie :

<\/p>\n\n\n\n

\n
\"\"<\/figure>\n<\/div>\n

 <\/p>\n\n\n\n

Remarques<\/u><\/strong> :<\/strong><\/p>\n

– L\u2019instruction \u201dchar c\u201d<\/strong> d\u00e9clare une variable, \u201dc\u201d<\/strong> d\u2019un octet de m\u00e9moire (8 bits) qui contient une valeur correspondant \u00e0 un caract\u00e8re. Les caract\u00e8res uniques sont \u00e9crits entre des guillemets simples, comme ceci : ‘A’<\/strong><\/p>\n

– Les caract\u00e8res sont stock\u00e9s de la m\u00eame fa\u00e7on que les nombres : \u00e0 chaque caract\u00e8re correspond une valeur num\u00e9rique comprise entre 0 et 127 (code ASCII). Ceci signifie \u00e9galement qu’il est possible de faire des op\u00e9rations sur les caract\u00e8res, dans lesquelles la valeur ASCII du caract\u00e8re est utilis\u00e9e (par exemple ‘A’+1 a la valeur 66, car la valeur ASCII de la lettre capitale A est 65).<\/p>\n

– Si la donn\u00e9e envoy\u00e9e contient plus d\u2019un caract\u00e8re (par exemple, le nombre \u00ab\u00a0123\u00a0\u00bb), la donn\u00e9e est consid\u00e9r\u00e9e comme une suite de 3 caract\u00e8res qui seront affich\u00e9s \u00e0 la suite tant que la fonction \u201dSerial.available()\u201d<\/strong> retournera une valeur non nulle.<\/p>\n

– Dans le code ASCII, chaque caract\u00e8re est cod\u00e9 sous 7 bits (valeur num\u00e9rique comprise entre 0 et 127 en d\u00e9cimal) et les accents ne sont pas pris en charge.
C\u2019est pourquoi, les messages affich\u00e9s dans le moniteur s\u00e9rie, par l\u2019instruction \u201dSerial.print()\u201d<\/strong>, sont envoy\u00e9s sans les accents (\u201dcaractere\u201d sans le \u201d\u00e8\u201d), sinon voici ce qui est affich\u00e9 :<\/p>\n\n\n\n

\n
\"\"<\/figure>\n<\/div>\n\n\n\n


– Le code ASCII (American Standard Code for Information Interchange) est la fa\u00e7on standard de coder un texte num\u00e9riquement :<\/p>\n\n\n\n

\n
\"\"<\/figure>\n<\/div>\n\n\n\n


Le code ASCII ne contient pas de caract\u00e8res accentu\u00e9s parce qu\u2019il a \u00e9t\u00e9 mis au point pour la langue anglaise. Pour coder ce type de caract\u00e8re, il faut recourir \u00e0 un autre code. Le code ASCII a donc \u00e9t\u00e9 \u00e9tendu \u00e0 8 bits (un octet) pour pouvoir coder plus de caract\u00e8res (on parle d’ailleurs de code ASCII \u00e9tendu…).<\/p>\n

Ce code attribue les valeurs 0 \u00e0 255 aux lettres majuscules et minuscules, aux chiffres, aux marques de ponctuation et aux autres symboles :<\/p>\n\n\n\n

\n
\"\"<\/figure>\n<\/div>\n

 <\/p>\n\n\n\n

– il est possible d\u2019afficher des caract\u00e8res avec accent dans le moniteur s\u00e9rie en ajoutant une fonction aux programmes Arduino :<\/p>\n\n\n\n

\n\n\n\n
\n

void PrintAccents(String TEXTE, boolean CR) {<\/span><\/p>\n

  int CAR;<\/span><\/p>\n

  for (byte I=0; I < TEXTE.length(); I++) {<\/span><\/p>\n

       if (byte (TEXTE[I]) == 195)        <\/span><\/p>\n

          {CAR = int(TEXTE[++I]);<\/span><\/p>\n

           switch (CAR) {<\/span><\/p>\n

             case -68 : {Serial.print(char (252)); break;} \/\/ \u00fc<\/span><\/span><\/p>\n

             case -69 : {Serial.print(char (251)); break;} \/\/ \u00fb<\/span><\/span><\/p>\n

             case -71 : {Serial.print(char (249)); break;} \/\/ \u00f9<\/span><\/span><\/p>\n

             case -74 : {Serial.print(char (246)); break;} \/\/ \u00f6<\/span><\/span><\/p>\n

             case -76 : {Serial.print(char (244)); break;} \/\/ \u00f4<\/span><\/span><\/p>\n

             case -81 : {Serial.print(char (239)); break;} \/\/ \u00ef<\/span><\/span><\/p>\n

             case -82 : {Serial.print(char (238)); break;} \/\/ \u00ee<\/span><\/span><\/p>\n

             case -85 : {Serial.print(char (235)); break;} \/\/ \u00eb<\/span><\/span><\/p>\n

             case -86 : {Serial.print(char (234)); break;} \/\/ \u00ea<\/span><\/span><\/p>\n

             case -87 : {Serial.print(char (233)); break;} \/\/ \u00e9<\/span><\/span><\/p>\n

             case -88 : {Serial.print(char (232)); break;} \/\/ \u00e8<\/span><\/span><\/p>\n

             case -89 : {Serial.print(char (231)); break;} \/\/ \u00e7  <\/span>    <\/span><\/p>\n

             case -92 : {Serial.print(char (228)); break;} \/\/ \u00e4<\/span>    <\/span><\/p>\n

             case -94 : {Serial.print(char (226)); break;} \/\/ \u00e2<\/span><\/span><\/p>\n

             case -96 : {Serial.print(char (224)); break;} \/\/ \u00e0  <\/span>                 <\/span><\/p>\n

             case -126 : {Serial.print(char (194)); break;} \/\/ \u00c2<\/span><\/span><\/p>\n

             case -128 : {Serial.print(char (192)); break;} \/\/ \u00c0<\/span><\/span><\/p>\n

             case -108 : {Serial.print(char (212)); break;} \/\/ \u00d4<\/span><\/span><\/p>\n

             case -114 : {Serial.print(char (206)); break;} \/\/ \u00ce<\/span><\/span><\/p>\n

             case -118 : {Serial.print(char (202)); break;} \/\/ \u00ca<\/span><\/span><\/p>\n

             case -119 : {Serial.print(char (201)); break;} \/\/ \u00c9 <\/span>         <\/span><\/p>\n

             case -120 : {Serial.print(char (200)); break;} \/\/ \u00c8 <\/span>           <\/span><\/p>\n

             case -121 : {Serial.print(char (199)); break;}}} \/\/ \u00c7<\/span><\/span><\/p>\n

       else Serial.print(TEXTE[I]);}<\/span><\/p>\n

  if (CR) Serial.println(); }<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

Et d\u2019utiliser la fonction \u201dPrintAccents()\u201d<\/strong> \u00e0 la place de \u201dSerial.Print()\u201d<\/strong> pour afficher un message comportant des accents dans le moniteur s\u00e9rie.

<\/p>\n

En fait pour l\u2019Arduino, les caract\u00e8res, qu\u2019ils soient accentu\u00e9s ou pas, sont cod\u00e9s sur 8 bits de mani\u00e8re sign\u00e9e, c\u2019est-\u00e0-dire de -127 \u00e0 127 en d\u00e9cimale, alors que dans le code ASCII \u00e9tendu, Les caract\u00e8res accentu\u00e9s sont cod\u00e9s de 128 \u00e0 255.<\/p>\n

La fonction \u201dPrintAccents()\u201d<\/strong> va analyser chaque caract\u00e8re de la chaine qui doit \u00eatre envoy\u00e9e dans le moniteur s\u00e9rie, \u00e0 l\u2019aide d\u2019une boucle \u201d<\/strong>for\u201d<\/strong>. Si le caract\u00e8re n\u2019est pas accentu\u00e9, il est affich\u00e9 tel quel, sinon (\u201d<\/strong> if (byte (TEXTE[I]) == 195)<\/strong> \u201d<\/strong>) en fonction de la valeur de sa conversion en nombre d\u00e9cimal (\u201d<\/strong>CAR = int(TEXTE[++I])<\/strong> \u201d<\/strong>), on affiche le caract\u00e8re correspondant en utilisant son code en ASCII \u00e9tendu (de 128 \u00e0 255).<\/p>\n

Un retour \u00e0 la ligne est effectu\u00e9 si la valeur de CR est \u00e9gale \u00e0 1.

<\/p>\n

Exemple (programme \u201dAccents.ino<\/a>\u201d<\/strong>)<\/u> :<\/p>\n\n\n\n

\n
\"\"<\/a><\/figure>\n<\/div>\n

R\u00e9sultat dans le moniteur s\u00e9rie<\/span> :<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n


Edit<\/span>:<\/p>\n

Avec les nouvelles version du logiciel Arduino IDE <\/strong>(\u00e0 partir de 1.8.10), il est maintenant possible d’afficher des messages avec des accents dans le moniteur s\u00e9rie:<\/p>\n\n\n\n

\n
\"\"<\/figure>\n<\/div>\n

Et la fonction \u00ab\u00a0PrintAccents()<\/strong>\u00a0\u00bb ne peut donc \u00eatre utilis\u00e9e qu\u2019avec les versions pr\u00e9c\u00e9dentes du logiciel Arduino IDE <\/strong>(fonction test\u00e9e avec la version 1.8.1).<\/p>\n\n\n\n

 <\/p>\n

<\/a>E<\/u>xemple d\u2019application du programme de r\u00e9ception d\u2019un caract\u00e8re<\/u> :<\/strong><\/h4>\n

Avec notre circuit<\/a>, support des exemples d\u2019application, le programme nomm\u00e9 \u00ab\u00a0LedRVB.ino<\/strong><\/a>\u00a0\u00bb qui sera t\u00e9l\u00e9vers\u00e9 dans la m\u00e9moire de l\u2019Arduino demande \u00e0 l\u2019utilisateur de saisir un caract\u00e8re :<\/p>\n

. \u2018R<\/strong>\u2019, \u2018V<\/strong>\u2019 ou \u2018B<\/strong>\u2019 pour allumer respectivement la DEL rouge, verte ou bleue<\/p>\n

. \u20180<\/strong>\u2019 pour \u00e9teindre les DELs<\/p>\n\n\n\n

\n
\"\"<\/figure>\n<\/div>\n

Le caract\u00e8re envoy\u00e9 est lu et l\u2019action correspondante est effectu\u00e9e. Le programme ne fait rien si le caract\u00e8re lu n\u2019est pas un des caract\u00e8res attendus.<\/p>\n\n\n\n

\n
\"\"<\/a><\/figure>\n<\/div>\n

 <\/p>\n\n\n\n

<\/a>. Programme pour la r\u00e9ception d\u2019une chaine de caract\u00e8res<\/u> par l’Arduino

<\/span><\/strong><\/span><\/h4>\n\n\n\n

Les chaines de caract\u00e8res sont repr\u00e9sent\u00e9es sous la forme de tableau de variables de type \u201dchar\u201d<\/strong> se terminant par un caract\u00e8re nul (code ASCII 0<\/strong>, \u00e0 distinguer du ‘0<\/strong>‘ qui a le code ASCII 48<\/strong>) et permettant ainsi \u00e0 la fonction \u201dSerial.print()\u201d<\/strong> de savoir o\u00f9 se termine la cha\u00eene de caract\u00e8res <\/p>\n

Exemples<\/u> :<\/p>\n\n\n\n

\n\n\n\n
\n

char Str1[15];          \/\/ D\u00e9clare un tableau de 15 caract\u00e8res sans l’initialiser       <\/span><\/span><\/p>\n

char Str2[8] = {‘a’, ‘r’, ‘d’, ‘u’, ‘i’, ‘n’, ‘o’};       \/\/D\u00e9clare un tableau de caract\u00e8res (avec un caract\u00e8re suppl\u00e9mentaire non utilis\u00e9) et le compilateur ajoutera le caract\u00e8re nul requis<\/span><\/span><\/p>\n

char Str3[8] = {‘a’, ‘r’, ‘d’, ‘u’, ‘i’, ‘n’, ‘o’, ‘\u0000’};   \/\/Idem, mais en d\u00e9clarant explicitement le caract\u00e8re nul<\/span><\/span><\/p>\n

char Str4[ ] = \u00ab\u00a0arduino\u00a0\u00bb;      \/\/ D\u00e9clare un tableau de caract\u00e8res initialis\u00e9 avec une cha\u00eene de caract\u00e8re constante entre guillemets doubles : le compilateur dimensionnera le tableau pour stocker la cha\u00eene de caract\u00e8re constante et le caract\u00e8re nul terminal<\/span><\/span><\/p>\n

char Str5[8] = \u00ab\u00a0arduino\u00a0\u00bb;    \/\/D\u00e9clare un tableau de caract\u00e8res initialis\u00e9 avec une taille explicite et une cha\u00eene de caract\u00e8re constante (avec un caract\u00e8re suppl\u00e9mentaire non utilis\u00e9) et le compilateur ajoutera le caract\u00e8re nul requis<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

La r\u00e9ception d\u2019une chaine de caract\u00e8res envoy\u00e9e depuis le moniteur s\u00e9rie, peut \u00eatre consid\u00e9r\u00e9 comme un envoi successif de caract\u00e8res uniques que l\u2019on peut stocker dans un tableau de caract\u00e8res afin de reconstituer la chaine.<\/p>\n

Le programme nomm\u00e9 \u201dChaines.ino<\/a>\u201d ci-dessous effectue cette reconstitution :<\/p>\n\n\n\n

\n
\"\"<\/a><\/figure>\n<\/div>\n

Dans ce programme, il est demand\u00e9 de saisir une chaine de caract\u00e8res.
Tant que le nombre de caract\u00e8res disponibles sur le port s\u00e9rie est nul (Val==0<\/strong>), la m\u00e9moire tampon du port s\u00e9rie est v\u00e9rifi\u00e9e (Val=Serial.available()<\/strong>), toutes les 200 ms, jusqu\u2019\u00e0 ce que tous les caract\u00e8res de la chaine soient comptabilis\u00e9s.
Ceux-ci sont alors lu un par un \u00e0 travers une boucle \u00ab\u00a0for<\/strong>\u00a0\u00bb (tampon[i]=Serial.read()<\/strong>) et sont stock\u00e9s dans un tableau de 20 caract\u00e8res au maximum appel\u00e9 \u00ab\u00a0tampon<\/strong>\u00a0\u00bb qui est ensuite affich\u00e9 dans le moniteur s\u00e9rie.
Puis la m\u00e9moire du port s\u00e9rie est vid\u00e9e et il est de nouveau demander de saisir une chaine de caract\u00e8res.<\/p>\n

Voici le r\u00e9sultat dans le moniteur s\u00e9rie :<\/p>\n\n\n\n

\n
\"\"<\/figure>\n<\/div>\n

 <\/p>\n\n\n\n

Une autre m\u00e9thode pour recevoir une chaine de caract\u00e8res depuis le moniteur s\u00e9rie est d\u2019utiliser la fonction \u201d<\/strong>readString()\u201d<\/strong> qui lit les caract\u00e8res contenus dans la m\u00e9moire tampon du port s\u00e9rie et retourne une chaine de caract\u00e8re. Au-del\u00e0, d\u2019un certain temps (par d\u00e9faut, 1 s), la fonction se termine. Le temps d\u2019attente pour recevoir les donn\u00e9es peut \u00eatre r\u00e9gl\u00e9 avec la fonction \u201d<\/strong>setTimeout()\u201d<\/strong>\u00a0en ms.<\/p>\n

<\/a>Par exemple, dans ce nouveau programme nomm\u00e9 \u201dReadString.ino<\/a>\u201d<\/strong>, toujours avec le m\u00eame circuit, on va maintenant demander \u00e0 l\u2019utilisateur d\u2019envoyer un message. Si le message est \u201d<\/strong>ON\u201d<\/strong>, la DEL rouge s\u2019allume, et si c\u2019est \u201d<\/strong>OFF\u201d<\/strong>, la DEL rouge s\u2019\u00e9teint.<\/p>\n\n\n\n

\n
\"\"<\/a><\/figure>\n<\/div>\n

 <\/p>\n\n\n\n

Remarques<\/u><\/strong> :<\/strong><\/p>\n

– Contrairement aux caract\u00e8res uniques (variable de type \u201dchar\u201d<\/strong>) qui sont \u00e9crit entre des guillemets simples (\u2018A\u2019<\/strong>), les chaines de caract\u00e8res sont \u00e9crites entre des doubles guillemets (\u201dABC\u201d<\/strong>).<\/p>\n

– L\u2019instruction \u201d String msg=\u201d\u201d; \u201d<\/strong>d\u00e9clare une variable \u201dchaine de caract\u00e8res\u201d<\/strong> initialement vide.<\/p>\n

– les objets String<\/strong> sont des instances de la classe String()<\/strong>, qui est int\u00e9gr\u00e9e au logiciel Arduino depuis la version 0019 et qui permet d’utiliser et de manipuler des cha\u00eenes de caract\u00e8res.

<\/p>\n

Tous les exemples suivants sont des d\u00e9clarations valides pour une nouvelle instance String :<\/p>\n\n\n\n

\n\n\n\n
\n

String stringOne = \u201dHello String\u201d; \/\/ en utilisant une cha\u00eene de caract\u00e8res<\/span><\/span>

String stringOne = String(‘a’); \/\/ conversion d’un caract\u00e8re simple en objet String<\/span>

String stringTwo = String(\u201dThis is a string\u201d); \/\/ conversion d’une cha\u00eene de caract\u00e8re en objet String <\/span><\/span><\/p>\n

String stringOne = String(stringTwo + \u201d with more\u201d); \/\/ concat\u00e9nation d’un objet String et d’une cha\u00eene<\/span><\/span><\/p>\n

String stringOne = String(13); \/\/ conversion d’un nombre en base 10 par d\u00e9faut<\/span><\/span><\/p>\n

String stringOne = String(analogRead(0), DEC); \/\/ conversion d’une valeur int en base 10<\/span>
<\/span>
String stringOne = String(45, HEX); \/\/ conversion de la valeur 45 en base hexadecimale<\/span>
<\/span>
String stringOne = String(255, BIN); \/\/ conversion de la valeur 255 en base binaire<\/span>
<\/span>
String stringOne = String(millis(), DEC); \/\/ conversion d’une valeur long en base 10<\/span>
<\/span>
String monString=char(65); \/\/ ajoute le caract\u00e8re ‘A’ au String \u00e0 partir du code ASCII 65<\/span><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n\n\n\n

\u00a0<\/p>\n

\u00a0<\/p>\n\n\n

\n
\n\n
\"\"<\/a><\/figure><\/div>\n\n<\/div>\n\n
\n\n
\"\"<\/a><\/figure><\/div>\n\n<\/div>\n<\/div><\/div>\n\n\n\n","protected":false},"excerpt":{"rendered":"

(du moniteur s\u00e9rie vers l\u2019Arduino)     L\u2019Arduino peut \u00e9galement recevoir des donn\u00e9es depuis le moniteur s\u00e9rie.   . Programme pour la r\u00e9ception d\u2019un caract\u00e8re par l’Arduino  Dans ce programme, on demande \u00e0 l\u2019utilisateur de saisir un caract\u00e8re dans le moniteur s\u00e9rie. Une fois, la saisie effectu\u00e9e, le nombre d’octets (caract\u00e8res) disponible pour lecture dans […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-2522","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/pages\/2522","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=2522"}],"version-history":[{"count":0,"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=\/wp\/v2\/pages\/2522\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.ardpylab.fr\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=2522"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}