Un bolide saisissant

L’analyse du mouvement d’un bolide offre plusieurs possibilités d’apprentissages pour le 2e cycle du secondaire. Dans la présente page, nous vous proposons un plan pour faire construire des robots qui ont pour but d’écrire sur une carte mémoire la position du bolide en fonction du temps.

Note aux débutants : La présente documentation a pour but d’inspirer, non pas d’être copiée-collée sans comprendre le programme et les circuits. Car le copier-coller en Arduino ne fonctionne pas nécessairement.

PFEQ

Ce projet peut être construit par des élèves du 1er ou 2e cycle du secondaire (projet technologique) et exploité (données) en 4e secondaire, science et technologie (ATS) ainsi qu’en mathématique (TS).

En ajoutant un accéléromètre pour avoir les valeurs d’accélération instantanée (en x, y, z), le bolide devient intéressant pour le cours de physique 5e secondaire (les analyses du mouvement sur un plan incliné, F=ma, etc.). On peut travailler le frottement également en attachant une masse (faire varier la surface de contact, la masse, etc.) derrière le bolide pour avoir une autre valeur d’accélération.

Mise à jour 19 avril : Voir ce fichier GeoGebra pour une analyse de données recueillies avec le bolide. Ce fichier contient des calculs pour trouver l’accélération (physique 5e secondaire).

Construction

Attention! Afin d’éviter des bris (suite à la manipulation fréquente des pièces) voir ces conseils.

Comme pour la plupart des projets avec Arduino, nous avons besoin de matériel électronique ainsi que d’autres pièces comme des roues, un châssis, etc. Voici la liste que nous vous proposons.

Matériel

Note : Les liens ci-dessous sont à titre indicatif, d’autres fournisseurs peuvent avoir de meilleurs prix.

1. Roues (elles doivent être insérées dans l’encodeur)
2. Essieux (on peut les couper à la bonne longueur)
3. Rondelles (optionnelles : elles serviront à diminuer le frottement entre les roues et le châssis)
4. Bloc piles avec interrupteur (permet de démarrer la saisie avec son interrupteur, mais les piles doivent être chargée, voir cet article pour l’alimentation d’une carte Arduino)
   1. Autre choix : pile 9V et ce connecteur
   2. Autre choix : 2 piles 3.7 V (chargeur et piles, bloc, piles)
5. Blindage pour acquisition des données
6. Module Arduino
7. Encodeur (c’est ce qui nous permet de mesurer la distance parcourue)
8. Châssis (plusieurs types de matériaux peuvent être utilisés ici, nous vous suggérons ceci. Si vous avez une imprimante 3D, imprimez!)
9. Total : environ 25$ (si on en fait une dizaine)

Notre montage utilise ici une demi-descente de gouttière comme châssis. Peu dispendieux, suffisamment solide, peut être facilement percé, ce châssis répond à nos critères (besoins pour le présent robot).

Le dessous du bolide contient le capteur boulonné au châssis. Nous avons retiré la roue pour ne garder que les rayons qui passent entre l’émetteur et le récepteur infrarouge (5 interruptions par tour de roue).

On peut également utiliser une roue ( 0,20$ par roue) comme l’image ci-dessous pour augmenter le nombre d’obstacles (interruptions) par tour de roue. Des tests seront à réaliser pour valider si la précision est meilleure.

Schéma électrique

Le schéma électrique est assez simple, nous utilisons le blindage «data logging» présenté/documenté dans cet article pour inscrire les données sur une carte SD. Le capteur utilisé est nommé «speed sensor», il nous permet de compter le nombre de fois qu’un objet passe entre son émetteur infrarouge et son récepteur.

Note : Nous utilisons ici la sortie A0 (connectée à la broche numérique 2 de l’Arduino) sur le capteur, car la sortie D0 (numérique) ne fonctionne pas correctement(nous cherchons pourquoi).

Capteur

