Les premiers pas de Daryl et Speed controler Pololu Trex DMC01

Un grand pas pour moi, des petits tours de roue pour Daryl!

J’ai reçu hier le speed controler Pololu TRex DMC01, ainsi que le micro maestro (servo controler).

Pour rappel, ces contrôleurs permettent :

• d’alimenter les moteurs via une alimentation externe (batterie)
• de supporter les pics d’intensité que ne pourrait pas prendre en charge l’arduino (les pins peuvent couvrir une intensité de 50mA max si je ne raconte pas de bêtises)
• de contrôler finement la vitesse des moteurs en les régulant

Le contrôleur Pololu TRex DMC01 permet de contrôler 2 canaux bidirectionnels et un auxiliaire unidirectionnel. Il accepte une tension d’entrée située entre 6 et 16V donc parfait pour mes moteurs de 12V. De plus, il peut gérer des pics d’intensité allant jusqu’à 13A. Je suis donc large sachant qu’un moteur peut atteindre (à rotor bloqué) 1.5A max. Comme j’ai choisi de connecter les moteurs en parallèle, je pourrais donc, théoriquement, obtenir des pics de 1.5+1.5 = 3A max, ce qui est donc largement en deçà des 13A autorisés.

Il est possible de contrôler les moteurs via trois interfaces de contrôle différentes: R/C, voltage analogique et serial. Dans mon cas, j’ai choisi le mode serial car il permet de contrôler les moteurs avec uniquement 2 pins.

Ce contrôleur est également parsemé de petites leds cms indiquant, pour chaque canal, si le moteur est en marche avant ou arrière, la réception de données sur le port série ou bien encore l’init/marche/arrêt du contrôleur lui-même.

Procédure:

Après avoir jeté un œil à la doc, je retire l’ensemble des jumpers (qui ne servent pas dans mon cas et que j’ai par ailleurs réutilisés pour le sensor shield), je branche les moteurs gauche en parallèle sur le canal1 et les moteurs droit en parallèle sur le canal2. Je branche la pin4 de l’arduino à la SI du TRex, pin5 de l’arduino à la pin SO du Trex et la pin GND de l’arduino à la pin GND du TRex. Pour finir, je connecte un petit bloc de piles 9.6V aux bornes VIN et GND du TRex. Et c’est tout! Simple Non?

Concernant la programmation, j’utilise la librairie arduino SerialSoftware qui permet de transformer deux pins classiques en pins serial. Pourquoi? Tout simplement parce que j’utilise déjà le port serial uart pour la communication entre le viliv (et donc le programme Java) et l’arduino.

Après un peu de travail, Daryl fait ses premiers pas (c’était la séquence émotion lol)

Vous constaterez dans la vidéo que Daryl n’est pas très rapide. C’est normal, il ne s’agit pas de sa vitesse maximum. En effet, mon bloc batterie provisoire ne fait que 9.6V. On peut donc dire que Daryl est amputé de 25% de sa vitesse nominale.

Les photos:

La vidéo: Un rapide sketch qui fait décélérer Daryl puis marche arrière en accélération.

Sur pastebin -> http://pastebin.com/vzx3ttHv

Publicités

Lynxmotion Terminator et best practices sur le câblage des moteurs

Hello!

Bonne nouvelle. Je viens de recevoir le châssis Lynxmotion Terminator et la plaque de Lexan supplémentaire. Comme je l’avais anticipé, le Terminator d’origine est trop petit pour accueillir tous les éléments de mon projet. C’est pourquoi j’ai acheté une plaque de Lexan supplémentaire afin de réaliser un étage intermédiaire entre la plaque à la base que l’on peut voir, et la petite plaque du dessus. L’étage intermédiaire devrait reprendre la même forme et mesure (un poil plus grand) que la plaque de la base. J’attends d’avoir l’ensemble des éléments de mon robot afin de bien choisir les mesures et la disposition. Aussi, la petite plaque du dessus devrait subir une rotation de 90° (dans le sens de la longueur donc) afin de pouvoir poser le viliv qui fait exactement la même taille (on ne pouvait pas faire mieux!)

