Estudo Experimental de Movimento Harmônico Simples: 5 Etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:36

Por arrowlikeFollow More by the author:

Na sala de aula, costumamos usar um cronômetro para conduzir o experimento do pêndulo, ou experimento de movimento harmônico simples. Aqui está um desafio, podemos produzir um gráfico real de seu movimento e ver qual é a posição angular e velocidade instantâneas, isso é muito mais informação e diversão.

Primeira pergunta, precisamos decidir se o corpo do pêndulo é um cordão sem peso ou uma haste rígida e uniforme. A abordagem do cordão parece ser mais fácil. A partir da prática de construir um, tenho as seguintes considerações de compensação: A maneira mais fácil de pendurar um sistema de pêndulo pode ser pendurá-lo na borda superior da porta. Isso dá um comprimento de pêndulo de ~ 2m sem fazer nenhum trabalho de construção estrutural. Mas é necessário que o balanço não toque a superfície da porta, o que simplesmente arruína todo o experimento. Portanto, o plano que ele balança deve ser precisamente paralelo à superfície da parede / porta. Um cabo sem peso tende a ser fino, pode girar facilmente e complicar a medição do ângulo de oscilação. Queremos usar uma medida para representar o estado de oscilação. Cordas finas, como a linha do peixe, podem ser elásticas e esticáveis, o que afeta uma de nossas constantes mais importantes medidas por nós e usadas na equação, que é o comprimento do pêndulo. Alguns também podem ser afetados pela temperatura. A massa de peso pendurada na extremidade do cabo deve ser pesada o suficiente para que o peso do cabo se torne insignificante. Comente se você concorda ou discorda deles, ou se tem outras idéias de compensação de design. Para estudar esse problema, precisamos de um dispositivo tão leve que seu peso possa ser ignorado e ainda tratamos o sistema de pêndulo como uma haste rígida e uniforme. Estou usando um controlador eletrônico vestível COTS, que nos fornece informações do giroscópio, do acelerômetro e do ângulo por meio de uma conexão bluetooth. Essas medições serão armazenadas em um arquivo de dados do aplicativo do telefone móvel. Depois disso, analisaremos os dados para nosso experimento de movimento harmônico simples. A análise numérica concentra-se nos seguintes tópicos: 1) Prever o período de oscilação do pêndulo 2) Coletar de forma programável os dados do experimento de movimento harmônico simples do pêndulo 3) Usar kmean para agrupar dados e remover outliers no processo de análise 4) Usar FFT de curto prazo para estimar a frequência de oscilação do pêndulo

Suprimentos

Aparelho de medição Bluetooth

Aplicativo de telefone Android: Vá para o Google playstore, pesquise M2ROBOTS e instale o aplicativo de controle. Caso seja difícil acessar o Google Playstore, visite minha página inicial para obter um método alternativo de download de aplicativos

vara de madeira

poucas peças impressas em 3D

lâminas de serra ou material de metal semelhante

Etapa 1: O que é o pêndulo? Como modelar?

Existem muitos artigos e livros que introduzem a derivação da equação do pêndulo, incluindo o livro do currículo de física. Seria melhor esse conteúdo não ser repetido aqui novamente. Apenas a conclusão final é listada aqui com relação ao tópico de "movimento harmônico simples". Para saber o período de um pêndulo, tudo o que precisamos saber é o comprimento do pêndulo, denominado "l", em metros.

Se estivermos razoavelmente seguros de que o peso está localizado quase completamente na extremidade de uma corda sem peso pendurada em um pivô, e o pêndulo está balançando em pequenos ângulos θ, digamos menos de 15 °, o período T1 de tal pêndulo é dado por:

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

g = aceleração da gravidade, aproximadamente 9,8 m / s ^ 2

Se o cabo sem peso for substituído por uma haste rígida e uniforme, novamente de comprimento l, seu período de movimento harmônico simples T2 é dado por T1 = 2 * pi * (2l / 3g) ^ 0,5

Efetivamente, ele tem o mesmo período que um pêndulo de corda sem peso, sendo dois terços do comprimento da haste rígida e uniforme.

