Аналіз характеристик даних акселерометра та проектування фільтра

У мене є приблизно 32 секунди даних акселерометра базового сценарію водіння 25MPH нормальних доріг разом з ударом близько 7 вибоїн та грубої ділянки дороги. Акселерометр встановлений на приладовій дошці мого автомобіля з двосторонньою стрічкою.

Проблема: у мене є всі дані, що шуміть від акселерометра, і мені потрібно зробити простий спосіб виявити, що відбулася подія на вибої. Нижче наведено кілька графіків даних у часовій області та FFT. Акселерометр вимірюється в GForce

В основному я хочу, щоб мій ардуїно знав, що вибоїна сталася з досить великою точністю і не використовуючи математику та методики випускників рівня.

Акселерометр, відібраний на 100 Гц, має простий фільтр низькочастотного пробігу 50 Гц на осі Z

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

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

ОНОВЛЕННЯ: Це повна пропускна здатність RAW акселерометра 1000 Гц, відібрана з найвищою швидкістю вибірки, яку я міг отримати на Arduino. Пряме завантаження файлу CSV: близько 112 секунд даних

http://hamiltoncomputer.us/RAWUNFILTEREDFULLBANDWIDTH500HZ.csv

Чорний слід - це нефільтровані дані про акселерометр RAW: Синій слід відфільтрований смуговим фільтром на основі екстремальних частот, виявлених у FFT, Dominate 2HZ та 12HZ.

Подія на вибоїні виглядає так у часовій області:

не впевнений, що компонент від 10 до 15 Гц є у FFT, це те, що власне вибоїна, чи це перехід коліс коліс проти дороги, чи це резонансна частота автомобіля?

FFT:

здається, що це фактичні події на вибоїнах, ось HPF @ 13HZ Домінуючі особливості вибоїн здаються покращеними

Я хочу мати можливість виявляти та рахувати вибоїни в режимі реального часу

Здається, це протиінтуїтивно зрозуміло, що підвіска повинна рухатися набагато повільніше, ніж 10-13 Гц, що може спричинити недугу руху, я вважаю

ОНОВЛЕННЯ:

Відповідно до пропозицій AngryEE, я використав повну пропускну здатність акселерометра 1000 Гц і максимальну швидкість вибірки, яку я міг отримати на ардуїно.

FFT:

ось зразок даних про подію на вибої та деякі удари та шум навколо дороги:

Додано схему детектора конвертів конвеєра, вихід виглядає однаково ... Акселерометр завжди виводить 0-3,3Вольти не від'ємні ...

ОНОВЛЕННЯ:

З багатьох дорожніх тестів я ніколи не перевищував 1,6 Г до 45 МПГ у своєму автомобілі на осі Z, я використовував rand () для генерації псевдовипадкових прискорень Gforce.

Моя ідея: якщо я можу переглянути 1–3 секундні вікна даних, я можу обчислити зміщення осі Z, але мене турбував дрейф акселерометра та помилки в інтеграції. Мені тут не потрібно бути навіть 90% точним,> 70% було б добре, але якщо я дивлюсь на переміщення за одну-три секунди за один раз, чи можна це зробити в режимі реального часу? Таким чином я можу побачити, чи зміщення більше ніж 1 дюйм, 2 дюйми, 5 дюймів. Чим більше зміщення, тим грубішою була шишка або вибоїна:

Чи можете ви перевірити, чи правильно я це роблю, я в основному налаштувався на робочий стіл, використовуючи rand () для генерації випадкових прискорень від -1,6 до 1,6 G, захоплюючи 3 секунди даних @ модельовану частоту дискретизації 50 ГГц

Якщо ви запускаєте * nix, я використовую Sleep () від Windows.h, щоб зробити затримку 20mS, частоту дискретизації 50 ГГц

Я просто хотів побачити, чи правильно виглядає код у вас, я ще не робив цецелярний буфер, я настільки розгублений, як його реалізувати: коментований код - з класу, над яким я працюю , але я ще не розумію цього на 100%. Круглий буфер дозволив би безперервно переміщувати вікна даних, правильно?

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

Проба зразка:

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

Схоже, це можна вирішити досить фільтрами прямого руху вперед. Ось ваші вихідні дані:

Це занадто багато, щоб побачити, що відбувається в окремому заході, на рівні, що відповідає тут. Ось лише дані з 26 по 28:

Спочатку я думав, що це низькочастотний фільтр, але це не працює, оскільки там немає низькочастотного сигналу. Амплітуда високочастотного сигналу замість цього збільшується. Ось низький прохід, накладений на оригінал:

Зауважте, це випливає з "середнього" сигналу досить добре, не під час події на вибої. Якщо відняти це середнє значення від вихідного сигналу, ми залишаємось набагато вищими екскурсіями від цього середнього протягом події, ніж інакше. Інакше кажучи, те, що ми насправді хочемо, - це фільтр високих частот. Ми зробимо це, віднявши низький прохід від оригіналу, оскільки саме так ми потрапили сюди, але у виробничій системі ви зробите це шляхом явно високочастотної фільтрації. У будь-якому випадку, тут відфільтрований оригінал високого проходу:

Зараз це вказує на очевидний підхід до виявлення події. Під час події набагато більше амплітуди сигналу, ніж інакше. Ми можемо виявити це, обчисливши RMS та застосувавши фільтрування низьких частот:

