Framework Python pour Robots Multi-Pattes

De Wiki LOGre
Aller à : navigation, rechercher
Langue : Français  • English

Projet réalisé par fma38.

Abouti

Présentation

Py4bot est un framework logiciel, écrit en python, permettant de contrôler un robot de type multi-pattes.

Cahier des charges

  • nombre et disposition des pattes configurables
  • nombre de degrés de liberté par patte librement configurable
  • démarches (gaits) extensibles
  • pilotage depuis plusieurs types de contrôleurs simultanément (gamepad, clavier, micro, wifi/ReST, custom...)
  • envoi d'infos aux contrôleurs
  • auto-pilote possible (total ou partiel) :
    • mémorisation de trajectoire
    • utilisation des capteurs pour conserver l'assiette, détecter le sol...

Théorie

Généralités

Géométrie hexapode

Cinématique inverse

La cinématique inverse (Inverse Kinematics, ou IK, en anglais), est l'algo qui permet de calculer la position des actionneurs en fonction de la position désirée, de la patte, par exemple ; c'est en effet cette dernière qui nous intéresse pour positionner l'hexapod, et pour le déplacer.

Ici, on se contentera d'une patte à 3 degrés de liberté (Degrees of Freedom, ou DoF, en anglais).

Exemple de routine de calcul, en python, inspiré de http://www.engineer-this.com/IK.shtml :

class Leg3DoFIk(object):
    def __init__(self, coxa, femur, tibia):
        super(Leg3DoFIk, self).__init__()
 
        self._coxa = coxa
        self._femur = femur
        self._tibia = tibia
 
    def _L(self, x, y, z):
        return math.sqrt((math.sqrt(x ** 2 + y ** 2) - self._coxa) ** 2 + z ** 2)
 
    def _alpha(self, x, y, z):
        return math.acos(z / self._L(x, y, z)) + \
               math.acos((self._tibia ** 2 - self._femur ** 2 - self._L(x, y, z) ** 2) / \
                         (-2 * self._L(x, y, z) * self._femur))
 
    def _beta(self, x, y, z):
        return math.acos((self._L(x, y, z) ** 2 - self._tibia ** 2 - self._femur ** 2) / \
                         (-2 * self._tibia * self._femur))
 
    def _gamma(self, x, y):
        return math.atan2(y, x)
 
    def solve(self, x, y, z):
        alpha = math.degrees(self._alpha(x, y, z))
        beta = math.degrees(self._beta(x, y, z))
        gamma = math.degrees(self._gamma(x, y))
 
        return alpha, beta, gamma

Ici, on a donc la position du bout de la patte exprimée dans un repère orthonormé, dont le centre est la rotation autour de l'articulation coxa, l'axe x est dirigé suivant le rayon du cercle sur lequel est fixée l'articulation coxa, vers l'extérieur, et l'axe z, vertical.

Il faut donc aussi calculer la position de ce repère dans le repère du sol ; cela va dépendre de la position du corps par rapport au sol. Là, on utilise de simples matrices de translation T) et de rotation (R). Au final, on aura quelque chose comme :

def Rz(yaw):
    yaw = math.radians(yaw)
    return matrix([[math.cos(yaw), -math.sin(yaw), 0],
                   [math.sin(yaw),  math.cos(yaw), 0],
                   [            0,              0, 1]])
 
# leg position vector
P = matrix([[leg.x],
            [leg.y],
            [legz]])
 
# Change to body reference
P = body.R * P + body.T
 
# Change to leg reference
gamma0 = config.LEGS_ORIGIN[legIndex]['gamma0']
x = config.LEGS_ORIGIN[legIndex]['radius']
legR = Rz(gamma0)
legT = matrix([[x],
               [0],
               [0]])
P = legR.I * P - legT
 
alpha, beta, gamma = legIk.solve(P[0], P[1], P[2])

Démarche

La démarche (gait, en anglais), et la façon dont le robot se déplace. Pour un hexapod, il existe plusieurs type de démarches :

  • tripod : 3 pattes en l'air en même temps, 2 pas entiers par cycle
  • tetrapod: 2 pattes en lair en même temps, 3 pas entiers par cycle
  • wave (ou metachronal): 1 patte en l'air à la fois, 6 pas entiers par cycle
  • ripple : ressemble à wave, mais où 2 pattes se lèvent de manière décalée dans le temps (une patte de chaque côté)

Les définitions ne sont pas claires, et diffèrent suivant les sources !

Liens

Cinématique inverse (IK)

Démarches (gaits)

Firmware