Die Funktion zur Tonerzeugung soll zwei Aufgaben erfüllen: Sie soll eine Liste mit den zu sendenden Bits in eine Sequenz von Sinustönen umwandeln. Diese Sequenz besteht aus einer Abfolge von zwei Tönen mit jeweils einer Frequenz für die 0 und die 1 und einer festgelegten Taktlänge. Zum anderen soll sie auf einer dritten Frequenz eine Folge von Tönen und Pausen senden, deren Länge jeweils dem Sendetakt entsprechen. Diese Taktfrequenz wird zur Taktrückgewinnung bei der Tonverarbeitung genutzt.

Es wird zuerst über den Rest der Teilung der Indizes von l durch 2 eine Folge von abwechselnd Nullen und Einsen erzeugt. Diese Liste besitzt die gleiche Länge wie l und dient zur Erzeugung des Taktsignals. Dann werden jeweils eine Liste für das Datensignal (signale) und das Taktsignal (taktsignale) angelegt. Diese Listen enthalten die Daten für die Erzeugung der jeweils zwei verschiedenen Elemente der Signale. Also zwei verschiedene Sinustöne beim Datensignal und ein Sinuston und eine Pause beim Taktsignal. Mithilfe dieser Listen werden nun die endgültigen Signale in Form der Listen signal und taktsignal erstellt. Dafür wird jeweils die Liste l bzw. t durchgegangen. Je nach dem ob es dich um eine 0 oder 1 handelt wird der entsprechende Ton der jeweiligen Liste hinzugefügt. Zum Schluss werden die beiden endgültigen Signale noch überlagert und mit playsnd aus schallwerkzeuge.py abgespielt.

def code(l):
	'''erzeugt aus der Bit-Liste l Töne und Taktsignal'''
	f_0 = 13000 # Frequenz zur codierung der 0
	f_1 = 12800 # Frequenz zur codierung der 1
	f_takt = 12600 # Taktfrequenz
	dauer_bit = 0.05 # Dauer des Signals für 1 Bit in Sekunden
	t = [] # List zur Speicherung des Taktsignals
 
	for i in range(0, len(l)): # Erzeugung des Taktsignals mit der Länge von l
		t.append(i%2)
 
	# Erzeugen der Sinus-Signale
	signale=[sinewave(f_0, RATE, dauer_bit),sinewave(f_1, RATE, dauer_bit)]
	taktsignale=[sinewave(f_takt, RATE, dauer_bit), np.zeros(dauer_bit*RATE)]
 
	signal=np.concatenate([signale[x] for x in l])
	taktsignal = np.concatenate([taktsignale[x] for x in t])
 
	signal = (signal+taktsignal)/2
	playsnd(signal,RATE)

Die Variante B funktioniert ähnlich wie Variante A, allerdings wird hier von Anfang an die vier auftretenden Fälle unterschieden und ausgehend davon die Töne erzeugt. Wir wissen, dass jeder Datentyp ein Vielfaches von 4 als Bit-Anzahl besitzt und damit eine gerade Anzahl hat. So endet bei einem ständigen Wechsel zwischen An/Aus die Takt-Frequenz immer gleich. Wenn wir nun neben der 0 und 1 Codierung eine Takt-Frequenz als zusätzliche Info miteinbringen wollen, so kommen wir auf 4 verschiedene Kombinationen an Tönen. Die erhaltene Bit-Liste aus der Datei wird deshalb umgeschrieben. Durch die Hinzugabe der Takt-Frequenz geht die 0 und 1 Codierung auch nicht verloren, da die Frequenzen keine Auswirkungen aufeinander haben. Sehr wichtig ist, dass auf jeder geraden Stelle der Liste die Takt-Frequenz gespielt wird, damit es auch damit endet. Dies ist für die Taktrückgewinnung relevant!

Legende:

0: 0-Codierung ohne Takt-Frequenz
1: 1-Codierung ohne Takt-Frequenz
2: 0-Codierung mit Takt-Frequenz
3: 1-Codierung mit Takt-Frequenz

def code(l):
	'''erzeugt aus der Bit-Liste l Töne'''
 
	a=0
 
	for y in l:
		if y == 0 and a%2 == 1: #jeder ungerade index wird geändert
			l[a] = 2
		if y == 1 and a%2 == 1: #jeder ungerade index wird geändert
			l[a] = 3
		a+=1
 
	# Erzeugung der Sinus-Signale
	signale=[sinewave(f_0, RATE, dauer_bit),sinewave(f_1, RATE, dauer_bit),(sinewave(f_0, RATE, dauer_bit)+sinewave(f_t, RATE, dauer_bit))/2,(sinewave(f_1, RATE, dauer_bit)+sinewave(f_t, RATE, dauer_bit))/2]
	signal=np.concatenate([signale[x] for x in l])
	playsnd(signal,RATE)