Acquisition de données

[IstSider]

Bonsoir à tous,
Malgré l'heure tardive (et le fait que je sois nouveau sur le forum) je me lance:

Je réalise dans le cadre de mon TIPE (sorte de "TPE" version classe prépa ) une étude de l'asservissement du Segway. N'ayant pas vraiment les moyens de m'en procurer un j'ai eu la chouette idée d'en construire une maquette avec un kit de Lego Mindstorms et un capteur gyroscopique trouvé sur le net. (http://www.hitechnic.com/models)

Avant qu'on me pose la question je précise que je n'ai pas pris en compte le récepteur infrarouge dans ma maquette n'ayant pas besoin de téléguider mon robot pendant l'expérience.
Justement, je m'explique un peu à propos de l'expérience que je souhaite réaliser: le robot sera placé sur un banc d'essai (une plateforme six axes en labo de SII permettant d'imposer l'inclinaison du support via un PC) et l'idée est de récupérer les données du gyroscope pendant l'expérience afin de pouvoir les analyser et grâce à un logiciel dédié d'obtenir un modèle de la fonction de transfert du système.

Seulement voilà, le robot et le programme disponible sur le site hitechnic fonctionnent nickel mais lorsque j'injecte dans le programme original le bloc visant à acquérir les données du capteur (j'utilise comme interface la version Education du logiciel lego Mindstorms) le robot ne parvient plus à se stabiliser, et d'après ce que m'a expliqué (en anglais) le mec du support technique du site hitechnic, c'est parceque la commande d'écriture du log ralentit l'ensemble du programme. Du coup les calculs de réajustement dans la boucle d'asservissement ne se font pas assez rapidement et ne permettent plus le maintient du robot à la position verticale...
Connaissez vous un quelconque moyen d'obtenir les données du gyroscope pendant l'exécution du programme sans risquer de ralentir les calculs ?!

