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.

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.

Dans la mouvance des single-board computers tels que Raspberry Pi et autres Beagle Boards, le LattePanda va essayer de se tailler une place.

Commençons par planter le décor

Un single-board computer – ordinateur mono-carte en français – est une carte électronique de petite taille (similaire à un disque dur 2.5′ pouces) qui embarque l’intégralité des composants traditionnels d’un ordinateur:

• Processeur (CPU)
• Processeur graphique (GPU)
• Mémoire vive (RAM)
• Stockage de masse
• Connectique et interfaces (USB, Ethernet, WiFi, Bluetooth, …)
• Alimentation

Cette prouesse d’intégration et de miniaturisation a été rendue possible par l’arrivée sur le marchés de nouveaux composants: les SoC (System on Chip). Un SoC est ni plus ni moins qu’un gros composant électronique multifonction: il intègre la plupart des fonctionnalités énumérées ci-dessus dans le même morceaux de silicium. Vous les trouverez un peu partout: ils animent la quasi totalité des téléphones portables.

Les concepteurs des différentes cartes sbComputer (single-board computer) n’ont alors « plus qu’à » conditionner le SoC avec les circuits d’alimentation, d’horloge, d’interface, … en respectant la fiche technique du fabricant.

Entrons dans le détail

Les premières cartes disponibles sur le marché, et encore de nombreuses aujourd’hui, étaient issues du monde libre: Les schémas sont disponibles gratuitement, le système d’exploitation est basé sur Linux, le processeur est un ARM. Ces paramètres se retrouvent sur la majorités des cartes existantes, du petit Raspberry Pi au volumineux Olinuxino A20 en passant par des versions plus spécifiques comme la Red Pitaya ou des systèmes professionnels comme les cRIO/sbRIO de National Instruments dédiés pour la mesure et le pilotage en milieu industriel. Ces derniers ne sont pas Open Sources mais découlent directement des travaux menés par le projet Yocto. Même l’Arduino s’y met avec sa version Yún.

Le concept est très intéressant et le facteur de forme de ces systèmes les rendent très attrayant pour les bidouilleurs. Cependant, leur limitations sont assez nombreuses: l’architecture ARM n’est pas très performante et restreint assez fortement le panel de logiciels disponibles, les distributions Linux peuvent s’avérer assez obscures à utiliser, les GPIOs (entrée/sorties à usage général) disponibles sur les cartes sont souvent directement issues de l’ARM ce qui rend le système assez chatouilleux aux perturbations extérieurs.

Le LattePanda: 4 cores, 4 Go de RAM et un Windows 10 !

Là où le LattePanda fait très fort, c’est sur l’architecture: processeur Intel Atom quatre cores, une version 64 bits disponible avec 4Go de RAM et 64Go de stockage de masse et un arduino léonardo en prime ! Une version 32 bits est également disponible (2Go de RAM et 32Go de stockage de masse).

Intel Atom x5 Z8300 = Processeur x86 + GPU Intel HD, autant dire que la plateforme est efficace.

Pour la connectique, on a le droit à:

• 1 port USB 3.0
• 2 ports USB 2.0
• 1 port HDMI
• 1 Ethernet Gigabit
• 1 slot micro SD
• 2 connecteurs pour l’écran tactile
• 6 connecteurs 3 point offrant chacun une broche de l’arduino et une alimentation 5Vdc
• 1 connecteur HE10 pour l’arduino
• 1 connecteur pour le SPI de l’arduino
• 1 connecteur pour 3 I2C et un UART de l’Intel Atom

Mise en route

Pour démarrer un LattePanda, il faut commencer par l’alimenter. Il lui faut du 5Vdc sous au moins 2A.