Este é o pano de fundo e podemos começar a preparar nosso experimento.

Etapa 2: preparar as peças para construção de hardware

Para construir a estrutura do pêndulo, imprimimos algumas peças em 3D e reciclamos algo que já temos. A estrutura geral do pêndulo é mostrada na Fig.1. É uma mistura de peças impressas em 3D com algumas peças feitas à mão e um longo pedaço de haste de madeira da Lowe's.

A parte impressa em 3D na Fig.2 está pendurada na borda superior de uma porta, porque nossa porta é uma superfície plana fácil para pendurarmos algo. Link para download do arquivo STL:

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

A parte verde na Fig.3 conecta a haste de madeira a uma lâmina, e a lâmina fica no topo de duas peças de trilho montadas no cabide de porta impresso em 3D anterior. Link para download do arquivo STL:

As duas peças do trilho são feitas quebrando uma lâmina de serra velha ao meio, veja a Fig. 4. A parte da Fig.2 preparou o tamanho de fenda certo para elas. Idealmente, podemos fazer um entalhe em forma de "V" nessas duas lâminas de serra usando uma lima. Um metal com arestas razoavelmente afiadas, como uma lâmina de barbear de gume único ou qualquer peça de metal feita à mão, pode ficar dentro dos entalhes em forma de "V". A razão pela qual precisamos de uma área de contato menor é para reduzir a energia cinética perdida durante o balanço.

A última parte impressa em 3D na Fig.5 é uma pequena bandeja para conter o aparelho de medição eletrônico.

O link de download:

O aparelho de medição bluetooth gera estimativa de ângulo, medição giroscópica e medição acelerômetro. Todos esses dados estão disponíveis para nós através do link wireless bluetooth.

Faremos vários experimentos implantando este aparelho em diferentes posições do braço do pêndulo e veremos as diferenças.

Etapa 3: coleta de dados do experimento

Existem dois métodos viáveis para a coleta de dados experimentais antes de analisarmos o conjunto de dados adquirido:

1) Use o aplicativo de telefone Android especificado na seção de requisitos para registrar todas as medições produzidas pelo aparelho em um arquivo de dados armazenado no cartão SD do seu telefone. Podemos copiar o arquivo e pós processar as informações.

2) Use um computador habilitado para bluetooth, um PC, um laptop ou um minicomputador RaspberryPi para estabelecer uma conexão bluetooth com o aparelho e ler os dados para análise em tempo real ou offline.

Existem prós e contras para cada método, vamos tentar ambos e ver a diferença neste instrutível.

Para o método (1) usando o aplicativo Android, quando estivermos na interface de controle do aplicativo Android, os dados de telemetria enviados do aparelho de medição bluetooth para o telefone Android serão registrados em um arquivo de registro de dados denominado m2flightDatayyyymmdd_hhmmss.txt. Ele pode ser encontrado na pasta Download / m2LogFiles do seu telefone Android. A pasta "Download" é uma pasta pré-existente no sistema operacional Android do seu telefone e "m2LogFiles" é uma pasta que o aplicativo criou. O conteúdo do nome do arquivo aaaammdd_hhmmss é a forma de codificar a hora de início do experimento (ano, mês, dia, hora, minuto e segundos) no nome do arquivo.

Cada linha do arquivo de log é um registro. Ele começa com o carimbo de data / hora do evento, string de preâmbulo "eam:", seguido por 4 dados triplos, que são:

Leitura do eixo XYZ do acelerômetro em valores brutos de leitura de registro de hardware do sensor

Leitura do eixo XYZ do giroscópio em valores brutos de leitura de registro de hardware do sensor

Leitura do eixo XYZ do magnetômetro em valores brutos de leitura de registro de hardware do sensor

Roll / Pitch / Raw estimado a bordo em grau

O arquivo de dados criado usando o programa python de computador usará formato de arquivo de dados idêntico, de modo que o programa que usamos na etapa de análise de dados não será incomodado com a fonte de dados que está sendo produzida por nosso programa python ou aplicativo Android.

Vamos começar a codificar usando o método (2).

Para interagir com o aparelho de medição bluetooth, dois tipos de SDK são fornecidos:

