Le sujet abordé dans cet article présente la réalisation d’une mesure de distance à l’aide d’un capteur Lidar monté sur un moteur pas à pas et commandé par LabVIEW à travers la bibliothèque LINX. Nous verrons comment rendre ce système embarqué sur un LattePanda. L’objectif est de pouvoir mesurer une distance entre 0,1 à 20 mètres sur 360° et de contrôler l’ensemble à partir d’une IHM (Interface Homme Machine) tactile.

Avant de commercer cet article, je tiens à remercier Amaury qui m’a permis de publier cet article sur son site. 🙂

Je découvre actuellement l’électronique et la programmation entre  LabVIEW et Arduino et je tiens à partager certains résultats avec vous. Certaines notions abordées ne seront pas forcément poussées ou assez détaillées pour des lectures ou lectrices plus expérimenté(e)s.

Théorie de mesure de distance Lidar

Lidar est l’acronyme anglais de light detection and ranging qui est une technique qui permet de mesurer des distances allant de quelques centimètres à la distance Terre-Lune. Le lidar Garmin utilisé ici, génère un train d’onde électromagnétique cohérente (un faisceau laser InfraRouge) de longueur d’onde λ de 905 nm. Les trains d’onde sont envoyés à une fréquence comprise entre 10 à 20 kHz (à ne pas confondre avec la fréquence propre de l’onde du laser IR) d’après les datasheet. Les trains d’ondes se réfléchissent sur la cible visée par le capteur. Une partie de la lumière du laser revient sur le capteur. Une photodiode placée dans le Lidar et sensible dans la plage de longueur d’onde des IR reçoit l’onde réfléchie. L’écart de temps entre le départ d’un train d’onde et son retour est mesuré par le capteur. Cet écart de temps est proportionnel à la distance parcourue par l’onde. Cette technologie de mesure est communément appelée Time of Flight.

Le matériel utilisé pour la réalisation

Nota : un clavier et une souris seront très certainement nécessaires pour naviguer sur LattePanda.

Le Montage global

Le schéma suivant a été réalisé sur le logiciel libre Fritzing. N’ayant pas trouvé de modèle de LattePanda dans la librairie Fritzing, il a donc été représenté par sa carte Arduino qu’il intègre. Un schéma du LattePanda est donné après.

Figure 1 Schéma Global de la mesure Lidar (à l’aide du logiciel gratuit Fritzing)

L’intégration des différents éléments a été faite à l’aide d’un vieux jeu mécanos.

LattePanda