ATTENTION: Le LattePanda est particulièrement sensible au niveau de l’alimentation: une tension instable, un courant trop faible ou même simplement un câble de mauvaise qualité pourront facilement le faire planter en cours de route… Pour ma part, j’ai opté pour un pack de batteries Li-Ion 9Ah vendu par Décathlon. Il me donne environ 4H d’autonomie et assure une tension d’alimentation suffisamment propre pour le LattePanda. Son facteur de forme est également très intéressant.

A la mise sous tension, une LED rouge s’allume indiquant l’initialisation de la carte. Il faut attendre son extinction pour enfin pouvoir démarrer la bête par un appuie long sur le bouton « POWER ».

Windows 10 démarre tranquillement (surtout la première fois)… ou pas! Pour ma part, sur deux cartes, une s’est lamentablement plantée au premier boot. Pour les cas d’urgence, voir la section restauration du système de la doc en ligne. On y trouve un tas d’informations pertinentes et les images de restauration du système (une en 32 bits et une en 64 bits).

Je vous épargne le laïus sur le premier démarrage de Windows, la procédure est classique et le net fourmille de tutos adaptés (par exemple: https://www.justegeek.fr/premier-demarrage-sous-windows-10/).

L’emballage

Il est possible d’acheter un boitier avec votre LattePanda. A l’heure actuelle, deux boitiers officiels existent. Il s’agit de deux déclinaisons du même boitier, l’une en contreplaqué, l’autre en acrylique. Ayant eu des déboires avec l’acrylique sur un Raspberry Pi, je me suis orienté sur le contre-plaqué (le meilleur conducteur thermique du monde 😀 !!!).

Amateurs de casses-têtes, bienvenue ! L’assemblage du boitier tiens plus du jeu de construction qu’autre chose. Et la notice est digne d’un meuble Ikéa… Le résultat est robuste et fonctionnel.

[metaslider id=555]

Tout y est: le déport des boutons, le déport des LED avec des guides optiques, les fentes d’accès aux connecteurs, l’aération, … Le seule reproche à faire concerne l’intégration de l’écran tactile; il n’y en a aucune! Et les nappes de connexion de la dalle LCD sont TRÈS fragiles. Une solution est à l’étude…

Comparatif

Cet article ne serait pas complet sans le sempiternel comparatif entre les différents produits du marché. Je simplement en choir quelques-unes et mettre en regard leurs points forts.

Agrandir le tableau

Cet article LattePanda – Première mise en route est apparu en premier sur Electronique et Informatique.

Commencez par créer un nouveau projet pour PIC18F4550, en fixant la fréquence de l’horloge du PIC (pas la fréquence de résonance du quartz, mais la fréquence en sortie de PLL fournie par le tableau ci-après).

Ensuite, il faut configurer le comportement du PIC en remplissant ses fusibles. Les fusibles sont différents registres du PIC qui fixent le type d’oscillateur, la vitesse de l’horloge interne, l’état du watchdog…
Pour ce faire, MikroC fournit une interface graphique qui simplifie la configuration du PIC (Project -> Edit Project). Pour que l’interface HID fonctionne correctement, il faut respecter quelques règles:

• Activer le régulateur de tension USB
• Assurer une fréquence d’horloge de 4MHz en sortie de la PLL
• Utiliser la sortie de la PLL comme horloge USB
• Activer le Master Clear (MCLR) => permet d’effectuer un RESET de la carte avec le bouton poussoir

Voici un extrait de ma configuration pour une horloge externe à 20MHz (quartz):

Pour la configuration du circuit d’horloge, il est important de respecter le tableau suivant (extrait du Datasheet du PIC18f4550, Section 2-3-2):

Ensuite, il faut configurer les ports d’entrées/sorties du PIC: les lignes D- et D+ (RC4 et RC5) doivent être placées en entrées pour utiliser l’USB.

Enfin, MikroC fournit un ensemble de librairies facilitant la mise en place du protocole HID. Voici les étapes clés de la programmation de l’interface:

1. 1. Générer le Descripteur de l’interface:
      1. Lancer l’utilitaire HID Terminal de MikroC (Tools -> HID Terminal)
      2. Onglet Descriptor
      3. Compléter les informations propres à votre interface
      4. Enregistrer le descripteur pour MikroC dans le dossier de votre projet

1. Importer le descripteur dans votre projet: #import « USBdsc.c »
2. Initialiser le module HID: HID-Enable(&ReadBuf, &WriteBuf);
3. Pour lire des informations: while (HID_Read() == 0); ou par interruption
4. Pour écrire des informations: HID_Write();

Pour plus de détail, voir l’aide de MikroC, rubrique USB:

Pour envoyer votre programme sur l’interface; il vous faut utiliser un programmateur de PIC. J’utilise un PicKit3. Pour utiliser un programmateur Microchip, il faut installer MPlab (ou MPlabX qui est multiplateforme). Ensuite il faut importer le fichier .hex qui a été généré par MikroC et programmer le PIC avec. La procédure diffère entre MPlab et MPlabX. Avec MPlab, il suffit de faire File -> import, puis de programmer; avec MPlabX, il faut créer un nouveau projet et y importer le fichier .hex en enfin programmer le PIC.

Pour tester la communication HID, vous pouvez utiliser le HID Terminal fournit par MikroC ou bien écrire votre propre programme.
Personnellement, j’utilise LabVIEW, un environnement de programmation graphique développé par National Instrument, qui offre une grande compatibilité avec la plupart des protocoles de communications.

Voici un exemple simple de communication HID permettant de piloter la luminosité des deux LED de l’interface:

#include "USBdsc.c"
#define TAILLE_BUF 64
 
/*------------- Pilotage des LEDs en luminosité -------------*/
/*                                                           */
/* Programme écrit pour MikroC 2009,                         */
/* incompatible avec la version 2011                         */
/*                                                           */
/* Auteur: LAURENT Amaury                                    */
/* Date: 30/11/2011                                          */
/*                                                           */
/*-----------------------------------------------------------*/
 
unsigned short userRD_buffer[TAILLE_BUF];
unsigned short userWR_buffer[TAILLE_BUF];
char * pt;
char ReadBuf[TAILLE_BUF] WriteBuf[TAILLE_BUF];
int i;
 
signed int consigne1=0, consigne2=0;
unsigned char cpt=0;
 
void Vider_Buffer(char * Buffer)
{
     for (i=0;i<TAILLE_BUF;i++) Buffer[i]=0;
}
 
void interrupt()
{
    if (PIR2.USBIF == 1)
    {
    asm CALL _Hid_InterruptProc
    asm nop
    
    if(HID_Read()!=0)
        {
            pt=strstr(ReadBuf,"LED1: ");
            if (pt!=0)
            {
                consigne1=*(pt+6);
            }
 
            pt=strstr(ReadBuf,"LED2: ");
            if (pt!=0)
            {
                consigne2=*(pt+6);
            }            
 
            Vider_Buffer(ReadBuf);
            Vider_Buffer(WriteBuf);
        }
   }
}
 
void InitPIC (void)
{
    ADCON1=0x0F;
    CMCON=7;
    
    //------------- LED1 ------------
    TRISD.f0=0;
    PORTD.f0=0;
 
    //------------- LED2 ------------
    TRISD.f1=0;
    PORTD.f1=0;
 
    //------------- USB -------------
    TRISC.f4=1;  //D-
    TRISC.f5=1;  //D+
    HID_Enable(&ReadBuf,&WriteBuf);
}
 
void main()
{
 
    InitPIC();
 
    while (1)
    {
        //-------------------------------
        //------------- PWM -------------
        //-------------------------------
        
        //----------- LED 1 -------------
        portd.f0=(consigne1>cpt);
 
        //----------- LED 2 -------------
        portd.f1=(consigne2>cpt);
 
        cpt++;
    }
}

Cet article Tutoriel de programmation de l’interface HID est apparu en premier sur Electronique et Informatique.