[ Arduino 302] Envoyer et recevoir des données sur la voie série

Dans ce chapitre, nous allons apprendre à utiliser la voie série avec Arduino. Nous allons voir comment envoyer puis recevoir des informations avec l’ordinateur, enfin nous ferons quelques exercices pour vérifier que vous avez tout compris. 🙂 Vous allez le découvrir bientôt, l’utilisation de la voie série avec Arduino est quasiment un jeu d’enfant, puisque tout est opaque aux yeux de l’utilisateur…

Préparer la voie série

Notre objectif, pour le moment, est de communiquer des informations de la carte Arduino vers l’ordinateur et inversement. Pour ce faire, on va d’abord devoir préparer le terrain.

Du côté de l’ordinateur

Pour pouvoir utiliser la communication de l’ordinateur, rien de plus simple. En effet, L’environnement de développement Arduino propose de base un outil pour communiquer. Pour cela, il suffit de cliquer sur le bouton Icône de la voie série (pour les versions antérieures à la version 1.0) dans la barre de menu pour démarrer l’outil. Pour la version 1.0, l’icône a changé et de place et de visuel :

Une nouvelle fenêtre s’ouvre : c’est le terminal série :

Voie série, vitesse

Dans cette fenêtre, vous allez pouvoir envoyer des messages sur la voie série de votre ordinateur (qui est émulée par l’Arduino) ; recevoir les messages que votre Arduino vous envoie ; et régler deux trois paramètres tels que la vitesse de communication avec l’Arduino et l’autoscroll qui fait défiler le texte automatiquement. On verra plus loin à quoi sert le dernier réglage.

Du côté du programme

L’objet Serial

Pour utiliser la voie série et communiquer avec notre ordinateur (par exemple), nous allons utiliser un objet (une sorte de variable mais plus évoluée) qui est intégré nativement dans l’ensemble Arduino : l’objet Serial.

Pour le moment, considérez qu’un objet est une variable évoluée qui peut exécuter plusieurs fonctions. On verra (beaucoup) plus loin ce que sont réellement des objets. On apprendra à en créer et à les utiliser lorsque l’on abordera le logiciel Processing.

Cet objet rassemble des informations (vitesse, bits de données, etc.) et des fonctions (envoi, lecture de réception,…) sur ce qu’est une voie série pour Arduino. Ainsi, pas besoin pour le programmeur de recréer tous le protocole (sinon on aurait du écrire nous même TOUT le protocole, tel que « Ecrire un bit haut pendant 1 ms, puis 1 bit bas pendant 1 ms, puis le caractère ‘a’ en 8 ms…), bref, on gagne un temps fou et on évite les bugs !

Le setup

Pour commencer, nous allons donc initialiser l’objet Serial. Ce code sera à copier à chaque fois que vous allez créer un programme qui utilise la voie série. Le logiciel Arduino à prévu, dans sa bibliothèque Serial, tout un tas de fonctions qui vont nous êtres très utiles, voir même indispensables afin de bien utiliser la voie série. Ces fonctions, je vous les laisse découvrir par vous même si vous le souhaitez, elles se trouvent sur cette page. Dans le but de créer une communication entre votre ordinateur et votre carte Arduino, il faut déclarer cette nouvelle communication et définir la vitesse à laquelle ces deux dispositifs vont communiquer. Et oui, si la vitesse est différente, l’Arduino ne comprendra pas ce que veut lui transmettre l’ordinateur et vice versa ! Ce réglage va donc se faire dans la fonction setup, en utilisant la fonction begin() de l’objet Serial.

Lors d’une communication informatique, une vitesse s’exprime en bits par seconde ou bauds. Ainsi, pour une vitesse de 9600 bauds on enverra jusqu’à 9600 ‘0’ ou ‘1’ en une seule seconde. Les vitesses les plus courantes sont 9600, 19200 et 115200 bits par seconde.

À présent, votre carte Arduino a ouvert une nouvelle communication vers l’ordinateur. Ils vont pouvoir communiquer ensemble.

Envoyer des données

Le titre est piégeur, en effet, cela peut être l’Arduino qui envoie des données ou l’ordinateur. Bon, on est pas non plus dénué d’une certaine logique puisque pour envoyé des données à partir de l’ordinateur vers la carte Arduino il suffit d’ouvrir le terminal série et de taper le texte dedans ! 😛 Donc, on va bien programmer et voir comment faire pour que votre carte Arduino envoie des données à l’ordinateur.

Et ces données, elles proviennent d’où ?

Eh bien de la carte Arduino… En fait, lorsque l’on utilise la voie série pour transmettre de l’information, c’est qu’on en a de l’information à envoyer, sinon cela ne sert à rien. Ces informations proviennent généralement de capteurs connectés à la carte ou de son programme (par exemple la valeur d’une variable). La carte Arduino traite les informations provenant de ces capteurs, s’il faut elle adapte ces informations, puis elle les transmet. On aura l’occasion de faire ça dans la partie dédiée aux capteurs, comme afficher la température sur son écran, l’heure, le passage d’une personne, etc.

