Étude expérimentale du mouvement harmonique simple : 5 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Par arrowlikeFollow More par l'auteur:

En classe, nous utilisons souvent un chronomètre pour mener l'expérience du pendule, ou une simple expérience de mouvement harmonique. Voici un défi, pouvons-nous produire un graphique réel de son mouvement et voir quelle est la position angulaire et la vitesse instantanées, c'est beaucoup plus d'informations et de plaisir.

Première question, nous devons décider que le corps du pendule est une corde en apesanteur ou une tige uniforme rigide. L'approche du cordon semble être plus facile. De la pratique de la construction d'un, j'ai les considérations de compromis suivantes: La façon la plus simple d'accrocher un système de pendule pourrait être de l'accrocher au bord supérieur de votre porte. Cela donne une longueur de pendule d'environ 2 m sans effectuer de travaux de construction structurels. Mais il faut que la balançoire ne touche pas la surface de la porte, ce qui ruine simplement toute l'expérience. Ainsi, le plan qu'il balance doit être exactement parallèle à la surface de votre mur/porte. Un cordon en apesanteur a tendance à être fin, il peut tourner facilement et compliquer la mesure de l'angle d'oscillation. Nous voulons utiliser une mesure pour représenter l'état d'oscillation. Une corde fine, telle que la ligne à poisson, peut être élastique et extensible, ce qui affecte l'une de nos constantes les plus importantes mesurées par nous et utilisées dans l'équation, qui est la longueur du pendule. Certains peuvent également être affectés par la température. La masse de poids suspendue au bout du cordon doit être suffisamment lourde pour que le poids du cordon devienne négligeable. Veuillez commenter si vous êtes d'accord ou en désaccord avec eux, ou si vous avez d'autres idées de compromis de conception. Pour étudier ce problème, nous avons besoin d'un appareil si léger que son poids peut être ignoré et nous traitons toujours le système pendulaire comme une tige rigide uniforme. J'utilise un contrôleur électronique portable COTS, qui nous fournit le gyroscope, l'accéléromètre et les informations d'angle via une connexion Bluetooth. Ces mesures seront stockées dans un fichier de données d'application de téléphone mobile. Après cela, nous analyserons les données pour notre expérience de mouvement harmonique simple. L'analyse numérique se concentre sur les sujets suivants: 1) Prédire la période d'oscillation du pendule 2) Collecter par programmation les données d'expérience de mouvement harmonique simple du pendule 3) Utiliser kmean pour regrouper les données et supprimer les valeurs aberrantes dans le processus d'analyse 4) Utiliser la FFT à court terme pour estimer la fréquence d'oscillation du pendule

Fournitures

Appareil de mesure Bluetooth

Application pour téléphone Android: accédez à Google Playstore, recherchez M2ROBOTS et installez l'application de contrôle. S'il est difficile d'accéder à Google Playstore, visitez ma page d'accueil personnelle pour une méthode alternative de téléchargement d'applications

tige de bois

quelques pièces imprimées en 3D

lames de scie ou matériau métallique similaire

Étape 1: Que sont les pendules ? Comment le modéliser ?

Il existe de nombreux articles et livres présentant la dérivation de l'équation du pendule, y compris votre livre de physique du programme. Il vaudrait peut-être mieux qu'un tel contenu ne soit pas répété ici. Seule la conclusion finale est énumérée ici concernant le sujet du "mouvement harmonique simple". Pour connaître la période d'un pendule, il suffit de connaître la longueur du pendule, notée "l", en mètres.

Si nous sommes raisonnablement sûrs que le poids est situé presque complètement à l'extrémité d'une corde en apesanteur suspendue à un pivot, et que le pendule oscille à de petits angles, disons inférieurs à 15°, la période T1 d'un tel pendule est donnée par:

T1 = 2*pi*(l/g)^0,5

g = accélération de la gravité, environ 9,8 m/s^2

Si la corde en apesanteur est remplacée par une tige rigide uniforme, toujours de longueur l, sa période de mouvement harmonique simple T2 est donnée par T1 = 2*pi*(2l/3g)^0,5

