POPE

POPE passt auf

POPE steht für Permanent Orientation and Positioning Engine. POPE ist ein kombinierter GPS-, GLONASS- und BeiDou-Empfänger. Mit Hilfe von POPE wissen wir, welche Route unser Ballon geflogen ist. Und wir wissen die Höhe, in der sich unser Ballon an jedem Punkt seines Flugs befunden hat. Wie die anderen Mess- und Aufnahmegeräte (SAITE, ADAM und SPRUCE) leitet auch POPE seine Positions- und Höhenangben an CHICK weiter, der sie brav in die Datenbank schreibt. Für unsere Zwecke können wir keinen normalen GPS-Empfänger verwenden, den man beim freundlichen Geiz-ist-Geil-Händler um die Ecke gekauft hat. Um nämlich Abdul Baader-Böhnhardt den Bau seines privaten Marschflugkörpers ein bisschen zu vermiesen, verweigert ein "normales" ziviles Satellitennavigationsgerät seinen Dienst, wenn

die gemessene Höhe 18.000m übersteigt

ODER

die gemessene Geschwindigkeit 515m/s übersteigt

Pech für Abdul. Und Pech für uns, weil wir beim Bear Space Project ja davon ausgehen Höhen von 30.000m zu erreichen. Für unsere Zwecke gibt es spezielle GPS-Empfänger, die sich erst abschalten, wenn

die gemessene Höhe 18.000m übersteigt

UND

die gemessene Geschwindigkeit 515m/s übersteigt

Pech für Abdul, aber nicht für uns! Schließlich wollen wir keinen Geschwindigkeitsrekord brechen, aber wir wollen sehr weit nach oben...

Wir sind POPE

POPE ist ein Satelitennavigationsmodul vom Typ ublox MAX M8Q mit einer passiven Quad-V-Antenne. Die gesamte Elektronik ist auf einem Break-Out-Board verlötet, die Eingangsspannung beträgt 3,3V. Ähnlich wie SPRUCE hat auch POPE keinerlei Bedienungs- oder Anzeigeelemente. POPE spricht nur mit CHICK und mit EFA. Wenn wir POPE einstellen möchten, müssen wir CHICK anweisen unsere Konfiguruerungswünsche an POPE zu senden. Und alles, was POPE misst und ausgibt, wird an CHICK und EFA gesendet. POPE lässt sich entweder über den I²C-Bus oder eine serielle Schnittstelle mit CHICK verbinden. Den I²C-Bus kennt Ihr ja bereits von ADAM. Im Vergleich zum Auslesen und Schreiben von Registern ist die Programmierung der seriellen Schnittstelle ziemlich einfach. Und weil einfach weniger fehleranfällig ist als kompliziert, wird POPE mit dem UART-Anschluss von CHICK verdrahtet.

POPEs direkter Draht

Eigentlich tut POPE genau das, was er tun soll, wenn man ihn richtig an CHICK angeschlossen hat: POPE sendet Daten ohne dazu aufgefordert worden zu sein. Und eigentlich sind diese Daten sogar richtig brauchbar. CHICK erfährt laufend die Position in unterschiedlicher Ausführlichkeit, die zur Positionsfindung herangezogenen Satelliten, die Qualität des Signalempfangs jedes einzelnen Satelliten und noch vieles mehr.

Wie wird POPE an CHICK angeschlossen? Die Datenübertragung erfolgt über die UART-Schnittstelle von CHICK. UART steht für Universal Asynchronous Receiver Transmitter und ist eine serielle Schnittstelle. Hier gibt es eine Leitung zum Senden und eine zum Empfangen von Daten. In der Praxis bedeutet dies, dass POPEs Datenausgangspin (TX) mit dem jeweiligen Dateneingangspin von CHICK und EFA verbunden wird und dass POPEs Dateneingangspin (RX) mit dem Datenausgangspin von CHICK verbunden wird. Außerdem benötigt POPE noch Strom, und zwar 3,3V. Am einfachsten lässt sich die Stromversorgung über CHICK bewerkstelligen: Wir verbinden einen von CHICKs +3,3V-Pins mit VCC und GND mit GND. Damit aber EFA auch dann noch funktioniert, wenn CHICK ausfallen sollte, bekommt POPE seine eigene Stromversorgung.

