71 réponses à ce sujet

[R2D21995]

Alors grâce aux fichiers de telson qui m'ont énormément aidé à comprendre comment tout ça fonctionne.(merci à toi Telson). J'ai réussi à faire les jambes (il n'y a que le côté gauche pour l'instant qui a des contraintes) mais il y a un petit écart entre le bassin et la hanche même si tout reste en place. Donc aujourd'hui ma priorité sera de régler ça. Bien sûr Telson. Tu connais git ??
PS:j'espère que tu ne le prends pas mal si je n'utilise pas tes fichers. Mon but est d'être capable de faire mes propres projets et de comprendre comment ça fonctionne.

[Telson]

Il n'y à pas de problème!

 

GIT??? non ???

 

 

Ah ok :::::::::: https://openclassroo...source-avec-git

[R2D21995]

Voilà il est installé de base sur Linux et tu peux le télécharger sur Windows.
C'est ce que j'utilise quand je partage quelque chose. C'est facile et si jamais tu fais un git par erreur tu peux revenir en arrière (sous conditions de se rappeller du nom du push. ça m'ai arrivé une fois et je suis revenu en arrière. Tu fais un script pour automatiser tout ça tu peux aussi n'autoriser que certaines personnes et chaque personne ce connecte avec son user et son mot de passe

[maximusk]

Voilà il est installé de base sur Linux et tu peux le télécharger sur Windows.
C'est ce que j'utilise quand je partage quelque chose. C'est facile et si jamais tu fais un git par erreur tu peux revenir en arrière (sous conditions de se rappeller du nom du push. ça m'ai arrivé une fois et je suis revenu en arrière. Tu fais un script pour automatiser tout ça tu peux aussi n'autoriser que certaines personnes et chaque personne ce connecte avec son user et son mot de passe

 

Si tu ne te rappelles pas du nom du commit pour revenir en arrière, tu as la commande "git log", qui liste les commits.

[R2D21995]

Merci pour la précision.

[Bobox]

Et 'gitk' pour une vue graphique de l'historique de tes commits.

[R2D21995]

Décidément c'est plus compliqué que prévu de modéliser les jambes du robot. À chaque fois les pièces finissent par voler et/où se torde

[Telson]

hummmmm si les pièces finissent par voler c'est que tu n'às pas validé une option.......Regarde bien l'exemple du robot 3 roues sur le site de Marilou c'est bien expliqué....

 

Si les pièces se tordent c'est que tu n'as pas défini un angle pour un servo .....

[R2D21995]

OK merci je vais voir.

[Telson]

Ici à la fin de la page : the robot/step2 : http://doc.anykode.com/frames.html?frmname=topic&frmfile=index.html
 
''Now, because the rigid bodies are connected Solver will no longer try to resolve any contacts / efforts between the wheels and the base. To override this behavior (which is very useful in our example), just check the property Collides with connected bodiesof rigid bodies. Collision detection system (and therefore the calculation of effort) is activated if the option is checked on two rigid bodies in contact.''
 
Pour la question des axes qui ne tiennent pas en position il faut initialiser le servomoteur avec un angle via la fonction : GoPositionDeg ou GoPositionRad

[R2D21995]

D'accord merci pour ta réponse.

[Telson]

Salut Léon,
 

Edit modération : message déplacé
Oui bien sûr, je comprends bien ta démarche en terme de programmation et comme tu l'indiques à juste titre nous n'avons pas la prétention de détenir LA solution.......
 
Mais je pense qu'en croissant nos visions nous pourrons que améliorer nos programmes.
 
D'ailleurs en parlant de programme, sur Marilou une chose qui me saoule bien c'est la déclaration des pointeurs pour les devices.
 
Dans le main il est présent la déclaration des pointeurs pour chaque servomoteur ou autres :
 

//configuration des variables servomoteurs Jambes Gauche
        DeviceServoMotor *pServoMaleolle_G=robot->QueryDeviceServoMotor("phx0/Hingecheville_G/maleolle_G/ServoMaleolle_G");

 
