“Filtro passa-baixo” em contextos de API de software não EE

Eu sou um engenheiro de software experiente e estou trabalhando em sensores de smartphone. Tomei aulas de EE fundamentais no DSP e estou tentando aplicar meu conhecimento. Acredito que compreendo convolução, funções de transferência, transformação z etc. Eu sei um pouco sobre filtros FIR e IIR.

Agora, ao ler as APIs e a documentação do software, vejo pessoas aplicando um LPF para sensor de dados no domínio do tempo. Eu sei que você faz isso através do uso de equações de diferença (por exemplo, y [i] = y [i-1] + 2 * x [i]), mas aprendi na minha classe de EE que o LPF é normalmente aplicado através da operação de convolução onde você envolve o sinal de tempo com os coeficientes de uma onda sinc (por exemplo) e com uma frequência de corte específica. Portanto, o uso coloquial de "filtro passa-baixo" não é exato o suficiente para mim.

Por exemplo, a API do Google Android possui esta documentação: http://developer.android.com/reference/android/hardware/SensorEvent.html#values

 public void onSensorChanged(SensorEvent event)
 {
      // alpha is calculated as t / (t + dT)
      // with t, the low-pass filter's time-constant
      // and dT, the event delivery rate

      final float alpha = 0.8;

      gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0];
      gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1];
      gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2];

      linear_acceleration[0] = event.values[0] - gravity[0];
      linear_acceleration[1] = event.values[1] - gravity[1];
      linear_acceleration[2] = event.values[2] - gravity[2];
 }

Como interpreto esse filtro passa-baixo? Qual é a frequência de corte? Qual é a largura de banda de transição? Eles estão usando esse LPF apenas para calcular a média?

filters filter-design software-implementation stackoverflowuser2010
fonte

bom isso me incomoda bem

Sibbs Gambling

Respostas:

O filtro no seu exemplo é um filtro de resposta de impulso infinito (IIR) de primeira ordem . Sua função de transferência é:

H (z) = \frac{1 - α}{1 - α z^{- 1}}

$H(z) = \frac{1 - \alpha}{1 - \alpha z^{-1}}$

que corresponde a uma equação de diferença de:

y [n] = α y [n - 1] + (1 - α) x [n]

$y[n] = \alpha y[n-1] + (1-\alpha) x[n]$

onde é a entrada do filtro e é a saída do filtro. $x[n]$ $y[n]$

Esse tipo de filtro é frequentemente usado como filtro passa-baixa de baixa complexidade e é frequentemente chamado de integrador com vazamento . É favorecido por sua implementação simples, baixa complexidade computacional e sua sintonização: sua frequência de corte depende do valor de . pode assumir valores no intervalo . não produz nenhuma filtragem (a saída é igual à entrada); medida que aumenta, a frequência de corte do filtro diminui. Você pode pensar em $\alpha$ $\alpha$ $[0,1)$ $\alpha = 0$ $\alpha$ $\alpha = 1$ como um caso de limite em que a frequência de corte é infinitamente baixa (a saída do filtro é zero para todo o tempo).

Você pode pensar nisso intuitivamente, observando que a entrada do filtro é ponderada por ; portanto, à medida que o parâmetro aumenta, a quantidade $\alpha$ $1-\alpha$ diminui, para que cada amostra de entrada tenha um efeito proporcional menor no valor de qualquer amostra de saída específica. Isso tem o efeito de diminuir a resposta de impulso do filtro por um longo período de tempo. A soma por um período mais longo é semelhante ao cálculo de uma média móvel longa. À medida que o comprimento de uma média móvel aumenta, a frequência de corte da média diminui.

Para o seu exemplo, onde , a resposta de frequência do filtro é a seguinte: $\alpha = 0.8$ insira a descrição da imagem aqui

Pelo exemplo, eu acho que esse filtro está sendo usado para suavizar o ruído de alta frequência de uma série temporal de medições de um sensor, tentando provocar um sinal de interesse comparativamente baixo. Essa seria uma aplicação muito típica para esse tipo de filtro.

Na sua outra sub-pergunta, você está certo de que a filtragem é frequentemente implementada via convolução do sinal de entrada com a resposta de impulso do filtro. Na maioria dos casos, isso é feito apenas com filtros de resposta finita ao impulso (FIR) . Filtros IIR como este são tipicamente implementados usando a equação de diferença do filtro; como a resposta de impulso de um sistema IIR é infinitamente longa, você deve truncá-lo em um comprimento finito para tornar a convolução com ele tratável, quando o filtro não é mais IIR. O formato da equação da diferença é quase sempre mais barato de implementar computacionalmente, embora o feedback inerente a essa estrutura possa levar a problemas numéricos que devem ser abordados (como excesso interno e acúmulo de erros de arredondamento).

