Analisando as características dos dados do acelerômetro e projetando um filtro

13

Eu tenho cerca de 32 segundos no valor de dados do acelerômetro de um cenário básico de condução de 25 MPH em estradas normais, além de atingir cerca de 7 buracos e um trecho áspero da estrada. O acelerômetro é montado no painel de instrumentos do meu carro com fita dupla face.

Problema: tenho todos os dados barulhentos do acelerômetro e preciso criar uma maneira simples de detectar que um evento ocorreu. Abaixo estão vários gráficos de dados no domínio do tempo e FFT. O acelerômetro está medindo no GForce

Basicamente, quero que meu arduino saiba que ocorreu um buraco com uma precisão bastante grande e que não usa técnicas e matemática de nível de pós-graduação.

O acelerômetro amostrado a 100 hz possui um simples filtro de baixa frequência RC de 50 HZ no Eixo Z

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

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

ATUALIZAÇÃO: Esta é a largura de banda RAW completa do acelerômetro 1000HZ amostrada na taxa de amostragem mais alta que eu poderia obter no Arduino. Download direto do arquivo CSV: cerca de 112 segundos de dados

http://hamiltoncomputer.us/RAWUNFILTEREDFULLBANDWIDTH500HZ.csv

O traço preto é um dado RAW não filtrado do acelerômetro: o traço azul é filtrado por um filtro de parada de banda com base nas frequências extremas encontradas em FFT, Dominate 2HZ e 12HZ.

http://img213.imageshack.us/img213/194/rollout.png

O evento Pothole se parece com isso no domínio do tempo: insira a descrição da imagem aqui

Não tenho certeza qual é o componente de 10 a 15HZ na FFT, é o buraco real, ou é o salto das rodas contra a estrada ou a frequência de ressonância do carro?

FFT:

FFT

parece que são os eventos reais do buraco, aqui está um HPF @ 13HZ As características dominantes dos buracos parecem aprimoradas

http://img69.imageshack.us/img69/8663/hpf13potholefft.png

Eu quero ser capaz de detectar e contar os buracos em tempo real

Parece ser contra-intuitivo que a suspensão deva se mover muito mais devagar que 10 a 13 HZ, o que causaria enjôo, acredito

ATUALIZAR:

De acordo com as sugestões do AngryEE, usei toda a largura de banda do acelerômetro 1000HZ e a taxa máxima de amostragem que pude obter no arduino.

FFT:

DADOS NÃO FILTRADOS FFT LARGURA DE BANDA

aqui está uma amostra de dados do evento buracos e alguns solavancos e ruídos da estrada ao seu redor:

EVENTO NÃO PILOTO DE DADOS

Adicionado o circuito detector do envelope de diodo, a saída parece a mesma ... O acelerômetro sempre gera 0 a 3,3Volts não negativos ... insira a descrição da imagem aqui

ATUALIZAR:

Em muitos testes de estrada, nunca ultrapassei os 1,6 G até 45 MPH no meu carro no eixo Z, usei rand () para gerar aceleração pseudo-aleatória do Gforce.

Minha idéia é que, se eu puder olhar para janelas de dados de 1 a 3 segundos, eu puder calcular o deslocamento do eixo Z, mas estava preocupado com a deriva do acelerômetro e com os erros na integração. Não preciso ser nem 90% preciso aqui,> 70% seria bom, mas se eu estiver olhando para o deslocamento de um a três segundos por vez, isso seria possível em tempo real? Dessa forma, posso ver se o deslocamento é maior do que 1 polegada, 2 polegadas, 5 polegadas. Quanto maior o deslocamento, maior o impacto ou o buraco:

Você pode verificar se estou fazendo isso direito? Basicamente, configurei na minha área de trabalho usando rand () para gerar aceleração aleatória de -1,6 a 1,6 G, capturando 3 segundos de dados em uma taxa de amostragem simulada de 50 Hz