Le problème c'est que lorsque tu appelles une fonction, à ce moment celle-ci ne connais pas ces pointeurs puisqu'il sont en local dans main.....c'est pénible je trouve car dès que tu appelles une fonction il faut passer tous les pointeurs :
 

initialisation(pServoPivot_D, pServoHanche_D,  pServoJambe_D,  pServoGenou_D,  pServoCheville_D,  pServoMaleolle_D,  pServoPivot_G,  pServoHanche_G,  pServoJambe_G,  pServoGenou_G,  pServoCheville_G,  pServoMaleolle_G);          

 
Et la fonction appelée :

void initialisation(ModaCPP::DeviceServoMotor *pServo1, ModaCPP::DeviceServoMotor *pServo2, ModaCPP::DeviceServoMotor *pServo3, ModaCPP::DeviceServoMotor *pServo4, ModaCPP::DeviceServoMotor *pServo5, ModaCPP::DeviceServoMotor *pServo6, ModaCPP::DeviceServoMotor *pServo13, ModaCPP::DeviceServoMotor *pServo14, ModaCPP::DeviceServoMotor *pServo15, ModaCPP::DeviceServoMotor *pServo16, ModaCPP::DeviceServoMotor *pServo17, ModaCPP::DeviceServoMotor *pServo18)

C'est la subterfuge que j'ai mis en place MAIS C'EST LOURD !!!
 
Serait t'il possible de faire autrement?????
 
Merci par avance.
 
++

[Leon]

Salut Telson,

Il y a 2 solutions pour simplifier les appels à des fonctions qui utilisent de nombreux pointeurs vers actionneurs.

 

1) Déclarer tous les pointeurs vers actionneurs comme variables globales, donc globales/communes à toutes tes fonctions. Tu peux même déclarer des variables globales utilisables dans plusieurs fichiers source, si ton code source est réparti en plusieurs fichiers. En C/C++, ça se fait avec "extern".

Dans tous les cas, si tu fais ça, il faut séparer

 - la déclaration de tes pointeurs vers actionneurs :

ModaCPP::DeviceServoMotor    *s_genou_D;

Cette déclaration sera en dehors de toute fonction, dans le fichier header .h si tu en as un.

 - l'initialisation de ton pointeur

s_genou_D=pPHX->QueryDeviceServoMotor("phx0/Genou_D/a1/s_genou_D");

Cette initialisation sera par exemple dans le main().

 

