Born to be wired
733409 visites
Uptime 80 days

Articles taggés avec ‘youpi’

 Youfo : le front-end pour Youpi

 13 septembre 2011  Bricolage  3 commentaires
L'interface utilisateur de Youfo

Avec la fin de mes travaux sur le back-end du robot Youpi, sauf remontée de bugs éventuelle, j’étais arrivé à la conclusion que je pouvais enfin passer à autre chose. Mais en même temps, j’avais sous la main un back-end plutôt abouti et pas avare en possibilités, et rien d’autre pour faciliter la manipulation du robot ou l’élaboration de scripts.

Je devais me rendre à l’évidence : il fallait que je réalise rapidement un petit front-end pour que le sujet soit bouclé. Libre ensuite aux gens de l’utiliser, de l’autopsier, et de l’adapter.

J’ai voulu un front-end pour un pilotage à la souris qui soit dans la mesure du possible léger et multiplateformes. Quoi de mieux qu’un front-end client léger accessible depuis n’importe quel navigateur — N’importe quel navigateur récent, s’entend. Fuck off IE6.

C’est de cette manière qu’est né Youfo (pour YOUpi FrOnt-end), une interface web ridiculement sobre, développée en quelques heures, articulée autour du framework jQuery et communiquant avec le back-end grâce à des messages Ajax/JSONP.

L'interface utilisateur de Youfo

L’interface utilisateur de Youfo

L’interface permet de piloter chacun des moteurs en cliquant sur le bouton approprié. Pour le fun, lors d’un survol des boutons, la partie du robot concernée par le mouvement se colorise sur l’image d’à côté.

En plus de cet aspect « pilotage en temps réel », à chaque fois que la position de l’ensemble du robot est satisfaisante, un clic sur le bouton au centre de l’écran permet de récupérer la position de tous les moteurs et enrichit le script dans la zone de texte. Il est ainsi possible de copier/coller le contenu de cette zone dans un shell qui, lorsqu’il est exécuté, rejoue les positions enregistrées de manière fluide et rapide.

Si vous considérez ces explications un peu abstraites, la vidéo suivante sera peut-être plus parlante :

Au final, même si cette interface reste dépouillée et souffre parfois d’un peu de lag, elle est facilement utilisable et elle démontre surtout un des gros avantages du back-end Youba : la possibilité d’écrire et d’intégrer au projet le front-end de son choix en très peu de temps. J’invite les bidouilleurs un peu curieux à regarder le code du cœur du front-end (resources/youfo.js) qui ne dépasse pas les 150 lignes.

À partir de là, on peut aussi envisager d’autres front-ends pour un pilotage au clavier, au joystick, à la Wiimote… Les plus motivés pourront décliner le produit en version un poil plus réactive grâce à une réécriture Java ou Qt… Il y a de quoi faire : amusez-vous, faites-vous plaisir.

Dernières recommandations :

  • Youfo nécessite une version de Youba >= 1.4
  • Les deux applications se trouvent sur la page des téléchargements.

Enjoy !

 Youba : release du back-end pour robot Youpi

 8 août 2011  Bricolage  52 commentaires
Le workbench pour tester le back-end Youba

Youba Logo

Une bonne nouvelle pour ceux qui attendaient désespérément un outil pour contrôler leur robot Youpi : je me suis botté le cul ces derniers jours, j’ai pu terminer la réalisation de mon back-end, le tester avec le robot, et même apprécier le résultat en générant un scénario de mouvements pour le robot en quelques secondes !

Le nom de cette merveille : Youba (pour YOUpi BAck-end), un petit programme de 500 lignes écrit en Python. Pour rappel, ce programme a été réalisé dans le contexte suivant :

  • Indépendance du front-end : le programme se contente d’attente ses ordres sur un port TCP. Les instructions en questions peuvent être envoyées par n’importe quel front-end (un terminal, un script, une page web, un programme analysant les commandes d’un joystick, tout ce que vous voulez).
  • Bufferisation : les ordres peuvent être envoyés en temps réel ou à l’avance.
  • Portabilité : au moins dans la mesure du possible. 99% du code est indépendant de la plate forme. Les 1% restants concernent l’envoi de données sur le port parallèle, que je n’ai pas su réaliser de manière totalement portable à l’heure actuelle. Les systèmes Linux et Windows sont supportés.
