190 réponses à ce sujet

[Mr Max]

Je les vois symétrique Oracid

[Telson]

@Oracid : je confirme que les cuisses sont bien symétriques,  pas de pb de ce côté là.

 

@Olivier : c'est ce que j'avais fait dans ma première version. Le bassin est certes étroit mais tu remontes le centre de gravité et le U pour tenir le servomoteur pivot de la jambe m'a posè des problèmes de rigidité et de solidité. Ensuite le servomoteur qui balance la jambe d'avant en arrière supporte un servomoteur en plus, celui qui fait pivoter la jambe.

 

Avoir un bassin étroit pose des problèmes de stabilité sauf à faire évoluer le robot avec les jambes écartées ou à mettre des pieds énorme.....J'ai choisi dans un second temps le bassin large et donc les pieds écartés + des pieds énormes....Oui je sais je triche !!

 

Pieds serrés + hauteur robot élevée est très difficile à gérer. La moindre oscillation engendre un déséquilibre et là sans centrale inertielle pour récupérer ??????

 

En fait dans ma nouvelle version le fait d'avoir un bassin large me permet d'y loger la batterie et l'électronique et de descendre le centre de gravité. Par contre le moment/couple sera plus important sur le servomoteur de la cheville et de la hanche de la jambe porteuse (ou pied d'appui).....

 

La position de l'ensemble batterie/électronique est vraiment importante. Il faut gérer l'encombrement, le passage de tous les câbles et puis l'inertie de la masse....

 

Il faut savoir qu'il y à 12 servomoteurs, deux cartes, deux régulateurs, une batterie. ça représente pas mal de chose déjà à placer !!!

 

Alors bien sûr, tout ce beau blabla n'est que le fruit de ma petite expérience en la matière et forcément c'est pas énorme et je sais déjà que cette nouvelle version sera encore modifiée....

 

Je ne pense pas que des servomoteurs soit la solution absolue pour des bipèdes.....Des actionneurs linéaires me semblent bien mieux appropriés

 

J'ai commencé cette aventure le 08 avril 2016 et je pensais au départ obtenir des jambes fonctionnelles au bout d'un an...Je devrais y arriver....Mais il me faudrait deux imprimantes !!!

 

Merci pour vos conseils et à très bientôt pour de nouvelles expériences !!

 

++

[Oliver17]

C'est clair que ce n'est pas évident et je prend notes de tes propos A très vite HumaOne POWER ^^

[Oracid]

Je ne pense pas que des servomoteurs soit la solution absolue pour des bipèdes.....Des actionneurs linéaires me semblent bien mieux appropriés

J'ai la même intuition que toi. D'un point du rendement cela est contesté, mais de la théorie à la pratique, il y a une place pour le doute.
Quand je vois des vérins sur une pelleteuse, je me dis que c'est super efficace, mais que ce choix est dû à l'utilisation d'air comprimé ou de liquide en pression.
Les actionneurs linéaires électriques sont souvent utilisés dans des conditions de commodité. Par exemple pour ouvrir un Vélux situé en hauteur. Dans cette situation, le rendement importe peu.
Je pense qu'il ne faut pas perdre de vue qu'un vérin électrique relève de la rotation d'une vis sans fin. Que l'on face avancer un écrou, ou que l'on face tourner une roue dentée avec une vis sans fin, les frottements sont du même type.
Par ailleurs, les actionneurs linéaires pour Lego sont des servos.

Permet moi, exceptionnellement, une vidéo Lego sur ton fil qui démontre que la vis sans fin a un mauvais rendement. Mais cette vidéo ne m'a pas vraiment convaincu.

[Telson]

OOOOOOO Punaise !!!! Je viens de terminer les vérifications de l'algo qui calcule les mouvements des jambes de HumaOne.........Bobo la tête !!!

 

J'ai sélectionné seulement 73 phases caractéristiques de la marche et il va maintenant me falloir terminer le montage des jambes......il me reste des pièces déjà imprimées mais non montées.....

 

J'espère que je serais en mesure de faire une p'tite vidéo si le résultat est intéressant.....J'espère ne pas trop à avoir à modifier l'algo car c'est du taf...

 