Appréhender l’objet Serial

Dans un premier temps, nous allons utiliser l’objet Serial pour tester quelques envois de données. Puis nous nous attèlerons à un petit exercice que vous ferez seul ou presque, du moins vous aurez eu auparavant assez d’informations pour pouvoir le réaliser (ben oui, sinon c’est plus un exercice !).

Phrase ? Caractère ?

On va commencer par envoyer un caractère et une phrase. À ce propos, savez-vous quelle est la correspondance entre un caractère et une phrase ? Une phrase est constituée de caractères les uns à la suite des autres. En programmation, on parle plutôt de chaine caractères pour désigner une phrase.

  • Un caractère seul s’écrit entre guillemets simples : ‘A’, ‘a’, ‘2’, ‘!’, …
  • Une phrase est une suite de caractère et s’écrit entre guillemets doubles : « Salut tout le monde », « J’ai 42 ans », « Vive Zozor ! »

Pour vous garantir un succès dans le monde de l’informatique, essayez d’y penser et de respecter cette convention, écrire ‘A’ ce n’est pas pareil qu’écrire « A » !

println()

La fonction que l’on va utiliser pour débuter, s’agit de println(). Ces deux fonctions sont quasiment identiques, mais à quoi servent-elles ?

  • print() : cette fonction permet d’envoyer des données sur la voie série. On peut par exemple envoyer un caractère, une chaine de caractère ou d’autres données dont je ne vous ai pas encore parlé.
  • println() : c’est la même fonction que la précédente, elle permet simplement un retour à la ligne à la fin du message envoyé.

Pour utiliser ces fonctions, rien de plus simple :

Bien sûr, au préalable, vous devrez avoir « déclaré/créé » votre objet Serial et définis une valeur de vitesse de communication :

Cet objet, parlons-en. Pour vous aider à représenter de façon plus concise ce qu’est l’objet Serial, je vous propose cette petite illustration de mon propre chef :

Comme je vous le présente, l’objet Serial est muni d’un panel de fonctions qui lui sont propres. Cet objet est capable de réaliser ces fonctions selon ce que le programme lui ordonne de faire. Donc, par exemple, quand j’écris : print() en lui passant pour paramètre la chaine de caractère : « Salut les zéros ! ». On peut compléter le code précédent comme ceci :

Sur le terminal série, on verra ceci :

La fonction print() en détail

Après cette courte prise en main de l’objet Serial, je vous propose de découvrir plus en profondeur les surprises que nous réserve la fonction print().

Petite précision, je vais utiliser de préférence print().

Résumons un peu ce que nous venons d’apprendre : on sait maintenant envoyer des caractères sur la voie série et des phrases. C’est déjà bien, mais ce n’est qu’un très bref aperçu de ce que l’on peut faire avec cette fonction.

Envoyer des nombres

Avec la fonction print(), il est aussi possible d’envoyer des chiffres ou des nombres car ce sont des caractères :

Tiens, le nombre pi n’est pas affiché correctement ! C’est quoi le bug ? o_O

Rassurez-vous, ce n’est ni un bug, ni un oubli inopiné de ma part. :mrgreen: En fait, pour les nombres décimaux, la fonction print() affiche par défaut seulement deux chiffres après la virgule. C’est la valeur par défaut et heureusement elle est modifiable. Il suffit de rajouter le nombre de décimales que l’on veut afficher :

Envoyer la valeur d’une variable

Là encore, on utilise toujours la même fonction (qu’est-ce qu’elle polyvalente !). Ici aucune surprise. Au lieu de mettre un caractère ou un nombre, il suffit de passer la variable en paramètre pour qu’elle soit ensuite affichée à l’écran :

Trop facile n’est-ce pas ?

Envoyer d’autres données

Ce n’est pas fini, on va terminer notre petit tour avec les types de variables que l’on peut transmettre grâce à cette fonction print() sur la voie série. Prenons l’exemple d’un nombre choisi judicieusement : 65.

Pourquoi ce nombre en particulier ? Et pourquoi pas 12 ou 900 ?

Eh bien, c’est relatif à la table ASCII que nous allons utiliser dans un instant.

Tout d’abord, petit cours de prononciation, ASCII se prononce comme si on disait « A ski », on a donc : « la table à ski » en prononciation phonétique.

La table ASCII, de l’américain « American Standard Code for Information Interchange », soit en bon français : « Code américain normalisé pour l’échange d’information » est, selon Wikipédia :

« la norme de codage de caractères en informatique la plus connue, la plus ancienne et la plus largement compatible »

En somme, c’est un tableau de valeurs codées sur 8bits qui à chaque valeur associent un caractère. Ces caractères sont les lettres de l’alphabet en minuscule et majuscule, les chiffres, des caractères spéciaux et des symboles bizarres. Dans cette table, il y a plusieurs colonnes avec la valeur décimale, la valeur hexadécimale, la valeur binaire et la valeur octale parfois. Nous n’aurons pas besoin de tout ça, donc je vous donne une table ASCII « allégée ».

