Pendule Jeudi

But

Le but de ce projet est de déterminer l'accélération de la pesanteur au moyen d'un pendule, d'un détecteur d'obstacle et d'un microcontrôleur Arduino.  

Le support PDF de la soutenance orale du projet est disponible sur l'espace de stockage en ligne suivant (cloud microsoft onedrive) :  

https://1drv.ms/f/s!AiUoIIYW1JV9ww0erCGmNnz0Er_I

Présentation du projet

Pour mesurer l'accélération de la pesanteur, nous voulons déterminer la période d'oscillation T d'un pendule simple de masse m et de longueur de fil L=0.691 m.

Pour ce faire, nous devons placer un détecteur d'obstacle à rayonnement infrarouge dans le plan d'oscillation, juste en-dessous du point d'énergie cinétique maximal (position stable).

Lorsque le détecteur reçoit le retour du rayon, la masse a donc oscillé pendant t qui est la moitié de sa période (donc t=T/2). En le connectant à Arduino, programmé pour afficher les temps de passage du pendule, on accède à cette demi-période et donc à l'accélération de la pesanteur g, par la relation

T=2.Pi.(L/g)^1/2 <=> g=4.Pi².L/T²

On sait que T=2*t donc g=4.Pi².L/(2*t)² soit

g=Pi²*L/t² avec L en mètre, t en secondes.

Cahier des charges

Un Arduino affichera les temps correspondant au passage du pendule en face du détecteur d'obstacle.

Capteurs nécessaires

La mesure du passage de la masse du pendule est effectuée par un détecteur d'obstacle à rayonnement infrarouge MH-SENSOR-SERIES Flying-Fish.

Transducteurs nécessaires

Le détecteur d'obstacle convertit un signal lumineux (ondes infrarouges réfléchies par l'obstacle) en un signal électrique (0V ou 5V)

On branche un voltmètre entre la sortie du capteur et la prise terre : on observe alors que lorsqu'il y a un obstacle sa tension en sortie est de 0V, sinon elle reste à 5V. Une diode rouge s'éteint lorsque le détecteur capte le passage de la masse. Arduino récupère le signal électrique et affiche les instants de détection (0V).

Besoins électriques

Pour alimenter la carte Arduino, on la branche à l'unité centrale d'un ordinateur par un câble USB. Le détecteur d'obstacle est alimenté par Arduino (en 5V), via la platine.

Besoins Mécaniques

Un pendule pesant simple, de longueur de fil L=0.691 m et de masse m à 0.5 cm du capteur en position verticale du pendule.

Arduino

L'Arduino UNO possède plusieurs sorties numériques.

Ici la sortie du capteur est relié à la broche n°2, celle liée à l'interruption. De même l'entrée diode rouge est placée sur la sortie du capteur, et sa sortie sur la prise Terre : ainsi tant que la sortie du capteur est à 5V (c'est-à-dire tant qu'aucun obstacle se trouve être détecté) la diode rouge est allumée. Lorsque le capteur détecte l'objet, sa tension en sortie tombe à 0V et la diode s'éteint.

Programme Arduino

//declaration des variables utilisees

float temps_ecoule=0.0;        //initialisation des variables à 0

float temps_depart=0.0;

float temps_precedent;        //variable de stockage du temps précédent afin de pouvoir l'afficher dans le

//Serial.print du deltaT de la boucle

float deltaT=0.0;

int i=1;  //compteur de la boucle while initialisé à 1

void arrivee_signal () {

temps_ecoule=millis();           //mesure le temps en  millisecondes pour lequel il y a interruption

deltaT=temps_ecoule-temps_depart; //calcul la différence de temps entre deux interruptions consécutives

temps_precedent=temps_depart;

temps_depart=temps_ecoule;      //le temps final devient le temps initial pour la prochaine interruption

}                                  //end of Interrupt Loop

void setup() { 

Serial.begin(9600);               // ouvre le port série et fixe le débit à 9600 bauds 

pinMode(2,INPUT); 

attachInterrupt(digitalPinToInterrupt(2), arrivee_signal, FALLING);  //lance le programme arrivee_signal lorsqu'une chute de tension est observée 

}

void loop() {                       // envoie une donnée sur le port série seulement quand reçoit une donnée 

while (i<=10 && temps_ecoule>0) {     

Serial.print("temps ecoule=  ");       

Serial.print(temps_ecoule);      

Serial.print("ms - temps precedent= ");      

Serial.print(temps_precedent);      

Serial.println("ms =");   

Serial.print("deltaT= ");      

Serial.print(deltaT);      

Serial.println("ms");      

Serial.println();       

delay(800);       

i++;  //incrémentation du compteur   

}   

}   

Mesures

On a mesuré somme_deltaT=8461 ms pour 10 valeurs de deltaT affichées, donc la demi-période est t=846.1ms. On calcule g=(Pi²*0.691)/0.8461² = 9.53m.s^-2

Conclusion

Nous étions supposé trouver g=9.81m.s^-2. L'erreur relative sur la valeur mesurée est

E=100* (9.81-9.53)/9.81=2.55%

L'écart entre la valeur théorique de g et celle mesurée provient d'incertitudes sur notamment la longueur du fil, qui doit être de l'ordre de 2mm, ainsi que sur le capteur lui-même. En effet le réglage de sa sensibilité influe sur sa capacité à détecter un objet si celui-ci se décale légèrement de son plan d'oscillations originel ou aussi en fonction du côté par lequel il se rapproche dudit détecteur. Ainsi l'objet ne sera pas forcément détecter au même endroit à chaque fois, par rapport au détecteur, ce qui jouera sur la valeur du temps mesuré à l'interruption et donc sur la période finale.

L'incertitude sur la valeur de g est donnée par :

delta_g = g *(delta_L/L + 2* delta_t/t)

Par rapport à nos résultats précédents, on calcule

>la moyenne des deltaT = (883+809+883+810+882+809+884+808+885+808)/10 = 846.1ms

>l'écart-type : ([(883-846.1)² +(809-846.1)² +(883-846.1)² +(810-846.1)² +(882-846.1)² +(809-846.1)² +(884-846.1)² +(808-846.1)² +(885-846.1)² +(808-846.1)²] /10)^1/2 = 37.3ms

Donc on a delta_g = 9.53 * (0.2/69.1 + 2* 37.3/846.1) = 0.8 m.s^-2

Ainsi on a mesuré expérimentalement g=9.53 +/- 0.8 m.s^-2