Esperimenti di registrazione avanzata dei dati (usando Python): 11 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

Ci sono molte istruzioni per la registrazione dei dati, quindi quando volevo creare un mio progetto di registrazione mi sono guardato intorno. Alcuni erano buoni, altri non così tanto, quindi ho deciso di prendere alcune delle idee migliori e fare la mia domanda. Ciò ha portato a un progetto più avanzato e più complicato di quanto mi aspettassi all'inizio. Una parte è diventata una serie di esperimenti nell'elaborazione dei dati dei sensori. Questa istruzione ti consente di provare gli stessi esperimenti o esperimenti simili.

(Puoi visualizzare tutto il codice e scaricarlo su: Code at GitHub Puoi entrare in visualizzazione, magari in un'altra finestra, con soli 2 click)

In genere la registrazione dei dati comporta quanto segue:

• Acquisizione dati: leggere alcuni dati da un sensore. Spesso si tratta solo di leggere un convertitore da analogico a digitale (ADC) su un dispositivo come un Arduino.
• Elaborazione dei dati: quando si legge un valore ADC, l'uscita del convertitore normalmente deve essere ridimensionata alle unità corrette. Potrebbe anche essere necessario eseguire alcune regolazioni per calibrare i valori per correggere gli errori del sensore.
• Filtraggio: i dati contengono comunemente del rumore, questo può essere filtrato in modo da cercare il segnale nei dati, non il rumore.
• Archiviazione dei dati: i dati vengono salvati, forse in un file di testo, forse nel cloud. I dati dovrebbero sopravvivere anche in caso di interruzione dell'alimentazione. È facile salvare troppi dati, abbiamo un piccolo trucco per ridurre lo spazio di archiviazione dei dati.
• Visualizzazione dei dati: metodi per guardare i tuoi dati, non proprio la registrazione dei dati, ma se non fai una sorta di visualizzazione dei dati perché raccoglierli?
• Accesso remoto: non necessario ma piacevole da avere.

La maggior parte degli istruttori include alcuni ma non tutti i precedenti, o li fa in un modo molto semplice. Questa istruzione affronterà 2 dei problemi di registrazione spesso ignorati e come bonus ti darà un mezzo per rappresentare graficamente i tuoi dati senza utilizzare un servizio cloud. Puoi usare l'intera cosa o estrarre pezzi e frammenti e remixarli in un progetto tutto tuo.

Passaggio 1: strumenti e materiali

Questo esempio è tutto in Python, quindi verrà eseguito e i componenti possono essere utilizzati su praticamente qualsiasi sistema operativo, inclusi Mac, PC, Linux e Raspberry Pi.

Quindi, per utilizzare questa istruzione tutto ciò che serve è un ambiente Python 3.6 in esecuzione e scaricare il codice allegato. Dopo aver eseguito il codice che ho impostato, puoi modificarlo per i tuoi esperimenti. Come al solito con Python potrebbe essere necessario aggiungere alcuni pacchetti/moduli per far funzionare tutto. Il mio ambiente Spyder viene fornito con praticamente tutte le parti necessarie sul posto (vedi: Graph Instructable Views with Python Screen Scraping). Quando esegui per la prima volta watch per eventuali messaggi di errore, ti informeranno di eventuali parti mancanti nel tuo ambiente.

I prossimi due passaggi ti diranno come creare ed eseguire un esperimento personale, ma probabilmente è meglio aspettare di eseguire gli esperimenti inclusi prima di provare il tuo.

Per comprendere il codice dovrai avere un po' di esperienza con Python orientato agli oggetti, spiegando che va oltre lo scopo di questo tutorial, ma Google dovrebbe darti tutto l'aiuto di cui potresti aver bisogno.

Nota il codice: (Codice su GitHub Puoi entrare nella visualizzazione, forse in un'altra finestra, con solo 2 clic) è ora in Python 3.6, quindi avere 3.6 sarebbe meglio. La versione precedente del codice è qui nei link sottostanti.

Passaggio 2: costruire un esperimento

Ci sono tre passaggi di programmazione (e linee) nella costruzione di un esperimento. Ogni esperimento è una funzione nell'oggetto LoggingSim nel file simula_logging.py. Diamo un'occhiata all'esperimento 1 (solo il primo grafico) che eseguiremo nel passaggio successivo:

def experiment_with_sample_rates(self):

print """ Esperimento con frequenze di campionamento Esaminando frequenze di campionamento diverse modificando delta T """ self.start_plot(plot_title = "Frequenze di campionamento - Parte 1/3: Delta T = 1.0") self.add_sensor_data(name = "dt = 1.", ampiezza = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot()

Ogni esperimento è scritto come una propria funzione, quindi abbiamo una linea che definisce la funzione (def esperimento…..)

La riga successiva, senza commenti, (start_plot(….) crea l'oggetto per l'esperimento e gli dà un nome.

La riga successiva, senza commenti, (add_sensor_data(…) è suddivisa in più righe. Simula un sensore che misura un segnale con potenziale rumore e qualche elaborazione. Gli argomenti della funzione sono i seguenti:

• nome: un nome messo sul grafico finale per identificare i dati
• ampiezza: quanto è grande il segnale, useremo sempre un'ampiezza di 1. in questo istruibile.
• noise_amp: quanto è grande il rumore, 0. non è rumore, inizieremo da qui.
• delta_t: il tempo tra le misurazioni, controlla la frequenza di campionamento.
• max_t: il tempo massimo in cui raccogliamo i dati, utilizzeremo sempre 10 in questo istruibile.
• run_ave: elaborazione utilizzando una media mobile, 0 significa nessuna elaborazione.
• trigger_value: elaborazione tramite trigger, 0 significa nessuna elaborazione

la riga finale, senza commento, (self.show_plot……) mostra il grafico.

Per rendere le cose un po' più complicate puoi avere più linee su un grafico o più grafici in un esperimento, questo dovrebbe essere chiaro dagli esperimenti che seguono.

Passaggio 3: eseguire un esperimento

Questo è il codice per eseguire un esperimento. Come in comune in Python è posto alla fine del file.

sim_logging = LoggingSim()

sim_logging.experiment_with_sample_rates()

Queste sono solo 2 righe:

• Crea un simulatore di registrazione (LoggingSim())
• Eseguilo (sim_logging.experiment_with_sample_rates())

Nel codice scaricato ho qualche riga in più e commenti, dovrebbe essere facile da capire.

Passaggio 4: esperimento: frequenza di campionamento

Il simulatore, come impostato qui, emette sempre una bella onda sinusoidale liscia di ampiezza 1. Per questo esperimento faremo confusione con la frequenza di campionamento, regolata da delta_t, la differenza di tempo tra i campioni. Non avremo rumore o altre elaborazioni. Il codice utilizza 3 frequenze di campionamento (delta_t = 1,0, 0,1 e 0,01). Poiché i grafici cadono uno sopra l'altro, l'esperimento è impostato per produrre 3 grafici diversi. I grafici risultanti sono le immagini per questo passaggio.

def experiment_with_sample_rates(self):

print """ Esperimento con frequenze di campionamento Esaminando diverse frequenze di campionamento modificando delta T """ self.start_plot(plot_title = "Esperimento frequenze di campionamento 1/3: Delta T = 1.0") self.add_sensor_data(name = "dt = 1.", ampiezza = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot() # ------------- ----------------------------------- self.start_plot(plot_title = "Frequenze di campionamento dell'esperimento 2/3: Delta T = 0.1") self.add_sensor_data(name = "dt = 1.", ampiezza = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot() # ------------------------------------------------ se stesso.start_plot(plot_title = "Experiment Sample Rates 3/3: Delta T = 0.01") self.add_sensor_data(name = "dt = 1.", ampiezza = 1., noise_amp =.0, delta_t = 0.01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot()

Per eseguirlo usa la riga: sim_logging.experiment_with_sample_rates()

Possibili conclusioni:

• Una frequenza di campionamento troppo bassa è davvero pessima.
• Tassi alti sono spesso migliori.

(Codice Python 3.6 al collegamento GitHub di seguito a instructables, 2.7)

Passaggio 5: Esperimento: visualizzazione del rumore

In questo esperimento manteniamo lo stesso segnale, usiamo una frequenza di campionamento media e abbiamo diverse quantità di rumore (noise_amp =.0,.1, 1.0.) Eseguilo con: sim_logging.experiment_showing_noise(). L'output è un grafico con 3 linee.

Possibile conclusione:

Il rumore rende difficile vedere il segnale, riducilo se puoi

Il codice:

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

def experiment_showing_noise(self): print """ Esperimento che mostra rumore Guardando diverse quantità di rumore cambiando l'ampiezza del rumore. """ self.start_plot(plot_title = "Esperimento che mostra rumore") self.add_sensor_data(name = "noise = 0.0 ", ampiezza = 1., noise_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data(name = "noise = 0.1", ampiezza = 1., noise_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data(name = "noise = 1.0", ampiezza = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot()

Passaggio 6: Esperimento: ridurre il rumore con una media mobile

Una media mobile (ad esempio con lunghezza 8) prende le ultime 8 misurazioni e ne calcola la media. Se il rumore è casuale, speriamo che la media si avvicini a 0. Esegui l'esperimento con: sim_logging.experiment_showing_noise(). Emetti un grafico.

Possibili conclusioni:

• Una media mobile elimina gran parte del rumore
• Più lunga è la media mobile, maggiore è la riduzione del rumore
• La media mobile più lunga può ridurre e distorcere il segnale

Il codice:

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

def experiment_with_moving_average(self): print """ Esperimento con MovingAverage Guardando una MovingAverage diversa cambiando la lunghezza. Tutti hanno lo stesso rumore. """ # ------------------ ---------------- self.start_plot(plot_title = "MovingAverage-Part 1/2: No Moving Average") self.add_sensor_data(name = "ave len=0", ampiezza = 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", ampiezza = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 8, trigger_value = 0) self.add_sensor_data(name = "ave len=32", ampiezza = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

Passaggio 7: Esperimento: media mobile e frequenza di campionamento

In questo esperimento confrontiamo il segnale grezzo con il rumore e 2 diverse variazioni sulla riduzione del rumore.

1. Frequenza di campionamento media e media di corsa media
2. Frequenza di campionamento elevata e media in esecuzione di lunghezza elevata

Eseguilo con: sim_logging…… L'output è un grafico. Penso che sia chiaro che il n. 2 fa un lavoro migliore nel ridurre il rumore, quindi potremmo concludere che:

Un'alta frequenza di campionamento e una media di corsa di lunghezza elevata sono buone

Ma devi tenere a mente che c'è un costo. #2 richiede molta più elaborazione e si traduce in molti più dati da salvare. Il costo può o non può valere la pena. Nel prossimo esperimento aggiungeremo un trigger, un dispositivo per ridurre la quantità di dati memorizzati.

Il codice:

def experiment_with_moving_average_and_sample_rate(self):

print """ Esperimento con media mobile e frequenza di campionamento, dt, la media di esecuzione viene variata """ # -------------- -------------------- self.start_plot(plot_title = "Media mobile e frequenza di campionamento") self.add_sensor_data(name = "dt=.1 ra=0 trig= 0", ampiezza = 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", ampiezza = 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", ampiezza = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot()

Passaggio 8: Esperimento: registrazione con trigger

In questo esperimento aggiungiamo un trigger. Innanzitutto, cosa intendo per trigger? Un trigger è una tecnica in cui raccogliamo dati ma li salviamo solo dopo che alcune variabili sono cambiate in modo significativo. In questi esperimenti ho messo un trigger sulla variabile tempo (asse x). Usando il trigger posso prendere l'elevata quantità di dati dal campionamento rapido e ridurla a una quantità di dati più ragionevole. È particolarmente utile con frequenze di campionamento elevate e una media di lunga durata.

Ho preso la riga n. 2 dall'ultimo esperimento che era "buono" e ho aggiunto un trigger. Eseguilo con: sim_logging…… L'output è un grafico, x linee.

Che succede? Otteniamo un grafico "buono" con una quantità ragionevole di dati (lo stesso del n. 1). C'è stato un certo costo nell'elaborazione più elevata. Nel complesso, tuttavia, i risultati sono all'incirca gli stessi di #1 la frequenza di campionamento più bassa con meno filtri. Potresti concludere:

• La media di lunga durata con triggering può fornire una buona riduzione del rumore con quantità ragionevoli di dati.
• L'elaborazione extra potrebbe non dare risultati molto migliori e ha un costo.

Il codice:

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

def experiment_with_trigger(self): print """ Esperimento con Triggering, dt, run media e trigger che vengono tutti variati """ # ----------------------- ------------------------- self.start_plot(plot_title = "Trigger 1/1 - Triggering On") self.add_sensor_data(name = "dt=.1 ra=10, trig =0", ampiezza = 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", ampiezza = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot()

=

Passaggio 9: Esperimento: registrazione con trigger - Rumore più forte

Facciamo lo stesso esperimento dell'ultimo passaggio e aumentiamo il rumore. Eseguilo con: sim_logging…… L'output è un grafico, 2 linee.

Ora l'elaborazione extra sembra più utile. Una conclusione ragionevole qui potrebbe essere:

La scelta della quantità e del tipo di elaborazione per la riduzione del rumore dipende dal segnale e dal rumore

Il codice:

def experiment_with_trigger_louder_noise(self):

print """ Rumore più forte rispetto all'esperimento precedente """ self.start_plot(plot_title = "Un esperimento con rumore di trigger più forte") self.add_sensor_data(name = "…dt=.1 ra=10", ampiezza = 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", ampiezza = 1., noise_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot()

Passaggio 10: fai i tuoi esperimenti

A questo punto spero che tu veda che le tecniche in questo istruibile possono essere utili nella registrazione dei dati, ma che devono anche essere usate con un po' di riflessione. Sperimentare con loro può aiutare questo processo.

Alcune osservazioni sugli esperimenti e sulle cose che potresti esaminare:

• Le onde sinusoidali non sono l'unico tipo di segnale interessante, provane altre, altre onde o rampe o …..
• Ho usato una distribuzione normale per il rumore, ci sono tanti tipi di rumore; dovresti considerare gli altri
• Le medie correnti sono un metodo semplice, ma non l'unico, per osservare il rumore

Nota: registrazione delle immagini da Wikipedia.

Passaggio 11: utilizzo delle tecniche nel software di registrazione

Il mio codice è orientato agli oggetti e l'elaborazione per la media di esecuzione e il trigger può essere semplicemente copiata nel tuo ambiente Python e quindi utilizzata. Gli oggetti sono:

• DataTrigger in data_trigger.py
• MovingAverage in Moving_average.py

Il mio oggetto principale LoggingSim in simula_logging.py dovrebbe darti un buon esempio di come usarlo. Se usi un'altra lingua puoi leggere il mio codice e implementarlo nella tua lingua.

Questo codice può dare al tuo progetto una migliore registrazione dei dati, provalo.

Il grafico sopra è tratto da Graph Your Solar Power di russ_hensel che utilizza lo stesso oggetto medio corrente.