En fait, il a la même période qu'un pendule à corde en apesanteur représentant les deux tiers de la longueur de la tige uniforme rigide.

C'est le contexte, et nous pouvons commencer à préparer notre expérience.

Étape 2: préparer les pièces pour la construction de matériel

Pour construire la structure du pendule, nous imprimons en 3D certaines pièces et recyclons quelque chose que nous avons déjà. La structure globale du pendule est illustrée à la Fig.1. C'est un mélange de pièces imprimées en 3D avec des pièces fabriquées à la main et un long morceau de tige de bois de Lowe.

La partie imprimée en 3D de la Fig.2 est accrochée au bord supérieur d'une porte, car notre porte est une surface plane facile pour nous d'accrocher quelque chose. Lien de téléchargement du fichier STL:

xiapeiqing.github.io/doc/kits/pendulum/pen…

La partie verte de la Fig.3 relie la tige de bois à une lame, et la lame repose sur deux morceaux de rail montés sur le précédent accroche-porte imprimé en 3D. Lien de téléchargement du fichier STL:

Les deux morceaux de rail sont fabriqués en brisant une vieille lame de scie en deux, voir Fig. 4. La partie de la Fig.2 a préparé la bonne taille de fente pour eux. Idéalement, nous pouvons faire une encoche en forme de "V" dans ces deux lames de scie à l'aide d'une lime. Un métal à bords assez tranchants, comme une lame de rasoir à un seul bord, ou toute pièce métallique faite à la main, peut se trouver à l'intérieur des encoches en forme de "V". La raison pour laquelle nous avons besoin d'une zone de contact plus petite est de réduire l'énergie cinétique perdue lors du balancement.

La dernière partie imprimée en 3D de la Fig.5 est un petit plateau pour contenir l'appareil de mesure électronique.

Le lien de téléchargement:

L'appareil de mesure Bluetooth génère une estimation d'angle, une mesure gyroscopique et une mesure d'accéléromètre. Toutes ces données sont à notre disposition via une liaison sans fil Bluetooth.

Nous allons mener plusieurs expériences en déployant cet appareil à différentes positions du bras du pendule, et voir les différences.

Étape 3: Expérimenter la collecte de données

Il existe deux méthodes possibles pour la collecte de données expérimentales avant d'analyser l'ensemble de données acquis:

1) Utilisez l'application pour téléphone Android spécifiée dans la section des exigences pour enregistrer toutes les mesures produites par l'appareil dans un fichier de données stocké sur la carte SD de votre téléphone. Nous pouvons copier le fichier et post-traiter les informations.

2) Utilisez un ordinateur compatible Bluetooth, un PC, un ordinateur portable ou un mini-ordinateur RaspberryPi pour établir une connexion Bluetooth avec l'appareil et lire les données pour une analyse en temps réel ou hors ligne.

Il existe à la fois des avantages et des inconvénients pour chaque méthode, nous allons essayer les deux et faire la différence dans cette instructable.

Pour la méthode (1) utilisant l'application Android, une fois que nous sommes dans l'interface de contrôle de l'application Android, les données de télémétrie envoyées de l'appareil de mesure Bluetooth au téléphone Android seront enregistrées dans un fichier de journal de données nommé m2flightDatayyyymmdd_hhmmss.txt. Il se trouve dans le dossier Download/m2LogFiles de votre téléphone Android. Le dossier "Télécharger" est un dossier préexistant dans le système d'exploitation Android de votre téléphone et "m2LogFiles" est un dossier créé par l'application. Le contenu du nom de fichier aaaammjj_hhmmss est le moyen d'encoder l'heure de début de l'expérience (année, mois, jour, heure, minute et seconde) dans le nom de fichier.

Chaque ligne du fichier journal correspond à un enregistrement. Il commence par l'horodatage de l'événement, la chaîne de préambule « eam: », suivie de 4 données de triplet, qui sont:

Lecture de l'axe XYZ de l'accéléromètre dans les valeurs brutes de relecture du registre matériel du capteur

