View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

Expérience : mesure du temps de chute d'un corps et calcul de la constante de gravité


ARDUINO Par X. HINAULT - Page créée le 03/03/2010

Source image

Description

Cette expérience se donne pour objectif de mesurer à l'aide d'une carte Arduino, le temps de chute d'un corps. Par voie de conséquence, la constante de gravité doit pouvoir être calculée, connaissant la hauteur de la chute.

Fondements théoriques

Pour faire simple, on a :

d'où :
avec :

  • g : la constante de la gravitation (m.s-2)
  • x : la hauteur (m)
  • t : le temps (s)

Ainsi, en connaissant t(le temps de la chute) et x (la hauteur), on peut estimer la constante gravitationnelle g.

Pour mémoire :

Ressources utiles

Cette page m'a été inspirée en visionnant un des excellents cours vidéo de physique du MIT du très didactique Prof Walter Lewin disponible en ligne. Si vous avez un peu de temps, je vous le conseille (en anglais) :

Quelques pages utiles :

Montage de l'expérience

L'idée de l'expérience est la suivante :

  • utiliser un électro-aimant pour déclencher la chute d'un corps
  • un bouton poussoir dans l'axe de la chute détecte l'impact du corps
  • un bouton poussoir de commande permet également d'activer l'électro-aimant
  • un autre bouton poussoir de commande permet de déclencher la chute du corps et la mesure du temps de chute.
  • une LED visualise la mise sous tension de l'électro-aimant
  • une seconde LED sert de témoin d'impact, assurant que l'impact est bien pris en compte.

Matériel de l'expérience :

  • Côté électronique :
    • une carte Arduino
    • 2 BP classiques
    • 1 BP préparé pour l'impact (mettre juste une plaque de bois en contre-plaqué posée dessus)
    • 1 CI ULN 2803
    • une alim 12V externe
  • Côté mécanique :
    • un électro-aimant 12V (de récup en ce qui me concerne)
    • un support réglable en hauteur : du tuyau de cuivre de plomberie avec un support à vis réglable qui coulisse
    • un objet métallique utilisé pour la chute. Noter que le poids n'a pas d'importance : pas trop gros mais pas trop petit non plus car la chute doit déclencher l'impact. Personnellement, j'ai utilisé un poids de 50g environ.

Principe du programme

L'idée ici est de calculer très précisément le temps de chute d'un poids entre le moment où l'électro-aimant est désactivé et le moment où le bouton poussoir de détection est appuyé. On mémorise la valeur de la fonction micros au déclenchement de la chute et on mémorise à nouveau la valeur de cette fonction au moment de l'impact. La différence entre les 2 donne le temps de la chute en microsecondes.

Le calcul de la constante G est obtenu en appliquant la formule déjà vue :