Se você rodar * nix, estou usando o Sleep () do Windows.h para fazer o atraso de 20 ms, a taxa de amostragem de 50 Hz

Eu só queria ver se o código parece certo para você, ainda não fiz o buffer cicular, estou meio confuso sobre como implementá-lo: o código comentado é da classe em que estou trabalhando nele , mas ainda não o entendo 100%. Um buffer circular permitiria mover contiguamente janelas de dados, certo?

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

Exemplo de execução:

    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 . . .
zacharoni16
fonte
3
Escrita bem detalhada. No entanto: editar isso para indicar uma pergunta específica e relativamente estreita ajudaria a obter respostas focadas.
Anindo Ghosh
Escrevi uma pergunta específica geral, preciso de uma maneira de detectar que um buraco ocorreu a partir de um sinal de acelerômetro barulhento. Extraindo recursos úteis ou método de detecção que permitiria um microcontrolador como o Arduino para detectar o evento buraco tivesse ocorrido em tempo real
zacharoni16
Como o evento do buraco é mais lento do que as vibrações que existem, independentemente do buraco, você provavelmente deve fazer o LPF em vez disso e aprimorar o bom solavanco que está chegando perto do buraco. Um filtro de média móvel pode ser capaz de fazer isso. Para facilitar a vida, você também pode considerar usar o valor abs da medida antes de aplicá-la ao LPF, já que seu buraco parece ser caracterizado por um único pacote com amplitude de envelope aprimorada, modulada pela frequência de vibração do carro.
Chintalagiri Shashank
Informações atualizadas, obrigado e eu estarei trabalhando na média móvel, a ressonância da suspensão parece estar em torno de 12,5HZ ??? o LPF no hardware teria um corte em torno de lá eu diria
zacharoni16
Forneça um bom exemplo de arquivo CSV ou algo assim. Onde você diz que os dados estão disponíveis acima não parece funcionar como um link.
Olin Lathrop

Respostas:

12

Parece que isso pode ser resolvido com uma filtragem bastante direta. Aqui estão seus dados originais:

É demais ver o que acontece em um evento individual no nível de detalhe apropriado aqui. Aqui estão apenas os dados do segundo 26 ao 28:

Eu pensava originalmente em filtrar passa-baixo isso, mas isso não funciona porque não há um sinal de baixa frequência lá. A amplitude do sinal de alta frequência aumenta em seu lugar. Aqui está um passe baixo sobreposto ao original:

Observe que isso segue muito bem a "média" do sinal, não durante o evento do buraco. Se subtrairmos essa média do sinal original, ficaremos com excursões muito mais altas dessa média durante o evento do que o contrário. Em outras palavras, o que realmente queremos é um filtro passa-alto. Para fazer isso, subtraímos o passe baixo do original, pois foi assim que chegamos aqui, mas em um sistema de produção, você faria isso por meio de filtragem explicitamente passa alta. De qualquer forma, aqui está o original com filtro passa-alto:

Isso agora aponta uma abordagem óbvia para a detecção do evento. Há muito mais amplitude de sinal durante o evento do que o contrário. Podemos detectar isso calculando o RMS e aplicando alguma filtragem passa-baixo:

Fazendo um zoom de volta para todos os dados, vemos:

Isso identifica claramente cinco eventos nos dados, embora eu não saiba se é isso que esses dados devem mostrar. Observando os eventos mais de perto, você percebe que cada um deles tem quedas baixas cerca de 1 segundo antes e depois dos picos. Isso significa que mais pode ser feito se o limiar do sinal RMS como está agora não for bom o suficiente. Por exemplo, um algoritmo simples que procurou a altura de um ponto em relação ao ponto mais baixo dentro de 1 segundo de qualquer maneira deve reduzir ainda mais o ruído de fundo. Outra maneira de dizer sobre a mesma coisa é diferenciar esse sinal procurando o aumento durante um período de 1 segundo. Um evento de buracos seria então detectado por um dupleto, significando um pico alto seguido por um pico baixo.

