Experiments de registre avançat de dades (amb Python): 11 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:11

Hi ha un munt d’instructibles per al registre de dades, de manera que quan vaig voler crear un projecte propi de registre vaig mirar un munt al voltant. Alguns eren bons, d’altres no tant, així que vaig decidir agafar algunes de les millors idees i fer la meva pròpia sol·licitud. Això va donar lloc a un projecte més avançat i complicat del que havia esperat al principi. Una part es va convertir en una sèrie d’experiments en el processament de dades de sensors. Aquesta instrucció us permet provar els mateixos experiments o similars.

(Podeu veure tot el codi i descarregar-lo a: Code a GitHub Podeu veure-ho, potser en una altra finestra, amb només 2 clics)

Normalment, el registre de dades implica el següent:

• Adquisició de dades: llegiu algunes dades d’un sensor. Sovint es tracta només de llegir un convertidor analògic a digital (ADC) en un dispositiu com un Arduino.
• Processament de dades: en llegir un valor ADC, la sortida dels convertidors normalment s’ha d’escalar a les unitats adequades. També pot ser necessari fer algun ajust per calibrar els valors per corregir els errors del sensor.
• Filtrat: les dades solen contenir soroll, es pot filtrar de manera que busqueu el senyal de les vostres dades, no el soroll.
• Emmagatzematge de dades: les dades es guarden, potser en un fitxer de text, potser al núvol. Les dades haurien de sobreviure fins i tot si s’apaga l’alimentació. És fàcil estalviar massa dades, tenim un petit truc per reduir l’espai d’emmagatzematge de dades.
• Visualització de dades: mètodes per mirar les vostres dades, no realment el registre de dades, però si no feu cap tipus de visualització de les dades, per què recopilar-les?
• Accés remot: no és necessari, però és bo tenir-lo.

La majoria d’instructibles inclouen algunes de les anteriors, però no totes, o les fan d’una manera molt senzilla. Aquesta informació útil abordarà 2 dels problemes de registre sovint omesos i, com a bonificació, us proporcionarà un mitjà per representar gràficament les vostres dades sense utilitzar un servei al núvol. Podeu fer servir el conjunt o treure trossos i remesclar-los en un projecte propi.

Pas 1: eines i materials

Aquest exemple es troba a Python, de manera que s'executarà i es poden utilitzar components, pràcticament qualsevol sistema operatiu, inclosos Mac, PC, Linux i el Raspberry Pi.

Per fer servir aquesta informació instructiva, tot el que necessiteu és un entorn Python 3.6 en execució i descarregueu el codi adjunt. Després d'executar el codi que he configurat, el podeu modificar per als vostres propis experiments. Com és habitual amb Python, és possible que hàgiu d'afegir alguns paquets / mòduls perquè tot funcioni. El meu entorn Spyder inclou pràcticament totes les parts necessàries al seu lloc (vegeu: Gràfic de vistes instructibles amb rascat de pantalla Python). Quan executeu per primera vegada els missatges d’error, us informaran de les parts que falten al vostre entorn.

Els dos passos següents us indicaran com crear i executar un experiment propi, però probablement és millor esperar a executar els experiments inclosos abans de provar el vostre.

Per entendre el codi, haureu de tenir una mica d’experiència amb Python orientat a objectes, explicant que està fora de l’abast d’aquesta instrucció, però Google us hauria d’ajudar amb la vostra ajuda.

Tingueu en compte que el codi: (Codi a GitHub Podeu veure-ho, potser en una altra finestra, amb només 2 clics) ara es troba a Python 3.6, de manera que és millor tenir-ne 3.6. La versió anterior del codi es troba aquí als enllaços següents.

Pas 2: crear un experiment

Hi ha tres passos (i línies) de programació per construir un experiment. Cada experiment és una funció de l'objecte LoggingSim del fitxer simulate_logging.py. Vegem l'experiment 1 (només el primer gràfic) que executarem al següent pas:

def experiment_with_sample_rates (auto):

