FIR in C programmieren

[Matt (Gast)]

Guten Abend,

ich bin gerade dabei einen FIR Filter in C zu programmieren.
Wie kann man diese Gleichung siehe Anhang in ein C Programm 
implementieren?

[2921 (Gast)]

Was das steht hast du begriffen ? Wo ist die Schwierigkeit ? Bei der 
Mathe oder beim C ?

[tom (Gast)]

da steht nix anderes als

y(k) = a(0)*x(k) + a(1)*x(k-1) + a(2)*x(k-2) + ... + a(i)*x(k-i)

du musst einfach nur deinen aktuellen digitalisierten wert x(k) mit 
filterkoeffiezient a(0) multiplizieren, den um eine abtastperiode 
zurückliegenden wert x(k-1) mit filterkoeffizient a(1) usw. zum schluss 
alles aufsummieren und als ergebnis y(k) abspeichern.

[Matt (Gast)]

Ich hab es mal gestern Abend noch probiert. Bin da nicht weitergekommen.
Zuerst tue ich alle x-Werte spiegeln bzw. drehen. Dann summiere ich auf. 
Irgendwie ist der Code misst.

[Hannes (Gast)]

Kann es sein das mit dem Stern die Faltung gemeint ist und nicht 
Multiplikation?

[Helmi (Gast)]

Schau mal hier

Hier kannst du dir eine Software downloaden die dir direkt C - Code
generiert

http://www.winfilter.20m.com/

Gruss Helmi

[Matt (Gast)]

Hat niemand von euch schonmal so einen FIR Filter in C programmiert?

Der Stern bedeutet hier eine Multiplikation.

[----- (Gast)]

Vielleich kannst du damit was anfangen.

public double[] Fir(double[] x, double[] a)
{
  double[] y = new double[x.Length - a.Length];
  for (int k = 0; k < y.Length; k++)
  {
    for (int i = 0; i < a.Length; i++)
      y[k] += a[i] * x[k + i];
  }
  return y;
}

[tom (Gast)]

@ ----:
du hast nen fehler im code. es müsste in der zweiten for-schleife heißen
y[k] += a[i] * x[k - i];
sonst läufst du aus dem x[]-Array raus.

@Hannes:
könnte sein dass mit * die Faltung gemeint ist, aber so auf den ersten 
Blick würde ich sagen, dass ein FIR bzw. IIR doch meistens nur aus 
Addition und Multiplikation besteht so dass ich jetzt auf Multiplikation 
tippe.

[Gast (Gast)]

Faltung ist ein Vorgang der zu FFT gehört.
Bei IIR- unf FIR-Filter gibt es keine Faltung,
sondern nur Multiplikation und Addition.
Die meisten CPU-Hersteller haben Applikations-
beispiele zur FIR und IIR in C. Einfach mal
dort nachschauen.
Vorsicht bei der AVR Application Note zu IIR -
da steckt ein Fehler drin.

[Gunb (Gast)]

@Gast:

Faltung ist eine mathematische Operation, die zur Ermittlung der 
Ausgangsfunktion bei gegebener Übertragungsfunktion eines Systems und 
der  am Eingang des Systems anliegenden Eingangsfunktion dient.

Der Faltung im Zeitbereich entspricht nach Fourier-Transformation die 
Multiplikation im Frequenzbereich. Das hat erst einmal nichts mit der 
Fast Fourier Transformation zu tun, sondern ist eine allgemeine 
Operation.

Dasselbe mit Laplace, da Fourier der Laplace-Transformation auf der 
imaginären Achse entspricht.

Mit FFT hat das nur nebensächlich zu tun, die Faltung ist im allgemeinen 
zur Systembeschreibung in der Nachrichtentechnik und der 
Regelungstechnik nötig.

Die FFT wird angewendet, um die Rechenzeit auf Controllern oder DSPs zu 
minimieren.

Zum Falten zweier Funktionen ist die Transformation in den 
Frequenzbereich nicht unbedingt notwendig, vereinfacht die Sache aber 
eventuell dadurch, dass im F-Bereich der Faltung die Multiplikation 
entspricht. Bei Verwendung von Tabellen oder bekannten einfachen 
Faltungen kann auf die Fourier-Transf. aber auch verzichtet werden.

Nur der Vollständigkeit und Richtigkeit halber.

Gruss
Gunb

[Gast (Gast)]

@Gunb
Weiter oben wurde gemutmaßt, es könnte sich bei dem
Operator * um Faltung handeln.
Faltung benutze ich in FFT, aber nicht in FIR und IIR.
Mehr wollte ich nicht sagen.
Deinen Ausführungen habe ich nichts hinzuzufügen, außer
dass sie mit meiner Aussage nicht im Widerspruch stehen.

[Thomas (Gast)]

@Gast:
schreib doch hier bitte nicht über Dinge, von denen du gar keine Ahnung 
hast!
Eine diskrete Faltung im Zeitbereich besteht nur aus Multiplikationen 
und Additionen.
Und ein FIR-Filter ist eine Faltung!
Die Formel ganz oben lässt sich auch als Faltung ausdrücken:

$$y=a*x$$

[Gast (Gast)]

@Thomas
Danke für die Aufklärung, dass der Operator "*" oben
nicht für eine Multiplikation steht, sondern für eine
Faltung.

[Matt (Gast)]

public double[] Fir(double[] x, double[] a)
{
  double[] y = new double[x.Length - a.Length];
  for (int k = 0; k < y.Length; k++)
  {
    for (int i = 0; i < a.Length; i++)
      y[k] += a[i] * x[k + i];
  }
  return y;
}