Outra maneira de ver isso é passar o sinal RMS em banda. Já é filtro passa-baixo, mas como você está procurando eventos repentinos com fortes inclinações, cortar algumas das baixas frequências também deve funcionar para reduzir o ruído de fundo.

Existem várias maneiras de refinar o sinal a partir daqui, mas espero ter mostrado como obter pelo menos um resultado útil de primeira passagem.

Adicionado:

Eu estava curioso para saber como a procura de mergulhos de ambos os lados de um pico funcionaria, então tentei. Usei um filtro não linear começando com o RMS do gráfico anterior. O valor de cada ponto é o mínimo de quanto está acima do ponto mais baixo no segundo anterior e do ponto mais baixo no segundo seguinte. O resultado parece muito bom:

O menor dos 5 picos é mais de 3 vezes maior que o maior ruído de fundo. É claro que isso pressupõe que esses 5 saliências representam eventos que você deseja detectar e o resto não.

Adicionado em resposta aos comentários:

Eu fiz os filtros no domínio do tempo, então não conheço a resposta de frequência diretamente. Para o filtro passa-baixo, convolvi o sinal de entrada com um núcleo de filtro COS ^ 2. Se bem me lembro, o raio (distância do centro à borda) do kernel é de apenas 100 ms. Eu experimentei o valor até o enredo parecer bom. Para filtro passa-baixo do RMS, usei o mesmo núcleo de filtro, mas desta vez com um raio de cerca de um segundo. Não me lembro exatamente. Experimente até obter bons resultados.

O filtro não linear não detectou dupletos. Como eu disse, encontrei a diferença entre o ponto atual e o menor de todos os pontos dentro de 1 segundo antes, e também a diferença entre o ponto atual e o menor de todos os pontos dentro de 1 segundo depois. Então eu peguei o min desses dois.

O software que usei foi um programa que hackeei para esse fim. Eu já tinha várias rotinas para ler e gravar arquivos CSV, então tudo o que eu precisava escrever era o código de filtragem, que é muito simples. O resto foi feito com programas pré-existentes que tenho para manipular e plotar arquivos CSV.

Olin Lathrop
fonte
WOW, isso é resultados muito empolgantes, você tem uma ótima maneira de explicar as coisas em termos práticos e estou animado para chegar em casa e começar a trabalhar nisso! Estou curioso para saber qual a frequência de corte que você usou no HPF e o ponto de corte LPF para o sinal RMS que parece perfeito. Além disso, o filtro não linear que você usou para detectar os dupletos, você fez isso no matlab ou em um aplicativo de design? Também quero tentar projetar isso em hardware, os 5 picos que você está recebendo coincidem com os 5 buracos que atingi, ótimo resultado! Eu tenho Matlab e também vindo a utilizar SciDAVis
zacharoni16
@zach: Vou tentar atualizar minha resposta para resolver algumas de suas perguntas. Infelizmente, minha resposta foi convertida em wiki da comunidade, então estou aguardando um mod para corrigir isso primeiro. Essa coisa da CW realmente é péssima quando você gasta tempo com alguma coisa, e de repente você não a possui mais.
Olin Lathrop
@OlinLathrop Você o converterá novamente quando o editar. Você deve sinalizar para revertê-lo quando terminar de editar. Farei isso agora, mas não se surpreenda se precisar sinalizar novamente. Na nota de reclamação sobre a CW, precisamos revertê-la uma vez a cada 4-6 meses, acho que você está falando de um caso muito estreito de situação em que existem tantas edições e o usuário não deseja ser a CW, e comparado a lidar com Tony ou alguma outra situação, trata-se da bandeira ideal para lidar, corte fácil e limpo. :) #
30513 Kortuk
1
@ Andrew: Como eu disse no último parágrafo da minha resposta, tenho vários programas enlatados que manipulam arquivos CSV e rotinas de bibliotecas que facilitam a leitura e gravação. A adição de código de filtragem acima é rápida e fácil. A maioria dos filtros são apenas algumas linhas de código executadas várias vezes. Para um teste único, como o que fiz acima, não há necessidade de usar o processador com eficiência, pois tudo termina instantaneamente. Por exemplo, chamei a função COS sempre que necessário, em vez de criar uma tabela.
Olin Lathrop
1
@OlinLathrop Vi o que você mencionou na resposta, mas não sabia se havia alguns scripts personalizados configurados, talvez matlab ou algo para executá-lo ou o que você fez. Você poderia compartilhar como está fazendo isso? Parece fascinante. Você está usando bibliotecas de gráficos enlatados para visualizar a saída, apenas despejando e plotando no Excel ou usando gnuplot / oitava ou ...?
akohlsmith
2

