Analizzare le caratteristiche dei dati dell'accelerometro e progettare un filtro

Ho circa 32 secondi di dati accelerometrici su uno scenario di guida di base con strade normali da 25 MPH, oltre a colpire circa 7 buche e un tratto di strada accidentato. L'accelerometro è montato sul cruscotto della mia auto con nastro biadesivo.

Problema: ho tutti i dati che sono rumorosi dall'accelerometro e devo fare un modo semplice per rilevare che si è verificato un evento buca. Di seguito sono riportati diversi grafici di dati nel dominio del tempo e FFT. L'accelerometro sta misurando in GForce

Fondamentalmente voglio che il mio arduino sappia che si è verificata una buca con una precisione abbastanza grande e non usando matematica e tecniche di livello universitario.

L'accelerometro campionato a 100Hz ha un semplice FILTRO PASSAGGIO BASSO 50Hz sull'ASSE Z.

Here is the CSV data for the 32 seconds of accelerometer readings TIME, GFORCE format:

http://hamiltoncomputer.us/50HZLPFDATA.CSV

AGGIORNAMENTO: Questa è la larghezza di banda RAW completa dell'accelerometro 1000 HZ campionata alla massima frequenza di campionamento che ho potuto ottenere su Arduino. Download diretto di file CSV: circa 112 secondi di dati

http://hamiltoncomputer.us/RAWUNFILTEREDFULLBANDWIDTH500HZ.csv

La traccia nera è i dati dell'accelerometro RAW non filtrato: la traccia blu è filtrata da un filtro passa banda basato sulle frequenze estreme trovate in FFT, Dominate 2HZ e 12HZ.

L'evento Pothole si presenta così nel dominio del tempo:

non sei sicuro di quale sia il componente da 10 a 15 HZ nella FFT, è la vera buca, o è il salto delle ruote contro la strada, o è la frequenza di risonanza della macchina?

FFT:

sembra che siano gli eventi reali di buca, ecco un HPF @ 13HZ Le caratteristiche dominanti delle buche sembrano migliorate

Voglio essere in grado di rilevare e contare le buche in tempo reale

Sembra controintuitivo che la sospensione dovrebbe muoversi molto più lentamente di un 10-13 HZ che causerebbe la cinetosi, credo

AGGIORNARE:

Come suggerito da AngryEE, ho usato tutta la larghezza di banda dell'accelerometro 1000 HZ e la massima frequenza di campionamento che ho potuto ottenere su Arduino.

FFT:

ecco un campione di dati dell'evento buca e alcuni dossi e rumori della strada intorno ad esso:

Aggiunto il circuito rivelatore a inviluppo di diodi, l'uscita ha lo stesso aspetto ... L'accelerometro emette sempre da 0 a 3,3 Volt non negativi ...

AGGIORNARE:

Da molti test su strada, non ho mai superato 1.6G fino a 45 MPH nella mia macchina sull'asse Z, ho usato rand () per generare un'accelerazione pseudocasuale della Gforce.

La mia idea è se posso guardare da 1 a 3 secondi di finestre di dati, posso calcolare lo spostamento dell'asse Z, ma ero preoccupato per la deriva dell'accelerometro e gli errori nell'integrazione. Non ho bisogno di essere preciso al 90% qui,> 70% sarebbe bello, ma se sto osservando lo spostamento da uno a tre secondi alla volta, sarebbe possibile farlo in tempo reale? In questo modo posso vedere se lo spostamento è maggiore di come 1 pollice, 2 pollici, 5 pollici. Maggiore è lo spostamento, più ruvido era il dosso o la buca:

Puoi verificare se sto facendo bene, sostanzialmente ho impostato sul mio desktop, usando rand () per generare un'accelerazione casuale da -1,6 a 1,6 G, catturando 3 secondi di dati @ una frequenza di campionamento di 50 HZ simulata

Se come se avessi eseguito * nix, sto usando Sleep () da Windows.h per fare il ritardo di 20 ms, frequenza di campionamento di 50 Hz

Volevo solo vedere se il codice ti sembrava giusto, non ho ancora fatto il buffer cicolare, sono un po 'confuso su come implementarlo: il codice commentato, è della classe su cui sto lavorando per questo , ma non lo capisco ancora al 100%. Un buffer circolare consentirebbe di spostare contigue finestre di dati, giusto?

#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <ctime> // USED BY RAND
#include <windows.h> // Used for delay


using namespace std;



#define SAMPLE_RATE   0.020 // Sample rate in Milliseconds
#define GRAVITYFT_SEC 32 // Gravity velocity 32 feet/sec
#define INCH_FOOT     12 // 12 inches in foot, from velocity to inch displacement calculation










