Ich brauche nochmal hilfe.
Ich hab nochmal neu ein wave2bitstream implementiert. Nun nach dem Schmitt-trigger prinzip. Ziel ist es, von dem
even_odd weg zu kommen und automatisch zu synchronisieren.
Aktueller Stand hier:
https://github.com/jedie/PyDragon32/blo ... tstream.py
Diesmal sind es mehrmals hintereinander geschaltete Interatoren:
1. iter_wave_values() - yield Frame Nummer und Amplituden-Wert (alter code) ->
https://github.com/jedie/PyDragon32/blo ... am.py#L194
2. iter_trigger() - yield Frame Nummer nach dem Schmitt Trigger Prinzip:
Code: Alles auswählen
def iter_trigger(self, iter_wave_values, half_sinus):
"""
yield only the triggered frame numbers
simmilar to a Schmitt trigger
"""
last_state = False
for frame_no, value in iter_wave_values:
if last_state == False and value > self.trigger_value:
yield frame_no
last_state = True
elif last_state == True and value < -self.trigger_value:
if half_sinus:
yield frame_no
last_state = False
->
https://github.com/jedie/PyDragon32/blo ... am.py#L179
3. iter_duration() - Berechnet die Zweiten zwischen den getriggerten Frames:
Code: Alles auswählen
def iter_duration(self, iter_trigger):
"""
yield the duration of two frames in a row.
"""
old_frame_no = next(iter_trigger)
for frame_no in iter_trigger:
duration = frame_no - old_frame_no
yield (frame_no, duration)
old_frame_no = frame_no
->
https://github.com/jedie/PyDragon32/blo ... am.py#L169
4. iter_bitstream() - Aus den Zeiten werden einsen und nullen (alter code) ->
https://github.com/jedie/PyDragon32/blo ... am.py#L106
Nun fehlt noch das synchronisieren zwischen den Halb-Sinus-Wellen... Dazu hatte ich zwei Ideen:
1. Man nimmt einen Teil des Bitstream und schaut nach dem Leading-Byte Muste wie 0101010...
2. Man schaut sich die Zeiten der Halbwellen an und überlegt ob die Zusammen passen.
Hab mich für die zweite Lösung entschieden, weil sie unabhängig vom verwendeten Leading-Byte Muster ist (Das kann man dann später suchen)...
Dazu habe ich eine, nicht so besonders optimierte Lösung:
Code: Alles auswählen
def diff_info(data):
"""
>>> diff_info([5,5,10,10,5,5,10,10])
(0, 15)
>>> diff_info([5,10,10,5,5,10,10,5])
(15, 0)
"""
def get_diff(l):
diff = 0
for no1, no2 in iter_steps(l, steps=2):
diff += abs(no1 - no2)
return diff
data1 = data[2:]
diff1 = get_diff(data1)
data2 = data[1:-1]
diff2 = get_diff(data2)
return diff1, diff2
->
https://github.com/jedie/PyDragon32/blo ... ls.py#L246
Also die Idee, ist, das im Bitstrom die Halb-Sinus-Wellen-Dauer immer die selbe Zeit haben (mit Toleranzen natürlich).
Ein Beispiel:
Beim Dragon ist eine 1 ~ 2400Hz und 2 ~ 1200Hz
Die Dauer wäre dann, weil es einfach ist: 1==10 und 0==20
Die Halbwelle ist halt die hälfte also nehmen wir mal die Beispielwerte 1/2 1==5 und 1/2 0==10 an...
Der Bitstrom ...,1,0,1,0,... wäre dann also diese Zeiten der Halbwellen:
...,5,5,10,10,5,5,10,10,...
Wenn es nicht synchron ist, dann sind die Werte um eine Halbwelle verschoben, also beispielsweise:
...,5,10,10,5,5,10,10,5,...
Mit
diff_info() kann man das dann feststellen. Sie DocTest darin...
Die Idee war nun, das man vor dem eigentlichen Auslesen einen Test machen
sync() und dann evtl. eine Halbwelle weiterspringt.
Genau das klappt aber z.Z. nicht, siehe:
https://github.com/jedie/PyDragon32/blo ... eam.py#L73
Für das "Weiterspringen" dache ich mir, lese ich einfach einen Wert aus und gut ->
https://github.com/jedie/PyDragon32/blo ... eam.py#L89
Tut es aber nicht.
Warum?
):
