28 réponses à ce sujet

[Oracid]

Voici un nouveau projet. Il s'agit de faire un "Spider" Kame, très populaire sur YouTube, avec une mécanique Lego.
Cela est rendu possible grace à ces nouveaux petits servos, https://www.robot-ma...ompatible-lego/
Ces servos sont des S9g avec un habillage Lego.

En faisant quelques recherches pour le projet de notre amie Manon, https://www.robot-ma...upede/?p=100203, je me suis intéressé aux quadrupèdes de type Spider et en particulier pour le Kame qui a la particularité de ne fonctionner qu'avec 8 servos. C'est donc un 8 DOF(Degree of Freedom) avec 2 servos par pattes, alors qu'habituellement ce type de quadrupèdes sont des 12 DOF avec 3 servos par pattes. Notez que l'une des caractéristiques du Kame est l'utilisation du parallélogramme pour la dernière articulation de la patte.

Indépendamment de la mécanique Lego, j'ai choisi d'utiliser un Arduino Nano au lieu de l'EV3 pour des questions de volume et de poids, mais il se pourrait que dans un deuxième temps je fasse une version avec l'EV3.
Par ailleurs, j'ai découvert le Shield Arduino Nano V3 sur lequel on enfiche directement le Nano et les connecteurs de servo. Cela évitera la forêt de connections habituelles que l'on voit sur une Breadbord.
Malheureusement, je n'ai pas réussi à trouver toutes les caractéristiques de ce Shield. Donc, si vous avez un lien, il sera bienvenu, merci d'avance.

Sur la photo, je ne montre que 2 pattes sur 4, car je n'avais commandé que 4 servos uniquement pour les tester. Je vais donc devoir attendre un mois avant d'avoir les autres. Mais je pense que l'on a déjà une bonne idée du résultat.

Voilà, il ne s'agit pas d'un projet collaboratif, néanmoins je suis impatient de pouvoir comparer mon quadrupède à celui de Manon qui devrait être assez similaire.

Cliquez moi.

[Oracid]

Quelques précisions sur ce projet.

Ce quadrupède est basé sur la version "Ez Arduino MiniKame" inspiré du Kame.
Cette version est basée sur un Arduino Nano enfiché sur un Shield Arduino Nano V3.

Liens Thingiverse, voir échanges sur la réalisation:
https://www.thingive...m/thing:2505147(28/08/2017) il semblerait que ce soit la référence. Code https://github.com/m...rduino-minikame
https://www.thingive...m/thing:2317065(13/05/2017) obsolète
https://www.thingive...m/thing:2872978(03/05/2018) fait référence au code https://github.com/m...no-minikame-mk2 et utilise le Huaduino https://www.instruct...OF-3D-Print-Qu/
https://www.thingive...m/thing:2523270(08/09/2017) fait référence au code https://github.com/m...rduino-minikame


Liens vers 2 codes. Ces 2 codes sont légèrement différents. Je n'ai pas encore fait mon choix :
https://github.com/m...rduino-minikame sans Bluetooth
https://github.com/m...no-minikame-mk2 avec Bluetooth


Connexion Bluetooth avec smartphone :
module HC05 ou HC06 : https://cdn.thingive...roid.chrome.png

[Oracid]

Il y a quelques jours, j'ai reçu le Shield Arduino Nano V3.
Il vraiment petit. C'est approximativement un carré dont le coté est égal au petit coté d'une carte de crédit.

J'ai fait un cable avec un connecteur type alim PC portable pour brancher ma batterie LiPo 2S.
Le Shield Arduino Nano V3 est pourvu d'une alimentation interne qui fournit du 5V et du 3,5V. Alors que ma LiPo 2S fournit du 8,3V.
Les servos sont alimentés en 5V.
Comme vous pouvez le constater sur l'image ci-dessous, tout est simplifié, pas de forêt de fils comme sur une Breadboard.
Le servo est directement branché sur un connecteur comprenant masse, tension et signal.
Pour l'instant, aucun problème, si ce n'est que les degrés du servo sont un peu large Il faut donc pondérer. En contrepartie, ces servos semblent d'excellente qualité.
J'ai reçu tous mes servos. J'attends une petite LiPo 2S très petite et légère.

Je vais donc commencer à étudier le code.

Cliquez moi.

[Oracid]

Schéma d'implantation des servos.

 

Le premier chiffre correspond au numéro du servo. Le deuxième chiffre correspond au numéro de la connection du pin Arduino.

 

'       left              FRONT            right'

 

'     (3,9)         (1,8)      (0,2)       (2,3)'

 

'     (7,7)         (5,6)      (4,4)       (6,5)'

 

 

En forme tableau :

 

'    N° servo   pin'

'         0           2'

'         1           8'

'         2           3'

'         3           9'

'         4           4'

'         5           6'

'         6           5'

'         7           7'

 

Le pire, c'est que dans le programme, les commentaires ne correspondent pas au code. Horrible !!!

  board_pins[FRONT_RIGHT_HIP] = 2; // front left inner
  board_pins[FRONT_LEFT_HIP] = 8; // front right inner
  board_pins[BACK_RIGHT_HIP] = 4; // back left inner
  board_pins[BACK_LEFT_HIP] = 6; // back right inner
  board_pins[FRONT_RIGHT_LEG] = 3; // front left outer
  board_pins[FRONT_LEFT_LEG] = 9; // front right outer
  board_pins[BACK_RIGHT_LEG] = 5; // back left outer
  board_pins[BACK_LEFT_LEG] = 7; // back right outer

[Oracid]

Voici le code de la version "Ez Arduino MiniKame".

Je pense que c'est ce code que je vais utiliser pour commencer. Déjà, la compile passe sans erreur.

 

minikame.ino

Spoiler

#include <Arduino.h>
#include "MiniKame.h"

//uncomment out below line if you want to use HC_SR04 sensor
//#define __HC_SR04__

#ifdef __HC_SR04__
#define HC_SR04_TRIGGER_PIN 10
#define HC_SR04_ECHO_PIN 11
#define MIN_DISTANCE 10
#define MAX_DISTANCE MIN_DISTANCE + 10
#endif

#define CAL_TRIGGER_PIN 12
#define LED_PIN A0
#define TIME_INTERVAL 5000

#define FORWARD 'f'
#define LEFT 'l'
#define STAND 's'
#define RIGHT 'r'
#define BACKWARD 'b'
#define GO 'g'
#define RIGHT_FRONT 'c'
#define RIGHT_BACK 'e'
#define LEFT_FRONT 'd'
#define LEFT_BACK 'h'

MiniKame robot;

volatile boolean auto_mode = true;
bool state = true;
char cmd = STAND;
boolean random_walk = true;

void setup() {
  Serial.begin(115200);

#ifdef __HC_SR04__
  pinMode(HC_SR04_TRIGGER_PIN, OUTPUT);
  pinMode(HC_SR04_ECHO_PIN, INPUT);
#endif
  randomSeed(analogRead(A7));

  //
  robot.init();
  delay(2000);

  //begin: triggering delay for servo calibrating
  pinMode(CAL_TRIGGER_PIN, OUTPUT);
  digitalWrite(CAL_TRIGGER_PIN, 0);
  pinMode(CAL_TRIGGER_PIN, INPUT);
  while (digitalRead(CAL_TRIGGER_PIN)) {
    analogWrite(LED_PIN, 128 * state); // on calibarting indication LED
    delay(1000);
    state = !state;
  }
  analogWrite(LED_PIN, 0); // off calibarting indication LED
  //end:
}

void loop() {
  if (auto_mode) {
    if (random_walk)
      gaits2(0);
    else
      gaits2(1);
  } else {
    gaits(cmd);
  }
}

void serialEvent() {
  char tmp = -1;
  boolean taken = false;

  while (Serial.available()) {
    state = !state;
    analogWrite(LED_PIN, 128 * state); //flashing LED indicating cmd received
    tmp = Serial.read (); //Serial.println(cmd);
    not_gaits(tmp);
    taken = gaits(tmp);
    if (taken) cmd = tmp;
  }
}