2) Faire une structure dans ton code (struct) qui regroupe tous tes pointeurs vers les actionneurs. Structure déclarée une seule fois, dans le main() par exemple. Et pour passer cette structure comme argument à des fonctions, il faut alors utiliser un pointeur vers cette structure. C'est là qu'on utilise le fameux symbole "->" en C/C++ : pour désigner un membre (tes pointeurs d'actionneurs) d'une structure dont on connait le pointeur. pointeur_structure->membre_1

Les pointeurs vers structure, c'est ultra courant et ultra pratique en C/C++.

Voir ce cours très bien fait:

https://openclassroo...es-de-variables

 

Perso, pour BOB5, j'ai utilisé la première solution, que les codeur "haut niveau" qualifieront de crade, mais qui fonctionne très bien pour nos petits programmes, sans se prendre la tête.

Quand tu as un petit nombre connu à l'avance d'objets, ça se fait très bien avec des variables globales, pas besoin de s'embêter avec les allocations dynamiques et autres.

La 2ieme solution est jugée plus propre par les codeurs "haut niveau", et c'est bien de s'habituer à coder proprement.

 

Leon.

[Telson]

RHOooooooooooooooooooooooooooo Punaise, tu serais du genre féminin j'te frais de gros bisous Léon !!!

Mais !! C'est bien sûr!!!

Déclarer les pointeurs en variables globales et les initialiser dans le main !!! Yé YAaaaaaaaaaaaaaaa !!!!

Non seulement mon programme vient de s'améliorer mais il est maintenant bien plus facile à lire!!! C'est carrément génial......Ho punaise de punaise..

Merci qui ???? Merci Léon !!!

[R1D1]

RHOooooooooooooooooooooooooooo Punaise, tu serais du genre féminin j'te frais de gros bisous Léon !!!

Mais !! C'est bien sûr!!!

Déclarer les pointeurs en variables globales et les initialiser dans le main !!! Yé YAaaaaaaaaaaaaaaa !!!!

Non seulement mon programme vient de s'améliorer mais il est maintenant bien plus facile à lire!!! C'est carrément génial......Ho punaise de punaise..

Merci qui ???? Merci Léon !!!

Nooooooooooooooooooooooooooooooooooooooon !

Pas de variables globales ! Ça réduit la visibilité du code, ça créé des problèmes de masquage de variable (la variable n globale et la variable n locale), et si ton code inclue plusieurs fichiers, ça devient un enfer de maintenance pour peu que tu aies plusieurs variables globales avec le même nom. À moins d'être obligé de définir une variable comme globale (par exemple, en Arduino, le main() est caché et on n'a accès qu'aux fonctions loop et setup), il y a toujours une solution simple qui utilise la bonne portée des variables.

En passant les arguments sur lesquels tu veux que ta fonction agisse, tu rends ta fonction plus explicite et plus modulaire. Exemple :

(1)
int additionner()
{
   return a+b; // a, b sont des variables globales
}

(2)
int additionner(int a, int b)
{
    return a+b; // a, b sont les arguments
}

En général, la signature d'une fonction doit suffire pour comprendre son fonctionnement. Ça évite de devoir se plonger dans son code qui n'est pas forcément explicite.
Dans ma première fonction, la seule information que j'ai est que ma fonction me retourne un entier (probablement une somme étant donné le nom de la fonction). Mais je n'ai aucun contrôle sur la somme, je ne sais pas quand je peux invoquer ma fonction pour obtenir le résultat voulu (où alors il faut que je modifie des variables globales, mais je ne sais pas lesquelles à lecture de la fonction), et cette fonction fait l'hypothèse que les variables a et b existent globalement, ce qui réduit énormément la réutilisabilité (c'est franais ce mot ? :/) de la fonction.
Dans le deuxième cas, le contrat est clair : cette fonction me retourne la somme de deux entiers que je passe au moment où je veux l'utiliser. Je peux l'utiliser n'importe quand, du moment que je passe mes variables.

Dans ton cas, ça devient ennuyeux parce que tu as beaucoup de variables différentes. Ça vient d'un problème de conception de ces variables: elles ont toutes un nom différent, ce qui casse les possibilités d'automatisation. La solution est donc, non pas de les déclarer globalement, mais d'utiliser une structure, comme proposé par Léon. Si tu fais du C++, pas besoin de chercher loin: les conteneurs de la library standard répondent à ton problème : map, vector, etc...
Tu peux créer une std::map<std::string, ModaCPP::DeviceServoMotor*> dans ton main(), et la remplir avec les couples (std::pair en C++) <nom de l'articulation, pointeur vers l'objet de ModaCPP associé>.
Ici, pas de question d'allocation dynamique : les objets sont créés statiquement dans le main, puis tu passes leur adresse:

ModaCPP::DeviceServoMotor servoGenouDroit;
all_ze_servos.insert(std::pair<...>("genou_droit", &servoGenouDroit)); // notez le "&"

Tu peux ensuite passer simplement:

initialisation(all_ze_servos);

Avantage : si tu ajoutes des servos à ta simu, tu n'as besoin que d'insérer l'objet correspondant dans la map. La difficulté ajoutée, c'est que ton code doit être un peu plus générique, donc faire des opérations particulières à un servo est moins facile. Mais globalement, tu y gagnes pour toutes les opérations appliquées à tous les objets (les initialiser).

Bref, même pour les débutants/petits projets, ça n'est pas si difficile d'éviter les variables globales, et le gain en clarté du code vaut à mon avis les quelques minutes de réflexion supplémentaires.

[Telson]

HA ????

 

Je ne suis pas assez pointu pour comprendre ton code :

ModaCPP::DeviceServoMotor servoGenouDroit;
all_ze_servos.insert(std::pair<...>("genou_droit", &servoGenouDroit)); // notez le "&"

Qu'est ce donc que cette histoire de pair???

 

Pour piloter mes servo (12) il faut que je lès définisse et que je leurs transmette leur vitesse et leur angle ....

 