La finition est très bonne et le lexan protégé grâce à des feuilles autocollantes (on peut d’ailleurs voir les brûlures laissées par la découpe laser). Sur le site de Lynxmotion, on peut trouver un tutorial pour matifier le Lexan. En effet, brillant (et donc sensible aux micro rayures) à l’origine, le Lexan peut être poncé avec du papier très fin afin de le rendre mat. Je pense apporter cette modification à Daryl.

Le châssis est très solide et est facile à monter. Il est livré avec 4 moteurs GHM-02 12V réduction 50:1 et 4 petits condensateurs ceramic de 0.1uF 50V antiparasitage.

Pas de fils fournis avec les moteurs, ce qui est juste scandaleux vis à vis du prix de châssis!

Les photos:

L’atelier 😉 On peut voir la plaque de Lexan supplémentaire en haut à gauche.

[BEST PRACTICES] Le câblage des moteurs.

Comme indiqué plus haut, pas de fils fournis avec les moteurs. J’ai donc acheté 4 kits de fils avec cosse. Par ailleurs, j’ai acheté 12 condensateurs ceramic de 0.1uF 50V chez E44 afin de limiter les parasites générés par les moteurs. Les parasites peuvent être réellement handicapants pour un projet robotique. En effet, ils générent des « interférences » vis à vis des flux électriques annexes comme les données digitales et analogiques transitant via les fils de l’arduino.

Les best pratices liés à la motorisation d’un robot sont les suivants:

• Mettre en place un « triangle » de condensateur sur chaque moteur: Pour cela on va souder, 1 condensateur relié à la cage du moteur (ou masse) et à la borne -. 1 condensateur relié à la cage du moteur (ou masse) et à la borne +. 1 condensateur relié à la borne + et à la borne -.

Astuce: Pour une bonne soudure sur la cage du moteur, on gratte un peu la cage avec un tournevis ou un papier de verre afin de créer des aspérités.

Je soude:

Je coupe les pattes qui dépassent puis je plug les cosses (perso j’ai ajouté un point d’étain sur les cosses afin de les fixer):

• Une autre bonne pratique consiste à vriller les deux fils du moteur afin de réduire les parasites. Il est recommandé de réduire la longueur des fils au maximum. Voila ce que ça donne au final:

• La dernière bonne pratique consiste à tenir à l’écart les fils des moteurs le plus loin possible des fils où transitent les « informations »

Voili voilo. Je vais pouvoir tester la partie motrice désormais.

@++

Ecran LCD Sainsmart 20×4 et Sensor Shield V4

Bonjours à tous,

Je viens de recevoir deux éléments de Daryl:

– L’écran LCD Sainsmart LCD2004 20×4: Cet écran LCD permet l’affichage de 20 caractères sur 4 lignes. Il dispose d’un rétroéclairage à leds bleues qui est activable/désactivable grâce à un petit jumper situé sur l’arrière du LCD. On le trouve facilement sur le site de Sainsmart http://www.sainsmart.com/ ou sur Ebay pour une vingtaine d’euros. L’atout de ce LCD est qu’il ne faut que 2 fils pour le piloter (contrairement aux autres LCD qui nécessitent parfois jusqu’à 8 pins!). Il utilise le port I2C de l’arduino (les pins A4 et A5 pour l’arduino Uno) qui permet de piloter plusieurs modules avec deux pins seulement, et ce, grâce à un système d’adressage. Pour info, le contraste du LCD est réglable grâce à un potar situé à l’arrière. Sainsmart met à disposition une librairie et un code exemple qui sont malheureusement dépassés.