Lecture de l'axe XYZ du gyroscope dans les valeurs brutes de relecture du registre matériel du capteur

Lecture de l'axe XYZ du magnétomètre dans les valeurs brutes de relecture du registre matériel du capteur

Roll/Pitch/Raw estimés à bord en degré

Le fichier de données créé à l'aide du programme informatique python utilisera un format de fichier de données identique, de sorte que le programme que nous utilisons dans l'étape d'analyse des données ne sera pas dérangé par la source de données produite par notre programme python ou notre application Android.

Commençons à coder en utilisant la méthode (2).

Pour interagir avec l'appareil de mesure Bluetooth, deux versions de SDK sont fournies:

1) Python SDK, qui peut être installé par "pip3 install m2controller", python3 est le langage utilisé. Les exemples de code d'application utilisateur sont stockés dans https://github.com/xiapeiqing/m2robots/tree/maste… Pour cette expérience, nous utiliserons le script python pendulum1.py

2) Java SDK, qui n'est pas utilisé dans cette instructable car nous voulons une visualisation et une analyse ultérieures des données de pendule acquises, ce qui pourrait nous demander un peu plus d'efforts pour programmer en Java.

Le code source du programme de collecte de données python3 contient de nombreux commentaires pour les détails des fonctionnalités du code. Un instantané du code source est fourni ici.

#!/usr/bin/env python# -*- codage: UTF-8 -*- de m2controller import m2controller de m2controller import m2Const import signal import time import datetime import usrCfg import pendule2

requestExit = Faux

################################################################

# nous voulons utiliser la même convention de nommage du fichier journal afin que le module d'analyse de données, pendulum2.py, puisse être indépendant de la façon dont nous obtenons le fichier de données journal ################# ################################################ logfilename = " m2flightData%s.txt"%(datetime.datetime.fromtimestamp(time.time()).strftime('%Y%m%d_%H%M%S')) dataLogfile = open(logfilename, "w")

def signal_handler(sig, frame):