int main(int argc, char *argv[])
{
    srand((unsigned)time(0)); // SEED RAND() for simulation of Geforce Readings

    // SIMULATING ACCELERATION READINGS INTO A CIRCULAR BUFFER

   // circular_buffer Acceleration; // Create a new Circular buffer for Acceleration

   // cb_init(&Acceleration, 150, 4); // Sampling @ 50HZ, 3 seconds of data = 150, size is float data of 4 bytes

    //Simulate a sample run of Acceleration data using Rand()

    // WE WILL BE SIMULATING "RANDOM" GEFORCE RATINGS using the rand() function constraining to -1.6 to 1.6 GFORCE 
    // These ratings are consistent with our road tests of apparently random vibration and Geforce readings not exceeding about 1.6 G's

    float Gforce[150]; // Random Geforce for 3 second window of data
    float velocity[150]; // Hold velocity information
    float displacement[150]; // Hold Displacement information


    float LO = -1.6; // Low GForce limit recorded from 6 road tests at different speeds
    float HI = 1.6; // High GForce limit recorded from 6 road tests at different speeds

    for(int i = 0; i < 150; i++) // 3 Second iwndow of random acceleration data
    {  
            Gforce[i] = LO + (float)rand()/((float)RAND_MAX/(HI-LO)); // Borrowed from Stackexchange : http://stackoverflow.com/questions/686353/c-random-float
            if( i == 0) // Initial values @ first Acceleration
            {
                velocity[i] = Gforce[i] * SAMPLE_RATE * GRAVITYFT_SEC; // Initial velocity
                displacement[i] = velocity[i] * SAMPLE_RATE * INCH_FOOT; // Initial Displacement
            }
            else
            {
                velocity[i] = velocity[i-1] + (Gforce[i] * SAMPLE_RATE * GRAVITYFT_SEC); // Calculate running velocity into buffer
                displacement[i] = displacement[i-1] +(velocity[i] * SAMPLE_RATE * INCH_FOOT); // Calculate running displacement into buffer
            }
            //cout << endl << Gforce[i]; // Debugging
            //cb_push_back(&Acceleration, &Gforce[i]);                   // Push the GeForce into the circular buffer


            Sleep(SAMPLE_RATE*1000); // 20mS delay simulates 50HZ sampling rate Sleep() expects number in mS already so * 1000

    }
    // PRINT RESULTS
    for (int j = 0; j < 150; j++)
            {
                cout << setprecision (3) << Gforce[j] << "\t\t" << velocity[j] << "\t\t" << displacement[j] << endl;
            }

    // READ THE BUFFER





    //cb_free(&Acceleration); // Pervent Memory leaks

    system("PAUSE");
    return EXIT_SUCCESS;
}

Esecuzione di esempio:

    GFORCE          FT/SEC          Inch Displacement Z axis

