1/ Pourquoi tu applique deux fois pythagore dans la fonction Vecteur ??
2/ Pourquoi tu rajoute z/Vecteur(x,y,z) a alpha ?
3/ Comment fonctionne sens et cote ?
4/ Les variable (x,y,z) ces moi qui doit les définir avec une valeur ???
5/ Ces quoi la différence entre lateral,longi,alti et (x,y,z) ??
sens,cote,x,y,z ne sont pas des variable mais des arguments de fonction
si tu regardes bien, mon système mathématique n'est construit que de fonction qui s'appellent les unes les autres
et elles définissent seule comment appliquer la cinématique inverse a chaque angle selon la patte
Je l'ai écris pour l appeler le plus naturellement possible
tu veux l angle alpha de la patte avant droite = AlphaPatte(avant,droite)
tout le reste se fais tout seul :
AlphaPatte appelle la fonction AngleAlpha(x,y,z)
AngleAlpha prend 3 argument (qui sont 3 fonction)
x = la distance x entre l Offset et le pied qui n'est pas la même selon si elle est à droite ou a gauche (cote)
y = la distance y entre l Offset et le pied qui n'est pas la même selon si elle est à l'avant ou l'arrière (sens)
Z = pour toi pour l instant pas d argument mais ça viendra
(le miens avec gyro dois savoir s il est sur le ventre ou sur le dos il prend en argument haut et bas
ect .....
donc tu vois bien que quand tu appels la fonction AlphaPatte toutes les autres sont appelé automatiquement avec les bon arguments .
BetaPatte(avant,gauche) et BetaPatte(arriere,droite) ne renvoient pas le même résultat mais elles appellent les fonctions nécessaire avec les bon argument pour que ça corresponde bien a l angle beta de la patte avant gauche et arrière droite.
Latéral commande de déplacement latéral (droite gauche) du CORPS du robot
Longi commande de déplacement longitudinale (avant, arrière) du CORPS du robot
Alti commande de déplacement altitude(monter, descendre) du CORPS du robot
Alors je sais que quand tu vas comprendre parfaitement comment ça marche, tu vas voir une façon beaucoup plus simple de le faire marcher sans Offset et sans les différentiel, mais ton IK sera figé. Cette structure te laisse la porte ouverte pour faire ce que tu veux.
exemple, comme moi, module Position corps ,et juste pour la moitié des Offset de mon robot (je t'épargne les équations)
Et la tu devrais comprendre pourquoi je te dis de bien structurer ton programme parce que ça prend très vite beaucoup de place
sur ce que tu a fais (je l ai juste survolé pas regardé en détail et je je suis pas bien placé pour t aider en codage je vais laisser ça à d autre) mais j ai quand même vu des erreur.
dans le loop (je pense que tu l auras compris ) toute ces fonctions non rien a faire la, elle sont appelé par:
AlphaPatte
BetaPatte
GammaPatte
et même ces fonctions la, devrait être appelé par une boucle sur l'asservissement des servo
les arguments de fonction (x,y,z,sens,cote) ne se déclare pas se sont des arguments
tu peux créer une fonction pour les "serial print"
y a des erreurs .
#define Avant 1
#define Arriere 1
#define droite 1
#define gauche 1
#define bas 1
#define haut 1
#define Avant 1
#define Arriere -1
#define droite 1
#define gauche -1
#define bas 1
#define haut -1
il faut bien comprendre qu'une valeur comme "largeur/2" vaut pour la droite et la gauche
avec la fonction : OffsetX(cote)=largeur/2*cote
quand tu appels :Valeur+OffsetX(droite) c'est égale à Valeur+(largeur/2)
Valeur+OffsetX(gauche) c est égale à Valeur-(largeur/2)
je trouve ça trop "fouillis" (avis perso, peut être a tord)
int Mouvement_Alpha_Patte(double sens, double cote)
{
Alpha_Patte = Angle_Alpha(Mouvement_DiffX(cote), Mouvement_DiffY(sens), Mouvement_DiffZ(sens));
Serial.print("Alpha_Patte=");
Serial.print(Alpha_Patte,DEC);
Serial.println();
}
je ne sais pas coder mais ça devrais ressembler plutôt à ça:
A L'AIDE Mike 118 
int Alpha_Patte(double sens, double cote)
{
Resultat = Angle_Alpha(DiffX(cote), DiffY(sens), DiffZ));
return Resultat;
}
Et ce pour toutes tes fonction
ça je comprends pas:
//Test :
for(int i =0; i<=1; i++)
{
//Avant droit Servos (1)
Move_Servo(AVD0,Gamma_Patte);
Move_Servo(AVD1,Alpha_Patte);
Move_Servo(AVD2,Beta_Patte);
//Arrière droit Servos (2)
Move_Servo(ARD0,Gamma_Patte);
Move_Servo(ARD1,Alpha_Patte);
Move_Servo(ARD2,Beta_Patte);
//Avant gauche Servos (3)
Move_Servo(AVG0,Gamma_Patte);
Move_Servo(AVG1,Alpha_Patte);
Move_Servo(AVG2,Beta_Patte);
//Arrière gauche Servos (4)
Move_Servo(ARG0,Gamma_Patte);
Move_Servo(ARG1,Alpha_Patte);
Move_Servo(ARG2,Beta_Patte);
}
GammaPatte, AlphaPatte, BetaPatte, de quoi? y a pas d'argument pour l IK !
//indiquer à l'IK de quelle patte il doit calculer cette angle
Move_Servo(AVD0,Gamma_Patte(avant,droite));
Move_Servo(ARD0,Gamma_Patte(arriere,droite));
Move_Servo(AVG0,Gamma_Patte(avant,gauche));
Bien qu'en Python le code et plus court, je pense que même en C tu peux réduire énormément il y a beaucoup de chose inutile ou mal structuré tu devrais bien comprendre la base de cinématique inversé que je t ai faite avant d' essayer de la coder sinon tu arriveras pas à faire marcher ton robot.Comme je n'ai fais que survoler ton code y a peut être d'autre erreur mais je pense que tu vas le retravailler.