imprimeix "" "Experimenta amb taxes de mostreig Mirant diferents taxes de mostra canviant delta T" "" self.start_plot (plot_title = "Taxes de mostra - Part 1/3: Delta T = 1.0") self.add_sensor_data (name = "dt = 1. ", amplitud = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Cada experiment s’escriu com a funció pròpia, de manera que tenim una línia que defineix la funció (experiment definitiu …)

La següent línia, sense comentaris, (start_plot (….) crea l'objecte de l'experiment i li dóna un nom.

La següent línia de línia sense comentaris, (add_sensor_data (…) es divideix en diverses línies. Simula un sensor que mesura un senyal amb potencialment soroll i un cert processament. Els arguments de la funció són els següents:

• nom: un nom posat al gràfic final per identificar les dades
• amplitud: quant de gran és el senyal, sempre farem servir una amplitud d'1.
• noise_amp: quant de gran és el soroll, 0. no hi ha soroll, començarem aquí.
• delta_t: el temps entre mesures, controla la freqüència de mostreig.
• max_t: el temps màxim que recopilem dades, sempre en farem servir 10.
• run_ave: processament mitjançant una mitjana corrent, 0 significa no processament.
• trigger_value: processament mitjançant triggering, 0 significa que no hi ha processament

la línia final, sense comentaris, (self.show_plot ……) mostra el gràfic.

Per fer les coses una mica més complicades, podeu tenir diverses línies en un gràfic o diversos gràfics en un experiment; això hauria de quedar clar a partir dels experiments següents.

Pas 3: executar un experiment

Aquest és el codi per executar un experiment. Com passa a Python, es col·loca al final del fitxer.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

Aquestes són només dues línies:

• Creeu un simulador de registre (LoggingSim ())
• Executeu-lo (sim_logging.experiment_with_sample_rates ())

Al codi descarregat tinc algunes línies i comentaris més, hauria de ser fàcil d’entendre.

Pas 4: experiment: freqüència de mostra

El simulador, tal com s’estableix aquí, sempre genera una bona ona sinusoïdal suau d’amplitud 1. Per a aquest experiment, ens equivocarem amb la freqüència de mostreig, ajustada per delta_t, la diferència de temps entre mostres. No tindrem soroll ni cap altre processament. El codi utilitza 3 freqüències de mostreig (delta_t = 1,0, 0,1 i 0,01). Com que els gràfics es topen els uns sobre els altres, l'experiment es configura per produir 3 gràfics diferents. Els gràfics resultants són les imatges d’aquest pas.

def experiment_with_sample_rates (auto):

imprimeix "" "Experimenta amb taxes de mostreig Mirant diferents taxes de mostra canviant delta T" "" self.start_plot (plot_title = "Taxes de mostra de l'experiment 1/3: Delta T = 1.0") self.add_sensor_data (name = "dt = 1. ", amplitud = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------- ----------------------------------- self.start_plot (plot_title = "Taxes de mostra de l'experiment 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 () # ------------------------------------------------ jo.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 ()

Per executar-lo utilitzeu la línia: sim_logging.experiment_with_sample_rates ()

Possibles conclusions:

• Una taxa de mostreig massa baixa és realment dolenta.
• Les taxes altes sovint són millors.

(Codi Python 3.6 a l'enllaç de GitHub a continuació a instructables, 2.7)

Pas 5: experiment: mostrar soroll

En aquest experiment, mantenim el mateix senyal, fem servir una freqüència de mostreig mitjana i tenim diferents quantitats de soroll (noise_amp =.0,.1, 1.0.) Executeu-lo amb: sim_logging.experiment_showing_noise (). La sortida és un gràfic amb 3 línies.

Possible conclusió:

El soroll fa que sigui difícil veure el senyal, reduïu-lo si podeu

El codi:

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

def experiment_showing_noise (self): print "" "Experiment que mostra soroll Mirant diferents quantitats de soroll canviant l'amplitud del soroll." "" self.start_plot (plot_title = "Experiment que mostra soroll") self.add_sensor_data (name = "noise = 0.0 ", amplitud = 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 (nom = "noise = 1.0", amplitud = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Pas 6: experiment: reduïu el soroll amb una mitjana mòbil

Una mitjana mòbil (per exemple, amb una longitud de 8) pren els últims vuit mesuraments i els fa una mitjana. Si el soroll és aleatori, esperem que arribi a la mitjana de prop de 0. Executeu l'experiment amb: sim_logging.experiment_showing_noise (). Sortiu un gràfic.

Possibles conclusions:

• Una mitjana mòbil elimina gran part del soroll
• Com més llarga sigui la mitjana mòbil, més reducció de soroll
• La mitjana mòbil més llarga pot reduir i distorsionar el senyal

El codi:

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

def experiment_with_moving_average (self): print "" "Experimenta amb MovingAverage Mirant diferents MovingAverage canviant la longitud. Tots tenen el mateix soroll." "# ------------------ ------------------------------ self.start_plot (plot_title = "MovingAverage-Part 1/2: No hi ha mitjana mòbil") 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 and 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 ()

Pas 7: Experiment: mitjana mòbil i freqüència de mostra

En aquest experiment, comparem el senyal cru amb el soroll i dues variacions diferents en la reducció del soroll.

1. Taxa de mostra mitjana i mitjana de funcionament mitja
2. Alta freqüència de mostreig i mitjana de cursa elevada

Executeu-lo amb: sim_logging …… La sortida és un gràfic. Crec que és clar que el número 2 fa un millor treball en la reducció del soroll, de manera que podríem concloure que:

L’alta taxa de mostreig i la mitjana de funcionament de gran longitud són bones

Però cal tenir en compte que hi ha un cost. El número 2 requereix molt més processament i fa que es desin moltes més dades. El cost pot valer la pena o no. Al proper experiment afegirem un activador, un dispositiu per reduir la quantitat de dades emmagatzemades.

El codi:

def experiment_with_moving_average_and_sample_rate (auto):

imprimeix "" Experimenta amb la mitjana mòbil i la freqüència de mostreig, dt, la mitjana d'execució varia "#" # ---------------------------- -------------------- self.start_plot (plot_title = "Mitjana mòbil i freqüència de mostra") 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 (name =" dt =.1 ra = 10 trig = 0 ", amplitud = 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 ()

Pas 8: experiment: registre amb activador

En aquest experiment afegim un activador. En primer lloc, què vull dir amb un disparador? Un activador és una tècnica en què recopilem dades, però només les desem després que alguna variable hagi canviat en una quantitat significativa. En aquests experiments he posat un disparador a la variable temps (eix x). En utilitzar el disparador, puc agafar la gran quantitat de dades d'un mostreig ràpid i reduir-la a una quantitat de dades més raonable. És particularment útil amb taxes de mostreig elevades i una mitjana de funcionament llarga.

He pres la línia número 2 de l'últim experiment que va ser "bo" i va afegir un activador. Executeu-lo amb: sim_logging ……. La sortida és un gràfic, x línies.

Què passa? Tenim una trama "bona" amb una quantitat raonable de dades (el mateix que el número 1). Hi ha hagut alguns costos en un processament superior. En general, però, els resultats són aproximadament els mateixos que el número 1, la taxa de mostreig més baixa i amb menys filtrat. Podríeu concloure:

• La mitjana de llarga durada amb activació pot proporcionar una bona reducció del soroll amb una quantitat raonable de dades.
• És possible que el processament addicional no doni tant millors resultats i comporti un cost.

El codi:

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

def experiment_with_trigger (self): print "" "Experimenta amb Triggering, dt, executa la mitjana i activa tots els canvis" "" # ----------------------- ------------------------- self.start_plot (plot_title = "Trigger 1/1 - Triggering On") self.add_sensor_data (name = "dt =.1 ra = 10, trig = 0 ", amplitud = 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 ", amplitud = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

=

Pas 9: experiment: registre amb activador: més soroll

Fem el mateix experiment que l'últim pas i augmentem el soroll. Executeu-lo amb: sim_logging …… La sortida és un gràfic, 2 línies.

Ara el processament addicional sembla més útil. Una conclusió raonable aquí podria ser:

Seleccionar la quantitat i el tipus de processament per reduir el soroll depèn del vostre senyal i del soroll

El codi:

def experiment_with_trigger_louder_noise (self):

imprimeix "" "Un soroll més fort que l'experiment anterior" "" self.start_plot (plot_title = "Un experiment amb un soroll més intens") 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 ()

Pas 10: feu els vostres propis experiments

En aquest punt espero que vegeu que les tècniques d’aquest instructiu poden ser útils per al registre de dades, però que també s’han d’utilitzar amb una mica de reflexió. Experimentar amb ells pot ajudar a aquest procés.

Alguns comentaris sobre els experiments i coses que podríeu examinar:

• Les ones sinuses no són l'únic tipus de senyal interessant, proveu d'altres, altres ones o rampes o …..
• He utilitzat una distribució normal per al soroll, hi ha tants tipus de soroll; hauríeu de tenir en compte els altres
• Les mitjanes corrents són un mètode senzill, però no l’únic per mirar el soroll

Nota: registre d'imatges de la Viquipèdia.

Pas 11: utilitzar les tècniques del programari de registre

El meu codi està orientat a objectes i el processament per a l'execució mitjana i activadora només es pot copiar al vostre entorn Python i després utilitzar-lo. Els objectes són:

• DataTrigger a data_trigger.py
• MovingAverage a moving_average.py

El meu objecte principal LoggingSim a simulate_logging.py us ha de donar un bon exemple de com utilitzar-lo. Si utilitzeu un altre idioma, podeu llegir el meu codi i implementar-lo en el vostre idioma.

Aquest codi pot proporcionar al vostre projecte un millor registre de dades, proveu-ho.

El gràfic anterior prové de Graph Your Solar Power de russ_hensel, que utilitza el mateix objecte mitjà en execució.