C'est un peu de temps je voulais construire un robot avec des jambes. En particulier, j'ai été fasciné par la possibilité de créer un mouvement fluide dans le robot, proche de la nature. Eh bien, j'ai découvert que ce n'est pas facile. La marche, qui nous semble une chose simple, est très complexe à réaliser pour un robot. Encore plus difficile si vous voulez faire un robot avec seulement 2 moteurs pour chaque jambe. Je tiens à remercier Oddbot pour son Quadrapod qui a inspiré la marche de mon chien robot. Je voulais aussi un robot qui interagit. Presque tous les quadrapods / hexapodes vous voyez simplement se promener. Au mieux, ils ont un capteur à ultrasons pour éviter les obstacles. En fait, la marche est souvent le but dans ce genre de petits robots. Mais pour moi, ce n'était pas assez, alors j'ai essayé de faire quelque chose de plus.
Une fois construit le châssis et installé les jambes, je pensais que ce serait bien aussi de faire une tête et une queue. La tête est faite avec un oeil composé, et un pan & tiltmovement que j'avais déjà utilisé pour le robot timide ( lien ). J'ai démonté et réutilisé elle. La queue est juste un servomoteur avec une feuille de papier enroulée autour d'elle-même.
C'est le chien:





Dans cette vidéo, il ya le test de robot marcheur. La tête et la queue ne sont pas présents.

Et puis la vidéo finale, avec les derniers réglages et la mise en œuvre de la tête et la queue. Le chien après un trajet de montrer ses compétences en tant que marcheur, attend. En approchant du chien, il s'ensuit la main avec sa tête. Mais si vous êtes trop près du chien recule. Tourner à gauche et à droite, le chien tourne le corps, à suivre la main.


Techniquement, le robot utilise 11 moteurs servo: 8 pour les jambes, 2 pour la tête et 1 pour la queue.

Quand j'ai vu le "M. General "robot par oddbot ( lien ), j'ai adoré. J'ai pensé qu'il est «expressif», une compétence difficile à trouver dans un robot construit à la maison. Donc j'ai construit ma version de Mr.General avec Arduino.
Le robot est basé sur le capteur composé des yeux un capteur infrarouge qui, avec un minimum de programmation, sait si
l'objet, aller de l'avant, va haut, bas, droite ou gauche.


Voici le robot:



Pour le bâtiment, en plus du capteur d'oeil composé, je deux équerres
avec deux servo-moteurs qui permettent le mouvement panoramique et
d'inclinaison, comme une tête. Aussi ceux-ci ont été fournies par le Dagu, qui a créé l'œil composé . Ces deux articles sont très pas cher: l'œil composé coûte 9 $, Pan et Tilt coûts 14,5 dollars, y compris les deux servomoteurs.
L'avantage d'utiliser la poêle et capteur d'inclinaison de la même compagnie est facilement compréhensible. Ils sont parfaitement intégrés et complétant parfaitement.

Pour compléter le robot, en plus de l'Arduino, j'ai utilisé deux servos
continu de rotation, un peu lanceur de roue et deux batteries, l'une
pour l'Arduino et un pour les servomoteurs (je vous recommande de
toujours utiliser des alimentations séparées avec un terrain d'entente) .
Le châssis est construit en utilisant une feuille de mousse PVC de 5 mm
qui a une incroyable facilité de modélisation (vous coupez avec un
couteau) et d'une résistance mécanique acceptable et la rigidité.
Qu'est-ce que fait le robot? C'est un robot timide. Il attend qu'un objet est en face.
Puis il commence, suit l'objet en mouvement devant lui, le regardant
comme un bon robot, en essayant de garder la bonne distance de l'objet. si l'objet va trop près, le robot s'enfuit, alors que si l'objet s'éloigne, le robot commence à chasser.
Voici le robot en action:


Voici le code complet:

Code:

#include <Servo.h>

#define IRleft 1 // Compound Eye Left - analog input A1
#define IRright 3 // Compound Eye Right - analog input A3
#define IRup 0 // Compound Eye Up - analog input A0
#define IRdown 2 // Compound Eye Down - analog input A2
#define IRleds 2 // Compound Eye LEDs - digital output D2

