• lvrt-schroot : pour LabVIEW 2014, la version initiale
• lvrt20-schroot : pour la future LabVIEW 2020 ?
• lvrt19-schroot : pour LabVIEW 2019 ?

Si l’on essayait ensemble d’installer lvrt19-schroot sur un Raspberry Pi 4 tout neuf ?

Introduction

Avant de commencer, il nous faut un Raspberry Pi (>2) fonctionnel avec la dernière version de Raspbian (Buster à l’heure où ce test a été mené). Pour ma part, je profite de la sortie du Raspberry Pi 4 pour le prendre en main et profité de la connexion WiFi (enfin!).

Installation de LINX 3 pour LabVIEW 2019

Nous sommes prêts? Allons-y !

Tout se passe en ligne de commande. Ouvrez un terminal SSH et connectez-vous sur le Raspberry Pi.

Commençons par mettre à jour notre installation:

• sudo apt-get update
• sudo apt-get dist-upgrade -y

Ensuite activons les modules i2c et spi:

• sudo raspi-config nonint do_i2c 0
• sudo raspi-config nonint do_spi 0

Ajoutons le dépôt d’installation de LINX:

• sudo sh -c ‘echo « deb [trusted=yes] http://feeds.labviewmakerhub.com/debian/ binary/ » >> /etc/apt/sources.list’
• sudo apt-get update

A ce stade, la magie n’a pas encore opéré. Installons donc le paquet lvrt19 (tuto extrait du forum NI, modifié pour LabVIEW 2019) :

• sudo apt-get install -y lvrt19-schroot
• sudo mv /etc/systemd/system/multi-user.target.wants/nisysserver.service /lib/systemd/system
• sudo mv /etc/systemd/system/multi-user.target.wants/labview.service /lib/systemd/system
• sudo schroot -c labview -d /usr/lib — ln -s liblinxdevice_rpi2.so liblinxdevice.so
• sudo systemctl enable nisysserver.service
• sudo systemctl enable labview.service
• sudo systemctl start nisysserver.service
• sudo systemctl start labview.service

Vérification de l’installation avec LabVIEW 2019

Avant d’aller plus loin, nous allons vérifier la bonne installation du runtime 2019 sur le Raspberry Pi.

Créons un nouveau projet LabVIEW vide et ajoutons une cible temps réelle compatible (cRIO 9039 au hasard) en spécifiant l’adresse IP du Raspberry Pi.

Ensuite, nous connectons le projet à la cible: clic droit sur la cible -> Connect.

LabVIEW déploie le projet et vérifie la connexion à la cible.

Comme nous avons défini la cible comme étant un compact RIO, LabVIEW cherche automatiquement à détecter les modules d’acquisitions présents dans el châssis. Nous avons un Raspberry Pi, donc LabVIEW échoue à détecter les modules, mais pas de panique, tout est normal.On continue la procédure en écrivant un petit code de test qui renvoie la version de LabVIEW et la version du système :

Confirmation du fonctionnement (ctrl + R), après déploiement et exécution, nous voyons la version 2019 et la version de l’OS (ici Linux raspberry 1.19.97) :

Vous trouverez le projet de test ici : test.zip

Ajout de la cible Raspberry Pi dans LabVIEW 2019

Pour ajouter le Raspberry Pi comme cible de déploiement dans LabVIEW, il faut ajouter des Providers. Ils sont fournis dans le paquet d’installation VIPM de LINX. Il est possible de récupérer l’archive zip intéressante en décompressant le fichier .vip ou en la téléchargeant ici : InstallProviders.zip

Quittez LabVIEW, décompressez cette archive et lancez la commande suivante :

• UpdateLinxProvider.bat « C:\Program Files (x86)\National Instruments\LabVIEW 2019 »

Une fois installé, le Raspberry Pi apparait dans la liste des cibles disponibles :

Conclusion

En attendant la sortie officielle de LabVIEW 2020 avec le support LINX inclus, il est possible de profiter d’un runtime 2019 sur un Raspberry Pi. Pour preuve, voici un pilotage moteur en CanOpen utilisant CanOpenSocket:

Cet article Le Raspberry Pi se propulse vers LabVIEW 2019 (et 2020) ! est apparu en premier sur Electronique et Informatique.

Avertissements

Cette manipulation pourrait rendre votre LattePanda disfonctionnel. Pour le restaurer dans la version Windows 10 d’origine, référez-vous à la page d’explication du forum LattePanda.