global requestExit print('utilisateur Ctrl-C pour quitter l'exécution du programme') requestExit = True signal.signal(signal. SIGINT, signal_handler)

################################################################

# à chaque fois que les données de mesure deviennent disponibles à une fréquence de 20 Hz, cette fonction de "rappel" sera invoquée ############################### ################################## def callbackfunc (télémétrie): strTimeStamp = datetime.datetime.fromtimestamp(time.time ()).strftime('%H:%M:%S.%f')[:-3] dataStr = "%s, eam:%d, %d, %d, %d, %d, %d, %d, %d, %d, %2.1f, %2.1f, %2.1f\n"%(strTimeStamp, télémétrie['m_fAccelHwUnit'][0], télémétrie['m_fAccelHwUnit'][1], télémétrie['m_fAccelHwUnit'][2], télémétrie['m_fGyroHwUnit'][0], télémétrie['m_fGyroHwUnit'][1], télémétrie['m_fGyroHwUnit'][2], télémétrie['m_fMagHwUnit'][0], télémétrie['m_fMagHwUnit'][1], télémétrie['m_fMagHwUnit'][2], télémétrie['m_fRPYdeg'][0], télémétrie['m_fRPYdeg'][1], télémétrie['m_fRPYdeg'][2]) ## ##################################################### ############ # nous imprimons la chaîne de données à l'écran et les sauvegardons dans le fichier journal ###################### ############################################ print(dataStr) dataLogfile.writelines(dataStr)

################################################################

# initialiser le contrôleur, n'oubliez pas de définir le champ BleMACaddress pour être l'adresse MAC de votre appareil ################################# ############################## # A FAIRE: initialisons la BleMACaddress si elle n'est pas définie par l'utilisateur. controller = m2controller. BleCtrller(m2Const.etDebian, callbackfunc, usrCfg. BleMAAddress) controller.connect() lorsque True: ############################ ######################################## # attendre les données de mesure créées et envoyées à partir de la mesure du pendule appareil ################################################## ############## controller.m_CommsTunnel.waitForNotifications(1.0) si requestExit: ######################## ########################################### # l'entretien ménager fonctionne ici lorsque nous aurons terminé l'enregistrement des données ##################################################### ############## controller.stop() dataLogfile.close() break

################################################################

# collecte de données terminée, analysons maintenant les données du journal ####################################### ########################## pendule2.parseDataLogFile(logfilename)

Pour une mise à jour à long terme, veuillez consulter

Expliquons maintenant son mode de fonctionnement. Ce programme python est écrit au-dessus d'un package installable pip, nommé m2controller. Le package de niveau inférieur offre un mécanisme de rappel, de sorte que chaque mise à jour de mesure reçue déclenche la fonction de rappel que nous avons écrite et enregistre les données dans un fichier journal local. Le format du contenu des données du fichier journal est identique à celui produit par l'application compagnon Android, de sorte que le fichier journal des données créé par le programme python ou l'application compagnon Android est échangeable.

Le signal utilisateur ctrl-C, capturé par le système d'exploitation, est transmis au programme et arrête la boucle infinie en attendant la nouvelle arrivée des données de mesure.

Jusqu'à présent, le fichier journal a été créé avec succès et ce programme appellera le programme d'analyse pour étudier les résultats de nos expériences.

Voici deux expériences, et la comparaison montre la différence très notable en attachant un appareil de 7 grammes à différents endroits.

Dans la Fig.2, nous utilisons une balance pour déterminer le poids réel de cet appareil de mesure Bluetooth.

La figure 3 illustre la configuration du pendule où le dispositif de 7 grammes est attaché à l'extrémité inférieure du pendule. La configuration d'installation de la Fig.4 a la masse de 7 grammes située beaucoup plus près du pivot oscillant.

La figure 5 est une vue rapprochée de la structure du pendule.

Étape 4: Analyse des données

L'appareil de mesure Bluetooth pèse environ 7 grammes, ce qui pèse beaucoup moins qu'un bâton de bois d'environ 1,6 mètre de long. Utilisez l'hypothèse de "tige uniforme rigide", et nous avons cette équation de période pendulaire, T1 = 2*pi*(2l/3g)^0,5

Pour obtenir la constante de gravité, nous pouvons utiliser 9,8 m/s^2. Mais une constante de gravité plus précise à n'importe quelle géolocalisation donnée peut être récupérée à partir de ce service Web:

www.wolframalpha.com/widgets/view.jsp?id=e…

Pour san francisco, c'est 9.81278m/s^2

La longueur du pendule est mesurée à 64,5''

2*pi*sqrt(2*64.5*0.0254/(3*9.81278)) donne la période de pendule attendue de 2.0962(sec).

Voyons si cela concorde avec nos expériences.

Dans la 1ère expérience, la configuration du pendule a le dispositif de 7 grammes attaché à l'extrémité inférieure du pendule. Mon fichier journal peut être téléchargé dans:

xiapeiqing.github.io/doc/kits/pendulum/pen…

Renommez-le en "PendulumTestData.txt" et placez-le dans le même dossier du programme d'analyse python. Un instantané du code source est fourni ici.

#!/usr/bin/env python# -*- codage: UTF-8 -*- import csv import matplotlib.pyplot as plt plt.style.use('seaborn-whitegrid') import numpy as np from datetime import datetime, timedelta import seaborn as sns from sklearn.cluster import KMeans from collections import Counter ##################################### ############################ # cette fonction exécute le travail d'analyse du fichier de données ############ ##################################################### ## def parseDataLogFile (nom du fichier de données): ########################################## ###################### # extraire les données du fichier journal de données séparé par des virgules (CSV) et enregistrer le contenu de chaque colonne dans une variable de type flottant ## ##################################################### ############ avec open(datafilename) comme csvfile: readCSV = csv.reader(csvfile, delimiter=', ') timestampS = fAccelHwUnit_x = fAccelHwUnit_y = fAccelHwUnit_z = fGyroHwUnit_x = fGyroHwUnit_y = fGyroHwUnit_z = fMagHwUnit_x = fMagHwUnit_y = fMagHwUni t_z = fRPYdeg_r = fRPYdeg_p = fRPYdeg_y = pour la ligne dans readCSV: essayez: x = datetime.strptime(row[0].split(', ')[0], '%H:%M:%S.%f') timestampS.append(timedelta(hours=x.hour, minutes=x.minute, seconds=x.second, microseconds=x.microsecond).total_seconds()) fAccelHwUnit_x.append(float(row [1][4:])) fAccelHwUnit_y.append(float(row[2])) fAccelHwUnit_z.append(float(row[3])) fGyroHwUnit_x.append(float(row[4])) fGyroHwUnit_y.append(float (ligne[5])) fGyroHwUnit_z.append(float(ligne[6])) fMagHwUnit_x.append(float(ligne[7])) fMagHwUnit_y.append(float(ligne[8])) fMagHwUnit_z.append(float(ligne) [9])) fRPYdeg_r.append(float(row[10])) fRPYdeg_p.append(float(row[11])) fRPYdeg_y.append(float(row[12])) sauf: pass timestampS = np.asarray(horodatages) horodatages = horodatages - horodatages [0] = fAccelHwUnit_x np.asarray (fAccelHwUnit_x) fAccelHwUnit_y = np.asarray (fAccelHwUnit_y) fAccelHwUnit_z = np.asarray (fAccelHwUnit_z) fGyroHwUnit_x = np.asarray (fGyroHwUnit_x) fGyroHwUnit_y = np.asarray (fGyroHwUnit_y) fGyroH wUnit_z = np.asarray (fGyroHwUnit_z) fMagHwUnit_x = np.asarray (fMagHwUnit_x) fMagHwUnit_y = np.asarray (fMagHwUnit_y) fMagHwUnit_z = np.asarray (fMagHwUnit_z) fRPYdeg_r = np.asarray (fRPYdeg_r) fRPYdeg_p = np.asarray (fRPYdeg_p) = fRPYdeg_p fRPYdeg_p - np.mean(fRPYdeg_p) fRPYdeg_y = np.asarray(fRPYdeg_y)

################################################################

# nous avons besoin d'une estimation précise de la fréquence d'échantillonnage pour une estimation précise de la période d'oscillation #################################### ############################ FsHz = getSamplingIntervalS(timestampS) ################ ################################################ # utilisation composante de tangage dans la sortie du système de référence de cap d'assiette pour l'analyse de la période du pendule ##################################### ########################### analyze_timeSequence(timestampS, fRPYdeg_p, FsHz, 'pitch') ########### ##################################################### ### # utiliser la sortie de mesure brute de l'accéléromètre pour l'analyse de la période du pendule ##################################### ########################## analyze_timeSequence(timestampS, fAccelHwUnit_x, FsHz, 'accel') ########### ##################################################### ### # utiliser la sortie de mesure brute du gyroscope pour l'analyse de la période du pendule ##################################### ########################## analyze_timeSequence(timestampS, fGyroHwUnit_y, FsHz, ' gyro') print('fait, félicitations:-)') plt.show() ############################### ################################## # dans le processus de communication Bluetooth, il y a une chance rare que le paquet de communication de données puisse être perdu # nous utilisons K-mean pour isoler les données de mesure à 20 Hz des valeurs aberrantes, qui sont causées par la perte de paquets # plongez dans "signal et système pour plus de détails" ################ ################################################# def getSamplingIntervalS (timestampS): plt.figure() sampleIntervalS = np.diff(timestampS) sns.distplot(sampleIntervalS) plt.ylabel('histogramme') plt.xlabel('intervalle(s) de mesure') clusterCnt = 5 km = KMeans(n_clusters = clusterCnt) km.fit(sampleIntervalS.reshape(-1, 1)) centroïdes = km.cluster_centers_ elemCnt = Counter(km.labels_) occurrenceCnt = for ii in range(clusterCnt): occurrenceCnt.append(elemCnt[ii]) FsHz = 1/centroids[occurrenceCnt.index(max(occurrenceCnt))] renvoie FsHz

################################################################

# utiliser un spectromètre, c'est-à-dire une FFT à court terme pour obtenir la composante de fréquence, le pic bin est notre meilleure estimation de l'oscillation du pendule ########################## ######################################## def analyze_timeSequence(timestampS, timeSeqData, FsHz, strComment): fig, (ax1, ax2) = plt.subplots(nrows=2) ax1.plot(timestampS, timeSeqData, marker='o', markerfacecolor='blue', markersize=2, color='skyblue', linewidth=1) ax1.set_title("mesure du domaine temporel du pendule -- %s"%strComment) ax1.set_xlabel("temps d'échantillonnage (seconde)") ax1.set_ylabel(strComment); NFFT = 2048 # la longueur des segments de fenêtrage

Pxx, freqs, bins, im = ax2.specgram(timeSeqData, NFFT=NFFT, Fs=FsHz, nooverlap=NFFT/2)

ax2.set_title("Spectrogramme") ax2.set_xlabel("échantillons") ax2.set_ylabel("fréquence(Hz)");

# La méthode `specgram` renvoie 4 objets. Elles sont:

# - Pxx: le périodogramme # - freqs: le vecteur de fréquence # - bins: les centres des intervalles de temps # - im: l'instance matplotlib.image. AxesImage représentant les données dans le plot pkresult = np.where(Pxx == np.amax(Pxx)) oscFreqHz = freqs[pkresult[0][0] print('oscillation pendulaire Freq(Hz)=%f, Period(Sec)=%f, source de données d'estimation: %s'%(oscFreqHz, 1/oscFreqHz, strComment)) renvoie 1/oscFreqHz

################################################################

# devons-nous exécuter ce programme indépendamment, c'est-à-dire n'étant pas appelé par pendulum1.py, # nous définissons un nom de fichier de données de journal par défaut à analyser #################### ############################################# if _name_ == "_main_ ": defaultFilename = './PendulumTestData.txt' import os.path if os.path.isfile(defaultFilename): parseDataLogFile(defaultFilename) else: print ("le fichier journal par défaut %s n'existe pas"%defaultFilename)

Pour une mise à jour à long terme, veuillez consulter

Le code source contient des commentaires détaillés, donnons ici un résumé de haut niveau de l'estimation mathématique.

1) Nous lisons d'abord le contenu du fichier CSV dans l'ordinateur, en utilisant un package python appelé "csv". Nous avons des mesures périodiques.