Le workbench pour tester le back-end Youba

Mon plan de travail : un PC, le robot, le câble de connexion adéquat, et un objet à saisir.

Le plan de travail qui m’a permis de valider mes tests se présente comme ceci : un PC avec une distrib Linux (Linux Mint dans ce cas), le robot, le câble de connexion parallèle fabriqué lors des étapes précédentes, et le tube en plastique d’un médicament générique quelconque préalablement lesté avec des contrepoids de touches de piano (j’ai pris ce que j’avais sous la main). Sur le PC, deux terminaux sont ouverts : à gauche le programme Youba qui écoute sur son socket et à droite le terminal d’envoi des instructions par netcat.

Les résultats des tests ont été au delà de mes espérances :

  • Fonctionnellement, le back-end rempli correctement son rôle, enquille les ordres et envoie leur traduction au robot.
  • Le mouvement sur plusieurs axes en simultané est possible. Cela peut paraitre anodin mais ce n’était pas forcément évident à concevoir.
  • Les mouvements sur chaque axe sont réalisés à une vitesse plutôt raisonnable. J’avais peur que le robot soit trop lent à réagir après avoir constaté des problèmes de mise en sommeil trop longue lors des essais avec mon programme Robotest. J’ai quand même réussi à minorer ce problème en revoyant complètement la gestion des intervalles d’envoi d’octets sur le port parallèle.
  • La précision sur les axes est au rendez-vous, et la pince dispose de suffisamment de pression pour tenir des objets cylindriques.

Et enfin, l’utilisation du back-end, grâce à la commande « I!! » qui affiche l’état des compteurs de demi-pas, permet de « cartographier » les déplacements sur chaque axe de manière très précise et d’utiliser ces informations pour scripter des scénarios très rapidement, dès qu’on connait un minimum la syntaxe attendue. J’ai réalisé le mien en moins de 5 minutes, c’est celui que j’utilise dans mon terminal de droite. Voici le script utilisé pour ordonner au robot de chopper mon tube cylindrique et de le déposer quelques centimètres plus loin :

#!/bin/bash
function sendyoupi {
	echo "$1" | nc localhost 12080
}

# Positionner le bras au-dessus du tube
sendyoupi 'C!W!0,R,H,750,1|1,L,H,999,1|2,R,H,4332,1|3,L,H,7334,1|5,R,H,2000,1'
# Serrer la pince
sendyoupi 'A!W!5,L,D,80,1'
# Lever le bras
sendyoupi 'A!W!1,R,D,30,1'
# Tourner la base de 60°
sendyoupi 'A!W!0,L,D,60,1'
# Baisser le bras
sendyoupi 'A!W!1,L,D,30,1'
# Desserrer la pince
sendyoupi 'A!W!5,R,D,80,1'
# Revenir en position de départ
sendyoupi 'A!W!A,I,S,1,1'

Et le résultat du script en images :

Attention, quelques conseils pour ceux qui souhaitent utiliser Youba :

Avant tout, il y a un fichier README.txt à la racine du projet. Si je me suis cassé la tête à l’écrire, c’est qu’il contient des tas d’informations intéressantes à respecter pour que tout puisse fonctionner. Donc, lisez-le. Vérifiez en particulier que le port parallèle est activé dans le BIOS, de préférence en mode EPP, que son driver est bien chargé par le système d’exploitation, et que vous avez correctement configuré son n° d’I/O dans le fichier de configuration. Si le robot ne répond pas aux ordres donnés, lancez Robotest (disponible en page de téléchargements) pour vous assurer que la partie matérielle fonctionne à minima. D’autre part, je n’ai pas eu l’occasion de tester l’intégralité du programme avec Windows (les 50% des 1% qui ne sont pas portables), j’ai bon espoir que cela fonctionne mais on ne sait jamais. Enfin, je rappelle que je ne réponds en général pas aux questions par mail car je préfère qu’elles soient abordées en commentaires afin que tous les intéressés puissent avoir accès aux réponses.