Le modèle de  LattePanda utilisé est le 4 GB/64 GB sous Windows 10. Ce modèle suffit pour faire tourner un LabVIEW 2014 (https://www.gotronic.fr/art-carte-lattepanda-4-gb-64-gb-dfr0419-24792.htm ). LattePanda sera très utile car il intègre une carte Arduino Leonardo et ses E/S associées. A l’aide des entrées et sorties numériques (0-5V), il sera possible de piloter le moteur pas à pas, le laser et d’acquérir le signal du Lidar. Le LattePanda est enfaîte un petit ordinateur d’instrumentation très compacte et assez puissant. Le projet n’utilise ici qu’une petite partie de sa capacité. Pour plus de détails sur LattePanda, le lecteur pourra se référer à l’article : LattePanda – Première mise en route

Le schéma ci-dessous reprend les principales E/S :

Figure 2 E/S LattePanda 4GB/64GB (https://www.lattepanda.com)

Le moteur Pas à Pas

Le moteur Pas à Pas bipolaire est contrôlé par un Driver Pololu (A4988). Le schéma ci-après (d’après le site Pololu qui commercialise le Driver) permet de connecter le moteur et le Driver. La puce du Driver est alimentée en 5 V par la carte Arduino du LattePanda. Ce driver a été choisi car il est facilement pilotable à partir des E/S digitales du Arduino, qui seront contrôlées par le logiciel ; lequel qui sera abordé après.

Figure 3 Schéma de fonctionnement du Drive couplé au moteur Pas à Pas (bipolaire)

Pour connecter correctement le moteur pas à pas au driver on pourra suivre le tableau suivant :

Figure 4 Schéma du moteur Pas à Pas (14HM11-0404S) d’après datasheet Go Tronic

Il est conseillé de relier la masse de l’alimentation du moteur à la masse du circuit afin d’éviter de le moteur ne grésille. Un petit régulateur LM7815 (15 V) permet de limiter la tension en entrée. Pour ma part j’ai utilisé deux piles de 9 V. En sortie du régulateur il vaut mieux ne pas oublier de limiter le courant à l’aide d’une résistance de charge. Le moteur consomme 400 mA par phase. Pour limiter le courant j’ai choisi de mettre en parallèle 4 résistances de 2 kΩ de 1/4 W qui forment une résistance 500 Ω supportant 1 W. Avec ce montage, le moteur ne chauffe et a assez de puissance pour réaliser ses pas. Un potentiomètre présent sur le driver permet de réguler la tension. Le réglage du courant limite est disponible dans la vidéo disponible en suivant de lien (https://www.youtube.com/watch?v=89BHS9hfSUk). Pololu préconise de régler le courant limite à l’aide du réglage du VREF et non en entrée comme cela a été fait ici.

• Une fois le montage du moteur réalisé, un test du moteur peut être réalise. Pour cela, la Pin STEP du driver peut être connecté au 5V délivré par l’Arduino. Le moteur est censé faire un pas. Sinon, revérifier le schéma de montage.

Les entrées MS1, MS2 et MS3 permettent de réduire le Pas, c’est-à-dire de gagner en précision angulaire. Le tableau ci-dessous affiche les niveaux à utiliser sur les pins en fonctions de la résolution du pas.

Figure 5 Tableau de résolution des pas d’après le site Pololu

Dans le cas présent, un pas complet est de 0,9°, un demi-pas en vaudra la moitié et ainsi de suite. Dans le présent projet, il n’est pas possible de descendre en dessous du demi-pas.

Nota important: il est fortement déconseillé de déconnecter le moteur du driver quand le moteur est en fonctionnement car le Driver peut-être endommagé. Il faudra couper l’alimentation du moteur pour effectuer des changements de postions (si besoin) sur les 4 fils du moteur pas à pas.

Le Lidar

Pour fonctionner le Lidar doit être alimenté en 5 V. L’alimentation 5 V de l’Arduino du LattePanda convient parfaitement. L’acquisition de la mesure de distance est lue en largeur d’impulsion (PWM) sur le fil jaune. Les datasheet préconisent l’utilisation d’une résistance de 1KΩ qui est reliée entre le fil de sortie de la mesure et la masse comme ci-dessous :

Figure 6 Schéma de câblage du lidar en acquisition de mesure en PWM (d’après datasheet Gramin)

Concernant les aspects métrologiques du capteur, la portée maximale du Lidar est de 40 mètres. Sa résolution est de 1 cm.

L’incertitude de mesure du Lidar Lite V3,  entre 0 et 5m est de ± 2.5cm et ± 10 cm au delà.

En sortie de mesure en largeur d’impulsion, la sensibilité est de 10 µs/cm. Cette valeur est à retenir pour comprendre la partie acquisition du signal du logiciel.

Le Laser de visée

Le laser est utile ici afin d’avoir un repère visuel sur l’orientation du Lidar. Le laser est du même type qu’utilisé pour les pointeurs laser de présentation (diode laser). Dans le cas présent, un laser d’alignement de 1 mW (λ = 650 nm) de couleur rouge a été utilisé. Il est alimenté en 5V par une entrée digitale de carte Arduino activable à partir du logiciel.

Attention aux yeux ! Le laser concentre l’énergie sur une surface très petite et a pour conséquence d’être nocif pour l’œil.

L’utilisateur est responsable de sa sécurité mais également celle des personnes autour !

Le logiciel/programme

Pour piloter les instruments (Lidar, moteur, laser) le logiciel LabVIEW 2014 est utilisé. Le but n’est pas de faire la présentation ni la promotion de ce logiciel mais de tenter d’expliquer comment utiliser certaines briques LINX. Si LabVIEW n’est pas utilisé, il sera quand même possible de piloter les instruments via un programme développé sur l’IDE Arduino. La suite de l’article pourra paraître obscure pour les personnes non initiées à LabVIEW; je m’en excuse par avance. Cependant, un petit effort a été fait pour que le code soit compris des personnes non initiées à LabVIEW.

Des briques (ou VI) de code LabVIEW ont été développées afin de faciliter grandement la compatibilité entre des cartes Arduino et LabVIEW. Pour utiliser les briques de codes LINX, la bibliothèque LINX côté LabVIEW doit avoir été installée préalablement dans VI Pack Manager (logiciel qui permet de charger des ToolKit ou librairies de programme).

Chargement des librairies

Avant de compiler le code, il faut charger les bibliothèques. Pour charger les bibliothèques, aller sur l’onglet Tool\MakerHub\LINX\Generate Firmware Librairies :

Et mettre en cible : C:\Program Files\Arduino\Libraries

Les librairies sont donc maintenant chargées et opérationnelles.

Configuration du type de carte

Avant de compiler le code, il faudra configurer le type de carte (Mega, Leonardo) et le type de liaison. Dans ce projet avec LattePanda, la carte Arduino Leonardo est utilisée sur le port COM 4. Dans LabVIEW cliquez dans l’onglet Tool puis \MakerHub\LINX\LINX Firmware Wizard… il faut configurer les champs à l’aide des informations mentionnées plus haut.

TEST simple avec une LED

Pour vérifier que la carte fonctionne correctement, l’exemple du pilotage d’une LED pourra être réalisé (onglet HELP/Find Example…). L’exemple est prêt à être utilisé et ne nécessite que la mise en place d’une LED en série avec une résistance de 220 Ω reliées au LattePanda.

Mettre le port COM 4 (normalement) et configurer la pin du Arduino sur laquelle est reliée l’anode de la LED (la patte la plus longue) et ne pas oublier la résistance de 220 Ω en série 😉 . Puis relier la résistance à la masse et lancer le programme (flèche blanche).

Si la LED clignote quand le bouton est pressé, c’est gagné. Passer aux étapes suivantes. Sinon, il faut trouver la raison de cette malchance.

Ne pas hésiter à reconfigurer la carte car il arrive (trop) souvent que cela saute au bout de 3 à 4 compilations. Par exemple, il vaut mieux arrêter proprement la boucle avec un bouton « stop » placé dans la boucle While plutôt que de stopper le programme avec le bouton rouge de LabVIEW.

L’IHM (côté « Face Avant » de LabVIEW)

L’IHM qui permet à l’utilisateur de contrôler les instruments pourra ressembler fortement à celle présentée ci-dessous.

Les configurations des Pins et du port sont situées à gauche.

Le bouton « Motor ON » permet d’activer le driver sur la Pin ENABLE (Driver).

Le bouton « Left » permet d’activer la Pin STEP (Driver)  et faire faire un pas au moteur.

Le bouton « Right »agit comme le bouton « Left » mais active la pin DIR (Driver) à l’état haut et permet de changer de sens de rotation.

Un bouton « Laser » permet d’activer le laser de visée.

Un bouton STOP permet d’arrêter l’exécution proprement et d’arrêter le moteur (ENABLE) et le Laser.

Trois types d’indicateurs sont présents : numérique (format chaîne de caractère), une barre de remplissage, et un graphe déroulant.

Un contrôleur barre graphe permet de passer au pilotage Pas par Pas (un clique sur LEFT ou RGTH = 0,9°) ou active la vitesse constante (comme sur la vidéo du début de l’article).

Pour le lecteur non initié à LabVIEW, la « face avant » est la partie visible finale du programme disponible pour l’utilisateur.

Le code est développé dans une seconde fenêtre appelée « Diagramme ». Et c’est la partie de développement du Diagramme que nous allons maintenant aborder.

Nota : un Crtl+E permet de permuter rapidement rentre la face avant et le diagramme.

La structure (côté diagramme)

La structure générale du programme est la suivante :

Figure 7 Structure générale du programme dans un boucle While

Le code source ne sera pas disponible dans cet article mais les principales briques seront détaillées pour arriver facilement au résultat. 🙂

Lecture de la valeur de la distance du Lidar

Le Lidar Garmin Lite V3 admet deux sorties de données pour la lecture des mesures : I2C ou PWM. La lecture en modulation de largeur d’impulsion est apparue comme le plus simple du point de vue du soft. Un VI LINX permet de réaliser cette mesure rapidement contre plusieurs VI pour la communication en I2C.

Dans la boucle While cadencée à 50 ms, la mesure du Lidar est effectuée à l’aide du VI « Lecture de la largueur d’impulsion » :

L’entrée DO Channel est connectée et la valeur de la Pin 0 de la carte Arduino est rentrée (cf Figure 8 ci-dessous).

Un tableau général de configuration des Pins d’E/S pourra être créé en amont de la boucle While comme ceci :

La valeur en sortie du VI n’est pas en cm mais en largeur d’une impulsion (µs), qui est proportionnelle à la distance mesurée en cm par le lidar. Afin de lire et d’afficher une valeur en cm, il faut diviser les valeurs en sortie du VI par une constante valant 10 pour obtenir une mesure de longueur (en cm). Cette constante est la sensibilité (en µs/cm) du capteur abordé précédemment que l’on peut retrouver dans la documentation du Lidar Lite V3 (page 4, §Mode Pin Control).

Une moyenne glissante pourra être développée afin d’obtenir une mesure plus stable et plus juste à l’aide des registres à décalage (flèches oranges sur les bords de la boucle While). L’inconvénient de cette technique est qu’il faudra attendre n fois le nombre de points moyennés, pour obtenir le résultat. Si l’on choisit de moyenner sur 10 points et que le temps du cadencement est de 500 ms, alors le résultat sera juste au bout de 5 secondes. Ne pas oublier d’initialiser les registres à décalage à zéro. Différents types d’indicateurs pourront être placés en face avant comme ci-dessous :

Figure 9 Moyenne glissante (côté diagramme/code) et exemples d’indicateurs en face avant

Comme le Lidar affiche une incertitude de ± 2.5 cm et une résolution de 1 cm, il a été choisi de n’afficher que des valeurs entières arrondies au centimètre.

VI de contrôle du Driver et du moteur

Un VI « écrire sur des E/S digitales » permet d’activer les sorties de l’Arduino du LattePanda afin de piloter le Driver.

La fonction suivante a été construite comme ci-après :

Cette fonctionnalité permet de prendre, en entrée, un tableau de booléens (ordres des boutons pressés en face avant) et d’activer les E/S correspondantes.

• La première entrée (en partant du haut) de la fonction « Construire un tableau» est reliée au bouton « MOTOR ON » et agit sur la Pin « ENABLE » du Driver. Ce bouton permet vraisemblablement d’activer l’alimentation du driver et du moteur.
• La seconde entrée permet de gérer la direction du moteur. Le fil (vert) est relié au bouton « RIGHT » de mon interface afin d’active la Pin « DIR » du driver. Le moteur tourne ainsi dans le sens horaire.
• La troisième entrée active la pin « STEP » du driver et permet d’effectuer un Pas de 0,9° (avec les entrées du driver MS1=MS2=MS3=0=GND). Le moteur effectue un pas par changement de niveau de l’état bas à l’état haut. Cette entrée est active si le bouton « LEFT » OU le bouton « RIGHT » est activé. Nous verrons ensuite comment faire tourner le moteur à vitesse constante.
• La quatrième entrée active le laser. Un laser de visée peut fonctionner qu’avec une tension de 5V et ne consomme que quelques milliampères. Il est souhaitable pour la sécurité des personnes, que le bouton « STOP » qui arrête le programme, puisse stopper l’émission du laser à la fin de la manip en même temps. Pour cela on pourra mettre une boucle conditions comme ci-dessous :

Il pourra être fait de même avec l’arrêt du moteur (« MOTOR ON ») à la fin de l’exécution du programme.

• Les cinquième, sixième et septième entrées activent les Pins MS1, MS2 et MS3 du driver et permettent de gagner en précision d’angle (jusqu’au demi pas ici).

Afin de faire fonctionner le moteur à vitesse constante, la fonctionnalité suivante a été développée :

Lorsqu’un booléen (bouton) active la structure « Cas », le VI « écrire un signal carré » est activé avec une fréquence nulle et d’une durée nulle sur la pin STEP. Cette fonctionnalité m’a permis de faire fonctionner le moteur à vitesse constante. Dans ce cas, la vitesse est fonction du temps de cadencement de la boucle (réglée à 50 ms). A l’heure où est écrit cet article, il existe surement de meilleures solutions, notamment avec le VI « PWM Set Duty Cycle »:

Mais cela n’a pas fonctionné comme il était souhaité lors du test.

A la suite de ces nombreux réglages et bidouillages, le programme doit pouvoir se lancer (flèche blanche non brisée). Si cela n’est pas le cas, résoudre les erreurs unes à unes.

Il fortement probable que rien ne fonctionne du premier coup, ou qu’à moitié, il est alors conseillé, dans un premier temps, de vérifier les branchements (alimentation) des organes dysfonctionnant.

L’utilisateur pourra jouer avec les différents types d’actions mécaniques pour contrôler le moteur (clique droit sur un bouton) :

Résultats en images :

Figure 10 Interface de la mesure de distance (Windows n’est pas à l’heure ^_^ )

J’espère que ce projet a pu continuer d’éveiller votre curiosité et a pu vous aider dans vos futurs développements !

Sources :

• Site Pololu (https://www.pololu.com/product/1182 )
• Site GO Tronic
• https://www.lattepanda.com
• Ressources LINX : http://sine.ni.com/nips/cds/view/p/lang/fr/nid/212478
• Forum LINX : https://www.labviewmakerhub.com/doku.php?id=libraries:linx:start
• Datasheet Lidar Garmin lite V3 : https://static.garmin.com/pumac/LIDAR_Lite_v3_Operation_Manual_and_Technical_Specifications.pdf
• LabVIEW – 4e édition – Programmation et applications – Introduction à LabVIEW NXG, Collection : Technique et ingénierie, Dunod, Parution : août 2018,Francis Cottet, Luc Desruelle, Michel Pinard

• The Art of electronic, Third edition, Paul Horowitz et Winfield Hill