Os buracos na detecção de bordas podem estar causando problemas. O envelope de vibração dos carros é onde está a resposta, pois as vibrações reais vistas pelo sensor estão em frequências muito mais altas. Eu iria com RMS para DC, que responde a cerca de 15Hz ou superior e passa baixo a coisa.

Chintalagiri Shashank
fonte
Acabei de fazer outro teste com largura de banda total do sensor de 1000HZ e amostrar o mais rápido que pude em série com o Arduino. Obtendo resultados semelhantes. Qualquer frequência acima de 17HZ desaparece rapidamente em comparação com a frequência dominante de 2HZ e 13HZ. Ainda não entendo de onde vêm as coisas de 9 a 13,5HZ. O acelerômetro está montado no painel, a suspensão não está obviamente se movendo das 9 às 13HZ ou eu estaria pulando como um louco. Não sei ao certo o que você quer dizer sobre RMS para DC?
precisa saber é o seguinte
O seu acelerômetro está conectado de alguma forma ao carro. Mesmo que você tenha aparafusado de alguma forma ao material rodante, os parafusos podem suprimir e amplificar as frequências. Um carro é um animal suficientemente complexo para que as coisas vibrem em muitas frequências diferentes. Existem circuitos (e provavelmente algoritmos matemáticos) que convertem um sinal CA em seu valor DC RMS. Uma pesquisa deve encontrar uma. Isso pode ajudá-lo a gerar o envelope do seu sinal, transformando as vibrações de alta frequência em sua amplitude.
Chintalagiri Shashank
Que tal um retificador de meia onda (diodo)? mas isso converteria tudo em picos positivos, o evento de buracos puxa -Gs ou isso não seria um problema?
precisa saber é o seguinte
Não espero que seja um problema. Suas amplitudes de vibração parecem ser altas o suficiente para serem o efeito dominante. No entanto, observando seus sinais, sugiro uma retificação de onda completa para evitar a perda dos buracos menores.
Chintalagiri Shashank
Shashack Adicionado o circuito de envelope postado acima, a saída não mudou muito. Eu escolhi a constante de tempo RC em torno de 2mS, estou amostrando a 2mS 500 amostras / segundo A tensão do acelerômetro está sempre entre 0 e 3,3V embora ... nunca fique negativa para que o diodo não funcione?
precisa saber é o seguinte
2

Em vez de procurar um filtro no domínio da frequência ou um limite, recomendo tentar criar um kernel para um buraco "típico" e fazer uma correlação contínua com ele. Seria considerado uma técnica de correspondência de modelos e pareceria se prestar a uma plataforma de microcontrolador.

Veja http://scribblethink.org/Work/nvisionInterface/vi95_lewis.pdf para uma revisão rápida e talvez DOBBS, STEVEN E., NEIL M. SCHMITT e HALUK S. OZEMEK. "Detecção de QRS por correspondência de modelos usando correlação em tempo real em um microcomputador." Jornal de engenharia clínica 9.3 (1984): 197-212.

