Telson

Dans le firmware il y a peut être une limite en vitesse mais le réglage de la vitesse est surtout réalisé dans la config de l'imprimante tout comme les épaisseurs de couche, les dimensions du plateau, ....

Hello,
 
C'est une très bonne carte pour piloter des servomoteurs.
 
il est tout à fait possible de ne pas passer par la carte maestro pour alimenter les servomoteurs ainsi tu peux organiser le passage des fils plus facilement mais surtout tu peux passer des tensions différentes et de forts ampèrages.
 
La carte est alors uniquement utilisée pour passer les commandes.
 
Attention toutefois à bien penser à mettre des masses communes PARTOUT !!!
 
Le premier qui arrive à faire danser Night Fever à son robot à gagner !!!


++

Hello Tout le monde!!!

 

Alors encore un fou qui se lance dans la réalisation d'un bipède !!! Héhé je déconne hein !!!

 

Alors j'ai lu rapidement les différents échanges et regardé tes premières photos.....

 

Donc si il y à déjà une chose de très bien déjà c'est que tu as commencé à fabriquer la structure de ton bipède comme il faut. C'est à dire avec de l'alu, une scie, une perceuse et de la sueur !!! ça, de mon point de vue c'est la bonne approche dans un premier temps....La CAO puis l'impression avec une I3D n'est pas une solution à mettre en œuvre de suite pour un débutant.....On pourrais en débattre mais c'est ma façon de voir maintenant.....

 

 

La structure est sobre est devrait pouvoir te permettre de commencer à obtenir des mouvements......Même si cette dernière n'est pas parfaite, c'est une bonne base pour débuter ce qui me semble le plus difficile : la programmation, l'algorithme !!! Je reviendrais sur ce point en dernier.

 

Avant d'attaquer les choses sérieuses, il faut gérer les commandes des servomoteurs.......Alors là!!! SANS AUCUNE hésitation je te recommande fortement une carte maestro 12 ou 24 servo. Pourquoi ??? Tout simplement parce que cette carte possède une interface pc qui te permettra d'étalonner parfaitement tes servo et SURTOUT de piloter directement chaque servomoteur. Tu pourras aussi vérifier, essayer, expérimenter si l'angle X pour la hanche, Y, pour le genou et Z pour la cheville te donne le mouvement attendu !!! Tu peux aussi enregistrer les mouvements que tu effectues dans un programme qui sera enregistré dans la carte maestro.....Le gain est énorme sur ta carte principale (arduino/Raspberry, ...).

 

Pour l'alimentation de l'ensemble, honnêtement, je dirais en filaire avec une bonne alimentation régulée...Tu évites la galère des batteries, des régulateurs......Cela ne devrait pas être une source de problème quand on débute...Il y en à suffisamment comme ça!!!

 

 

Enfin, LA partie ardue !! LA partie qui me semble LA partie la plus complexe....Selon son niveau, le type de mouvement que l'on souhaite atteindre et la complexité du robot.......Alors là !!! Et bien !!! Il n'y à pas vraiment de secret hein....Si tu es débutant accroche toi bien au rideau......Surtout il faut éviter de vouloir faire un bipède qui marche comme terminator.....commencer simplement..............Éviter les 12 dégrées de liberté............Ce faire la main....

 

C'est donc une première approche de ton projet que je te livre là. Bien sûr mon approche est incomplète car la réalisation d'un bipède peut vite devenir un projet complexe.....Alors il est forcément possible d'avoir, sans aucun doute, une autre approche que la mienne ...................

 

A+

PFeeeeeeeeeeeeee ça laisse rêveur une telle merveille.....

 

Un tuto !! Un tuto !! Un tuto !!

sur le site adafruit il existe une doc complète pour l'utilisation de cette carte.

 

