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.

• 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

!!!! immer 0 oder 1 schreiben !!!!

def decode(y, idx):
	'''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
	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)
 
 
 
	for x in f:
		if x[f_0] > s0:
			l.append(0)
		elif x[f_1] > s1:
			l.append(1)
		else:
			l.append(1)
 
 
 
	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)