Commande du RobotArm (SVI-2000) par le port parrallele sous Windows XP [Résolu]

[Shuraan]

Bonjour.
Je voudrais savoir comment se servir du driver "DriverLINX Port I/O"
pour ecrire et envoyer des valeurs sur le port parallele.
(Mon projet etait de commander le bras robot "RobotArm (SVI-2000)" par le port parallele. Mais ne pouvant pas directement faire la chose [sous Win XP, il faut passer par l'intemerdiaire d'un driver], j'ai trouvé ce driver : "DriverLINX Port I/O" mais je ne sais pas l'utiliser )

Merci de me repondre rapidement ^^

[Emmanuel Delahaye]

Envoyé par Shuraan

Bonjour.
Je voudrais savoir comment se servir du driver "DriverLINX Port I/O"
pour ecrire et envoyer des valeurs sur le port parallele.
(Mon projet etait de commander le bras robot "RobotArm (SVI-2000)" par le port parallele. Mais ne pouvant pas directement faire la chose [sous Win XP, il faut passer par l'intemerdiaire d'un driver], j'ai trouvé ce driver : "DriverLINX Port I/O" mais je ne sais pas l'utiliser )

Merci de me repondre rapidement ^^

Je ne connais pas ce driver (qui sonne un peu trop 'Linux' pour fonctionner sous windows...)
Pour accéder aux ports I/O j'utilise la DLL inpout32.dll.

http://www.logix4u.net/inpout32.htm

J'ai fait un wrapper :

http://delahaye.emmanuel.free.fr/clib/pio/

[Shuraan]

Merci
Je vais essayer cette methode ^^

[Shuraan]

La methode proposée marche mais quel fonction faut-il utiliser pour rentrer une valeur sur le port ? (Laquelle est-ce dans les fonctions misent en exemple)

[Emmanuel Delahaye]

Envoyé par Shuraan

La methode proposée marche mais quel fonction faut-il utiliser pour rentrer une valeur sur le port ? (Laquelle est-ce dans les fonctions misent en exemple)

Il faut lire la valeur dans la configuration matérielle de ton système.

Démarrer > Click droit sur 'Poste de travail' > Propriétés > Matériel > Gestionnaire de périphériques > Ports COM et LPT > Sur Port Imprimante ECP (LPT1), click droit > Propriétés > Ressource > Plage d'E/S OUF !

Tu dois lire l'adresse de base.

[Shuraan]

Merci mais il se trouve qu'il y a deux ligne "Plage d'E/S".

Screenshot :


La quelle dois-je prendre ?



PS : Euh....La ligne de commande pour entrer une valeur c'est celle la ?

Code :

pio_err_e pio_outb (unsigned port, unsigned data);

[Emmanuel Delahaye]

Envoyé par Shuraan

Merci mais il se trouve qu'il y a deux ligne "Plage d'E/S".
C'est la première.

PS : Euh....La ligne de commande pour entrer une valeur c'est celle la ?

Code :

pio_err_e pio_outb (unsigned port, unsigned data);

Pour écrire dans un port, oui.

Mais attention, l'adresse de base, ici, c'est

Code :

#define PARA_BASE 0x378

ensuite, selon ce que tu veux faire il faut accéder aux différents registres

Code :

1
2
3
4
#define PARA_DATA (PARA_BASE + 0)
#define PARA_STATUS (PARA_BASE + 1)
#define PARA_CONTROL (PARA_BASE + 2)

etc.
J'espère que tu connais le port // des PC...

[Shuraan]