Avec une recherche tu trouveras sur ce site des informations complémentaires sur cette carte de commande de servo.....Je peux déjà te prédire que si tu tires plus de 500 mah le régulateur de ta carte PCA le régulateur va voler. Il te faudra alimenter tes servomoteurs directement sur les pistes +/- et encore sans trop tirer en énérgie car sur la carte PCA les pistes sont étroites.....

voici un exemple de simulation sous Marilou. Ici le robot s'incline sur la droite, lève la jambe gauche, la repose et revient en position initiale....

 

 

 

J'suis un peu dég de ne pas avoir suffisamment de tps pour avancer dans la programmation mais j'avance à mon rythme.....

Hello,

 

Félicitation, tu oses te lancer c'est déjà un grand pas de réalisé.

 

Le bipède haaaa !!! Quelle belle aventure.....Je suis à l'heure actuelle sur le sujet et certes je n'ai pas sorti beaucoup de chose concluante MAIS j'ai appris énormément de chose....

 

Je ne sais pas exactement quelles sont tes compétences de départ alors il est assez difficile de donner des conseils mais si il y à une chose qui est sûr est certaine c'est que quelle que soit tes compétences en électronique, mécanique, impression 3D, conception 3D......Le nerf de la guerre c'est le programme qui va piloter ta réalisation....

 

Alors tout le monde ne sera pas d'accord avec moi et je l'entends bien mais en fonction de la qualité des mouvements souhaitée pour ta réalisation, le cœur du problème reste le programme.....

 

Au départ tu penses que ta structure va le faire, tu prends du temps pour la concevoir en 3D, tu prends tu temps pour l'imprimer et au final !! Aie, parfois ça coince à l'impression, au montage, à la résistance ......Et surtout cela peut ne facilite pas du tout les calculs, la programmation, ......

 

Mon premier conseil serait donc, de commencer par effectuer une simulation informatique...Sans non plus tomber dans l'usine à gaz si les mouvements nécessitent pas énormément de réflexion...Il ne faut pas non plus tomber dans la psychose !!

 

Bien sûr, et je le répète, cela dépend de tes compétences de départ et puis si tu aimes bien bricoler, monter démonter.....Après tout cela doit rester un plaisir en fait.

 

Le deuxième paramètre que je prendrais en compte avant de me relancer dans un projet c'est le temps que tu peux y consacrer....Bon là tout le monde me comprends je crois.

 

Enfin, le budget !! Pas besoin d'explication non plus là hein.....

 

 

Je rajouterais juste ceci pour conclure et ce par rapport à la première vidéo du message #5 il n'est pas toujours judicieux de concevoir une pièce en 3D, puis de l'imprimer pour effectuer des tests....Nous devrions parfois reprendre les bonnes vieilles habitudes de la petite plaque de plexiglas ou d'acier coupée, tordue, percée, collée, ....pour effectuer les première approches....La conception 3D plus l'impression c'est parfois long, voir très long....pour un résultat mécanique pas tjrs au rendez-vous.....

 

++

C'est sûr que c'est réalisable.....De mon côté j'avance doucement et je me suis aperçu que ma structure ne me facilitait pas du tout les calculs.....Je vais donc peaufiner ma modélisation et quand j'aurais quelque chose de propre je referai une structure complète.....

 

Je suis parti trop rapidement sur une structure sans réfléchir aux programmes qui allait piloter tout ça et sans m'assurer que j'allais être capable de générer un algo qui fasse tout les calculs....

 

Finalement, je pense qu'il est plus judicieux de réaliser une petite modélisation pour s'assurer que le programme pilotera correctement les membres du robot et ensuite passer à la réalisation de la structure.....

Question 1 : où est ton main dans le fichier main.cpp :: Ce sont des extraits de mon code par conséquent il est vrai que nous ne voyons pas la fonction principale main.
 
Le fichier main.cpp ressemble à ça, en résumé bien sûr  ::

