Un chronomètre géant automatique

Medium rtz1yzbw0hctyxcpsip1

Difficulté:

Comment savoir votre temps, quand vous faites des tours de pistes, sans avoir à appuyer sur un déclencheur de chronomètre ?


Bonjour à tous, dans ce tutoriel je vais vous apprendre à fabriquer un chronomètre automatique qui compte votre temps au tour. (Utilisé pour le sport)
Attendez tout d’abord, que je vous explique la raison pour laquelle j’ai fabriqué cet appareil. J’ai 16 ans et je pratique du roller de vitesse en compétition, pour cela je me suis fait un chronomètre géant et automatique, à l’aide d’une carte Arduino Mega 250. Il me permet de voir, en instantané, mon temps au tour de piste. Je m’entraîne avec le temps au tour de piste et non pas en km/h comme sur vélo de route. Avec une petite dizaine de coéquipiers, nous roulons sous forme de peloton. Afin que tout le monde puisse voir le temps au tour j’ai donc décidé de faire ce chronomètre géant (Notre rythme du temps au tour est tout le temps inférieur à 1 min c’est pour cela que mon chronomètre s’arrête à 60,00 secondes). Voila pour la petite histoire, passons maintenant à la partie construction de ce chronomètre.
Je suis encore en train de peaufiner et améliorer mon projet. J’avais d’abord fait un afficheur avec des LED vertes mais en pleine journée ensoleillé on ne voyait aucun chiffre apparaître. J’ai donc tout démonté et recommencé à zéro avec plus de LED rouges. Je vous montrerai donc mon deuxième chronomètre qui est, à peine finis niveau esthétique, mais qui fonctionne quand même très bien. Le but de ce chrono est de donner le temps au tour de tout le peloton et non seulement le temps d’une personne. Le principe est donc : le chrono se lance, on fait notre tour de piste et on passe devant le capteur. Au moment ou l’on passe devant le capteur, le chrono se relance (à 00:00) et l’afficheur affiche le temps pendant 10 secondes. Au même instant, le capteur s’éteint (pendant 10 secondes) pour ne pas prendre en compte le reste du peloton.

Matériel

Medium dvmyka0d7jbbdxqqlg0z

Budget:

40 €

Vous aurez besoins de :

-Un fer à souder ainsi que de l’étain
-Une troisième main (bien pratique)
-Une pince à dénuder et une pince coupante
-De quoi couper et percer du bois (perceuse, scie sauteuse de préférence)
-De quoi mesurer (mètre, règle,crayon de bois)
-Une scie à métaux ou un lapidaire
-deux planches de bois de 2mm(420×160) et de 15mm(540×160)
-Colle (pour coller les segments sur la planche de bois)
-Deux plaque à souder
-Des fils électriques
-Un câble téléphonique de 15m ou 4 fils électriques de 15m (pour relier le capteur au chronomètre)
-Du scotch chatertone
-Peinture
-Une carte Arduino Mega 250
-Une batterie pour alimenter la carte Arduino (Ici j’ai récupéré ma batterie de voiture télécommandé 7.2V)
-Un interrupteur
-28 résistances de 100 ohm (pour les 28 segments du chronomètre)
-224 LED rouges 5mm, 2V, Imax=30mA,(8 LED en dérivation par segments)
-Un capteur ultrason HC-SR04
( Pas très précis mais pas chère du tout. J’ai réussis il n’y a pas longtemps à avoir un capteur photoélectrique de 12V qui, du coup est bien plus précis. Cependant je ne l’ai pas encore mis au point. Je vous présenterai donc le chronomètre, avec un capteur utrason HC-SR04. D’ici quelques semaines je penses mettre dans les commentaires l’amélioration du chronomètre avec le capteur photoélectrique )

Etape 1 : Construction et soudure

