Eksperimenter i avanceret datalogning (ved hjælp af Python): 11 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:26

Der er mange datalogningsinstruktioner, så da jeg ville bygge et eget logningsprojekt, kiggede jeg rundt på en flok. Nogle var gode, nogle ikke så meget, så jeg besluttede at tage nogle af de bedre ideer og lave min egen ansøgning. Dette resulterede i et projekt både mere avanceret og mere kompliceret, end jeg først havde forventet. En del af det blev til en række eksperimenter i behandling af sensordata. Denne instruktive lader dig prøve de samme eller lignende eksperimenter.

(Du kan se al koden og downloade den på: Kode på GitHub Du kan komme i visning, måske i et andet vindue, med kun 2 klik)

Typisk indebærer datalogning følgende:

• Dataopsamling: Læs nogle data fra en sensor. Ofte er det bare at læse en analog til digital konverter (ADC) på en enhed som en Arduino.
• Databehandling: Når man læser en ADC -værdi, skal konverternes output normalt skaleres til de rigtige enheder. Det kan også være nødvendigt at foretage nogle justeringer for at kalibrere værdierne for at korrigere for sensorfejl.
• Filtrering: Data indeholder normalt noget støj, dette kan filtreres, så du leder efter signalet i dine data, ikke støj.
• Datalagring: Dataene gemmes, måske i en tekstfil, måske i skyen. Data bør overleve, selvom strømmen slukker. Det er let at gemme for meget data, vi har et lille trick til at reducere datalagringspladsen.
• Datavisning: Metoder til at se på dine data, egentlig ikke datalogning, men hvis du ikke laver en visning af dataene, hvorfor indsamle dem?
• Fjernadgang: Ikke nødvendigt, men rart at have.

De fleste instruktører indeholder nogle, men ikke alle ovenstående, eller gør dem på en meget enkel måde. Denne instruktive vil behandle 2 af de ofte sprungede logningsproblemer og som en bonus give dig et middel til at tegne dine data uden at bruge en cloud -service. Du kan bruge det hele eller trække stykker ud og remixe dem til et eget projekt.

Trin 1: Værktøjer og materialer

Dette eksempel er alt i Python, så det vil køre, og komponenter kan bruges på stort set alle operativsystemer, herunder Mac, PC, Linux og Raspberry Pi.

Så for at bruge denne instruerbare er alt, hvad du har brug for, et kørende Python 3.6 -miljø, og download den vedhæftede kode. Efter at have kørt den kode, jeg har konfigureret, kan du ændre den til dine egne eksperimenter. Som sædvanligt med Python skal du muligvis tilføje nogle pakker/moduler for at få alt til at fungere. Mit Spyder -miljø indeholder stort set alle de krævede dele på plads (se: Graph Instructable Views with Python Screen Scraping). Når du først kører efter eventuelle fejlmeddelelser, giver de dig besked om manglende dele i dit miljø.

De næste to trin fortæller dig, hvordan du bygger og kører et eget eksperiment, men det er sandsynligvis bedre at vente, indtil du kører de medfølgende eksperimenter, før du prøver dit eget.

For at forstå koden skal du have en smule erfaring med objektorienteret Python, der forklarer, at det ligger uden for denne instruks, men Google bør give dig den hjælp, du måske har brug for.

Bemærk koden: (Kode på GitHub Du kan komme i visning, måske i et andet vindue, med kun 2 klik) er nu i Python 3.6, så at have 3.6 ville være bedst. Ældre version af koden er her i linkene herunder.

Trin 2: Opbygning af et eksperiment

Der er tre programmeringstrin (og linjer) i opbygningen af et eksperiment. Hvert eksperiment er en funktion i LoggingSim -objektet i filen simulate_logging.py. Lad os se på eksperiment 1 (kun den første graf), som vi vil køre i det næste trin:

def experiment_with_sample_rates (self):