Voila, il est maintenant temps de dévoiler où il est possible de télécharger Youba : c’est sur la page de téléchargements !

Une dernière chose : je serai content de savoir si vous utilisez ce back-end, ce que vous en pensez, quel front-end vous utilisez, et surtout si vous avez de bonnes idées quand à l’utilisation du robot Youpi.

 Backend Youpi :: documentation

 18 juillet 2010  Bricolage  12 commentaires
Diagramme de commandes

Ceux qui ont déjà fait un peu de code savent à quel point il peut être tentant de se lancer tête baissée dans un développement sans avoir pris le temps de réfléchir un minium au préalable. Et à quel point cela peut s’avérer une fausse bonne idée lorsque le développement est démarré depuis longtemps et qu’il faut reconsidérer la moitié de l’implémentation à cause d’une erreur de conception.

Pour une fois, j’ai décidé de suivre la voie de la sagesse, si l’on peut dire, en choisissant de poser avec soin les bases de la communication avec le futur backend du robot Youpi, et de ne pas commencer à coder à la hâte.

Je dévoile donc dans la suite de cet article le draft de communication frontend-backend imaginé ce week-end pendant quelques moments perdus. Il permet déjà d’avoir un bon aperçu de la manière d’implémenter ces exigences dans le code.

Pour ceux qui auraient tendance à trouver ce formatage quelque peu indigeste (et je les comprends), une version RTF avec quelques couleurs est disponible ici : Youpi backend instruction manual (RTF).