Nous allons ici faire l’interface, ainsi que tout ce qui est construction du chronomètre en lui même. C’est la partie la plus longue. Dans cette première, aucune fonction informatique n’est pratiquée.
Tout d’abord, prenez la planche de 15 mm, découpez la de sorte à faire une planche de 420×160. Puis peignez la en noir. Tracez au verso de la planche les emplacements des segments, ainsi que les trous ou passeront les fils d’alimentation des segments. (Photo1)

Après, prenez vos plaques à souder afin d’en faire des segments de 7 cm de long. Découpez les avec le lapidaire ou une scie à métaux, pensez y le lapidaire a une lame épaisse donc prévoyez. (voir photo 2)

Peignez le, afin qu’il puisse être confondu avec la planche. Puis positionnez les LED et soudez les en dérivation. De même, soudez les fils à chaque bout de segments. Prévoyez une dizaine de centimètres pour la longueur des câbles. Pour vous donner un ordre d’idée, je passais environ 7 min par segment, le temps de positionner les LED, les souder, dénuder les fils…Donc 7 minutes multiplié par 28 segments = 3h 12min ! Bon courage 🙂 (voir photo 3)

Une foie tous ces segments fait, vous pouvez les placer et les fixer en les collant. Ainsi que passer les fils dans les trous prévus à cet effet. (photos 4 et 5)

Tout est collé ? Vous pouvez, maintenant, placer votre carte Arduino en la vissant à l’arrière au centre. Prévoyez aussi un endroit pour attacher la batterie. (Photos 6 et 7 )

Découpez maintenant votre plaque à souder de sorte à faire un rectangle de 50×30, pour souder 28 résistances. Celles-ci seront disposés face à face (photo 8) de sorte à laisser une tige d’environ 5mm pour qu’elles puissent s’enfoncer au bout de l’Arduino Mega. Cette partie est aussi très longue et surtout très précise.
Une foie toutes ces résistances soudées, vous allez maintenant relier les segments aux résistances. Attention à l’ordre !! Je vous mets ici les segments correspondant à chaque sortie de l’Arduino. Pensez aussi à relier tous les GND ensemble.
B C A G D F E
centième :{30,29,28,27,26,25,24}
dixième : {37,36,35,34,33,32,31}
secondes :{44,43,42,41,40,39,38}
dizaines : {51,50,49,48,47,46,45}

Ça y est, c’est presque finis, vous êtes maintenant libre de faire le reste. Je m’explique, comme mon projet est encore en cours, et que je tenais quand même à le partager avant la fin du concours, je n’ai pas fini l’interface de mon afficheur. Je veux le fermer en faisant un pavé de 60x160x420. Et si je trouve, mettre une plaque de plexiglas devant les LED.

NB : Afin de bien voir mon afficheur à bonne hauteur , je le pose sur un trépied d’appareil photo.

Etape 2 : Le capteur

Le capteur que j’utilise est un capteur ultrason HC-SR04 qui détecte jusqu’à 4m. Il n’est pas très précis mais assez pour mon utilité.Le capteur à quatres entrée/sorties. Une GND, une VCC, une sortie Echo que vous brancherez sur la pin 12 et une Trig qui se relie à la pin 11. Pour arrêter le capteur pendant quelques secondes, quand l’on passe devant, on fait un shunt entre la pin 13 et 2. (il faut les relier). Vous allez devoir créer un support pour le capteur pour qu’il ai une distance d’environ 50cm par rapport au sol. 50 cm car les ondes émettent un angle de 15° et si, on le met trop proche du sol, à 4m, le capteur détecte le sol.(photo 1) De plus, on place le capteur un quinzaine de mètres plus loin que l’afficheur afin que l’on puisse voir pendant quelques secondes notre temps. C’est pour cela q’on utilise un câble téléphonique de 15m.(photo 2)

NB: d’ici quelques temps j’utiliserais un capteur photoélectrique.(photo 3)

Etape 3 : La programmation

http://blog.ouiaremakers.com/wp-content/uploads/formidable/hc-sr04_ultrasonic_module_user_guidejohn.pdf