définition en global :

ModaCPP::DeviceServoMotor *pServoPivot_D;
ModaCPP::DeviceServoMotor *pServoHanche_D;
ModaCPP::DeviceServoMotor *pServoJambe_D;
ModaCPP::DeviceServoMotor *pServoGenou_D;
ModaCPP::DeviceServoMotor *pServoCheville_D;
ModaCPP::DeviceServoMotor *pServoMaleolle_D;
ModaCPP::DeviceServoMotor *pServoPivot_G;
ModaCPP::DeviceServoMotor *pServoHanche_G;
ModaCPP::DeviceServoMotor *pServoJambe_G;
ModaCPP::DeviceServoMotor *pServoGenou_G;
ModaCPP::DeviceServoMotor *pServoCheville_G;
ModaCPP::DeviceServoMotor *pServoMaleolle_G;

initialisation dans le main :

        //initialisation des variables servomoteurs Jambes Gauche
        pServoMaleolle_G=robot->QueryDeviceServoMotor("phx0/Hingecheville_G/maleolle_G/ServoMaleolle_G");
        pServoCheville_G=robot->QueryDeviceServoMotor("phx0/HingeCheville_G/cheville_G/ServoCheville_G");
        pServoGenou_G=robot->QueryDeviceServoMotor("phx0/HingeGenou_G/a1/ServoGenou_G");
        pServoJambe_G=robot->QueryDeviceServoMotor("phx0/HingeHanche_G/jambe_G/ServoJambe_G");
        pServoHanche_G=robot->QueryDeviceServoMotor("phx0/HingeHanche_G/hanche_G/ServoHanche_G");
        pServoPivot_G=robot->QueryDeviceServoMotor("phx0/HingePivot_G/a1/ServoPivot_G");
        //initialisation des variables servomoteurs Jambes Droite
        pServoMaleolle_D=robot->QueryDeviceServoMotor("phx0/HingeCheville_D/maleolle_D/ServoMaleolle_D");
        pServoCheville_D=robot->QueryDeviceServoMotor("phx0/HingeCheville_D/cheville_D/ServoCheville_D");
        pServoGenou_D=robot->QueryDeviceServoMotor("phx0/HingeGenou_D/a1/ServoGenou_D");
        pServoJambe_D=robot->QueryDeviceServoMotor("phx0/HingeHanche_D/jambe_D/ServoJambe_D");
        pServoHanche_D=robot->QueryDeviceServoMotor("phx0/HingeHanche_D/Hanche_D/ServoHanche_D");
        pServoPivot_D=robot->QueryDeviceServoMotor("phx0/HingePivot_D/a1/ServoPivot_D");

Et quand je veux envoyer les vitesses et les angles j'appelle la fonction servo :