Se você estivesse em uma plataforma mais robusta, eu recomendaria dar uma volta nas wavelets.

Scott Seidman
fonte
Obrigado :), isso parece muito difícil de fazer, ou estou faltando alguma coisa?
precisa saber é o seguinte
Mais difícil do que um simples filtro, mas é mais provável que ele faça o que você deseja quando terminar! Por todos os meios, não tentar implementá-lo em um microcontrolador até que você tem que trabalhar em algo como Matlab ou R
Scott Seidman
Para executar seu "filtro" em tempo real, você provavelmente o manipularia como uma convolução, em vez de realizar uma multiplicação no domínio da frequência a cada passo do tempo. Uma correlação cruzada (uma abordagem principal para a correspondência de modelos) seria a mesma operação exata, exceto que a escala de tempo da resposta ao impulso não seria invertida como seria em uma convolução e chamaríamos essa resposta de impulso de "modelo" . Agora, você só precisa descobrir o que esse modelo precisa ser.
Scott Seidman
Obrigado por esta resposta, vou ter que fazer muito mais pesquisa e estudo para implementá-la, pois parece estar acima do meu nível de habilidade atual. I apreciam o esforço embora
zacharoni16
2

Outra abordagem seria calcular uma variação móvel do seu sinal para ver se os buracos realmente se destacam. Aqui está uma função matlab para um filtro de variação móvel, N aponta largamente - de forma inteligente (se devo dizer assim) usando uma convolução para cálculo

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));
Scott Seidman
fonte
Isso seria semelhante a um cálculo de desvio padrão?
precisa saber é o seguinte
sim, apenas ao quadrado
Scott Seidman
1

Meu pensamento inicial é que um filtro passa-baixo pode ser o tipo errado de filtro a ser usado. O buraco é essencialmente um evento de alta frequência - como uma função de passo ou onda quadrada. Basta olhar para os dados filtrados de 50Hz e me fazer pensar que você está perdendo as informações sobre o buraco - tudo parece os mesmos rabiscos, sem distinção significativa para o evento do buraco. Eu usaria primeiro um filtro passa-alto, depois um filtro passa-baixo com uma frequência muito maior. Você pode evitar completamente o filtro passa-baixo se o seu acelerômetro já estiver filtrado.

Depois de ter os dados filtrados de alta passagem, acho que um comparador simples com um limite definido adequadamente selecionará os picos nos dados de aceleração causados ​​pelos buracos e permitirá que você os conte.

AngryEE
fonte
Vou tirar o filtro RC 50HZ e o acelerômetro usará um LPF padrão de 500HZ ou 1000HZ que deve ser alto o suficiente para obter a vibração mecânica. Vou aumentar a taxa de amostragem de 100HZ para 1000HZ e postar mais dados. Agradecimentos para o insight
zacharoni16
Eu usei a largura de banda total do acelerômetro e mais rápido amostragem, parecem estar recebendo dados semelhantes :( Isso é confuso sobre como filtro e isolar o buraco e bater eventos
zacharoni16
Eu disse para usar um filtro passa-alto, não um filtro baixo. Eu ficaria interessado em ver uma FFT dos dados não filtrados.
precisa saber é o seguinte
Bem, o acelerômetro foi construído em 1000HZ LPF e não posso mudar isso. Vou postar em breve a FFT dos dados não filtrada
zacharoni16
Você não precisa mudar isso - você quer as altas frequências que surgem da aceleração abrupta quando você bate em um buraco, mas não o balanço suave da marcha normal. Seu sinal parece ser caracterizado por uma vibração de baixa frequência com vários picos transitórios importantes. Você deseja que as altas frequências capturem os picos transitórios rápidos, mas deseja rejeitar as baixas frequências constantes. Portanto, você provavelmente deve filtrar tudo em 50Hz ou 100Hz.
precisa saber é o seguinte