Title: Youpi backend instruction manual
Author: AlphaK - www.alphak.net
Revision: 2011-08-01
Status: Draft
.
>
> GLOSSARY
>
.
An instruction is an order for a motor to start or stop a rotation.
.
An instructionSet is a set of instructions executed simultaneously.
.
An instructionChain is a set of instructionSets executed sequentially.
.
An instructionChainModifier is a request to the backend for the modification of the current instructionChain.
.
A specialAction is a request to the backend not related to the rotation of a motor.
.
A command is a set of printable characters sent to the backend to order an instructionChainModifier or a specialAction.
.
>
> SYNOPSIS
>
.
command
(instructionChainModifier|specialAction)\n
A command contains exactly one instructionChainModifier or one specialAction, and ends with a carriage return character (byte 0x0A, symbolized with \n in this document for readability).
.
specialAction
(I|C|R)!!
A specialAction contains exactly one of the I, C, R characters and ends with a double exclamation mark.
I: Information request - Asks the backend to report for each motor the number of half-steps executed since the beginning of the program or the last half-step counter reset.
C: Counter restet - Asks the backend to reset half-step counter.
R: Re-init - Asks the backend to send the re-init instruction to the robot.
.
instructionChainModifier
[action!waitMode!]instructionSet
An instructionChainModifier contains an action, a waitMode parameter, and an instructionSet, separated by exclamation marks. action and waitMode are optional; instructionChainModifier defaults to C!W!instructionSet when not provided by the frontend.
.
action
C|A|M
An action contains exactly one of the C, A, M characters.
C: Cancel - The current and all the following instructionSet in the instructionChain are cancelled, and the instructionChain starts executing the provided instructionSet.
A: Append - The provided instructionSet is appended at the end of the instructionChain.
M: Merge - The current instructionSet in the instructionChain is merged with the provided instructionSet. Remaining instructionSets in the instructionChain are not altered. If the provided instructionSet contains instructions related to a motor for which there is no instruction in the current instructionSet, provided instructions are added to the current instructionSet. If the provided instructionSet contains instructions related to a motor for which there is already an instruction in the current instructionSet, current instructions are cancelled and replaced by provided instructions.
.
waitMode
W|N|D
A waitMode contains exactly one of the W, N, D characters.
W: Wait - Sets the instructionSet in wait mode. In that mode, the backend waits the end of all instructions of the instructionSet to consider the last is over and to execute next instructionSet. If the ordered action is M, the waitMode of the current instructionSet is replaced by the waitMode of the provided instructionSet.
N: Nowait - Sets the instructionSet in nowait mode. In that mode, the backend considers the instructionSet as over as soon as the first instruction has ended. If the ordered action is M, the waitMode of the current instructionSet is replaced by the waitMode of the provided instructionSet.
D: Default - If the ordered action is C or A, waitMode D defaults to W. If the ordered action is M, waitMode D does not modify the waitMode of the current instructionSet.
.
instructionSet
instruction[|instruction...]
An instructionSet contains one or more instructions. Each instruction is separated by a pipe character. If an instructionSet contains several instructions related to the same motor, the instructionSet is considered invalid.
.
instruction
motor,rotation,unit,value,period
An instruction contains exactly 5 parameters given in an invariable order and separated by a comma.
.
motor
0|1|2|3|4|5|A
A motor contains exactly one of the 0, 1, 2, 3 4, 5, A characters. The provided character is related to a motor of the robot.
0: Base motor
1: Shoulder motor
2: Elbow motor
3: Wrist motor
4: Hand motor
5: Plier motor
A: All motors
.
rotation
L|R|N|I
A rotation contains exactly one of the L, R, N, I characters. The provided character is related to a rotation order.
L: Left rotation
R: Right rotation
N: No operation. Asks the motor to stop.
I: Back to Initial state, order motors to rotate back to their initial position according to motor counters. USE WITH CAUTION!
.
unit
H|D|S|U
A unit contains exactly one of the H, D, T, U characters. The provided character is related to a unit order. If rotation is I, unit must be U.
H: Half-step - Provided value represents half-steps, or steps for plier motor.
D: Degrees - Provided value represents degrees. Not relevant for plier motor.
S: Seconds - Provided value represents seconds.
U: Unlimited - Ordered rotation has no limit. USE WITH CAUTION!
.
value
Float value, greater or equal than zero. Decimal separator is a dot '.'.
The value is provided according to the provided unit. If unit is U, value must be 0. As there is no physical or logical limits on the robot to ensure the motor does not exceed the maximum rotation angle, the frontend must ensure that provided values and unit will not damage the robot.
.
period
Float value, greater or equal than one. Decimal separator is a dot '.'.
The period affects the rotation speed for each motor. Default period is 1 and represents the maximum motor speed. The provided period is proportional to the interval of low-level orders sent to the same motor. For instance a provided period of 2 will make the motor rotate twice as slow as the maximum speed.
.
>
> EXAMPLES
>
.
Cancel all orders and asks the base motor to rotate left over 40° at maximum speed:
C!W!0,L,D,40,1\n
.
Appends the order for the shoulder motor to rotate right during 5.2 seconds with 1/3 of maximum speed:
A!W!1,R,S,5.2,3\n
.
Immediately cancel all orders, asks all motors to stop for an unlimited duration:
C!W!A,N,U,0,1\n
.
Cancel all orders and asks elbow and wrist motors to rotate simultaneously 150 half-steps each:
C!W!2,R,H,150,1|3,L,H,150,1\n
.
Adds the order for the base motor to rotate 600 half-steps at half speed meanwhile other motors are already rotating:
M!D!0,L,H,600,2\n
.
Puts back base motor into initial position at 1/4 speed:
C!W!0,I,U,0,4\n
.

Quelques explications supplémentaires en plus du pavé ci-dessus :

Le backend s’attend à recevoir une commande par ligne. Une commande permet de mettre en mouvement ou arrêter un seul ou plusieurs moteurs. Grâce aux différents en-têtes des instructionChainModifiers, le robot sera pilotable en mode temps réel (interactions directes avec l’utilisateur via le frontend), ou scripté (une floppée de commandes fournie au démarrage ou graduellement, et le robot exécute le tout). J’ai également prévu un léger reporting afin que l’utilisateur puisse connaitre la position de chaque moteur depuis une origine et ainsi établir plus facilement ses commandes si un pilotage scripté est désiré.