Nous voici dans la dernière partie qui est la programmation. Voilà, j’ai 16 ans et je ne suis bas très doué en programmation. Sachant que j’ai tout imaginé, il était difficile pour moi de faire ça tout seul. J’ai donc demandé de l’aide à des personnes pour programmer. Voila le programme, si des questions demandez dans les commentaires. Le programme contient deux LED pour séparer les secondes aux dixièmes de secondes, je ne les ai pas encore placés sur l’afficheur, mais vous pouvez très bien le faire.

Voici le code:

#include 

int distance = 20000;  // 1000 = 20 cm//pour détecter de 0 à 2 mètres,il faut mettre 10000
int temps_de_blocage = 10000; //pour 10 secondes

const int trigPin = 11;
const int echoPin = 12;
const int reportPin=13;
//shunt entre 13 et 2
volatile boolean capteur_ligne = true;
boolean depart = false;
int digit=0;
int valeur = 0;
boolean top = false;
boolean DPH = true;
boolean DPB = true;
unsigned long temps_top = 0;
unsigned long temps = 0;
unsigned long temps_start = 0;
unsigned long duree = 0;
unsigned long temps_au_tour;
unsigned long temps_au_top_interruption = 0;
unsigned long TempsHr = 0;
unsigned long TempsMn = 0;
unsigned long TempsSec = 0;
unsigned long TempsDix =0;
unsigned long TempsMil = 0;
//declaration des sorties pour segments
//                     B  C  A  G  D  F  E
const char centiemes[]{30,29,28,27,26,25,24};
const char dixiemes[]{37,36,35,34,33,32,31};
const char secondes[]{44,43,42,41,40,39,38};
const char diz_secondes[]{51,50,49,48,47,46,45};
//declaration des points décimaux
const char points[]{53,52};

void setup()
{
  Serial.begin(57600);
  noInterrupts();
  for (int f =24;f (temps_top + 1000)){DPH!=DPH;DPB!=DPB;digit=52;actionDigitalpoint(digit,DPH,DPB);temps_top = millis();}
  detection_passage();
  if ((capteur_ligne == false)& (depart == false))           // oui, il y a eu interruption "partiel"
    {
    depart = true;
    capteur_ligne = true;
    }
    else {}
  }
  
void loop() 
{ 
if (millis() > (temps_top+1000)){DPH!=DPH;DPB!=DPB;digit=52;actionDigitalpoint(digit,DPH,DPB);temps_top = millis();}
  if (capteur_ligne == true) 
  {
    detection_passage(); //si pas occupé suite à détection
  
  }
  temps = (millis() - temps_start);init_h_m_s();affichage(); 
  controle_si_interruption();
}

void detection_passage()
{
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(15);
  digitalWrite(trigPin, LOW);
  duree = pulseIn(echoPin, HIGH);
  //Serial.print(("detection passage duree retour = ")); Serial.println(duree);
  if (duree < distance) //pour 2m, il faut mettre environ 10000
  {
    capteur_ligne = false; 
    digitalWrite(reportPin, LOW);
}

}