En outre, l’installation de NI Real-Time et la programmation du LattePanda avec LabVIEW RT ne sont pas supportés officiellement, ni par National Instruments, ni par moi-même. Cet article expose la possibilité d’utiliser le LattePanda avec LabVIEW RT à titre purement expérimental et non professionnel. En effet, le LattePanda n’offre pas les mêmes caractéristiques techniques qu’un compact RIO en terme de robustesse, fiabilité ou déterminisme. Il ne saurait en aucun cas remplacer un contrôleur industriel certifié et testé.

Prérequis

Pour commencer, il vous faut réunir les pièces suivantes:

• Un LattePanda première génération
• Son écran 7 » (facultatif, mais alors il faudra un écran HDMI)
• Un clavier USB pour le LattePanda
• Une clés USB d’au moins 128Mo
• Un PC installé avec LabVIEW, LabVIEW RT et MAX (Measurement and Automation eXplorer)
• La possibilité de brancher sur le même réseau le PC et le LattePanda (la carte WiFi ne sera pas utilisable)
• L’image d’installation via NIPM ou ici : standard_x64_recovery.iso

Récupération de l’image via NIPM

Lancer NIPM et faire la recherche « Linux ». Le résultat doit être le suivant :

Sélectionner le produit « Image Système NI Linux RT PXI » et cliquer sur installer.

MAX doit être mis à jour pour permettre la création de la clé USB. Dans tous les cas l’image se trouvera dans « ..\National Instruments\RT Images\Utilities\Linux RT PXI Safemode\7.0 ».

Création de la clé USB d’installation

Depuis peu (version 19.0), MAX est doté de la possibilité de générer une clé USB de restauration pour NI Linux RT.

Pour ce faire, passer par le menu Outils -> Créer une clé de restauration NI Linux RT

Ensuite, choisissez votre clé USB et le fichier standard_x64_recovery.iso

Cliquer sur Formater et laisser MAX générer la clé d’installation.

Installation de NI Linux RT

ATTENTION : pour fonctionner correctement, le LattePanda doit avoir un BIOS configuré en UEFI.

Pour installer NI Linux RT sur le LattePanda, il faut amorcer la clé USB générée par MAX. Pour ce faire, appuyer sur F12 pendant l’écran d’amorçage et sélectionner la clés USB. Normalement, un shell Linux devrait démarrer vous demandant si vous souhaitez formater votre cible et installer NI Linux RT. Répondez oui (‘Y’ puis Entrer).

L’installation dure quelques secondes, puis un message de confirmation apparait.

Il reste à retirer la clé USB et appuyer sur Entrer pour redémarrer le LattePanda. L’écran d’accueil est le suivant:

L’identifiant par défaut est :

login : admin
mot de passe : aucun

Installation des logiciels

Maintenant que le LattePanda fonctionne sous NI Linux RT, la suite des opérations se déroule dans MAX. Logiquement, le LattePanda doit apparaitre dans la section systèmes déportés. S’il n’apparait pas, il est possible que le pare-feu Windows fasse obstruction…

Pour ajouter des logiciels au LattePanda, faire un clic droit sur sa section « Logiciels » et choisir « Ajouter/Supprimer des logiciels » :

Valider les droits admin :

En fonction des paquets logiciels disponibles sur votre pc hôte, l’interface suivante vous proposera différents paquets à installer.

De base, , en choisissant une installation personnalisée, il est possible d’installer le run-time LabVIEW RT ainsi que VISA, les web services, les Network Streams… :

Voici un exemple de paquets que vous pouvez installer :

Il peut cependant être utile d’installer des paquets supplémentaires cette fois-ci dans LabVIEW. Pour ce faire, on utilise le VI Package Manager. Voici une liste des paquets intéressants:

• NI Linux RT Inter-Process Communication
• NI Linux RT Utilities
• NI Linux RT Errno
• Digilent LINX
• RTI DDS Toolkit

Activation de l’Embedded UI

L’introduction de NI Linux RT a permis de tirer parti d’un écran connecté sur la cible RT. Cela permet de concevoir des applications autonomes équipées d’une interface graphique.

Il est possible que le serveur graphique ne démarre pas automatiquement. Pour palier à ce problème il faut éditer le fichier de configuration ni-rt.ini à l’emplacement /etc/natinst/share.

Ajouter la clé ui.enabled=True dans la section SYSTEMSETTINGS :

Installation d’un serveur VNC