21:34:26,362, eam:0, -128, 14464, -8, 144, -96, 2112, -1280, 1664, -0,5, -5,5, 40,5

21:34:26,373, eam:128, 0, 14272, -8, 136, 40, 2112, -1280, 1664, -0,5, -6,5, 40,0

21:34:26.412, eam:448, -64, 14208, -8, 136, 24, 2176, -1280, 1664, -0,5, -7,5, 40,5

21:34:26.462, eam:448, -128, 14272, -8, 120, 16, 2176, -1280, 1664, -0,5, -8,0, 40,5

2) Étant donné que le taux de mesure est si critique et introduit directement une erreur d'estimation de la période du pendule, nous voulons les estimer. Notre intervalle de mesure nominal est de 50 ms, soit 20 Hz. La moyenne sur toutes les mesures semble correcte, mais nous perdons occasionnellement des paquets de transmission de données, l'intervalle de mise à jour devient 100 ms ou 150 ms, …

Si nous traçons l'occurrence de ces données, voir Fig.1, en tant qu'humain, nous pouvons facilement avoir une valeur oculaire de 0,05 s. Cependant, pouvons-nous faire mieux que cela?

Nous devons utiliser la méthode de classification pour ne sélectionner que les bons pour le calcul de la moyenne. Python a une boîte à outils nommée KMeans pour nous aider avec le clustering, ou disons la classification. Ces concepts sont utilisés dans de nombreux domaines du Big Data et de l'IA.