Die berechneten Werte werden ja in dem double Array y abgelegt.
Anschließend müssen doch noch alle Werte in dem Array aufsummiert 
werden.
Ist das korrekt so?

[----- (Gast)]

Die Funktion Fir funktioniert schon, da gibt es keinen Überlauf. Denn 
der Index k geht nur bis x.Length - a.Length. Ist vielleich nicht sehr 
elegant funktioniert aber.

Die Funktion Faltet x mit a als Resultat erhälst du eine neue Funktion 
y, da muss nichts aufsummiert werden.

[Thomas (Gast)]

Ach Gast, jetzt stell dich doch bitte nicht noch dümmer, als du bist.
Niemand hier hat was gegen dumme Fragen oder Mutmaßungen, aber hier 
grobe Falschaussagen zu einem Thema von dem man offenbar nicht allzu 
viel versteht als Fakt darzustellen ist nicht lustig. Kein Grund hier 
den Trotzkopf zu spielen.


http://de.wikipedia.org/wiki/Faltung_%28Mathematik%29
http://de.wikipedia.org/wiki/Schnelle_Faltung

[Noch ein Gast (Gast)]

Bevor hier noch mehr verwirrung aufkommt:

Der FIR-Filter ist eine Faltung im Zeitbereicht.
Die Rechenvorschrift oben ist sozusagen diese Faltungssumme.
Das '*' ist hier aber eine Multiplikation.

[Unbekannt (Gast)]

Es ist eine Faltung von zeitdiskreten Signalen nicht zu verwechseln mit 
kontinuierlichen Signalen(obwohl da eine gewisse Analogie besteht).

Man faltet also zwei Folgen a[n] und x[n] miteinander im "Zeitbereich 
(genauer im Zeitdiskreten Bereich) und bekommt y[n]. Das mit dem * ist 
eine Multiplikation da eine Faltung im Zeitbereich IMMER eine 
Multiplikation ist, weil man sonst nicht im Zeitbereich falten könnte, 
ich werde das jetzt auch nicht näher Begründen weil es einfach 
mathematisch so ist!!!!!!

Das * dient eigentlich zu Symbolik das man es mit einer Faltung zu tun 
hat hier ein Bsp. y(t)=(g*f)(t) Funtkion g wird mit Funtkion f gefaltet 
mehr bedeutet das nicht, das blöde ist nur das man mit den 
Schreibporgrammen das Malzeichen auch mit * darstellt, deshalb kommt es 
hier zu Irrtümern.


Hier nochaml ein Überblick: für zeitkontinuierliche und zeitdiskrete 
Signale gibt es Zwei Möglickeiten um auf die Lösung zu kommen.


Zeitkontinuierliches Signal ---> 1.Laplace ---> Rücktransformation
                                 2.Faltung mit corelation "Integral"

Zeitdiskretes Signal        ---> 1.z-Transformation ---> Rücktransform.
                                 2.Faltung über die "Summenbildung"
                                   (das was du oben abgebildet hast)




Vielleicht hilft dir auch das Programm unten weiter.

#include <stdio.h>
#include <stdlib.h>

long int a[100];
long int b[100];
long int cM[100][100];
long int c[100];

int n;
int k;
int i;

int main(int argc, char *argv[])
{

 //Faltung von Folgen im Zeitdiskreten-Bereich

  for(n=0; n<=20; n++) 
  {
     for(k=0; k<=20; k++)
      {
           
           //Folge a[n]
           a[0]=0;
           a[1]=1;
           a[2]=1;
           a[3]=1; 
           a[4]=0; 
           a[k+5]=0; //Rest = 0
          
          
           //Folge b[n]
           b[0]=0;
           b[1]=1;
           b[2]=1;
           b[3]=0; 
           b[4]=0; 
           b[k+5]=0; //Rest = 0                
          
          
          i=k-n;
          
          if (i>=0) // Summe fängt bei i=0 an (keine Negative Werte)!!!!
          {  
                               
           c[k] = c[k] + (a[n]*b[i]);   //Faltung

           }
           
           
     
  
           
       }
   }
  
  
  //Ausgabe der Folge c[k] auf dem Bildschirm
             printf("Faltung von an * bn = cn \n\n");
             
       for(k=0; k<=20; k++)
       {
            
             printf("a[%d] = %d    b[%d]= %d        c[%d] = %d\n",k,a[k],k,b[k],k,c[k]);
       }
             printf("\n\nBerechnung Ende \n\n");
  
  system("PAUSE");  
  return 0;
}

[A. B. (funky)]

nach 2 Jahren musste das jetzt wirklich mal gesagt werden ;))

[Samir D. (hota)]

FIR filter  in C implimentieren aber Parallelisieren mit OpenMP ??????

[Ein Gast (Gast)]

:D

[Michael W. (Gast)]

Samir D. schrieb:
> FIR filter  in C implimentieren aber Parallelisieren mit OpenMP

Grundsätzlich kann man das durchaus parallelisieren.
Ist hauptsächlich eine Frage der Stratgie der Threaderzeugung.

[Sinus T. (micha_micha)]

Oh Gott - nach 11.5 Jahren gibt immernoch Jemand seinen Senf dazu :-(

[Und noch einer (Gast)]

Ich glaube, das liegt daran, dass einem beim Eintippen neuer Fragen 
alte, ähnliche Beiträge vorgeschlagen werden. Ist dann die Frage ob man 
sich da dranhängt. Es hätte den Vorteil, dass jemand auch Antworten 
findet, wenn ihm zuerst der alte Faden ausgegeben wird.

>FIR in C programmieren

Man sollte erst mal festlegen, welcher Filter das sein soll, denn "FIR" 
sagt nicht viel, wie man nachlesen kann.