Avec un serveur graphique fonctionnel, il est possible d’installer un serveur VNC pour prendre la main à distance sur le LattePanda.

Pour ce faire, il faut installer manuellement X11VNC. Sur NI Linux RT, le gestionnaire de paquets est opkg. Pour installer VNC, commencer par mettre à jour la liste des paquets:

$ opkg update

Puis installer VNC:

$ opkg  install x11vnc

Pour la configuration et le lancement manuel (je n’ai pas réussi à le rendre automatique), se référer à la page de LinuxTricks suivante:

https://www.linuxtricks.fr/wiki/vnc-x11vnc-pour-prendre-le-controle-du-bureau-a-distance

Installation de l’Arduino

Installation de l’IDE

A partir de votre PC, télécharger la version d’Arduino pour Linux 64 bits. Pour envoyer le paquet tar.xz sur le LattePanda, il est possible de monter un disque réseau Windows sur le système WebDAV du LattePanda. Il est autrement possible de passer en SCP ou en SSHFS (par exemple avec WinSCP). Une dernière solution consiste à installer le serveur FTP (legacy mode) avec MAX.

Pour le WebDAV, voici les informations de connexions:

• adresse : http://ip_panda/files
• login : admin
• mot de passe : vide

Placer l’archive tar.xz dans le dossier /home/lvuser

Pour décompacter l’archive .tar.xz, il faut les utilitaires tar et xz:

$ opkg intall tar xz

$ tar -xJf arduino-x.x.x-linux64.tar.xz

Aller dans le dossier Arduino et faire un chmod +x sur le fichier arduino.

Pour lancer l’IDE, un simple ./arduino devrait faire l’affaire.

Compilation et téléchargement de LINX

Pour charger LINX dans l’Arduino, il est nécessaire de le compiler à partir des sources du firmware. Il est possible de les récupérer à partir du GITHUB de MakerHub ou de les récupérer à partir de LabVIEW:

Il faut ensuite recompiler l’exemple Arduino_Leonardo_Serial.ino et le téléverser sur l’arduino du LattePanda. Une fois cette opération faite, il est possible d’utiliser LabVIEW pour accéder à l’arduino.

Utilisation sous LabVIEW