boolean  gaits(char cmd) {
  bool taken = true;
  switch (cmd) {
    case GO:
      robot.walk();
      break;
    case FORWARD:
      robot.walk();
      break;
    case BACKWARD:
      //robot.run(0);
      robot.walk(0);
      break;
    case RIGHT:
      robot.turnR(1, 550);
      break;
    case LEFT:
      robot.turnL(1, 550);
      break;
    case RIGHT_FRONT:
      robot.turnR(1, 550);
      robot.walk();
      break;
    case RIGHT_BACK:
      robot.turnR(1, 550);
      robot.walk(0);
      break;
    case LEFT_FRONT:
      robot.turnL(1, 550);
      robot.walk();
      break;
    case LEFT_BACK:
      robot.turnL(1, 550);
      robot.walk(0);
      break;
    case STAND:
      robot.home();
      break;
    default:
      taken = false;
  }
  return taken;
}

void not_gaits(char cmd) {
  static short receivedNumber = 0;
  static bool negative = false;
  static byte channel = 1;

  switch (cmd) {
    case 'L':
      robot.loadTrim();
      break;
    case 'S':
      robot.storeTrim();
      break;
    case  '<':  // fall through to start a new number with prefix x,y char
      receivedNumber = 0;
      channel = 0;
      negative = false;
      break;
    case 'x':
      channel = 1;
      break;
    case 'y':
      channel = 2;
      break;
    case 'z':
      channel = 3;
      break;
    case 'Z':
      channel = 4;
      break;
    case 'a':
      channel = 5;
      break;
    case 'A':
      channel = 6;
      break;
    case '0' ... '9':
      receivedNumber *= 10;
      receivedNumber += cmd - '0';
      break;
    case '-':
      negative = true;
      break;
    case '>': // end of getting a number in format of <[x,y,z,a]number>
      if (negative) receivedNumber = -receivedNumber;
      switch (channel) {
        case 1:
          if (receivedNumber >= 127) {
            state = auto_mode = false;
            analogWrite(LED_PIN, 0);
            robot.home();
          }
          else {
            state = auto_mode = true;
            analogWrite(LED_PIN, 128);
          }
          break;
        case 2:
          if (receivedNumber >= 127)
            random_walk = false;
          else
            random_walk = true;
          break;
        case 3:
          if (auto_mode) break;
          robot.setTrim(FRONT_RIGHT_HIP, receivedNumber);
          robot.home();
          break;
        case 4:
          if (auto_mode) break;
          robot.setTrim(FRONT_LEFT_HIP, receivedNumber);
          robot.home();
          break;
        case 5:
          if (auto_mode) break;
          robot.setTrim(BACK_RIGHT_HIP, receivedNumber);
          robot.home();
          break;
        case 6:
          if (auto_mode) break;
          robot.setTrim(BACK_LEFT_HIP, receivedNumber);
          robot.home();
          break;
      }  // end of inner switch
      break;
  } // end of switch

}

void gaits2(int pattern) {
  char movements[] = {FORWARD, LEFT, STAND, RIGHT, BACKWARD, RIGHT_FRONT, RIGHT_BACK, LEFT_FRONT, LEFT_BACK, GO};
  char movements2[] = {FORWARD, LEFT, FORWARD,  RIGHT};
  static unsigned long cur_time = 0, prev_time = 0;
  static char cmd = FORWARD, prev_cmd = -1;
  static int c = 0;

  cur_time = millis();
  if (cur_time - prev_time >= TIME_INTERVAL) {
    prev_time = cur_time;
    do {
      switch (pattern) {
        case 0: c = (int)random(0, sizeof(movements));
          cmd = movements[c];
          break;
        case 1:  c = c % sizeof(movements2);
          cmd = movements2[c++];
          break;
        default:
          pattern = 0;
      }
    } while (cmd == prev_cmd);
    prev_cmd = cmd; //Serial.println(cmd);
  }
#ifdef __HC_SR04__
  cmd = detect_obstacle(cmd);
#endif
  switch (cmd) {
    case GO:
      robot.pushUp(2, 5000);
      break;
    case FORWARD:
      robot.run();
      break;
    case BACKWARD:
      robot.run(0);
      break;
    case RIGHT:
      robot.turnR(1, 550);
      break;
    case LEFT:
      robot.turnL(1, 550);
      break;
    case RIGHT_FRONT:
      robot.hello();
      break;
    case LEFT_FRONT:
      robot.dance(2, 1000);
      break;
    case RIGHT_BACK:
      robot.frontBack(2, 1000);
      break;
    case LEFT_BACK:
      robot.moonwalkL(4, 2000);
      break;
    case STAND:
      robot.upDown(4, 250);
      break;
  }
}


#ifdef __HC_SR04__
char detect_obstacle(char cmd) {
  char i = cmd;
  long cm = distance_measure();
  if (cm < MIN_DISTANCE) {
    i = STAND;
  } else if (cm >= MIN_DISTANCE && cm <= MAX_DISTANCE) {
    i = BACKWARD;
  }
  return i;
}

