Estudio experimental del movimiento armónico simple: 5 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:41

Por arrowlike Siga más por el autor:

En el aula, a menudo usamos un cronómetro para realizar el experimento del péndulo o un simple experimento de movimiento armónico. Aquí hay un desafío, ¿podemos producir un gráfico real de su movimiento y ver cuál es la posición angular instantánea y la velocidad? Eso es mucha más información y diversión.

Primera pregunta, debemos decidir que el cuerpo del péndulo es un cordón ingrávido o una varilla rígida uniforme. El enfoque del cordón parece ser más fácil. De la práctica de construir uno, tengo las siguientes consideraciones de compensación: La forma más fácil de colgar un sistema de péndulo podría ser colgarlo en el borde superior de su puerta. Eso le da a su péndulo de ~ 2 m de longitud sin realizar ningún trabajo de construcción estructural. Pero necesita que el columpio no toque la superficie de la puerta, lo que simplemente arruina todo el experimento. Por lo tanto, el plano en el que se balancea debe estar exactamente paralelo a la superficie de la pared / puerta. Un cordón ingrávido tiende a ser delgado, puede girar fácilmente y complicar la medición del ángulo de oscilación. Queremos usar una medida para representar el estado de oscilación. El cordón delgado, como el sedal, puede ser elástico y estirable, lo que afecta a una de nuestras constantes más importantes medidas por nosotros y utilizadas en la ecuación, que es la longitud del péndulo. Algunos también pueden verse afectados por la temperatura. La masa de peso que cuelga del extremo del cable debe ser lo suficientemente pesada para que el peso del cable sea insignificante. Comente si está de acuerdo o en desacuerdo con ellos, o si tiene otras ideas de compensación de diseño. Para estudiar este problema, necesitamos un dispositivo que sea tan ligero que se pueda ignorar su peso y todavía tratamos el sistema de péndulo como una varilla rígida uniforme. Estoy usando un controlador electrónico portátil COTS, que nos envía la información del giroscopio, el acelerómetro y el ángulo a través de una conexión bluetooth. Estas medidas se almacenarán en un archivo de datos de la aplicación del teléfono móvil. Después de eso, analizaremos los datos para nuestro experimento de movimiento armónico simple. El análisis numérico se centra en los siguientes temas: 1) Predecir el período de oscilación del péndulo 2) Recopilar de manera programada los datos del experimento de movimiento armónico simple del péndulo 3) Usar kmean para agrupar datos y eliminar valores atípicos en el proceso de análisis 4) Usar FFT de tiempo corto para estimar la frecuencia de oscilación del péndulo

Suministros

Aparato de medición Bluetooth

Aplicación de teléfono Android: vaya a Google Play Store, busque M2ROBOTS e instale la aplicación de control. En caso de que sea difícil acceder a Google Play Store, visite mi página de inicio personal para obtener un método alternativo de descarga de aplicaciones

varilla de madera

pocas piezas impresas en 3D

hojas de sierra o material metálico similar

Paso 1: ¿Qué son los péndulos? ¿Cómo modelarlo?

Hay muchos artículos y libros que presentan la derivación de la ecuación del péndulo, incluido el libro de física de su plan de estudios. Tal contenido sería mejor que no se repita aquí nuevamente. Aquí sólo se enumera la conclusión final con respecto al tema del "movimiento armónico simple". Para saber el período de un péndulo, todo lo que necesitamos saber es la longitud del péndulo, denotado como "l", en metros.

Si estamos razonablemente seguros de que el peso está ubicado casi por completo en el extremo de una cuerda ingrávida que cuelga de un pivote, y el péndulo se balancea en ángulos pequeños θ, digamos menos de 15 °, el período T1 de dicho péndulo está dado por:

T1 = 2 * pi * (l / g) ^ 0.5

g = aceleración de la gravedad, aproximadamente 9,8 m / s ^ 2

Si la cuerda ingrávida se reemplaza por una varilla rígida uniforme, nuevamente de longitud l, su período de movimiento armónico simple T2 viene dado por T1 = 2 * pi * (2l / 3g) ^ 0.5

Efectivamente, tiene el mismo período que un péndulo de cuerda ingrávida siendo dos tercios de la longitud de la varilla rígida uniforme.

Este es el trasfondo y podemos empezar a preparar nuestro experimento.