Le diagramme suivant permet d’avoir un meilleur aperçu des possibilités théoriques du backend. Chaque ligne correspond à un moteur. En abscisses, le temps. Chaque subdivision correspond à une seconde. Une barre horizontale bleue située sur une ligne indique la rotation du moteur correspondant. En bleu figurent également les commandes, ainsi que le moment où elles sont envoyées au backend. Les instructionSets qui composent l’instructionChain sont encadrés en rouge.

Diagramme de commandes

Diagramme de commandes

Voila l’état d’avancement actuel. Il s’agit de ce que je considère actuellement comme un ensemble « idéal » de fonctionnalités. Ces exigences sont encore à l’état de draft et pourront évoluer dans le futur en fonction des différents commentaires et remarques. Pour ce qui est de l’implémentation, j’imagine que ça se fera par étapes en fonctions des priorités.

 Youpi, me revoila !

 17 juillet 2010  Bricolage  2 commentaires
Diagrame d'interaction entre composants

Après un temps d’attente assez long, et une remarque d’un certain Jérémie s’étonnant du manque de nouveau contenu ces dernières semaines, je reprends mon courage et tente désespérément un nouveau départ sur tous mes projets farfelus ainsi que leur narration sur la toile 2.0.

Ces derniers temps, je me suis légèrement intéressé à la création d’un backend générique pour contrôler le robot Youpi. Ceux qui ont manqué les épisodes précédents au sujet de ce robot peuvent toujours les retrouver ici.

J’exposerai dans cet article et les suivants le résultat de mes réflexions encore légèrement inachevées, qui constitueront par la même occasion un draft de documentation pour ceux qui souhaiteraient l’utiliser et/ou créer les frontends adéquats.

Le but de l’opération est le suivant :

  • Développement d’un backend utilisé comme point d’interface unique avec le robot, acceptant des instructions génériques de haut niveau, capable de les interpréter et de les régurgiter en instructions de bas niveau pour le robot.
  • Sur ce backend pourront se greffer divers frontends faisant le lien avec l’utilisateur, qui pourront être développés par n’importe qui en fonction des besoins. Ces frontends auront pour but de saisir les commandes de l’utilisateur par divers moyens (clavier, joystick, interface web), de les convertir en instructions de haut niveau et de les envoyer au backend.

Je résume donc ce but avec le diagramme suivant :

Diagramme d'interaction entre composants

Diagramme d'interaction entre composants

Dans la suite de cet article, je me concentrerai sur le backend, les différents frontends pouvant être développés à loisir en fonction des besoins. Ma réflexion m’a mené aux exigences et conséquences suivantes :

  • Le backend doit être écrit dans un langage portable, lisible, et disposant d’un nombre conséquent de modules ou bibliothèques afin de faciliter la tâche du développeur → je choisis Python.
  • Le backend doit pouvoir communiquer facilement avec les frontends, accepter leurs instructions mais aussi leur fournir un retour → je choisis la communication par sockets.
  • Le backend doit accepter des commandes de haut niveau, offrant le plus de souplesse possible aux frontends, au format texte de façons à pouvoir être lues par un humain → je m’oriente vers une syntaxe simple permettant à la fois l’enchainement et la parallélisation de commandes.

Cette syntaxe est encore en cours de conception à l’heure actuelle, elle fera l’objet d’un prochain article.

 Youpi, testons les moteurs !

 30 décembre 2009  Bricolage  20 commentaires
robot-youpi-T-formula

J’avais longuement expliqué dans cet article les étapes de fabrication d’un câble parallèle pour relier le robot Youpi à un PC standard.

Aujourd’hui je vais comme promis diffuser les quelques lignes de code permettant de tester l’ensemble des moteurs. Le programme est grandement inspiré de celui que l’on peut trouver sur le site du BTS-IRIS de Niort.

C’est un programme développé à la va-vite en C. Il pourra servir de base pour tous ceux qui comme moi souhaitent vérifier que tous les moteurs sont en bon état de fonctionnement. (suite…)

 On a retrouvé le prototype du T-800 !

 30 mai 2009  Bricolage  59 commentaires
