İvmeölçer veri özelliklerini analiz etme ve bir filtre tasarlama

Temel sürüş senaryosunun yaklaşık 32 saniye değerinde ivmeölçer verisi var 25MPH normal yollarda yaklaşık 7 çukur ve zorlu bir yol yamasıyla birlikte. İvmeölçer, çift taraflı bantla arabamın gösterge panosuna monte edilir.

Sorun: İvmeölçerden gürültülü olan tüm verilere sahibim ve bir çukur olayının meydana geldiğini tespit etmek için basit bir yol yapmam gerekiyor. Aşağıda, zaman alanı ve FFT'deki çeşitli veri grafikleri bulunmaktadır. İvmeölçer GForce'de ölçüyor

Temelde, arduino'mun bir çukurun oldukça büyük bir doğrulukla olduğunu ve lisansüstü matematik ve teknikler kullanmadan bilmesini istiyorum.

100hz'de örneklenen ivmeölçer, Z EKSENİNDE basit bir 50HZ RC DÜŞÜK GEÇİŞ FİLTRESİ'ne sahiptir.

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

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

GÜNCELLEME: Bu, Arduino'da alabileceğim en yüksek örnekleme hızında örneklenen ivmeölçer 1000HZ'nin RAW tam bant genişliği. Doğrudan CSV dosyası indir: Yaklaşık 112 Saniye veri

http://hamiltoncomputer.us/RAWUNFILTEREDFULLBANDWIDTH500HZ.csv

Siyah iz RAW filtrelenmemiş İvmeölçer verileri: Mavi iz, FFT, Dominate 2HZ ve 12HZ'de bulunan aşırı frekanslara dayanan bir bant filtresi ile filtrelenir.

Pothole olayı zaman alanında şöyle görünür:

FFT'de 10 ila 15HZ bileşeninin ne olduğundan emin değilsiniz, gerçek çukur mu yoksa tekerleklerin yola karşı tekerlek zıplaması mı yoksa arabanın rezonans frekansı mı?

FFT:

gerçek çukur olayları gibi görünüyor, işte bir HPF @ 13HZ Çukurların baskın özellikleri gelişmiş görünüyor

Çukurları gerçek zamanlı olarak tespit edip sayabilmek istiyorum

Süspansiyonun 10 ila 13 HZ'den çok daha yavaş hareket etmesi gerektiğine inanıyorum, bu da hareket hastalığına neden olacak.

GÜNCELLEME:

AngryEE'nin önerilerine göre, ivmeölçer 1000HZ'nin tam bant genişliğini ve arduinoda alabileceğim maksimum örnekleme oranını kullandım.

FFT:

Burada çukur olayının örnek bir veri parçası ve etrafındaki bazı çarpmalar ve yol gürültüsü:

Diyot zarf dedektörü devresi eklendi, çıkış aynı görünüyor ... İvmeölçer her zaman 0 ila 3.3Volts negatif değil ...

GÜNCELLEME:

Birçok yol testinden, Z eksenindeki arabamda 1.6G'yi 45 MPH'ye kadar aşmadım, sahte Gforce hızlandırması oluşturmak için rand () kullandım.

Benim fikrim, 1 ila 3 saniyelik veri pencerelerine bakabilirsem, Z ekseninin yer değiştirmesini hesaplayabilirim, ancak ivmeölçer sapması ve entegrasyondaki hatalar hakkında endişeliydim. Burada% 90 bile doğru olmam gerekmiyor,>% 70 iyi olurdu, ancak bir seferde bir ila üç saniyede yer değiştirmeye bakıyorsam, bu gerçek zamanlı olarak mümkün olabilir mi? Bu şekilde yer değiştirmenin 1 inç, 2 inç, 5 inçten daha büyük olup olmadığını görebilirim. Yer değiştirme ne kadar büyük olursa, yumru veya çukur o kadar sertti:

Bunu doğru yapıp yapmadığımı kontrol edebilir misiniz, temelde masaüstümde, -1.6 ila 1.6 G'lardan rastgele hızlanma oluşturmak için 3 saniye veri simüle edilmiş bir 50HZ örnekleme oranı yakalayarak rand () kullanarak kurdum