Paso 2: preparar las piezas para la construcción del hardware

Para construir la estructura del péndulo, imprimimos en 3D algunas piezas y reciclamos algo que ya tenemos. La estructura del péndulo general se muestra en la figura 1. Es una mezcla de piezas impresas en 3D junto con algunas piezas hechas a mano y un trozo largo de varilla de madera de Lowe`s.

La parte impresa en 3D de la figura 2 se cuelga del borde superior de una puerta, porque nuestra puerta es una superficie plana fácil de colgar algo. Enlace de descarga de archivos STL:

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

La parte verde de la figura 3 conecta la varilla de madera a una hoja, y la hoja se asienta sobre dos piezas de riel montadas en el colgador de puerta impreso en 3D anterior. Enlace de descarga del archivo STL:

Las dos piezas de riel se hacen partiendo una vieja hoja de sierra por la mitad, consulte la Fig. 4. La pieza de la Fig. 2 ha preparado el tamaño de ranura correcto para ellas. Idealmente podemos hacer una muesca en forma de "V" en esas dos hojas de sierra usando una lima. Un metal con bordes razonablemente afilados, como una hoja de afeitar de un solo filo, o cualquier pieza de metal hecha a mano, puede asentarse dentro de las muescas en forma de "V". La razón por la que necesitamos un área de contacto más pequeña es para reducir la pérdida de energía cinética durante el balanceo.

La última pieza impresa en 3D en la figura 5 es una pequeña bandeja para contener el aparato de medición electrónico.

El enlace de descarga:

El aparato de medición bluetooth genera estimación de ángulo, medición de giroscopio y medición de acelerómetro. Todos estos datos están disponibles para nosotros a través de un enlace inalámbrico bluetooth.

Vamos a realizar múltiples experimentos desplegando este aparato en diferentes posiciones del brazo del péndulo y veremos las diferencias.

Paso 3: recopilación de datos experimentales

Hay dos métodos factibles para la recopilación de datos experimentales antes de analizar el conjunto de datos adquiridos:

1) Utilice la aplicación de teléfono Android especificada en la sección de requisitos para registrar todas las mediciones producidas por el aparato en un archivo de datos almacenado en la tarjeta SD de su teléfono. Podemos copiar el archivo y procesar la información.

2) Utilice una computadora habilitada para bluetooth, una PC, una computadora portátil o una mini computadora RaspberryPi para establecer una conexión bluetooth al aparato y leer los datos para análisis en tiempo real o fuera de línea.

Existen pros y contras para cada método, vamos a probar ambos y notar la diferencia en este instructivo.

Para el método (1) que usa la aplicación de Android, una vez que estemos en la interfaz de control de la aplicación de Android, los datos de telemetría enviados desde el aparato de medición bluetooth al teléfono Android se registrarán en un archivo de registro de datos llamado m2flightDatayyyymmdd_hhmmss.txt. Se puede encontrar en la carpeta Download / m2LogFiles de su teléfono Android. La carpeta "Descargar" es una carpeta preexistente en el sistema operativo Android de su teléfono y "m2LogFiles" es una carpeta que creó la aplicación. El contenido del nombre de archivo aaaammdd_hhmmss es la forma de codificar la hora de inicio del experimento (año, mes, día, hora, minuto y seg) en el nombre del archivo.

Cada línea del archivo de registro es un registro. Comienza con la marca de tiempo del evento, la cadena de preámbulo "eam:", seguida de 4 datos de tripletes, que son:

Lectura del eje XYZ del acelerómetro en valores de lectura del registro de hardware del sensor sin procesar

Lectura del eje XYZ del giroscopio en los valores de lectura del registro de hardware del sensor sin procesar

Lectura del eje XYZ del magnetómetro en valores de lectura del registro de hardware del sensor sin procesar

Roll / Pitch / Raw estimado a bordo en grados

El archivo de datos creado con el programa Python de la computadora usará un formato de archivo de datos idéntico, por lo que el programa que usamos en el paso de análisis de datos no se verá afectado por la fuente de datos producida por nuestro programa Python o la aplicación de Android.

Comencemos a codificar usando el método (2).

Para interactuar con el aparato de medición bluetooth, se proporcionan dos versiones de SDK:

1) Python SDK, que se puede instalar mediante "pip3 install m2controller", python3 es el lenguaje utilizado. Los ejemplos de código de aplicación de usuario se almacenan en https://github.com/xiapeiqing/m2robots/tree/maste … Para este experimento, usaremos el script de Python pendulum1.py

2) Java SDK, que no se utiliza en este instructable porque queremos una posterior visualización y análisis de los datos del péndulo adquiridos, lo que podría requerir un poco más de esfuerzo para programar en Java.

El código fuente del programa de recopilación de datos python3 contiene muchos comentarios para los detalles de la funcionalidad del código. Aquí se proporciona una instantánea del código fuente.

#! / usr / bin / env python # - * - codificación: UTF-8 - * - de m2controller importar m2controller de m2controller importar m2Const importar señal importar tiempo importar fecha y hora importar usrCfg importar péndulo2

requestSalir = Falso

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

# queremos usar la misma convención de nomenclatura de archivos de registro para que el módulo de análisis de datos, pendulum2.py, pueda ser independiente de cómo obtenemos el archivo de datos de registro ################# ################################################################################################################################################# m2flightData% s.txt "% (datetime.datetime.fromtimestamp (time.time ()). strftime ('% Y% m% d_% H% M% S')) dataLogfile = open (logfilename," w ")

def manejador_de_señal (sig, marco):

solicitud global Salir imprimir ('el usuario Ctrl-C para salir de la ejecución del programa') solicitud Salir = Verdadera señal.señal (señal. SIGINT, manejador_señal)

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

# cada vez que los datos de medición estén disponibles a una velocidad de 20 Hz, esta función de "devolución de llamada" se invocará ############################# ################################ def callbackfunc (telemetría): 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, telemetría ['m_fAccelHwUnit'] [0], telemetría ['m_fAccelHwUnit'] [1], telemetría ['m_fAccelHwUnit'] [2], telemetría ['m_fGyroHwUnit'] [0], telemetría ['m_fGyroHwUnit'] [1], telemetría ['m_fGyroHwUnit'] [2], telemetría ['m_fNit' telemetry [0] 'm_fMagHwUnit'] [1], telemetría ['m_fMagHwUnit'] [2], telemetría ['m_fRPYdeg'] [0], telemetría ['m_fRPYdeg'] [1], telemetría ['m_fRPYdeg'] [2]) ## ################################################ ############ # imprimimos la cadena de datos en la pantalla y los guardamos en el archivo de registro ##################### ####################################### imprime (dataStr) dataLogfile.writelines (dataStr)

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

# inicialice el controlador, recuerde configurar el campo BleMACaddress para que sea la dirección MAC de su dispositivo ############################### ############################## # TODO: inicialicemos la BleMACaddress si no la ha configurado el usuario. controller = m2controller. BleCtrller (m2Const.etDebian, callbackfunc, usrCfg. BleMACaddress) controller.connect () while True: ########################## #################################### # esperar los datos de medición creados y enviados desde la medición del péndulo aparato ############################################### ############### controller.m_CommsTunnel.waitForNotifications (1.0) if requestSalir: ######################## ###################################### # el mantenimiento de la casa funciona aquí cuando terminamos el registro de datos ################################################ ############## controller.stop () dataLogfile.close () break

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

# recopilación de datos completada, ahora analicemos los datos de registro ##################################### ######################## pendulum2.parseDataLogFile (logfilename)

Para una actualización a largo plazo, consulte

Ahora expliquemos su método de operación. Este programa de Python está escrito sobre un paquete instalable pip, llamado m2controller. El paquete de nivel inferior ofrece un mecanismo de devolución de llamada, de modo que cada actualización de medición recibida activará la función de devolución de llamada que escribimos y guardará los datos en un archivo de registro local. El formato del contenido de los datos del archivo de registro es idéntico al que produce la aplicación complementaria de Android, por lo que el archivo de registro de datos creado por el programa Python o la aplicación complementaria de Android es intercambiable.

La señal ctrl-C del usuario, capturada por el sistema operativo, se pasa al programa y detiene el bucle infinito esperando la nueva llegada de los datos de medición.

Hasta ahora, el archivo de registro se ha creado con éxito y este programa llamará al programa de análisis para estudiar los resultados de nuestro experimento.

Aquí hay dos experimentos, y la comparación muestra la diferencia muy notable al conectar un dispositivo de 7 gramos en diferentes ubicaciones.

En la figura 2, utilizamos una escala para determinar el peso real de este aparato de medición bluetooth.

La figura 3 muestra la configuración del péndulo donde el dispositivo de 7 gramos se adjunta al extremo inferior del péndulo. La configuración de instalación en la figura 4 tiene la masa de 7 gramos ubicada mucho más cerca del pivote de balanceo.

La figura 5 es una vista de cerca de la estructura del péndulo.

Paso 4: análisis de datos

El aparato de medición bluetooth pesa ~ 7 gramos, que pesa mucho menos que un palo de madera de ~ 1,6 metros de largo. Utilice el supuesto de "varilla uniforme rígida", y tenemos esta ecuación del período del péndulo, T1 = 2 * pi * (2l / 3g) ^ 0.5

Para obtener la constante de gravedad, podemos usar 9,8 m / s ^ 2. Pero se puede recuperar una constante de gravedad más precisa en cualquier geolocalización de este servicio web:

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

Para san francisco, es 9,81278 m / s ^ 2

La longitud del péndulo se mide en 64,5 ''

2 * pi * sqrt (2 * 64.5 * 0.0254 / (3 * 9.81278)) da el período de péndulo esperado de 2.0962 (seg).

Veamos si está de acuerdo con nuestros experimentos.

En el primer experimento, la configuración del péndulo tiene el dispositivo de 7 gramos conectado al extremo inferior del péndulo. Mi archivo de registro se puede descargar en:

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

Cambie el nombre a "PendulumTestData.txt" y colóquelo en la misma carpeta del programa de análisis de Python. Aquí se proporciona una instantánea del código fuente.

#! / usr / bin / env python # - * - codificación: UTF-8 - * - import csv import matplotlib.pyplot as plt plt.style.use ('seaborn-whitegrid') import numpy as np from datetime import datetime, timedelta importar seaborn como sns desde sklearn.cluster importar KMeans de colecciones importar Contador ################################# ############################# # esta función ejecuta el trabajo de análisis del archivo de datos ############ ################################################ ## def parseDataLogFile (nombre de archivo de datos): ######################################## ##################### # extraer datos en el archivo de registro de datos separados por comas (CSV) y guardar el contenido de cada columna en una variable de tipo flotante ## ############################################### ############ con open (datafilename) como csvfile: readCSV = csv.reader (csvfile, delimiter = ',') timestampS = fAccelHwUnit_x = fAccelHwUnit_y = fAccel_zHwUnit_y = fAccel_zHwUnit fGyroHwUnit_x = fGyroHwUnit_y = fGyroHwUnit_z = fMagHwUnit_x = fMagHwUnit_y = fMagHwUni t_z = fRPYdeg_r = fRPYdeg_p = fRPYdeg_y = para la fila en readCSV: intente: x = datetime.strptime (fila [0].split (',') [0], '% H:% M:% S.% f ') timestampS.append (timedelta (horas = x.hora, minutos = x.minuto, segundos = x.segundo, microsegundos = x.microsegundo).total_seconds ()) fAccelHwUnit_x.append (float (fila [1] [4:])) fAccelHwUnit_y.append (float (fila [2])) fAccelHwUnit_z.append (float (fila [3])) fGyroHwUnit_x.append (float (fila [4])) fGyroHwUnit_y.append (float (fila [4])) (fila [5])) fGyroHwUnit_z.append (float (fila [6])) fMagHwUnit_x.append (float (fila [7])) fMagHwUnit_y.append (float (fila [8])) fMagHwUnit_z.append (float (fila [9])) fRPYdeg_r.append (float (fila [10])) fRPYdeg_p.append (float (fila [11])) fRPYdeg_y.append (float (fila [12])) excepto: pass timestampS = np.asarray (marcas de tiempo) marcas de tiempo = marcas de tiempo - marcas de tiempo [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)

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

# Necesitamos una estimación exacta de la frecuencia de muestreo para una estimación precisa del período de oscilación ############################################################################################################## ########################### FsHz = getSamplingIntervalS (timestampS) ################ ################################################ # usar componente de cabeceo en la salida del sistema de referencia de rumbo de actitud para el análisis del período del péndulo ################################### ########################## analysis_timeSequence (marca de tiempo, fRPYdeg_p, FsHz, 'tono') ############ ################################################ ### # utilizar la salida de medición sin procesar del acelerómetro para el análisis del período del péndulo ################################### ########################## analysis_timeSequence (marcas de tiempo, fAccelHwUnit_x, FsHz, 'accel') ########### ################################################ ### # utilizar la salida de medición sin procesar del giroscopio para el análisis del período del péndulo #################################### ########################## analysis_timeSequence (marca de tiempo, fGyroHwUnit_y, FsHz, ' gyro ') print (' hecho, felicitaciones:-) ') plt.show () ############################# ################################ # en el proceso de comunicación bluetooth, existe una rara posibilidad de que el paquete de comunicación de datos perderse # usamos K-mean para aislar los datos de medición de 20Hz de los valores atípicos, que son causados por paquetes caídos # sumérjase en "señal y sistema para obtener más detalles" ################ ############################################# def getSamplingIntervalS (timestampS): plt.figure () sampleIntervalS = np.diff (timestampS) sns.distplot (sampleIntervalS) plt.ylabel ('histograma') plt.xlabel ('intervalo (s) de medición') clusterCnt = 5 km = KMeans (n_clusters = clusterCnt) km.fit (sampleIntervalS.reshape (-1, 1)) centroides = km.cluster_centers_ elemCnt = Contador (km.labels_) ocurrenciaCnt = para ii en el rango (clusterCnt): ocurrenciaCnt.append (elemCnt [ii]) FsHz = 1 / centroides [ocurrenciaCnt.index (max (ocurrenciaCnt))] return FsHz

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

# use espectrómetro, es decir, FFT de tiempo corto para obtener el componente de frecuencia, el intervalo de pico es nuestra mejor estimación de la oscilación del péndulo ########################## #################################### def analyse_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 ("medición del dominio del tiempo del péndulo -% s"% strComment) ax1.set_xlabel ("tiempo de muestreo (segundo)") ax1.set_ylabel (strComment); NFFT = 2048 # la longitud de los segmentos de ventana

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

ax2.set_title ("Espectrograma") ax2.set_xlabel ("muestras") ax2.set_ylabel ("frecuencia (Hz)");

# El método `specgram` devuelve 4 objetos. Son:

# - Pxx: el periodograma # - freqs: el vector de frecuencia # - bins: los centros de los bins de tiempo # - im: la instancia matplotlib.image. AxesImage que representa los datos en el gráfico pkresult = np.where (Pxx == np.amax (Pxx)) oscFreqHz = freqs [pkresult [0] [0] print ('pendulum oscillation Freq (Hz) =% f, Period (Sec) =% f, fuente de datos de estimación:% s'% (oscFreqHz, 1 / oscFreqHz, strComment)) return 1 / oscFreqHz

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

# si ejecutamos este programa de forma independiente, es decir, sin ser llamado por pendulum1.py, # definimos un nombre de archivo de datos de registro predeterminado para ser analizado #################### ########################################## if _name_ == "_main_ ": defaultFilename = './PendulumTestData.txt' import os.path if os.path.isfile (defaultFilename): parseDataLogFile (defaultFilename) else: print (" el archivo de registro predeterminado% s no existe "% defaultFilename)

Para una actualización a largo plazo, consulte

El código fuente contiene comentarios detallados, hagamos un resumen de alto nivel de la estimación matemática aquí.

1) Primero leemos el contenido del archivo CSV en la computadora, usando un paquete de Python llamado "csv". Disponemos de medición periódica.

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) Dado que la tasa de medición es tan crítica e introduce directamente el error de estimación del período del péndulo, queremos estimarlos. Nuestro intervalo de medición nominal es de 50 ms, es decir, 20 Hz. El promedio de todas las mediciones parece correcto, pero ocasionalmente perdemos paquetes de transmisión de datos, el intervalo de actualización se convierte en 100 ms o 150 ms,…

Si graficamos la ocurrencia de estos datos, vea la Figura 1, como humano, podemos tener fácilmente un valor visual de 0.05 segundos. Sin embargo, ¿podemos hacerlo mejor que eso?

Necesitamos usar el método de clasificación para seleccionar solo los buenos para el cálculo promedio. Python tiene una caja de herramientas llamada KMeans para ayudarnos con la agrupación, o decir clasificación. Estos conceptos se utilizan en muchas áreas de Big Data e IA.

3) La figura 2 contiene dos imágenes. La gráfica superior es una secuencia en el dominio del tiempo de nuestra medición del ángulo de oscilación en grados. Al hacer referencia a la marca de tiempo del eje x en Segundo, podemos leer aproximadamente 22.5 ciclos en 50 segundos, lo que se traduce en un período de péndulo de 2.22 segundos. ¿Hay alguna forma de automatizar este proceso y tener una estimación más precisa? Sí, podemos usar una herramienta matemática llamada espectrograma, que usa una pequeña porción de datos de medición y nos dice su frecuencia, vea la figura a continuación. La lectura del eje y para la línea más oscura es la frecuencia de oscilación del péndulo. Ser una línea horizontal confirma que la oscilación del péndulo no cambió en absoluto durante el experimento. El valor inverso de la frecuencia de oscilación es el período de oscilación del péndulo.

El informe final elaborado por el programa es un resumen de texto:

frecuencia de oscilación del péndulo (Hz) = 0,449224, período (seg) = 2,226059, fuente de datos de estimación: tono

Podemos encontrar nuestro resultado anterior del cálculo de la mano visual, 2,22 segundos, es bastante consistente con el valor calculado por el programa.

En comparación con el valor calculado teóricamente de 2.0962 (s), tenemos un error restante de ~ 5%. ¿Cómo deshacerse de ellos? ¿Recuerda que el supuesto es "varilla uniforme rígida"? Incluso un peso extra de 7 gramos parece trivial, es la principal causa del error restante.

Ahora movemos el dispositivo, cerca del pivote. Consulte el paso anterior para ver una foto de primer plano. El archivo de registro que creé se puede descargar aquí:

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

Ejecute los mismos pasos de análisis y obtenemos un período de 2.089867 (seg), consulte la figura 3, que es casi idéntica a la predicción teórica. ¡Excelente!

Dado que no solo tenemos la medición del ángulo de oscilación, sino también la medición giroscópica y la medición del acelerómetro a la misma velocidad. Realice el mismo análisis para las otras dos mediciones, obtenemos resultados en las Figuras 4 y 5. Las estimaciones de las tres fuentes de medición coinciden, lo que nos hace más seguros del éxito de nuestro experimento.

Aquí está el resultado como el resultado final del programa Python en ejecución:

frecuencia de oscilación del péndulo (Hz) = 0,478499, período (seg) = 2,089867, fuente de datos de estimación: tono

frecuencia de oscilación del péndulo (Hz) = 0,478499, período (seg) = 2,089867, fuente de datos de estimación: acel

Frecuencia de oscilación del péndulo (Hz) = 0,478499, período (seg) = 2,089867, fuente de datos de estimación: giroscopio

Último pensamiento en este paso, ¿cómo pueden los resultados de la estimación ser exactamente idénticos utilizando diferentes fuentes de datos de entrada? Esto es contraintuición. Dejaré esta pregunta a los lectores. Aquí hay una pista: recuerde que estamos usando la FFT de tiempo corto para estimar la frecuencia de oscilación? En el dominio digital, la estimación de frecuencia se da en intervalos de frecuencia discretos en lugar de una estimación de número flotante.

Paso 5: Recomendaciones de trabajo futuro

Hay pocas categorías de recomendaciones de trabajo futuro.

En el paso anterior, logramos reducir el error de nuestro experimento de ~ 5% a menos del 1%, ¿podemos hacerlo mejor que eso? Al notar que la magnitud de la oscilación disminuye exponencialmente, un factor que contribuye puede ser el arrastre de aire causado al balancear el péndulo. Puede que sea necesario modificar la sección transversal del péndulo para que tenga una forma aerodinámica a fin de reducir la resistencia aerodinámica.

¿Podemos aplicar una ganancia variable en el tiempo aprendida usando técnicas de filtro adaptativo para generar una señal de magnitud pico constante? Mientras tanto, correlacione la magnitud de la atenuación con las fuerzas externas.

Difícilmente podemos encontrar algo más simple que el "simple movimiento armónico". ¿Podemos utilizar las instalaciones en las que analizamos el péndulo para analizar algo más complicado, una actividad deportiva, una secuencia de lanzamiento de un cohete de agua, etc?

Feliz piratería