1. La librairie est obsolète, car codée pour une ancienne version de l’arduino IDE. Si vous utilisez la librairie sainsmart avec arduino IDE 1.0.1 vous obtiendrez une erreur de compilation. En cherchant quelques heures un peu, j’ai trouvé une librairie nommée NewLiquidCristal qui fonctionne parfaitement avec ce LCD. La librairie met à disposition un ensemble de fonctions permettant le scrolling, l’affichage par la gauche/droite, l’effacement… Elle est téléchargeable ici: https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/Home
2. L’adresse indiquée dans l’exemple n’est pas correcte! En effet, l’exemple et la fiche produit semblent indiquer que le LCD est pilotable via l’adresse 0x3F. Or, en utilisant un petit sketch arduino permettant de scanner les éléments connectés au port I2C, et donc de récupérer leur adresse,  je me suis rendu compte que l’adresse du LCD était 0x27!

J’ai posté le code exemple pour le LCD sur pastebin: http://pastebin.com/31PmDQ9d

J’ai posté le code du scanner I2C sur pastebin: http://pastebin.com/HnFjmmnq

Les photos:

La vidéo:

– Le Sensor Shield v4: Ce shield qui vient se poser sur l’arduino uno, permet de faciliter les connections vers les  modules ou capteurs. En effet, dés que l’on souhaite connecter plusieurs connecteurs, il faut à minima une plaque d’essai pour repiquer soit le +5V soit le ground. Le sensor shield met à disposition 6 connecteurs et/ou 22 entrées/sorties avec, à chaque fois, ground/V+/signal. On peut donc directement connecter ses capteurs! De plus, on retrouve un connecteur I2C/COM que j’utilise bien évidement pour connecter le LCD sainsmart 20×4. Une led permet d’indiquer la bonne alimentation du sensor shield, et un bouton reset a été ajouté car celui de l’arduino uno n’est plus accessible. Petite précision, aucun jumper n’est fourni avec ce shield. Hors, il est nécessaire de positionner deux jumpers sur la carte pour lui indiquer que l’on veut utiliser le mode I2C pour le port I2C/com. On trouve ce shield sur différents sites. Pour ma part sur Ebay pour 8€.

Les photos:

@++

PS1: Désolé pour les pubs de merde youtube à 10s de la vidéo, je viens de désactiver le truc (et ce n’est pas rétroactif sur les vidéos déjà importées comme par hasard!)

PS2: Désolé pour la musique moisie dans la vidéo mais entre la country et le reste, youtube offre un choix totalement minable concernant les musiques…

Architecture matérielle de Daryl

Je travaille actuellement (de façon intensive) sur la validation de l’architecture matérielle de Daryl. En effet, rien ne doit être laissé au hasard. Combien de moteurs? Quel couple pour les moteurs sachant que Daryl pèsera probablement moins de 3 Kg? Comment contrôler ces moteurs ? Quel type de capteur pour éviter les obstacles ? Quel type de batterie pour mon projet ? Quelle puissance de batterie ? Autant de questions auxquelles il faut absolument répondre avant de commencer un projet. Après pas mal de recherches et de réflexions, je suis parti sur la solution illustrée par le diagramme ci-dessous (Rendez-vous plus bas pour les explications) :