Le genre d'appareil pas très commun dans les chaumières, sauf peut-être chez le Dr Emmett Brown

Alors qu’il arpentait le bric-à-brac incommensurable de son fournisseur de breloques habituel, dont je tairai le nom, mon père était désappointé. Il n’avait pas encore trouvé de gadget inutile et encombrant à acheter ce jour là.

Soudain il tomba nez à nez (ou plutôt nez à bras) avec deux massives armatures articulées, et terminées par une pince.
_ « Fichtre, se dit-il, ça ne vaut pas une armoire normande ou une borne Jeutel de 150 kg, mais on va faire avec. »
C’est comme ceci que le garage de mes parents se trouva investi par deux bras mécaniques articulés, pour le plus grand bonheur de toute la famille qui aime bien voir débarquer des objets hétéroclites dans la maison.

Le genre d'appareil pas très commun dans les chaumières, sauf peut-être chez le Dr Emmett Brown

Le genre d’appareil pas très commun dans les chaumières, sauf peut-être chez le Dr Emmett Brown

Dès que j’ai découvert ces objets merveilleux dans le garage de mes parents, je n’ai pas pu m’empêcher de me poser mille questions. Est-ce que ça fonctionne encore ? Avec quoi ça s’interface ? Comment le tester ? Qu’est-ce qu’on va pouvoir faire de marrant avec ? Et ainsi une longue quête commença.

Vue sous différents angles

Vue sous différents angles

Les machines sont estampillées « YOUPI – JD PRODUCTIQUE« . Je me mis immédiatement en quête d’informations.

Ma première conclusion fut la suivante : j’avais en face de moi le tout premier prototype du T-800. Ce robot a hérité d’un nom de code à consonance enfantine « Youpi » pour ne pas éveiller les soupçons sur ses capacités meurtrières inégalées. La société JD Productique n’est autre qu’une filiale française de Cyberdyne Systems. Mais cette hypothèse n’a pas tenu très longtemps, car la machine ne présentait aucune trace de BIOS bootant sur le réseau Skynet :p

La ressemblance est frappante. Ou pas.

La ressemblance est frappante. Ou pas.

Mes recherches suivantes, effectuées en n’étant pas sous l’emprise de la drogue, révélèrent que le robot Youpi est un formidable outil vendu principalement à des fins d’apprentissage, possédant 6 moteurs de grande précision, 5 degrés de liberté, et pilotable par le port parallèle. Je passe le détail sur les specs, elles sont disponibles ici.

Je m’attelle donc à tester rapidement le fonctionnement des robots. En vrac, il faut :

  • Nettoyer les composants, dégripper les engrenages et retendre les courroies.
  • Mettre à disposition un PC pour la partie software.
  • Construire un câble pour interconnecter les deux équipements.
Les éléments assurant la transmission ont subi les affres du temps et de la poussière

Les éléments assurant la transmission ont subi les affres du temps et de la poussière

Je décide de remettre à plus tard les tâches de nettoyage et passe directement à l’étape informatique. Je sélectionne parmi les machines entassées dans le garage quelques candidats pour le pilotage du bras mécanique. Le vainqueur est un foudre de guerre qui m’a été donné par Ben (merci à lui), jugez plutôt :

  • Processeur Pentium 233
  • Mémoire 64 Mo EDO
  • Disque dur IDE 850 Mo

Oui, ça fait rire, à l’époque du Phenom III et du Core i7, mais c’est dans les vieux pots qu’on fait les meilleures soupes. Et puis on est toujours content d’avoir du vieux matos sous la main pour ce type de bricolage.

Duel de titans

Duel de titans

J’installe une Debian sur le poste. La copie des fichiers lors de l’installation prend loooooooooooooooooongtemps. Pas parce que c’est du Debian hein, parce qu’on est sur du très vieux matos pas du tout optimisé. Comme dirait Indiana Jones, « sa place est dans un musée ! ».

Installation de Debian sur l'antiquité

Installation de Debian sur l’antiquité

