LIFA signifie LabVIEW Interface For Arduino. C’est une extension de LabVIEW (compatible à partir de la version 2009) qui permet de piloter une carte compatible Arduino depuis LabVIEW. Dans cet article je vous propose d’installer et de découvrir LIFA car pour l’instant je n’ai pas trouvé beaucoup de ressources sur Internet à ce sujet. Attention cet article n’est pas une présentation de LabVIEW ou d’Arduino (vous avez plein de ressources pour cela sur le web) mais une utilisation conjointe de LabVIEW et Arduino. Cependant les VI (Virtual Instrument) de tests sont très simples et il n’y a PAS de programmation C/C++ du coté Arduino.
 Imprimer cet article

Matériels et logiciels nécessaire

Matériels :

• un ordinateur de type compatible PC avec Microsoft Windows7 ou WindowsXP (je n’ai pas testé sous GNU/Linux mais ça doit être fonctionnel)
• une carte compatible Arduino : dans notre cas une carte arduino UNO
• un shield de prototypage ou une plaquette d’essai sans soudure (http://www.lextronic.fr/P4130-kit-arduino-protoshield.html à 15€ par exemple)
• divers shields en fonction des utilisations avancées : ethershield, Xbee Shield, etc… (facultatif)
• quelques composants de bases (résistance, dels, …) et des capteurs (température, humidité aussi bien en I2C qu’en analogique)

Logiciels :

• L’environnement de développement d’arduino ( http://arduino.cc/en/Main/Software )
• NI LabVIEW (version d’évaluation disponible sur http://www.ni.com/trylabview/) avec les pilotes VISA qui gèrent la voie série ( http://joule.ni.com/nidu/cds/view/p/id/2251/lang/en )
• VI Packet Manager : logiciel qui gère l’installation des extensions de LabVIEW disponible sur le site d’un partenaire de National Instrument ( http://jki.net/vipm/download )
  
• Le paquet LIFA décrit sur https://decibel.ni.com/content/groups/labview-interface-for-arduino et son installation sur https://decibel.ni.com/content/docs/DOC-15971
• Le logiciel Fritzing pour dessiner les schémas de câblage ( http://fritzing.org/welcome/ )

Téléchargez le tout puis installez dans l’ordre ci-dessus. La plupart du temps ça se résume à « suivant », « suivant »,… »terminer ». La version de LIFA utilisée ici est 2.XX.

Installation du firmware LIFA sur la carte Arduino

Le firmware LIFA est disponible après installation dans le répertoire « C:\Program Files\National Instruments\LabVIEW 2011\vi.lib\LabVIEW Interface for Arduino\Firmware\LVIFA_Base » (du moins sur mon installation). Vous trouverez alors plusieurs fichiers dont les trois principaux sont :

• le sketch « LVIFA_Base.ino » : c’est ce sketch que vous compilerez et transfèrerez dans la platine Arduino
• le sketch « LabVIEWInterface.ino » : il contient l’implémentation de toutes les fonctions utilisées par LabVIEW pour dialoguer avec la carte Arduino
• le fichier d’inclusion « LabVIEWInterface.h » : ce fichier d’en-tête est particulièrement intéressant puisque c’est lui qui contient les « define » que vous pouvez modifier pour adapter LIFA. Trois « define » en particulier seront à modifier suivant vos projets :
  • DEFAULTBAUDRATE : la vitesse de transmission de la voie série. En effet LabVIEW communique avec la carte Arduino par une voie série, par défaut la vitesse est de 115200 bauds/s mais si vous utilisez une liaison série sans fil (XBee ou Bluetooth), il faudra sans doute baisser la vitesse de transmission pour fiabiliser le dialogue
  • COMMANDLENGHT : le nombre d’octets transmis en une seule fois par une commande LabVIEW. Par défaut cette valeur est à 15. Si c’est insuffisant pour votre projet il faut le changer ici et sur le diagramme LabVIEW
  • STEPPER_SUPPORT : permet ou non d’intégrer le support des moteurs pas à pas dans le firmware, cela permet de diminuer la taille du fichier hex
• Les autres fichiers sont pour la gestion des moteurs pas à pas.

Chargez donc « LVIFA_Base.ino » dans l’environnement Arduino, compilez-le puis programmez votre carte Arduino.

Vous disposez normalement maintenant d’une Arduino prête à fonctionner avec LabVIEW.

Remarque : L’extension « ino » est la nouvelle extension pour les « sketches » arduino depuis la version 1.00, avant l’extension était « pde ».

Premier exemple : Allumer une diode depuis LabVIEW et lire l’état d’une entrée

On commence toujours par une del 🙂 donc on échappe pas à la tradition ! Le câblage sur la plaquette d’essai peut se présenter de la manière suivante (le dessin est réalisé avec le logiciel Fritzing) :

Lancez LabVIEW, puis réalisez la face avant suivante:

Lorsque vous passez sur le diagramme, une nouvel palette dédié à Arduino doit apparaitre :

Réalisons le diagramme suivant:

Les applications LabVIEW utilisant LIFA sont toutes construites sur le même modèle:

1. Établir la connexion avec la platine Arduino à l’aide du sous VI « INIT ». Celui-ci dispose de nombreuses entrées pour le configurer. Je vous conseille de créer des constantes pour ces entrées afin d’observer les différents choix possibles. La création d’une constante se fait en cliquant avec le bouton droit sur une des entrées puis choisir « Créer », « Constante ». Si vous souhaitez modifier ces paramètres sur la face avant créez des indicateurs. Tout d’abord choisir le port COM qui a été créé lors de la première connexion de l’arduino (ici COM19). Choisir la vitesse, elle doit correspondre avec celle défini dans « LabVIEWInterface.h » (ici 115200 qui est la valeur par défaut), ensuite le choix de la carte Arduino (par défaut UNO). Les deux derniers paramètres sont laissés tels quels. En sortie vous obtenez la « ressource » initialisée (trait épais rose) qui sera utilisée par tous les sous VI arduino et de quoi gérer les erreurs (trait épais jaune).
2. Initialiser les E/S. Si vous utilisez des E/S numériques, utilisez le sous VI « Set Digital Pin Mode ». Il faut préciser alors la broche concernée ( ici 8 ) et son sens ( ici output : on pilote une del ).
3. Boucle infinie de gestion des évènements. Comme sur micro-controlleur vous avez une boucle infinie qui gère les évènements (on ne considère pas ici les interruptions). Cette boucle infinie est ici représentée par une boucle « while » (flèche épaisse grise qui reboucle sur elle-même). Pour arrêter cette boucle, créez un indicateur sur le terminal de répétition de la boucle (ici point rouge). On doit allumer la DEL en fonction de l’état de l’interrupteur à levier de la face avant (Commande DEL). On transforme tout d’abord l’information booléenne (true, false) en nombre (0,1) puis on envoie cette information à l’entrée du sous VI « Digital Write Pin ». La broche de sortie est bien sur toujours la 8. Si vous regardez bien le diagramme, un petit point rouge à l’entrée du VI « Digital Write Pin » est présent. Ce qui indique que les formats utilisés ne sont pas totalement compatibles (ici la conversion booléenne se fait vers un entier signé codée sur 16 bits, or le VI attend une valeur non signé sur 8 bits).
4. Fermeture de la connexion avec la carte Arduino à l’aide du sous VI « CLOSE ». On libère ainsi proprement la mémoire et le port COM. Éventuellement câblez un gestionnaire d’erreurs simple.

Testez votre programme, lors de la manipulation de l’interrupteur de la face avant la diode doit réagir en conséquence. Vous savez donc piloter en tout ou rien des sorties. A titre d’exercice, modifiez le câblage, la face avant et le diagramme pour lire et afficher l’état d’un interrupteur…..

La correction est donnée ci-dessous :

Le câblage :La face avant dans LabVIEW:Le diagramme :

Remarque: Le microcontrolleur Atmel présent sur la carte Arduino possède des résistance de pull-up interne activable individuellement. Vous pouvez donc vous passez de la résistance de 10K sur le schéma de câblage à condition de modifier le « sketch » de LIFA dans la fonction setup. Lire cet article : http://arduino.cc/fr/Main/ApprendreBrochesEntreeSortie

Remarque: Si vous avez plusieurs broches à initialiser en entrée ou en sortie, le faire dans une boucle sous LabVIEW.

Deuxième exemple : Lire une tension analogique

Nous allons lire la tension issu d’un capteur de température analogique (LM35 : datasheet ici) et l’afficher sous LabVIEW. Ce capteur donne 0V à 0°C et à une pente de +10mV/°C. Ce qui fait par exemple à 25°C : 250mV. La variation de tension n’est pas importante et nous choisissons de ne pas amplifier cette tension pour garder un schéma de câblage simple. Le convertisseur analogique numérique de l’Atmel est un 10bits. La plage de numérisation est de base entre 0V et +Vcc = 5V. Le quantum fait donc 5/2^10 = 4,88mV. On réalise le câblage suivant:

La face avant sous LabVIEW peut se présenter de la manière suivante:

Le diagramme se présente de la manière suivante :

Remarque : la sortie du sous VI « Analog Read Pin » donne une tension et pas un nombre compris entre 0 et 1023 !

Troisième exemple : Moteur CC commandé en sens et en vitesse

Nous allons utiliser un circuit intégré qui permet de piloter deux moteurs CC : le L293D (datasheet ici). Ce circuit est relativement facile à mettre en œuvre et comme nous allons piloter qu’un seul moteur cela simplifie encore l’ensemble. Notez qu’il existe des shields pour piloter des moteurs CC (par ex : http://www.lextronic.fr/P5073-platine-de-commande-de-moteurs-dc.html). La broche 1 (EN1) permet d’activer le premier pont en H, si l’on connecte cette broche à une broche de l’arduino qui fourni un signal MLI alors on pourra faire varier la vitesse du moteur. Les broches 2 (IN1) et 7 (IN2) permettent de fixer le sens de rotation du moteur ou encore de le freiner. Les broches 3 (OUT1) et 6 (OUT2) sont les broches de sorties de puissance vers le moteur. La broche 16 (VSS) reçoit une alimentation 5V issu de la carte arduino. La broche 8 (VS) est connecté au +9V d’une pile pour assurer l’alimentation en puissance du moteur. Enfin les broches 4,5,12, 13 sont reliées aux masses (GND de l’arduino et pôle négatif de la pile). On obtient donc le schéma de câblage suivant :

Les broches 7 et 8 de l’arduino devront donc être en mode « digital » pour piloter le sens du moteur, la broche 11 en mode MLI (remarque: seul les broches avec une tilde peuvent être mises en mode MLI matériel : 6 broches en tout sur une arduino UNO). Le sens de rotation du moteur suit le tableau suivant:

Enable 1 (EN1)	Input 1 (IN1)	Input 2 (IN 2)	Fonction
High	Low	High	Tourne dans le sens horaire
High	High	Low	tourne dans le sens trigonométrique
High	Low	Low	Stop
High	High	High	Stop
Low	Non applicable	Non applicable	Stop

La face avant de cette exemple sera très simple (un potentiomètre unique qui évolue de -100% à +100%, le signe permet de fixer le sens de rotation) :

Le programme LabVIEW peut se présenter de la manière suivante (la seule partie qui varie d’une capture à l’autre, c’est l’intérieur de la boite de test : Vrai et Faux :

Câblez et testez : le moteur doit varier en vitesse et en sens. A l’oscilloscope la fréquence de la MLI est de 400Hz. Cette fréquence n’est pas réglable par l’intermédiaire d’un VI.

Quatrième exemple : Capteur de température DS1621 sur bus I2C

Le DS1621 est un capteur de température relativement répandu (datasheet ici). Je ne vais pas détailler ici la documentation, on va juste préciser les commandes à envoyer au DS1621 pour l’initialiser et faire une lecture simple de température. La broche 1 est SDA, la 2 est SCL : signaux du bus I2C. La broche 3 (Tout) ne sera pas utilisée dans notre application. Les broches 7 (A0), 6 (A1) et 5 (A0) sont reliés à la masse pour fixer l’adresse I2C de ce capteur. La broche 4 est la masse et la broche 8 +Vcc (ici 5V).

La séquence d’initialisation est la suivante (broches A0, A1 et A2 reliées à la masse) :

1. Condition de départ (start)
2. Écrire 0x90 : on sélectionne le boitier à l’adresse A2A1A0 = 000 en écriture
3. Écrire 0xAC : on écrit dans le registre de configuration
4. Écrire 0x00 : conversion de température en continu
5. Condition d’arrêt (stop)
6. Attendre 20ms : écriture en eeprom de la configuration précédente
7. Condition de départ (start)
8. Écrire 0x90 : on sélectionne le boitier à l’adresse A2A1A0 = 000 en écriture
9. Écrire 0xEE : lancement de la conversion en continu de la température
10. Condition d’arrêt (stop)

La séquence suivante permet la lecture de la température :

1. Condition de départ (start)
2. Ecrire 0x90 : on sélectionne le boitier à l’adresse A2A1A0 = 000 en écriture
3. Ecrire 0xAA : demande de lecture de la dernière température échantillonnée
4. Condition de départ (restart)
5. Ecrire 0x91 : on sélectionne le boitier à l’adresse A2A1A0 = 000 en lecture
6. Lire les 8 bits de poids fort de la température
7. Lire les 8 bits de poids faible de la température et faire un NACK !!
8. Condition d’arrêt (stop)

Vous remarquez que ce n’est pas très simple mais on va essayer d’implémenter le tout en LabVIEW avec les fonctions Arduino. Suivant la version de la carte arduino UNO que vous possédez les broches SCL et SDA ne sont pas au même endroit (UNO Rev2 : A4=SDA, A5=SCL; UNO Rev3: deux broches dédiées sur un connecteur SCL et SDA). Au moment de rédiger ce tutoriel  je dispose d’une carte arduino UNO rev2, le schéma de câblage ci-dessous est donc adapté pour cette plate-forme :

La face avant sous LabVIEW se présente de la manière suivante :

Remarque : un indicateur permet de choisir l’adresse du capteur DS1621 sur le bus I2C. Sous l’intitulé « Données I2C » c’est en fait un indicateur sous forme de tableau, il permet de visualiser les données brutes lues sur le bus I2C.

Le diagramme peut se présenter de la manière suivante :

Cela mérite quelques explications !!! Tout d’abord j’ai triché…pour comprendre comment fonctionne les sous VI I2C j’ai regardé les signaux I2C issu de l’arduino sur un oscilloscope et je dois dire que ça m’a bien aidé ! Lecture du diagramme de gauche à droite:

1. Initialisation du bus I2C (TWI dans la terminologie arduino)
2. Initialisation du DS1621. Tout d’abord l’adresse du composant. L’adresse est sur 7 bits (bit de poids fort en premier), les 4 premiers sont fixes (1001 voir documentation), les 3 derniers sont fixés avec les broches A2A1A0. Dans notre cas A2A1A0=000 donc l’adresse du composant est 0b1001000 en binaire ou 0x48 en hexadécimal ou 72 en décimal. Vous avez donc l’explication de la valeur 72 sur la face avant. Ensuite il faut écrire les valeurs 0xAC (172) et 0x00 (0) : c’est le rôle du premier sous VI  « I2C Write ».
3. Suite de l’initialisation. Normalement il faut attendre une dizaine de ms mais comme la transmission des 15 octets de LabVIEW vers l’arduino prend du temps, on peut considérer que la temporisation est réalisée. On écrit alors la valeur 0xEE (238). A ce point le DS1621 est correctement initialisé.
4. On rentre alors dans une boucle infinie. La température sera demandée toutes les 500ms. Pour faire la demande de la dernière température, il faut écrire la valeur 0xAA (170).
5. On lit alors le résultat : ici le DS1621 doit nous renvoyer 2 octets d’où la valeur 2 sur le sous VI « I2C Read ». Ce sous VI se charge aussi de faire le NACK final (vérifié à l’oscilloscope). On obtient alors un tableau 1D à deux cases contenant des entiers non signés codés sur 8 bits. Ces données sont affichées de manière brute dans un l’indicateur de la face avant « Données I2C ».
6. Il faut traiter les deux valeurs fourni par le DS1621. On commence par extraire les données du tableau avec le sous VI « Indexer un tableau ». L’indice  ‘0’ : 8 bit de poids fort du résultat de la température en entier signé et l’indice ‘1’ : 8 bit de poids faible de la conversion : dans notre cas cet octet prendra deux valeurs : soit 128 pour indiquer qu’il faut rajouter 0,5°C, soit 0.
7. On reconstruit alors la température réelle et on l’affiche sur le thermomètre.

Cela fonctionne, notez cependant que l’on ne gère pas les températures négatives…c’est à faire en guise d’exercice 🙂

Cinquième exemple : Afficheur LCD alphanumérique

Pour ce test il existe un shield (par exemple http://www.zartronic.fr/shield-lcd-pour-arduino-p-125.html) ou on peut le fabriquer à partir des fichiers Isis et Ares disponible sur http://www.ac-limoges.fr/sti_ge/spip.php?article38. L’afficheur LCD sera utilisé en mode 4 bits et la ligne RW sera reliée à la masse pour diminuer le nombre de fils. On peut avoir le câblage suivant qui n’est PAS DU TOUT le câblage par défaut proposé sous LabVIEW :

Pour être plus explicite on a le câblage suivant (j’exclue les alimentations et le réglage de contraste avec le potentiomètre).

• broche 4 de l’arduino vers broche 4 (RS) de l’afficheur
• broche 5 (RW) de l’afficheur reliée à la masse : l’afficheur est toujours en mode écriture
• broche 6 de l’arduino vers broche 6 (E) de l’afficheur
• broches 10,11,12,13 de l’arduino respectivement sur 11,12,13,14 (DB4,DB5,DB6,DB7) les 4 bits de poids fort du bus de données de l’afficheur

Remarque : suivant votre afficheur, vous pouvez tenter de mettre la broche 3 (Vcontrast) directement à la masse. Si les caractères sont encore visibles cela simplifie encore le câblage.

On va afficher la date et l’heure courante du PC sur l’afficheur LCD. On vérifiera que la longueur de la chaine à afficher est compatible avec le nombre de colonne de l’afficheur sinon on affichera le mot « Erreur !! » et on positionnera un témoin lumineux à rouge. La face avant peut être celle-ci :

Compte tenu du cahier des charges précédent, on peut obtenir le diagramme LabVIEW suivant :

Quelques commentaires sur ce diagramme:

• le sous VI « LCD configure 4-bit » permet d’affecter les broches de l’afficheur LCD aux broches de l’arduino. Le nom des broches est rappelé sur le diagramme. La valeur 255 pour la ligne R/W indique que cette ligne n’est pas cablé du coté de l’arduino. La broche « LCD » précise quel ligne sur l’arduino sera utilisée pour piloter le rétroéclairage de l’afficheur s’il en possède un. Ne connectez pas directement la broche de l’arduino à la broche d’alimentation du rétro-éclairage (vu sur les exemples de chez NI) mais utilisez plutôt un petit transistor MOS type BS170 (datasheet ici) pour piloter l’alimentation du rétro-éclairage.
• Le sous VI « LCD Init » permet de préciser le nombre de colonnes (ici 16) et le nombre de ligne (ici 2) de l’afficheur LCD.
• Tout ce qui est dans la partie supérieure de la boucle while concerne la récupération de la date et de l’heure du PC (avec un format précis) et du test pour savoir si la longueur de la chaine générée est compatible avec le nombre de colonnes de l’afficheur
• Le sous VI « LCD Set Cursor Position » permet de fixer la position de départ de la chaine à afficher. Notez bien que les coordonnées x,y de l’afficheur commence à 0,0 et pas 1,1 !
• Le sous VI « LCD print » permet d’afficher la chaine que l’on a généré auparavant

Remarque : le VI précédent a été testé sur un afficheur LCD 16×2 et un afficheur LCD 20×4 en changeant les paramètres d’initialisation et la position d’affichage. Tout a bien fonctionné 😉

Conclusion…

Pour explorer plus avant les possibilités de LIFA, il suffit d’ouvrir les VI exemples fournis. Ceux-ci se trouvent dans « C:\Program Files\National Instruments\LabVIEW 2011\vi.lib\LabVIEW Interface for Arduino\Palette Examples ». J’espère aussi que les quelques exemples précédents vous ont ouvert l’appétit ! Je trouve le « mariage » open-source, open-harware de l’arduino et le très propriétaire NI LabVIEW assez intéressant car il permet de développer rapidement de petites applications ou projets. De ce point de vue LIFA correspond bien à une philosophie d’apprentissage par projet !

Je compte, si j’ai assez de temps faire un second article, sur une utilisation plus avancé de LIFA. Un des thèmes abordés pourrait être la manette nunchuck de la wii car elle embarque un accéléromètre 3 axes, un joystick analogique et deux boutons poussoirs, le tout interrogeable par un bus I2C pour un prix de 20€…

Vous trouverez ci-dessous une archive zip contenant les captures d’écrans, les fichiers pour fritzing, les VI des exemples (réalisés avec la version 2011 de LabVIEW). N’hésitez pas à commenter cet article et à apporter votre pierre à l’édifice de l’open source – open hardware.