🌇 🏏 🗞️ Nous ressuscitons l'hexapode. Partie un 🥠 👳🏿 🐼

Dans un article précédent, nous avons partagé notre expérience dans la création d'un hexapode utilisant la technologie d'impression 3D. Nous allons maintenant parler du composant logiciel, qui lui a permis de renaître.

Il était initialement prévu de présenter toutes les informations dans un seul article, mais au cours de la rédaction, il est devenu clair qu'une telle présentation serait superficielle et non informative. Par conséquent, il a été décidé d'écrire plusieurs articles avec une présentation plus détaillée du sujet.

Appareil hexapode

Actuellement, la carte UNO R3 avec Wi-Fi ESP8266 est utilisée comme contrôleur principal . En fait, cette carte avec deux contrôleurs à bord, interagissant entre eux via une interface UART.

Malgré le fait qu'Uno dispose d'une quantité assez limitée de ressources informatiques, il suffit d'apprendre au robot à exécuter des commandes de base:

mouvement en ligne droite avec une vitesse et une durée données
mouvement circulaire vers la gauche ou la droite (tourner en place)
prendre des positions de membre prédéfinies

L'ESP8266 est responsable de l'organisation du canal de communication sans fil et sert de passerelle à travers laquelle Uno reçoit les commandes de contrôle.

Le robot peut être contrôlé via le réseau local au sein de la session telnet établie avec lui ou via une connexion filaire au contrôleur (pour le firmware ou le débogage). Pour plus de commodité, nous avons également écrit une application Android simple qui implémente une fonctionnalité interactive minimale pour contrôler le robot.

La figure ci-dessous montre schématiquement la structure hexapode.

Tous les servos sont connectés à la carte d' extension Multiservo Shield , qui vous permet de contrôler 18 servos. Sa communication avec Arduino se fait via le bus I²C. Par conséquent, même avec 18 servos de direction en même temps, presque toutes les broches Arduino resteront libres.
Il convient de noter que la carte d'extension a un connecteur pour alimenter les servos connectés. Mais le courant maximal admissible pour lequel la carte est conçue est d'environ 10 A, ce qui n'est pas suffisant pour alimenter les servo-variateurs MG996R, dont la consommation de courant maximale totale peut dépasser la valeur spécifiée. Par conséquent, dans notre version, chaque servo était connecté à une ligne d'alimentation distincte, contournant la carte d'extension.

Gestion des hexapodes

La logique de contrôle des membres hexapodes est implémentée dans le programme à l'aide de la classe GeksaFoot .

classe GeksaFoot

class GeksaFoot {
private:
//         
  Vector3D m_p0;
//          
  Vector3D m_r0;
//  Multiservo,    
  Multiservo m_coxaServo;   //  
  Multiservo m_femoraServo; //  
  Multiservo m_tibiaServo;  //  
public:
  GeksaFoot(Vector3D p0,Vector3D r0);
//   
  void begin(int coxaPin, int femoraPin, int tibiaPin);
//   
  void end();   

//   

  void coxaAngle(int);      //      (-90 .. 90 )
  int coxaAngle();          //     

  void femoraAngle(int);    //       (-90 .. 90 )
  int femoraAngle();        //     

  void tibiaAngle(int);     //       (-90 .. 90 )
  int tibiaAngle();         //     

//         

  //         
  int getAngles(Vector3D p, int& coxaAngle, int& femoraAngle, int& tibiaAngle);
  //       
  int getPoint(int coxaAngle, int femoraAngle, int tibiaAngle, Vector3D& p);
};

Les méthodes coxaAngle , femoraAngle , tibiaAngle vous permettent de définir ou de trouver l'angle de rotation d'une articulation de jambe individuelle. Les méthodes auxiliaires getAngles et getPoint implémentent la logique de calcul de la cinématique directe et inverse, avec laquelle vous pouvez calculer la valeur des angles de jambe pour un point donné dans l'espace de son membre. Ou vice versa, un point d'espace pour les valeurs d'angle actuelles.

La position moyenne de chaque joint correspond à une valeur nulle de l'angle, et la plage de rotation du joint se situe dans la plage de -90 à 90 degrés.

La classe de niveau supérieur est la classe Geksapod. Il met en œuvre la logique de l'ensemble du robot. Chaque jambe hexapode est incluse dans cette classe en tant qu'instance distincte de la classe GeksaFoot .

geksapod de classe