1. Viliv S5 Premium: Cerveau de Daryl, le viliv S5 hébergera une application Java qui se chargera d’envoyer les commandes vers l’arduino via le port serial rx/tx (USB), mais aussi de recevoir les informations depuis l’arduino (capteurs). Je n’ai pas encore établi le degré d’implication du programme Java concernant l’envoi des commandes. En effet, est-ce que je laisse le viliv et donc l’application Java recevoir les données des capteurs puis traiter en envoyant des commandes à l’arduino pour faire fonctionner les moteurs OU est-ce que je laisse l’arduino traiter lui-même les informations provenant des capteurs et donc commander les moteurs. Dans ce cas, l’application Java n’aurait plus un rôle direct, mais indiquerait simplement à l’arduino: « bouge, arrête de bouger »… Je préfère la première solution, c’est à dire déporter au maximum la logique au sein de l’application Java, mais cela dépendra des temps de réponse entre l’arduino et l’application.
2. Hub USB: J’ai opté pour un micro hub USB qui me permettra de connecter, d’une part l’arduino, mais aussi la webcam. J’espère que ces deux éléments ne tireront pas trop sur le viliv. Même si celui-ci possède une excellente autonomie (5h-6h avec la luminosité au minimum), il ne faut pas oublier que l’application Java tournera en permanence, et par conséquent consommera de l’énergie.
3. Arduino Uno: Je ne présente plus ce petit micro contrôleur. Il sera connecté au viliv via USB et en mode serial rx/tx. L’arduino pilotera également le contrôleur motor Pololu Trex via un port serial. Il faut savoir que l’arduino possède 2 pins rx/tx pour la communication en mode serial. Cependant, comme j’utilise déjà le serial pour communiquer avec le viliv, je vais devoir utiliser une librairie arduino (SerialSoftware) qui permet de transformer deux pins classiques de l’arduino en pins serial.
4. Châssis Lynxmotion Terminator: J’ai choisi ce châssis car il est sympa, mais aussi parce qu’il est livré avec 4 moteurs 12V réduction 50:1 95 RPM. Vu sa petite taille, il est fort probable qu’intégrer l’ensemble des éléments sera difficile. C’est pourquoi j’ai prévu l’achat d’une petite plaque en lexan du même constructeur qui me permettra de construire un étage supplémentaire.
5. Webcam Microsoft Lifecam Cinema: Cette micro webcam sera positionnée sur le module tilt/pan sur l’avant du robot. La webcam me permettra par la suite d’agrémenter les fonctionnalités de Daryl (reconnaissance faciale, reconnaissance/suivi d’objets ou marqueurs, éviter les obstacles…). J’ai pris la version 720p pour ne pas trop charger le viliv en traitement d’image (la reconnaissance faciale par exemple est très consommatrice en ressource processeur). De plus les retours sur le web semblent indiquer que le micro est très bon (ce qui n’est pas négligeable pour la reconnaissance vocale). J’espère juste que le bruit des moteurs ne créera pas d’interférence avec le micro.
6. Batterie NiMH 12V 4000mAh : Pour la batterie, je me suis tourné vers le NiMH. Au départ j’étais parti sur du Lipo mais les contraintes liées au Lipo m’ont vite calmé (chargeur spécial, surveillance obligatoire pendant la charge, sac anti-feu lors de la charge pour les batteries grande capacité, fragilité…) Je suis donc parti sur du classique NiMH 12V (car les moteurs sont en 12V). De plus l’arduino peut prendre une tension d’entrée jusqu’à 12V ce qui sera parfait pour l’alimenter. Selon mes calculs, l’ensemble du robot devrait consommer 700mAh min à 1450 max à un instant T, et à charge nominale. Donc, en prenant la valeur maximum (ce qui sera peut probable) on arrive à 4000/1450 soit 2.85h de fonctionnement minimum.
7. Pololu Trex DMC01 contrôleur de vitesse pour moteur: L’arduino peut délivrer uniquement 50mA par pin. Or un moteur à lui seul peut tirer 270mA (à pleine charge et vitesse max) voir 1.5A en pic lorsque le rotor du moteur est bloqué (ok cela ne doit pas arriver car ça abimerait rapidement les moteurs). Si je connectais directement les moteurs sur l’arduino, les pins rendraient instantanément l’âme. De plus l’arduino ne peut délivrer que 5V max. C’est pour cela que je vais utiliser un contrôleur de vitesse pour moteur. J’ai choisi le Pololu DMC01 car il permet le contrôle de 2 canaux (moteurs gauche / moteurs droit que je branche en parallèle dans mon cas) + un moteur auxiliaire. Il peut encaisser des pics de 13A (donc je suis large car 1.5*2 = 3A max dans mon cas). Il peut prendre une tension d’entrée située entre 6-16V, donc adapté à mes moteurs / batterie 12V. Aussi, il permet les modes de communication suivants: RC/analog/serial. Le mode qui m’intéresse est le mode serial. Il permet de piloter les deux canaux via 2 fils seulement (RX/TX). Comme évoqué plus haut, j’utliserais la librairie SerialSoftware qui permet d’émuler un port série grâce à deux pins classiques de l’arduino.
8. Moteurs: Les quatre moteurs sont livrés avec le châssis Lynxmotion. Il s’agit de moteurs 12V avec réduction de 50:1, donc relativement puissants (développe 1.14Kg-cm). Ces moteurs seront largement suffisants compte tenu du poids de Daryl (évalué entre 2kg et 2.4kg max)
9. Contrôleur servo moteur: Tout comme les moteurs, les servos moteur peuvent requérir de grande quantité d’énergie. Il est donc nécessaire d’utiliser un contrôleur alimenté en externe. J’ai choisi le micro maestro de Pololu. Il accepte une tension d’entrée située de entre 5 et 6V (tension classique des servos moteur 4,8V ou 6V) et permet de piloter 6 servos moteur. Les servos moteur permettront l’orientation de la tourelle tilt/pan. Tout comme le contrôleur moteur, le micro maestro sera piloté depuis l’arduino via SerialSoftware.
10. Module servo tilt/pan: Ce petit module permettra d’une part l’orientation de la webcam (gauche-droite / haut-bas) lors de face/object tracking par exemple, mais aussi la rotation du capteur Sharp central et du capteur ultrason Ping. En effet, lorsque Daryl rencontrera un mur, un des trois capteurs Sharp indiquera à Daryl la présence de l’obstacle. Le module pan réalisera dés lors un balayage ultrason et IR afin de « scanner » l’environnement et indiquer à Daryl ou se rendre.
11. Capteur de distance Infrarouge Sharp: Ces capteurs IR seront placés sur la partie avant droite / gauche et au centre du robot. Ils permettront à Daryl d’éviter des petits obstacles (entre 4 et 30 cm de distance). Ces capteurs analogiques renvoient une valeur dépendante de la distance entre l’obstacle et le capteur lui-même. Ce type de capteur existe en version 10-80 / 30-150… J’ai choisi une détection de 4-30 car Daryl sera relativement petit (25 cm sur 25 approximativement). De plus les capteurs grande distance semblent moins précis.
12. Ecran LCD Sainsmart 4 lignes LCD2004: J’ai prévu l’installation d’un petit écran LCD 20*4 qui permettra l’affichage de données importantes (ou debug). J’ai choisi cet écran car il utilise seulement 2 fils! En effet, il utilise le BUS I2C (ou IIC) de l’arduino (sur les pins A4 et A5). De plus il est possible d’utiliser plusieurs éléments sur le bus I2C grâce à un système d’adresse.
13. Capteur de distance ultrasonique Parallax Ping ))): Ce capteur ultrason viendra en complément des capteurs IR Sharp. Basé sur le système des ultrasons (comme les chauves souris), ce capteur envoi des ondes sonores puis calcule le temps écoulé entre l’émission et le retour. Les types de capteur IR et ultrason sont vraiment complémentaires dans le sens où l’un comble souvent les lacunes de l’autre. Les capteurs IR ont un champ de détection très fin contrairement aux capteurs ultrason qui ont un cône de détection relativement élevé. Les capteurs IR sont sensibles à la lumière et à la couleur des surfaces, ce qui n’est pas le cas des capteurs ultrasons. A contrario, ces derniers sont sensibles à la pression/température et aux échos parasites… Le capteur ultrason Ping de Parallax permet la détection d’obstacles situés entre 2cm et 3m dans un cône relativement restreint 20° max (plus le cône de détection est fin, meilleur sera la détection).
14. Sensor shield pour arduino: J’ai prévu l’adjonction d’un petit sensor shield à l’arduino. Ce shield vient se poser directement sur l’arduino et permet d’accéder directement à des connexions pour capteurs. NB: les pins de l’arduino sont toujours accéssibles et un bouton reset est toujours disponible.

