Die Tonverarbeitung besteht aus den zwei Komponenten Taktrückgewinnung und Decodierung. Die Taktrückgewinnung muss dabei zuerst ablaufen, da sie aus dem gesendeten Taktsignal den Sendetakt rekonstruiert, der enorm wichtig für die Decodierung ist, weil diese immer taktweise stattfindet. Die Taktrückgewinnung liefert den ermittelten zugrunde liegenden Sendetakt an die Decodierungsfunktion. Diese übersetzt nun den aufgenommenen Schall mithilfe des übermittelten Taktes in eine Liste von Nullen und Einsen, welche dann noch weiter verarbeitet werden kann. Eine dritte neu hinzu gekommene Komponente ist die Queue. Deren Aufgabe ist es ständig, aber kontrolliert stückweise Audio-Daten von der Soundkarte zu liefern, die dort vom Mikrofon ankommen. Diese zusätzliche Komponente ist nötig um eine ständige Aufnahme zu ermöglichen, bei der automatisch erkannt wird wann etwas gesendet wird und das Gesendete sofort decodiert wird.

• Taktrückgewinnung 1.0 (verworfen)
• Taktrückgewinnung 1.1
• Taktrückgewinnung 1.2

Die eigentliche Decodierung wird durch decode erledigt. Zu Anfang werden auch hier wieder wichtige lokale Variablen gesetzt, die aber auch global festgelegt werden könnten. Außerdem wird der Startindex und einige leere Listen zur späteren Verwendung definiert. Dann erfolgt die Diskrete Fourier-Transformation. Dafür wird der Index idx immer um die Taktlänge tl erhöht und die Fourier-Funktion immer auf dem Abschnitt zwischen aktuellem und vorigen Index angewendet. a enthält jetzt das Frequenz-Spektrum in diesem Abschnitt, allerdings benötigen wir nur den reellen Teil des Ergebnisses welches wir mit (a*np.conjugate(a)).real berechnen und an f anhängen. Nachdem alle Abschnitte in y abgearbeitete wurden werden die für uns interessanten Frequenzen f0 und f1 herausgeschrieben und in w0 bzw. w1 gespeichert. Anschließend werden die Schranken als Bedingung zur Bit-Listen-Berechnung. Zum Schluss wird noch geprüft ob f0 oder f1 im jeweiligen Abschnitt mit einer Intensität über dem Schranken-Wert vorhanden sind und so wird eine 0 oder 1 in l geschrieben, sodass man eine decodierte Bit-List erhält.

def decode(y, dt):
	'''erzeugt aus der Aufnahme y eine Liste der übertragenen Bits'''
	tdauer = 0.05 # Taktlänge in Sekunden
	tl = tdauer*RATE # Taktlänge in Samples
	f_0 = 12900*tdauer # Frequenz zur codierung der 0 umgerechnet für das Frequenz-Spektrum in f
	f_1 = 12800*tdauer # Frequenz zur codierung der 1 umgerechnet für das Frequenz-Spektrum in f
 
	idx = dt + tl # Startindex
	f = [] # Liste zur Speicherung des Frequenz-Spektrums
	l = [] # Liste für die fertig decodierten Bits
	w0 = [] # Liste zur Speicherung der Intensität bei f0 auf jeweiligen Abschnitten
	w1 = [] # Liste zur Speicherung der Intensität bei f1 auf jeweiligen Abschnitten
 
 
	while idx < len(y): # Abschnittsweise Diskrete Fourier-Transformation
		a = FFT.fft(y[idx-tl:idx+1])
		f.append((a*np.conjugate(a)).real)
		idx += tl
 
	for x in f: # Intensität bei Sendefrequenzen in jeweiligen Abschnitten
		w0.append(x[f_0])
		w1.append(x[f_1])
 
	s0 = max(w0)*0.1 # Berechnung der Schranke für intensität von f0
	s1 = max(w1)*0.1 # Berechnung der Schranke für intensität von f1
 
	for x in f: # Schreiben einer 0 oder 1 in Bit-Liste
		if x[f_0] > s0:
			l.append(0)
		elif x[f_1] > s1:
			l.append(1)
 
	return l

Diese Decodierungs-Funktion gleicht überwiegend der vorigen. Allerdings wird hier keine Taktverschiebung übergeben, sondern eine Liste idx mit konkreten Indizes zur Einteilung in Abschnitte. Nun werden die Indizes vom ersten bis zum vorletzen durchgegangen und die Diskrete Fourier-Transformation auf den Abschnitt vom jeweils aktuellen bis zum nächsten Index angewendet. Weiter geht es äquivalent zur anderen decode-Funktion.

def decode(y, idx):
	'''erzeugt aus der Aufnahme y eine Liste der übertragenen Bits'''
	f_0 = 12900*tdauer # Frequenz zur codierung der 0
	f_1 = 12800*tdauer # Frequenz zur codierung der 1
	f = []
	l = []
	w0 = []
	w1 = []
 
 
	for i in range(0, len(idx)-1):
		a = FFT.fft(y[idx[i]:idx[i+1]])
		f.append((a*np.conjugate(a)).real)
 
	# [...]

Da wir aufgrund der Taktrückgewinnung 1.2 davon ausgehen können, dass in allen Abschnitten auch wirklich etwas gesendet wurde machen wir eine kleine Änderung bei der Bit-Listen-Erzeugung um zu verhindern, dass hier Bits vollständig verloren gehen, weil beide Schranken s0 und s1 nicht erreicht werden. Man kann hier dann in einem else-Zweig ein beliebiges Bit setzen, welches dann von der Fehlerkorrektur behoben wird falls es falsch ist. Logischer und wahrscheinlich auch zuverlässiger ist es aber zu prüfen welche Frequenz mit größerer Intensität vorhanden ist und dann den zur größeren Intensität zugehörigen Bit-Wert zu setzen, wie in der alternativen Variante gezeigt.

	# [...]
 
	for x in f:
		if x[f_0] > s0:
			l.append(0)
		elif x[f_1] > s1:
			l.append(1)
		else:
			l.append(1)
 
	# oder alternativ:
 
	for x in f:
		if x[f_0] > s0:
			l.append(0)
		elif x[f_1] > s1:
			l.append(1)
		elif x[f0] > x[f1]:
			l.append(0)
		else:
			l.append(1)