L’arduino devrait apparaitre dans MAX comme alias VISA (il est possible de le renommer :

LINX utilisera cet alias pour se connecter à l’arduino :

En cas de problèmes, n’hésitez à pas à me contacter 🙂

Cet article LabVIEW RT & LattePanda est apparu en premier sur Electronique et Informatique.

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

Cet article Mesure Lidar rotatif embarqué sur LattePanda et piloté par LabVIEW (LINX) est apparu en premier sur Electronique et Informatique.

Comme je vous l’ai expliqué dans l’article précédent, il est possible de déployer une application LabVIEW dans le Raspberry Pi. Il fonctionne alors en mode autonome, sans interface utilisateur. Je vais aujourd’hui vous présenter l’une des solution qui permet de communiquer avec son programme en utilisant un simple navigateur internet: le service Web.

Principe de fonctionnement

L’exécution d’une application LabVIEW sur une cible embarquée repose sur le moteur d’exécution (Run-Time Engine). Ce moteur fournit l’environnement d’exécution de l’application. Il fournit également un serveur de débogage distant, des modules d’accès aux ressources systèmes (réseau, fichiers, interpréteur de commande, …), le Vi Server et bien d’autres choses.

Il se trouve qu’il y a également a disposition des développeurs un serveur web. Il s’agit d’un environnement d’exécution particulier qui permet d’interroger un VI via une requête HTTP.

Comme illustré sur l’image d’introduction, ce serveur Web est dissocié de l’application principale. Cependant, il est possible de communiquer avec elle en utilisant le Vi Server ou d’autres mécanismes. Dans l’exemple qui va suivre, j’utiliserai des variables globales pour échanger de simples valeurs courantes.

Créer un Service Web

Pour créer un service Web sur une cible LabVIEW (PC ou embarquée), il suffit de faire un clic droit sur cette dernière et de choisir Nouveau > Service Web.

Un nouvel objet apparait alors dans le projet. Il contient deux sous sections, Ressources Web et VI de Démarrage. Nous nous intéresserons exclusivement à la première.

Ce service Web va servir de point d’entrée pour les requêtes HTTP. On va maintenant ajouter de nouvelles ressources. Chaque ressource sera liée d’une part à une URL, d’autre part à un VI.

Pour ajouter une ressource, il suffit là encore de faire un clic droit sur l’objet Ressources Web, puis Nouveau VI. Chaque nouveau VI sera lié à une URL. Il est également possible d’ajouter une Ressource Web. Ces ressources permettent simplement de structurer le service Web (un peu comme des dossiers pour un serveur Apache). Il faudra alors spécifier le nom de la ressource Web dans l’URL.

Pour chaque VI, il est possible de définir le type de requête HTTP associé: GET, POST, PUT ou DELETE. Cela permet par exemple de développer des API REST.

De manière générale, le VI sera accessible par l’URL suivante:

http://xxx.xxx.xxx.xxx:8001/RessourcesWeb/NomDuVi

Formater une réponse HTTP

Les VI ajoutés dans un Service Web sont exécutés dès qu’une requête HTTP est reçue sur l’URL associée. Voyons maintenant le type de code que peut contenir une ressource Web, et surtout comment formater la réponse HTTP.

1 – Formatage automatique

Pour un simple échange de valeurs courantes, il est possible de déléguer à LabVIEW la création de la réponse. Pour cela, il suffit de câbler les données à envoyer sur le terminal du VI.

Le diagramme du VI est lui chargé d’élaborer les données à transférer. Dans mon cas, je remonte simplement trois mesures. Le VI lit donc simplement trois variables globales et les envoie dans des indicateurs.

Le code source pourrait être bien plus complexe, par exemple en réalisant des calculs, ou en interprétant la requête HTTP. Gardez cependant une chose à l’esprit: ce VI est exécuté pour chaque requête. Plus il est long, plus la réponse sera longue à obtenir…

Mais comment LabVIEW envoie les données ?

Et bien, on peut choisir ! En faisant un clic droit sur le Service Web dans le projet puis en allant dans Propriétés on obtient tous les paramètres voulus dans la section HTTP Method VI Settings:

Les paramètres sont réglés VI par VI.

La première sous section correspond à la mise en forme de l’URL d’accès et au type de requête attendu.

La deuxième sous section permet de configurer la réponse HTTP.

Par défaut, le VI est configuré pour une sortie sur Terminaux avec un format HTML. Pour faire un formatage automatique, il faut impérativement choisir une sortie sur Terminal.

LabVIEW va prendre tous les terminaux du VI et mettre leurs valeurs dans une table HTML. Voici la page affichée par un navigateur Web pour mon VI simpliste:

<html>
    <body>
        <h1>URL: /WebService/RawData/HTTPMethod_Html</h1>
        <h2>Output Terminals</h2>
        <table  border=1.0>
            <tr>
                <th>Terminal Name</th>
                <th>Terminal Value</th>
            </tr>
            <tr>
                <td>Temperature</td>
                <td>25.32916641235352</td>
            </tr>
            <tr>
                <td>Hygrometrie</td>
                <td>30.240014152</td>
            </tr>
            <tr>
                <td>Pression</td>
                <td>907.505615234375</td>
            </tr>
        </table>
    </body>
</html>

Les autres formats de sortie sont les suivants:

• XML

<Response>
    <Terminal>
        <Name>Temperature</Name>
        <Value>25.375</Value>
    </Terminal>
    <Terminal>
        <Name>Hygrometrie</Name>
        <Value>30.10982604800001</Value>
    </Terminal>
    <Terminal>
        <Name>Pression</Name>
        <Value>907.39013671875</Value>
    </Terminal>
</Response>

• JSON

{
    "Temperature":25.39583396911621,
    "Hygrometrie":30.247509352,
    "Pression":907.404296875
}

• Texte brut

Temperature=25.46249961853027
Hygrometrie=30.04304245000001
Pression=907.55322265625

La seule précaution à prendre pour ce type de Service Web est de ne pas utiliser de caractères accentués dans les étiquettes des terminaux.

Bien que LabVIEW renvoie du HTML par défaut, il est cependant préférable de se cantonner au XML ou au JSON, bien que le XML généré par LabVIEW soit assez mal organisé (requête XPath complexes à cause du manque d’utilisation de tags).

2 – Formatage manuel

Avec ce mode de formatage, il est possible de fabriquer par programme la réponse HTTP. Pour passer en formatage manuel, il faut choir une sortie de type Stream dans la fenêtre de propriétés du Service Web. Le diagramme du VI est un peu plus complexe: on utilise la sous palette Web Service de la palette Connectivity pour fabriquer toute la réponse HTTP:

• Code de la réponse
• type MIME
• Contenu
• …

Il devient alors possible de générer du code HTML plus évolué, d’ajouter du style CSS, d’envoyer des images, … Pour l’exemple, je me suis contenté d’une feuille HTML de base:

<!DOCTYPE html>
<html>
    <body>
        <h1>Température</h1><p>25.5 °C</p>
        <h1>Pression</h1><p>907.6 hPa</p>
        <h1>Hygrométrie</h1><p>30.2 %HR</p>
    </body>
</html>

Ce mode de création de la réponse HTTP permet par exemple de générer un code XML mieux organisé que celui de base.

Déploiement

Pour déployer un service Web en source, il suffit de faire un clic droit sur ce dernier et de choisir Démarrer. Cependant, il semble y avoir un problème avec LINX: quelques fois, il y a une erreur au déploiement (LabVIEW ne trouve pas le serveur web et échoue à démarrer l’application). Du coup, je préfère tester mes services Web directement en compilant mon application. Pour cela, il convient de modifier les spécifications de construction de l’application:

Il faut alors choisir les services Web à inclure dans l’application, recompiler l’ensemble, déployer et redémarrer le Raspberry Pi.

Conclusion

Les services Web sont une solution relativement simple pour communiquer avec une application LabVIEW.

Ils peuvent être utilisés pour surveiller une application ou consulter des valeurs courantes.

Ils peuvent également servir pour communiquer avec un système distant, tel qu’une base de données, une application Android, un site Web, … Les applications sont nombreuses et puissantes. Je n’ai qu’effleuré l’aspect « Service » pour me concentrer sur l’implémentation sous LabVIEW.

Si le sujet vous intéresse, vous trouverez plus d’informations sur OpenClassRoom.

La seule contrainte liée au formatage automatique est d’éviter les caractères ASCII étendus.

Enfin, il faut garder à l’esprit que les VI des services Web sont exécutés de manière asynchrone, et par conséquent ont un impacte important et non prédictible sur les performances globales du système.

Cet article LINX 3.0 – Création d’un Service Web avec LabVIEW est apparu en premier sur Electronique et Informatique.

Cependant, LabVIEW permet de faire bien plus. Une application embarquée va être amenée à fonctionner de manière autonome, dans un lieux potentiellement inaccessible. Il est alors indispensable que l’application soit téléchargée dans la cible et démarre automatiquement.

Déployer son application en mode autonome

Une fois le programme mis au point, il est possible de le déployer à demeure dans la cible. Un petit peu comme on flasherait une programme dans un microcontrôleur. Pour ce faire, il faut créer une spécification de construction de type Real Time Application (bien que cette dernière n’ai pas le déterminisme d’une vrai application RT, du fait des limitations du Raspberry Pi).

Un assistant de configuration s’ouvre. La première page vous permet de nommer votre application et de choisir dans quel dossier elle sera construite.

La section la plus importante est la suivante: Source Files. Elle permet entre autre de choisir le VI de démarrage. Il s’agit du premier VI lancé par le Run-Time au démarrage de l’application. Autrement dit, il s’agit du Main de l’application.

Une autre page intéressant est celle concernant les options avancées. On y trouve notamment la possibilité de compiler l’application en mode Debug, qui permet de connecter LabVIEW à l’application compilée pour la debugguer in situ.

Une fois la spécification de construction terminée, ne cliquez pas directement sur Build, mais plutôt sur OK. Enregistrez ensuite l’intégralité du projet. En effet, la configuration de la spécification de construction est sauvée dans le fichier .lvproj lui-même. La spécification apparait alors dans le projet. Il est possible de la compiler via le menu du clic droit en choisissant Build.

Une fenêtre faisant apparaitre la progression de la compilation s’ouvre:

Quand la compilation est terminée, cliquer sur Done.

A ce stade, l’application n’est pas encore dans le Raspberry Pi. LabVIEW a juste généré le fichier binaire exécutable. Pour télécharger l’application dans la cible et faire en sorte qu’elle démarre automatiquement à la mise sous tension, il fait repasser par le menu du clic droit et choisir Run as startup.

LabVIEW télécharge alors le binaire dans le Raspberry Pi et configure ce dernier pour le lancer au démarrage. Un popup apparait alors pour vous proposer de redémarrer la cible. Acceptez et votre application devrait se lancer an quelques dizaines de secondes.

Conclusion

Une application compilée sera plus économe en ressources systèmes. Elle peut démarrer automatiquement, sans le recours à LabVIEW pour lancer le code. Cependant, il n’y a plus d’interface graphique, donc certaines fonctions sont inopérantes: les popups, les message d’erreurs, … Il faut donc trouver d’autres solutions pour communiquer, mais cela sera l’objet d’un autre article.

Bon dév à tous !

Cet article LINX 3.0 – Déploiement d’une application LabVIEW sur Raspberry Pi est apparu en premier sur Electronique et Informatique.

Ce toolkit permet donc de développer une application avec LabVIEW, de la compiler et de la télécharger dans la cible pour lui permettre de fonctionner de manière autonome!

Le Contexte

National Instruments, la société qui développe et maintient l’environnement LabVIEW, a récemment choisi une distribution Linux RT (Real Time) pour animer ses systèmes embarqués (cDAQ, cRIO, PXI…). Elle supporte actuellement les plateformes Zynq de Xillinx (ARMv7) et Intel Atom (x86). Or il se trouve que les Raspberry Pi 2 et 3 ainsi que la BeagleBone ont un jeu d’instruction ARMv7… Partant de ce postula, un portage du noyau d’exécution LabVIEW (Run-Time Engine) sur ces plateforme n’était qu’une question de temps.

C’est maintenant chose faite ! Une chose manque cependant à l’appel: le support du serveur graphique.

En effet, depuis l’arrivée des cRIO 903x, NI propose l’utilisation d’un serveur XFCE pour ajouter une interface graphique aux applications embarquées. Ceci n’est à ce jour pas encore supporté par LINX.

ATTENTION: Le Raspberry Pi N’EST PAS A CE JOUR UNE CIBLE LabVIEW TEMPS RÉEL!

LINX: Le toolkit LabVIEW

Digilent, une société acquise par National Instruments, a développé LINX, une solutions permettant le fonctionnement d’application LabVIEW sur certaines cibles telles que les Arduino ou Raspberry Pi.

Depuis la version 3.0 de LINX, la cible (Raspberry Pi ou Beagle Board) devient autonome!

L’idée de Digilent est brillante de simplicité: installer le Run-Time LabVIEW RT dans un environnement chroot à l’intérieur de l’OS d’origine. Sur le Raspberry Pi, Digilent recommande l’utilisation de Raspbian Jessy.

Configuré pour booter en mode console sans environnement graphique, l’application développée avec LINX 3.0 démarre en quelques dizaines de secondes à partir de la mise sous tension; les performances sont donc au rendez-vous!

Les premières versions fonctionnaient en mode supervisé:  un daemon installé sur la cible recevait des commandes d’un PC qui exécutait le VI LabVIEW. Une perte de communication entre les deux et le programme se plantait.

Mise en place de l’environnement

Le première chose à faire est d’installer LabVIEW 2014 SP1 32bits. Une licence Home Bundle est disponible aux alentour de 50€ à destination des makers et autres amateurs. Digilent propose également des packs LabVIEW Physical Computing à moins de 100€ incluant la licence et la cible. Je vous recommande particulièrement d’installer la version anglaise de LabVIEW, l’essentiel des communautés d’utilisateurs faisant usage du jargon anglophone. Prévoir quelques Go d’espace disque, LabVIEW est relativement volumineux (mon installation fait plus de 4Go sans compter les modules additionnels), ainsi qu’une connexion Internet pour l’activation.

Une fois LabVIEW correctement installé et activé, il faut lui ajouter LINX 3.0. Pour cela, rien de plus facile: VIPM est là pour ça!

Mais qu’est donc? VIPM (VI Package Manager) est un outils développé par JKI pour donner accès à une bibliothèque de toolkits et plugins pour LabVIEW. Certains sont gratuits, voir Open Source (tels que l’OpenG ou encore LINX), d’autres sont soumis à licence. Du coup, pour installer LINX, il suffit de lancer VIPM, chercher LINX dans la liste des modules et cliquer sur Installer…

Pour vérifier la bonne installation de LINX, lancer LabVIEW et ouvrir le menu Outils. Vérifier la présence d’un sous menu MakerHub:

Installation de la cible

Je vais détailler ici l’installation de LINX 3.0 sur Raspberry Pi 2 ou 3, n’ayant pas de BeagleBone sous le coude… Pour ces dernières, je vous propose de regarder les tutoriaux vidéos de Digilent.

Commençons par installer Raspbian Jessy Lite sur la carte SD du Raspberry. Un petit coup de dd sous Linux ou de Win32DiskImager sous Windows et le tour est joué. Pour configurer le Raspberry, un petit sudo raspi-config. Il est utile d’activer l’UART, le SPI et L’I2C ainsi que d’étendre la partition système à toute la carte SD. Pour continuer, il va également falloir configurer le réseau: Ethernet pour le Pi 2, possiblement le WiFi pour le Pi 3. Notez bien l’adresse IP du Raspberry, nous en aurons besoin.

Retour sous LabVIEW. Aller dans le menu Outils > MakerHub > LINX > LINX Target Configuration…

Renseigner les champs comme suit:

Hostname or IP : xxx.xxx.xxx.xxx (l’adresse IP du Raspberry Pi sur le LAN)

Username: pi

Password: raspberry

Et cliquer sur Connect puis sur l’onglet Install Software.

Un simple appuie sur le bouton Install et le tour est joué. L’utilitaire d’installation se connecte sur les dépôts d’installation de NI pour récupérer le Run-Time et l’installer dans l’environnement chroot.

Programmer la cible avec LabVIEW

Pour attaquer une cible embarquée avec LabVIEW, il faut commencer par créer un projet. Pour l’exemple, je vais créer un projet vide, mais rien n’empêche de partir d’un modèle de projet. Pour ajouter le Raspberry au projet, faire un clic droit sur la racine du projet (et non sur My Computer, comme souvent commis par erreur…) et ajouter une nouvelle cible:

Spécifier l’adresse IP de la cible et choisir son type: LINX > Raspberry Pi / BeagleBone. Une nouvelle cible est ajoutée au projet. Tout les VI placés dans cette cible s’exécuteront sur celle-ci et non sur l’ordinateur.

Quand on édite un VI, on peut savoir sur quelle cible il s’exécute lorsque l’on clique sur la flèche d’exécution. Il suffit pour cela de regarder en bas à gauche de la fenêtre (face avant ou diagramme): un  champ texte précise le nom de la cible et permet de modifier ponctuellement celle-ci.

Par exemple, on développe un algorithme de calcul sur le Raspberry et l’on aimerait le tester rapidement: rien de plus simple! Un clic droit sur le champ texte et on choisi My Computer. LabVIEW va alors exécuter le code sur le PC plutôt que sur le Raspberry. Les conditions d’exécution sont différentes, mais on économise la phase de compilation et de déploiement qui peut prendre un peu de temps.

Les fonctions spécifiques au module LINX sont accessibles par la palette MakerHub. On y retrouve toute l’API: accès aux E/S tout ou rien, aux modules UART/SPI/I2C ainsi que tout un tas de drivers pour capteurs et afficheurs. On y trouve également une Toolbox qui propose des fonctions de support utiles.

L’accès à l’API LINX s’effectue de la manière suivante:

1. Ouverture d’une référence en mode Local I/O
2. Initialisation des différents sous modules (typiquement le SPI)
3. Accès aux E/S, fonctionnement nominal de l’application
4. Fermeture des sous modules
5. Fermeture de la référence principale

Voici un exemple de communication sur bus SPI.

• Le premier VI ouvre une référence vers l’API LINX. Elle est nécessaire à l’accès aux ressources de la cible.
• Le deuxième VI initialise le module SPI 0
• Le troisième VI configure le module SPI: vitesse de communication, ordre des bits, mode de fonctionnement de l’horloge…
• Le quatrième VI écrit et lit des trames sur le bus
• Le cinquième VI ferme et détruit la référence à l’API LINX.

Il n’est pas nécessaire de fermer l’accès au module SPI.

Lancement du programme

Pour exécuter le programme, il y a deux méthode:

• En source
• En exécutable

La première solution est à privilégier pour la phase de développement. Il suffit simplement de cliquer sur la flèche d’exécution. LabVIEW compile le programme, le télécharge sur la cible et connecte la face avant restée sur le PC sur le Run-Time de la cible. Ainsi, on peut interagir avec le programme, utiliser les outils de debug usuels (sondes, loupiote, points d’arrêts…).

Cette solution est très pratique, mais gourmande en ressources sur la cible. En effet, une communication réseau permanente est établie entre la cible et le PC. en outre, le programme ne peut être lancé qu’à partir de LabVIEW. Cela signifie qu’il faut rouvrir les sources du programme, compiler, télécharger et exécuter celui-ci à partir de LabVIEW à chaque mise sous tension de la cible.

Conclusion

LINX 3.0 représente une petite révolution dans le monde National Instruments. Il devient en effet possible pour tout un chacun de développer une application embarquée avec LabVIEW pour un budget accessible. En effet, la licence Home Bundle est à 50€ et les Raspberry Pi oscillent entre 30 et 40€. Tout le monde a désormais accès à l’ergonomie du langage G et à la puissance de l’environnement LabVIEW.

A bientôt pour de plus amples informations sur le déploiement d’une application LabVIEW sur le Raspberry Pi.

Lancez-vous !

[EDIT du 03/12/2017] – Problème lié au déploiement de LINX sur le Raspberry Pi

Lors de l’installation du LINX sur un Raspberry Pi, il se peut que l’une des étapes ne se déroule pas complètement, probablement à cause de certains droits d’accès qui auraient changés dans la dernière version de Raspbian (Stretch au moment où j’écris ces lignes).

Le symptôme est le suivant: au déploiement d’un programme faisant appel à la bibliothèque LINX, un message d’erreur survient:

« LMH-LINX.lvlib:Local IO.lvlib:Load Device Channels.vi loaded with errors on the target and was closed. »

La cause probable est la suivante :

LINX installe une bibliothèque sur le Raspberry Pi : /usr/lib/liblinxdevice_rpi2.so

Cependant, pour assurer la compatibilité avec les BeagleBone Black, une deuxième bibliothèque est installée : /usr/lib/liblinxdevice_bbb.so

Le choix de la bonne bibliothèque est fait grâce à la création d’un lien symbolique: liblinxdevice.so -> ./liblinxdevice_rpi2.so. La coutume est courante sous Linux, mais dans notre cas précis le lien peut ne pas exister.

Pour s’assurer de la bonne installation de la bibliothèque, commencez par ouvrir un terminal SSH (soit dit en passant, Windows 10 est nativement doté d’un shell Linux…).

Ouvrir ensuite un accès à l’environnement chroot d’exécution LabVIEW: $ sudo schroot --run-session -c lv

Naviguer dans le dossier /usr/lib : # cd /usr/lib

Lister le contenu du dossier : # ls -l | grep linx

S’il n’y a que deux fichiers (le bbb et le rpi2), le problème de déploient du code viens de là.

Pour corriger le problème, il suffit de recréer le lien symbolique : # ln -s ./liblinxdevice_rpi2.so ./liblinxdevice.so

J’ai trouvé cette solution en parcourant le forum LabVIEW MakerHub (page d’origine). Nous la devons à Kryptman. Je me suis contenté de la tester et de la traduire en Français. Merci à lui.

Cet article LINX 3.0 – Ou comment programmer un Raspberry Pi avec LabVIEW est apparu en premier sur Electronique et Informatique.

Pour communiquer sur les entrées/sorties standards d’un PC, LabVIEW utilise un ensemble de librairies nommées VISA. Pour rendre compatible notre interface avec VISA, il faut un driver spécifique. Heureusement pour nous, National Instrument à tout prévu! LabVIEW fournit ainsi une interface graphique pour générer ce driver.

Voici la procédure à suivre pour générer le Driver:

1. Lancer le programme National Instrument -> VISA -> Driver Wizard
2. Choisir le bus USB
3. Choisir son interface dans la liste
4. Nommer son driver
5. Et finalement l’installer
6. Votre interface doit apparaître dans la catégorie NI-VISA USB Device

Une fois le driver installé, vous êtes opérationnel. Entrons maintenant dans le vif du sujet.
Voici les différentes étapes d’une communication HID:

• Lister les interfaces (évite les désagréments liés aux changements de nom de l’interface)
• Ouvrir la liaison
• Activer les évènements (ou interruptions, permet de recevoir des données)
• Envoyer des données
• Recevoir des données

Particularité depuis Windows 8

Depuis Windows 8, Microsoft a décidé de restreindre l’installation des drivers de périphériques aux drivers signés numériquement. Concrètement, il devient impossible d’installer un pilote sans que celui-ci soit avalisé par Microsoft. C’est le cas du pilote généré par le Driver Wizard.

Pour installer le pilote généré, il faut au préalable désactiver la vérification des signatures de pilotes.

Voici un tutoriel qui explique comment le faire:

Installer un pilote non signé sous Windows 8 et 8.1

Cette manipulation est également valable avec Windows 10.

Cet article Communication entre LabVIEW et L’interface HID est apparu en premier sur Electronique et Informatique.