Le programme complet prend sur une mega2560, 8% de l'espace de stockage de programmes et les variables 11% de mémoire dynamique...Cool il me reste de la place....Mais bon je finirai par passer sur Python (pi).

 

A bientôt alors pour de plus amples info.....

 

 

++
 

[Oliver17]

YYeeeaahhhh merci pour les news.

 

Pourquoi passer sur une Pi et programmer en Python ??

 

Du au manque de puissance de calcul du microcontroleur ??

 

Perso je fini au plus vite mon apprentissage sur la trigo (ouais j'ai pas fais que ça entres temps lol) et vais essayer de programmer déjà sur deux servos.

 

Bref, merci et n'hésite pas de faire une vidéo, même si tu penses que ce n'est pas top je suis tout de même curieux.

 

VIIIVVAAAA HHUUMMAAAOONNEEEEE (version Elvis) ^^

 

Ps : il est possible nous donner le procédé utilisé (Al Kashi, matrice etc etc) ?

Pas le code hein, juste ta façon dont tu vois les choses.

 

Merci

Modifié par Oliver17, 23 février 2017 - 11:27 .

[Oracid]

Heureusement que le mec qui a inventé l'eau chaude n'a pas étudié la mécanique quantique, sinon on y serait encore.

 

Je plaisante.

Je suis frustré de ne pas avoir tout ce savoir.  

Bon courage.

[Path]

Salut Telson, j'ai les mêmes interrogations qu'Oliver

[Telson]

Alors je pense passer sur pi pour les performances du matériel, la possibilité de faire du multitâches et aussi la possibilité d'utiliser un soft pour développer le code et visualiser le déroulement de l'algo avec point d'arrêt, espions sur variables...ça me saoule avec l'IDE arduino de de tjrs devoir charger le programme pour le faire tourner et visualiser les résultats dans le moniteur série, de ne pas pouvoir mettre des points d'arrêts, etc.....Me parler pas de circuits.io je ne suis pas fan....

 

Bon sinon pour les problématiques de calculs des mouvements pas de problème pour partager, rien de secret mais en même temps rien de très pro.....En fait c'est plus de la bidouille et je pense que certains ici vont grincer des dents en lisant ma façon de faire mais le principal étant de partager et puis pourquoi pas par la suite sur la base de conseils avisés développer des méthodes plus pro....

 

 

Ma méthode maintenant !! vous êtes prêt...J'vais essayer de perdre personne en route......Imbuvable cela va être !!!

 

Je commence déjà par initialiser mon bipéde jambes tendues et donc compte tenu de la structure tous mes servomoteurs sont à 90° sauf le servo pour le genou gauche = 0° et le servo du genou droit = 180 °. A partir de là je connais les X/Y/Z de toutes mes articulations.

 

 

Pour commencer la marche j'impose une inclinaison sur la gauche de disons 20°. Je sais que pour incliner le robot sur la gauche je vais devoir augmenter l'angle de certains servo et diminuer l'angle sur d'autres....C'est la structure qui l'impose

 

J'ai aussi une variable qui me permet de savoir si mon robot est incliné sur la gauche( inclinaison =-1) ou si mon robot est incliné sur la droite...

 

Exemple :

ROT_GD = 20
hauteur_sol = 15

ElseIf (inclinaison = 1) Then //''jambe droite  porteuse
        A_temp = 90 + ROT_GD
        convert_dr A_temp

//'''''''''Nous allons définir les coordonnées de la malléole de la jambe porteuse comme étant l'origine :
X_maleolle_D = 0
Y_maleolle_D = 0
Z_maleolle_D = 0

        //'calcul de la hauteur de la jambe droite
        X_cuisse_D = 0
        Y_cuisse_D = (L_jambe_D * Cos(A_temp))
        Z_cuisse_D = (L_jambe_D * Sin(A_temp)) //'''  SOUS CONDITION D'AVOIR REPLACE LE BASSIN A L'HORIZONTALE     

        //''''calcul de la position du haut de la cuisse Gauche
        X_cuisse_G = X_cuisse_D

        //''''calcul de la position de la cheville_D
        Y_cheville_D = (L_cheville_D * Cos(A_temp))
        Z_cheville_D = (L_cheville_D * Sin(A_temp))
        
        //''''calcul de la position du genou_D
        Y_genou_D = ((L_cheville_D + L_tibia_D) * Cos(A_temp))
        Z_genou_D = ((L_cheville_D + L_tibia_D) * Sin(A_temp))
//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
        //'''  SOUS CONDITION DE L'ANGLE DE PIVOT
        //''ATTENTION CES CALCULS anticipe la mise à la verticale de la jambe
        Y_cuisse_G = Y_cuisse_D + L_bassin
        Y_genou_G = Y_cuisse_G
        Y_cheville_G = Y_cuisse_G

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
        //'''  SOUS CONDITION D'AVOIR REPLACE LE BASSIN A L'HORIZONTALE
        Z_cuisse_G = Z_cuisse_D
        //'''Nous pouvons maintenant définir la position de la malléole de la jambe libre
        //'''  SOUS CONDITION DE L'ANGLE DE PIVOT
        X_maleolle_G = X_maleolle_D

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
        For Z_maleolle_G = 5 To hauteur_sol Step 5
        Call AV_jambe(boucle, X_cuisse_G, Z_cuisse_G, L_cuisse_G, A_cuisse_G, X_genou_G, Z_genou_G, L_tibia_G, A_genou_G, X_cheville_G, Z_cheville_G, L_cheville_G, A_cheville_G, X_maleolle_G, Z_maleolle_G, L_maleolle_G, A_maleolle_G)
                //'@@@@@@@@@@@@@envoi des commandes
                nom_phase = "souleve pied G"
                Call enregistrement(nom_phase, A_maleolle_D, A_cheville_D, A_genou_D, A_cuisse_D, A_hanche_D, A_pivot_D, A_maleolle_G, A_cheville_G, A_genou_G, A_cuisse_G, A_hanche_G, A_pivot_G, X_cheville)
                Call affiche_coord(nom_phase)
                //'@@@@@@@@@@@@@envoi des commandes
        Next
        Z_maleolle_G = Z_maleolle_G - 5 //''permet de supprimer la dernière incrémentation

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
//''ns mettons ensuite la jambe gauche à la verticale et pied à plat
A_hanche_G = 90
A_maleolle_G = 90

//'@@@@@@@@@@@@@envoi des commandes
nom_phase = "jambe G verticale"
Call enregistrement(nom_phase, A_maleolle_D, A_cheville_D, A_genou_D, A_cuisse_D, A_hanche_D, A_pivot_D, A_maleolle_G, A_cheville_G, A_genou_G, A_cuisse_G, A_hanche_G, A_pivot_G, X_cheville)
Call affiche_coord(nom_phase)
End If

Dans la fonction qui incline le robot à gauche/droite j'ai placé une boucle qui soulève le pied jusqu'à hauteur_sol par pas de 5°

 

 

J'ai presque toujours utilisé des notions très simples en mathématique (sin/cos/atan). Ce qui ne facilite pas toujours les calculs et encore moins les performances......bref !!

 

J'utilise aussi la solution des intersections de cercle. Par exemple je connais la position de ma cuisse et sa la longueur et je connais la position de la cheville et sa longueur. Par conséquent l'intersection du cercle de centre X/Z_cuisse et de rayon L_cuisse avec le cercle de centre X/Z_cheville de rayon L_cheville me donnera X/Z_genou....à la verticale !!! Ma jambe est inclinée de 20°/axe X !! Alors les coordonnées des deux cercles et de l'intersection à la verticale passées dans une matrice de rotation de 20°/axe X me donne les coordonnées de ma cuisse, du genou et de la cheville..........inclinée de 20°.....

 

J'utilise aussi beaucoup Angle = Atan (côé_opposé/côté_adjacent)...Il faut cependant toujours faire la différence ntre la jambe gauche ou droite et particulièrement aux coordonnées des articulations .....

 

 

Par exemple dans la boucle pour lever le pied au dessus du sol j'appel la fonction ::

Call AV_jambe(boucle, X_cuisse_G, Z_cuisse_G, L_cuisse_G, A_cuisse_G, X_genou_G, Z_genou_G, L_tibia_G, A_genou_G, X_cheville_G, Z_cheville_G, L_cheville_G, A_cheville_G, X_maleolle_G, Z_maleolle_G, L_maleolle_G, A_maleolle_G)

A cette fonction je passe les coordonnées de mes articulations et je récupères tous les angles des servo...A_genou_G, ....

 

Pour la jambe droite je fais :

Call cal_angles(X_cuisse_D, Z_inter, X_genou_D, Z_genou_D, X_cheville_D, Z_cheville_D, A_cuisse_D, A_cheville_D, A_genou_D, A_maleolle_D)

Voici maintenant son contenue

Function cal_angles(X_cuisse As Double, Z_cuisse As Double, X_genou As Double, Z_genou As Double, X_cheville As Double, Z_cheville As Double, A_cuisse As Double, A_cheville As Double, A_genou As Double, A_maleolle As Double)
//''''''''''''''''''''''''''''''''''''''''''''''''''
//''''''''''''''plusieurs cas :
//''''1 ::  X_cuisse = X_cheville
//''''2 :: X_cheville > X_cuisse
//''''3 :: X_cheville < X_cuisse
//'''''''''''''''''''''''''''''''''''''''''''''''''''''

If (inclinaison = -1) Then '''jambe gauche porteuse
//''''''''''''''''''''''''''''''''''''''''''''''''''''
//''''1 ::  X_cuisse = X_cheville
//''''''''''''''''''''''''''''''''''''''''''''''''''''
        //'''''utilisaton du triangle et de Atn avec verticale passant par X_cuisse et horizontale passant par Y_genou
       // ''''calcul de A_cuisse = atan(opp/adj) = atan(deltaX/deltaY) = atan((X_genou-X_cuisse)/(Y_cuisse-Y_genou))
        If (X_cuisse = X_cheville) Then
                A_cuisse = Atn((X_genou - X_cuisse) / (Z_cuisse - Z_genou))
                convert_rd A_cuisse
                
               // ''''calcul de A_genou : Al_KASHI
               // ''gros subterfuge pour ne pas recréer une variable
                A_genou = ((L_cuisse_D ^ 2 + L_tibia_D ^ 2 - (Z_cuisse - Z_cheville) ^ 2) / (2 * L_cuisse_D * L_tibia_D))
                
                If Abs(A_genou) - 1 < 0.001 Then //''permet de supprimer l'erreur de précision ds les calculs
                    If A_genou < -1 Then //''si angle négatif
                    A_genou = -1
                    ElseIf A_genou > 1 Then //''si angle positif
                    A_genou = 1
                    End If
                End If
                
                A_genou = Arccos(A_genou)
                convert_rd A_genou
               
                //''calcul cheville_D
                If (X_cheville <= X_genou) Then
                A_cheville = Atn((Z_genou - Z_cheville) / (X_genou - X_cheville))
                convert_rd A_cheville
                A_cheville = 180 - A_cheville
                ElseIf (X_cheville > X_genou) Then
                A_cheville = Atn((Z_genou - Z_cheville) / (X_cheville - X_genou))
                convert_rd A_cheville
                End If
                
                
                //'''il faut corriger l'angle de ma cuisse après avoir calculé A_cheville et uniquement après avoir calculé A_cheville
                A_cuisse = 90 + A_cuisse
                
               //'''' Il faut corriger A_genou = 180-A_genou MAIS après calcul de A_cheville
                A_genou = 180 - A_genou
                If A_genou < 0.1 Then
                A_genou = 0
                End If
        
        End If
//''''''''''''''''''''''''''''''''''''''''''''''''''''
//''''2 :: X_cheville > X_cuisse''''''''''''''''''''''
//''''''''''''''''''''''''''''''''''''''''''''''''''''
        If (X_cheville > X_cuisse) Then
                A_cuisse = Atn((X_genou - X_cuisse) / (Z_cuisse - Z_genou)) '' il est aussi possible de faire AL_KASHI -> fonction
                convert_rd A_cuisse
                //'''il faut corriger l'angle de ma cuisse
                A_cuisse = 90 + A_cuisse
                                
                //''''calcul de A_genou :: AL-KASHI
                //''gros subterfuge pour ne pas recréer une variable
                //'''il faut calculer la longueur du segment de la cuisse jusqu'àu tibia = Sqr((Xcuisse - X_cheville) ^ 2 + (Z_cuisse - Z_cheville) ^ 2
                L = Sqr((X_cuisse - X_cheville) ^ 2 + (Z_cuisse - Z_cheville) ^ 2)
                A_genou = ((L_cuisse_G ^ 2 + L_tibia_G ^ 2 - L ^ 2) / (2 * L_cuisse_G * L_tibia_G))
                
                If Abs(A_genou) - 1 < 0.001 Then //''permet de supprimer l'erreur de précision ds les calculs
                    If A_genou < -1 Then ''si angle négatif
                    A_genou = -1
                    ElseIf A_genou > 1 Then ''si angle positif
                    A_genou = 1
                    End If
                End If
               
                A_genou = Arccos(A_genou)
                convert_rd A_genou
                
               //'''' Il faut corriger A_genou = 180-A_genou
                A_genou = 180 - A_genou
                If A_genou < 0.1 Then
                A_genou = 0
                End If
                             
                //''calcul cheville_D
                If (X_cheville <= X_genou) Then
                A_cheville = Atn((Z_genou - Z_cheville) / (X_genou - X_cheville))
                convert_rd A_cheville
                A_cheville = 180 - A_cheville
                ElseIf (X_cheville > X_genou) Then
                A_cheville = Atn((Z_genou - Z_cheville) / (X_cheville - X_genou))
                convert_rd A_cheville
                End If
                
        End If
//''''''''''''''''''''''''''''''''''''''''''''''''''''
//''''3 ::  X_cheville < X_cuisse
//''''''''''''''''''''''''''''''''''''''''''''''''''''
        If (X_cheville < X_cuisse) Then
                A_cuisse = Atn((X_genou - X_cuisse) / (Z_cuisse - Z_genou)) //'' il est aussi possible de faire AL_KASHI -> fonction
                convert_rd A_cuisse
                //'''il faut corriger l'angle de ma cuisse
                A_cuisse = 90 + A_cuisse
                                
                //''''calcul de A_genou :: AL-KASHI
                //''gros subterfuge pour ne pas recréer une variable
                //'''il faut calculer la longueur du segment de la cuisse jusqu'àu tibia = Sqr((Xcuisse - X_cheville) ^ 2 + (Z_cuisse - Z_cheville) ^ 2
                L = Sqr((X_cuisse - X_cheville) ^ 2 + (Z_cuisse - Z_cheville) ^ 2)
                A_genou = ((L_cuisse_G ^ 2 + L_tibia_G ^ 2 - L ^ 2) / (2 * L_cuisse_G * L_tibia_G))
                
                If Abs(A_genou) - 1 < 0.001 Then //''permet de supprimer l'erreur de précision ds les calculs
                    If A_genou < -1 Then //''si angle négatif
                    A_genou = -1
                    ElseIf A_genou > 1 Then //''si angle positif
                    A_genou = 1
                    End If
                End If
               
                A_genou = Arccos(A_genou)
                convert_rd A_genou
                
               //'''' Il faut corriger A_genou = 180-A_genou
                A_genou = 180 - A_genou
                If A_genou < 0.1 Then
                A_genou = 0
                End If
                             
                //''calcul cheville_D
                If (X_cheville <= X_genou) Then
                A_cheville = Atn((Z_genou - Z_cheville) / (X_genou - X_cheville))
                convert_rd A_cheville
                A_cheville = 180 - A_cheville
                ElseIf (X_cheville > X_genou) Then
                A_cheville = Atn((Z_genou - Z_cheville) / (X_cheville - X_genou))
                convert_rd A_cheville
                End If
               
        End If
 

ElseIf (inclinaison = 1) Then //'''jambe droite porteuse
//''''1 ::  X_cuisse = X_cheville
        If (X_cuisse = X_cheville) Then
                A_cuisse = Atn((X_genou - X_cuisse) / (Z_cuisse - Z_genou))
                convert_rd A_cuisse //'''il faut corriger l'angle de ma cuisse après avoir calculé A_cheville
                //''''calcul de A_genou : Al_KASHI
                //''gros subterfuge pour ne pas recréer une variable
                A_genou = ((L_cuisse_G ^ 2 + L_tibia_G ^ 2 - (Z_cuisse - Z_cheville) ^ 2) / (2 * L_cuisse_G * L_tibia_G))
                If Abs(A_genou) - 1 < 0.001 Then //''permet de supprimer l'erreur de précision ds les calculs
                    If A_genou < -1 Then //''si angle négatif
                    A_genou = -1
                    ElseIf A_genou > 1 Then // ''si angle positif
                    A_genou = 1
                    End If
                End If
               
                A_genou = Arccos(A_genou)
                convert_rd A_genou
                If A_genou > 180 Then
                A_genou = 180
                End If
                      
                //''calcul cheville_G
                If (X_cheville <= X_genou) Then
                A_cheville = Atn((Z_genou - Z_cheville) / (X_genou - X_cheville))
                convert_rd A_cheville
                ElseIf (X_cheville > X_genou) Then
                A_cheville = Atn((Z_genou - Z_cheville) / (X_cheville - X_genou))
                convert_rd A_cheville
                A_cheville = 180 - A_cheville
                End If
               
        End If
//''''''''''''''''''''''''''''''''''''''''''''''''''''
//''''2 :: X_cheville > X_cuisse''''''''''''''''''''''
//''''''''''''''''''''''''''''''''''''''''''''''''''''
        If (X_cheville > X_cuisse) Then
                A_cuisse = Atn((X_genou - X_cuisse) / (Z_cuisse - Z_genou)) //'' il est aussi possible de faire AL_KASHI -> fonction
                convert_rd A_cuisse
                A_cuisse = 90 - A_cuisse
                               
                L = Sqr((X_cuisse - X_cheville) ^ 2 + (Z_cuisse - Z_cheville) ^ 2)
                A_genou = ((L_cuisse_G ^ 2 + L_tibia_G ^ 2 - L ^ 2) / (2 * L_cuisse_G * L_tibia_G))
                
                If Abs(A_genou) - 1 < 0.001 Then //''permet de supprimer l'erreur de précision ds les calculs
                    If A_genou < -1 Then //''si angle négatif
                    A_genou = -1
                    ElseIf A_genou > 1 Then //''si angle positif
                    A_genou = 1
                    End If
                End If
               
                A_genou = Arccos(A_genou)
                convert_rd A_genou
                If A_genou > 180 Then
                A_genou = 180
                End If
                
                //''calcul cheville_G
                If (X_cheville <= X_genou) Then
                A_cheville = Atn((Z_genou - Z_cheville) / (X_genou - X_cheville))
                convert_rd A_cheville
                ElseIf (X_cheville > X_genou) Then
                A_cheville = Atn((Z_genou - Z_cheville) / (X_cheville - X_genou))
                convert_rd A_cheville
                A_cheville = 180 - A_cheville
                End If
        End If
//''''''''''''''''''''''''''''''''''''''''''''''''''''
//''''3 ::  X_cheville < X_cuisse
//''''''''''''''''''''''''''''''''''''''''''''''''''''
        If (X_cheville < X_cuisse) Then
                A_cuisse = Atn((X_genou - X_cuisse) / (Z_cuisse - Z_genou)) //'' il est aussi possible de faire AL_KASHI -> fonction
                convert_rd A_cuisse
                //'''il faut corriger l'angle de ma cuisse
                A_cuisse = 90 - A_cuisse
                               
                L = Sqr((X_cuisse - X_cheville) ^ 2 + (Z_cuisse - Z_cheville) ^ 2)
                A_genou = ((L_cuisse_G ^ 2 + L_tibia_G ^ 2 - L ^ 2) / (2 * L_cuisse_G * L_tibia_G))
                
                If Abs(A_genou) - 1 < 0.001 Then //''permet de supprimer l'erreur de précision ds les calculs
                    If A_genou < -1 Then //''si angle négatif
                    A_genou = -1
                    ElseIf A_genou > 1 Then //''si angle positif
                    A_genou = 1
                    End If
                End If
                
                A_genou = Arccos(A_genou)
                convert_rd A_genou
                If A_genou > 180 Then
                A_genou = 180
                End If
               
                
                //''calcul cheville_G
                If (X_cheville <= X_genou) Then
                A_cheville = Atn((Z_genou - Z_cheville) / (X_genou - X_cheville))
                convert_rd A_cheville
                ElseIf (X_cheville > X_genou) Then
                A_cheville = Atn((Z_genou - Z_cheville) / (X_cheville - X_genou))
                convert_rd A_cheville
                A_cheville = 180 - A_cheville
                End If
        End If
End If
End Function

Vous trouverez aussi du AL-KASHI, que j'utilise presque exclusivement pour les articulations des genou::

                //''''calcul de A_genou :: AL-KASHI
                //''gros subterfuge pour ne pas recréer une variable
                //'''il faut calculer la longueur du segment X/Z_cuisse jusque X/Z_cheville = Sqr((Xcuisse - X_cheville) ^ 2 + (Z_cuisse - Z_cheville) ^ 2
                L = Sqr((X_cuisse - X_cheville) ^ 2 + (Z_cuisse - Z_cheville) ^ 2)
                A_genou = ((L_cuisse_G ^ 2 + L_tibia_G ^ 2 - L ^ 2) / (2 * L_cuisse_G * L_tibia_G))
                A_genou = Arccos(A_genou)

Je sais!!! C'est vraiment merdique par moment et je vais pouvoir largement optimiser pas mal de calcul en particulier les calculs pour les A_cuisse et surtout créer des fonctions pour le calculs des angles....Mais chaque chose en son temps....

 

J'arrête là pour le moment.....

 

 

Si vous avez des propositions remarques pas de problème...

[Path]

Merci je vais lire ça avec attention. Normalement je code les premières lignes ce we.

[Oliver17]

Pas tout pigé, mais hâte de le voir faire ses premiers pas

[Oliver17]

Heeeeyyyyyyyy grand poulet une tite question, as tu creusé l'idée des quaternions ???

 

PS : t'as des vidéos ou photos ton avancer, j'ai hâte ^^

[Telson]

Pouaaaa non pas avancé du tout....En ce moment il y à bcp de bonnes vagues alors les week-end c'est plutôt plage et soleil.....Et les soirs je consacre en ce moment mon temps à l'organisation des prochaines vacances......

[Oliver17]

Oki doki, tu as bien raison, profite

[Telson]

Salut tout le monde,

Des nouvelles de HumaOne !!! Pas d’inquiétude, mon projet n'est pas tombé au fond des oubliettes !!!

Après quelques semaines de vacances je me suis remis sur mon tracassin et là AIE !! Dur dur la reprise !!! Un constat simple : pas assez de documentation sur mes innombrables élucubrations mathématiques et informatiques.

Par conséquent j'ai décidé de me faire violence et de tout mettre d’abord par écrit.

Donc, avant de me relancer dans le développement, je mets tout sur papier. Ce qui me permet de mieux gérer mes variables, mes fonctions, etc.

Je suis parti tête baissée dans la prog et au bout de qqes semaines j'ai oublié pas mal de détails et surtout je m'aperçois que c'est pas très optimale....Fallait sans douter.....

C'est pas super génial ce passage mais il faut en passer par là je pense....

J'espère que j'arriverai à en sortir qqes chose de tout ça.....

A+ et bon courage à tous!

[Mike118]

Pour ce genre de chose mettre le choses à plat en ligne peut t'aider. 
Ici ou ailleurs =) en plus de les retrouver plus facilement que sur une feuille volante; ça se partagera plus facilement et ça prendra moins de place qu'un cahier  

[Oliver17]

Ok Telson, prends ton temps

[Telson]

Oui et bien je vais déjà commencer par mettre ça sur papier sans me préoccuper de la mise en page, mode : crayon gomme......

[Amhnemus]

Salut à toi, j'ai lu ton post qu'Olivier17 m'as conseillé de lire et je peux dire que bravo mais vraiment bravo parce que fasse à tout les problèmes que tu as rencontré tu n'as rien lâcher et tu en appris aux autres et à moi aussi par la même occasion.

Je suis moi aussi en cours de réalisation d'un robot bipède j'espère que tu passeras voir mon post pour ajouter tes commentaires même désagréable

En tout cas bonne continuation et je continuerai à suivre ton avancement avec attention

[Telson]

Salut,

 

je te remercie ça fait plaisir.....

 

J'ai pris le temps de lire ton post et d'y apporter mon point de vue.....Attention, je ne considère pas posséder la meilleur méthode ou vision pour réaliser un bipède.....C'est ma façon de voir les choses disons....

 

A+