Voila pour l’architecture. J’ai déjà commandé prioritairement certains éléments (Pololu Trex et Servo, châssis Lynxmotion Terminator, sensor shield et écran LCD). Les éléments tels que la batterie et les capteurs suivront très vite car importants dans l’architecture. Les éléments restants tels que la webcam et le module PAN viendront un peu plus tard car beaucoup moins importants pour l’instant. Je pense qu’il va se passer quelques semaines entre la réception de tous les éléments et leur intégration. Mais ne vous inquiétez pas je vous tiendrai au courant… En attendant, je fais un peu de veille sur la reconnaissance / tracking d’objet avec la webcam et sur la reconnaissance faciale. Je commence aussi à réfléchir à l’architecture logiciel Java (Thread, séparation commandes…)

@+ Christophe

Sondage du mois [EDITION 1]

Un petit sondage pour faire vivre un peu le blog:

Récupération des données GPS depuis le viliv S5 et port COM

Comme évoqué dans un article précédent, le viliv S5 est équipé d’une puce GPS Sirf Star3. J’ai donc voulu voir ce que la bête avait dans le ventre, en ayant en tête une future commande du genre « Quel temps fera t-il demain Daryl? » et bim Daryl va voir sur le net la météo concernant la ville où il se trouve…

J’ai donc cherché a little sur le net et… le GPS peut être directement attaqué sur son port COM… Cela ne vous rappelle pas quelque chose?