1) Python SDK, que pode ser instalado por "pip3 install m2controller", python3 é a linguagem usada. Os exemplos de código de aplicativo do usuário estão armazenados em https://github.com/xiapeiqing/m2robots/tree/maste… Para este experimento, usaremos o script python pendulum1.py

2) Java SDK, que não é usado neste instrutível porque queremos visualização e análise posterior dos dados do pêndulo adquiridos, o que pode exigir um pouco mais de esforço para programarmos em Java.

O código-fonte do programa de coleta de dados python3 contém muitos comentários para os detalhes da funcionalidade do código. Um instantâneo do código-fonte é fornecido aqui.

#! / usr / bin / env python # - * - codificação: UTF-8 - * - de m2controller importar m2controller de m2controller importar m2Const sinal de importação importação hora importar data e hora importar usrCfg importar pendulum2

requestExit = False

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

# queremos usar a mesma convenção de nomenclatura de arquivo de log para que o módulo de análise de dados, pendulum2.py, possa ser independente de como obtemos o arquivo de dados de log ################### ########################################################### 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 ('usuário Ctrl-C para sair da execução do programa') requestExit = Sinal verdadeiro.signal (signal. SIGINT, signal_handler)

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

# quando todos os dados de medição estiverem disponíveis na taxa de 20 Hz, esta função de "retorno de chamada" será chamada ######################################################################################################################## ############# Def callbackfunc (telemetria): 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, telemetria ['m_fAccelHwUnit'] [0], telemetria ['m_fAccelHwUnit'] [1], telemetria ['m_fAccelHwUnit'] [2], telemetria ['m_fGyroHwUnit'] [0], telemetria ['m_fGyroHwUnit'] [1], telemetria ['m_fGyroHwUnit'] [2], telemetria ['m_fMagHwUnit] [0], telemetria] 'm_fMagHwUnit'] [1], telemetria ['m_fMagHwUnit'] [2], telemetria ['m_fRPYdeg'] [0], telemetria ['m_fRPYdeg'] [1], telemetria ['m_fRPYdeg'] [2]) ## ############################################################### ################ # imprimimos a string de dados na tela e os salvamos no arquivo de log ############################ ##################################################### Print (dataStr) dataLogfile.writelines (dataStr)

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

# inicializar o controlador, lembre-se de definir o campo BleMACaddress como o endereço MAC do seu dispositivo ###################################### ################################################################################################################################################################################################################################# controller = m2controller. BleCtrller (m2Const.etDebian, callbackfunc, usrCfg. BleMACaddress) controller.connect () while True: ############################################################################################################################## #################################################### # espere pelos dados de medição criados e enviados da medição do pêndulo aparelho ############################################################## #################### controller.m_CommsTunnel.waitForNotifications (1.0) se requestExit: ############################# ################################################################################################################################ ############################################################### ################## Controller.stop () dataLogfile.close () break

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

# coleta de dados concluída, agora vamos analisar os dados de log ############################################## ################################ Pendulum2.parseDataLogFile (logfilename)

Para atualizações de longo prazo, confira

Agora vamos explicar seu método de operação. Este programa Python é escrito sobre um pacote instalável pip, denominado m2controller. O pacote de nível inferior oferece mecanismo de retorno de chamada, de modo que cada atualização de medição recebida acione a função de retorno de chamada que escrevemos e salve os dados em um arquivo de log local. O formato do conteúdo dos dados do arquivo de log é idêntico ao que é produzido pelo aplicativo complementar do Android, de modo que o arquivo de registro de dados criado pelo programa python ou pelo aplicativo complementar do andriod pode ser trocado.

O sinal do usuário ctrl-C, capturado pelo sistema operacional, é passado para o programa, e interrompe o loop infinito aguardando a nova chegada dos dados de medição.

Até agora, o arquivo de log foi criado com sucesso, e este programa irá chamar o programa de análise para estudar os resultados do nosso experimento.

Aqui estão dois experimentos, e a comparação mostra a diferença notável ao conectar um dispositivo de 7 gramas em locais diferentes.

Na Fig.2, usamos uma escala para determinar o peso real deste aparelho de medição bluetooth.