-0.882          -0.565          -0.136
0.199           -0.437          -0.24
-1.32           -1.29           -0.549
0.928           -0.691          -0.715
0.6             -0.307          -0.788
1.47            0.635           -0.636
0.849           1.18            -0.353
-0.247          1.02            -0.108
1.29            1.85            0.335
0.298           2.04            0.824
-1.04           1.37            1.15
1.1             2.08            1.65
1.52            3.05            2.38
0.078           3.1             3.12
-0.0125         3.09            3.87
1.24            3.88            4.8
0.845           4.42            5.86
0.25            4.58            6.96
0.0463          4.61            8.06
1.37            5.49            9.38
-0.15           5.39            10.7
0.947           6               12.1
1.18            6.75            13.7
-0.791          6.25            15.2
-1.43           5.33            16.5
-1.58           4.32            17.5
1.52            5.29            18.8
-0.208          5.16            20.1
1.36            6.03            21.5
-0.294          5.84            22.9
1.22            6.62            24.5
1.14            7.35            26.3
1.01            8               28.2
0.284           8.18            30.1
1.18            8.93            32.3
-1.43           8.02            34.2
-0.167          7.91            36.1
1.14            8.64            38.2
-1.4            7.74            40
-1.49           6.79            41.7
-0.926          6.2             43.2
-0.575          5.83            44.6
0.978           6.46            46.1
-0.909          5.87            47.5
1.46            6.81            49.2
0.353           7.04            50.8
-1.12           6.32            52.4
-1.12           5.6             53.7
-0.141          5.51            55
0.463           5.8             56.4
-1.1            5.1             57.6
0.591           5.48            59
0.0912          5.54            60.3
-0.47           5.23            61.5
-0.437          4.96            62.7
0.734           5.42            64
-0.343          5.21            65.3
0.836           5.74            66.7
-1.11           5.03            67.9
-0.771          4.54            69
-0.783          4.04            69.9
-0.501          3.72            70.8
-0.569          3.35            71.6
0.765           3.84            72.5
0.568           4.21            73.5
-1.45           3.28            74.3
0.391           3.53            75.2
0.339           3.75            76.1
0.797           4.26            77.1
1.3             5.09            78.3
0.237           5.24            79.6
1.52            6.21            81.1
0.314           6.41            82.6
0.369           6.65            84.2
-0.598          6.26            85.7
-0.905          5.68            87.1
-0.732          5.22            88.3
-1.47           4.27            89.4
0.828           4.8             90.5
0.261           4.97            91.7
0.0473          5               92.9
1.53            5.98            94.3
1.24            6.77            96
-0.0228         6.76            97.6
-0.0453         6.73            99.2
-1.07           6.04            101
-0.345          5.82            102
0.652           6.24            104
1.37            7.12            105
1.15            7.85            107
0.0238          7.87            109
1.43            8.79            111
1.08            9.48            113
1.53            10.5            116
-0.709          10              118
-0.811          9.48            121
-1.06           8.8             123
-1.22           8.02            125
-1.4            7.13            126
0.129           7.21            128
0.199           7.34            130
-0.182          7.22            132
0.135           7.31            133
0.885           7.87            135
0.678           8.31            137
0.922           8.9             139
-1.54           7.91            141
-1.16           7.16            143
-0.632          6.76            145
1.3             7.59            146
-0.67           7.16            148
0.124           7.24            150
-1.19           6.48            151
-0.728          6.01            153
1.22            6.79            154
-1.33           5.94            156
-0.402          5.69            157
-0.532          5.35            159
1.27            6.16            160
0.323           6.37            162
0.428           6.64            163
0.414           6.91            165
-0.614          6.51            166
1.37            7.39            168
0.449           7.68            170
0.55            8.03            172
1.33            8.88            174
-1.2            8.11            176
-0.641          7.7             178
-1.59           6.69            179
1.02            7.34            181
-0.86           6.79            183
-1.55           5.79            184
-0.515          5.46            186
0.352           5.69            187
0.824           6.22            188
1.14            6.94            190
-1.03           6.29            192
-1.13           5.56            193
0.139           5.65            194
0.293           5.84            196
1.08            6.53            197
-1.23           5.75            199
-1.1            5.04            200
-1.17           4.29            201
-0.8            3.78            202
-0.905          3.2             203
-0.0769         3.15            203
-0.323          2.95            204
-0.0186         2.93            205
Press any key to continue . . .

Sembra che possa essere risolto con un filtro abbastanza diretto. Ecco i tuoi dati originali:

È troppo per vedere cosa succede in un singolo evento al livello di dettaglio appropriato per qui. Ecco solo i dati dal secondo 26 al 28:

Inizialmente avevo pensato di filtrare questo passa basso, ma non funziona perché non c'è un segnale a bassa frequenza. L'ampiezza del segnale ad alta frequenza aumenta invece. Ecco un passaggio basso sovrapposto all'originale:

Si noti che questo segue la "media" del segnale abbastanza bene non durante l'evento buca. Se sottraggiamo questa media dal segnale originale, durante l'evento ci rimarranno escursioni molto più elevate di questa media rispetto ad altre. Detto in altro modo, ciò che vogliamo veramente è un filtro passa-alto. Lo faremo sottraendo il passa basso dall'originale poiché è così che siamo arrivati ​​qui, ma in un sistema di produzione lo faresti filtrando esplicitamente il passaggio alto. Comunque, ecco l'originale filtrato passa-alto:

Questo ora indica un approccio ovvio per rilevare l'evento. Vi è molta più ampiezza del segnale durante l'evento rispetto al resto. Possiamo rilevarlo calcolando l'RMS e applicando alcuni filtri passa basso:

Rimpicciolendo tutti i dati, vediamo:

Ciò identifica chiaramente cinque eventi nei dati, anche se non so se questo è ciò che questi dati dovrebbero mostrare. Osservando più da vicino gli eventi, noti che ciascuno di essi ha bassi salti circa 1 secondo prima e dopo le cime. Ciò significa che si può fare di più se semplicemente il limite del segnale RMS in quanto non è abbastanza buono. Ad esempio, un semplice algoritmo che ha cercato l'altezza di un punto rispetto al più basso entro 1 secondo in entrambi i modi dovrebbe ridurre ulteriormente il rumore di fondo. Un altro modo di dire della stessa cosa è differenziare questo segnale cercando l'aumento in un periodo di 1 secondo. Un evento buca verrebbe quindi rilevato da un doppietto, il che significa un picco alto seguito da un picco basso.

Un altro modo di vedere questo è passare in banda il segnale RMS. È già filtrato passa-basso, ma dato che stai cercando eventi improvvisi con forti pendenze, eliminare alcune delle basse frequenze dovrebbe funzionare anche per ridurre il rumore di fondo.

