À partir de zéro pour construire un environnement mini-simulation guépard robot à quatre pattes (a) des structures de châssis

Tout d'abord, le cadre

Selon l'idée de base de l'apprentissage de renforcement, il faut construire l'environnement de simulation pour interagir avec la section des agents. Chaque cycle nécessite les étapes suivantes:

• Initialiser l'environnement : y compris l' importation du modèle pertinent, définissez les paramètres cinétiques et similaires
• Exécution d' une action : L'agent d'action pour rendre les modèles de mouvement générés
• Statut de retour et incitations : Après avoir effectué l'action à nouveau pour obtenir l'état actuel et calculer la valeur de récompense, de retour à l'agent

Par conséquent, nous devons inclure cadre environnemental il dispose:

class Cheetah(object):
    def __init__(self):
    	'''
    	初始化参数
		'''
        pass
        
    def reset(self):
    	'''
    	环境复位
    	'''
		pass
		
    def step(self):
    	'''
    	执行动作
    	'''
		pass
	
	def get_observe(self):
		'''
		获取当前状态
		'''
		pass
	
	def reward(self):
		'''
		计算奖励值
		'''
		pass

nous ne sommes pas ici considérés comme faisant partie de l'apprentissage de renforcement, de sorte que vous pouvez ignorer une partie de la fonction de récompense

1,__init__

Ici nous avons besoin d'initialiser les éléments suivants:

• client pybullet : pybullet en utilisant la norme
• motor_id : permet de définir l'angle du moteur, il est nécessaire de faire la distinction entre les différents types de joint, où le nombre correspondant est donné directement par commodité.
• Set gravité
• Définissez les paramètres : addUserDebugParameterCe api fournit des paramètres définis par l' utilisateur, je suis ici pour régler l'angle de la hanche
• Set Angle : resetDebugVisualizerCameraCe api peut définir l'attitude de la caméra, dans mon article pybulet pratique a introduit son utilisation

Lorsque nous avons besoin d'appeler l'initialisation de la classe d'une reset()fonction pour définir la position mini - guépard

    def __init__(self):
        # self.pybullet_client = self._pybullet_client = bc.BulletClient(connection_mode=pybullet.GUI)
        self.pybullet_client = pybullet
        self.pybullet_client.connect(self.pybullet_client.GUI)
        self.pybullet_client.setAdditionalSearchPath(pybullet_data.getDataPath())
        self.motor_id_list = [0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14]
        self.pybullet_client.setGravity(0, 0, -9.8)
        # self.upper_angle = self.pybullet_client.addUserDebugParameter("upper_angle", 0, 1, 0.4)
        self.pybullet_client.resetDebugVisualizerCamera(0.2, 45, -30, [1, -1, 1])
        self.reset()

2,reset

• terrain d'importation
• Importation modèle mini_cheetah
• Imprimer l' information commune: getNumJointspour acquérir une information conjointe
• Appelez la reset_pos（）fonction pour régler chaque position de la jambe

    def reset(self):
        init_position = [0, 0, 0.5]
        self._ground_id = self.pybullet_client.loadURDF('plane.urdf')
        self.quadruped = self.pybullet_client.loadURDF(
            "mini_cheetah/mini_cheetah.urdf",
            init_position,
            useFixedBase=False)
            
        num_joints = self.pybullet_client.getNumJoints(self.quadruped)
        for i in range(num_joints):
            print(self.pybullet_client.getJointInfo(self.quadruped, i))
        for i in range(4):
            self.reset_pos(i, 0.7853982)

3,step

Depuis que la démonstration ici, donc il n'y a pas utilisation de la commande de fonctionnement plus avancé, où la fonctionnalité est ajustée de façon dynamique pour obtenir la garde au sol de mini_cheetah (fonction sin) en fonction du temps.

readUserDebugParameterCe api est adapté à la lecture d' un des paramètres définis par l' utilisateur, la __init__fonction a été initialisé, nous pouvons ajuster la garde au sol du curseur, veillez à ne pas boire la fonction péché en même temps.

    def step(self):
        t = 0
        while 1:
            t += 0.001
            angle = 0.4 * np.sin(t) + 0.5
            # angle = self.pybullet_client.readUserDebugParameter(self.upper_angle)
            for i in range(4):
                self.reset_pos(i, angle)
            self.pybullet_client.stepSimulation()

4,reset_pos

Définir la position de la jambe, setJointMotorControl2ce pybullet api est le plus souvent utilisé comme joints de contrôle sont effectuées par de cette api. L'API utilisée ici, respectivement pour la hanche et de commande de l' angle du genou.

    def reset_pos(self, leg_id, angle):
        l1 = 208
        l2 = 180
        hip_angle = 0.0
        upper_angle = -angle
        # 离地高度L与髋关节角度alpha的关系，在数学问题-初始姿态这篇文章介绍过该公式
        
        L = l1 * np.cos(angle) + np.sqrt(-l1 ** 2 * np.sin(angle) ** 2 + l2 ** 2)
        gamma = np.arccos((-l1 ** 2 + L ** 2 + l2 ** 2) / (2 * L * l2))
        beta = angle + gamma

        self.pybullet_client.setJointMotorControl2(self.quadruped,
                                jointIndex=self.motor_id_list[3 * leg_id],
                                controlMode=self.pybullet_client.POSITION_CONTROL,
                                targetPosition=hip_angle)
        self.pybullet_client.setJointMotorControl2(self.quadruped,
                                self.motor_id_list[3 * leg_id + 1],
                                self.pybullet_client.POSITION_CONTROL,
                                targetPosition=upper_angle)
        self.pybullet_client.setJointMotorControl2(self.quadruped,
                                self.motor_id_list[3 * leg_id + 2],
                                self.pybullet_client.POSITION_CONTROL,
                                targetPosition=beta)

5, l'exécution

if __name__ == '__main__':
    env = Cheetah()
    env.step()

: Maintenant , regardez comment nous exécutons les programmes d'

effets dynamiques: