Experimentos en el registro de datos avanzado (usando Python): 11 pasos

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

Hay muchos instructivos de registro de datos, así que cuando quise construir un proyecto de registro propio miré a mi alrededor en un montón. Algunas eran buenas, otras no tanto, así que decidí tomar algunas de las mejores ideas y hacer mi propia aplicación. Esto resultó en un proyecto más avanzado y complicado de lo que esperaba al principio. Una parte se convirtió en una serie de experimentos para procesar datos de sensores. Este instructivo le permite probar los mismos experimentos o experimentos similares.

(Puede ver todo el código y descargarlo en: Code at GitHub Puede acceder a la visualización, tal vez en otra ventana, con solo 2 clics)

Normalmente, el registro de datos implica lo siguiente:

• Adquisición de datos: lee algunos datos de un sensor. A menudo, esto es solo leer un convertidor de analógico a digital (ADC) en un dispositivo como un Arduino.
• Procesamiento de datos: cuando se lee un valor de ADC, la salida del convertidor normalmente necesita escalarse a las unidades correctas. También puede ser necesario realizar algunos ajustes para calibrar los valores y corregir los errores del sensor.
• Filtrado: los datos comúnmente contienen algo de ruido, esto se puede filtrar para que esté buscando la señal en sus datos, no el ruido.
• Almacenamiento de datos: los datos se guardan, quizás en un archivo de texto, quizás en la nube. Los datos deberían sobrevivir incluso si se corta la energía. Es fácil guardar demasiados datos, tenemos un pequeño truco para reducir el espacio de almacenamiento de datos.
• Visualización de datos: métodos para ver sus datos, no realmente el registro de datos, pero si no realiza algún tipo de visualización de los datos, ¿por qué recopilarlos?
• Acceso remoto: no es necesario, pero es bueno tenerlo.

La mayoría de los instructivos incluyen algunos de los anteriores, pero no todos, o hazlos de una manera muy simple. Este instructivo abordará 2 de los problemas de registro que a menudo se omiten y, como beneficio adicional, le brindará un medio para graficar sus datos sin usar un servicio en la nube. Puede usarlo todo o extraer fragmentos y mezclarlos en un proyecto propio.

Paso 1: herramientas y materiales

Este ejemplo está todo en Python, por lo que se ejecutará y los componentes se pueden usar en prácticamente cualquier sistema operativo, incluidos Mac, PC, Linux y Raspberry Pi.

Entonces, para usar este instructivo, todo lo que necesita es un entorno Python 3.6 en ejecución y descargar el código adjunto. Después de ejecutar el código que he configurado, puede modificarlo para sus propios experimentos. Como es habitual con Python, es posible que deba agregar algunos paquetes / módulos para que todo funcione. Mi entorno de Spyder viene con casi todas las partes requeridas en su lugar (ver: Vistas gráficas instruccionables con Python Screen Scraping). Cuando ejecute por primera vez, observe los mensajes de error, le informarán sobre las piezas faltantes en su entorno.

Los dos pasos siguientes le indicarán cómo crear y ejecutar un experimento propio, pero probablemente sea mejor esperar hasta ejecutar los experimentos incluidos antes de probar el suyo.

Para comprender el código, deberá tener un poco de experiencia con Python orientado a objetos, explicando que está más allá del alcance de este instructivo, pero Google debería brindarle la ayuda que pueda necesitar.

Tenga en cuenta el código: (Código en GitHub que puede ver, tal vez en otra ventana, con solo 2 clics) ahora está en Python 3.6, por lo que tener 3.6 sería lo mejor. La versión anterior del código está aquí en los enlaces a continuación.

Paso 2: creación de un experimento

Hay tres pasos de programación (y líneas) en la construcción de un experimento. Cada experimento es una función en el objeto LoggingSim en el archivo simulate_logging.py. Veamos el experimento 1 (solo el primer gráfico) que ejecutaremos en el siguiente paso:

def experiment_with_sample_rates (self):

print "" "Experimente con frecuencias de muestreo Observando diferentes frecuencias de muestreo cambiando delta T" "" self.start_plot (plot_title = "Frecuencias de muestreo - Parte 1/3: Delta T = 1.0") self.add_sensor_data (name = "dt = 1. ", amplitud = 1., ruido_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Cada experimento está escrito como su propia función, por lo que tenemos una línea que define la función (def experimento…..)

La siguiente línea sin comentarios, (start_plot (….) Crea el objeto para el experimento y le da un nombre.

La siguiente línea, sin comentarios, (add_sensor_data (…) se divide en varias líneas. Simula un sensor que mide una señal con ruido potencial y algo de procesamiento. Los argumentos de la función son los siguientes:

• nombre: un nombre que se pone en el gráfico final para identificar los datos
• amplitud: qué tan grande es la señal, siempre usaremos una amplitud de 1. en este instructable.
• noise_amp: qué tan grande es el ruido, 0. no hay ruido, comenzaremos aquí.
• delta_t: el tiempo entre mediciones, controla la frecuencia de muestreo.
• max_t: el tiempo máximo que recopilamos datos, siempre usaremos 10 en este instructable.
• run_ave: procesamiento usando un promedio móvil, 0 significa sin procesamiento.
• trigger_value: procesamiento mediante activación, 0 significa que no hay procesamiento

la línea final, sin comentarios, (self.show_plot ……) muestra el gráfico.

Para hacer las cosas un poco más complicadas, puede tener varias líneas en un gráfico o varios gráficos en un experimento, esto debería quedar claro en los experimentos que siguen.

Paso 3: ejecutar un experimento

Este es el código para ejecutar un experimento. Como es común en Python, se coloca al final del archivo.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

Esto es solo 2 líneas:

• Cree un simulador de registro (LoggingSim ())
• Ejecútelo (sim_logging.experiment_with_sample_rates ())

En el código descargado tengo algunas líneas y comentarios más, debería ser fácil de entender.

Paso 4: Experimento: frecuencia de muestreo

El simulador, como se configura aquí, siempre genera una agradable onda sinusoidal suave de amplitud 1. Para este experimento, nos meteremos con la frecuencia de muestreo, ajustada por delta_t, la diferencia de tiempo entre muestras. No tendremos ruido ni ningún otro procesamiento. El código usa 3 frecuencias de muestreo (delta_t = 1.0, 0.1 y 0.01.) Dado que los gráficos se superponen, el experimento está configurado para producir 3 gráficos diferentes. Los gráficos resultantes son las imágenes de este paso.

def experiment_with_sample_rates (self):

print "" "Experimente con frecuencias de muestreo Observando diferentes frecuencias de muestreo cambiando delta T" "" self.start_plot (plot_title = "Experiment Sample Rates 1/3: Delta T = 1.0") self.add_sensor_data (name = "dt = 1. ", amplitud = 1., ruido_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------- ----------------------------------- self.start_plot (plot_title = "Tasas de muestreo del experimento 2/3: Delta T = 0.1 ") self.add_sensor_data (name =" dt = 1. ", amplitud = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------------------------------------------ uno mismo.start_plot (plot_title = "Experiment Sample Rates 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 ejecutarlo use la línea: sim_logging.experiment_with_sample_rates ()

Posibles conclusiones:

• Una frecuencia de muestreo demasiado baja es realmente mala.
• Las tasas altas suelen ser mejores.

(Código de Python 3.6 en el enlace de GitHub a continuación en instructables, 2.7)

Paso 5: Experimento: mostrar ruido

En este experimento mantenemos la misma señal, usamos una frecuencia de muestreo media y tenemos diferentes cantidades de ruido (noise_amp =.0,.1, 1.0). Ejecútelo con: sim_logging.experiment_showing_noise (). El resultado es un gráfico con 3 líneas.

Posible conclusión:

El ruido dificulta ver la señal, reduzca si puede

El código:

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

def experiment_showing_noise (self): print "" "Experimento que muestra ruido Mirando diferentes cantidades de ruido cambiando la amplitud del ruido." "" self.start_plot (plot_title = "Experimento que muestra ruido") self.add_sensor_data (name = "noise = 0.0 ", amplitud = 1., ruido_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (nombre =" ruido = 0.1 ", amplitud = 1., ruido_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 ()

Paso 6: Experimente: Reduzca el ruido con una media móvil

Un promedio móvil (por ejemplo, con longitud 8) toma las últimas 8 mediciones y las promedia. Si el ruido es aleatorio, esperamos que tenga un promedio cercano a 0. Ejecute el experimento con: sim_logging.experiment_showing_noise (). Genere un gráfico.

Posibles conclusiones:

• Una media móvil elimina gran parte del ruido.
• Cuanto más larga sea la media móvil, mayor será la reducción de ruido.
• La media móvil más larga puede reducir y distorsionar la señal.

El código:

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

def experiment_with_moving_average (self): print "" "Experimente con MovingAverage Observando diferentes MovingAverage cambiando la longitud. Todos tienen el mismo ruido." "" # ------------------ ------------------------------ self.start_plot (plot_title = "MovingAverage-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 = "MovingAverage-Part 2/2: Len 8 y 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 ()

Paso 7: Experimento: media móvil y frecuencia de muestreo

En este experimento comparamos la señal sin procesar con ruido y 2 variaciones diferentes para reducir el ruido.

1. Frecuencia de muestreo media y media móvil media
2. Frecuencia de muestreo alta y promedio de ejecución de larga duración

Ejecútelo con: sim_logging …… La salida es un gráfico. Creo que está claro que el n. ° 2 hace un mejor trabajo para reducir el ruido, por lo que podríamos concluir que:

Una frecuencia de muestreo alta y un promedio de ejecución de larga duración son buenos

Pero hay que tener en cuenta que tiene un coste. El número 2 requiere mucho más procesamiento y da como resultado que se guarden muchos más datos. El costo puede valer la pena o no. En el próximo experimento agregaremos un disparador, un dispositivo para reducir la cantidad de datos almacenados.

El código:

def experiment_with_moving_average_and_sample_rate (auto):

print "" "Experimente con la media móvil y la frecuencia de muestreo, dt, variando la media de ejecución" "" # ---------------------------- -------------------- self.start_plot (plot_title = "Promedio móvil y frecuencia de muestreo") self.add_sensor_data (name = "dt =.1 ra = 0 trig = 0 ", amplitud = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (nombre =" 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., ruido_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot ()

Paso 8: Experimento: registro con Trigger

En este experimento agregamos un disparador. Primero, ¿qué quiero decir con un disparador? Un disparador es una técnica en la que recopilamos datos pero solo los guardamos después de que alguna variable haya cambiado en una cantidad significativa. En estos experimentos puse un disparador en la variable de tiempo (eje x). Al usar el disparador, puedo tomar la gran cantidad de datos del muestreo rápido y reducirla a una cantidad de datos más razonable. Es especialmente útil con frecuencias de muestreo altas y un promedio de larga duración.

He tomado la línea # 2 del último experimento que fue "bueno" y agregó un disparador. Ejecútelo con: sim_logging …… La salida es un gráfico, x líneas.

¿Lo que sucede? Obtenemos un gráfico "bueno" con una cantidad razonable de datos (lo mismo que el # 1). Ha habido algún costo en un procesamiento superior. Sin embargo, en general, los resultados son aproximadamente los mismos que en el n. ° 1, la frecuencia de muestreo más baja con menos filtrado. Podrías concluir:

• El promedio de larga duración con activación puede proporcionar una buena reducción de ruido con cantidades razonables de datos.
• El procesamiento adicional puede no dar mejores resultados y tiene un costo.

El código:

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

def experiment_with_trigger (self): print "" "Experimente con Triggering, dt, run average y trigger todos variando" "" # ----------------------- ------------------------- 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 (nombre =" dt =.01 ra = 100, trig =.1 ", amplitud = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

=

Paso 9: Experimento: Registro con Trigger - Ruido más fuerte

Tomemos el mismo experimento que el último paso y amplifiquemos el ruido. Ejecútelo con: sim_logging …… La salida es un gráfico, 2 líneas.

Ahora el procesamiento adicional parece más valioso. Una conclusión razonable aquí podría ser:

La elección de la cantidad y el tipo de procesamiento para la reducción de ruido depende de su señal y ruido

El código:

def experiment_with_trigger_louder_noise (self):

print "" "Ruido más fuerte que el experimento anterior" "" self.start_plot (plot_title = "Un experimento con ruido más fuerte que dispara") 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., ruido_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

Paso 10: haz tus propios experimentos

En este punto, espero que vea que las técnicas en este instructivo pueden ser útiles en el registro de datos, pero que también deben usarse con un poco de reflexión. Experimentar con ellos puede ayudar en ese proceso.

Algunas observaciones sobre los experimentos y cosas que podría considerar:

• Las ondas sinusoidales no son el único tipo de señal interesante, prueba con otras, otras ondas o rampas o…..
• Usé una distribución normal para el ruido, hay muchos tipos de ruido; deberías considerar a los demás
• Los promedios corrientes son un método simple, pero no el único, para observar el ruido.

Nota: registro de imágenes de Wikipedia.

Paso 11: uso de las técnicas de su software de registro

Mi código está orientado a objetos y el procesamiento para el promedio de ejecución y el disparador se puede copiar en su entorno de Python y luego usar. Los objetos son:

• DataTrigger en data_trigger.py
• MovingAverage en moving_average.py

Mi objeto principal LoggingSim en simulate_logging.py debería darte un buen ejemplo de cómo usarlo. Si usa otro idioma, puede leer mi código e implementarlo en su idioma.

Este código puede darle a su proyecto un mejor registro de datos, pruébelo.

El gráfico anterior es de Graph Your Solar Power de russ_hensel, que utiliza el mismo objeto de promedio móvil.