void controle_si_interruption()
{
  if (capteur_ligne == false)            // oui, il y a eu interruption "partiel"
  {
      temps_au_top_interruption = millis();      //relevé du temps au tour                    
      temps = (temps_au_top_interruption - temps_start);
     
      temps_start = temps_au_top_interruption;
      
      init_h_m_s();
      affichage();
      
      while( (millis() = 10 )
    {digit=0;valeur=(TempsMn/10);/*aiguillage();*/}//Serial.print(F("TempsMn>10 = "));Serial.println(valeur);}//chiffre significatif pour dizaines de minutes
  else
    {digit=0;valeur=0;/*aiguillage();*/}//Serial.print(("TempsMn>>10 =0 = "));Serial.println(valeur);} //dizaines de minutes valent zero
 
  if (TempsMn < 10  )
    {digit=0;valeur=(TempsMn);/*aiguillage();*/}//Serial.print(F("TempsMn<10 = "));Serial.println(valeur);}//chiffre significatif pour minutes
  else
    {digit=0;valeur=0;/*aiguillage();*/}//Serial.print(("TempsMn<= 10)
  {digit=45;valeur=((TempsSec/10));aiguillage();} //chiffre significatif pour dizaines de secondes                   
  else
  {digit=45;valeur=0;aiguillage();} //dizaines de secondes valent zero
 
if (TempsSec = 100 )
  {digit=31;valeur=(TempsMil/100);aiguillage();}// chiffre significatif pour dixièmes de secondes
  else
  {digit=31;valeur=0;aiguillage();}// dixièmes de secondes valent zero

if ((TempsMil > 9 ))
//if ((TempsMil > 100 ) &(TempsMil > 9 ))
  {digit=24;valeur=((TempsMil/10)-((TempsMil/100)*10));aiguillage();}//chiffre significatif pour centièmes de secondes
  else
  {digit=24;valeur=0;aiguillage();}//centièmes de secondes valent zero
  //Serial.println((" = "));
  }
 
  
 
void aiguillage()
  {
        switch (valeur)
        { 
         case 0://             B C A G D F E    //chiffre 0
           actionDigital(digit,1,1,1,0,1,1,1);
           break ;
         case 1://             B C A G D F E    //chiffre 1
           actionDigital(digit,1,1,0,0,0,0,0);
           break ;
         case 2://             B C A G D F E    //chiffre 2
           actionDigital(digit,1,0,1,1,1,0,1);
           break ;
         case 3://             B C A G D F E    //chiffre 3
           actionDigital(digit,1,1,1,1,1,0,0);
           break ;
         case 4://             B C A G D F E    //chiffre 4
           actionDigital(digit,1,1,0,1,0,1,0);
           break ;
         case 5://             B C A G D F E    //chiffre 5
           actionDigital(digit,0,1,1,1,1,1,0);
           break ;                         
         case 6://             B C A G D F E    //chiffre 6
           actionDigital(digit,0,1,1,1,1,1,1);
           break ;       
         case 7://             B C A G D F E    //chiffre 7
           actionDigital(digit,1,1,1,0,0,0,0);
           break ;
         case 8://             B C A G D F E    //chiffre 8
           actionDigital(digit,1,1,1,1,1,1,1);
           break ;
         case 9://             B C A G D F E    //chiffre 9
           actionDigital(digit,1,1,1,1,1,1,0);
           break ;
         default:
         break;
       }
   }
 
   //                                B        C         A          G           D        F        E
  void actionDigital(int digit,byte un,byte deux,byte trois,byte quatre,byte cinq,byte six,byte sept)
  {
     digitalWrite(digit+6, un);           //Segment B
     digitalWrite(digit+5, deux);         //Segment C
     digitalWrite(digit+4, trois);        //Segment A
     digitalWrite(digit+3, quatre);       //Segment G
     digitalWrite(digit+2, cinq);         //Segment D
     digitalWrite(digit+1, six);          //Segment F
     digitalWrite(digit, sept);           //Segment E
  }

//                                           DPH           DPB
  void actionDigitalpoint(int digit,byte pointhaut,byte pointbas)
  {
     digitalWrite(digit+1, pointbas);    //Segment point bas
     digitalWrite(digit, pointhaut);     //Segment point haut
  }

void isr_ligne_franchie()              // routine d'interruption 0
{
  capteur_ligne = false;
  //depart == true;
}

Modifier mon Tutoriel

Vous aimez ce tutoriel ?


davidomo

07 juil. 2016 à 10:36

Bonjour,


auriez vous une petit vidéo pour voir ce jolie chronomètre en action

félicitation pour ce travail une boite avec plexiglas fumé devant et chrono de pro


Oh ça buzz

+ de 1 000 vues pour Un chronomètre géant automatique



Gotronic

Voir l'espace DIY gotronic


S'inscrire:


  • Vues: 1716
  • J'aime: 3