Fonctionnement

  • Au préalable, modifier la hauteur dans le programme en fonction de la hauteur utilisée ainsi que le délai de déclenchement qui sera variable d'un électro-aimant à l'autre.
  • Ouvrir le moniteur série
  • Activer l'électro-aimant par appui sur le BP ON
  • Positionner l'objet métallique et vérifier que le BP Impact est bien dans l'axe
  • Déclencher la chute par appui sur le BP GO : attention, çà va très vite (500 ms environ, la chute est tout de même violente et le BP d'impact est malmené...
  • Le résultat s'affiche dans la fenêtre Terminal.

Résultats

Résultats initiaux

Les premiers résultats obtenus :

!Hauteur!Temps Chute!Valeur G calculée
117cm560ms7.46
167cm657ms7.50

La valeur calculée pour la constante G semble donc erronée, bien que dans l'ordre de grandeur attendu et non reproductible.

Hypothèse explicative

Au vu de ces résultats, j'ai pensé qu'il devait y avoir un délai entre le déclenchement de la chute par le programme et le déclenchement réel de la chute. Dès lors, la formule à utiliser devient :

Après quelques calculs, j'ai estimé le délai à 70ms. Dès lors, on a :

!Hauteur!Temps Chute!Valeur G calculée
117cm560ms9.74
163cm657ms9.46

Cette valeur est beaucoup plus proche de la valeur de G et est reproductible, ce qui tend à conforter l'hypothèse dun délai de déclenchement.

Nouveaux résultats en prenant en compte le délai de déclenchement électro-aimant

Voici le résultat obtenu pour une hauteur différente, avec utilisation du même délai de déclenchement:

Ouaahh, top !! 9,8 !! Pas mal pour du bricolage et de la récup'...

Remarques

  • les résultats sont très reproductibles pour une hauteur donnée, ce qui tend à prouver que le système fonctionne bien. Voici une série de mesure à la même hauteur :
  • plus la hauteur de chute est grande et mieux c'est pour s'affranchir des erreurs liées au déclenchement
  • attention à la parallaxe lorsque l'on mesure la hauteur. Bien se mettre en face de la hauteur que l'on mesure.

Conclusion

Je suis content du résultat : la programmation à l'aide d'une carte Arduino donne la possibilité de créer de véritables expériences de physique digne d'un labo chez soi, avec trois fois rien... On fait pareil qu'au MIT à la maison...

Malgré un montage rudimentaire et un programme sans prétention, on arrive à une valeur proche du G, à savoir

.

Evolutions ?

  • Il pourrait être intéressant de faire la même chose avec un déclenchement de l'impact et du comptage à l'aide d'optocoupleur par exemple.
  • Utiliser également les interruptions pour un déclenchement encore plus précis. Il semble cependant que l'élement déterminant soit plutôt la hauteur.

Le programme complet en langage Arduino :

A copier/coller directement dans l'éditeur Arduino


// --- Programme Arduino ---
// par X. HINAULT - Le 06/03/2010
// www.mon-club-elec.fr 

// --- Que fait ce programme ? ---
/* réalise la mesure du temps de chute d'un corps
et calcule la constante de la gravité

Un BP active l'électro-aimant
Un autre BP désactive l'électro aimant et déclenche le comptage
Un 3ème BP est utilisé pour détecter l'impact. sur broche 2 pour utiliser interruption externe

Une LED visualise la mise sous tension de l'électro-aimant
Une 2ème LED visualise la validation de l'impact

Un électro-aimant est connecté via un ULN 2803 sur une broche

Le résultat est affiché par connexion série sur le PC */

// --- Fonctionnalités utilisées ---
// Utilise la connexion série vers le PC 

// --- Circuit à réaliser ---
// Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)  
// Connecter  sur la broche 2 (configurée en entrée) un BP connecté à la masse
// Connecter  sur la broche 3 (configurée en entrée) un BP connecté à la masse
// Connecter  sur la broche 4 (configurée en entrée) un BP connecté à la masse
// Connecter  sur la broche 5 (configurée en sortie) une LED et sa résistance en série au 0V
// Connecter  sur la broche 6 (configurée en sortie) une LED et sa résistance en série au 0V
// Connecter  sur la broche 7 (configurée en sortie) un électro-aimant via un ULN 2083

//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables...

// --- Inclusion des librairies utilisées ---

// --- Déclaration des constantes ---
const int APPUI=0; // constante état du BP - appui sur niveau bas
const int PAS_APPUI=1; // constante état du BP - relâché sur niveau haut


// --- constantes des broches ---

const int BP_impact=2; //declaration constante de broche 
const int BP_ON=3; //declaration constante de broche 
const int BP_GO=4; //declaration constante de broche 

const int LED_ON=5; //declaration constante de broche 
const int LED_impact=6; //declaration constante de broche 

const int ElectroAimant=7; //declaration constante de broche 

// --- Déclaration des variables globales ---

// variables mesure temps de chute
unsigned long tempsDebut=0; // valeur microsecondes debut chute
volatile unsigned long tempsFin=0; // valeur microsecondes fin chute - volatile car modifiée dans routine interruption 
unsigned long tempsChute=0; // en µs
unsigned long retardElectroaimant=70000; // délai déclenchement électro-aimant - évaluation empirique

// variables pour la gestion des BP
int temoinGO=0;
volatile int temoinImpact=0; // volatile si modifiée dans routine interruption 
int temoinON=0;

// variables calcul gravité
float Hauteur=143.0; // en cm
float constanteG=0.0; // en m.s^-2

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---

//**************** FONCTION SETUP = Code d'initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// --- ici instructions à exécuter au démarrage --- 

Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission 


// ------- Broches en sortie -------  

pinMode(LED_ON, OUTPUT); //met la broche en sortie 
pinMode(LED_impact, OUTPUT); //met la broche en sortie 
pinMode(ElectroAimant, OUTPUT); //met la broche en sortie 

// ------- Broches en entrée -------  

pinMode(BP_impact, INPUT); //met la broche en entree 
pinMode(BP_ON, INPUT); //met la broche en entree 
pinMode(BP_GO, INPUT); //met la broche en entree 

// ------- Activation du rappel au + interne des broches en entrée si nécessaire -------  

digitalWrite(BP_impact, HIGH) ; // activation du pullup de la broche en entrée
digitalWrite(BP_ON, HIGH) ; // activation du pullup de la broche en entrée
digitalWrite(BP_GO, HIGH) ; // activation du pullup de la broche en entrée

// --------- Initialisation des broches en sortie --------

digitalWrite(LED_ON,LOW); 
digitalWrite(LED_impact,LOW); 
digitalWrite(ElectroAimant,LOW); 


// interruption externe
//attachInterrupt(0, impact, FALLING); // attache l'interruption externe n°0 (broche à la fonction impact)

} // fin de la fonction setup()
// ********************************************************************************