long distance_measure()
{
  // establish variables for duration of the ping,
  // and the distance result in inches and centimeters:
  long duration, cm;

  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:

  digitalWrite(HC_SR04_TRIGGER_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(HC_SR04_TRIGGER_PIN, HIGH);
  delayMicroseconds(5);
  digitalWrite(HC_SR04_TRIGGER_PIN, LOW);

  // The same pin is used to read the signal from the PING))): a HIGH
  // pulse whose duration is the time (in microseconds) from the sending
  // of the ping to the reception of its echo off of an object.
  duration = pulseIn(HC_SR04_ECHO_PIN, HIGH);

  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the
  // object we take half of the distance travelled.
  cm =  duration / 29 / 2;
  //Serial.print(cm);
  //Serial.println("cm");
  // delay(100);
  return cm;
}
#endif

 

MiniKame.h

Spoiler

#ifndef minikame_h
#define minikame_h
#include "Octosnake.h"

// servo index to board_pins

#define FRONT_RIGHT_HIP 0
#define FRONT_LEFT_HIP 1
#define FRONT_RIGHT_LEG 2
#define FRONT_LEFT_LEG 3
#define BACK_RIGHT_HIP 4
#define BACK_LEFT_HIP 5
#define BACK_RIGHT_LEG 6
#define BACK_LEFT_LEG 7

class MiniKame {

  public:
    MiniKame();
    void init();
    void run(int dir = 1, float steps = 1, float T = 550);
    void walk(int dir = 1, float steps = 1, float T = 550);
    void omniWalk(float steps, float T, bool side, float turn_factor);
    void turnL(float steps, float period);
    void turnR(float steps, float period);
    void moonwalkL(float steps, float period);
    void dance(float steps, float period);
    void upDown(float steps, float period);
    void pushUp(float steps, float period);
    void hello();
    void jump();
    void home();
    void frontBack(float steps, float period);

    void setServo(int id, float target);
    void reverseServo(int id);
    float getServo(int id);
    void moveServos(int time, float target[8]);
    void setTrim(int index, int value) {
      trim[index] = value;
    }
    void storeTrim();
    void loadTrim();
  private:
    Oscillator oscillator[8];
    Servo servo[8];
    int board_pins[8];
    int trim[8]; //deviation servo offset
    bool reverse[8];
    unsigned long _init_time;
    unsigned long _final_time;
    unsigned long _partial_time;
    float _increment[8];
    float _servo_position[8];

    void execute(float steps, float period[8], int amplitude[8], int offset[8], int phase[8]);
    inline int angToUsec(float value) {
      return value / 180 * (MAX_PULSE_WIDTH - MIN_PULSE_WIDTH) + MIN_PULSE_WIDTH;
    };
    int EEPROMReadWord(int p_address);
    void EEPROMWriteWord(int p_address, int p_value);
};

#endif

 

MiniKame.cpp

Spoiler

#include <EEPROM.h>
#include "MiniKame.h"

/*
   (servo index, pin to attach pwm)
   __________ __________ _________________
  |(3,9)_____)(1,8)      (0,2)(______(2,3)|
  |__|       |left FRONT right|        |__|
             |                |
             |                |
             |                |
   _________ |                | __________
  |(7,7)_____)(5,6)______(4,4)(______(6,5)|
  |__|                                 |__|

*/
//comment below manually setting trim in MiniKame() constructor
#define __LOAD_TRIM_FROM_EEPROM__

#define EEPROM_MAGIC  0xabcd
#define EEPROM_OFFSET 2   //eeprom starting offset to store trim[]


MiniKame::MiniKame(): reverse{0, 0, 0, 0, 0, 0, 0, 0}, trim{0, 0, 0, 0, 0, 0, 0, 0} {
  board_pins[FRONT_RIGHT_HIP] = 2; // front left inner
  board_pins[FRONT_LEFT_HIP] = 8; // front right inner
  board_pins[BACK_RIGHT_HIP] = 4; // back left inner
  board_pins[BACK_LEFT_HIP] = 6; // back right inner
  board_pins[FRONT_RIGHT_LEG] = 3; // front left outer
  board_pins[FRONT_LEFT_LEG] = 9; // front right outer
  board_pins[BACK_RIGHT_LEG] = 5; // back left outer
  board_pins[BACK_LEFT_LEG] = 7; // back right outer
}

void MiniKame::init() {
  /*
     trim[] for calibrating servo deviation,
     initial posture (home) should like below
     in symmetric
        \       /
         \_____/
         |     |
         |_____|
         /     \
        /       \
  */
  /*
    trim[FRONT_LEFT_HIP] = 0;
    trim[FRONT_RIGHT_HIP] = -8;
    trim[BACK_LEFT_HIP] = 8;
    trim[BACK_RIGHT_HIP] = 5;

    trim[FRONT_LEFT_LEG] = 2;
    trim[FRONT_RIGHT_LEG] = -6;
    trim[BACK_LEFT_LEG] = 6;
    trim[BACK_RIGHT_LEG] = 5;
  */
#ifdef __LOAD_TRIM_FROM_EEPROM__
  int val = EEPROMReadWord(0);
  if (val != EEPROM_MAGIC) {
    EEPROMWriteWord(0, EEPROM_MAGIC);
    storeTrim();
  }
#endif

  for (int i = 0; i < 8; i++) {
    oscillator[i].start();
    servo[i].attach(board_pins[i]);
#ifdef __LOAD_TRIM_FROM_EEPROM__
    int val = EEPROMReadWord(i * 2 + EEPROM_OFFSET);
    if (val >= -90 && val <= 90) {
      trim[i] = val;
    }
#endif
  }

  home();
}

void MiniKame::turnR(float steps, float T = 600) {
  int x_amp = 15;
  int z_amp = 15;
  int ap = 15;
  //int hi = 23;
  int hi = 0;
  float period[] = {T, T, T, T, T, T, T, T};
  int amplitude[] = {x_amp, x_amp, z_amp, z_amp, x_amp, x_amp, z_amp, z_amp};
  int offset[] = {90 + ap, 90 - ap, 90 - hi, 90 + hi, 90 - ap, 90 + ap, 90 + hi, 90 - hi};
  int phase[] = {0, 180, 90, 90, 180, 0, 90, 90};

  execute(steps, period, amplitude, offset, phase);
}

void MiniKame::turnL(float steps, float T = 600) {
  int x_amp = 15;
  int z_amp = 15;
  int ap = 15;
  int hi = 0;
  float period[] = {T, T, T, T, T, T, T, T};
  int amplitude[] = {x_amp, x_amp, z_amp, z_amp, x_amp, x_amp, z_amp, z_amp};
  int offset[] = {90 + ap, 90 - ap, 90 - hi, 90 + hi, 90 - ap, 90 + ap, 90 + hi, 90 - hi};
  int phase[] = {180, 0, 90, 90, 0, 180, 90, 90};

  execute(steps, period, amplitude, offset, phase);
}

void MiniKame::dance(float steps, float T = 600) {
  int x_amp = 0;
  int z_amp = 40;
  int ap = 30;
  int hi = 0;
  float period[] = {T, T, T, T, T, T, T, T};
  int amplitude[] = {x_amp, x_amp, z_amp, z_amp, x_amp, x_amp, z_amp, z_amp};
  int offset[] = {90 + ap, 90 - ap, 90 - hi, 90 + hi, 90 - ap, 90 + ap, 90 + hi, 90 - hi};
  int phase[] = {0, 0, 0, 270, 0, 0, 90, 180};

  execute(steps, period, amplitude, offset, phase);
}

void MiniKame::frontBack(float steps, float T = 600) {
  int x_amp = 30;
  int z_amp = 25;
  int ap = 20;
  int hi = 0;
  float period[] = {T, T, T, T, T, T, T, T};
  int amplitude[] = {x_amp, x_amp, z_amp, z_amp, x_amp, x_amp, z_amp, z_amp};
  int offset[] = {90 + ap, 90 - ap, 90 - hi, 90 + hi, 90 - ap, 90 + ap, 90 + hi, 90 - hi};
  int phase[] = {0, 180, 270, 90, 0, 180, 90, 270};

  execute(steps, period, amplitude, offset, phase);
}

void MiniKame::run(int dir, float steps, float T) {
  int x_amp = 15;
  int z_amp = 15;
  int ap = 15;
  int hi = 0;
  int front_x = 0;
  float period[] = {T, T, T, T, T, T, T, T};
  int amplitude[] = {x_amp, x_amp, z_amp, z_amp, x_amp, x_amp, z_amp, z_amp};
  int offset[] = {    90 + ap - front_x,
                      90 - ap + front_x,
                      90 - hi,
                      90 + hi,
                      90 - ap - front_x,
                      90 + ap + front_x,
                      90 + hi,
                      90 - hi
                 };
  int phase[] = {0, 0, 90, 90, 180, 180, 90, 90};
  if (dir == 1) {
    phase[0] = phase[1] = 180;
    phase[4] = phase[5] = 0;
  }
  execute(steps, period, amplitude, offset, phase);
}

void MiniKame::omniWalk(float steps, float T, bool side, float turn_factor) {
  int x_amp = 15;
  int z_amp = 15;
  int ap = 15;
  int hi = 23;
  int front_x = 6 * (1 - pow(turn_factor, 2));
  float period[] = {T, T, T, T, T, T, T, T};
  int amplitude[] = {x_amp, x_amp, z_amp, z_amp, x_amp, x_amp, z_amp, z_amp};
  int offset[] = {    90 + ap - front_x,
                      90 - ap + front_x,
                      90 - hi,
                      90 + hi,
                      90 - ap - front_x,
                      90 + ap + front_x,
                      90 + hi,
                      90 - hi
                 };

  int phase[8];
  if (side) {
    int phase1[] =  {0,   0,   90,  90,  180, 180, 90,  90};
    int phase2R[] = {0,   180, 90,  90,  180, 0,   90,  90};
    for (int i = 0; i < 8; i++)
      phase[i] = phase1[i] * (1 - turn_factor) + phase2R[i] * turn_factor;
  }
  else {
    int phase1[] =  {0,   0,   90,  90,  180, 180, 90,  90};
    int phase2L[] = {180, 0,   90,  90,  0,   180, 90,  90};
    for (int i = 0; i < 8; i++)
      phase[i] = phase1[i] * (1 - turn_factor) + phase2L[i] * turn_factor + oscillator[i].getPhaseProgress();
  }

  execute(steps, period, amplitude, offset, phase);
}

void MiniKame::moonwalkL(float steps, float T = 5000) {
  int z_amp = 45;
  float period[] = {T, T, T, T, T, T, T, T};
  int amplitude[] = {0, 0, z_amp, z_amp, 0, 0, z_amp, z_amp};
  int offset[] = {90, 90, 90, 90, 90, 90, 90, 90};
  int phase[] = {0, 0, 0, 120, 0, 0, 180, 290};

  execute(steps, period, amplitude, offset, phase);
}


void MiniKame::walk(int dir, float steps, float T) {
  int x_amp = 15;
  int z_amp = 20;
  int ap = 20;
  //int hi = 10;
  int hi = -10;
  //int front_x = 12;
  int front_x = 0;
  float period[] = {T, T, T / 2, T / 2, T, T, T / 2, T / 2};
  int amplitude[] = {x_amp, x_amp, z_amp, z_amp, x_amp, x_amp, z_amp, z_amp};
  int offset[] = {   90 + ap - front_x,
                     90 - ap + front_x,
                     90 - hi,
                     90 + hi,
                     90 - ap - front_x,
                     90 + ap + front_x,
                     90 + hi,
                     90 - hi
                 };
  //int  phase[] = {90, 90, 270, 90, 270, 270, 90, 270};
  int  phase[] = {270, 270, 270, 90, 90, 90, 90, 270};
  if (dir == 0) { //backward
    phase[0] = phase[1] = 90;
    phase[4] = phase[5] = 270;
  }
  for (int i = 0; i < 8; i++) {
    oscillator[i].reset();
    oscillator[i].setPeriod(period[i]);
    oscillator[i].setAmplitude(amplitude[i]);
    oscillator[i].setPhase(phase[i]);
    oscillator[i].setOffset(offset[i]);
  }

  _final_time = millis() + period[0] * steps;
  _init_time = millis();
  bool side;
  while (millis() < _final_time) {
    side = (int)((millis() - _init_time) / (period[0] / 2)) % 2;
    setServo(0, oscillator[0].refresh());
    setServo(1, oscillator[1].refresh());
    setServo(4, oscillator[4].refresh());
    setServo(5, oscillator[5].refresh());

    if (side == 0) {
      setServo(3, oscillator[3].refresh());
      setServo(6, oscillator[6].refresh());
    }
    else {
      setServo(2, oscillator[2].refresh());
      setServo(7, oscillator[7].refresh());
    }
    delay(1);
  }
}

void MiniKame::upDown(float steps, float T = 5000) {
  int x_amp = 0;
  int z_amp = 35;
  int ap = 20;
  //int hi = 25;
  int hi = 0;
  int front_x = 0;
  float period[] = {T, T, T, T, T, T, T, T};
  int amplitude[] = {x_amp, x_amp, z_amp, z_amp, x_amp, x_amp, z_amp, z_amp};
  int offset[] = {    90 + ap - front_x,
                      90 - ap + front_x,
                      90 - hi,
                      90 + hi,
                      90 - ap - front_x,
                      90 + ap + front_x,
                      90 + hi,
                      90 - hi
                 };
  int phase[] = {0, 0, 90, 270, 180, 180, 270, 90};

  execute(steps, period, amplitude, offset, phase);
}


void MiniKame::pushUp(float steps, float T = 600) {
  int z_amp = 40;
  int x_amp = 65;
  int hi = 0;
  float period[] = {T, T, T, T, T, T, T, T};
  int amplitude[] = {0, 0, z_amp, z_amp, 0, 0, 0, 0};
  int offset[] = {90, 90, 90 - hi, 90 + hi, 90 - x_amp, 90 + x_amp, 90 + hi, 90 - hi};
  int phase[] = {0, 0, 0, 180, 0, 0, 0, 180};

  execute(steps, period, amplitude, offset, phase);
}

void MiniKame::hello() {
  float sentado[] = {90 + 15, 90 - 15, 90 - 65, 90 + 65, 90 + 20, 90 - 20, 90 + 10, 90 - 10};
  moveServos(150, sentado);
  delay(200);

  int z_amp = 40;
  int x_amp = 60;
  int T = 350;
  float period[] = {T, T, T, T, T, T, T, T};
  int amplitude[] = {0, 50, 0, 50, 0, 0, 0, 0};
  int offset[] = {
    90 + 15, 40,
    90 - 10, 90 + 10,
    90 + 20, 90 - 20,
    90 + 65, 90
  };

  int phase[] = {0, 0, 0, 90, 0, 0, 0, 0};

  execute(4, period, amplitude, offset, phase);

  float goingUp[] = {160, 20, 90, 90, 90 - 20, 90 + 20, 90 + 10, 90 - 10};
  moveServos(500, goingUp);
  delay(200);

}



void MiniKame::jump() {
  //float sentado[] = {90 + 15, 90 - 15, 90 - 65, 90 + 65, 90 + 20, 90 - 20, 90 + 10, 90 - 10};
  float sentado[] = {
    90 + 15, 90 - 15, //front hips servos
    90 - 10, 90 + 10, //front leg servos
    90 + 10, 90 - 10, // back hip servos
    90 + 65, 90 - 65  // back leg servos
  };
  int ap = 20;
  int hi = 35;
  float salto[] = {90 + ap, 90 - ap, 90 - hi, 90 + hi, 90 - ap * 3, 90 + ap * 3, 90 + hi, 90 - hi};

  moveServos(150, sentado);
  delay(200);
  //moveServos(0, salto);
  //delay(100);
  home();
}

void MiniKame::home() {
  int ap = 20;
  //int hi = 35;
  int hi = 0;
  int position[] = {90 + ap, 90 - ap, 90 - hi, 90 + hi, 90 - ap, 90 + ap, 90 + hi, 90 - hi};
  for (int i = 0; i < 8; i++) {
    if (position[i] + trim[i] <= 180 && position[i] + trim[i] > 0) {
      setServo(i, position[i] + trim[i]);
    }
  }
}



void MiniKame::reverseServo(int id) {
  if (reverse[id])
    reverse[id] = 0;
  else
    reverse[id] = 1;
}


void MiniKame::setServo(int id, float target) {
  if (!reverse[id])
    servo[id].writeMicroseconds(angToUsec(target + trim[id]));
  else
    servo[id].writeMicroseconds(angToUsec(180 - (target + trim[id])));
  _servo_position[id] = target + trim[id];
}

float MiniKame::getServo(int id) {
  return _servo_position[id];
}


void MiniKame::moveServos(int time, float target[8]) {
  if (time > 10) {
    for (int i = 0; i < 8; i++)	_increment[i] = (target[i] - _servo_position[i]) / (time / 10.0);
    _final_time =  millis() + time;

    while (millis() < _final_time) {
      _partial_time = millis() + 10;
      for (int i = 0; i < 8; i++) setServo(i, _servo_position[i] + _increment[i]);
      while (millis() < _partial_time); //pause
    }
  }
  else {
    for (int i = 0; i < 8; i++) setServo(i, target[i]);
  }
  for (int i = 0; i < 8; i++) _servo_position[i] = target[i];
}

void MiniKame::execute(float steps, float period[8], int amplitude[8], int offset[8], int phase[8]) {

  for (int i = 0; i < 8; i++) {
    oscillator[i].setPeriod(period[i]);
    oscillator[i].setAmplitude(amplitude[i]);
    oscillator[i].setPhase(phase[i]);
    oscillator[i].setOffset(offset[i]);
  }

  unsigned long global_time = millis();

  for (int i = 0; i < 8; i++) oscillator[i].setTime(global_time);

  _final_time = millis() + period[0] * steps;
  while (millis() < _final_time) {
    for (int i = 0; i < 8; i++) {
      setServo(i, oscillator[i].refresh());
    }
    yield();
  }
}
void MiniKame::storeTrim() {
  for (int i = 0; i < 8; i++) {
    EEPROMWriteWord(i * 2 + EEPROM_OFFSET, trim[i]);
    delay(100);
  }

}

// load/send only trim of hip servo
void MiniKame::loadTrim() {
  //FRONT_LEFT/RIGHT_HIP
  for (int i = 0; i < 4; i++) {
    Serial.write(EEPROM.read(i + EEPROM_OFFSET));
  }
  
  //BACK_LEFT/RIGHT_HIP
  for (int i = 8; i < 12; i++) {
    Serial.write(EEPROM.read(i + EEPROM_OFFSET));
  }
}

int MiniKame::EEPROMReadWord(int p_address)
{
  byte lowByte = EEPROM.read(p_address);
  byte highByte = EEPROM.read(p_address + 1);

  return ((lowByte << 0) & 0xFF) + ((highByte << 8) & 0xFF00);
}

void MiniKame::EEPROMWriteWord(int p_address, int p_value)
{
  byte lowByte = ((p_value >> 0) & 0xFF);
  byte highByte = ((p_value >> 8) & 0xFF);

  EEPROM.write(p_address, lowByte);
  EEPROM.write(p_address + 1, highByte);
}

 

Octosnake.cpp

Spoiler

#include "Octosnake.h"
#include <Servo.h>

Oscillator::Oscillator(){
    _period = 2000;
    _amplitude = 50;
    _phase = 0;
    _offset = 0;
    _stop = true;
    _ref_time = millis();
    _delta_time = 0;
}

float Oscillator::refresh(){
    if (!_stop){
        _delta_time = (millis()-_ref_time) % _period;
        _output =   (float)_amplitude*sin(time_to_radians(_delta_time)
                    + degrees_to_radians(_phase))
                    + _offset;
    }

    return _output;
}

void Oscillator::reset(){
    _ref_time = millis();
}

void Oscillator::start(){
    reset();
    _stop = false;
}

void Oscillator::start(unsigned long ref_time){
    _ref_time = ref_time;
    _stop = false;
}

void Oscillator::stop(){
    _stop = true;
}

void Oscillator::setPeriod(int period){
    _period = period;
}

void Oscillator::setAmplitude(int amplitude){
    _amplitude = amplitude;
}

void Oscillator::setPhase(int phase){
    _phase = phase;
}

void Oscillator::setOffset(int offset){
    _offset = offset;
}

void Oscillator::setTime(unsigned long ref){
    _ref_time = ref;
}

float Oscillator::getOutput(){
    return _output;
}

unsigned long Oscillator::getTime(){
    return _ref_time;
}

float Oscillator::getPhaseProgress(){
    return ((float)_delta_time/_period) * 360;
}

float Oscillator::time_to_radians(double time){
    return time*2*PI/_period;
}

float Oscillator::degrees_to_radians(float degrees){
    return degrees*2*PI/360;
}

float Oscillator::degrees_to_time(float degrees){
    return degrees*_period/360;
}

 

Octosnake.h

Spoiler

#ifndef octosnake_h
#define octosnake_h

#include <Arduino.h>
#include <Servo.h>

#ifndef PI
  #define PI 3.14159
#endif


class Oscillator{

    public:
        Oscillator();
        float refresh();
        void reset();
        void start();
        void start(unsigned long ref_time);
        void stop();
        float time_to_radians(double time);
        float degrees_to_radians(float degrees);
        float degrees_to_time(float degrees);
        void setPeriod(int period);
        void setAmplitude(int amplitude);
        void setPhase(int phase);
        void setOffset(int offset);
        void setTime(unsigned long ref);
        float getOutput();
        float getPhaseProgress();
        unsigned long getTime();

    private:
        int _period;
        int _amplitude;
        int _phase;
        int _offset;
        float _output;
        bool _stop;
        unsigned long _ref_time = 0;
        float _delta_time = 0;
};

#endif

[Oracid]

Voici quelques nouvelles de Kame.

J'ai complètement repensé la structure qui était trop étroite.
Les servos sont de bonne qualité. Ils maintiennent leur position et je n'ai pas réussi à bouger le palonnier à la main, sans aller au delà du raisonnable bien sûr. Je ne tiens pas à en briser un.
Malheureusement, leur déplacement physique est de 270°, alors que le déplacement électronique est bien de 180°.
Cela a eu pour conséquence des débattements désordonnés et quelques sueurs froides. D'où la présence d'un bouton d'arrêt d'urgence.
Autre bizarrerie, hors connexion, on peut faire tourner le palonnier en rotation continue, alors qu'ils ne sont pas prévus pour cela.

En attendant ma petite batterie, je lui fais faire des mouvements sur un piédestal. Le code n'est vraiment pas bien documenté et je me demande si je ne vais pas écrire le mien. Le problème, c'est que cela me prendra beaucoup de temps.
Mon objectif avec cette réalisation est d'avoir quelque chose qui fonctionne "rapidement" et d'extrapoler vers quelque chose de plus grand ou tout du moins de plus ambitieux.

Je trouve la programmation de l'Arduino très contraignante avec le cable USB, l'obligation d'arréter le programme manuellement.
Rien à voir avec le confort de l'EV3.

Cliquez moi.

[Oracid]

Premiers tests avec une batterie trop lourde. Cela fonctionne, mais très mal.
De plus, parfois, il y a un servo qui part en vrille et qui cogne violemment contre la structure.
Impossible de l'arrêter, même avec le bouton d'urgence qui provoque une interruption qui remet les servos au neutre (90°), mais à condition que le servo accepte la commande.
Je vais changer cela et couper directement l'alimentation, avec ce bouton.
Il n'est pas impossible que le Nano ait également un problème. Je pense que je vais le changer.

[Mike118]

As tu branché le 5V de la nano avec le 5V des servomoteurs ? Si c'est le cas cela peut expliquer un problème ... 

[Oracid]

As tu branché le 5V de la nano avec le 5V des servomoteurs ? Si c'est le cas cela peut expliquer un problème ...

Non, quand même !
Quoique, des fois, par inadvertance, je retire la Lipo 2S, avant l'USB. C'est pas bon, ça !
Il faut retirer l'USB avant la Lipo 2S, sinon il y a un petit moment ou c'est l'USB, et donc le Nano qui alimente les servos.

Mais, en fait, ce n'est pas le Nano. J'ai flingué 3 servos. J'ai l'impression que ces servos ne supportent pas le dépassement de couple, du fait qu'ils maintiennent très fermement la position.
J'ai contrôlé ces servos avec un autre Arduino qui me sert de testeur. C'est très net, ils sont morts, ils font n'importe quoi.

Le programme est pas mal et je pense en avoir compris les rouages principaux.
Mais, j'ai décidé de tout reprendre avec mon propre programme, https://www.robot-ma...rupede/?p=84015qui est plus rustique et que je maitrise parfaitement.
Là, au moins, je saurai si c'est les servos qui sont morts ou mon programme qui n'est pas bon.

[Mike118]

N'hésite pas à t'inspirer du travail de nulentout sur la sonde quadrupède jekert D'ailleurs je dois encore mettre en ligne le dernière ouvrage + des vidéos ... Honte à moi de ne pas avoir encore fait ça ... 

[Oracid]

N'hésite pas à t'inspirer du travail de nulentout sur la sonde quadrupède jekert D'ailleurs je dois encore mettre en ligne le dernière ouvrage + des vidéos ... Honte à moi de ne pas avoir encore fait ça ...

Oui, oui, j'y pense. J'ai lu tout le dossier au fur et à mesure de sa parution, mais je dois reconnaitre que je n'ai analyser le code.
La cinématique doit être plus compliqué, c'est un 3-DOF, alors que là, je travaille sur un 2-DOF.

[Oracid]

Sans commentaires…

[Path]

Mais mdr excellent mec !!

[cocothebo]

oh oh oh

 

Sinon sur le robot et pas le monsieur tout rouge, pourquoi il "boite" ton robot? La marche ne semble pas symétrique, c'est voulu ou c'est un problème de je ne sais quoi (calibration, servomoteurs différents, le froid, l'arrivée des fêtes, etc.).

[Oracid]

oh oh oh
Sinon sur le robot et pas le monsieur tout rouge, pourquoi il "boite" ton robot? La marche ne semble pas symétrique, c'est voulu ou c'est un problème de je ne sais quoi (calibration, servomoteurs différents, le froid, l'arrivée des fêtes, etc.).

Oui, j'étais assez pressé de publier ma petite vidéo avant ce soir.
Mais, pour un premier test, je suis assez satisfait. C'est vrais qu'il y a quand même un gros potentiel de progression…

En fait, cette cinématique est le résultat d'un programme que j'ai écrit.
Il s'agit d'un utilitaire très facile à mettre en oeuvre et qui devrait me permettre d'améliorer très sensiblement la cinématique.
J'ai prévu de le publier et d'en parler dans le courant de la semaine.

[Oracid]

Voici mon code.

Spoiler

/* This program tests the "simultaneous" kinematic of several servos - by Oracid. 26/12/2018 */
#include <Servo.h>

Servo mySrv[8];   // Indicate how many servos. Here 8 servos
const int nbSrv = sizeof(mySrv)/sizeof(Servo);

// quadruped forward
int Tabl[nbSrv][11]={ {110,100, 90, 80, 70, 60, 70, 80, 90,100,110},    // Indicate value angles of kinematic for each servo. 
                      { 70, 80, 90,100,110,120,110,100, 90, 80, 70},    // one ligne for one servo. First and last value should be equal
                      {110,100, 90, 80, 70, 60, 70, 80, 90,100,110},    // Number of lignes must be equal to number of servos
                      { 70, 80, 90,100,110,120,110,100, 90, 80, 70},    // the minimal foot should always be the same (here 10)
                      { 90, 90, 90, 90, 90,110,110,110,110,110, 90},    // if servo don't move, duplicate value
                      { 70, 70, 70, 70, 70, 90, 90, 90, 90, 90, 70},
                      { 70, 70, 70, 70, 70, 90, 90, 90, 90, 90, 70},
                      { 90, 90, 90, 90, 90,110,110,110,110,110, 90}};
                      
int lgTabl = sizeof(Tabl[1])/sizeof(int);
int Foot = abs(Tabl[0][0]-Tabl[0][1]);
int Speed = 2;                                                  // indicate the speed of kinematic
int SrvAdjust[nbSrv]={ 0, 5, 0, 9, 8, 2, -2, 4 };               // each servo need an adjustement position                        

void  setup() {
//  Serial.begin(9600); // uncomment out if debug
//  Serial.print("nbSrv = ");Serial.print(nbSrv);Serial.print("  lgTabl = ");Serial.print(lgTabl);Serial.print("  Foot = ");Serial.print(Foot);Serial.print("  Speed = ");Serial.println(Speed);
  mySrv[0].attach(8);   // servos attachments to Arduino outputs
  mySrv[1].attach(9);
  mySrv[2].attach(10);
  mySrv[3].attach(3);
  mySrv[4].attach(4);
  mySrv[5].attach(5);
  mySrv[6].attach(6);
  mySrv[7].attach(7);
//  Kinematic(&lgTabl, Tabl[0], &nbSrv, &Speed, &Foot, &SrvAdjust[0] );   // to test one cycle
}

void  loop() {
  Kinematic(&lgTabl, Tabl[0], &nbSrv, &Speed, &Foot, &SrvAdjust[0] );
}

void  Kinematic(int *lg, int *tb, int *nsrv, int *vel, int *foot, int *srvadjust){
int pos, srv, stp;
  for( int i=0; i < (*lg-1); i++){              // loop on the first line of the table
    for( stp = 0; stp < (*foot); stp++){        // loop on the step between two table values, here foot=10
      for(srv = 0; srv < (*nsrv); srv++){       // loop on the number of servos, here 8 servos
        if ( *(tb+(srv*(*lg))+i) >= *(tb+(srv*(*lg))+i+1) ){ pos=(*(tb+(srv*(*lg))+i))*(-1)+stp; }  // if current value is bigger than the next 
          else { pos=(*(tb+(srv*(*lg))+i))+stp; }                                                   // then pos is multiply by -1 so it can be incremanted to the next value
        if ( *(tb+(srv*(*lg))+i) == *(tb+(srv*(*lg))+i+1) ){ pos=(*(tb+(srv*(*lg))+i)); }           // if current and next value are equal then pos keep value
        mySrv[srv].write(abs(pos+(*(srvadjust+srv))));                                              // abs(pos) because when negative value
//        Serial.print("Tabl=");Serial.print(i);Serial.print(" srv=");Serial.print(srv);Serial.print(" pos=");Serial.println(abs(pos+(*(srvadjust+srv))));
        delay((*vel));
      }
    }
  }
}

Les éléments principaux de ce programme sont le tableau qui contient toutes les positions des servos et la fonction Kinematic().
Chaque ligne correspond à un servo. Chaque ligne contient les valeurs successives que doit prendre le servo.

La fonction Kinematic() consiste en 3 boucles imbriquées qui positionnent les servos au degré suivant.
Ainsi, l'impression de simultanéité des mouvements des 8 servos est excellente.

Description de la fonction Kinematic :
- La première boucle se positionne sur les colonnes du tableau.
---La deuxième boucle se positionne sur le pas (ici, le pas est de 10). Ce pas, ou un multiple, sépare deux valeurs sur la même ligne.
---c'est là que se fait la progression degré par degré.
-----La troisième boucle se positionne sur les lignes du tableau, c'est à dire sur les servos
---------la première condition teste si la valeur en cours est supérieure à la suivante. Si c'est le cas, on la multiplie par -1.
---------De cette manière, en incrémentant un nombre négatif, on décrémente sa valeur absolue.
--
---------la deuxième condition teste si la valeur courante est égale à la suivante.
---------Si c'est le cas, on conserve la même position pendant tout le pas
---------positionnement du servo au degré suivant avec la valeur absolue trouvée, augmentée de la dérive propre à chaque servo.
---------une temporisation permet de définir la vitesse de la cinématique.
-Fin

Cette fonction fonctionne parfaitement bien et bien entendu, je ferai une vidéo ces prochains jours.
Je veux dire l'année prochaine

Pour moi, ce programme constitue une grosse avancée de mon projet Gato. Et cela, sans faire appel à du code que je ne maitrise pas.

[Mike118]

Bon à défaut de l'avoir publié dans le blog dédié au projet BRIEL, car le projet est en stand bye complet depuis plusieurs mois et il risque de le rester encore longtemps, 

 

Je te partage le code tel qu'il l'est actuellement : 

 

Spoiler

//Bibliothèques :
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

#define NBSERVO 10

//Driver :
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

// Jambe1 
#define MIN0 93
#define MAX0 450
#define MIN1 96
#define MAX1 451
#define MIN2 101
#define MAX2 451
#define MIN3 105
#define MAX3 440
#define MIN4 111
#define MAX4 440

// Jambe2 
#define MIN5 165
#define MAX5 500
#define MIN6 145
#define MAX6 450
#define MIN7 124
#define MAX7 456
#define MIN8 152
#define MAX8 500
#define MIN9 155
#define MAX9 506

//120 457

// Tableau qui attribue à chaque servo sa place sur le driver pour 16 servo
uint8_t servomoteur[NBSERVO] = {0, 1, 2, 3, 5, 10, 12, 13, 14, 15};

//Servos :
//Liste des longueurs minimum d'impulsions pour - 90°
uint16_t servomoins90[NBSERVO] = {MIN0, MIN1, MIN2, MIN3, MIN4, MIN5, MIN6, MIN7, MIN8, MIN9};

//Liste des longueurs minimum d'impulsions pour + 90°
uint16_t servoplus90[NBSERVO] =  {MAX0, MAX1, MAX2, MAX3, MAX4, MAX5, MAX6, MAX7, MAX8, MAX9};



// Position Max orienté des servomoteurs en degrés
int8_t position90[NBSERVO] = {-90, -90, -90, -90,  90, -90,  90,  90,  90,  90};

// Offset pour palier au jeu des servo


int8_t limiteMax[NBSERVO] = { -90, -90, -90, -90,  90, -90,  90,  90,  90,  90};
int8_t limiteMin[NBSERVO] = {  30,  20,  90,  90, -10,  10, -90, -90, -20, -30}; 

int8_t accroupie[NBSERVO] =  {  0, -35, -90, -45,   0,  0,  45,  90,  35,   0}; 
int8_t position0B[NBSERVO] =  { 10,  10,  10,  10,  -5,  5, -10, -10, -10,  10};
int8_t position0[NBSERVO] =  { 0};
//int8_t agenou[NBSERVO] =   {  0, -99, -80,  65,   0,  0, -65,  90,  99,   0};
int8_t agenou[NBSERVO] =     {  -45, -90, -90,  65,  45,  -45, -65,  90,  90,  45};
int8_t demiEcart[NBSERVO] =  {-45,   0,   0,   0,   45, -45, 0,  0,    0,  45};

//int8_t pencheDroit[NBSERVO]= { 15,   0,   0,   0,   15, 15, 0,  0,  0,  15};


int8_t pencheDroit[NBSERVO]= { 25,   0,   0,   0,   10, -10, 0,  0,  0,  20};
int8_t leverGauche[NBSERVO]= { 10,   0, 0, 0,      15, 15, 45,  90,  35,  20};


int8_t pencheGauche[NBSERVO]= {-20,   0,   0,   0,   -15, 15, 0,  0,  0,  -25};
int8_t leverDroit[NBSERVO]= {  0,   -35, -90, -45,   -15, -15, 0,  0,  0,  -25};

int8_t lever[NBSERVO]= {  -90,   0, 0, 0,   20, -20, 0,  0,  0,  90};

int8_t currentPosisition[NBSERVO] = {0};


#define PAUSE 5000


void setup() {
  
 
  pwm.begin();
  pwm.setPWMFreq(50); //Fréquence utilisée par les servos analogiques
  montageJambeDroite();
  montageJambeGauche();
  
  
}

void loop() {
  //while(1){writePose(leverGauche);}
  //delay(PAUSE);
  //writePose(position0);
  //delay(PAUSE);
   goToPositionFluide( position0, 200);
   goToPositionFluide( accroupie, 200);
   goToPositionFluide( position0, 200);
   goToPositionFluide( lever, 200);
   goToPositionFluide( position0, 200);
   goToPositionFluide( demiEcart, 200);
   goToPositionFluide( position0, 200);
   goToPositionFluide( lever, 200);
   goToPositionFluide( demiEcart, 200);
   goToPositionFluide( position0, 200);
  goToPositionFluide( pencheGauche, 200);
  goToPositionFluide( leverDroit, 200);
  delay(PAUSE);
  goToPositionFluide( pencheGauche, 200);
  goToPositionFluide( position0, 200);
  
  goToPositionFluide( pencheDroit, 200);
  goToPositionFluide( pencheDroit, 200);
  goToPositionFluide( leverGauche, 200);
  delay(PAUSE);
   goToPositionFluide( pencheDroit, 200);
   goToPositionFluide( position0, 200);

  /*
    goToPositionFluide( position0, 200);

  */

   
   
   //goToPositionFluide( position0, 200);
   //goToPositionFluide( agenou, 200);
   
  

  //doubleFlexion(); // fluide
  //demiGrandEcart(); // direct
  //calibrageJambeDroite();
  //calibrageJambeGauche();

  //testSensJambeDroite();
  //testSensJambeGauche();
  //test90JambeDroite();
  //test90JambeGauche();
  //flexionJambeDroite();
  //flexionJambeGauche();
  //flexionCompenseJambeDroite();
  //flexionCompenseJambeGauche();
  //grandEcart(); // direct
  

 
}

void writeServo(uint8_t i, int8_t degree)
{
  uint16_t x = map(degree,-90, 90, servomoins90[i], servoplus90[i]);
  pwm.setPWM(servomoteur[i],0,x);
}

void calibrerServo(uint8_t i){
   writeServo(i, 0);
  delay(PAUSE);
  writeServo(i, 90);
  delay(PAUSE);
  writeServo(i, -90);
  delay(PAUSE);
}
void calibrageJambeDroite(){
   for(uint8_t i = 0; i< 5; i++) {
    writeServo(i, 0);
  }
  delay(PAUSE);
  for(uint8_t i = 0; i< 5; i++) {
    writeServo(i, 90);
  }
  delay(PAUSE);
  for(uint8_t i = 0; i< 5; i++) {
    writeServo(i, -90);
  }
  delay(PAUSE);
}

void calibrageJambeGauche(){
   for(uint8_t i = 5; i< 10; i++) {
    writeServo(i, 0);
  }
  delay(PAUSE);
  for(uint8_t i = 5; i< 10; i++) {
    writeServo(i, 90);
  }
  delay(PAUSE);
  for(uint8_t i = 5; i< 10; i++) {
    writeServo(i, -90);
  }
  delay(PAUSE);
}

void montageJambeDroite(){
  for(uint8_t i = 0; i< 5; i++) {
    writeServo(i, 0);
  }
}

void montageJambeGauche(){
  for(uint8_t i = 5; i< 10; i++) {
    writeServo(i, 0);
  }
}

void testSensJambeDroite(){
   for(uint8_t i = 0; i< 5; i++) {
    writeServo(i, 0);
  }
  delay(PAUSE);
  for(uint8_t i = 0; i< 5; i++) {
    writeServo(i, 30);
  }
  delay(PAUSE);
}

void testSensJambeGauche(){
   for(uint8_t i = 5; i< 10; i++) {
    writeServo(i, 0);
  }
  delay(PAUSE);
  for(uint8_t i = 5; i< 10; i++) {
    writeServo(i, 30);
  }
  delay(PAUSE);
}

void test90JambeDroite() {
  for(uint8_t i =0 ;i<255; i++ ){
    for(uint8_t j = 0; j < 5; j++) {
      writeServo( j, (position90[j]*i)/254 );
    }
  }
  delay(PAUSE);
  for(uint8_t i =255 ; i>0 ; i-- ){
    for(uint8_t j = 0; j < 5; j++ ) {
      writeServo(j, (position90[j]*i)/255 );
    }
  }
  delay(PAUSE);
}

void test90JambeGauche() {
  for(uint8_t i =0 ;i<255; i++ ){
    for(uint8_t j = 5; j < 10; j++) {
      writeServo( j, (position90[j]*i)/254 );
    }
  }
  delay(PAUSE);
  for(uint8_t i =255 ; i>0 ; i-- ){
    for(uint8_t j = 5; j < 10; j++ ) {
      writeServo(j, (position90[j]*i)/255 );
    }
  }
  delay(PAUSE);
}

void flexionJambeDroite() {
  for(uint8_t j = 0; j < 5; j++) {
     writeServo( j, 0 );
  }
  for(int i =0; i < 5; i++ ) {
    writeServo( 1, (position90[1] * i)/10 );
    writeServo( 2, (position90[2] * i)/5 );
    writeServo( 3, (position90[3] * i) /10);
    delay(110);
  }
  for(int16_t i = 5 ; i>0 ; i-- ) {
    writeServo( 1, (position90[1] * i)/10 );
    writeServo( 2, (position90[2] * i)/5 );
    writeServo( 3, (position90[3] * i)/10);
    delay(110);
  }
}

void flexionJambeGauche() {
  for(uint8_t j = 5; j < 10; j++) {
     writeServo( j, 0 );
  }
  for(int i =0; i < 5; i++ ) {
    writeServo( 8, (position90[8] * i)/10 );
    writeServo( 7, (position90[7] * i)/5 );
    writeServo( 6, (position90[6] * i) /10);
    delay(110);
  }
  for(int16_t i = 5 ; i>0 ; i-- ) {
    writeServo( 8, (position90[8] * i)/10 );
    writeServo( 7, (position90[7] * i)/5 );
    writeServo( 6, (position90[6] * i)/10);
    delay(110);
  }
}

void flexionCompenseJambeDroite() {
  for(uint8_t j = 0; j < 5; j++) {
     writeServo( j, 0);
  }
  for(int i =0 ;i<5; i++ ){
    writeServo( 1, position0[1] + (position90[1] *i)/10 );
    writeServo( 2, position0[2] + (position90[2] *i)/5 );
    writeServo( 3, position0[3] + (position90[3] *i) /10);
    delay(110);
  }
  for(int i = 5 ; i>0 ; i-- ){
    writeServo( 1, position0[1] + (position90[1] *i)/10 );
    writeServo( 2, position0[2] + (position90[2] *i)/5 );
    writeServo( 3, position0[3] + (position90[3] *i)/10);
    delay(110);
  }
}

void flexionCompenseJambeGauche() {
  for(uint8_t j = 5; j < 10; j++) {
     writeServo( j, 0);
  }
  for(int i =0 ;i<5; i++ ){
    writeServo( 8, position0[8] + (position90[8] * i) / 10);
    writeServo( 7, position0[7] + (position90[7] * i) / 5);
    writeServo( 6, position0[6] + (position90[6] * i) / 10);
    delay(110);
  }
  for(int i = 5 ; i>0 ; i-- ){
    writeServo( 8, position0[8] + (position90[8] * i) / 10);
    writeServo( 7, position0[7] + (position90[7] * i) / 5);
    writeServo( 6, position0[6] + (position90[6] * i) / 10);
    delay(110);
  }  
}

void doubleFlexion(){
  for(uint8_t j = 0; j < 10; j++) {
     writeServo( j, 0);
  }
  for(int i =0 ;i<5; i++ ){
    writeServo( 1, position0[1] + (position90[1] * i) / 10);
    writeServo( 2, position0[2] + (position90[2] * i) / 5);
    writeServo( 3, position0[3] + (position90[3] * i) /10);
    writeServo( 8, position0[8] + (position90[8] * i) / 10);
    writeServo( 7, position0[7] + (position90[7] * i) / 5);
    writeServo( 6, position0[6] + (position90[6] * i) / 10);
    delay(110);
  }
  for(int i = 5 ; i>0 ; i-- ){
    writeServo( 1, position0[1] + (position90[1] * i) / 10);
    writeServo( 2, position0[2] + (position90[2] * i) / 5);
    writeServo( 3, position0[3] + (position90[3] * i) / 10);
    writeServo( 8, position0[8] + (position90[8] * i) / 10);
    writeServo( 7, position0[7] + (position90[7] * i) / 5);
    writeServo( 6, position0[6] + (position90[6] * i) / 10);
    delay(110);
  }  
}

void grandEcart(){
  for(uint8_t i =0 ;i<255; i++ ){
    writeServo( 0, (position90[0]*i)/254 );
    writeServo( 4, (position90[4]*i)/254 );
    writeServo( 5, (position90[5]*i)/254 );
    writeServo( 9, (position90[9]*i)/254 );
  }
  delay(PAUSE);
  for(uint8_t i =255 ; i>0 ; i-- ){
    writeServo( 0, (position90[0]*i)/254 );
    writeServo( 4, (position90[4]*i)/254 );
    writeServo( 5, (position90[5]*i)/254 );
    writeServo( 9, (position90[9]*i)/254 );
  }
  delay(PAUSE);
}


void demiGrandEcart(){
  for(uint8_t i =0 ;i<127; i++ ){
    writeServo( 0, (position90[0]*i)/254 );
    writeServo( 4, (position90[4]*i)/254 );
    writeServo( 5, (position90[5]*i)/254 );
    writeServo( 9, (position90[9]*i)/254 );
  }
  delay(PAUSE);
  for(uint8_t i =127 ; i>0 ; i-- ){
    writeServo( 0, (position90[0]*i)/254 );
    writeServo( 4, (position90[4]*i)/254 );
    writeServo( 5, (position90[5]*i)/254 );
    writeServo( 9, (position90[9]*i)/254 );
  }
  delay(PAUSE);
}

void writeServoConstrain(uint8_t i, int8_t degree)
{
  degree = constrain(degree, min(limiteMin[i], limiteMax[i]), max(limiteMin[i], limiteMax[i]));
  writeServo( i, degree);
}


void updateCurrentPosition(int8_t *pose){
  for(uint8_t i=0; i<NBSERVO; i++){
   currentPosisition[i]= pose[i];
  }
}

void goToPositionFluide( int8_t *pose, uint16_t nbpose){
 for (uint16_t i = 0; i <nbpose; i++){
  for (uint8_t j=0; j<NBSERVO; j++) {
    writeServoConstrain( j,  (((int)i* (pose[j] - currentPosisition[j])) / (int)nbpose ) + currentPosisition[j]);
    //writeServo( j,  (((int)i* (pose[j])) / (int)nbpose ));
  }
  delay(1);
 }
 updateCurrentPosition(pose);
}

void writePose(int8_t *pose){
  for (uint8_t i = 0; i<NBSERVO ; i++){
    writeServo(i, pose[i]);
  }
}

Bien entendu il y a de grosses différences entre nos deux projets, BRIEL est un bipède, qui utilise un driver de servo ... Toi non mais au delà de ça les similitudes dans le fait d'utiliser des séquences pré enregistrer font que tu peux éventuellement t'inspirer de certaines idées qui sont présentes dans le code pour faire évoluer le tiens en le rendant plus " facilement utilisable " ... 

Dommage que je ne prenne pas d'avantage le temps de continuer la présentation de ce code étape par étape sur le blog de briel plutôt que de le lâcher comme ça d'un coup ... 

Si tu as des questions hésites pas ! ( Après avoir regardé le blog bien entendu qui explique une première partie de la démarche =) )


Joyeux Noël !

[Oracid]

Bien entendu il y a de grosses différences entre nos deux projets, BRIEL est un bipède, qui utilise un driver de servo ... Toi non mais au delà de ça les similitudes dans le fait d'utiliser des séquences pré enregistrer font que tu peux éventuellement t'inspirer de certaines idées qui sont présentes dans le code pour faire évoluer le tiens en le rendant plus " facilement utilisable " ...

J'ai survolé ton code. J'ai beaucoup de mal à lire le code d'une autre personne.
La calibration des servos est beaucoup plus critique pour un bipède que pour un quadrupède. Je vois que tu calibres le servo sur sa course de -90°,0°,90°. Puis tu fais un map sur la plage trouvée avant de positionner le servo. C'est très intéressant.
Ma calibration, je ne la fais que sur la position 90° (0 pour toi). C'est plus simple et moins précis, c'est certain. Mais c'est pour un quadrupède, donc beaucoup moins de risque. Je note l'idée en cas de nécessité. Cette manière de faire est somme toute assez classique et on peut voir quelque chose basé sur le même principe dans le fichier MiniKame.cpp posté plus haut.
C'est justement en essayant de décrypter ce fichier que j'ai décidé de faire mon propre programme.

Mon programme a pour simple objectif de tester très rapidement la mécanique avec une séquence de positions des servos.
Il n'y a rien d'autre à faire que d'indiquer le nombre de servos utilisée et de remplir le tableau avec ses propres valeurs.
Et ça marche !

[Mike118]

Je comprends ta démarche, et je comprends que tu trouves le code compliqué. Justement si je me suis lancé dans le blogs de briel c'était pour présenter les différentes parties du code au fur et à mesure avant qu'il ne devienne " complexe " ... 

 

Grosso modo pour reprendre tes mots, le but du code proposé, c'est de" facilement" pouvoir faire la calibration de tes servomoteurs avec des fonctions prévues à cet effet, et de définir des positions de servomoteurs à atteindre tout en fournissant  une fonction pour jouer les différentes positions. 
Tu peux demander de jouer n'importe quel des mouvements à la suite, il joura le mouvement en douceur en prenant en compte sa position actuelle.

Exemple concret de ce que permet le code proposé . 
Imaginons que pour avancer un quadrupède ait besoin de 8 positions intermédiaire : 
P0, P1, P2, P3, P4, P5, P6, P7 , joués dans cet ordre. 
Il peut être utile de savoir le jouer dans l'ordre inverse par exemple... Ainsi le robot reculerait ? 
Il peut aussi être utilie de le jouer dans un ordre différent pour que le robot soit capable de tourner .... 
 

Donc cela permet aussi de rapidement tester des séquence, mais le but c'est donc d'aller au delà du simple test  avec la proposition de briques de codes qui vont se retrouver dans le code final d'un robot opérationnel capable de décider dans quel direction il peut aller "à la volée" sans avoir à juste jouer que des séquences de positions.

 

Sur le principe le code est pensé pour que le robot puisse être interompu au milieu de la réalisation d'un mouvement, et il pourra repartir d'exactement où il s'est arrêté, avec un mouvement fluide sans avoir à finir son mouvement. 

Par contre je pense que si tu veux un bon résultat, la partie calibration / montage est une étape très importante ... 
Si tu veux fournir une démarche " symétrique " , identique, sans avoir des valeurs différentes un peu partout pour compenser d'eventuelles imprécisions liées aux moteurs et au montage ...  Je pense qu'une calibration avancée est indispensable avec ce genre de servomoteurs ...

[Oracid]

Sur le principe le code est pensé pour que le robot puisse être interompu au milieu de la réalisation d'un mouvement, et il pourra repartir d'exactement où il s'est arrêté, avec un mouvement fluide sans avoir à finir son mouvement.

Très intéressant.

Je suis bien convaincu par ce que tu dis. Mais il faut bien comprendre qu'une fois la vidéo faite, je passerai à un autre quadrupède.
Avec celui-là, j'aurais déjà beaucoup appris et de plus j'aurais fait un utilitaire très pratique pour la suite quite à l'améliorer en m'inspirant d'autres codes. Du tien, par exemple, merci d'avance.

Ceci dit, aujourd'hui, pas de problème ! Je vais en avant, en arrière, tourne à gauche et tourne à droite. Cela me suffit !
Je ne vais pas perdre mon temps à faire des figures de style ou le Moon Walk.
Je sais que cela se vend bien sur les vidéos, mais cela ne m'intéresse pas.