Le capteur envoie un signal lorsque passe un obstacle entre son émetteur et son récepteur infrarouge qui est compté grâce à la fnct_compter (voir https://www.arduino.cc/en/Reference/AttachInterrupt ). On affiche sur le moniteur série le nombre d’interruptions total à toutes les secondes. Voici le code (merci à Jean-François Garneau pour son aide) :

int compteur = 0 ;

void setup() {
 attachInterrupt(0, fnct_compter, RISING ); // broche numérique 2
 Serial.begin(9600); 
}

void fnct_compter() { //on ajoute +1 à chaque interruption envoyée par le capteur
 compteur++;
}

void loop() {
 Serial.println( compteur );
delay(1000);
}

Calcul distance

Pour connaître la distance parcourue par le bolide il faut trouver la formule qui permettra de la calculer. Les variables sont la circonférence de la roue, nombre d’obstacles (interruption du capteur) par tour de roue. À vous de jouer!

Programmation

Nous avons maintenant tous les morceaux pour programmer notre robot à entrer des données de position en fonction du temps. Voici notre programme commenté (si vous avez des questions, n’hésitez pas à nous contacter à pierres@recitmst.qc.ca) :

/*Exemple de code pour prendre des données et les écrire sur une carte SD 
RÉCIT MST 2016, version du 21 avril 2016
Inspiration http://www.worldofgz.com/electronique/ecrire-et-lire-des-donnees-sur-une-carte-sd/
http://tiptopboards.free.fr/arduino_forum/viewtopic.php?f=5&t=68
http://forum.arduino.cc/index.php?topic=107367.0
*/
#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "RTClib.h"

RTC_DS1307 rtc;

File fichierSD;

int initial;
int compteur = 0 ;
unsigned long time;
double duree;
float distance;

void setup() {
 Serial.begin(9600);
 pinMode(6,OUTPUT);
 pinMode(5,OUTPUT);
 initial=1;
//Pour la carte SD=======================================
 //Initialisation de l'instance
 if(!SD.begin(10)) {//10 pour notre carte, peut etre different
 Serial.println(F("Initialisation impossible !"));
 initial=0;
 return;
 }
 Serial.println(F("Initialisation OK"));
//Fin carte SD====================================================

//Pour l'horloge===============================================
 #ifdef AVR
 Wire.begin();
 #else
 Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
 #endif
 rtc.begin();

 if (! rtc.isrunning()) {
 Serial.println("RTC ne fonctionne PAS!");
 // La ligne qui suit ajuste le RTC à la date et time du moment de compilation(si connectee a ordinateur)
 rtc.adjust(DateTime(__DATE__, __TIME__));
 }
//Fin horloge======================================================

//Pour le capteur ===============================================
 pinMode(2, INPUT_PULLUP);//broche numérique 2 sur Arduino
 attachInterrupt(digitalPinToInterrupt(2), fnct, CHANGE);
 
//Fin capteur

}

void loop() {
 time = millis(); //pour augmenter la précision des données (si nécessaire)
 DateTime now = rtc.now();
 distance = compteur*0.136425648; //formule pour notre bolide donne distance en cm, à vous de trouver la vôtre ;-)
 duree = time/1000.0;
//On envoie dans le moniteur série l'info écrite, pour vérifier si tout fonctionne
 /* Serial.print(now.year(), DEC);
 Serial.print('/');
 Serial.print(now.month(), DEC);
 Serial.print('/');
 Serial.print(now.day(), DEC);
 Serial.print(' ');
 Serial.print(now.hour(), DEC);
 Serial.print(':');
 Serial.print(now.minute(), DEC);
 Serial.print(':');
 Serial.print(now.second(), DEC);
 Serial.print(';');
 Serial.print(duree);//On inscrit la durée depuis le début du programme
 Serial.print(";");
 Serial.println(distance);
*/
//On nomme le fichier selon la date, donc toutes les donnees prises le meme jour dans un seul fichier==========
 char datafile[13];
 int jour=now.day();
 int mois = now.month();
 int annee= now.year(); 
 sprintf(datafile,"%02d%02d%04d.csv",jour,mois,annee); // %d pour un int, 2 pour 2 chiffres
 datafile[13]='\0';
//Fin nommer fichier===============================================

//Ouverture du fichier==============================================
 fichierSD = SD.open(datafile, FILE_WRITE);
 

 //Test pour écriture
 if(fichierSD && initial==1) {

 Serial.println(F("Ecriture en cours"));
 digitalWrite(6,HIGH);//DEL verte pour OK
 //Ecriture
 maintenant();//fonction qui écrit la date et heure de la prise de donnée
 fichierSD.print(',');//séparateur = , pour importation simple dans Geogebra voir https://www.geogebra.org/m/3230177
 fichierSD.print(duree,3);//On inscrit la durée depuis le début du programme. print(val,NOMBRE_DECIMAL)
 fichierSD.print(",");
 fichierSD.println(distance);//distance en cm
 fichierSD.close();
 }
 else { analogWrite(5,255);//DEL rouge pour problème
 
 }
 //Fermeture du fichier avec une ligne de plus============
 
 delay(10);//on laisse respirer le robot, mais on prend le plus de données possible.
}

//Fonction qui écrit la date et l'heure dans le fichierSD===
void maintenant() {
 DateTime now = rtc.now();
 
 fichierSD.print(now.year(), DEC);
 fichierSD.print('/');
 fichierSD.print(now.month(), DEC);
 fichierSD.print('/');
 fichierSD.print(now.day(), DEC);
 fichierSD.print(' ');
 fichierSD.print(now.hour(), DEC);
 fichierSD.print(':');
 fichierSD.print(now.minute(), DEC);
 fichierSD.print(':');
 fichierSD.print(now.second(), DEC);
}

//Fonction pour le capteur===================================
void fnct() {
 compteur++;
}

Bonne saisie de données!