#define panPin 3 // PAN Servo - digital output D3
#define tiltPin 5 // TILt Servo - digital output D5
#define sServoPin 9 // Left Motor Servo - digital output D9
#define dServoPin 6 // Right Motor Servo - digital output D6

// definisci le costanti - define constants
byte LRscalefactor=10;  //fattore di scala - calibrare sui propri servi - calibrate depending on servo
byte UDscalefactor=10;  //fattore di scala - calibrare sui propri motori - calibrate depending on servo
// distanza minima per far muovere la testa - minimum distance to move the head
int distancemax=250;    //valore da trovare sperimentalmente - experimental value - adc value for analaog input for mimu
// distanza che provoca uno spostamento dei servi desto e sinistro - distance for moving the servos left and right
int bestdistance=450;  // valore da trovare sperimentalmente - experimental value - acd
int PanZero=78;        // stop servo di pan (destra - sinistra) - pan servo stop
int TiltZero=70;        //stop servo alto basso - tilt servo stop
int sMotorStop=90;      // stop servo sinistro - stop left servo
int dMotorStop=90;      // stop servo destro - stop right servo
int LRmax=170;          // max valore servo pan - pan servo max value
int LRmin=10;            // min valore servo pan - pan servo min value
int UDmax=170;          // max valore servo tilt - tilt servo max value
int UDmin=10;            // min valore servo tilt - tilt servo min value

// Definisci le variabili di appoggio - define global variables
int pan=PanZero;
int tilt=TiltZero;
int panscale;
int tiltscale;
int sSpeed=sMotorStop;
int dSpeed=dMotorStop;
int panOld;
int tiltOld;
int distance;
int temp;

// IR Sensors - sensori IR
int updown;
int leftright;
int leftIRvalue;
int rightIRvalue;
int upIRvalue;
int downIRvalue;

//Servomotors - Servomotori
Servo sMotor;
Servo dMotor;
Servo panLR;
Servo tiltUD;

void setup()
{
  // inizializza i servo e configura i pin
  // initialize servos and configure pins
  sMotor.attach(sServoPin);
  sMotor.write(sMotorStop);
  dMotor.attach(dServoPin);
  dMotor.write(dMotorStop);
  panLR.attach(panPin);
  panLR.write(PanZero);
  tiltUD.attach(tiltPin);
  tiltUD.write(TiltZero);

  pinMode (IRleds,OUTPUT);
}

void loop()
{
  // imposta velocità servi - speed servos set
  sMotor.write(sSpeed);
  dMotor.write(dSpeed);
  panLR.write(pan);
  tiltUD.write(tilt);

  IReye();  // leggi valori compound eye - read compound eye values
  IRfollow(); // imposta inseguimento - following set
}

void IReye()//===============================================================Read IR compound eye================================================
{
  digitalWrite(IRleds,HIGH);                                  // turn on IR LEDs to read TOTAL IR LIGHT (ambient + reflected) - attiva sensore IR (ambiente + riflessione)
  delay(5);                                                  // Allow time for phototransistors to respond - aspetta per permettere la risposta dei fototransistors
  leftIRvalue=analogRead(IRleft);                            // TOTAL IR = AMBIENT IR + LED IR REFLECTED FROM OBJECT
  rightIRvalue=analogRead(IRright);                          // TOTAL IR = AMBIENT IR + LED IR REFLECTED FROM OBJECT
  upIRvalue=analogRead(IRup);                                // TOTAL IR = AMBIENT IR + LED IR REFLECTED FROM OBJECT
  downIRvalue=analogRead(IRdown);                            // TOTAL IR = AMBIENT IR + LED IR REFLECTED FROM OBJECT
  delay(2);
  digitalWrite(IRleds,LOW);                                  // turn off IR LEDs to read AMBIENT IR LIGHT (IR from indoor lighting and sunlight)- spegni IR per leggere luminosità ambientale (luce interna + sole)
  delay(5);                                                  // Allow time for phototransistors to respond- aspetta per permettere la rispsta dei fototransistors
  leftIRvalue=leftIRvalue-analogRead(IRleft);                // REFLECTED IR = TOTAL IR - AMBIENT IR
  rightIRvalue=rightIRvalue-analogRead(IRright);              // REFLECTED IR = TOTAL IR - AMBIENT IR
  upIRvalue=upIRvalue-analogRead(IRup);                      // REFLECTED IR = TOTAL IR - AMBIENT IR
  downIRvalue=downIRvalue-analogRead(IRdown);                // REFLECTED IR = TOTAL IR - AMBIENT IR

  distance=(leftIRvalue+rightIRvalue+upIRvalue+downIRvalue)/4;// distance of object is average of reflected IR - la distanza dell'oggetto è la media di quanto riflesso dal sensore IR
}