A Fig.3 mostra a configuração do pêndulo onde o dispositivo de 7 gramas é conectado à extremidade inferior do pêndulo. A configuração de instalação na Fig.4 tem a massa de 7 gramas localizada muito mais perto do pivô oscilante.

A Fig.5 é uma vista aproximada da estrutura do pêndulo.

Etapa 4: Análise de dados

O aparelho de medição bluetooth pesa ~ 7 gramas, que pesa muito menos do que uma vara de madeira de ~ 1,6 metros. Use a suposição de "haste uniforme rígida", e temos esta equação do período do pêndulo, T1 = 2 * pi * (2l / 3g) ^ 0,5

Para obter a constante de gravidade, podemos usar 9,8 m / s ^ 2. Mas uma constante de gravidade mais precisa em qualquer localização geográfica pode ser recuperada neste serviço da web:

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

Para São Francisco, é 9,81278 m / s ^ 2

O comprimento do pêndulo é medido em 64,5 ''

2 * pi * sqrt (2 * 64,5 * 0,0254 / (3 * 9,81278)) dá o período de pêndulo esperado de 2,0962 (seg).

Vamos ver se concorda com nossos experimentos.

No primeiro experimento, a configuração do pêndulo tem o dispositivo de 7 gramas preso à extremidade inferior do pêndulo. Meu arquivo de log pode ser baixado em:

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

Renomeie-o para "PendulumTestData.txt" e coloque-o na mesma pasta do programa de análise python. Um instantâneo do código-fonte é fornecido aqui.

#! / usr / bin / env python # - * - codificação: UTF-8 - * - import csv import matplotlib.pyplot as plt plt.style.use ('seaborn-whitegrid') import numpy como np from datetime import datetime, timedelta import seaborn as sns from sklearn.cluster import KMeans from collection import Counter ############################################################################################################################################ ################################################################################################################################################ ############################################################### ## def parseDataLogFile (datafilename): ################################################ ############################### Extraia os dados no arquivo de registro de dados separados por vírgula (CSV) e salva o conteúdo de cada coluna em uma variável do tipo flutuante ## ############################################################### ########### Com open (datafilename) como csvfile: readCSV = csv.reader (csvfile, delimiter = ',') timestampS = fAccelHwUnit_x = fAccelHwUnit_y = fAccelHwUnit_y = fAccelHwUnit_y = fGyroHwUnit_x = fGyroHwUnit_y = fGyroHwUnit_z = fMagHwUnit_x = fMagHwUnit_y = fMagHwUni t_z = fRPYdeg_r = fRPYdeg_p = fRPYdeg_y = para linha em readCSV: try: x = datetime.strptime (linha [0].split (',') [0], '% H:% M:% S.% f ') timestampS.append (timedelta (horas = x.horas, minutos = x.minuto, segundos = x.segundo, microssegundos = x.microssegundo).total_seconds ()) fAccelHwUnit_x.append (float (linha [1] [4:])) fAccelHwUnit_y.append (float (linha [2])) fAccelHwUnit_z.append (float (linha [3])) fGyroHwUnit_x.append (float (linha [4])) fGyroHwUnit_y.ap (float (linha [5])) fGyroHwUnit_z.append (float (linha [6])) fMagHwUnit_x.append (float (linha [7])) fMagHwUnit_y.append (float (linha [8])) fMagHwUnit_z.append (linha [9])) fRPYdeg_r.append (float (row [10])) fRPYdeg_p.append (float (row [11])) fRPYdeg_y.append (float (row [12])) exceto: passar timestampS = np.asarray (timeStamps) timeStamps = timeStamps - timeStamps [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)

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