* Nix'i çalıştırırsanız, 20mS gecikmesini, 50HZ örnekleme oranını yapmak için Windows.h'den Sleep () kullanıyorum

Ben sadece kod size doğru görünüyorsa görmek istedim, henüz cicular tampon yapmadım, nasıl uygulamak konusunda biraz karışık: yorum kodu, üzerinde çalıştığım sınıftan , ama henüz% 100 anlamıyorum. Dairesel bir arabellek veri pencerelerini bitişik olarak hareket ettirmeye izin verir mi?

#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;
}

Örnek çalışma:

    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 . . .

Bu, oldukça düz ileri filtreleme ile çözülebiliyor gibi görünüyor. İşte orijinal verileriniz:

Bu, bireysel bir etkinlikte neler olduğunu görmek için burada uygun ayrıntı düzeyinde çok fazla. İşte sadece 26-28 arasındaki veriler:

Başlangıçta bunu düşük geçişli filtreyi düşünmüştüm, ama bu işe yaramıyor çünkü orada düşük frekanslı bir sinyal yok. Bunun yerine yüksek frekans sinyalinin genliği artar. Orijinalin üzerine yerleştirilmiş bir alçak geçiş:

Bu, çukur olayı sırasında değil, sinyalin "ortalama" sını izler. Bu ortalamayı orijinal sinyalden çıkarırsak, etkinlik sırasında bu ortalamadan diğerlerine göre çok daha yüksek geziler kalırız. Başka bir deyişle, gerçekten istediğimiz bir yüksek geçiş filtresi. Bunu orijinalden düşük geçişi çıkararak yapacağız, çünkü buraya geldik, ancak bir üretim sisteminde bunu açıkça yüksek geçişli filtreleme ile yapardınız. Her neyse, işte yüksek geçişli filtrelenmiş orijinal:

Bu şimdi olayı tespit etmek için bariz bir yaklaşıma işaret ediyor. Etkinlik sırasında diğerlerinden çok daha fazla sinyal genliği vardır. Bunu, RMS'yi hesaplayıp bazı düşük geçişli filtreleme uygulayarak tespit edebiliriz:

Tüm verilere geri dönüp baktığımızda şunu görüyoruz:

Bu, verilerdeki beş olayı açıkça tanımlar, ancak bu verilerin ne göstermesi gerektiğini bilmiyorum. Olaylara daha yakından baktığınızda, her bir zirveden yaklaşık 1 saniye önce ve sonra düşük düşüşler olduğunu fark ettiniz. Bu, RMS sinyalini şimdi yeterince iyi olmadığı için eşiklemek gerekirse daha fazla şey yapılabileceği anlamına gelir. Örneğin, her iki şekilde de 1 saniye içinde en düşük noktaya göre bir noktanın yüksekliğini arayan basit bir algoritma, arka plan gürültüsünü daha da azaltmalıdır. Aynı şey hakkında söylemenin başka bir yolu, bu sinyali 1 saniyelik bir artış için arayan farklılaştırmaktır. Bir çukur olayı daha sonra bir çiftle tespit edilir, yani yüksek bir tepe düşük bir tepe tarafından follwed edilir.

Buna bakmanın bir başka yolu, RMS sinyalini bant geçirmektir. Zaten düşük geçiş filtreli, ancak güçlü eğimli ani olaylar aradığınız için, düşük frekansların bazılarının durdurulması da arka plan gürültüsünü azaltmak için çalışmalıdır.

Sinyali buradan düzeltmenin birçok yolu var, ama umarım en azından ilk geçişte faydalı bir sonuca nasıl ulaşacağımı gösterdim.

Katma:

Bir zirvenin her iki tarafında dips aramanın ne kadar iyi olacağını merak ettim, bu yüzden denedim. Önceki çizimden RMS ile başlayan doğrusal olmayan bir filtre kullandım. Her bir noktanın değeri, bir önceki saniyedeki en düşük noktanın ve bir sonraki saniyedeki en düşük noktanın ne kadar yüksek olduğu minimumdur. Sonuç oldukça iyi görünüyor:

5 zirvenin en düşükü, en yüksek arka plan gürültüsünden 3 kat fazladır. Bu, elbette, bu 5 çarpmanın tespit etmek istediğiniz olayları temsil ettiğini ve geri kalanının olmadığını varsayar.