class Geksapod: public AJobManager {
  friend class MotionJob;
  friend CommandProcessorJob;
  //  
  GeksaFoot m_LeftFrontFoot;
  GeksaFoot m_LeftMidleFoot;
  GeksaFoot m_LeftBackFoot;
  GeksaFoot m_RigthFrontFoot;
  GeksaFoot m_RigthMidleFoot;
  GeksaFoot m_RigthBackFoot;
  // ,    
  MotionJob m_MotionJob;
private:
  //       
  //       
  //     
  int _setPose(int idx, int ca, int fa, int ta);
  int _setPose(int[FOOTS_COUNT][3]);  
  int _setPose(Vector3D points[FOOTS_COUNT]); 
protected:
  //          
  int setPose(int idx, int ca, int fa, int ta, int actionTime); 
  int setPose(int pose[FOOTS_COUNT][3], int actionTime);
  int setPose(int idx, Vector3D p, int actionTime);
  int setPose(Vector3D points[FOOTS_COUNT], int actionTime = 0);
  int setPose(int ca, int fa, int ta, int actionTime);
  //      
  void getPose(int idx, int& ca, int& fa, int& ta);
  void getPose(int pose[FOOTS_COUNT][3]);
  void getPose(int idx, Vector3D& p);
  void getPose(Vector3D points[FOOTS_COUNT]);
  //    
  int execute(Motion* pMotion);
public:
  Geksapod();
  void setup();
  //   
  int move(int speed, int time);    //   
  int rotate(int speed, int time);  //   
  void stop();                      //  
  //         
  int getAngles(int idx, Vector3D p, int& ca, int& fa, int& ta);
  int getPoint(int idx, int coxaAngle, int femoraAngle, int tibiaAngle, Vector3D& p);
  int getAngles(Vector3D points[FOOTS_COUNT], int pose[FOOTS_COUNT][3]);
  int getPoints(int pose[FOOTS_COUNT][3], Vector3D points[FOOTS_COUNT]);
};

Les méthodes getPose et setPose surchargées sont destinées à un usage interne et vous permettent d'obtenir la position actuelle des membres du robot ou d'en définir une nouvelle. Dans ce cas, la position des jambes est définie sous la forme d'un ensemble de valeurs des angles de rotation de chaque articulation ou comme un ensemble de coordonnées des points d'extrémité des membres du robot par rapport à son centre.
Pour un mouvement fluide des membres lors de l'appel des méthodes setPose , vous pouvez spécifier le temps (paramètre actionTime ) après lequel les jambes doivent atteindre la position spécifiée.
Le robot est contrôlé par les méthodes publiques de déplacement , rotation et arrêt .

Émulation multitâche

La classe Geksapod hérite de l'implémentation de la classe AJobManager et contient une instance de la classe MotionJob , qui à son tour hérite de la classe AJob . Ces classes vous permettent d'implémenter ce que l'on appelle le multitâche non préemptif, vous permettant de vous abstraire de la linéarité des programmes et d'effectuer plusieurs tâches en même temps.

classe ajob

class AJob {
  friend class AJobManager;
private:
  AJobManager* m_pAJobManager;   
  AJob* mJobNext;                      
  unsigned long m_counter;         //    onRun
  unsigned long m_previousMillis; //     onRun
  unsigned long m_currentMillis;  //   
  unsigned long m_delayMillis;    //    onRun
  void run();
public:
  AJob(AJobManager*, unsigned long delay = 0L);
  ~AJob();
                  
  void finish();  //     
  long counter(); //    onRun    
  long setDelay(unsigned long); //    onRun
  unsigned long previousMillis();//      onRun
  unsigned long currentMillis(); //    
                              
  virtual void onInit();  //      
  virtual void onRun();   //     
  virtual void onDone();  //        finish
};

La classe AJob est la classe de base pour toutes les tâches qui nécessitent une exécution simultanée. Ses héritiers doivent remplacer la méthode onRun , qui implémente la logique de la tâche en cours d'exécution. Étant donné les spécificités du multitâche préemptif, l'appel de cette méthode ne devrait pas prendre trop de temps. Il est recommandé de diviser la logique de la tâche en plusieurs sous-tâches plus légères, chacune étant exécutée pour un appel onRun distinct .

classe AJobManager

class AJobManager {
  friend class AJob;
  AJob* mJobFirst;  //      
  void attach(AJob*);   //    
  void dettach(AJob*); //    
  void dettachAll();   //   
public:  
  AJobManager();
  ~AJobManager();
  void setup();
  void loop();
};

La classe AJobManager a une déclaration plus modeste et contient seulement deux méthodes publiques: setup et loop . La méthode de configuration doit être appelée une fois avant de démarrer la boucle du programme principal. Dans ce document, une initialisation une par une de toutes les tâches se produit, en appelant la méthode onInit correspondante pour chaque tâche de la liste.
Une tâche est automatiquement ajoutée à la liste lorsque son constructeur est appelé et peut être supprimée en appelant la méthode de fin publique de la tâche elle-même.

