Experiment i avancerad dataloggning (med Python): 11 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:38

Det finns många dataloggningsinstruktioner, så när jag ville bygga ett eget loggprojekt såg jag mig omkring på ett gäng. Vissa var bra, andra inte så mycket, så jag bestämde mig för att ta några av de bättre idéerna och göra min egen ansökan. Detta resulterade i ett projekt både mer avancerat och mer komplicerat än jag först hade förväntat mig. En del av det blev en serie experiment med behandling av sensordata. Med denna instruerbara kan du testa samma eller liknande experiment.

(Du kan visa all koden och ladda ner den på: Kod på GitHub Du kan komma till visning, kanske i ett annat fönster, med bara 2 klick)

Normalt innebär dataloggning följande:

• Datainsamling: Läs några data från en sensor. Ofta är det bara att läsa en analog till digital omvandlare (ADC) på en enhet som en Arduino.
• Databehandling: När man läser ett ADC -värde måste omvandlarens utdata normalt skalas till rätt enheter. Det kan också vara nödvändigt att göra några justeringar för att kalibrera värdena för att korrigera för sensorfel.
• Filtrering: Data innehåller vanligtvis lite brus, detta kan filtreras så att du letar efter signalen i dina data, inte bruset.
• Datalagring: Data sparas, kanske i en textfil, kanske i molnet. Data bör överleva även om strömmen går av. Det är lätt att spara för mycket data, vi har ett litet knep för att minska datalagringsutrymmet.
• Datavisning: Metoder för att titta på dina data, egentligen inte dataloggning, men om du inte gör någon form av visning av data varför samla in dem?
• Fjärråtkomst: Inte nödvändigt men trevligt att ha.

De flesta instruktioner inkluderar några men inte alla ovanstående, eller gör dem på ett mycket enkelt sätt. Denna instruktör kommer att ta upp två av de ofta hoppade loggningsproblemen och som en bonus ge dig ett sätt att rita dina data utan att använda en molntjänst. Du kan använda det hela eller dra ut bitar och remixa dem till ett eget projekt.

Steg 1: Verktyg och material

Det här exemplet finns i Python så det kommer att köras och komponenter kan användas på i stort sett alla operativsystem inklusive Mac, PC, Linux och Raspberry Pi.

Så för att använda denna instruerbara är allt du behöver en Python 3.6 -miljö som körs och ladda ner den bifogade koden. När du har kört koden som jag har konfigurerat kan du ändra den för dina egna experiment. Som vanligt med Python kan du behöva lägga till några paket/moduler för att allt ska fungera. Min Spyder -miljö har i stort sett alla nödvändiga delar på plats (se: Graph Instructable Views with Python Screen Scraping). När du första gången tittar på eventuella felmeddelanden meddelar de dig om saknade delar i din miljö.

De två följande stegen kommer att berätta hur du bygger och kör ett eget experiment, men det är förmodligen bättre att vänta tills du kör de medföljande experimenten innan du provar ditt eget.

För att förstå koden måste du ha lite erfarenhet av objektorienterad Python, förklara att det ligger utanför ramen för denna instruerbara, men Google borde ge dig all hjälp du kan behöva.

Notera koden: (Kod på GitHub Du kan komma till visning, kanske i ett annat fönster, med bara 2 klick) är nu i Python 3.6, så att ha 3,6 vore bäst. Äldre version av koden finns här i länkarna nedan.

Steg 2: Skapa ett experiment

Det finns tre programmeringssteg (och linjer) för att bygga ett experiment. Varje experiment är en funktion i LoggingSim -objektet i filen simulate_logging.py. Låt oss titta på experiment 1 (bara det första diagrammet) som vi kommer att köra i nästa steg:

def experiment_with_sample_rates (self):