Pendant ce temps, je fouille dans les tiroirs pour en extraire un câble de liaison parallèle DB-25 à sacrifier. J’enlève sa coque de protection, repère et note les codes couleur des fils électriques.

09_dsc03375

25 fils à répertorier et à réorganiser, en avant la musique

Les correspondances couleurs/broches sont notées à l’arrache sur des feuilles volantes, comme d’habitude. Le brochage à utiliser est fourni dans la documentation du Youpi (page 22 pour les fainéants).

Mes notes de travail, toujours aussi soignées...

Mes notes de travail, toujours aussi soignées…

C’est ensuite parti pour la grande étape de soudure. Avec les moyens du bord. On dit toujours qu’il faut de bons outils pour bien travailler, et c’est vrai. J’avais à ma disposition un fer à la panne gigantesque, reposant dans une enclume faute de support plus approprié, avec le câble d’alim grossièrement rafistolé. Attention cher lecteur, chère lectrice, laisser reposer un fer à souder panne en haut est dangereux, ce câble et mes mains peuvent en témoigner. Inexorablement, avec un matériel pareil, pour mes soudures, j’ai fait du travail de cochon.

Plan de travail avec les moyens du bord

Plan de travail avec les moyens du bord

Note pour plus tard : idée de cadeau pour la fête des pères, un fer à souder à panne fine et un support de fer.

Connecteurs DB-25 après intervention

Connecteurs DB-25 après intervention

Une fois le travail de soudure terminé, on peut couper les fils restants ou les laisser dans le vide, l’important étant qu’ils ne créent pas de contact supplémentaire. On peut ensuite rajouter les capots en plastique.

Connecteurs DB-25 finalisés

Connecteurs DB-25 finalisés

On peut donc repartir sur le PC. Une fois le système installé, il faut juste ajouter quelques packages en fonction du langage de programmation choisi. J’ai orienté ma démarche vers le C car j’avait quelques exemples de programmation du Youpi en C sous la main. J’ai donc installé à minima les packages gcc, make, et leurs dépendances. Mais rien n’interdit d’utiliser Python, Perl, ou Microsoft Virtual Cobol 2009 Professionnal Edition si vous le trouvez. La partie backend du programme doit juste se contenter d’envoyer des octets sur le port parallèle de la machine.

Un morceau du programme à l'écran

Un morceau du programme à l’écran

Les premiers tests sont fructueux, les moteurs sont actionnés et le bras se met en mouvement. Dans la foulée je réalise une routine qui teste la rotation de tous les moteurs dans les deux sens.

C’est assez lent pour le moment, il y a des petits blocages par endroits, mais ça fonctionne bien dans l’ensemble. Un nettoyage (eh oui, l’étape volontairement oubliée) du robot de fond en comble devrait améliorer la situation.

Le second bras articulé a donné de moins bons résultats. Tous les moteurs ne fonctionnent pas. Selon les options, il finira peut-être en pièces détachées.

En ce qui concerne le frontend, rien n’a encore été développé. On peut imaginer en vrac un pilotage au clavier, au joystick, à la webcam, ou une routine totalement automatisée.

Il reste encore une question en suspens : quelle application vais-je pouvoir tirer de tout ce bazar, maintenant qu’il fonctionne à peu près ?

En plus il va falloir être original, en général ça existe déjà. Je me donne un délai de quelques mois pour y réfléchir et trouver une idée sympa. Cher lecteur, chère lectrice, toi qui es tombé sur cet article par hasard, tes idées m’intéressent.
Autres liens sur le même sujet :
Le site d’Edouard Forler
Le site du BTS-IRIS de Niort

Mise à jour du 09/12/2009 :

Vous avez été plusieurs à me contacter via le formulaire disponible sur ce site pour des demandes d’aide ou d’avis. Je suis disposé à vous aider, mais au lieu de me contacter directement, merci de poser vos questions en commentaire de cet article. Ainsi vos questions seront capitalisées et profiteront à la petite communauté de personnes qui utilisent un robot Youpi, et cela évitera que plusieurs personnes me posent la même question.