Hungry Robot

Erreur lors de la création de la miniature : Fichier avec des dimensions supérieures à 12,5 MP

Description

Qui n'a jamais trouvé la tâche de nettoyage rébarbative ? Après le bricolage ou des des expériences, il y a toujours des morceaux qui traînent, des bouts de paille, des gaines, des morceaux de papier... Avec le Hungry Robot, fini l'ennui ! Ce petit robot pratique et amusant vous facilitera le ménage ! Vous venez de dénuder un fil ? Il le mange. Des bouts de papier ? De même. Des morceaux de cure-dent ? Il l'avale sans hésiter ! De plus, le Hungry Robot peut se déplacer. Placez-le d'un côté de la table, il la parcourra, permettant à tous vos convives de se délester de leurs détritus.

Matériel nécessaire

• Une carte Arduino
• Du fil électrique
• Un interrupteur
• Deux servo-moteurs
• Un capteur de distance
• Une pince à dénuder
• Une plaque labdec
• Une boîte en carton
• Une bouteille ou un gros bocal en plastique
• Un petit bocal cylindrique en plastique
• Des bouchons en liège
• De la patafix
• Un pistolet à colle chaude
• Une découpeuse laser
• Une pile
• Un adaptateur pile à alimentation de la carte arduino

Coque

La structure du Hungry Robot est constituée de deux parties :

La poubelle

La partie avant du robot est la partie qui avalera vos déchets. Elle est constituée d'un bocal rond surmontée d'une tête articulée, ainsi que de bras qui tiennent un bac. Le capteur est fixé à l'avant, juste au-dessus du bac.

Le chariot

La partie arrière du robot se compose en un bac en carton dans lequel sera inséré la carte arduino, le board et la poubelle. La jambe du robot est un assemblage articulé lui permettant d'avancer comme une chenille.

Montage électrique

Arduino

Le montage est centralisé autour d'une carte Arduino Uno, sur laquelle est branchée tous les composants électroniques.

Servo moteurs

Deux servo moteurs sont utilisés : un pour monter et descendre le bac, et un pour faire bouger la jambe du robot.

Capteur

Un capteur de distance à ultrasons placé à l'avant du robot permet de détecter une main mettant quelque chose dans le bac.

Interrupteur

Un interrupteur est prévu pour choisir si le robot doit avancer ou non.

Code Source

#include <Servo.h>

// CONFIG SERVOS ----------------------------------

Servo servo_chariot;  // Servo du chariot
Servo servo_poubelle; // Servo de la poubelle

/* Pin des servos */
const byte PIN_CHARIOT = 4;
const byte PIN_POUBELLE = 5;

/* Booléen d'activation des servos */
bool SERVO_CHARIOT_ON = 0;
bool POUBELLE_ON = 0;

// CONFIG CAPTEUR ---------------------------------

/* Constantes pour les broches */
const byte TRIGGER_PIN = 2; // Broche TRIGGER
const byte ECHO_PIN = 3;    // Broche ECHO

/* Constantes pour le timeout */
const unsigned long MEASURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s

/* Vitesse du son dans l'air en mm/us */
const float SOUND_SPEED = 340.0 / 1000;

/* Distances (mm) */
const unsigned int CAPTEUR_BAC = 80;
const unsigned int MIN_D = 20;
float distance = 0;

// CONFIG SWITCH
const byte PIN_SWITCH = 6;

// CONFIG TEMPORELLE ------------------------------

/* Variables de temps */
unsigned long dt = 0;
unsigned long mesure_prev_dt = 0;
unsigned long servo_prev_dt = 0;

/* Constantes de temps */
const int MESURE_DT = 50;
const int SERVO_DT = 500;

//##################################################

void setup() {
  Serial.begin(9600); // Monitor

  // SERVO CHARIOT
  servo_chariot.attach(PIN_CHARIOT);  // Attache le servo du chariot au Pin 9
  servo_chariot.write(0);             // Init position chariot
  delay(SERVO_DT);

  // SERVO POUBELLE
  servo_poubelle.attach(PIN_POUBELLE);  // Attache le servo de la poubelle au Pin 8
  servo_poubelle.write(0);              // Init position poubelle
  delay(SERVO_DT);

  // CAPTEUR POUBELLE
  /* Initialise les broches */
  pinMode(TRIGGER_PIN, OUTPUT);
  digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
  pinMode(ECHO_PIN, INPUT);

  // SWITCH
  pinMode(PIN_SWITCH, INPUT);
  
  Serial.println("Setup Done !");
}

//##################################################

void loop() {
  /* Temps */
  dt = millis();

  if(dt - mesure_prev_dt >= MESURE_DT){
    distance = mesure(0);
    mesure_prev_dt = dt;
    if((distance > MIN_D) && (distance < CAPTEUR_BAC)){
       /* On vérifie si on detecte qq hose devant le capteur */
      POUBELLE_ON = 1;
    }
  }

  if(POUBELLE_ON){
    /* Activation de la poubelle */
    
    delay(2*SERVO_DT);
    Serial.println("    Mange on");
    servo_poubelle.write(140);      //Bras levé
    delay(SERVO_DT);
    Serial.println("    Mange off");
    servo_poubelle.write(0);       //Bras baissé
    delay(2*SERVO_DT);
    POUBELLE_ON = 0;
    
  } else {
    /* Si pas de poubelle et switch on, marche */

    if(digitalRead(PIN_SWITCH)){
      if(dt - servo_prev_dt >= SERVO_DT && !SERVO_CHARIOT_ON){
        /* Avancer la jambe */
        Serial.println("Bouge on");
        servo_chariot.write(90);   //Avance Jambe
        SERVO_CHARIOT_ON = 1;
        servo_prev_dt = dt;
        
      } else if(dt - servo_prev_dt >= SERVO_DT && SERVO_CHARIOT_ON){
        /* Reculer la jambe */
        Serial.println("Bouge off");
        servo_chariot.write(0);     //Recul Jambe 
        SERVO_CHARIOT_ON = 0;
        servo_prev_dt = dt;
      }
    }
  }
}

//##################################################
/* Fonction de mesure du capteur */

float mesure(bool show){
  digitalWrite(TRIGGER_PIN, HIGH);
  delay(10);
  digitalWrite(TRIGGER_PIN, LOW);
  
  /* Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
  long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);
   
  /* Calcul la distance à partir du temps mesuré */
  float distance_mm = measure / 2.0 * SOUND_SPEED;
   
  /* Affiche les résultats en mm, cm et m */
  if(show){
    Serial.print(F("Distance: "));
    Serial.print(distance_mm);
    Serial.print(F("mm ("));
    Serial.print(distance_mm / 10.0, 2);
    Serial.print(F("cm, "));
    Serial.print(distance_mm / 1000.0, 2);
    Serial.println(F("m)"));
  }

  return distance_mm;
}