print "" "Eksperimenter med prøvehastigheder Ser på forskellige prøvehastigheder ved at ændre delta T" "" self.start_plot (plot_title = "Prøvepriser - del 1/3: Delta T = 1.0") self.add_sensor_data (navn = "dt = 1. ", amplitude = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Hvert eksperiment er skrevet som sin egen funktion, så vi har en linje, der definerer funktionen (def eksperiment …..)

Den næste linje uden kommentarer, (start_plot (….) opretter objektet til eksperimentet og giver det et navn.

Den næste linje med ikke -kommentar (add_sensor_data (…) er opdelt i flere linjer. Den simulerer en sensor, der måler et signal med potentielt støj og en vis behandling. Funktionsargumenterne er som følger:

• navn: et navn på den sidste graf for at identificere dataene
• amplitude: hvor stort signalet er, vil vi altid bruge en amplitude på 1. i denne instruerbare.
• noise_amp: hvor stor støjen er, 0. er ingen støj, vi starter her.
• delta_t: tiden mellem målinger, styrer samplingshastigheden.
• max_t: den maksimale tid, vi indsamler data, vil vi altid bruge 10 i denne instruktive.
• run_ave: behandling ved hjælp af et løbende gennemsnit, 0 betyder ingen behandling.
• trigger_value: behandling ved hjælp af triggering, 0 betyder ingen behandling

den sidste linje uden kommentarer (self.show_plot ……) viser grafen.

For at gøre tingene lidt mere komplicerede kan du have flere linjer på en graf eller flere grafer i et eksperiment, dette bør fremgå tydeligt af de efterfølgende eksperimenter.

Trin 3: Kørsel af et eksperiment

Dette er koden til at køre et eksperiment. Som almindeligt i Python er det placeret i slutningen af filen.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

Dette er kun 2 linjer:

• Opret en loggesimulator (LoggingSim ())
• Kør det (sim_logging.experiment_with_sample_rates ())

I den downloadede kode har jeg et par linjer og kommentarer mere, det burde være let at finde ud af.

Trin 4: Eksperiment: Prøvehastighed

Simulatoren, som den er oprettet her, udsender altid en dejlig glat sinus med amplitude 1. Til dette eksperiment vil vi rode med samplingshastigheden, som justeret af delta_t, tidsforskellen mellem prøver. Vi vil ikke have støj eller anden behandling. Koden bruger 3 samplingshastigheder (delta_t = 1,0, 0,1 og 0,01.) Da graferne falder oven på hinanden, er eksperimentet sat op til at producere 3 forskellige grafer. De resulterende grafer er billederne til dette trin.

def experiment_with_sample_rates (self):

print "" "Eksperimenter med prøvehastigheder Ser på forskellige prøvehastigheder ved at ændre delta T" "" self.start_plot (plot_title = "Eksperimentprøvehastigheder 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 = "Eksempel på prøvepriser 2/3: Delta T = 0,1 ") self.add_sensor_data (navn =" dt = 1. ", amplitude = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------------------------------------------ selv.start_plot (plot_title = "Eksempeleksempelpriser 3/3: Delta T = 0,01") self.add_sensor_data (navn = "dt = 1.", amplitude = 1., noise_amp =.0, delta_t = 0.01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

For at køre det skal du bruge linjen: sim_logging.experiment_with_sample_rates ()

Mulige konklusioner:

• For lav en prøveudtagningshastighed er virkelig dårlig.
• Høje satser er ofte bedre.

(Python 3.6 -kode på GitHub -linket herunder på instruktører, 2.7)

Trin 5: Eksperiment: Viser støj

I dette eksperiment beholder vi det samme signal, bruger en medium samplingshastighed og har forskellige mængder støj (noise_amp =.0,.1, 1.0.) Kør det med: sim_logging.experiment_showing_noise (). Outputtet er en graf med 3 linjer.

Mulig konklusion:

Støj gør det svært at se signalet, reducer det, hvis du kan

Koden:

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

def experiment_showing_noise (self): print "" "Eksperiment viser støj Ser på forskellige mængder støj ved at ændre støjamplituden." "" self.start_plot (plot_title = "Experiment viser støj") self.add_sensor_data (navn = "noise = 0.0 ", amplitude = 1., noise_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (navn =" noise = 0.1 ", amplitude = 1., noise_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (navn = "noise = 1.0", amplitude = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Trin 6: Eksperiment: Reducer støj med et glidende gennemsnit

Et glidende gennemsnit (f.eks. Med længde 8) tager de sidste 8 målinger og gennemsnit dem. Hvis støjen er tilfældig, håber vi, at den vil komme i gennemsnit til tæt på 0. Kør eksperimentet med: sim_logging.experiment_showing_noise (). Output en graf.

Mulige konklusioner:

• Et glidende gennemsnit fjerner meget af støjen
• Jo længere det glidende gennemsnit er, desto mere støjreduktion
• Det længere glidende gennemsnit kan reducere og forvrænge signalet

Koden:

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

def experiment_with_moving_average (self): print "" "Eksperiment med MovingAverage Ser på forskellige MovingAverage ved at ændre længden. Alle har den samme støj." "" # ------------------ ------------------------------ self.start_plot (plot_title = "MovingAverage-Part 1/2: No Moving Average") selv.add_sensor_data (navn = "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 og 32") self.add_sensor_data (navn = "ave len = 8", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 8, trigger_value = 0) self.add_sensor_data (navn = "ave len = 32", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

Trin 7: Eksperiment: glidende gennemsnit og prøvehastighed

I dette eksperiment sammenligner vi råsignalet med støj og 2 forskellige variationer om reducering af støj.

1. Middels prøvehastighed og medium løbende gennemsnit
2. Høj sample rate og høj længde løbende gennemsnit

Kør det med: sim_logging …… Output er en graf. Jeg synes, det er klart, at #2 gør et bedre stykke arbejde med at reducere støj, så vi kan konkludere, at:

Høj prøvehastighed og høj gennemsnitslængde er gode

Men du skal huske på, at der er en pris. #2 tager meget mere behandling og resulterer i, at mange flere data gemmes. Omkostningerne kan være værd eller ikke. I det næste eksperiment tilføjer vi en trigger, en enhed til at reducere mængden af data, der er gemt.

Koden:

def experiment_with_moving_average_and_sample_rate (self):

print "" "Eksperimenter med glidende gennemsnit og prøvehastighed, dt, kørselsgennemsnit varieres" "" # ---------------------------- -------------------- self.start_plot (plot_title = "Glidende gennemsnit og prøvehastighed") self.add_sensor_data (navn = "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 (navn =" 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 (navn = "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 ()

Trin 8: Eksperiment: Logning med udløser

I dette eksperiment tilføjer vi en trigger. For det første, hvad mener jeg med en trigger? En trigger er en teknik, hvor vi indsamler data, men kun gemmer dem, efter at en variabel har ændret sig betydeligt. I disse eksperimenter satte jeg en trigger på variablen tid (x -akse). Ved at bruge triggeren kan jeg tage den høje datamængde fra hurtig sampling og reducere den til en mere rimelig mængde data. Det er særligt nyttigt med høje prøvehastigheder og et langt løbende gennemsnit.

Jeg har taget #2 -linjen fra det sidste eksperiment, som var "godt" og tilføjede en trigger. Kør det med: sim_logging …… Output er en graf, x linjer.

Hvad der sker? Vi får et "godt" plot med en rimelig mængde data (det samme som #1). Der har været nogle omkostninger ved højere behandling. Samlet set er resultaterne dog omtrent det samme som #1 den lavere prøvehastighed med mindre filtrering. Du kan konkludere:

• Langt løbende gennemsnit med udløsning kan give god støjreduktion med rimelige mængder data.
• Den ekstra behandling giver måske ikke så meget bedre resultater og koster en pris.

Koden:

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

def experiment_with_trigger (self): print "" "" Eksperimenter med Triggering, dt, kør gennemsnittet og trigger alle til at blive varieret "" " # ----------------------- ------------------------- 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 (navn =" 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 ()

=

Trin 9: Eksperiment: Logning med udløser - højere støj

Lad os tage det samme eksperiment som det sidste trin og forstærke støjen. Kør det med: sim_logging …… Output er en graf, 2 linjer.

Nu ser den ekstra behandling mere værd ud. En rimelig konklusion her kan være:

Valg af mængde og type behandling til støjreduktion afhænger af dit signal og din støj

Koden:

def experiment_with_trigger_louder_noise (self):

print "" "Højere støj end tidligere eksperiment" "" self.start_plot (plot_title = "Et eksperiment med Trigger-Louder Noise") self.add_sensor_data (navn = "… 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 (navn = "..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 ()

Trin 10: Lav dine egne eksperimenter

På dette tidspunkt håber jeg, at du kan se, at teknikkerne i denne instruktive kan være nyttige i datalogning, men at de også skal bruges med omtanke. At eksperimentere med dem kan hjælpe denne proces.

Nogle bemærkninger til eksperimenterne og ting, du kan se nærmere på:

• Sinusbølger er ikke den eneste interessante signaltype, prøv andre, andre bølger eller ramper eller ….
• Jeg brugte en normal fordeling for støjen, der er så mange slags støj; du bør overveje andre
• Løbende gennemsnit er en enkel, men ikke den eneste metode til at se på støj

Bemærk: logning af billeder fra Wikipedia.

Trin 11: Brug af teknikkerne i din logningssoftware

Min kode er objektorienteret, og behandlingen til løbende gennemsnit og trigger kan bare kopieres til dit Python -miljø og derefter bruges. Objekterne er:

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

Mit hovedobjekt LoggingSim i simulate_logging.py skulle give dig et godt eksempel på, hvordan du bruger det. Hvis du bruger et andet sprog, kan du læse min kode og implementere på dit sprog.

Denne kode kan give dit projekt bedre datalogning, prøv det.

Grafen ovenfor er fra Graph Your Solar Power af russ_hensel, der bruger det samme løbende gennemsnitlige objekt.