POPE PUPst

Das ausschließlich für POPE eingerichtete separate Stromversorgungssystem heißt PUP. PUP steht für Power Up POPE. Hauptbestandteil von PUP ist ein Spannungswandler vom Typ Pololu D24V3F3.

Anders als bei IPS, dem Spannungswandler für CHICK und EFA, ist PUP lediglich ein Step-Down-Spannungswandler, d.h. er kann nur höhere Spannungen auf 3,3V herunter- nicht jedoch niedrigere Spannungen auf 3,3V hochregeln. Bei einer Ausgangsspannung von 6,0V aus vier in Reihe geschalteten AA-Batterien ist nicht zu erwarten, dass die Spannung einer einzelnen AA-Batterie auf unter 0,825V sinkt; ein Hochregeln niedrigerer Spannungen auf 3,3V ist damit nicht erforderlich.

POPE bekommt seine eigene Stromzufuhr, um JACKY so ausfallsicher wie möglich zu machen. Würden wir POPE über CHICKs GPIO mit Strom versorgen, würde POPE im Falle eines Systemamsturzes von CHICK nicht mehr mit Strom versorgt werden, würde daher auch keine Daten mehr liefern und auch EFA wäre damit funktionslos. Natürlich wünschen wir CHICK nichts Böses, schließlich sind wir gespannt auf JACKYs Fotos und die Messwerte, aber sollte CHICK tatsächlich ausfallen, würde JACKY mit EFA weiterhin seine Position an das Recovery-Team senden können.

POPE hat Sendungsbewusstsein

Um mit POPE etwas Sinnvolles in Python anfangen zu können, reicht import serial aus. POPE ist von Haus aus so eingestellt, dass er ungefragt und am laufenden Band Statusmeldungen sendet. Diese Statusmeldungen erfolgen im NMEA 0183-Protokoll. NMEA ist ein Datenprotokoll, das eigentlich zur Übertragung von Navigationsdaten zwischen nautischen Geräten konzipiert wurde. Die meisten Satellitennavigationssysteme beherrschen NMEA. Für uns hat NMEA zwei Nachteile:

Einige, eigentlich die meisten, Informationen benötigen wir nicht - z.B. einen ausführlichen Satellitenstatus
Es gibt mehrere Arten der Positionsmeldung, von denen keine alle von uns benötigten Informationen enthält.

Ein NMEA-Statement hat eine feste Struktur. Ansfangs steht ein $-Zeichen, dann folgt eine Art Bezeichner, aus dem man ersehen kann, von welchem Navigationssystellitensystem (GPS, GLONASS, etc.) die folgenden Informationen stammen sowie welche Art von Informationen folgen. Die Struktur (Reihenfolge und Länge) der daran anschließenden eigentlichen Daten wird durch den Bezeichner festgelegt. Am Ende eines NMEA-Statements steht eine Checksumme und ein Zeilenrücklaufkommando. Kein einzelnes dieser NMEA-Statements enthält alle Informationen, die wir benötigen.

Zum Glück verfügt POPE über ein weiteres, herstellerspezifisches, Datenformat, das UBX-Protokoll. Das UBX-Protokoll enthält eine Statusmeldung, die alle von uns benötigten Informationen enthält. Wir müssen also, sobald die Kommunikation zwischen CHICK und POPE möglich ist, alle NMEA-Outputs aus- und von den UBX-Meldungen, die eine für uns interessante einschalten. Der Aufbau der UBX-Statements ähnelt sehr den NMEA-Outputs. Die von uns benötigte UBX-Message hat folgenden Aufbau:

$PUBX,00,hhmmss.ss,Latitude,N,Longitude,E,AltRef,NavStat,Hacc,Vacc,SOG,COG, Vvel,ageC,HDOP,VDOP,TDOP,GU,RU,DR,*cs

Eine weitere wichtige Funktion, die POPE zukommt, ist das Festlegen der Systemzeit. CHICK verfügt über keine gepufferte Uhr. Wenn CHICK ausgeschaltet wird, vergisst es Datum und Uhrzeit und holt sich nach dem Einschalten und dem Login ins Internet die Systemzeit via ntp. Dort, wo unser Ballon starten soll, gibt es aber kein Internet und CHICK wüsste daher nicht, wie spät es ist. Und damit könnten wir allen Messwerten keine genaue Uhrzeit zuweisen. Zum Glück liefert POPE mit jeder Positionsmeldung atomuhrgenau Datum und Uhrzeit, so dass einmalig vor dem Start mit POPEs Hilfe CHICKs Uhr gestellt wird.

Vor alle dem dürfen wir auf keinen Fall vergessen, POPE in den Flugmodus zu versetzen, damit er uns auch oberhalb 18.000m Positionsdaten liefert.

All das geschieht in CHICKs Selbsttest- und Startroutine, in der alle angeshlossenen Module auf ihre Funktionsfähigkeit abgeklopft werden.

POPE und Python

Wenn alle Voreinstellungen für POPE vorgenommen sid, sieht der notwendige Python-Code so aus:

#! /usr/bin/python
import time
import datetime
from os import statvfs
import serial
import MySQLdb as mdb

# MySQL connection
con = mdb.connect(host="localhost", user="root", passwd="streng-geheim", db="flightlog")
cursor = con.cursor()

# Serial UART connection
ser=serial.Serial('/dev/ttyAMA0', 9600)

# Format fuer datetime
#t_format = "%Y-%m-%d %H:%M:%S.%f"
#datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")

# Festlegen der send- und empfangbaren Nachrichten
#Config PUBX
pubx_pos_poll = "$PUBX,00*33\r\n" #reply: $PUBX,00,hhmmss.ss,Latitude,N,Longitude,E,AltRef,NavStat,Hacc,Vacc,SOG,COG,Vvel,ageC,HDOP,VDOP,TDOP,GU,RU,DR,*cs<CR><LF>

#Holen einer Positionsangabe
def get_pos():
	#ser.write(pubx_pos_poll)
	msg_in = ser.readline()
	msg_list = msg_in.split(",")
	del msg_list [0:2]
	return msg_list

#Umwandeln der GPS-Zeit in mySQL-Format
def time_stamp(time_raw):
	d = datetime.datetime.now().strftime("%Y-%m-%d")
	h = time_raw[0:2]
	m = time_raw[2:4]
	s = time_raw[4:]
	t = h + ":" + m + ":" + s
	t_stamp = d + " " + t
	return t_stamp

# Formatieren der Positionsangaben in Dezimal-Grad
def form_pos(pos_raw):
	#print pos_raw
	#Erzeuge Zeitstempel
	t_stamp = time_stamp(pos_raw[0])
	print t_stamp
	
	#Umrechnen der Breite in Dezimalgrad
	lat_deg = float(pos_raw[1][0:2])
	lat_min = float(pos_raw[1][2:])
	if pos_raw[2] == "N":
		lat_ind = 1
	else:
		lat_ind = -1
	lat = lat_ind * (lat_deg + (lat_min / 60))
	
	#Umrechnen der Laenge in Dezimalgrad
	lon_deg = float(pos_raw[3][0:3])
	lon_min = float(pos_raw[3][3:])
	if pos_raw[4] == "E":
		lon_ind = 1
	else:
		lon_ind = -1
	lon = lon_ind * (lon_deg + (lon_min / 60))
	
	#Umrechnen der Hoehe in float in Metern
	alt = float(pos_raw[5])
	
	#Fix-Info
	fix_info = pos_raw[6]
	
	#Horizontale Genauigkeit in Metern
	h_acc = float(pos_raw[7])
	
	#Vertikale Genauigkeit in Metern
	v_acc = float(pos_raw[8])
	
	#Geschwindigkeit ueber Grund in km/h
	sog = float(pos_raw[9])
	
	#Kurs ueber Grund in Grad
	cog = float(pos_raw[10])
	
	#Steig- und Sinkrate
	#Umgekehrt als von GPS steigen (positiv) sinken (negativ)
	v_vel = -1 * float(pos_raw[11])
	
	#Alter der letzten DGPS-Korrektur in s, -1: nicht vorhanden
	if pos_raw[12] == "":
		age_c = -1
	else:
		age_c = float(pos_raw[12])
	
	#Verringerung der horizontalen Genauigkeit
	h_dop = float(pos_raw[13])
	
	#Verringerung der vertikalen Genauigkeit
	v_dop = float(pos_raw[14])
	
	#Verringerung der Zeitgenauigkeit
	t_dop = float(pos_raw[15])
	
	#Anzahl GPS-Satelliten fuer Fix
	num_gps = int(pos_raw[16])
	
	#Anzahl GLONASS-Satelliten fuer Fix
	num_glon = int(pos_raw[17])
	
	#Koppelungsloesung (DR=Dear Reckoning)
	dr = float(pos_raw[18].split("*")[0])
	
	return [t_stamp, lat, lon, alt, fix_info, h_acc, v_acc, sog, cog, v_vel, age_c, h_dop, v_dop, t_dop, num_gps, num_glon, dr]

