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