void IRfollow ()//==============================================Track object in range================================================================
{
  // ferma servi - stop servos
  sSpeed=sMotorStop;
  dSpeed=dMotorStop;

  // se il valore restituito è basso, significa che non ci sono oggetto vicini
  // if the value read is low, there aren't object in front of the sensor
    if (distance<distancemax)
  {
    // riporta il sensore in posizione di riposo - reset the sensor at zero position
    if (pan>PanZero)pan=pan-1;
    if (pan<PanZero)pan=pan+1;
    if (tilt>TiltZero)tilt=tilt-1;
    if (tilt<TiltZero)tilt=tilt+1;

  }
  else
  {
    //-------------------------------------------------------------Track object with head------------------------------------------------
    panscale=(leftIRvalue+rightIRvalue)*LRscalefactor/10; //fattore di scala - scale value
    tiltscale=(upIRvalue+downIRvalue)*UDscalefactor/10; // fattore di scala - scale value

    // se sinistra gira a sinistra la testa - if left, turn left the head
    if (leftIRvalue>rightIRvalue)
    {
      leftright=(leftIRvalue-rightIRvalue)*15/panscale;
      pan=pan-leftright;
    }
    // se destra gira a destra la testa - if right, turn right the head
    if (leftIRvalue<rightIRvalue)
    {
      leftright=(rightIRvalue-leftIRvalue)*15/panscale;
      pan=pan+leftright;
    }

    // se alto, gira in alto la testa - if up, turn up the head
    if (upIRvalue>downIRvalue)
    {
      updown=(upIRvalue-downIRvalue)*15/tiltscale;
      tilt=tilt+updown;
    }

    // se basso, gira in basso la testa - if up, turn up the head
    if (downIRvalue>upIRvalue)
    {
      updown=(downIRvalue-upIRvalue)*15/tiltscale;
      tilt=tilt-updown;
    }

    panOld=pan;
    tiltOld=tilt;
    if (pan<LRmin) pan=LRmin;
    if (pan>LRmax) pan=LRmax;
    if (tilt<UDmin)tilt=UDmin;
    if (tilt>UDmax)tilt=UDmax;

    //-------------------------------------------------------------Turn body to follow object--------------------------------------------
    // se la testa si gira più di 60 gradi, gira anche il corpo - if the head turn more than 60 degrees, turn the body
    temp=LRmax-panOld;
    if (temp<60)
    {
      sSpeed=sMotorStop-50+temp/2;
      dSpeed=dMotorStop-50+temp/2;
    }
    temp=panOld-LRmin;
    if (temp<60)
    {
      dSpeed=dMotorStop+50-temp/2;
      sSpeed=sMotorStop+50-temp/2;
    }

    //------------------------------------------------------Move forward or backward to follow object------------------------------------
    // se l'oggetto è a distanza inferiore a quella bestdistance, muovi per tornare a quella distanza
    // if the object distance is less than bestdistance, move the robot to go again to the same distance
    temp=distance-bestdistance;
    temp=abs(temp);

    if (temp>10)
    {
      temp=temp-10;
      if (distance>bestdistance)
      {
        dSpeed=dSpeed-temp/3;
        sSpeed=sSpeed+temp/3;
      }
      else
      {
        dSpeed=dSpeed+temp/3;
        sSpeed=sSpeed-temp/3;
      }
    }
  }
}