Ouhlala le port parallèle ^^"
Ben je connais pas grand chose dessus (En fait mon probleme c'est de savoir comment envoyer des valeurs binaires tels que chaque bit soit une sortie Dn du port (D0, D1, D2......D7)...) D'apres la fiche technique du bras robot je trouve :

_Axe 2 vers le haut : 11 01 11 11
_Axe 2 vers le bas : 11 10 11 11
_Axe 1 vers la gauche : 01 11 11 11
_Axe 1 vers la droite : 10 11 11 11
_Axe 3 vers le bas : 11 11 01 11
_Axe 3 vers le haut : 11 11 10 11
_Axe 5 ouverture : 11 11 11 01
_Axe 5 fermeture : 11 11 11 10

_11 11 11 11 : Arreter tout les mouvements

(Note : L'axe 4 [celui de la rotation de la pince] est inutilisé. {Car on ne pouvait mettre que 8 deplacements})


Docs Technique :

Doc 1 :



Doc 2 :




Ma question est la suivante :

Comment puis-je faire correspondre les bits aux sorties ? (que faut-il definir au debut du process ?)
==> Sachant que je compte commander le bras par l'intermediaire du clavier (donc il faut que mon process fasse que tout s'arrete lorsque je relache la touche si j'ai bien compris...)

[Emmanuel Delahaye]

Envoyé par Shuraan

Ouhlala le port parallèle ^^"
Ben je connais pas grand chose dessus (En fait mon probleme c'est de savoir comment envoyer des valeurs binaires tels que chaque bit soit une sortie Dn du port (D0, D1, D2......D7)...) D'apres la fiche technique du bras robot je trouve :

_Axe 2 vers le haut : 11 01 11 11
_Axe 2 vers le bas : 11 10 11 11
_Axe 1 vers la gauche : 01 11 11 11
_Axe 1 vers la droite : 10 11 11 11
_Axe 3 vers le bas : 11 11 01 11
_Axe 3 vers le haut : 11 11 10 11
_Axe 5 ouverture : 11 11 11 01
_Axe 5 fermeture : 11 11 11 10

_11 11 11 11 : Arreter tout les mouvements

Afin d'éviter du code gore avec des manipulations de bits dans tout les sens, je conseille une organisation rigoureuse du code et des données sous la forme d'un ADT suite à une analyse correcte de la spécification.

L'interessant est ceci :

Code :

1
2
3
4
5
6
7
8
9
10
11
Axe 2 vers le haut : 11 01 11 11
Axe 2 vers le bas : 11 10 11 11
Axe 1 vers la gauche : 01 11 11 11
Axe 1 vers la droite : 10 11 11 11
Axe 3 vers le bas : 11 11 01 11
Axe 3 vers le haut : 11 11 10 11
Axe 5 ouverture : 11 11 11 01
Axe 5 fermeture :  11 11 11 10

11 11 11 11 : Arreter tout les mouvements

Et on suppose qu'il s'agit du port // (data)

La matrices des commandes est donc :

Code :

1
2
3
4
5
6
axe : arret : haut : bas : gauche : droite : ouvert : ferme
1   : 1     : 0    : 0   : 1      : 1      : 0      : 0
2   : 1     : 1    : 1   : 0      : 0      : 0      : 0
3   : 1     : 1    : 1   : 0      : 0      : 0      : 0
5   : 1     : 0    : 0   : 0      : 0      : 1      : 1

Je conseille donc de fournir les fonctions suivantes :

drbt = 'driver' robot

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#ifndef H_DRBT
#define H_DRBT
/*
   Driver Robot
   interface

   drbt.h
*/

/* identification des axes */
typedef enum
{
   DRBT_AXE_1,
   DRBT_AXE_2,
   DRBT_AXE_3,
   DRBT_AXE_5,
   DRBT_AXE_NB
}
drbt_axe_e;

/* identification des commandes */
typedef enum
{
   DRBT_CDE_ARRET,
   DRBT_CDE_HAUT,
   DRBT_CDE_BAS,
   DRBT_CDE_GAUCHE,
   DRBT_CDE_DROITE,
   DRBT_CDE_OUVERT,
   DRBT_CDE_FERME,
   DRBT_CDE_NB
}
drbt_cde_e;

typedef struct drbt drbt_s;

/* constructeur / destructeur */
drbt_s *drbt_create (unsigned port);
void drbt_delete (drbt_s * self);

/* actions */

/* Commandes des axes
  E : contexte
  E : axe
  E : commande
  R : 0=OK 1=Erreur
*/
int drbt_commande (drbt_s * self, drbt_axe_e axe, drbt_cde_e cde);

/* arret (d'urgence) */
void drbt_arret (drbt_s * self);

#endif /* guard */

Pour la suite, ça commence comme ça :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
/*
   Driver Robot
   implémentation

   drbt.c
*/
#include "drbt.h"

#include <stdlib.h>

struct drbt
{
   unsigned port;
   /* ... */
};

/* constructeur / destructeur */
drbt_s *drbt_create (unsigned port)
{
   drbt_s *this = malloc (sizeof *this);
   if (this != NULL)
   {
      this->port = port;
      /* a continuer */
   }
   return this;
}

void drbt_delete (drbt_s * this)
{
   if (this != NULL)
   {
      free (this);
   }
}

/* actions */

/* Commandes des axes
  E : contexte
  E : axe
  E : commande
  R : 0=OK 1=Erreur
*/
int drbt_commande (drbt_s * this, drbt_axe_e axe, drbt_cde_e cde)
{
   static const char matrice[DRBT_AXE_NB][DRBT_CDE_NB] = {
/*     A H B G D O F */
      {1, 0, 0, 1, 1, 0, 0},    /* 1 */
      {1, 1, 1, 0, 0, 0, 0},    /* 2 */
      {1, 1, 1, 0, 0, 0, 0},    /* 3 */
      {1, 0, 0, 0, 0, 1, 1},    /* 5 */
   };

   int err = 0;
   if (this != NULL)
   {
      /* verification des parametres */
      err = axe >= DRBT_AXE_NB
         || cde >= DRBT_CDE_NB || matrice[axe][cde] != 1;

      if (!err)
      {
         /* a continuer */
      }
   }
   return err;
}

/* arret (d'urgence)
  E : contexte
*/
void drbt_arret (drbt_s * this)
{
   if (this != NULL)
   {
      /* a continuer */
   }
}

Je recommande l'usage d'une mémoire image et des opérateurs bits

http://emmanuel-delahaye.developpez..../ed/inc/bits.h

Je recommande l'implémentation de la matrice de commande (simple tableau statique interne à 2 dimensions) pour vérifier la validité du couple axe/commande...

test à l'arrache...

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h>

#include "drbt.h"

int main (void)
{
   drbt_s *my_robot = drbt_create (0x378);
   if (my_robot != NULL)
   {
      drbt_axe_e axe;
      for (axe = 0; axe < DRBT_AXE_NB; axe++)
      {
         drbt_cde_e cde;
         for (cde = 0; cde < DRBT_CDE_NB; cde++)
         {
            int err = drbt_commande (my_robot, axe, cde);

            if (!err)
            {
               printf ("OK : axe=%d cde=%d\n", (int) axe, (int) cde);
            }
         }
      }

      drbt_arret (my_robot);

      drbt_delete (my_robot);
   }
   return 0;
}

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
OK : axe=0 cde=0
OK : axe=0 cde=3
OK : axe=0 cde=4
OK : axe=1 cde=0
OK : axe=1 cde=1
OK : axe=1 cde=2
OK : axe=2 cde=0
OK : axe=2 cde=1
OK : axe=2 cde=2
OK : axe=3 cde=0
OK : axe=3 cde=5
OK : axe=3 cde=6

Press ENTER to continue.

[DaffyDuck]

Si c'est pas de la réponse complète ça...

Juste un truc au niveau matériel, tu auras peut-être à rajouter des pull-ups de 1K sur des E/S du port //.

[Emmanuel Delahaye]

Envoyé par DaffyDuck

Si c'est pas de la réponse complète ça...

Disons que c'est un bon cadre de démarrage...

[Shuraan]

Ouhlala ! En effet c'est detaillé mais ca m'a l'air compliqué tout ca..
(Alors maintenant, que dois-je faire pour faire bouger les axes ? ^^"
=> J'avais pensé a utiliser le code virtuel des touches sous la condition If

Code :

if (GetKeyState(VK_RIGHT))

Est-ce toujours faisable ?)

[Emmanuel Delahaye]

Envoyé par Shuraan

Ouhlala ! En effet c'est detaillé mais ca m'a l'air compliqué tout ca..
(Alors maintenant, que dois-je faire pour faire bouger les axes ? ^^"

Il y a un plusieurs de solutions.

Passer une commande (portable)
Utiliser le clavier en mode direct :
- non portable : texte : conio, curses,
- graphique portable sur Linux/Windows... : SDL...
Utiliser une interface graphique (souris...) Non standard, mais pourrait être portable sur Linux et Windows avec GTK+.

Tout dépend de ce que tu veux faire, tu temps à y consacrer de tes connaissances en programmation...

Code :

GetKeyState(VK_RIGHT)

m'est inconnu. Quelle bibliothèque ?

Tu devrais faire une étude préalable de ton application pour définir les entrées (interface IHM) les traitements et les sorties (actions sur le robot).
Sinon, ça va vite devenir n'importe quoi...

Le mode commande est simple à faire et il permet de créer des scripts qui contiennent les commandes et permet de réaliser des séquences de commandes automatiques. Prevoir une commande de delai...

[Shuraan]

Si le mode commande est simple, je crois que je vais aller pars la. (Pour le temps, il serait préferable pour moi que je termine avant Lundi...Mardi grand maximum.)

Pour la commande c'est une fonction de l'API Windows (J'avais pensé que ca serait plus simple de faire : "Si on appuie sur D, envoie une valeur au port [et donc bouge l'axe...Chaque touche une commande]"..)

[Emmanuel Delahaye]

Envoyé par Shuraan

Si le mode commande est simple, je crois que je vais aller pars la. (Pour le temps, il serait préferable pour moi que je termine avant Lundi...Mardi grand maximum.)

Pour la commande c'est une fonction de l'API Windows (J'avais pensé que ca serait plus simple de faire : "Si on appuie sur D, envoie une valeur au port [et donc bouge l'axe...Chaque touche une commande]"..)

Pour le mode commande, il faut faire un interpréteur de commande. Mais comme tu m'as l'air gravement débutant et paumé, je le sens mal d'ici mardi... Pourquoi un délai si court ? Tu ne connais quasiment rien en informatique et tu dois tout faire en 4 jours ? C'est n'importe quoi.

Si tu veux juste une commande par une touche de clavier, ça peut être très simple avec kbhit() et getch() de conio.

Si tu as Dev-C++, il t'es facile d'installer conio par l'installateur de DevPak. mais évidemment, ça suppose que tu connaisses un peu ton IDE... On s'improvise pas programmeur en 3 jours...