Voici une deuxième table avec les caractères et symboles affichés : Revenons à notre exemple, le nombre 65. C’est en effet grâce à la table ASCII que l’on sait passer d’un nombre à un caractère, car rappelons-le, dans l’ordinateur tout est traité sous forme de nombre en base 2 (binaire). Donc lorsque l’on code :

Si vous faites ensuite :

Au début, on trouvait une seule table ASCII, qui allait de 0 à 127 (codée sur 7bits) et représentait l’alphabet, les chiffres arabes et quelques signes de ponctuation. Depuis, de nombreuses tables dites « étendues » sont apparues et vont de 0 à 255 caractères (valeurs maximales codables sur un type char qui fait 8 bits).

Et que fait-on avec la fonction print() et cette table ?

Là est tout l’intérêt de la table, on peut envoyer des données, avec la fonction print(), de tous types ! En binaire, en hexadécimal, en octal et en décimal.

Vous pouvez donc manipuler les données que vous envoyez à travers la voie série ! C’est là qu’est l’avantage de cette fonction.

Exercice : Envoyer l’alphabet

Objectif

Nous allons maintenant faire un petit exercice, histoire de s’entraîner à envoyer des données. Le but, tout simple, est d’envoyer l’ensemble des lettres de l’alphabet de manière la plus intelligente possible, autrement dit, sans écrire 26 fois « print(); »… La fonction setup restera la même que celle vue précédemment. Un délai de 250 ms est attendu entre chaque envoi de lettre et un delay de 5 secondes est attendu entre l’envoi de deux alphabets.

Bon courage !

Correction

Bon j’espère que tout c’est bien passé et que vous n’avez pas joué au roi du copier/coller en me mettant 26 print…

Secret: Réponse SelectionnerAfficher
Si l’exercice vous a paru trop simple, vous pouvez essayer d’envoyer l’alphabet à l’envers, ou l’alphabet minuscule ET majuscule ET les chiffres de 0 à 9… Amusez-vous bien ! 😉

Recevoir des données

Cette fois, il s’agit de l’Arduino qui reçoit les données que nous, utilisateur, allons transmettre à travers le terminal série. Je vais prendre un exemple courant : une communication téléphonique. En règle générale, on dit « Hallo » pour dire à l’interlocuteur que l’on est prêt à écouter le message. Tant que la personne qui appelle n’a pas cette confirmation, elle ne dit rien (ou dans ce cas elle fait un monologue :mrgreen: ). Pareillement à cette conversion, l’objet Serial dispose d’une fonction pour « écouter » la voie série afin de savoir si oui ou non il y a une communication de données.

Réception de données

On m’a parlé ?

Pour vérifier si on a reçu des données, on va régulièrement interroger la carte pour lui demander si des données sont disponibles dans son buffer de réception. Un buffer est une zone mémoire permettant de stocker des données sur un cours instant. Dans notre situation, cette mémoire est dédiée à la réception sur la voie série. Il en existe un aussi pour l’envoi de donnée, qui met à la queue leu leu les données à envoyer et les envoie dès que possible. En résumé, un buffer est une sorte de salle d’attente pour les données. Je disais donc, nous allons régulièrement vérifier si des données sont arrivées. Pour cela, on utilise la fonction available() (de l’anglais « disponible ») de l’objet Serial. Cette fonction renvoie le nombre de caractères dans le buffer de réception de la voie série. Voici un exemple de traitement :

Cette fonction de l’objet Serial, available(), renvoie la valeur -1 quand il n’y a rien à lire sur le buffer de réception.

Lire les données reçues

Une fois que l’on sait qu’il y a des données, il faut aller les lire pour éventuellement en faire quelque chose. La lecture se fera tout simplement avec la fonction… read() ! Cette fonction renverra le premier caractère arrivé non traité (comme un supermarché traite la première personne arrivée dans la file d’attente de la caisse avant de passer au suivant). On accède donc caractère par caractère aux données reçues. Ce type de fonctionnement est appelé FIFO (First In First Out, premier arrivé, premier traité). Si jamais rien n’est à lire (personne dans la file d’attente), je le disais, la fonction renverra -1 pour le signaler.

Ce code est une façon simple de se passer de la fonction available().

Le serialEvent

Si vous voulez éviter de mettre le test de présence de données sur la voie série dans votre code, Arduino a rajouter une fonction qui s’exécute de manière régulière. Cette dernière se lance régulièrement avant chaque redémarrage de la loop. Ainsi, si vous n’avez pas besoin de traiter les données de la voie série à un moment précis, il vous suffit de rajouter cette fonction. Pour l’implémenter c’est très simple, il suffit de mettre du code dans une fonction nommé « serialEvent() » (attention à la casse) qui sera a rajouté en dehors du setup et du loop. Le reste du traitement de texte se fait normalement, avec Serial.read par exemple. Voici un exemple de squelette possible :