///////////////////////////////////////////////////////////////////////////////////
//LES LIBRAIRIES
#include <iostream>
using namespace std;
#include "ModaCPP.h"
using namespace ModaCPP;
//#include <Eigen/Core>

#include <Eigen>
using namespace Eigen;


#include <math.h>

#include "matrices.h"

///////////////////////////////////////////////////////////////////////////////////
//Déclaration des Variables
int iteration =0;//Permet de déterminer l'itération dans une boucle

double Angle; //Permet de transmettre un angle à une articulation

///////////////////////////////////////////////////////////////////////////////////
//Déclaration du tableau contenant les paramètres de DH, 23 repères
double DH[20][4] = {35.1,0,PI2,-PI2,72.35,0,-PI2,0, 0,0,PI2,PI2,99.95,0,0,-PI2, 92,0,0,0,-36.35,0,PI2,PI, 0,0,0,0, 0,0,0,0, 0,0,0,0,0,0,0,0,-35.1,0,PI2,-PI2,-72.35,0,-PI2,0,0,0,PI2,PI2,99.95,0,0,-PI2,92,0,0,0,-36.35,0,PI2,PI,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0};

///////////////////////////////////////////////////////////////////////////////////
//Déclaration du tableau angle et coordonnées de chaque articulation [angle,X,Y,Z]
double AngleCoord[20][4];

///////////////////////////////////////////////////////////////////////////////////
//déclaration des variables matrices :: Mt, Mres, Mp_A, Mp_B, Mpi_A, Mpi_B, Mrot.
//Une MATRICE de TRANSLATION
extern Matrix4d Mt;
//Une MATRICES RESULTAT
extern Matrix4d Mres;
//Deux MATRICES de PASSAGE
extern Matrix4d Mp_A;
extern Matrix4d Mp_B;
//Deux MATRICES de PASSAGE INVERSE
extern Matrix4d Mpi_A;
extern Matrix4d Mpi_B;
//Une Matrice de rotation
extern Matrix4d Mrot;


///////////////////////////////////////////////////////////////////////////////////
//fonction calculs matricielles

void CalculMatricielle (double Angle)
{  
               IniMatriceMpi_A(DH[f][0], DH[f][1], DH[f][2], DH[f][3],0); //Passage de r,d,alpha,teta et angle de rotation de l'articulation
                            std::cout << "Valeur de la Matrice Mpi_A  :: " << std::endl;
                            std::cout << Mpi_A << std::endl;
                            std::cout << "*********************" << std::endl;
}//FIN :: void CalculMatricielle (double Angle)


///////////////////////////////////////////////////////////////////////////////////
//////////////////////PARTIE PRINCIPAL ////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
int main(int argc, CHAR* argv[])
{
          Angle = 20;//pour test
          CalculMatricielle (Angle);
}

Question 2 : quelle est ta commande pour compiler (ou ton fichier Makefile) :: J'utilise visual studio 2010 express, par conséquent pour compiler le programme j'utilise le menu :: Générer/Générer "nomduprojet".

 

Question 3 (lié à la question 1) : pourquoi déclarer ta variable globalement dans ton fichier matrices.cpp et pas dans main.cpp directement (vu que tu inclus le reste, ça ne devrait pas poser de problème) :: Si je ne déclare pas les variables des matrices dans le fichier matrices.cpp j'ai alors des messages d'erreurs puisque dans ce même fichier je déclare également les fonctions qui calculent les matrices de translation, de rotation, de passage et de passage inverse.

 

Le fichier matrices.cpp contient donc ::

#include "matrices.h"

#include <Eigen>
using namespace Eigen;

///////////////////////////////////////////////////////////////////////////////////
//Déclaration des valeurs PI et PI/2
# define PI (3.14159265358979323846)
# define PI2 (1.57079632679489661923)