3) La Fig.2 contient deux images. Le graphique du haut est une séquence dans le domaine temporel de notre mesure d'angle d'oscillation en degrés. En se référant à l'horodatage de l'axe des x en secondes, nous pouvons lire environ 22,5 cycles en 50 secondes, ce qui se traduit par une période de pendule de 2,22 secondes. Existe-t-il un moyen d'automatiser ce processus et d'avoir une estimation plus précise ? Oui, nous pouvons utiliser un outil mathématique appelé spectrogramme, qui utilise une petite partie des données de mesure et nous indique sa fréquence, voir la figure ci-dessous. La lecture de l'axe des y pour la ligne la plus sombre est la fréquence d'oscillation du pendule. Le fait d'être une ligne horizontale confirme que l'oscillation du pendule n'a pas du tout changé tout au long de l'expérience. La valeur inverse de la fréquence d'oscillation est la période d'oscillation du pendule.

Le rapport final fait par le programme est un résumé textuel:

oscillation du pendule Freq(Hz)=0.449224, Period(Sec)=2.226059, source de données d'estimation: pitch

Nous pouvons trouver que notre résultat de calcul de la main eyeballing précédent, 2,22 sec, est assez cohérent avec la valeur calculée du programme.

Par rapport à la valeur théoriquement calculée de 2,0962 (sec), nous avons ~5% d'erreur restante. Comment se débarrasser d'eux? Rappelez-vous que l'hypothèse est « tige uniforme rigide » ? Même un poids supplémentaire de 7 grammes semble insignifiant, c'est la principale cause de l'erreur restante.