Ci sono molti modi per affinare il segnale da qui, ma spero di aver mostrato come ottenere almeno un risultato utile al primo passaggio.

Inserito il:

Ero curioso di sapere quanto avrebbero funzionato i tuffi su entrambi i lati di un picco, quindi l'ho provato. Ho usato un filtro non lineare a partire dall'RMS del grafico precedente. Il valore di ciascun punto è il minimo di quanto è sopra il punto più basso nel secondo precedente e il punto più basso nel secondo successivo. Il risultato sembra abbastanza buono:

Il più basso dei 5 picchi è oltre 3 volte superiore al rumore di fondo più elevato. Questo ovviamente presuppone che questi 5 dossi rappresentino eventi che si desidera rilevare e il resto no.

Aggiunto in risposta ai commenti:

Ho creato i filtri nel dominio del tempo, quindi non conosco direttamente la risposta in frequenza. Per il filtro passa basso ho contorto il segnale di ingresso con un kernel di filtro COS ^ 2. Se ricordo bene, il raggio (distanza dal centro al bordo) del kernel è di qualche 100 ms. Ho sperimentato il valore fino a quando la trama sembrava buona. Per filtrare passa basso l'RMS, ho usato lo stesso kernel di filtro ma questa volta con un raggio di circa un secondo. Non ricordo esattamente. Sperimenta fino ad ottenere buoni risultati.

Il filtro non lineare non ha rilevato doppietti. Come ho detto, ho trovato la differenza tra il punto corrente e il più basso di tutti i punti entro 1 secondo prima, e anche la differenza tra il punto corrente e il più basso di tutti i punti entro 1 secondo dopo. Poi ho preso il minimo di quei due.

Il software che ho usato era un programma che ho hackerato per questo scopo. Avevo già varie routine per leggere e scrivere file CSV, quindi tutto quello che dovevo scrivere era il codice di filtro, che è molto semplice. Il resto è stato fatto con programmi preesistenti che ho per manipolare e tracciare file CSV.

Le buche di rilevamento dei bordi potrebbero richiedere problemi. L'inviluppo delle vibrazioni dell'auto è la risposta, poiché le vibrazioni effettive viste dal sensore sono a frequenze molto più elevate. Andrei con RMS a DC che risponde a circa 15Hz o superiore e passa basso la cosa.

Invece di cercare un filtro del dominio della frequenza o una soglia, consiglio di provare a trovare un kernel per una "tipica" buca, e di fare una correlazione continua con esso. Sarebbe considerata una tecnica di abbinamento dei modelli e sembrerebbe prestarsi a una piattaforma di microcontrollori.

Vedi http://scribblethink.org/Work/nvisionInterface/vi95_lewis.pdf per una rapida rassegna, e forse DOBBS, STEVEN E., NEIL M. SCHMITT e HALUK S. OZEMEK. "Rilevamento QRS mediante corrispondenza del modello mediante correlazione in tempo reale su un microcomputer." Giornale di ingegneria clinica 9.3 (1984): 197-212.

Se fossi su una piattaforma più robusta, consiglierei di dare un giro alle wavelet.

Un altro approccio sarebbe calcolare una varianza mobile del segnale per vedere se le buche sporgono davvero. Ecco una funzione matlab per un filtro di varianza mobile, N punti largamente - abilmente (se devo dirlo io stesso) usando una convoluzione per il calcolo

function y=movingvar(X,N)
% y=movingvar(X,N)
% Calculates N-point moving variance of  Vector X
% Highly recommend that N be odd (no error checking)
% Note: first and last N/2 points will be unreliable.
% Output will be a column vector.


X=X(:);
XSQR=X.*X;
convsig=ones(1,N);
y=(conv(convsig,XSQR)-(conv(convsig,X).^2)/N)/(N-1);

y=y(ceil(N/2):length(X)+floor(N/2));

Il mio pensiero iniziale è che un filtro passa-basso potrebbe essere il tipo sbagliato di filtro da usare. La buca è essenzialmente un evento ad alta frequenza, come una funzione a gradino o un'onda quadra. Il solo fatto di guardare i dati filtrati a 50Hz mi fa pensare che stai perdendo le informazioni sulla buca - tutto sembra come gli stessi scarabocchi senza alcuna distinzione significativa per l'evento della buca. Prima userei un filtro passa-alto, quindi un filtro passa-basso con una frequenza molto più alta. Potresti evitare del tutto il filtro passa-basso se il tuo accelerometro è già filtrato passa-basso.

Una volta che hai i dati filtrati passa-alto, penso che un semplice comparatore con una soglia impostata rileverà opportunamente i picchi nei dati di accelerazione causati dalle buche e ti consentirà di contarli.