J’ai donc réutilisé l’API RXTX:

1. On récupère le port en question
2. On se connecte
3. On lit la stream de données

Constatations:

On récupère un beau charabia du genre:

$GPRMC,101836.000,A,4825.1856,N,00956.8032,E,0.23,226.38,230710,,*07

$GPVTG,226.38,T,,M,0.23,N,0.4,K*68

$GPGGA,101837.000,4825.1857,N,00956.8023,E,1,04,1.4,567.4,M,48.0,M,,0000*5E

$GPGSA,A,3,17,05,08,18,,,,,,,,,8.6,1.4,8.5*36

$GPRMC,101837.000,A,4825.1857,N,00956.8023,E,0.57,292.18,230710,,*0

Seule la ligne GPGGA nous intéresse. En effet elle contient les données GPS. En faisant une petite recherche sur le net, on apprend que le flux est défini selon la norme NME 0183, soit:

• Current time in UTC
• Latitude and identifier N or S
• Longitude and identifier E or W
• Quality of measurement (0 == invalid, 1 == valid GPS, 2 == valid DGPS)
• Horizontal Dilution of Precision
• Height above sea level, with unit
• Height over geoid, minus height over ellipsoid, with unit
• Checksum

Dans mon code Java, je filtre donc sur les lignes GPGGA, je split sur « , » et dans un premier temps je récupère la 6ième valeur (0 si pas de fix GPS, 1 si fix satellite OK)

Ensuite, si on a un fix, on découpe le reste pour faire ressortir:

1. la latitude
2. la lat direction Nord ou Sud
3. la longitude
4. la long direction Est ou Ouest

Bon à savoir: les latitudes et longitudes ne sont pas directement exploitables, elles sont au format 4825.1857 or la plupart des applications utilisent le format du style 48° 25.1857′

Pour cela j’ai récupéré une petite class qui prend en entrée toute la ligne GPGGA et renvoie des informations bien formatées.

Bon, le résultat sur le viliv S5 est un peu décevant car il y a un petit blackout entre le moment où l’on se connecte au port, et le moment où l’on obtient les 1ères données (1min approx), du coup on ne sait pas trop ce que fait le programme. De plus la réception du viliv S5 n’est pas extraordinaire en intérieur. Je peine à fixer les satellites à 1m de la fenêtre. Quand je vois cela, je me dis que le GPS de l’iphone est vraiment pas mal…

Code java ici: http://pastebin.com/91weXXNb

Class format NMEA ici: http://pastebin.com/D1wk0Drk

Une petite photo du résultat (j’ai effacé quelques données… Catch me if you want…):

Interface entre PC et Arduino, via le port série et grâce à l’API Java RXTX

Je viens d’effectuer une avancée majeure dans mon projet: La réalisation de l’interface permettant la communication entre le PC (le viliv S5 dans mon cas) et l’arduino, via le port série (USB).