# precisamos de uma estimativa precisa da frequência de amostragem para uma estimativa precisa do período de oscilação ################################################################################################################## ###################################### FsHz = getSamplingIntervalS (timestampS) ################## ################################################ # usar componente de inclinação na saída do sistema de referência do rumo de atitude para análise do período do pêndulo ################################################################################################################################################# ################################### Analise_timeSequence (timestampS, fRPYdeg_p, FsHz, 'pitch') ############ ############################################################### ### # use a saída de medição bruta do acelerômetro para a análise do período do pêndulo ########################################################################################################## #################################### Analise_timeSequence (timestampS, fAccelHwUnit_x, FsHz, 'accel') ############ ############################################################### ### # use a saída de medição bruta do giro para a análise do período do pêndulo ########################################################################################################################## ################################### Analise_timeSequence (timestampS, fGyroHwUnit_y, FsHz, ' giroscópio ') print (' pronto, parabéns:-) ') plt.show () ##################################### ########################################### # no processo de comunicação bluetooth, há uma chance rara de que o pacote de comunicação de dados poderia ser perdido # usamos K-mean para isolar os dados de medição de 20 Hz de outliers, que são causados por pacotes perdidos # mergulho em "sinal e sistema para mais detalhes" ################# ############################################################ Def getSamplingIntervalS (timestampS): plt.figure () sampleIntervalS = np.diff (timestampS) sns.distplot (sampleIntervalS) plt.ylabel ('histogram') plt.xlabel ('intervalo (s) de medição') clusterCnt = 5 km = KMeans (n_clusters = clusterCnt) km.fit (sampleIntervalS.reshape (-1, 1)) centroids = km.cluster_centers_ elemCnt = Counter (km.labels_) occurCnt = for ii no intervalo (clusterCnt): occurCnt.append (elemCnt [ii]) FsHz = 1 / centroids [occurCnt.index (max (ocont))] return FsHz

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

# usar espectrômetro, ou seja, FFT de curto tempo para obter o componente de frequência, bin de pico é nossa melhor estimativa de oscilação pendular ############################### ############# 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 ("medição do domínio do tempo do pêndulo -% s"% strComment) ax1.set_xlabel ("tempo de amostragem (segundo)") ax1.set_ylabel (strComment); NFFT = 2048 # o comprimento dos segmentos de janelas

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

ax2.set_title ("Espectrograma") ax2.set_xlabel ("amostras") ax2.set_ylabel ("frequência (Hz)");

# O método `specgram` retorna 4 objetos. Eles são:

# - Pxx: o periodograma # - freqs: o vetor de frequência # - bins: os centros dos bins # - im: a instância matplotlib.image. AxesImage que representa os dados no gráfico pkresult = np.where (Pxx == np.amax (Pxx)) oscFreqHz = freqs [pkresult [0] [0] print ('oscilação do pêndulo Freq (Hz) =% f, Período (Seg) =% f, fonte de dados de estimativa:% s'% (oscFreqHz, 1 / oscFreqHz, strComment)) return 1 / oscFreqHz

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

# devemos executar este programa independentemente, ou seja, não sermos chamados por pendulum1.py, # definimos um nome de arquivo de dados de log padrão a ser analisado ######################## ######################################################## Se _name_ == "_main_ ": defaultFilename = './PendulumTestData.txt' import os.path if os.path.isfile (defaultFilename): parseDataLogFile (defaultFilename) else: print (" arquivo de log padrão% s não existente "% defaultFilename)

Para atualizações de longo prazo, confira

O código-fonte contém comentários detalhados, vamos dar um resumo de alto nível da estimativa matemática aqui.

1) Primeiro lemos o conteúdo do arquivo CSV no computador, usando um pacote python chamado "csv". Temos medição 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) Como a taxa de medição é tão crítica e introduz diretamente o erro de estimativa do período do pêndulo, queremos estimá-los. Nosso intervalo de medição nominal é de 50ms, ou seja, 20Hz. A média de todas as medições parece OK, mas ocasionalmente perdemos o pacote de transmissão de dados, o intervalo de atualização torna-se 100 ms ou 150 ms, …

Se representarmos graficamente a ocorrência desses dados, consulte a Fig.1, como humanos, podemos facilmente ter um valor de 0,05 seg. No entanto, podemos fazer melhor do que isso?

Precisamos usar o método de classificação para selecionar apenas os bons para o cálculo da média. Python tem uma caixa de ferramentas chamada KMeans para nos ajudar com o clustering ou, digamos, classificação. Esses conceitos são usados em muitas áreas de big data e IA.