///////////////////////////////////////////////////////////////////////////////////
//déclaration des variables matrices en extern
//Une MATRICE de TRANSLATION
Matrix4d Mt(4,4);
//Une MATRICES RESULTAT
Matrix4d Mres(4,4);
//Deux MATRICES de PASSAGE
Matrix4d Mp_A(4,4);
Matrix4d Mp_B(4,4);
//Deux MATRICES de PASSAGE INVERSE
Matrix4d Mpi_A(4,4);
Matrix4d Mpi_B(4,4);
//Une Matrice de rotation
Matrix4d Mrot(4,4);


///////////////////////////////////////////////////////////////////////////////////
//fonction initialisation de la matrice de translation
void IniMatriceMt(double x, double y, double z)
    {    
        Mt(0,0) = 1;Mt(0,1) = 0;Mt(0,2) = 0;Mt(0,3) = x;
        Mt(1,0) = 0;Mt(1,1) = 1;Mt(1,2) = 0;Mt(1,3) = y;
        Mt(2,0) = 0;Mt(2,1) = 0;Mt(2,2) = 1;Mt(2,3) = z;
        Mt(3,0) = 0;Mt(3,1) = 0;Mt(3,2) = 0;Mt(3,3) = 1;
    }

///////////////////////////////////////////////////////////////////////////////////
//fonction initialisation de la matrice de passage A
void IniMatriceMp_A(double r, double d, double alpha, double teta, double angle)
    {
        angle = angle*PI/180;//Conversion de l'angle en radi
        teta = teta + angle; //Permet d'intégrer l'angle de la rotation
        Mp_A(0,0) = cos(teta);Mp_A(0,1) = -cos(alpha)*sin(teta);Mp_A(0,2) = sin(alpha)*sin(teta);Mp_A(0,3) = r*cos(teta);
        Mp_A(1,0) = sin(teta);Mp_A(1,1) = cos(alpha)*cos(teta);Mp_A(1,2) = -sin(alpha)*cos(teta);Mp_A(1,3) = r*sin(teta);
        Mp_A(2,0) = 0;Mp_A(2,1) = sin(alpha);Mp_A(2,2) = cos(alpha);Mp_A(2,3) = d;
        Mp_A(3,0) = 0;Mp_A(3,1) = 0;Mp_A(3,2) = 0;Mp_A(3,3) = 1;
    }

///////////////////////////////////////////////////////////////////////////////////
//fonction initialisation de la matrice de passage B
void IniMatriceMp_B(double r, double d, double alpha, double teta, double angle)
    {
        angle = angle*PI/180;//Conversion de l'angle en radi
        teta = teta + angle; //Permet d'intégrer l'angle de la rotation
        Mp_B(0,0) = cos(teta);Mp_B(0,1) = -cos(alpha)*sin(teta);Mp_B(0,2) = sin(alpha)*sin(teta);Mp_B(0,3) = r*cos(teta);
        Mp_B(1,0) = sin(teta);Mp_B(1,1) = cos(alpha)*cos(teta);Mp_B(1,2) = -sin(alpha)*cos(teta);Mp_B(1,3) = r*sin(teta);
        Mp_B(2,0) = 0;Mp_B(2,1) = sin(alpha);Mp_B(2,2) = cos(alpha);Mp_B(2,3) = d;
        Mp_B(3,0) = 0;Mp_B(3,1) = 0;Mp_B(3,2) = 0;Mp_B(3,3) = 1;
    }

///////////////////////////////////////////////////////////////////////////////////
//fonction initialisation d'une matrice de passage Inverse A
void IniMatriceMpi_A(double r, double d, double alpha, double teta, double angle)
    {        
        angle = angle*PI/180;//Conversion de l'angle en radi
        teta = teta + angle; //Permet d'intégrer l'angle de la rotation
        Mpi_A(0,0) = cos(teta);Mpi_A(0,1) = sin(teta);Mpi_A(0,2) = 0;Mpi_A(0,3) = -r;
        Mpi_A(1,0) = -cos(alpha)*sin(teta);Mpi_A(1,1) = cos(alpha)*cos(teta);Mpi_A(1,2) = sin(alpha);Mpi_A(1,3) = -d*sin(alpha);
        Mpi_A(2,0) = sin(alpha)*sin(teta);Mpi_A(2,1) = -sin(alpha)*cos(teta);Mpi_A(2,2) = cos(alpha);Mpi_A(2,3) = -d*cos(alpha);
        Mpi_A(3,0) = 0;Mpi_A(3,1) = 0;Mpi_A(3,2) = 0;Mpi_A(3,3) = 1;
    }

