Benutzer-Werkzeuge
ss15:taktrueckgewinnung_1.2
Unterschiede
Hier werden die Unterschiede zwischen zwei Versionen gezeigt.
| Beide Seiten der vorigen Revision Vorhergehende Überarbeitung Nächste Überarbeitung | Vorhergehende Überarbeitung | ||
|
ss15:taktrueckgewinnung_1.2 [2015/10/06 18:51] m.schramm [1. Problem:] |
ss15:taktrueckgewinnung_1.2 [2016/05/10 14:46] (aktuell) |
||
|---|---|---|---|
| Zeile 13: | Zeile 13: | ||
| <code python> | <code python> | ||
| - | y=recordsnd(None,t) | + | def takt_finder(y): |
| - | b, a = signal.butter(4, [(f_t-100)*2./RATE, (f_t+100)*2./RATE], btype="bandpass") | + | '''liefert Liste mit Indizes der Taktflanken''' |
| - | yf = signal.lfilter(b,a,y) # Taktfrequenzfilter | + | takt = 0.05*RATE |
| - | yh = np.abs(signal.hilbert(yf)) # Hilbert-Funktion | + | f_takt = 12600 |
| + | mind = 0.005 | ||
| + | minl = 16 | ||
| + | idx = [] | ||
| + | |||
| + | b, a = signal.butter(4, [(f_takt-100)*2./RATE, (f_takt+100)*2./RATE], btype="bandpass") # Parameter für Butterworth-Filter | ||
| + | yf = signal.lfilter(b,a,y) # Taktfrequenzfilter | ||
| + | yh = np.abs(signal.hilbert(y)) # Hilbert-Transformation | ||
| + | # [...] | ||
| </code> | </code> | ||
| Zeile 50: | Zeile 58: | ||
| \\ | \\ | ||
| === Variante 2 === | === Variante 2 === | ||
| - | Die Variante 1 wirft allerdings ein Problem auf: Wurde im untersuchten Abschnitt kein Signal aufgenommen, d.h. es herrscht nahezu Stille auf der Taktfrequenz, wird diese Stille mit ihrem ganz geringen Grundrauschen trotzdem auf den üblichen Wert verstärkt. Das führt dann aber dazu, dass Takt-Flanken erkannt werden wo gar keine sind. Deshalb erachte ich es für sinnvoller eine minimale Grenze zu definieren, ab dem das Taktsignal als vorhanden gewertet wird und die Grenze zur Erkennung wie gehabt über das Maximum oder ähnlich zu berechnen. | + | Die Variante 1 wirft allerdings ein Problem auf: Wurde im untersuchten Abschnitt kein Signal aufgenommen, d.h. es herrscht nahezu Stille auf der Taktfrequenz, wird diese Stille mit ihrem ganz geringen Grundrauschen trotzdem auf den üblichen Wert verstärkt. Das führt dann aber dazu, dass Takt-Flanken erkannt werden wo gar keine sind. Deshalb erachte ich es für sinnvoller eine feste minimale Grenze zu definieren, ab dem das Taktsignal als vorhanden gewertet wird und die Grenze zur Erkennung wie gehabt über das Maximum oder ähnlich zu berechnen. |
| + | <code python> | ||
| + | # [...] | ||
| + | ma = max(yh) | ||
| + | if ma > mind: | ||
| + | s = ma/5 | ||
| + | tol = 0.002 * ma | ||
| + | idx = np.where(np.abs(yh-s)<tol) | ||
| + | # [...] | ||
| + | </code> | ||
| ==== 2. Problem: ==== | ==== 2. Problem: ==== | ||
| Zeile 66: | Zeile 83: | ||
| übertragen. Der momentane Index wird mit dem nächstkommenden Index auf seinen | übertragen. Der momentane Index wird mit dem nächstkommenden Index auf seinen | ||
| Abstand überprüft und nur als 'richtig' übertragen, wenn diese im Taktabstand | Abstand überprüft und nur als 'richtig' übertragen, wenn diese im Taktabstand | ||
| - | mit einer Toleranz von +-10% vom Taktabstand zueinander stehen. Somit fallen | + | mit einer Toleranz von +-5% vom Taktabstand zueinander stehen. Somit fallen |
| - | sofort alle Indices raus, dessen Abstand ungleich des Taktabstandes zum | + | sofort alle Indizes raus, deren Abstand ungleich des Taktabstandes zum |
| nächsten Index ist, also die der gleichen Flanke angehören oder die den | nächsten Index ist, also die der gleichen Flanke angehören oder die den | ||
| 'falschen' Flanken angehören, die sich zwischenmogeln könnten. | 'falschen' Flanken angehören, die sich zwischenmogeln könnten. | ||
| Zeile 108: | Zeile 125: | ||
| Indices gefüllt. | Indices gefüllt. | ||
| + | <code python> | ||
| + | # [...] | ||
| + | v=[] # alle Indices um Grenze | ||
| + | h=[] # Sortierung der Indices aus v nach nur richtigen Takt-Flanken | ||
| + | e=[] # Hilfliste zur Ergänzung von Takt-Flanken, falls richtige Takt-Flanken nicht auffindbar (Lückenliste) | ||
| + | n=0 # Zähler für v-Liste | ||
| + | m=0 # Zähler für h-Liste | ||
| + | k=0 # Zähler für falsche Takt-Flanken in v-Liste | ||
| + | v.extend(np.array(idx).flatten().tolist()) | ||
| + | |||
| + | for x in v: | ||
| + | n+=1 | ||
| + | if n==len(v): | ||
| + | for x in sorted(v,reverse=True): # v-liste von hinten nochmal durchgehen, damit letzte Takt-Flanke noch in h hinzugefügt wird | ||
| + | if h[-1]+takt+0.1*takt>x and h[-1]+takt-0.05*takt<x: | ||
| + | h.append(x) # die letzte richtige Taktflanke | ||
| + | break | ||
| + | elif x+takt+0.05*takt>v[n] and x+takt-0.05*takt<v[n]: # nächste Flanke ist einen Takt mit Toleranz von +-5% entfernt | ||
| + | if k!=0 and v[n-k-1]+takt+0.05*takt>x and v[n-k-1]+takt-0.05*takt<x: | ||
| + | h.append(v[n-k-1]) # vergangene richtige Takt-Flanke, die nun durch einer nachfolgenden Takt-Flanke gefunden wurde | ||
| + | h.append(x) | ||
| + | k=0 # Neustart nach neuer gefundenen richtigen Takt-Flanke | ||
| + | else: | ||
| + | k+=1 # merke um wieviele Flanken wir uns von pot. richtigen Takt-Flanke entfernen | ||
| + | |||
| + | for x in h: # Lückenfüller von richtigen Takt-Flanken | ||
| + | m+=1 | ||
| + | if m==len(h): | ||
| + | h=sorted(h+e) # fülle Lücken in der richtigen Takt-Liste | ||
| + | break | ||
| + | elif not (x+takt+0.05*takt>h[m] and x+takt-0.05*takt<h[m]): # findet Lücken | ||
| + | e.append(int(x+takt)) | ||
| + | return h | ||
| + | </code> | ||
| ====Resultat:==== | ====Resultat:==== | ||
| Wir erhalten die genauen Zeitpunkte eines Wechsels der Lautstärke der Takt-Frequenz und damit lässt sich die Takteinteilung des Signals ablesen. | Wir erhalten die genauen Zeitpunkte eines Wechsels der Lautstärke der Takt-Frequenz und damit lässt sich die Takteinteilung des Signals ablesen. | ||
| - | |||
| - | __Bilder folgen noch!__ | ||
ss15/taktrueckgewinnung_1.2.1444150314.txt.gz · Zuletzt geändert: 2016/05/10 14:46 (Externe Bearbeitung)
Seiten-Werkzeuge