Nous déplaçons maintenant l'appareil, près du pivot. Voir l'étape précédente pour une photo en gros plan. Le fichier journal que j'ai créé peut être téléchargé ici:

xiapeiqing.github.io/doc/kits/pendulum/pen…

Exécutez les mêmes étapes d'analyse et nous obtenons une période de 2,089867 (sec), voir Fig.3, qui est presque identique à la prédiction théorique. Super!

Puisque nous avons non seulement la mesure de l'angle d'oscillation, mais aussi la mesure gyroscopique et la mesure de l'accéléromètre au même rythme. Exécutez la même analyse pour les deux autres mesures, nous obtenons des résultats sur les figures 4 et 5. Les estimations des trois sources de mesure concordent, ce qui nous rend plus confiants quant au succès de notre expérience.

Voici le résultat en tant que sortie finale du programme python en cours d'exécution:

oscillation du pendule Freq(Hz)=0.478499, Period(Sec)=2.089867, source de données d'estimation: pitch

oscillation du pendule Freq(Hz)=0.478499, Period(Sec)=2.089867, source de données d'estimation: accel

oscillation du pendule Freq(Hz)=0.478499, Period(Sec)=2.089867, source de données d'estimation: gyroscope

Dernière réflexion à cette étape, comment les résultats de l'estimation peuvent-ils être exactement identiques en utilisant différentes sources de données d'entrée ? C'est une contre-intuition. Je laisse cette question aux lecteurs. Voici un indice: rappelez-vous que nous utilisons la FFT à court terme pour estimer la fréquence d'oscillation ? Dans le domaine numérique, l'estimation de fréquence est donnée dans des cases de fréquence discrètes au lieu d'une estimation de nombre flottant.

Étape 5: Recommandations pour les travaux futurs

Il existe peu de catégories de recommandations de travaux futurs.

Dans l'étape précédente, nous parvenons à réduire notre erreur d'expérimentation de ~5% à moins de 1%, pouvons-nous faire mieux que cela ? En remarquant que l'amplitude de l'oscillation diminue de façon exponentielle, un facteur contributif peut être la traînée d'air causée lors du balancement du pendule. La section transversale du pendule pourrait devoir être modifiée pour être de forme aérodynamique afin de réduire la traînée aérodynamique.

Pouvons-nous appliquer un gain variant dans le temps appris à l'aide de techniques de filtre adaptatif pour produire un signal d'amplitude de crête constant. En attendant, corréler l'atténuation de l'amplitude aux forces externes.

On peut difficilement trouver quelque chose de plus simple que le "mouvement harmonique simple". Pouvons-nous utiliser les installations que nous analysons le pendule pour analyser quelque chose de plus compliqué, une activité sportive, une séquence de lancement de fusée à eau, etc. ?

Bon piratage