3) A Fig.2 contém duas imagens. O gráfico superior é uma sequência no domínio do tempo de nossa medição do ângulo de oscilação em graus. Fazendo referência ao carimbo de data / hora do eixo x em segundos, podemos ler aproximadamente 22,5 ciclos em 50 segundos, o que se traduz em 2,22 segundos de período de pêndulo. Existe uma maneira de automatizar esse processo e ter uma estimativa mais precisa? Sim, podemos usar uma ferramenta matemática chamada espectrograma, que usa um pequeno pedaço de dados de medição e nos diz sua frequência, veja a figura abaixo. A leitura do eixo y para a linha mais escura é a frequência de oscilação do pêndulo. Ser uma linha horizontal confirma que a oscilação do pêndulo não mudou em nada durante o experimento. O valor inverso da frequência de oscilação é o período de oscilação do pêndulo.

O relatório final do programa é um resumo do texto:

oscilação do pêndulo Freq (Hz) = 0,449224, Período (Seg) = 2,226059, fonte de dados de estimativa: pitch

Podemos descobrir que nosso resultado anterior do cálculo da mão do globo ocular, 2,22 seg, é bastante consistente com o valor calculado do programa.

Em comparação com o valor calculado teoricamente de 2,0962 (seg.), Temos cerca de 5% de erro restante. como se livrar deles? Lembra que a suposição é "haste rígida e uniforme"? Mesmo um peso extra de 7 gramas parece trivial, é a maior causa do erro remanescente.

Agora movemos o dispositivo, perto do pivô. Veja a etapa anterior para uma foto em close-up. O arquivo de log que criei pode ser baixado aqui:

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

Execute as mesmas etapas de análise e obtemos Período de 2,089867 (seg), consulte a Fig.3, que é quase idêntico à previsão teórica. Excelente!

Uma vez que não temos apenas a medição do ângulo de oscilação, mas também a medição giroscópica e a medição do acelerômetro na mesma taxa. Execute a mesma análise para as outras duas medições, obtemos os resultados nas Fig.4 e 5. As estimativas de todas as três fontes de medição concordam, o que nos torna mais confiantes no sucesso de nosso experimento.

Aqui está o resultado como a saída final do programa Python em execução:

oscilação do pêndulo Freq (Hz) = 0,478499, Período (Seg) = 2,089867, fonte de dados de estimativa: pitch

oscilação do pêndulo Freq (Hz) = 0,478499, Período (Seg) = 2,089867, fonte de dados de estimativa: aceleração

oscilação do pêndulo Freq (Hz) = 0,478499, Período (Seg) = 2,089867, fonte de dados de estimativa: giroscópio

Último pensamento nesta etapa, como os resultados da estimativa podem ser exatamente idênticos usando fontes de dados de entrada diferentes? Isso é contra-intuição. Vou deixar essa pergunta para os leitores. Aqui vai uma dica: lembra que estamos usando o FFT de curto prazo para estimar a frequência de oscilação? No domínio digital, a estimativa de frequência é dada em compartimentos de frequência discretos em vez de uma estimativa de número flutuante.

Etapa 5: Recomendações de trabalho futuro

Existem algumas categorias de recomendações de trabalho futuro.

Na etapa anterior, conseguimos reduzir nosso erro experimental de ~ 5% para menos de 1%, podemos fazer melhor do que isso? Percebendo que a magnitude da oscilação diminui exponencialmente, um fator contribuinte pode ser a resistência do ar causada ao balançar o pêndulo. A seção transversal do pêndulo pode precisar ser modificada para ter um formato aerodinâmico, a fim de reduzir o arrasto aerodinâmico.

Podemos aplicar um ganho variável no tempo aprendido usando técnicas de filtro adaptativo para gerar um sinal de magnitude de pico constante. Nesse ínterim, correlacione a atenuação da magnitude às forças externas.

Dificilmente podemos encontrar algo mais simples do que o "movimento harmônico simples". Podemos usar as instalações que analisamos o pêndulo para analisar algo mais complicado, uma atividade esportiva, uma sequência de lançamento de foguete aquático, etc?

Feliz hackeando