//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()

// --- ici instructions à exécuter par le programme principal --- 

//---- allume électro aimant ----
if (digitalRead(BP_ON)==APPUI && temoinON==0) { // si appui sur BP ON et temoin ON vaut 0

  digitalWrite(ElectroAimant,HIGH); // allume l'électro-aimant
  digitalWrite(LED_ON,HIGH); // met la LED sous tension
  //delay (100);
  temoinON=1; // pour éviter 2ème prise en compte
}

//----- déclenchement de la chute
if (digitalRead(BP_GO)==APPUI && temoinGO==0) { // si appui sur BP GO et temoin GO vaut 0

 digitalWrite(ElectroAimant,LOW); // éteint électro-aimant = déclenche la chute
  digitalWrite(LED_ON,LOW); // éteint la LED témoin ON

  tempsDebut=micros(); // mémorise la valeur courante de la fonction micros

  //Serial.println(tempsDebut);
  //delay(200);
  temoinGO=1; // pour éviter 2ème prise en compte
}

// ----- gestion impact ---
if (digitalRead(BP_impact)==APPUI && temoinImpact==0) { // si appui BP impact et témoin vaut 0 

  tempsFin=micros(); // mémorise la valeur courante de la fonction micros
  //detachInterrupt(0); // inactive l'interruption pour éviter nouveau déclenchement par rebond
  digitalWrite(LED_impact,HIGH); // allume la LED témoin impact
  temoinImpact=1; // témoin impact a eu lieu 
}

//---- affichage résultat ---- 
if (temoinImpact==1) { // si impact a eu lieu 

  Serial.print("Hauteur chute : ");
  Serial.println(Hauteur);

  Serial.print("Top depart : ");
  Serial.println(tempsDebut);

  Serial.print("Top impact : ");
  Serial.println(tempsFin);

  tempsChute = tempsFin-tempsDebut; 
  Serial.print("Duree Chute : ");
  Serial.println(tempsChute);

  temoinImpact=2; // pour un seul affichage

  //----- calcul de la constante de gravité ---- 
  tempsChute=tempsChute-retardElectroaimant;
  Serial.print("Duree Chute corrigee (- delai declenchement) : ");
  Serial.println(tempsChute);


  tempsChute=tempsChute/1000;

  constanteG=(2.0*Hauteur*10000.0);
  constanteG=constanteG/(float(tempsChute)*float(tempsChute));

  Serial.print("Valeur de la constante de gravitation G : "); 
  Serial.println(constanteG,3);



}

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

//*************** Autres Fonctions du programme *************

//void impact() { // cette fonction gère l'interruption déclenchée par le BP impact


//}

// --- Fin programme ---



Page originale créée par X. HINAULT. www.mon-club-elec.fr