print "" "Experimentera med provhastigheter Titta på olika samplingshastigheter genom att ändra delta T" "" self.start_plot (plot_title = "Sample Rates - Del 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 ()

Varje experiment är skrivet som sin egen funktion så vi har en rad som definierar funktionen (def experiment …..)

Nästa rad utan kommentar, (start_plot (….) skapar objektet för experimentet och ger det ett namn.

Nästa rad utan rad, (add_sensor_data (…) är uppdelad i flera rader. Den simulerar en sensor som mäter en signal med potentiellt brus och viss bearbetning. Funktionsargumenten är följande:

• namn: ett namn på det sista diagrammet för att identifiera data
• amplitud: hur stor signalen är kommer vi alltid att använda en amplitud på 1. i denna instruerbara.
• noise_amp: hur stort bullret är, 0. är inget buller, vi börjar här.
• delta_t: tiden mellan mätningarna styr provhastigheten.
• max_t: den maximala tiden vi samlar in data, vi kommer alltid att använda 10 i denna instruerbara.
• run_ave: bearbetning med löpande medelvärde, 0 betyder ingen behandling.
• trigger_value: bearbetning med trigging, 0 betyder ingen behandling

den sista raden utan kommentarer, (self.show_plot ……) visar diagrammet.

För att göra saker lite mer komplicerade kan du ha flera rader på ett diagram eller flera grafer i ett experiment, detta borde framgå av de experiment som följer.

Steg 3: Kör ett experiment

Detta är koden för att köra ett experiment. Som vanligt i Python placeras den i slutet av filen.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

Detta är bara 2 rader:

• Skapa en loggningssimulator (LoggingSim ())
• Kör det (sim_logging.experiment_with_sample_rates ())

I den nedladdade koden har jag några fler rader och kommentarer, det borde vara lätt att räkna ut.

Steg 4: Experiment: Provhastighet

Simulatorn, som den är konfigurerad här, matar alltid ut en fin jämn sinusvåg av amplitud 1. För detta experiment kommer vi att röra med samplingshastigheten, justerad med delta_t, tidsskillnaden mellan proverna. Vi kommer inte att ha buller eller annan behandling. Koden använder 3 samplingsfrekvenser (delta_t = 1,0, 0,1 och 0,01.) Eftersom graferna faller ovanpå varandra sätts experimentet upp för att producera 3 olika grafer. De resulterande graferna är bilderna för detta steg.

def experiment_with_sample_rates (self):

print "" "Experimentera med provhastigheter Titta på olika samplingshastigheter genom att ändra 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., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------- ----------------------------------- self.start_plot (plot_title = "Experiment Exempelpriser 2/3: Delta T = 0,1 ") self.add_sensor_data (namn =" dt = 1. ", amplitud = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------------------------------------------ själv.start_plot (plot_title = "Experiment Sample Rates 3/3: Delta T = 0.01") self.add_sensor_data (namn = "dt = 1.", amplitud = 1., noise_amp =.0, delta_t = 0.01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

För att köra den, använd raden: sim_logging.experiment_with_sample_rates ()

Möjliga slutsatser:

• För låg samplingsfrekvens är riktigt dålig.
• Höga priser är ofta bättre.

(Python 3.6 -kod på GitHub -länken nedan på instruktörer, 2.7)

Steg 5: Experiment: visar buller

I detta experiment behåller vi samma signal, använder en medelhög samplingshastighet och har olika brusmängder (noise_amp =.0,.1, 1.0.) Kör den med: sim_logging.experiment_showing_noise (). Utdata är en graf med 3 rader.

Möjlig slutsats:

Buller gör det svårt att se signalen, minska den om du kan

Koden:

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

def experiment_showing_noise (self): print "" "Experiment som visar brus Tittar på olika mängder brus genom att ändra brusamplituden." "" self.start_plot (plot_title = "Experiment som visar brus") 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 (namn =" noise = 0.1 ", amplitud = 1., noise_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (namn = "noise = 1.0", amplitud = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Steg 6: Experiment: Minska buller med ett glidande medelvärde

Ett glidande medelvärde (till exempel med längd 8) tar de senaste 8 mätningarna och genomsnitt dem. Om bruset är slumpmässigt hoppas vi att det kommer att bli i genomsnitt nära 0. Kör experimentet med: sim_logging.experiment_showing_noise (). Mata ut en graf.

Möjliga slutsatser:

• Ett glidande medelvärde eliminerar mycket av bullret
• Ju längre glidande medelvärde desto mer brusreducering
• Det längre glidande genomsnittet kan minska och förvränga signalen

Koden:

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

def experiment_with_moving_average (self): print "" "Experiment with MovingAverage Titta på olika MovingAverage genom att ändra längden. Alla har samma brus." "" # ------------------ ------------------------------ self.start_plot (plot_title = "MovingAverage-Part 1/2: No Moving Average") själv.add_sensor_data (namn = "ave len = 0", amplitud = 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 och 32") self.add_sensor_data (namn = "ave len = 8", amplitud = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 8, trigger_value = 0) self.add_sensor_data (namn = "ave len = 32", amplitud = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

Steg 7: Experiment: glidande medelvärde och provhastighet

I detta experiment jämför vi råsignalen med brus och 2 olika variationer för att reducera bruset.

1. Medium samplingsfrekvens och medelhög löpande medelvärde
2. Hög samplingshastighet och löpande medelhög längd

Kör det med: sim_logging …… Output är ett diagram. Jag tror att det är klart att #2 gör ett bättre jobb för att minska bullret så vi kan dra slutsatsen att:

Hög samplingshastighet och löpande medelhög längd är bra

Men du måste komma ihåg att det kostar. #2 tar mycket mer bearbetning och resulterar i att mycket mer data sparas. Kostnaden kan vara värt det eller inte. I nästa experiment kommer vi att lägga till en trigger, en enhet för att minska mängden data som lagras.

Koden:

def experiment_with_moving_average_and_sample_rate (self):

print "" "Experimentera med glidande medelvärde och samplingshastighet, dt, körmedelvärde varieras" "" # ---------------------------- -------------------- self.start_plot (plot_title = "Glidande medelvärde och samplingsfrekvens") self.add_sensor_data (namn = "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 (namn =" 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 (namn = "dt =.01 ra = 100 trig = 0", amplitud = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot ()

Steg 8: Experiment: Logga med Trigger

I detta experiment lägger vi till en utlösare. Först, vad menar jag med en trigger? En trigger är en teknik där vi samlar in data men bara sparar den efter att någon variabel har ändrats avsevärt. I dessa experiment satte jag en trigger på variabeln tid (x -axel). Genom att använda utlösaren kan jag ta den höga datamängden från snabb sampling och reducera den till en mer rimlig mängd data. Det är särskilt användbart med höga samplingshastigheter och ett långt löpande genomsnitt.

Jag har tagit #2 -raden från det senaste experimentet som var "bra" och lade till en utlösare. Kör den med: sim_logging …… Output är ett diagram, x rader.

Vad händer? Vi får en "bra" plot med en rimlig mängd data (samma som #1). Det har blivit en del kostnader i högre bearbetning. Sammantaget är resultaten dock ungefär samma som #1 den lägre samplingshastigheten med mindre filtrering. Du kan dra slutsatsen:

• Långt genomsnitt med triggning kan ge bra brusreducering med rimliga mängder data.
• Den extra bearbetningen ger kanske inte så mycket bättre resultat och kommer med en kostnad.

Koden:

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

def experiment_with_trigger (self): print "" "Experiment with Triggering, dt, run average and trigger all being variety" "" # ----------------------- ------------------------- 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 (namn =" 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 ()

=

Steg 9: Experiment: Loggning med utlösare - högre ljud

Låt oss ta samma experiment som det sista steget och förstärka bullret. Kör den med: sim_logging …… Output är ett diagram, 2 rader.

Nu ser den extra bearbetningen mer värd ut. En rimlig slutsats här kan vara:

Att välja mängd och typ av behandling för brusreducering beror på din signal och brus

Koden:

def experiment_with_trigger_louder_noise (self):

skriv ut "" "Högre brus än tidigare experiment" "" self.start_plot (plot_title = "Ett experiment med triggare-högre buller") self.add_sensor_data (namn = "… dt =.1 ra = 10", amplitud = 1., noise_amp =.5, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (namn = "..dt =.01 ra = 100 tv =.1", amplitud = 1., noise_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

Steg 10: Gör dina egna experiment

Vid det här laget hoppas jag att du ser att teknikerna i denna instruerbara kan vara användbara vid dataloggning, men att de också måste användas med lite eftertanke. Att experimentera med dem kan hjälpa den processen.

Några kommentarer om experimenten och saker du kan titta på:

• Sinusvågor är inte den enda intressanta signaltypen, prova andra, andra vågor eller ramper eller ….
• Jag använde en normal fördelning för bruset, det finns så många sorters brus; du bör tänka på andra
• Löpande medelvärden är en enkel, men inte den enda metoden för att titta på buller

Obs: logga bilder från Wikipedia.

Steg 11: Använda teknikerna i din loggningsprogramvara

Min kod är objektorienterad och behandlingen för löpande medelvärde och trigger kan bara kopieras till din Python -miljö och sedan användas. Objekten är:

• DataTrigger i data_trigger.py
• MovingAverage i moving_average.py

Mitt huvudobjekt LoggingSim i simulate_logging.py bör ge dig ett bra exempel på hur du använder det. Om du använder ett annat språk kan du läsa min kod och implementera på ditt språk.

Denna kod kan ge ditt projekt bättre dataloggning, prova.

Grafen ovan är från Graph Your Solar Power av russ_hensel som använder samma löpande medelobjekt.