Méthode de boucleIl est appelé à plusieurs reprises dans le cycle de programme principal et est responsable de l'exécution séquentielle de la logique de chaque tâche à partir de la liste à des intervalles spécifiés (si installés).

Ainsi, lors de la création d'une instance de la classe Geksapod héritée de la classe AJobManager , nous mettons à notre disposition un outil multitâche pratique.

Mise en œuvre du mouvement

Tout mouvement du corps peut être décrit par une fonction qui détermine sa position à un moment donné. Une telle fonction peut être composite, c'est-à-dire qu'elle peut être un ensemble de fonctions, dont chacune n'est applicable que pendant une certaine période de temps.

Les différents types de mouvement des membres de l'hexapode sont définis et peuvent être étendus à l'aide de classes héritées de la classe Motion .

mouvement de classe

class Motion {
  friend class MotionJob;
protected:
  long m_MaxTime;     //      
  long m_TotalTime;   //      
  bool m_IsLooped;    //   
  Motion* m_pNext;    //     
public:  
  Motion(long maxTime, bool isLooped, long totalTime = -1, Motion* pNext = NULL);
  ~Motion();
  
  inline long maxTime() { return m_MaxTime; }
  inline long totalTime() { return m_TotalTime; }
  inline bool isLooped() { return m_IsLooped; }

  //          

  //       0 <= time <= m_MaxTime 
  virtual int getPose(long time, Vector3D points[FOOTS_COUNT]) { return E_NOT_IMPL; };  
  //        0 <= time <= m_MaxTime
  virtual int getPose(long time, int pose[FOOTS_COUNT][3]) { return E_NOT_IMPL; };       
};

Pour mettre en oeuvre le mouvement, la substituée getPose méthode doit retourner la position des membres du robot pour une période de temps donnée de temps dans la plage de 0 à mMaxTime (en millisecondes). Dans le cas où le mouvement est bouclé ( m_IsLooped == true) , la durée du mouvement peut être limitée en définissant la durée dans m_TotalTime . Et enfin, vous pouvez organiser une séquence de mouvements en les combinant dans une liste.

Ainsi, nous avons l'occasion de décrire les mouvements du robot. Mais la description elle-même (dans notre cas, une instance de la classe héritée de Motion) ne fera pas bouger le robot. Nous avons besoin d'un mécanisme qui réorganisera les jambes de l'hexapode, guidé par la description qui lui est donnée.

Et ce mécanisme est une instance de la classe MotionJob déclarée dans la classe Geksapod .

classe MotionJob

class MotionJob: public AJob {
  enum STATUS { 
    NONE, RUNING, STOPING 
   } m_Status;
  
  Geksapod* m_pGeksapod;
  Motion* m_pMotion;
  long m_MotionTime;
  long m_TotalTime;
public:  
  MotionJob(Geksapod* pGeksapod);
  int execute(Motion* pMotion);
  void onRun();
};

Une instance de la classe MotionJob , héritée d' AJob, est une tâche dans laquelle la méthode onRun est appelée à intervalles réguliers . Il implémente également un mécanisme qui oblige notre robot à effectuer des mouvements. Nous avons juste besoin de lui dire comment se déplacer, en indiquant une description du mouvement lors de l'appel de la méthode execute. C'est tout pour le moment. Il y a encore de nombreux problèmes non éclairés que j'essaierai d'écrire dans le prochain article. J'espère que je n'ai pas fatigué les lecteurs avec trop de code. Prêt à répondre à toutes vos questions. A suivre ... PS En préparation du prochain article, j'ai légèrement modifié la structure de la visibilité des méthodes dans la classe AJob . Méthodes OnInit

, onRun et onDone n'ont pas besoin d'un accès public, car leur appel provient de la classe conviviale AJobManager . Considérant que ces méthodes doivent se chevaucher chez les héritiers, il suffit de les placer dans la section protégée .

classe ajob

class AJob {
  friend class AJobManager;
private:
  AJobManager* m_pAJobManager;   
  AJob* mJobNext;                      
  unsigned long m_counter;         //    onRun
  unsigned long m_previousMillis; //     onRun
  unsigned long m_currentMillis;  //   
  unsigned long m_delayMillis;    //    onRun
  void run();
protected:
  virtual void onInit();  //      
  virtual void onRun();   //     
  virtual void onDone();  //        finish
public:
  AJob(AJobManager*, unsigned long delay = 0L);
  ~AJob();

  void finish();  //     
  long counter(); //    onRun    
  long setDelay(unsigned long); //    onRun
  unsigned long previousMillis();//      onRun
  unsigned long currentMillis(); //    
};

Nous ressuscitons l'hexapode. Partie un

Appareil hexapode

Gestion des hexapodes

Émulation multitâche

Mise en œuvre du mouvement

More articles: