Piège araignée pour Halloween avec arduino

2367

Aujourd’hui on va apprendre à comment fabriquer un piège araignée pour halloween avec arduino.

Ce sont les tuto que je préfère créer ou l’on met en application ce que l’on a appris précédemment.

 

// Copyright https://retroetgeek.com

#define PIN_PWMA 9
#define PIN_AIN2 7
#define PIN_AIN1 6
#define PIN_STBY 5
#define PIN_POT  A0

#define PIN_INIT  4
#define PIN_FINCOURSE  3

#define PIN_SPEED 2

#define PIN_TRIG  10
#define PIN_ECHO  11
const unsigned long MEASURE_TIMEOUT = 25000UL;

// ici on definie la valeur d'un step de la roue 1 step = 0.85cm, un tour complet de ma roue donne 17cm
// how to calculate referenceStep   =>     size_of_whell / step_number = referenceStep
const float referenceStep = 0.85;
// ici on definie la valeur a déduire de la descente de l'araignée
// value in Cm to deduce to the final value ( heigth of spider ) 
const int reglage_spider = 15 ;
// temps avant prochain declenchement de l'araigne
// time after next start of spider 300000 => 5 min    
const int timer_spider = 10000 ;

int compteur = 0 ;
bool compteurBool = 0 ;
long tempsCompteur = 0;
int vitesse = 0 ;

long tempsArret = 0;

int nombreStep = 0;
bool learnBool = 1;
int ajustement = 0;

float objectif = 0;
int vitesseInit = 0 ;

long duration_hc, distance_hc;
int hauteurReference = 0 ;

void setup() {
//////Serial.begin(57600);
  pinMode(PIN_PWMA,OUTPUT);
  pinMode(PIN_AIN2,OUTPUT);
  pinMode(PIN_AIN1,OUTPUT);
  pinMode(PIN_STBY,OUTPUT);

  pinMode(PIN_SPEED,INPUT);

  pinMode(PIN_TRIG, OUTPUT);
  digitalWrite(PIN_TRIG, LOW);
  pinMode(PIN_ECHO, INPUT);

  pinMode(PIN_FINCOURSE, INPUT);
  pinMode(PIN_INIT, INPUT);

}

void loop() {

// il faut initialiser l'araignée pour la distance 
// when you push button init, init spider control height and in learn test low speed of motor and init to 0
  if(digitalRead(PIN_INIT) == HIGH ){
    ////Serial.println("Init");
    initSpider();
    learn();
  }
// déclenchement araignée
// launch spider if size of detected thing is more than 40 cm ( prevent if cat gon under :) )
  if(hauteurReference != 0 && (hauteurReference - mesureDistance()) > 40 ){
    if(distance_hc != 0){

      distance_hc-=reglage_spider;
      //Serial.print(hauteurReference);
      //Serial.print(" - ");
      //Serial.print(distance_hc);
      //Serial.println(" SPIDER");
      spider(distance_hc);
      delay(500);   
    }
  }
  else{
    delay(500);
  }
}

void initSpider(){
// on va attendre 3 secondes avant de mesurer la distance sans obstacle
  delay(5000);
  while(1){
    hauteurReference=mesureDistance();
    if(hauteurReference != 0 ){
      break;
    }
    delay(500);
  }
  //Serial.println("Mesure Ok");
  //Serial.println(hauteurReference);

}

// function pour mesurer la distance avec le capteur a ultrason
// function to mesure distance with ultrasonic sensor
int mesureDistance(){

  digitalWrite(PIN_TRIG, LOW);  
  delayMicroseconds(5); 
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10); 
  digitalWrite(PIN_TRIG, LOW);
 //,MEASURE_TIMEOUT
 pinMode(PIN_ECHO, INPUT);
  duration_hc = pulseIn(PIN_ECHO, HIGH,MEASURE_TIMEOUT);

  distance_hc = duration_hc / 58;
  //Serial.print("Distance "); 
  //Serial.println(distance_hc);  
  return distance_hc;
}

void learn(){
// objectif faire 40 step 
// objective of step for speed test
objectif = 40;
nombreStep = 0;
tempsArret=0;
analogWrite(PIN_PWMA,255);
digitalWrite(PIN_STBY,HIGH);

// on descend l'araignée un court instant et on remonte jusqu'au capteur de fin de course
//on met la vitesse au minimum et on monte la valeur jusqu'a ce que le capteur de vistesse change d'etat
// Firts we test slow speed test to know witch value we need for PWN

vitesseInit = 0 ;
bool moteurZero = digitalRead(PIN_SPEED);

long tempVitesseTempo = millis();
  while(1){
      analogWrite(PIN_PWMA,vitesseInit);
        digitalWrite(PIN_AIN1,LOW);
        digitalWrite(PIN_AIN2,HIGH);

      if(digitalRead(PIN_SPEED)== HIGH && compteurBool == 1){
        nombreStep++;
        compteurBool=0;
      }
      else if(digitalRead(PIN_SPEED)== LOW ){
        compteurBool=1;
      }

      if(vitesseInit >= 255 || nombreStep > 5 ){
        //Serial.println("Stop test lent");
        vitesseInit+=20;
        digitalWrite(PIN_AIN1,LOW);
        digitalWrite(PIN_AIN2,LOW);

        break;
      }
      if( millis() > (tempVitesseTempo + 500) ){

        vitesseInit+=10;
        //Serial.print("Vitesse plus ");
        //Serial.println(vitesseInit);
        digitalWrite(PIN_AIN1,LOW);
        digitalWrite(PIN_AIN2,LOW);
        delay(500);
        tempVitesseTempo = millis();
      }
      else{

      }

  }

//Serial.println(vitesseInit);
//Serial.println("Fin vitesse lente");
digitalWrite(PIN_AIN1,HIGH);
digitalWrite(PIN_AIN2,HIGH);
delay(2000);

// mesure  ecart vitesse ///////////////////////////////////////////////////////////
// Speed test to know how many step of error we got at maximum speed
nombreStep = 0;
analogWrite(PIN_PWMA,255);
  while(learnBool == 1){    
      if(digitalRead(PIN_SPEED)== HIGH && compteurBool == 1){
        nombreStep++;
        compteurBool=0;
      }
      else if(digitalRead(PIN_SPEED)== LOW ){
        compteurBool=1;
      }
//rotation dans un sens
      if(nombreStep >= objectif - ajustement ){
          digitalWrite(PIN_AIN1,HIGH);
          digitalWrite(PIN_AIN2,HIGH);
          if(tempsArret == 0){
            tempsArret=millis()+1000;
          }
                if(millis() >= tempsArret){
                // affichage du resultat combien de step j'ai fait en plus pour deduire la fois d'apres
                //Serial.print("le moteur a fait  ");
                 //Serial.println(nombreStep);
                  learnBool=0;                  
                  if(nombreStep - objectif != 0){
                    ajustement+= nombreStep - objectif;
                  }
                }
      }
      else{
          digitalWrite(PIN_AIN1,LOW);
          digitalWrite(PIN_AIN2,HIGH);
      }
  }

learnBool=1;
          digitalWrite(PIN_AIN1,HIGH);
          digitalWrite(PIN_AIN2,HIGH);

  delay(2000);

// fin test vitesse , on doit remonter l'araignée jusqu'a la fin de course
// end of test , spider go slowly to end stop 
//Serial.println("On remonte jusqu'a fin de course");
//Serial.println(vitesseInit);

  analogWrite(PIN_PWMA,vitesseInit);
  digitalWrite(PIN_AIN1,HIGH);
  digitalWrite(PIN_AIN2,LOW);

  // on memorise l'etat du step moteur pour eviter les blocages
  moteurZero = digitalRead(PIN_SPEED);
  tempVitesseTempo = millis();
  while( digitalRead(PIN_FINCOURSE) == LOW ){   

   // on bloucle ant que le fin de course n'est pas atteind
   // on verifie que le moteur ne se bloque pas
    if(moteurZero != digitalRead(PIN_SPEED)){
      moteurZero = digitalRead(PIN_SPEED);
      tempVitesseTempo = millis();      
    }

    if(millis() >=  (tempVitesseTempo + 2000 )){
      //Serial.println("Blocage fin de course fin de course");
      vitesseInit+=10;
      tempVitesseTempo = millis();
      analogWrite(PIN_PWMA,vitesseInit);
      moteurZero = digitalRead(PIN_SPEED);
    }

  }
  digitalWrite(PIN_AIN1,HIGH);
  digitalWrite(PIN_AIN2,HIGH);
  analogWrite(PIN_PWMA,255);

  delay(2000);
}

// Fonction araignée ////////////////////////////////////////////////////////////////////////////////////////////
// Spider function ,  we send value for spider
void  spider(int distanceSpider){
objectif=(distanceSpider/referenceStep);

  //Serial.println("dist spid");
  //Serial.print(distanceSpider);
  //Serial.println(" cm");

  //Serial.println("ref step");
  //Serial.println(referenceStep);

  //Serial.println("Objectif");
  //Serial.print(objectif);
  //Serial.println(" step");

tempsArret = 0;
nombreStep = 0;

float objectifModifie = 0;
// descente rapide
// quick down 
while(1){

      if(digitalRead(PIN_SPEED)== HIGH && compteurBool == 1){
        nombreStep++;
        compteurBool=0;
      }
      else if(digitalRead(PIN_SPEED)== LOW ){
        compteurBool=1;
      }

//rotation dans un sens
      if(nombreStep >= objectif - ajustement ){
          digitalWrite(PIN_AIN1,HIGH);
          digitalWrite(PIN_AIN2,HIGH);
          if(tempsArret == 0){
            tempsArret=millis()+1000;
          }
          break;
      }
      else{
          digitalWrite(PIN_AIN1,LOW);
          digitalWrite(PIN_AIN2,HIGH);
      }
}

// remontée rapide et lente
// quick up and slow
objectif-=20;
nombreStep = 0 ;
//Serial.print("obj - 20 = ");
//Serial.println(objectif);
if(objectif > 0 ){
  //Serial.println("Remonte rapide");
  while(1){
        if(digitalRead(PIN_SPEED)== HIGH && compteurBool == 1){
          nombreStep++;
          compteurBool=0;
        }
        else if(digitalRead(PIN_SPEED)== LOW ){
          compteurBool=1;
        }
  //rotation dans un sens
        if(nombreStep >= objectif - ajustement ){
            digitalWrite(PIN_AIN1,HIGH);
            digitalWrite(PIN_AIN2,HIGH);
            if(tempsArret == 0){
              tempsArret=millis()+1000;
            }
            break;
        }
        else{
            digitalWrite(PIN_AIN1,HIGH);
            digitalWrite(PIN_AIN2,LOW);
        }
  }
}

// Slow mode motor
//Serial.println("On remonte lentement");
// on remonte lentement
  analogWrite(PIN_PWMA,vitesseInit);
  digitalWrite(PIN_AIN1,HIGH);
  digitalWrite(PIN_AIN2,LOW);

  // on memorise l'etat du step moteur pour eviter les blocages
long  tempVitesseTempo = millis();
bool  moteurZero = digitalRead(PIN_SPEED);
  while( digitalRead(PIN_FINCOURSE) == LOW ){   

   // on bloucle ant que le fin de course n'est pas atteind
   // on verifie que le moteur ne se bloque pas
    if(moteurZero != digitalRead(PIN_SPEED)){
      moteurZero = digitalRead(PIN_SPEED);
      tempVitesseTempo = millis();      
    }

    if(millis() >=  (tempVitesseTempo + 2000 )){
      //Serial.println("Blocage fin de course fin de course");
      vitesseInit+=10;
      tempVitesseTempo = millis();
      analogWrite(PIN_PWMA,vitesseInit);
      moteurZero = digitalRead(PIN_SPEED);
    }

  }
  digitalWrite(PIN_AIN1,HIGH);
  digitalWrite(PIN_AIN2,HIGH);
  analogWrite(PIN_PWMA,255);

// Quand relancer l araigne ? temps necessaire avant prochain piege
// When do you start again spider
  delay(timer_spider);
}

En matériel il nous faut :
– 1 arduino mini pro ( ou autre )
– 1 module TB6612FNG
– 1 moteur 12V avec réducteur
– 1 speed encoder avec le moteur
– 1 end stop ( capteur fin de course )
– 1 opto interrupteur ITR9608
– 1 résistance 180Ω
– 1 bouton poussoir
– 3 résistance 1kΩ ou autre
– 1 capteur à ultrason HC-SR04
– 1 régulateurs de tension 5 V L7805 ou AMS117-5.0 5.0V 1A
– 2 condensateurs 25v 10μF

Pour alimenter le montage je vous conseille une alimentation secteur en 12V, mais il est possible de le faire fonctionner avec une pile 9V ( mais je ne connais pas l’autonomie) ou deux powerbank en parallèle avec un power booster ( ce que je vais utiliser ).

On transforme cette tension en 5v avec un régulateur de tension L7805  (ou AMS117-5.0 ) et 2 condensateur.

Le capteur a ultrason est branché sur le pin 10 de l’arduino avec le pin Trig et le pin 11 sur le pin Echo.

Pour le branchement du TB6612FNG rien de compliqué, VM pour la tension du moteur ( différente de l’arduino, on récupère le 7-12 Volt ), VCC ici on récupère le 5 Volt comme l’arduino, A01 et A02 pour le moteur A , PWMA branché sur le pin 9, AIN2 sur le pin 7, AIN1 sur le pin 6, STBY sur le pin 5 .

Le bouton init est branché sur le pin 4, le endstop sur le pin 3 et l’opto interrupteur ( partie récepteur ° ) sur le pin 2.

 

Pour le code je définis mes différents pin avec define comme dans tous les programmes.

Les valeur importantes à paramétrer sont :

– referenceStep qui définie la valeur quand la roue tourne et fait un step , ici la roue complète déroule 17cm et j’ai 20 steps donc ma valeur est 17/20=0.85 cm / step

– reglage_spider qui définie la valeur à déduire à la descente de l’araignée ici 15 cm

– timer_spider qui définie le temps à attendre avant la prochaine descente de l’araignée pour ne pas se déclencher toutes les secondes, j’ai mis 10 secondes actuellement  ( 10000 ) .

Pour tout le reste normalement il n’y a rien à toucher a part peut être dans le loop la condition ” (hauteurReference – mesureDistance()) > 40 ” ou 40 définie la taille minimum requise pour s’enclencher.

Dans le setup on initialise les pin rien de plus.

Partie boucle, ma première condition vérifie si le bouton init est appuyé et si oui lance initSpider et learn.

La fonction initSpider mesure la distance entre le capteur et le sol avec la fonction mesureDistance,  cette mesure va nous servir de référence pour la suite.

Et la fonction learn sert à initialiser la position de l’araignée et un réglage de la vitesse moteur ( test vitesse lente, test vitesse rapide et mesure écart de mesure, remonté lente jusqu’au endstop).

L’autre condition gère le déclenchement de l’araignée, si “l’objet” détecté dépasse de 40cm par rapport au sol alors on déclenche la fonction spider.

Dans la fonction spider la première phase l’araignée descend en vitesse rapide à la hauteur détectée, deuxième phase l’araignée remonte en vitesse rapide une grande partie de la distance et troisième phase l’araignée remonte doucement jusqu’au endstop.

Je suis assez bref dans la description du code mais je te laisse creuser sur le fonctionnement, si tu bloques sur certaines parties n’hésite pas à poser des questions.

A toi de jouer.
Télécharger le code :
Halloween Spider

N’hésitez pas à poser vos questions sur les réseaux sociaux de la chaîne instagramtwitter , facebook ,youtube ; si vous ne comprenez pas certaines parties du tutoriel n’hésitez pas , me dire ce que vous aimeriez que je crée pour en faire des vidéos tutoriel  et à partager les projets que vous aimeriez créer etc…

Comme toujours allez sur la page de C’est quoi Retro et Geek pour connaître tout ce que je recherche à faire sur la chaîne.

Merci les RetroGeeker et RetroGeekeuse