Experimentos em registro de dados avançado (usando Python): 11 etapas

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

Existem muitos instructables de registro de dados, então, quando eu queria construir um projeto de registro próprio, olhei em volta para vários. Alguns eram bons, outros nem tanto, então decidi pegar algumas das melhores ideias e fazer meu próprio aplicativo. Isso resultou em um projeto mais avançado e mais complicado do que eu esperava a princípio. Uma parte disso se tornou uma série de experimentos no processamento de dados do sensor. Este instrutível permite que você experimente os mesmos experimentos ou experimentos semelhantes.

(Você pode visualizar todo o código e baixá-lo em: Código no GitHub Você pode começar a visualizar, talvez em outra janela, com apenas 2 cliques)

Normalmente, o registro de dados envolve o seguinte:

• Aquisição de dados: leia alguns dados de um sensor. Freqüentemente, isso é apenas ler um conversor analógico para digital (ADC) em um dispositivo como um Arduino.
• Processamento de dados: Ao ler um valor ADC, a saída do conversor normalmente precisa ser ajustada para as unidades corretas. Também pode ser necessário fazer alguns ajustes para calibrar os valores para corrigir os erros do sensor.
• Filtragem: os dados geralmente contêm algum ruído, isso pode ser filtrado para que você observe o sinal em seus dados, não o ruído.
• Armazenamento de dados: os dados são salvos, talvez em um arquivo de texto, talvez na nuvem. Os dados devem sobreviver mesmo se a energia for desligada. É fácil salvar muitos dados, temos um pequeno truque para reduzir o espaço de armazenamento de dados.
• Exibição de dados: métodos para observar seus dados, não realmente o registro de dados, mas se você não faz algum tipo de exibição dos dados, por que coletá-los?
• Acesso remoto: Não é necessário, mas é bom ter.

A maioria dos instructables inclui alguns, mas não todos os itens acima, ou os faz de uma maneira muito simples. Este instrutível abordará 2 dos problemas de registro frequentemente ignorados e, como bônus, fornecerá a você um meio de representar graficamente seus dados sem usar um serviço de nuvem. Você pode usar a coisa toda ou retirar pedaços e remixá-los em um projeto próprio.

Etapa 1: Ferramentas e materiais

Este exemplo está todo em Python, por isso será executado e os componentes podem ser usados em praticamente qualquer sistema operacional, incluindo Mac, PC, Linux e Raspberry Pi.

Portanto, para usar este instrutível, tudo o que você precisa é um ambiente Python 3.6 em execução e baixar o código em anexo. Depois de executar o código que configurei, você pode modificá-lo para seus próprios experimentos. Como é normal com Python, você pode precisar adicionar alguns pacotes / módulos para fazer tudo funcionar. Meu ambiente Spyder vem com praticamente todas as peças necessárias no lugar (consulte: Exibições instrutivas de gráfico com captura de tela Python). Quando você executa o relógio pela primeira vez em busca de mensagens de erro, eles o informam sobre as partes ausentes em seu ambiente.

As próximas duas etapas lhe dirão como construir e executar um experimento por conta própria, mas provavelmente é melhor esperar até executar os experimentos incluídos antes de tentar o seu próprio.

Para entender o código, você precisará ter um pouco de experiência com Python orientado a objetos, explicando que está além do escopo deste manual, mas o Google deve fornecer qualquer ajuda necessária.

Observe o código: (o código no GitHub pode ser visualizado, talvez em outra janela, com apenas 2 cliques) agora está no Python 3.6, portanto, ter o 3.6 seria o melhor. A versão mais antiga do código está aqui nos links abaixo.

Etapa 2: Construindo uma Experiência

Existem três etapas de programação (e linhas) na construção de um experimento. Cada experimento é uma função no objeto LoggingSim no arquivo simulate_logging.py. Vejamos o experimento 1 (apenas o primeiro gráfico), que executaremos na próxima etapa:

def experiment_with_sample_rates (self):

print "" "Experimente com taxas de amostragem Observando diferentes taxas de amostragem alterando delta T" "" self.start_plot (plot_title = "Taxas de amostragem - Parte 1/3: Delta T = 1.0") self.add_sensor_data (name = "dt = 1. ", amplitude = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Cada experimento é escrito como sua própria função, então temos uma linha definindo a função (def experimento…..)

A próxima linha, sem comentários, (start_plot (….) Cria o objeto para o experimento e dá a ele um nome.

A próxima linha, sem linha de comentário, (add_sensor_data (…) é dividida em várias linhas. Ela simula um sensor medindo um sinal com potencialmente ruído e algum processamento. Os argumentos da função são os seguintes:

• nome: um nome colocado no gráfico final para identificar os dados
• amplitude: quão grande é o sinal, sempre usaremos uma amplitude de 1. neste instrutível.
• noise_amp: quão grande é o ruído, 0. não há ruído, vamos começar aqui.
• delta_t: o tempo entre as medições, controla a taxa de amostragem.
• max_t: o tempo máximo que coletamos dados, sempre usaremos 10 neste instrutível.
• run_ave: processamento usando uma média de execução, 0 significa nenhum processamento.
• trigger_value: processamento usando acionamento, 0 significa nenhum processamento

a linha final, sem comentários, (self.show_plot ……) exibe o gráfico.

Para tornar as coisas um pouco mais complicadas, você pode ter várias linhas em um gráfico ou vários gráficos em um experimento, isso deve ficar claro nos experimentos a seguir.

Etapa 3: Executar um experimento

Este é o código para executar um experimento. Como em Python, ele é colocado no final do arquivo.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

Isso tem apenas 2 linhas:

• Crie um simulador de registro (LoggingSim ())
• Execute-o (sim_logging.experiment_with_sample_rates ())

No código baixado, tenho mais algumas linhas e comentários, deve ser fácil de descobrir.

Etapa 4: Experiência: Taxa de amostragem

O simulador, conforme configurado aqui, sempre produz uma bela onda senoidal suave de amplitude 1. Para este experimento, iremos mexer com a taxa de amostragem, ajustada por delta_t, a diferença de tempo entre as amostras. Não teremos nenhum ruído ou outro processamento. O código usa 3 taxas de amostragem (delta_t = 1,0, 0,1 e 0,01.) Como os gráficos ficam em cima uns dos outros, o experimento é configurado para produzir 3 gráficos diferentes. Os gráficos resultantes são as imagens para esta etapa.

def experiment_with_sample_rates (self):

print "" "Experimente taxas de amostragem Observando diferentes taxas de amostragem alterando delta T" "" self.start_plot (plot_title = "Experiment Sample Rates 1/3: Delta T = 1.0") self.add_sensor_data (name = "dt = 1. ", amplitude = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------- ----------------------------------- self.start_plot (plot_title = "Taxas de amostra da experiência 2/3: Delta T = 0.1 ") self.add_sensor_data (name =" dt = 1. ", amplitude = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------------------------------------------ auto.start_plot (plot_title = "Taxas de amostra do experimento 3/3: Delta T = 0,01") self.add_sensor_data (name = "dt = 1.", amplitude = 1., noise_amp =.0, delta_t = 0,01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Para executá-lo, use a linha: sim_logging.experiment_with_sample_rates ()

Possíveis conclusões:

• Uma taxa de amostragem muito baixa é muito ruim.
• Taxas altas geralmente são melhores.

(Código Python 3.6 no link GitHub abaixo em instructables, 2.7)

Etapa 5: experimento: mostrando ruído

Neste experimento, mantemos o mesmo sinal, usamos uma taxa de amostragem média e temos diferentes quantidades de ruído (noise_amp =.0,.1, 1.0.) Execute-o com: sim_logging.experiment_showing_noise (). A saída é um gráfico com 3 linhas.

Possível conclusão:

O ruído torna difícil ver o sinal, reduza-o se puder

O código:

# ------------------------------------------------

def experiment_showing_noise (self): print "" "Experimento mostrando ruído Olhando para diferentes quantidades de ruído alterando a amplitude do ruído." "" self.start_plot (plot_title = "Experimento mostrando ruído") self.add_sensor_data (name = "noise = 0,0 ", amplitude = 1., noise_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name =" noise = 0.1 ", amplitude = 1., noise_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name = "noise = 1.0", amplitude = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Etapa 6: Experimente: Reduza o ruído com uma média móvel

Uma média móvel (por exemplo, com comprimento 8) toma as últimas 8 medições e calcula a média delas. Se o ruído for aleatório, esperamos que a média seja próxima de 0. Execute o experimento com: sim_logging.experiment_showing_noise (). Produza um gráfico.

Possíveis conclusões:

• Uma média móvel elimina muito do ruído
• Quanto mais longa for a média móvel, maior será a redução de ruído
• A média móvel mais longa pode reduzir e distorcer o sinal

O código:

# ------------------------------------------------

def experiment_with_moving_average (self): print "" "Experiment with MovingA Average Observando diferentes MovingA Average alterando o comprimento. Todos têm o mesmo ruído." "" # ------------------ ------------------------------ self.start_plot (plot_title = "MovingAght-Part 1/2: No Moving Average") self.add_sensor_data (name = "ave len = 0", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () self.start_plot (plot_title = "MovingA Average-Part 2/2: Len 8 e 32") self.add_sensor_data (name = "ave len = 8", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 8, trigger_value = 0) self.add_sensor_data (name = "ave len = 32", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

Etapa 7: Experiência: Média móvel e taxa de amostragem

Neste experimento, comparamos o sinal bruto com ruído e 2 variações diferentes na redução do ruído.

1. Taxa de amostragem média e média de execução média
2. Alta taxa de amostragem e alta média de execução de comprimento

Execute-o com: sim_logging …… A saída é um gráfico. Acho que está claro que o nº 2 faz um trabalho melhor na redução do ruído, então podemos concluir que:

Alta taxa de amostragem e média de execução de longa duração são boas

Mas você deve ter em mente que existe um custo. # 2 exige muito mais processamento e resulta em muito mais dados a serem salvos. O custo pode ou não valer a pena. No próximo experimento, adicionaremos um gatilho, um dispositivo para reduzir a quantidade de dados armazenados.

O código:

def experiment_with_moving_average_and_sample_rate (self):

print "" "Experiência com média móvel e taxa de amostragem, dt, média de execução variada" "" # ---------------------------- -------------------- self.start_plot (plot_title = "Média móvel e taxa de amostragem") self.add_sensor_data (name = "dt =.1 ra = 0 trig = 0 ", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name =" dt =.1 ra = 10 trig = 0 ", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (name = "dt =.01 ra = 100 trig = 0", amplitude = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot ()

Etapa 8: experimento: registro com gatilho

Neste experimento, adicionamos um gatilho. Primeiro, o que quero dizer com gatilho? Um gatilho é uma técnica em que coletamos dados, mas apenas os salvamos depois que alguma variável foi alterada em uma quantidade significativa. Nessas experiências, coloquei um gatilho na variável de tempo (eixo x). Usando o gatilho, posso pegar a grande quantidade de dados da amostragem rápida e reduzi-la a uma quantidade de dados mais razoável. É particularmente útil com altas taxas de amostragem e uma média de longa duração.

Eu peguei a linha # 2 do último experimento que era "bom" e adicionei um gatilho. Execute-o com: sim_logging …… A saída é um gráfico, x linhas.

O que acontece? Obtemos um gráfico "bom" com uma quantidade razoável de dados (igual ao número 1). Houve algum custo no processamento mais alto. No geral, entretanto, os resultados são quase os mesmos que # 1 - a taxa de amostragem mais baixa com menos filtragem. Você pode concluir:

• A média de execução longa com acionamento pode fornecer boa redução de ruído com quantidades razoáveis de dados.
• O processamento extra pode não dar resultados muito melhores e tem um custo.

O código:

# ------------------------------------------------

def experiment_with_trigger (self): print "" "Experimente com acionamento, dt, média de execução e acionamento sendo todos variados" "" # ----------------------- ------------------------- self.start_plot (plot_title = "Trigger 1/1 - Triggering On") self.add_sensor_data (name = "dt =.1 ra = 10, trig = 0 ", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (name =" dt =.01 ra = 100, trig =.1 ", amplitude = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

=

Etapa 9: experimento: registro com gatilho - ruído mais alto

Vamos fazer o mesmo experimento da última etapa e aumentar o ruído. Execute-o com: sim_logging …… A saída é um gráfico de 2 linhas.

Agora, o processamento extra parece valer mais a pena. Uma conclusão razoável aqui pode ser:

Escolher a quantidade e o tipo de processamento para redução de ruído depende do seu sinal e ruído

O código:

def experiment_with_trigger_louder_noise (self):

print "" "Ruído mais alto que o experimento anterior" "" self.start_plot (plot_title = "Um Experimento com Ruído Gatilho-Mais Alto") self.add_sensor_data (name = "… dt =.1 ra = 10", amplitude = 1., noise_amp =.5, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (name = "..dt =.01 ra = 100 tv =.1", amplitude = 1., noise_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

Etapa 10: faça suas próprias experiências

Neste ponto, espero que você veja que as técnicas neste instrutível podem ser úteis no registro de dados, mas que também devem ser usadas com alguma reflexão. Experimentar com eles pode ajudar nesse processo.

Algumas observações sobre os experimentos e coisas que você pode examinar:

• As ondas senoidais não são o único tipo de sinal interessante, tente outros, outras ondas ou rampas ou…..
• Usei uma distribuição normal para o ruído, existem tantos tipos de ruído; você deve considerar os outros
• As médias corridas são um método simples, mas não o único para observar o ruído

Nota: registrar imagens da Wikipedia.

Etapa 11: usando as técnicas em seu software de registro

Meu código é orientado a objetos e o processamento para executar a média e o gatilho pode apenas ser copiado em seu ambiente Python e então usado. Os objetos são:

• DataTrigger em data_trigger.py
• MovingA Average em moving_average.py

Meu objeto principal, LoggingSim, em simulate_logging.py, deve dar um bom exemplo de como usá-lo. Se você usar outro idioma, poderá ler meu código e implementar em seu idioma.

Este código pode fornecer ao seu projeto um melhor registro de dados, experimente.

O gráfico acima é do Graph Your Solar Power de russ_hensel, que usa o mesmo objeto de média em execução.