Yorumlara yanıt olarak eklendi:

Filtreleri zaman alanında yaptım, bu yüzden frekans tepkisini doğrudan bilmiyorum. Alçak geçiren filtre için giriş sinyalini bir COS ^ 2 filtre çekirdeğiyle kıvrıldım. Doğru hatırlıyorsam, çekirdeğin yarıçapı (merkezden kenara mesafe) birkaç 100 ms olarak. Arsa iyi görünene kadar değeri denedim. RMS'yi düşük geçişli filtre etmek için aynı filtre çekirdeğini kullandım, ancak bu sefer yaklaşık bir saniyelik bir yarıçapla. Tam olarak hatırlamıyorum. İyi sonuçlar elde edene kadar deneme yapın.

Doğrusal olmayan filtre çiftleri tespit etmedi. Söylediğim gibi, daha önce 1 saniye içinde mevcut nokta ile tüm noktaların en düşük değeri arasındaki farkı ve sonraki 1 saniye içinde geçerli nokta ile en düşük nokta arasındaki farkı buldum. Sonra bu ikisinin minisini aldım.

Kullandığım yazılım bu amaçla kullandığım bir programdı. Zaten CSV dosyalarını okumak ve yazmak için çeşitli rutinleri vardı, bu yüzden yazmak zorunda olduğum tek şey çok basit filtreleme kodu oldu. Geri kalanı, CSV dosyalarını manipüle etmek ve çizmek için önceden var olan programlarla yapıldı.

Kenar algılama çukurları sorun istiyor olabilir. Otomobilin titreşim zarfı, cevabın yattığı yerdir, çünkü sensör tarafından görülen gerçek titreşimler çok daha yüksek frekanslardadır. Ben yaklaşık 15Hz veya daha yüksek ve düşük bir şey geçmek yanıt RMS DC gitmek istiyorum.

Bir frekans etki alanı filtresi veya bir eşik aramak yerine, "tipik" bir çukur için bir çekirdek bulmaya çalışmanızı ve bununla çalışan bir ilişki kurmanızı öneririm. Şablon eşleştirme tekniği olarak kabul edilir ve kendini mikrodenetleyici platformuna borçlu gibi görünür.

Hızlı bir inceleme için http://scribblethink.org/Work/nvisionInterface/vi95_lewis.pdf adresine bakın ve belki DOBBS, STEVEN E., NEIL M. SCHMITT ve HALUK S. OZEMEK. "Bir mikrobilgisayar üzerinde gerçek zamanlı korelasyon kullanarak şablon eşleme ile QRS algılama." Klinik mühendisliği dergisi 9.3 (1984): 197-212.

Daha iyi bir platformda olsaydınız, dalgacıklara bir dönüş vermenizi tavsiye ederim.

Başka bir yaklaşım, çukurların gerçekten çıkıp çıkmadığını görmek için sinyalin hareketli bir varyansını hesaplamak olacaktır. İşte hareketli bir varyans filtresi için bir matlab fonksiyonu, N geniş - akıllıca (eğer kendim söylemeliysem) hesaplama için bir evrişim kullanarak

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));

İlk düşüncem, düşük geçişli bir filtrenin kullanılacak yanlış filtre türü olabileceğidir. Derin çukur aslında bir adım fonksiyonu veya kare dalga gibi yüksek frekanslı bir olaydır. Sadece 50Hz filtrelenmiş verilere bakmak, çukur hakkındaki bilgileri kaybettiğinizi düşündürüyor - çukur olayı için önemli bir ayrım olmaksızın hepsi aynı dalgalı çizgiler gibi görünüyor. İlk önce bir yüksek geçirgen filtre, daha sonra çok daha yüksek frekanslı bir düşük geçiren filtre kullanırım. İvmeölçer zaten düşük geçirgen filtreli ise, düşük geçiş filtresinden tamamen kaçınabilirsiniz.

Yüksek geçişli filtrelenmiş verilere sahip olduğunuzda, uygun bir eşik değerine sahip basit bir karşılaştırıcının çukurların neden olduğu hızlanma verilerindeki zirveleri seçeceğini ve bunları saymanıza izin vereceğini düşünüyorum.