Збільшивши всі дані, ми бачимо:

Це чітко ідентифікує п'ять подій у даних, хоча я не знаю, чи саме так мають бути показані ці дані. Придивляючись до подій уважніше, ви помічаєте, що кожен з них має низькі занурення приблизно за 1 секунду до і після піків. Це означає, що можна зробити більше, якщо просто порогове значення RMS-сигналу, як зараз, недостатньо добре. Наприклад, простий алгоритм, який шукав висоту точки відносно найнижчої протягом 1 секунди будь-яким способом, повинен додатково зменшити фоновий шум. Ще один спосіб сказати про те саме - це диференціювати цей сигнал, шукаючи підйому за 1 секунду. Потім подія на вибоїні буде виявлена ​​дублетом, що означає високий пік, який знижується низьким піком.

Інший спосіб дивитися на це - смуга передачі сигналу RMS. Це вже фільтр з низьким проходом, але оскільки ви шукаєте раптових подій із сильними нахилами, вимкнення деяких низьких частот має працювати також і для зменшення фонового шуму.

Існує маса способів уточнити сигнал звідси, але, сподіваюся, я показав, як досягти принаймні першого корисного результату.

Додано:

Мені було цікаво, наскільки добре шукати спринцювання з будь-якої сторони піку, то я спробував це. Я використовував нелінійний фільтр, починаючи з RMS з попереднього сюжету. Значення кожної точки є мінімальним, на скільки вона вище найнижчої точки на попередній секунді та найнижчої точки на наступній секунді. Результат виглядає досить непогано:

Найнижча з 5 вершин - в 3 рази вище, ніж найвищий фоновий шум. Звичайно, якщо припустити, що ці 5 ударів представляють події, які ви хочете виявити, а решта - ні.

Додано у відповідь на коментарі:

Я робив фільтри у часовій області, тому не знаю прямо частотної характеристики. Для фільтра низьких частот я ввімкнув вхідний сигнал ядром фільтра COS ^ 2. Якщо я пам'ятаю правильно, радіус (відстань від центру до краю) ядра становить декілька 100 мс. Я експериментував із цінністю, поки сюжет не виглядав добре. Для низькочастотного фільтра RMS я використовував те саме ядро ​​фільтра, але цього разу з радіусом близько секунди. Я точно не пам’ятаю. Експериментуйте, поки не отримаєте хороших результатів.

Нелінійний фільтр не виявив дублетів. Як я вже говорив, я виявив різницю між поточною точкою і найнижчою з усіх точок протягом 1 секунди раніше, а також різницею між поточною точкою і найнижчою з усіх точок протягом 1 секунди після. Тоді я взяв хвилину цих двох.

Програмне забезпечення, яке я використав, - це програма, яку я зламав для цієї мети. У мене вже були різні процедури для читання та запису файлів CSV, тому все, що мені потрібно було написати, - це код фільтрації, який дуже простий. Інше було зроблено за допомогою вже існуючих у мене програм для маніпулювання та побудови графічних файлів CSV.

Виявлення країв вибоїн, можливо, вимагає неприємностей. У вібраційній оболонці автомобілів лежить відповідь, оскільки фактичні коливання, які бачать датчик, знаходяться на значно більшій частоті. Я б поїхав з RMS в постійний струм, який реагує приблизно на 15 Гц або вище і низько пропускає річ.

Замість того, щоб шукати фільтр частоти домену або поріг, я рекомендую спробувати придумати ядро ​​для "типового" вибоїни і зробити кореляцію роботи з ним. Це вважалося б методом відповідності шаблонів і, здавалося б, піддалося платформі мікроконтролерів.

Див. Http://scribblethink.org/Work/nvisionInterface/vi95_lewis.pdf для швидкого огляду, і, можливо, DOBBS, STEVEN E., NEIL M. SCHMITT та HALUK S. OZEMEK. "Виявлення QRS за відповідності шаблонів з використанням кореляції в режимі реального часу на мікрокомп'ютері." Журнал клінічної інженерії 9.3 (1984): 197-212.

Якщо ви знаходитесь на платформі beefier, я б рекомендував розмотати вейвлетів.

Іншим підходом було б обчислення рухомої дисперсії вашого сигналу, щоб побачити, чи дійсно вибоїни стирчать. Ось функція matlab для фільтра з рухомою дисперсією, N точок шириною - спритно (якщо я повинен так сказати сам), використовуючи згортку для обчислення

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

Моя початкова думка полягає в тому, що фільтр низьких частот може бути неправильним типом фільтра. Вибоїна по суті є високочастотною подією - як крок або квадратна хвиля. Якщо дивитися на відфільтровані на 50 Гц дані, змушують мене думати, що ви втрачаєте інформацію про вибоїну - все це схоже на ті ж викрутаси, що не мають суттєвих відмінностей для події на вибої. Я б спочатку використовував високочастотний фільтр, потім фільтр низьких частот із значно більшою частотою. Ви можете взагалі уникнути низькочастотного фільтра, якщо ваш акселерометр вже фільтр низького проходу.

Після того, як ви отримаєте високопрохідні відфільтровані дані, я думаю, що простий компаратор із встановленим пороговим значенням дозволить вибрати піки даних про прискорення, спричинені вибоїнами, і дозволить вам їх порахувати.