///////////////////////////////////////////////////////////////////////////////////
//fonction initialisation d'une matrice de passage Inverse B
void IniMatriceMpi_B(double r, double d, double alpha, double teta, double angle)
    {
        angle = angle*PI/180;//Conversion de l'angle en radi
        teta = teta + angle; //Permet d'intégrer l'angle de la rotation
        Mpi_B(0,0) = cos(teta);Mpi_B(0,1) = sin(teta);Mpi_B(0,2) = 0;Mpi_B(0,3) = -r;
        Mpi_B(1,0) = -cos(alpha)*sin(teta);Mpi_B(1,1) = cos(alpha)*cos(teta);Mpi_B(1,2) = sin(alpha);Mpi_B(1,3) = -d*sin(alpha);
        Mpi_B(2,0) = sin(alpha)*sin(teta);Mpi_B(2,1) = -sin(alpha)*cos(teta);Mpi_B(2,2) = cos(alpha);Mpi_B(2,3) = -d*cos(alpha);
        Mpi_B(3,0) = 0;Mpi_B(3,1) = 0;Mpi_B(3,2) = 0;Mpi_B(3,3) = 1;
    }
///////////////////////////////////////////////////////////////////////////////////
//fonction initialisation de la matrice de rotation

void IniMatriceMrot(double angle)
    {
        angle = angle*PI/180;//Conversion de l'angle en radian

        Mrot(0,0) = cos(angle);Mrot(0,1) = -sin(angle);
        Mrot(1,0) = sin(angle);Mrot(1,1) = cos(angle);
        Mrot(2,2) = 1;
        Mrot(3,3) = 1;
    }

Alors bien sûr il faut prendre tout cela avec précaution, je suis un débutant en C++.....En fait je suis débutant sur tous les thèmes que ce projet met en œuvre !!

 

 

J'AI TROUVEEEEEEEEEEEEEEEeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee il faut dans le fichier main.cpp déclarer la variable Mpi_A en externe comme ceci :

 

/////////////dans le fichier main.cpp////////////////////////////////////////////
extern Matrix4d Mpi_A;

 

@Ulysse et @arobasseb : J'ai corrigé mon exemple en fait dans mon programme j'ai bien Matrix4d Mpi_A(4,4)
 
@arobasseb
Réaliser une classe, oui je vais regarder ça ....Surcharger l'opérateur << : ok je vais essayer de trouver de l'info sur le sujet.....
 
Merci....

 

Je ne connais pas C++.

......... Cette manière de faire m'est étrangère, moi je déclarerais et je définirais la fonction dans matrices.h

Mais je me plante peut-être complètement.

Effectivement si tu ne connais pas C++ cette manière de faire doit te paraître étrangère mais heureusement sur le net il existe beaucoup de cours, j'utilise celui-ci particulièrement :
https://openclassroo...tatus=published

 

++

Top génial ce petit robot, le partage de toutes les info et il y à même le logo robot-maker sur le robot....

 

 

Excellentissime !!

 

Et il te reste encore un peu de colle....

..........

Je pense que ces liens sont déjà disponibles sur le site mais au cas ou :

 

http://www.makershop.fr/blog/ultimaker-le-guide-visuel/

 

http://www.makershop.fr/blog/optimiser-imprimante-3d-apres-test/

 

Tu me diraS Ce que tu en penseS :::