Exemple de code complet

Voici maintenant un exemple de code complet qui va aller lire les caractères présents dans le buffer de réception s’il y en a et les renvoyer tels quels à l’expéditeur (mécanisme d’écho).

Avouez que tout cela n’était pas bien difficile. Je vais donc en profiter pour prendre des vacances et vous laisser faire un exercice qui demande un peu de réflexion. 😈

[Exercice] Attention à la casse !

Consigne

Le but de cet exercice est très simple. L’utilisateur saisit un caractère à partir de l’ordinateur et si ce caractère est minuscule, il est renvoyé en majuscule ; s’il est majuscule il est renvoyé en minuscule. Enfin, si le caractère n’est pas une lettre on se contente de le renvoyer normalement, tel qu’il est. Voilà le résultat de mon programme :

Correction

Je suppose que grâce au superbe tutoriel qui précède vous avez déjà fini sans problème, n’est-ce pas ? 😛

La fonction setup() et les variables utiles

Une fois n’est pas coutume, on va commencer par énumérer les variables utiles et le contenu de la fonction setup(). Pour ce qui est des variables globales, on n’en retrouve qu’une seule, « carlu ». Cette variable de type int sert à stocker le caractère lu sur le buffer de la carte Arduino. Puis on démarre une nouvelle voie série à 9600bauds :

Secret: Réponse SelectionnerAfficher

Le programme

Le programme principal n’est pas très difficile non plus. Il va se faire en trois temps.

  • Tout d’abord, on boucle jusqu’à recevoir un caractère sur la voie série
  • Lorsqu’on a reçu un caractère, on regarde si c’est une lettre
  • Si c’est une lettre, on renvoie son acolyte majuscule ; sinon on renvoie simplement le caractère lu

Voici le programme décrivant ce comportement :

Secret: Réponse SelectionnerAfficher
Je vais maintenant vous expliquer les parties importantes de ce code. Comme vu dans le cours, la ligne 4 va nous servir à attendre un caractère sur la voie série. Tant qu’on ne reçoit rien, on ne fait rien ! Sitôt que l’on reçoit un caractère, on va chercher à savoir si c’est une lettre. Pour cela, on va faire deux tests. L’un est à la ligne 8 et l’autre à la ligne 13. Ils se présentent de la même façon : SI le caractère lu à une valeur supérieure ou égale à la lettre ‘a’ (ou ‘A’) ET inférieure ou égale à la lettre ‘z’ (‘Z’), alors on est en présence d’une lettre. Sinon, c’est autre chose, donc on se contente de passer au renvoi du caractère lu ligne 21. Une fois que l’on a détecté une lettre, on effectue quelques transformations afin de changer sa casse. Voici les explications à travers un exemple :

Description Opération (lettre) Opération (nombre) Valeur de carlu
On récupère la lettre ‘e’ e 101 ‘e’
On isole son numéro de lettre en lui enlevant la valeur de ‘a’ e-a 101-97 4
On ajoute ce nombre à la lettre ‘A’ A + (e-a) 65 + (101-97) = 69 ‘E’
Il ne suffit plus qu’à retourner cette lettre ‘E’ 69 E

On effectuera sensiblement les mêmes opérations lors du passage de majuscule à minuscule.

A la ligne 19, j’utilise la fonction write() qui envoie le caractère en tant que variable de type byte, signifiant que l’on renvoie l’information sous la forme d’un seul octet. Sinon Arduino enverrait le caractère en tant que ‘int’, ce qui donnerait des problèmes lors de l’affichage.

Vous savez maintenant lire et écrire sur la voie série de l’Arduino ! Grâce à cette nouvelle corde à votre arc, vous allez pouvoir ajouter une touche d’interactivité supplémentaire à vos programmes.