En effet, comme évoqué dans le billet listant mes objectifs et contraintes, je me suis donné pour but de développer Daryl avec mon langage de prédilection, c’est-à-dire Java. Or l’arduino n’est pas directement programmable en Java, mais en C/C++ uniquement.

Je me suis donc orienté vers l’architecture suivante: Intelligence de Daryl côté PC via une application Java, partie gestion des moteurs et senseurs côté arduino.

Après pas mal de recherche, j’ai constaté qu’il était possible de faire communiquer le PC et l’arduino via le port série (USB), et donc d’envoyer ou recevoir des données depuis l’arduino (afin de récupérer les données des senseurs et/ou de donner des ordres aux moteurs).

J’ai trouvé une API Java rxtx (http://rxtx.qbang.org/wiki/index.php/Main_Page) permettant d’établir une connexion avec le port COM série de l’arduino puis la communication avec celui-ci en envoyant/recevant des données. On trouve facilement des exemples simples sur le net expliquant comment envoyer/recevoir des données au travers du port série.
Par exemple, je peux envoyer TOTO côté PC et je constate que j’ai bien reçu TOTO côté arduino. Les exemples sont sympas mais ils n’expliquent pas comment dire à l’arduino « donne la valeur 255 pour la pin de la LED ». Je pourrais envoyer PINLED255, mais comment lire cette information dans un flot de données constant?! Et bien c’est là tout le problème! De plus, sur ce point, il n’y a plus rien en terme exemple sur net!

J’ai donc conçu un système d’identification des trames permettant une lecture du flot de données de manière à pouvoir l’interpréter par la suite. J’ai mis en place ce système côté montant comme descendant (PC et arduino).

Exemple: Si je veux allumer ma LED côté arduino (donc valeur 255) alors j’écris les caractères suivants sous forme de bytes au travers du flux ~L0255$

L’arduino étant en écoute sur le port série, il va donc dépiler la stream byte par byte et par conséquent:

1. Si l’arduino constate l’arrivée du flag ~ , alors il sait qu’une nouvelle donnée interprétable va arriver. On enregistre donc les prochains bytes dans un tableau.
2. Lorsque l’arduino constate l’arrivée du flag $ , alors il sait que la donnée est complète… et interprétable.
3. On va donc récupérer le flag de la commande à exécuter (ici L pour… LED) et reconstituer sa valeur (en effet à ce moment précis, elle est encore sous forme de CHAR).

Donc pour résumer: on lit séquentiellement le flux et on interpréte les données grâce aux flags de début (~) et de fin ($).

On fait strictement la même manipulation côté PC pour recevoir les données de l’arduino 😉

Voili voilo, je ne vous cache pas que je me suis arraché les cheveux quelques soirées (couché à 6h du mat) sur ce point.

Comme vous pourrez le voir dans la vidéo, j’ai pu:

1. Allumer/éteindre une LED (~L0000$ ou ~L0255$)
2. Récupérer la valeur d’un potentiomètre côté interface (~P0000$ à ~P1023$)
3. Envoyer à l’arduino la valeur angulaire pour le servo moteur (~S0000$ à ~S0180$)
4. Obtenir un niveau de réponse excellent
5. Exécuter cet exploit depuis le viliv S5

NB: Vous pourrez constater sur l’interface, les deux panels affichant le flot de données (input) en provenance de l’arduino, et le flot de données (output) envoyé vers l’arduino.

Côté Java les sources sont organisées de cette manière:

1. Partie interface NB: j’ai utilisé JGLOO (http://www.cloudgarden.com/jigloo/) de Cloudgarden pour la réaliser facilement: http://pastebin.com/BFqbwPF3
2. Partie communication RXTX port série (lecture des trames et écriture): http://pastebin.com/4WfeNrZf
3. Partie interprétation des données: http://pastebin.com/WtfX2fhz
4. Code arduino: http://pastebin.com/pZxptAkF

La vidéo: