Dieses erste funktionsfähige Programm sollte zeigen, dass die Idee der Datenübertragung per Schall grundsätzlich umsetzbar ist. Das Programm besteht hauptsächlich aus den zwei Funktionen code und decode.

In code, der „Sende-Funktion“, werden für die binären Elemente 1 und 0 jeweils eine Frequenz definiert. code übersetzt nun eine übergebene Liste l mit Bits in eine Sequenz von Sinustönen unter Benutzung der Funktion sinewave aus schallwerkzeuge.py, welche dann mit playsnd, ebenfalls aus schallwerkzeuge.py, über die Lautsprecher ausgegeben werden.

def code(l):
	'''erzeugt aus der Bit-Liste l Töne'''
	f_0 = 2000 # Frequenz zur Codierung der 0
	f_1 = 1800 # Frequenz zur Codierung der 0
	dauer_bit = 0.1 # Dauer des Signals für 1 Bit in Sekunden
	# Erzeugen der Sinus-Signale
	signal_0 = sinewave(f_0, RATE, dauer_bit)
	signal_1 = sinewave(f_1, RATE, dauer_bit)
 
	for x in l: # Aussenden der Signale für jedes Bit, entweder 0 oder 1
		if x == 0:
			playsnd(signal_0, RATE)
		else:
			playsnd(signal_1, RATE)

Die Funktion decode stellt die Empfängerseite dar. Ihr wird eine Aufnahme in Form der Liste y übergeben. Diese Aufnahme wird nun in sehr kleine Abschnitte zerlegt, die wesentlich kürzer als die Dauer eines Bits sind. Nun wird für jeden dieser Abschnitte die Diskrete Fourier-Transformation durchgeführt, deren Ergebnis angibt wie „stark“ jede einzelne Frequenz in einem Abschnitt vorhanden ist, also ihre Intensität. Nun wird für jeden Abschnitt überprüft, ob der Intensitäts-Wert bei der jeweilige Frequenzen zur Codierung einer 0 oder 1 über einer festgelegten Schranke liegt. Falls ja werden die folgenden Abschnitte, die theoretisch ebenfalls zum gleichen gesendeten Bit gehören müssen, ebenfalls auf das Vorhandensein der codierenden Frequenz geprüft. Ist in mindestens 50% der Abschnitte ebenfalls die Frequenz in starker Intensität vorhanden wird je nach Frequenz eine 0 oder 1 in die Ergebnis-Liste s geschrieben und die Überprüfung geht dort weiter, wo das Ende des gesendeten Bits vermutet wird. Ist das Ende der Aufnahme erreicht wird die fertig decodierte Ergebnis-Liste s zurückgegeben.

def decode(y):
	'''erzeugt aus der Aufnahme y eine Liste der übertragenen Bits'''
	f_0 = 2000 # Frequenz zur Codierung der 0
	f_1 = 1800 # Frequenz zur Codierung der 1
	schranke = 0.5 # Wert, ab dem Signal auf Frequenz als vorhanden gewertet wird
	s = [] #Liste für fertig decodierte Bits
	f = [] # Liste zum Zwischenspeichern nach der abschnittweisen Fourier-Transformation
	n = 100 # Anzahl der Abschnitte, in welche eine Sekunde der Aufnahme geteilt wird
	v = 10 # Anzahl der Abschnitte, in welche ein Bit-Signal geteilt wird
 
	for i in  range(0, len(y), int(RATE/n)): # abschnittsweise Fourier-Transformation der Aufnahme
		a = FFT.fft(y[i:int(i+RATE/n)])
		f.append((a*np.conjugate(a)).real) # umwandeln der Werte von komplex in reell
 
	skip_idx = 0 # Variable, die angibt wie viele Indizes übersprungen werden sollen
	for x in range(0, len(f)):
		if skip_idx > 0: # wenn skip_idx > 0, überspringe skip_idx-mal Überprüfung der Frequenzen, da noch zum 'alten' Bit gehörend
			skip_idx -= 1
		elif f[x][f_0/n] > schranke: # wenn Wert bei Frequenz f_0 > schranke ...
			a = 0 # Anzahl der Abschnitte, die Signal enthalten
			for h in range(0, v): # ... prüfe in welchen der nächsten v-1 Abschnitte Signal ebenfalls vorhanden
				if f[x+h][f_0/n] > schranke:
					a += 1
			if a >= v*0.5: # ... und wenn >= 50% der Abschnitte Signal enthalten...
				s.append(0) # ... schreibe eine 0 in s
				skip_idx = v - 1 # ... und setze skip_idx auf v - 1
		elif f[x][f_1/n] > schranke: # äquivalent für Wert bei Frequenz f_1
			a = 0
			for h in range(0, v):
				if f[x+h][f_1/n] > schranke:
					a += 1
			if a >= v*0.5:
				s.append(1)
				skip_idx = v - 1
	return s

Mit dem entstandenen Prototypen konnten wir die grundsätzliche Umsetzbarkeit unseres Projekts zeigen. Allerdings war uns schon von vornherein klar, dass die Einteilung in sehr kleine Abschnitte aufgrund des hohen Rechenaufwands keine endgültige Lösung ist und wir uns ein System zur Rückgewinnung des Sendetaktes überlegen müssen.