//FONCTION MOUVEMENTS SERVOMOTEURS
void servo()
{
//pServoPivot_D,pServoHanche_D,  pServoJambe_D,  pServoGenou_D,  pServoCheville_D,  pServoMaleolle_D,  
//pServoPivot_G,  pServoHanche_G,  pServoJambe_G,  pServoGenou_G,  pServoCheville_G,  pServoMaleolle_G
                //FONCTIONS PASSAGE VITESSE ET ANGLE AUX SERVOMOTEURS
                ///////////////////////////////////JAMBE DROITE
                pServoPivot_D->SetEffectiveMaxVelocityDPS(Speed[1]);
                pServoHanche_D->SetEffectiveMaxVelocityDPS(Speed[2]);
                pServoJambe_D->SetEffectiveMaxVelocityDPS(Speed[3]);
                pServoGenou_D->SetEffectiveMaxVelocityDPS(Speed[4]);
                pServoCheville_D->SetEffectiveMaxVelocityDPS(Speed[5]);
                pServoMaleolle_D->SetEffectiveMaxVelocityDPS(Speed[6]);        
                ///////////////////////////////////JAMBE GAUCHE
                pServoPivot_G->SetEffectiveMaxVelocityDPS(Speed[13]);
                pServoHanche_G->SetEffectiveMaxVelocityDPS(Speed[14]);
                pServoJambe_G->SetEffectiveMaxVelocityDPS(Speed[15]);
                pServoGenou_G->SetEffectiveMaxVelocityDPS(Speed[16]);
                pServoCheville_G->SetEffectiveMaxVelocityDPS(Speed[17]);
                pServoMaleolle_G->SetEffectiveMaxVelocityDPS(Speed[18]);    
                ////PASSAGE DES ANGLES///////////////////////////
                ///////////////////////////////////JAMBE DROITE        
                pServoPivot_D->GoPositionDeg(NewAngle[1]);
                pServoHanche_D->GoPositionDeg(NewAngle[2]);
                pServoJambe_D->GoPositionDeg(-NewAngle[3]);///ATTENTION INVERSION DE SIGNE POUR LA CUISSE
                pServoGenou_D->GoPositionDeg(-NewAngle[4]);///ATTENTION INVERSION DE SIGNE POUR LE GENOU
                pServoCheville_D->GoPositionDeg(-NewAngle[5]);///ATTENTION INVERSION DE SIGNE POUR LA CHEVILLE
                pServoMaleolle_D->GoPositionDeg(NewAngle[6]);    
                ///////////////////////////////////JAMBE GAUCHE
                pServoPivot_G->GoPositionDeg(NewAngle[13]);
                pServoHanche_G->GoPositionDeg(NewAngle[14]);
                pServoJambe_G->GoPositionDeg(-NewAngle[15]);///ATTENTION INVERSION DE SIGNE POUR LA CUISSE
                pServoGenou_G->GoPositionDeg(-NewAngle[16]);///ATTENTION INVERSION DE SIGNE POUR LE GENOU
                pServoCheville_G->GoPositionDeg(-NewAngle[17]);///ATTENTION INVERSION DE SIGNE POUR LA CHEVILLE
                pServoMaleolle_G->GoPositionDeg(NewAngle[18]);

}

aie !!! aie !!! non pas les cailloux s'il vous plaît non !! non !!!! aie yeuuuuuuuuuuuu !!!!

[Leon]

Nooooooooooooooooooooooooooooooooooooooon !

Pas de variables globales ! Ça réduit la visibilité du code, ça créé des problèmes de masquage de variable (la variable n globale et la variable n locale), et si ton code inclue plusieurs fichiers, ça devient un enfer de maintenance pour peu que tu aies plusieurs variables globales avec le même nom. À moins d'être obligé de définir une variable comme globale (par exemple, en Arduino, le main() est caché et on n'a accès qu'aux fonctions loop et setup), il y a toujours une solution simple qui utilise la bonne portée des variables.

Pas vraiment d'accord avec ça.

OK, si tu fais des gros programmes bien complexes, si tu fais des trucs pro, les variables globales c'est mal.

Mais pour nos petites bidouilles, pour des petits programmes avec seulement quelques fonctions, ça passe très bien.

Et je vais même au delà: pour programmer des petits microcontrôleurs, c'est même préconisé, car ça accélère l'exécution dans certains cas.

Bref, ça n'est pas parce que des profs disent que c'est mal, que ça l'est forcément.

 

Leon.

[R1D1]

Pour std::pair, std::map, etc.., voir la référence : http://fr.cppreference.com/w/cpp/container/map(ou http://www.cplusplus.com/reference/map/map/map/ en anglais mais avec des exemples). Ce sont des conteneurs (des "tableaux de variables" évolués) de base en C++. Ils sont très pratiques pour manipuler des listes de variables plus simplement qu'en les déclarant explicitement à la main.

Je ne connais pas Anykode, mais pourquoi est-ce que tu créés un pointeur sur DeviceServoMotor plutôt que l'objet en lui même (un objet de classe DeviceServoMotor) ?

Dans tous les cas, tu peux, dans ton main():