#Funktion zur Pruefung von Tabelle go in DB
#Checken fuer finales GO
def get_go():
	con = mdb.connect(host="localhost", user="root", passwd="finky", db="flightlog")
	cursor = con.cursor()
	cursor.execute("SELECT * FROM go WHERE id = (SELECT MAX(id) FROM go)")
	row = cursor.fetchone()
	cursor.close()
	con.close()
	if row:
		print row
		print "POPE: GO!"
		return True
	else:
		print "POPE: warten"
		return False
  
#Warten auf GO!
#Abfrage der Tabelle go in DB
while not get_go():
	get_go()
	time.sleep(1)

#Warte 10 sek nach GO
time.sleep(10)

	
#Hauptschleife
# Holen der Positionen
reading = 1
while 1:
	pos = get_pos()
	print pos
	nav_data = form_pos(pos)
	print reading
	print nav_data
	print""
	cursor.execute("INSERT INTO pope (time_mess, lat, lon, alt, fix_info, h_acc, v_acc, sog, cog, v_vel, age_c, h_dop, v_dop, t_dop, num_gps, num_glon, dr, reading) VALUES ('%s', %s, %s, %s, '%s', %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)" % (nav_data[0], nav_data[1], nav_data[2], nav_data[3], nav_data[4], nav_data[5], nav_data[6], nav_data[7], nav_data[8], nav_data[9], nav_data[10], nav_data[11], nav_data[12], nav_data[13], nav_data[14], nav_data[15], nav_data[16], reading))
	con.commit()
	diskinfo = statvfs(".")
	freespace = diskinfo.f_bavail * diskinfo.f_frsize
	print freespace
	if freespace < 5242880:
		con.close()
		break
	reading += 1
	#time.sleep(1)

con.close()

Technische Daten und Links

BSP-Bezeichnung	POPE Permanent Orientation and Positioning Engine
Satellitensysteme	GPS, GLONASS, BeiDou
Hersteller und Bezeichnung	Hersteller: HABSupplies uBLOX MAX-M8Q Breakout With Sarantel +SAW/LNA Chipsatz: u-blox MAX-M8Q
Technische Daten	Ein- und Ausgänge: seriell (UART), I²C Pins: SDA, SCL, TX, RX, TP (PPS Output), BAT (Backup Battery), GND, VCC Spannung: 3,3V - Achtung beim Anschluss an einen Arduino! Übertragungsprotokoll: NMEA 0183, UBX Max. Höhe: 50.000m
mech. Daten	Abmessungen: 55,8mmm x 22,0mm x 12,9mm Masse: ca. 11g 9 POPEs wiegen weniger als eine Tafel Schokolade! Vielen Dank an die Raphael-Apotheke, Starnberg für das Wiegen!
Preis	POPE: £28.79 (zuzügl. Versand) PUP: €3,95 (zuzügl. Versand)
Links	HAB Supplies Der u-blox MAX-M8 Chipsatz NMEA-Übertragungsstandards Pololu - Der Hersteller von PUP