Voilà c'est un peu long j'espère que ça n'en découragera pas certains de lire !
Je suis ouvert à toutes les propositions (pour ma part je suis un peu à court d'idées) et j'espère que la communauté de NXTistes saura m'aider à trouver une solution à ce problème qui paralyse un peu mon travail...

Merci d'avance !

PS: petite précision, je ne connais rien à la programmation "pure et dure"

[roboleo]

Salut et bienvenue parmi nous…

J'aimerais bien voir le programme que tu as utilisé.
La version Education du NXT-G dispose d'une fonction spéciale qui permet de procéder directement au datalogging. Dans la version grand public du NXT-G, cela n'existe pas, mais par programmation on peut l'envisager.
As-tu lu le chapitre consacré à l'enregistrement ces données de mon guide NXT-G vers 2.0 Maj 1(chapitre 13 page 109 et suivantes)?
Ou voir ici:
topic3791.html

Tout dépend de la fréquence de relevé des mesures.
L'enregistrement des données se programme à l'aide d'une boucle incluant un bloc Minuteur et un bloc Attendre. Cet enregistrement se fait d'une manière particulière dans la mémoire du NXT.
Les "pauses" parasites signalées par le support technique de HiTechnic, sont exactes. Elles résultent du mode de fonctionnement du NXT qui n'écrit pas immédiatement toutes les informations en mémoire. Il attend en fait d'avoir "suffisamment" de données à écrire puis procède à l'écriture en une seule fois. Les longues pauses éventuelles du NXT résultent de l'obligation de déplacer le fichier tout entier (copie dans une nouvelle zone de mémoire) parce qu'au fur et à mesure de son grossissement il ne dispose plus assez de place.
La combinaison de l'écriture des données avec les exigences demandées au robot explique le ralentissement des calculs, donc l'impossibilité de le maintenir en équilibre.
Cela est inhérent au NXT lui-même qui, par conception, ne peut pas répondre à ton problème.

Ai-je été suffisamment clair?

[IstSider]

Oui merci à toi pour ta réponse jusque là tout est clair. Pour la version du programme que j'ai utilisé c'est la même que celle dispo sur le site de Hitechnic pour le HTway j'ai simplement ajouté le bloc de data logging sous NXT-G edu. et je me suis débarrassé de la boucle servant à la commande par infrarouge dont je n'ai pas besoin.

Donc d'après toi il n'y aurait aucune solution à mon problème ? Je peux pas baisser les bras avant d'avoir tout essayé vu que toute mon étude ou presque repose sur l'analyse de ces données

Peut-être certains pourront m'aider à comprendre la solution qu'envisage le contact du support technique de Hitechnic qui parle d'une solution faisant appel à un mon bloc appelé "1-D array" disponible à cette adresse: http://www.teamhassenplug.org/NXT/NXTGAdditions.html

Voilà une copie du mail en anglais...

Hello Raphaël,
I think the problem is that when you add the block to log the data you are slowing down the control loop to the point that in no longer can balance. The timing of the control loop is critical.  

When I developed the balance code for the HTWay I did it initially in NXC. In my debug version of this program I would log the last few seconds of data into a large memory array on the NXT and if the robot fell I would then write this array to a text file on the NXT for uploading and analysis on the PC.

I'm not sure if that is possible programming in NXT-G using just the standard blocks. The problem is that you the standard blocks don't support arrays and that when you write directly to a file, which is what I believe the data logging commands do, they are too slow to not affect the balance code.

If you want to stick to programming in NXT-G then one possibility may be to download and install a custom block that lets you read and write data to an array.  You would then collect data by writing the data to the array instead of directly to the data log file.  When you are done collecting the data to the array, you will then need to write that data into a text file that you can upload to the PC.  You can find an array block here:
http://www.teamhassenplug.org/NXT/NXTGAdditions.html

J'espère que certains pourront m'éclairer là dessus car j'ai essayé de manipuler ce bloc mais en vain je ne sais pas ou le placer dans le programme. Merci

[Skanzo]

Tu le met très simplement dans ta boucle à côté de ton bloc gyroscope. Tu le règle sur l'action "add" et tu connecte la mesure du gyroscope au plot "Value" (tu dois sortir le tiroir de plot de données).
À chaque relevé l'index s’incrémentera automatiquement et placera les mesures l'une après l'autre dans l'array.

Il faudra par contre prévoir une condition pour arrêter le fonctionnement du segway, puis programmer une boucle pour écrire les valeurs de l'array grâce au "data logging" ou "accès fichier".

[roboleo]

Je ne connaissais pas ce bloc. Je l'ai téléchargé puis installé dans ma palette "avancée".
Ce bloc "Simple Array" crée tout simplement une table numérique à 2 entrées , comportant un index et une valeur . Il permet 4 actions possibles:
initialisation (clear)
Ajout (add)
Récupère une valeur (Get)
Remplace une valeur existante (replace)
Ce bloc fournit, à l'aide des fils de données, une valeur en sortie.

Quant au gyroscope, il fournit en sortie 2 valeurs Angle et Vitesse qui sont utilisées dans le programme principal (avec d'autres MonBlocs) pour calculer la Direction et la Puissance des moteurs.
Tu as donc 2 valeurs à analyser à ta disposition. Il faudra réfléchir sur la manière de placer ces valeurs dans la table.
Par contre je ne sais ce qu'elles deviennent en fin de programme.

Ce que dit Skanzo est très clair, Il faut raccorder le plot de données Angle ou Vitesse (ou les deux?) du gyroscope au plot "value" du bloc "Simple Array".
À chaque relevé l'index s’incrémentera automatiquement et placera les mesures l'une après l'autre dans l'array.
Ce bloc est à placer entre le bloc "GetGyroData" et le bloc "GetMotorData".
Ensuite, incertitude, puisque je ne dispose pas de capteur gyroscopique pour vérifier.

Je ne sais comment se comporte SimpleArray, je présume que les data résident en RAM et que les valeurs stockées disparaissent en fin de programme.
Comme le préconise Skanzo, il faut ajouter une condition pour mettre fin au fonctionnement du segway, par exemple une durée de fonctionnement. Et avant la fin du programme principal une boucle pour récupérer les valeurs contenues dans l'Array et les enregistrer en datalogging.

@ IstSider
Du travail sur la planche, tu as 2 choses à faire:
vérifier comment se comporte le bloc "Simple Array"
Ecrire un module pour récupérer les valeurs de ce bloc et les enregistrer en datalogging après avoir stoppé ton segway, mais avant la fin du programme principal.

[Skanzo]

Ha il y a deux valeurs à relever, merci pour cette précision Roboleo
Ça complique les choses

Le SubVI du bloc "simple array" n'est pas protégé (pas comme ceux de HiTechnic et MindSensor). J'ai regardé dedans: l'array est le même à chaque exécution du programme. Pas moyen de préciser si on veut utiliser l'array 1, 2 ou 3 (comme le bloc minuteur). Il faudrait modifier pas mal de choses pour créer un bloc "multiple array" à partir de celui-là.

Mais il y a peut-être un autre moyen :
Relever successivement Angle puis Vitesse, Angle puis Vitesse, etc (ou l'inverse).
On se retrouverait avec un array un peu comme ça (faites pas gaffe aux valeurs ) :

Code: Tout sélectionner

-1- 37°
-2- 1.23m/s
-3- 44°
-4- 0.87m/s
-5- 67°
-6- 1.99m/s
etc...

Pour le retransformer à la fin du programme dans le data-logging (ou dans un fichier texte genre CSV) :

Code: Tout sélectionner

-1- 37°, 1.23m/s
-2- 44°, 0.87m/s
-3- 67°, 1.99m/s
etc...

Edit : Truc à l'arrache, je crée un "simple array bis" avec un array différent

[roboleo]

Le SubVI du bloc "simple array" n'est pas protégé (pas comme ceux de HiTechnic et MindSensor). J'ai regardé dedans: l'array est le même à chaque exécution du programme. Pas moyen de préciser si on veut utiliser l'array 1, 2 ou 3 (comme le bloc minuteur). Il faudrait modifier pas mal de choses pour créer un bloc "multiple array" à partir de celui-là.

J'ai lu que le bloc Simple Array n'est pas protégé. Il y a donc un risque de plantage.
Si l'Array est le même à chaque exécution du programme, on ne peut pas et effet, l'utiliser à plusieurs reprises (pour chaque valeurs à étudier) comme un bloc Minuteur.

Mais il y a peut-être un autre moyen :
Relever successivement Angle puis Vitesse, Angle puis Vitesse, etc (ou l'inverse).
On se retrouverait avec un array un peu comme ça (faites pas gaffe aux valeurs ) :

Code: Tout sélectionner

-1- 37°
-2- 1.23m/s
-3- 44°
-4- 0.87m/s
-5- 67°
-6- 1.99m/s
etc...

Pour le retransformer à la fin du programme dans le data-logging (ou dans un fichier texte genre CSV) :

Code: Tout sélectionner

-1- 37°, 1.23m/s
-2- 44°, 0.87m/s
-3- 67°, 1.99m/s
etc...

Edit : Truc à l'arrache, je crée un "simple array bis" avec un array différent

Ton astuce de relever par alternance Angle et Vitesse est intéressante.
Mais çà complique le programme. Il faudrait à ce moment 2 blocs "Simple Array" situés aux bons endroits, réglés sur le mode action "Add" pour enregistrer successivement les 2 valeurs, telles que tu les as présentées.
La retransformation en fin de programme passerait par un fichier texte (à l'aide de blocs "Accès aux fichiers". Les données enregistrées en mode texte (et non pas numérique) du type CSV (Comma Separated Values).
Pourquoi?
parce que pour exploiter séparément les valeurs en colonnes il faut choisir un tableur et que les fichiers du type CSV utilisent la virgule comme séparateur. Le tableur exécute automatiquement la séparation en colonnes.
(Voir mon guide de programmation NXT-G vers 2.0 maj 1, chapitre 13 ou topic3791.html).
La colonne des index (à refaire) n'étant d'aucune nécessité, elle pourrait disparaître. Il suffira de conserver l'ordre…

PS > Ton idée de créer à l'arrache un "Simple Array Bis" ne résoud pas le problème d'une manière générale. Il y aura toujours une valeur de dernier moment à ajouter… Et puis mon esprit tatillon et de rigueur mathématique trouve que çà manque d'élégance.

[Skanzo]

En disant que le bloc n'était pas protégé, je voulais dire que lorsqu'on souhaite ouvrir le SubVi avec LabView il n'y pas de mot de passe pour empêcher les gens de farfouiller le code source et éventuellement s'approprier la paternité du programme. Donc pas de plantage à l'horizon

C'est clair que c'est pas facile de séparer et concaténer convenablement nos deux valeurs. Obligé d'utiliser une variable qu'on incrémente nous-même alors qu'une boucle compteur serait plus simple.

En ayant deux arrays distincts ça facilite beaucoup plus les choses étant donné que l'index est le même pour chaque ligne du CSV.
La preuve (avec une boucle compteur) :

Quoi qu'il en soit le bloc Simple Array Bis se trouve là :
http://skanzo.free.fr/lego/SimpleArrayBis.rar

Ok Roboleo, je te l'accorde, c'est pas très classe. Mais je suis qu'un bidouilleur et je salue ton pragmatisme (sans parler de tes guides de programmation!). Ce qui me gène le plus c'est de trafiquer la réalisation d'une autre personne

ps : j'ai pas compris ce que tu voulais dire par "valeur de dernier moment à ajouter"

[IstSider]

D'abord merci beaucoup à vous deux, vos réponses m'aident énormément. J'ai donc essayer d'intégrer le bloc Simple Array dans la boucle principale comme vous me l'avez indiqué:

Comme le préconise Skanzo, il faut ajouter une condition pour mettre fin au fonctionnement du segway, par exemple une durée de fonctionnement. Et avant la fin du programme principal une boucle pour récupérer les valeurs contenues dans l'Array et les enregistrer en datalogging.

Il faudra par contre prévoir une condition pour arrêter le fonctionnement du segway, puis programmer une boucle pour écrire les valeurs de l'array grâce au "data logging" ou "accès fichier".

C'est là que je sèche un peu... J'ai bien compris la leçon n°15 où il est expliqué comment réaliser un data log avec le bloc Accès aux fichiers. Néanmoins j'ai peur de ne pas avoir tout bien compris: qu'obtient-on en "value out" du bloc Simple Array ? J'ai fait plusieurs tests sans qu'aucun ne soit fructueux. Pourriez-vous m'aider à programmer cette boucle ? Devra-t-elle se placer dans la boucle principale ou en dehors ?
Dernière question, pourquoi faut-il prévoir une condition pour arrêter le fonctionnement du segway alors que le programme original prévoit déjà l'arrêt des moteurs dès lors que la chute a été détectée ?

Merci d'avance.

[roboleo]

@ Skanzo
Bravo pour l'astuce des 2 Simple Array…!
C'est vrai que la boucle est dans ce cas d'une simplicité comme j'aime, et que la concaténation est facilitée avec le même index. Simple is beautiful!

Je ne connaissais pas les fichiers du type .rar.
J'ai donc fait l'acquisition sur App Store (Je suis sur Mac OS X) de "Rar extrator Plus" (1,59 €) et installé le bloc dans ma palette "Avancé".

Explique moi en quoi ces 2 blocs sont différents. En les examinant je constate qu'il n'y a aucune différence hormis le nom.
J'ai les mêmes scrupules que toi, je respecte trop la matière grise et je n'aime pas trafiquer le travail des autres.. Mais ici nous ne faisons pas du commerce…

Ce que je voulais dire par "une valeur de dernier moment à ajouter" c'est qu'il faut à chaque fois créer un nouveau bloc Array pour chaque nouvelle valeur à traiter que l'on découvre, comme par hasard, au dernier moment.

@ IstSider
A toi de jouer maintenant. Une grande partie du travail est accompli grâce à Skanzo. Il ne te reste plus qu'à modifier le programme de HiTechnic.


EDIT:
@ IstSider: Toasted!
Ton programme est à reprendre puisqu'il y a maintenant 2 Simple array au lieu d'un seul. Il faut également raccorder les plots du bloc GetGyroData aux 2 blocs Array correspondants.
La boucle proposée par Skenzo est à mettre à la suite dans le programme principal. C'est elle qui termine le programme.

Tant qu'il n'y a pas de chute du robot, le programme se poursuit normalement. Si l'on veut enregistrer les valeurs, il y a 2 solutions, soit le faire chuter, soit l'arrêter au bout d'un certain temps. C'est à cette 2ème éventualité que je faisait allusion.
N'oublie pas également de mettre deux blocs au début du programme, pour fermer et effacer le fichier que tu vas utiliser (pour démarrer avec une feuille propre), et pour garder seulement ces données, un troisième bloc pour fermer le fichier avant de quitter le programme (c'est une bonne habitude à prendre).
Et termine par un joli top sonore pour bien faire comprendre que l'enregistrement des données est accompli…

[IstSider]

Je remercie Skanzo pour ce qu'il a fait mais je n'en demandais même pas autant. Pour mon étude, seules les valeurs de l'angle mesuré par le gyroscope m'intéressent. J'ai pu constater que la boucle s'effectuait en exactement 11ms, à partir de là je pourrais facilement tracer un graphique "position angulaire=f(temps)" si j'arrivais à récupérer les valeurs de l'array et c'est tout ce que je demande! Le problème c'est que soit je ne sais pas manipuler le bloc Simple Array, soit ce dernier ne fonctionne pas. Je l'ai testé à maintes reprises et chaque fois j'obtiens dans le fichier .txt une suite de 0 notamment en réalisant cette boucle :



Par ailleurs, j'ai également remarqué que le simple fait d'ajouter le bloc Simple Array dans la boucle principale du programme de Hitechnic sans le modifier, et en ne le reliant à aucun autre bloc, rendait le robot instable... Je ne comprends vraiment pas comment cela est possible alors qu'aucun lien logique ne le relie à un autre élément de la boucle et qu'initialement le robot s'équilibre parfaitement avec le programme original.
Ayez un peu d'indulgence je vous en prie, n'ayant aucune connaissance en programmation et ne maniant l'interface NXT-G que depuis à peine 1 mois ce travail m'est rendu beaucoup plus difficile qu'il n'y paraît.

[roboleo]

Petite question @ Skenzo:
J'ai testé la boucle "compteur" à la suite d'un programme écrit pour la circonstance:
relever le temps écoulé d'un minuteur et le niveau lumineux du capteur de Couleurs en mode photosensible correspondant. Objectif dresser la courbe lumineuse dans le temps et en fonction d'une variation brutale de la luminosité ambiante.
Elle fonctionne parfaitement sous réserve de fixer arbitrairement le comptage à 100 (ou n'importe quelle autre valeur).

A quoi est raccordé la prise "Compteur" de la boucle? Est-ce aux plots index des blocs Simple Array? Comment procèdes-tu pour répéter exactement le nombre de boucles correspondant au dernier index?

@IstSider
As-tu pris la précaution de mettre en début de programme un bloc Simple Array "clear"?
Combien de lignes as-tu obtenu dans le fichier .txt?
Pour ce qui est du changement de comportement du robot après l'ajout du bloc Simple Array, je n'ai pas de réponse, et l'image du programme n'est pas suffisamment nette. Pose la question au support technique de HiTechnic en leur expliquant ce que tu as fait. La valeur de l'angle est peut-être à prendre ailleurs.

Mais je suis indulgent, çà ne se voit pas? Ton enthousiasme et ta précipitation te font oublier qu'apprendre, est une longue patience…


Pour tous ceux qui lirons ici:
Ne vous lancez pas dans la programmation en NXT-G pour faire des choses compliquées, si vous n'êtes pas familiarisé aux outils de programmation, si vous ne connaissez pas tous les blocs et leur modes de relation.
Et en particulier l'usage des fils de données…
Je l'ai déjà dit maintes fois, apprenez d'abord à manier les outils…

[Skanzo]

IstSider, tu n'as besoin que de la valeur angulaire? Mais alors... je sers à rien!... snif..


Plus sérieusement, je suis comme Roboleo. Je voie pas vraiment pourquoi le robot devient instable.
Cela dit, la personne de HiTechnic a précisé que "The timing of the control loop is critical". J'ai aussi relevé le bloc tempo de "0.001s" dans le programme, à quoi sert-il? Cependant la personne affirme qu'elle a réussi à relever les valeurs dans un array, mais c'était avec un NXC.
Par contre un prof m'a dit un jour "qui peut le plus, peut le moins". Avec le NXT-G on devrait donc pas avoir de problème. Bref c'est clairement flou...

Sinon le fait de mettre un bloc non-relié qui sert à rien dans une boucle consomme malgré tout du temps d’exécution. Un ordinateur, en l’occurrence notre NXT-G, fera toujours ce qu'on lui dit de faire, même si c'est 0+0 malgré que tout le monde sait que ça fait la tête à toto
Mais avec notre bloc simple array on perd trois fois rien, ça ne devrait pas être perceptible! Je comprends pas...


Vue de loin ta ligne de code semble bonne. J'imagine que la valeur angulaire est un facteur de pi? Ce qui signifie un nombre flottant.
Je sais pas trop où (je regarderai) mais à un moment on perd les décimales, 0.87 devient 0 et 1.99 devient 1. Mais alors tu n'aurais pas que des zéros mais aussi des 1, 2, 3, etc.
Surtout bien suivre les conseils de Roboleo, à savoir être ordonnée et propre quand aux accès fichiers.

Il faudrait que je télécharge ce programme, même si j'ai pas de gyro. Voir à quoi ça ressemble. Mais tout laisse penser que le programme est très regardant sur le temps d'exécution et n'autorise aucun écart, même minime
Il n'y a vraiment que la personne de HiTechnic qui pourra mieux te renseigner

[Skanzo]

IstSider, je viens de regarder le programme. Au tout début de la boucle qui maintient le robot en équilibre, il y a le bloc "CalcInterval". Ce bloc recalcule inlassablement l’intervalle de temps de chaque passage dans la boucle. L'intervalle est réutilisé dans quasiment tous les "mon bloc" de la boucle, pour obtenir la vitesse à appliquer aux roues par exemple.

J'ai une idée toute bête : place le bloc simple array tout à la fin de la boucle, comme tu l'avais fait avant, c'est à dire avec aucun plot raccordé. De cette manière les blocs tels que "DriveControl" ou "SteerControl" seront moins parasités.
Si le robot redevient stable comme avant, c'est qu'on tient le bon bout


L'angle obtenu avec le bloc "GetGyroData" est exprimé en degrés (me suis trompé ). Il semble que ce soit le simple array qui vire les décimales.
De toute façon c'est plutôt étrange d'avoir que des zéros.

[roboleo]

L'angle obtenu avec le bloc "GetGyroData" est exprimé en degrés (me suis trompé ). Il semble que ce soit le simple array qui vire les décimales.
De toute façon c'est plutôt étrange d'avoir que des zéros.

Si c'est le cas, il suffit de multiplier la valeur par 100 avant de l'inscrire dans l'Array.
Le fichier qui enregistrera cet Array sera traité en conséquence. C'est avec le tableur qu'on rectifiera l'échelle.