66 commentaires

  1. Salut
    je n’ai pas compris pour il faut utiliser write() à la place de print(). Par ailleurs pourquoi ne pas remplacer
    « carlu = carlu – ‘a’;
    carlu = carlu + ‘A’; »
    par « carlu +=32; »
    j’imagine qu’il y a une raison derrière cette méthode
    Merci

    • Il y a une réponse : Clarté pour un utilisateur plus novice 🙂 . En effet ta méthode marche très bien aussi bien sur, mais est plus obscure (mais encore une fois, le résultat serait exactement le même, dans un but d’efficacité elle serait même encouragée).
      On aurait aussi pu ecrire : carlu = carlu-'a'+'A'; 😀 (le compilateur aurait alors fait l’optimisation carlu = carlu+32;

  2. Salut,
    J’ai réaliser un petit programme de test qui envoie des données sur une voie série.
    Le programme Arduino reçoit ces données.

    J’aimerais savoir si c’est possible de simuler la réception de données avec ISIS Proteus à partir d’un programme externe ?

    Pour l’instant je simule tout, parce que j’ai pas les moyens d’acheter les matériels. :/

    • Je n’en ai malheureusement pas la moindre idée. Je n’ai pas utilisé Proteus depuis longtemps (Arduino était juste en train de naître) et du coup je ne pourrais pas t’apporter de réponses à ce sujet. J’émet un doute sur la possibilité de cette opération cependant.

  3. Bonjour,

    J’ai un problème, mon ordinateur (windows vista) ne reconnait plus ma carte Arduino Uno. Voici le message d’erreur de Windows lorsque je connecte la carte à mon ordi :

    [img]http://www.calculatriceconvertisseur.vv.si/erreur.png[/img]

    Et voici l’erreur que le logiciel Arduino m’affiche :

    [code] This report would have more information with
    « Show verbose output during compilation »
    enabled in File > Preferences.
    Arduino: 1.0.6 (Windows Vista), Board: « Arduino Uno »
    Taille binaire du croquis : 1 912 octets (d’un max de 32 256 octets)

    processing.app.SerialNotFoundException: Port série « COM3 » non trouvé. L’avez-vous bien sélectionné dans le menu Outils > Port série ?

    at processing.app.Serial.(Serial.java:191)

    at processing.app.Serial.(Serial.java:77)

    at processing.app.debug.Uploader.flushSerialBuffer(Uploader.java:77)

    at processing.app.debug.AvrdudeUploader.uploadViaBootloader(AvrdudeUploader.java:175)

    at processing.app.debug.AvrdudeUploader.uploadUsingPreferences(AvrdudeUploader.java:67)

    at processing.app.Sketch.upload(Sketch.java:1666)

    at processing.app.Sketch.exportApplet(Sketch.java:1622)

    at processing.app.Sketch.exportApplet(Sketch.java:1594)

    at processing.app.Editor$DefaultExportHandler.run(Editor.java:2382)

    at java.lang.Thread.run(Thread.java:619)[/code]

    Je pense que le problème vient peut-être que hier, j’ai débranché la carte de l’ordinateur alors qu’elle utilisait la liaison série.

    J’espère vraiment que vous pourrez m’aider…

    Merci d’avance,

    Au revoir

    • Hum… je ne suis pas trop familier de Windows Vista (et windows en general)… Debrancher la carte quand la voie serie est en marche ne devrait pas abimer quoi que ce soit. Au pire le port série restera occupé tant que le PC ne sera pas redémarrer, mais dans ce cas la carte devrait se reconnecter sur un autre port-série… Est-ce qu’un autre port peut-etre vu dans l’interface Arduino ?

      Une dernière piste de résolution (plus drastique) pourrait surement être de re-installer le driver Arduino dans l’interface de gestion des périphériques.

  4. Vraiment genial tes cours’ tu fait parti bienféteur du l’humanité cinserment. Tu donne ton temps gratuiement pour nous tous d’un grand interré. Voila j’ai volue faire une chaine de caractere ;
    char int* info1= »munérot du servo moteur;  » ;
    Int mumerot;

    Dans le void loop
    Print (info+munerot);

    Me donne aprés le lancement du programme.
    Unerot du servo moteur
    Il me manque le ‘m’ et la valeur’munerot

  5. Secret SelectionnerAfficher

    //voila essaye et dit moi quoi comme on dit en picardi.
    //a bientot…

  6. Bonjour. Encore merci pour tous ces tutos.

    Est-ce qu’il existe une fonction sur Arduino qui se rapproche de la fonction « printf » en langage C (dans lequel on peut mettre des « %d », %s », etc ?
    La fonction Serial.write envoie la variable sous forme d’un octet (type byte). Est-ce correct que cette fonction fait en interne une sorte de « cast » : serial.write(x) serial.print((byte)x) ??

    Merci encore.

    • En C on a le classique « printf » qui fait exactement cela pour afficher sur la sortie standard.
      Pour etre plus exact, la fonction print envoi une chaine de caractere, et fait dans sa tambouille interne en sorte que les variables soient bien inscrites dans la chaine.

  7. Bonjour,
    je suis novice autant en programmation qu’en électronique et même si parfois j’ai du mal a suivre je trouve vos tutos vraiment super
    j’ai un petit soucis avec l’affichage des caractères avec accent ( é, è, à,) et peut être d’autres ou sa affiche des truc bizarre sauf les caractères voulu. est-ce que je dois installer la table ASCII ou la déclarer quelque part là je ne comprend d’autant plus que sur votre vidéo vous les afficher correctement.
    merci de bien vouloir m’éclairer
    et merci encore pour tous vos cours

    • Je pense que ca dépend du système que tu utilises. Tu es sur Windows ? Sur Linux/Ubuntu je n’ai rien fait de particulier pour que cela fonctionne. Cependant, de manière générale les accents pour les systèmes embarques (comme Arduino) peuvent souvent être capricieux.

      • Bonjour,
        oui c’est assez bizarre je suis sous Windows 7 quand je tape le code :
        void setup()
        {
        Serial.begin(9600);
        Serial.print(« Salut les zéros »);
        Serial.println(« Vive Zozor ! »);
        Serial.println(« Cette phrase passe en dessous des deux précédentes »);
        }
        void loop()
        {
        }
        les (é) ne s’affiche pas et j’ai des A avec accent a la place
        et quand j’écris le code :
        void setup()
        {
        Serial.begin(9600);
        }
        void loop()
        {
        char carlu = 0;
        int cardispo = 0;
        cardispo = Serial.available();
        while(cardispo > 0)
        {
        carlu = Serial.read();
        Serial.print(carlu);
        cardispo = Serial.available();
        }
        }
        là bizarrement tout est OK
        y a t il une raison particulière ?

  8. Merci pour ce tuto Eskimon.
    Est ce que vous pouvez m’aider? je suis debutant, j’ai un petit projet que je souhaite realiser.
    l’idee c’est de pouvoir brancher un lecteur code a barre a un Arduino et je fait un scansur un code a barre, ce code doit etre afficher sur un ecran LCD et en meme temps doit etre afficher dans un textbox d’une application c# sur mon PC.
    Quand le code est affiche sur le textbox il doit etre generer automatiquement un action vers Arduino pour ouvrir une porte. je veux pas envoyer ce code en cliquant sur unn bouton, je veux qu’il soit envoye automatiquement.
    Si vous me donner une idee claire sur le mecanisme s’il vous plais. avec quel canal de communication je dois passer? et quel type de donnees je doit recevoir et envoyer? et est ce que Arduino doit etre programmee ailleur de mon application c# oubien tout se passe en temps reel entre mon c# et Arduino.
    Et merci beaucoup

  9. Salut Eskimon.

    Tout d’abord bravo et mille merci pour ce tutoriel plein de bonne pédagogie!

    Chez moi, il se passe un truc étrange avec Serial.print. Si je compile ce code:

    J’obtiens sur le moniteur série : 3.14159274101257324
    Et si je lui demande -par exemple- 12 chiffres après la virgule Serial.print(3.1415926535,12);
    , il me renvoie 3.141592741012

    Est-ce que tu aurais une idée d’où il me sort ce nombre (et surtout pourquoi ça ne correspond pas à celui que j’ai rentré?).

    Merci et encore bravo!

    Xavier.

      • Salut!

        En fait, dans le tutoriel, tu as donné les clés pour que je réponde tout seul à ma question (mais ta réponse m’a quand même bien aidé à la chercher au bon endroit).

        Dans les références du site d’Aduino, à la rubrique « float », ils disent que le degré de précision d’un nombre à virgule (de type float ou long, donc) est de 6 ou 7 chiffres, ce qui se vérifie bien dans mon exemple.

        Je sais donc désormais que si j’ai besoin d’avoir un résultat très précis, je dois plutôt me débrouiller pour faire le calcul avec des entiers.

        Merci beaucoup!

        Xavier.

  10. En tout cas on dirais je suis sur la voix de sortie de mon calvaire
    Bonjour ou bonsoir avant tout MR ou Mme (désolé je ne sais votre genre, mais je croix vous êtes ou tu es Mr)

    Merci pour ce tuto sauveur et j’espère, oui vous pouvez m’aider

    En fait je suis stagiaire débutant dans une société et je suis tombé sur une tâcher intéressant mais ça me complique ; il s’agit de commander un Robot basé sur une carte Arduino mega ADK avec 20 servomoteur par une interface graphique matlab GUI que je prépare déjà (via la communication série votre tuto est un bon exemple seulement sur Arduino IDE) et finalement faire cette fameuse commande via bluetooth sous une application à créée aussi encours.

    j’ai écrit déjà à mon mieux le code arduino mais je suis heurté à un problème de communication série sous l’interface graphique GUI de matlab 2014a avec le code manipulant les servo du robot. votre aide me soulagerais d’avant si pas me permettre d’arriver au bonheur car l’objectif serait atteint.
    je travail actuellement sous Win7
    merci

  11. Salut,
    J’ai un projet scolaire qui consiste à allumer des LEDs à distance à l’aide de boutons poussoir.
    Pour cela notre encadrant nous a demandé que lorsque l’on appuie sur notre bouton poussoir il est censé nous envoyer un mot de 2 octets sur le moniteur série.
    Le problème c’est que l’on arrive pas à afficher la valeur du bouton sur le moniteur lorsqu’il est appuyé.
    J’aurai besoin d’aide car ça fait 2 semaines que je suis bloqué dessus
    Merci d’avance.

  12. Bonjour,

    Au risque de répéter ce qui a déjà été dit, bravo pour les tuttos et surtout un grand merci !
    J’ai actuellement un étrange problème:
    En faisant l’exercice Envoyer l’alphabet, impossible d’obtenir des lettres. J’obtenait des nombres allant de 65 a 88. Au bout de quelques heure j’ai lâcher l’affaire et regardé la solution, qui en fait était quasiment la même chose que ce que j’avais fait.
    En faisant un copier coller de la solution, j’ai maintenant des nombres allant de 0 à 250 augmentant de 1 en 1 pour la première boucle de l’alphabet puis de 2 en 2 pour la deuxième boucle puis de 4 en 4 etc…
    Donc toujours pas de lettres. Si quelqu’un pouvait me dire pourquoi j’en serait ravi.
    Merci d’avance

  13. Bonjour,
    J’ai bien lu le tuto 104-arduino-302-envoyer-recevoir-des-données-voie-serie. Tout cela est parfaitement bien expliqué et je vous en remercie mais, je ne vois pas comment passer une chaîne de caractère baptisée message$ de mon programme en Just Basic (un Liberty Basic) dans le buffer de COM3 (arduino Uno).
    J’ai cru bien faire en ajoutant à mon programme JB les lignes de code suivantes :

    open « Com3 :9600,n,8,1,ds0,cs0,rs » for random as #2
    print #2, message$
    dataread$= input$(#2,7)
    print dataRead$

    mais rien ne se passe . En particulier j’escomptais trouver message$ dans le cadre supérieur du moniteur série mais celui ci reste vide.
    Il y a quelquechose qui cloche pouvez vous m’aider SVP
    merci
    François Fleury

  14. Bonjour ,
    Excusez moi, j’ai oublié de préciser que j’étais sous Windows 10 et compte tenu de toutes les recherches que j’ai effectué, j’ai l’impression que mon problème doit être lié à ce système d’exploitation. Une dll qui manque ?
    merci encore
    françois Fleury

  15. Bonjour.
    J’ai un programme qui me donne la position du soleil en fonction du temps. Je souhaiterais mettre ces valeurs dans un tableau excel pour traitement. Je ne sais comment procéder puis avoir des solutions?
    Cordialement!

    Aboubakar.

  16. Bonjour Eskimon,

    Un grand merci du fond du coeur pour tes TPS très bien expliqués !
    J’aimerais réaliser un programme relativement lourd sur une Arduino Mega. Je débute et j’ai donc décidé de diviser mon programme en plein de petits sous-programmes pour commencer.
    J’ai connecté un capteur reed à la pin A0 et au voltage 5V.
    J’ai réalisé le programme suivant :
    const int CV1 = A8;
    int EtatCV1;
    int LED = 13;
    void setup() {
    // put your setup code here, to run once:
    pinMode(CV1,INPUT);
    pinMode(LED,OUTPUT);
    Serial.begin(9600);
    }
    void loop() {
    // put your main code here, to run repeatedly:
    int EtatCV1=Serial.available();
    EtatCV1=analogRead(CV1);
    if (EtatCV1 !=0)
    {digitalWrite(LED,LOW);}
    else
    {digitalWrite(LED,HIGH);}
    }
    Cependant il ne fonctionne pas car j’ai beau passer des choses aimantées devant le capteur, la LED reliée à la pin 13 ne s’allume pas aux passages des choses aimantées. Sauriez-vous pourquoi? En vous remerciant infiniment

      • Je ne suis pas encore un spécialiste de l’ARDUINO, mais j’ai déjà utilisé des capteurs REED qui ne sont, pour moi, que des interrupteurs. Lorsqu’il est « ouvert », l’état est indéterminé et il faut penser à mettre une résistance de tirage au 0V. c’est du moins ce qu’il faudrait faire si tu utilisais une entrée digitale. N’y a t il pas le même problème avec une entrée analogique?

  17. Bonjour,
    Je débute sur ARDUINO. Du côté des E/S tout va bien, et le tutoriel sur le 595 m’a bien aidé (à quand un tutoriel sur le 165?).
    Par contre, je teste la fonction SERIAL. J’ai simplement recopié un exemple:

    void setup()
    {
    Serial.begin(9600);

    //l’objet exécute une première fonction
    Serial.print(« Salut les zéros ! « );
    //puis une deuxième fonction, différente cette fois-ci
    Serial.println(« Vive Zozor ! »);
    //et exécute à nouveau la même
    Serial.println(« Cette phrase passe en dessous des deux précédentes »);
    }

    et j’obtiens un message d’erreur lors de la compilation:

    « C:\DOCUME~1\JEAN-M~1\LOCALS~1\Temp\build6178799902270964151.tmp/core.a(main.cpp.o): In function main':
    C:\Program Files\Arduino\hardware\arduino\avr\cores\arduino/main.cpp:43: undefined reference to
    loop’
    collect2.exe: error: ld returned 1 exit status
    Erreur lors de la compilation. »

    Ou peut bien être le problème?

  18. bonjour
    j’envoie un message sur la console, pour afficher la valeur d’un compteur, et je voudrai reecrire la valeur a la meme place sans repasser a la ligne a chaque ecriture comment faire, j’ai toujour le saut de ligne meme si je n’utilise pas printn
    Merci pour votre aide

  19. Bonjour quelle est la meilleure solution pour éviter une réinitialisation du programme en ouvrant le terminal série ? si on veut seulement recevoir de la carte UNO des données sans pour autant réinitialiser le PRG ? (Je n’ai pas compris ce que l’on peut faire avec RESET EN et je voudrais éviter de mettre une capacité sur l’entrée RESET) Est ce qu’il y a une fonction logicielle qui permet d’éviter le reset donnée par la liaison série-USB ? Merci ! Est ce qu’il y a un terminal série sous ubuntu et sous Win qui évite cela ? Merci

  20. Bonjour à tous, je vous présente mon problème. Je ne suis pas une lumière en informatique et en programmation. J’aimerais vous demander comment reçevoir les données d’un panneau solaire sur une carte arduino et les envoyer sur un site internet que nous auront créé ( si vous avez des conseils pour programmer notre site n’hésitez pas). C’est dans le cadre de notre projet de Terminal pour le Bac STI2D SIN.

    Merci d’avance.

  21. Bonjour, j’te remercie pour tes cours si agréables à lire et très bien construits 🙂 J’ai une question à propos arduino, je travail sur mon projet de fin d’étude « simulateur d’un poste HT/MT », je veux réaliser un interface (HM) graphique en utilisant visual basic, et arduino, ce dernier qui va communiquer avec les relais de protection numérique par exemple (SEPAM 40) liaison série. DOnc je veux savoir comment je peux transferer les mesures depuis le relais vers l’arduino puis les afficher sur l’interface graphique en utilisant les ports (RX/TX?). Les mesusres sont ( Courant phase, tension, fréquence ect ) Je veux bien savoir si c’est faisable 🙂 et merci d’avance.

  22. Salut Eskimon !

    J’aurai besoin d’un petit coup de pouce pour un projet. Pour faire simple j’ai créer une application android pour domotisé mon chez moi, le principe est très simple, si je veux allumé la lumière l’application envoie par bluetooth un message texte « salonECLon », ou pour éteindre « salonECLoff ». Je reçois donc les infos via la liaison série de l’arduino que je viens lire pour traité les actions à faire selon ce que l’application à envoyé.
    Le problème est que je ne sais pas comment lire une chaine de caractère, je n’arrive pas à faire fonctionné tout ça correctement. Je dois utilisé char; String ? Voici un bout de code que j’utilise pour faire mes tests:

    char state;
    int led = 14;

    void setup() {

    Serial.begin(9600);
    pinMode (led, OUTPUT);
    }

    void loop() {

    if (Serial.available() )
    state = Serial.read();
    delay(30);

    if (state == « salonECLon »)
    {
    digitalWrite (led, HIGH);
    }
    if (state == »salonECLoff »)
    {
    digitalWrite (led, LOW);
    }
    }

    Voilà j’attends un petit coup de main du seigneur de l’arduino. A+

  23. Salut,
    Je rencontre un petit problème sur l’afficheur série.. J’utilise la même technique que tous le monde et pourtant aucun résultat cohérent.
    Avec les lignes :
    Serial.begin(9600);
    Serial.println(« Hello »);
    J’obtiens sur le port série :
    « fžàžàžþžæ€˜€€˜ »
    Avez vous une solution ?
    Cimer !

  24. salut eskimon, j’ai un petit problème et je n’arrive pas a le résoudre. Mon problème est que je veux, en mettant le chiffre 1 dans le moniteur série que la carte me réponde en me renvoyant le 1.
    Voici le programme:
    // ========================================================================
    // inclusion des librairie et des fichier headers
    // ========================================================================

    #include

    unsigned long absoluteTime = 0; // reference de temps absolue, initialise par setup

    // ========================================================================
    // displayMsg (String myMsg)
    // ========================================================================
    void displayMsg (String myMsg) {

    // cette fonction affiche les message en fonction de la définition de Console, LCD, 3DR, etc ..
    float timeStamp;

    // rajoute un horodatage
    timeStamp = millis() – absoluteTime;
    timeStamp = timeStamp / 1000 ; // conversion en secondes
    myMsg = String(timeStamp) + « –  » + myMsg;
    Serial.println (myMsg); // affichage sur la console serie de l’IDE

    } // end displayMsg

    // ========================================================================
    // fonction Setup
    // ========================================================================

    void setup(void) {

    displayMsg (« Initialisation Serials ….. »);
    Serial.begin(9600); // initilisation de la ligne serie RX1 TX1
    displayMsg (« Initialisation terminee …… « );
    }

    // ========================================================================
    // fonction Loop
    // ========================================================================

    void loop(void) {

    if (Serial.available() > 0) {
    int inByte = Serial.read();

    switch (inByte) {
    case ‘1’ : // reception de la valeur 1
    displayMsg (« Valeur recue : » + String(inByte) +  » . »);
    break;

    default:
    displayMsg (« Sequence non reconue :  » + String(inByte));
    } // end switch
    } // end read serial1

    delay(200); //temporisation pour ne pas boucler trop vite

    } // end loop

  25. Pingback: Sources : Arduino » MyWorld

Laisser un commentaire