int main(int argc, char** argv)
{
    // creation d'un container de type map pour gerer tous les pointeurs:
    std::map<std::string, ModaCPP::DeviceServoMotor *> all_servos;
    // creation d'un container de type vector pour tous les chemins(?) de servos
    std::vector<std::string> all_chemins_servos = {"phx0/Hingecheville_G/maleolle_G/ServoMaleolle_G",
                                                  "phx0/HingeCheville_G/cheville_G/ServoCheville_G",
                                                  "phx0/HingeGenou_G/a1/ServoGenou_G",
                                                  "phx0/HingeHanche_G/jambe_G/ServoJambe_G",
                                                  "phx0/HingeHanche_G/hanche_G/ServoHanche_G",
                                                  "phx0/HingePivot_G/a1/ServoPivot_G",
                                                  //initialisation des variables servomoteurs Jambes Droite
                                                  "phx0/HingeCheville_D/maleolle_D/ServoMaleolle_D",
                                                  "phx0/HingeCheville_D/cheville_D/ServoCheville_D",
                                                  "phx0/HingeGenou_D/a1/ServoGenou_D",
                                                  "phx0/HingeHanche_D/jambe_D/ServoJambe_D",
                                                  "phx0/HingeHanche_D/Hanche_D/ServoHanche_D",
                                                  "phx0/HingePivot_D/a1/ServoPivot_D"};
     // on initialise tous les servos:
     for(int i = 0 ; i < all_chemin_servos.size() ; i++)
     {
        std::string name = "servo"+std::string(i); // Ou autre nom plus explicite
        all_servos.insert(std::pair<std::string, ModaCPP:DeviceServiceMotor*>(name, robot->QueryDeviceServoMotor(all_chemin_servos.at(i))));
     }
     /*
     ou :
     initialise(&all_servos, all_chemins_servos); // la boucle precedente va dans la fonction ; on passe le pointeur du tableau à modifier sinon la fonction utilisera une copie et a priori, aucune modification ne sera faite
     */

     // Meme logique pour la commande:
     // en supposant que tes vitesses et positions sont dans Speed et NewAngle
     for(int i = 0 ; i < all_servos.size() ; i++)
     {
        all_servos.at(i)->SetEffectiveMaxVelocityDPS(Speed[i]);
        all_servos.at(i)->GoPositionDeg(NewAngle[i]);
     }
     /*
       ou un appel à une fonction qui fait pareil
     */
   
}

Le code est plus compact, extensible facilement. Qu'on soit d'accord: ça n'est pas une question de variables globales ou pas. C'est une question de nommage et d'utilisation des structures adaptées. Mais ici, il n'y a aucun intérêt à passer par des variables globales.

[R1D1]

Pas vraiment d'accord avec ça.
OK, si tu fais des gros programmes bien complexes, si tu fais des trucs pro, les variables globales c'est mal.
Mais pour nos petites bidouilles, pour des petits programmes avec seulement quelques fonctions, ça passe très bien.
Et je vais même au delà: pour programmer des petits microcontrôleurs, c'est même préconisé, car ça accélère l'exécution dans certains cas.
Bref, ça n'est pas parce que des profs disent que c'est mal, que ça l'est forcément.
 
Leon.

On ne parle pas de microcontrôleurs ici, on parle d'une simulation, non ? Ou alors, j'ai loupé un post ? Cela dit, qu'est-ce qui est optimisé dans le cas des microcontrôleurs ? Moins d'intéractions avec les registres (j'avoue que mes cours de µC datent) ?
Il ne s'agit pas d'appliquer bêtement ce que disent les profs, il s'agit de respecter des principes d'organisation pour faciliter la maintenance du code et le déboguage, et de comprendre ce qu'on fait. Le problème ici ne vient pas d'une question de portée des variables, mais de passage correct des arguments.

[Telson]

Et ben !! Je vois qu'ici comme sur la toile la question des variables globales fait débat....

 

 

@R1D1, je te remercie pour le code. C'est vraiment génial et je vais creuser l'histoire du container. La partie logique de commande est vraiment très intéressant aussi :

all_servos.at(i)->SetEffectiveMaxVelocityDPS(Speed[i]);
all_servos.at(i)->GoPositionDeg(NewAngle[i])

La possibilité d'utiliser non plus des nom complexe (pServoPivot_D, ....) mais une variable i, va aussi me faciliter les choses....

 

GROS bisous à toi aussi alors hein !!! Sur la bouche ?

 

A+