Jason R
fonte

Obrigado! Algumas perguntas de acompanhamento: (1) Você disse que sua equação H (z) = ... é uma equação de diferença; é realmente uma função de transferência, certo? Eu pensei que uma equação de diferença é estritamente para o domínio do tempo. (2) No seu integrador com vazamento, 1.0 corresponde a sampling_frequency / 2 (como no Matlab)? (3) Em relação à FIR vs IIR, meu entendimento está correto de que a equação da diferença IIR pode ser aplicada em O (N), mas a convolução é O (N ^ 2) ou O (N lgN) com convolução baseada em FFT? (4) Você pode recomendar um livro para programadores de software implementarem essas idéias de DSP? Como o que o exemplo de código do Android está fazendo.

stackoverflowuser2010

π

$\pi$

+ π

$+\pi$

O (N)

$O(N)$

N

$N$

N

$N$

Eu sei que (i) aplicar a equação da diferença é O (N). Mas eu pensei que (ii) a operação de convolução usando a soma sobre multiplicar e adicionar (songho.ca/dsp/convolution/convolution.html) é O (N ^ 2) ou O (N lgN) com uma implementação baseada em FFT . Em todos os casos, N é a ordem do filtro - em que estou assumindo que a ordem do filtro e a duração do sinal de tempo são da mesma ordem de magnitude (por exemplo, ambas 256). Então (i) e (ii) não são diferentes? Além disso, vi o livro de Lyons na Amazon.com, mas esperava algo mais escrito para programadores de software C / Java.

precisa

O (N)

$O(N)$

N

$~N$

O (N^{2})

$O(N^2)$

M

$M$

N

$N$

O (M N)

$O(MN)$

M

$M$

N

$N$

Jason R

O (M \times (N + M))

$O(M \times (N+M))$

i \in N

$i \in N$

O (N^{2})

$O(N^2)$

O (N M)

$O(NM)$

Para resumir, os filtros IIR baseados em modelos físicos idealizados simples, como um filtro RC, têm um pequeno número de pólos e zeros e, portanto, são geralmente implementados como uma equação de diferença, pois um pequeno número de pólos ou zeros implica em poucas operações aritméticas por amostra usando uma equação de diferença.

Como um IIR implica uma resposta de impulso de comprimento infinito, a convolução exigiria uma computação eterna ou o uso de uma aproximação.

Os filtros FIR são geralmente implementados por convolução com a resposta de impulso de comprimento finito (ou por convolução rápida da FFT se o filtro for longo o suficiente para que seja computacionalmente eficiente). Esses tipos de filtros são mais frequentemente usados quando se pode aproximar uma especificação de resposta de frequência desejada com uma resposta de impulso de comprimento finito, em vez de saber onde os pólos e zeros do plano Z podem estar localizados.

No entanto, como um filtro com uma especificação precisa implica uma longa convolução FIR, a implementação dos filtros FIR pode ser muito mais lenta, e a configuração pode envolver muito mais linhas de código, e é por isso que os filtros FIR podem não ser usados com tanta frequência em software simples exemplos.

hotpaw2
fonte

Encontro-me voltando a este post uma e outra vez. Obrigado por fazer a pergunta. Aqui está uma ótima implementação computacionalmente amigável do integrador com vazamento em C (destinado a um microcontrolador).

Primeiro, algum rearranjo: y = α * x + (1 - α) * y_last = α * (x - y_last) + y_last

se restringirmos α a cerca de 12%, 25%, 50%, (1/8, 1/4, 1/2, ...). Podemos tirar proveito de algumas mudanças de bits eficientes. Tomando o caso de 1/8, 8 => 2 ^ 3 => (downshift 3 vezes)

= (x - y_last) / 8 + y_last

#define SMOOTHING_FACTOR       (3)

int16_t FilterSample(int16_t new_sample)
{
  static int16_t last_result = 0;

  // Each bit shift down is equivalent to dividing-by-two
  last_result = (new_sample - last_result) >> SMOOTHING_FACTOR) + last_result;

  return last_result;
}

Espero que ajude.

tarabyte
fonte