Guten Morgen und Hallo.

 

Da mein IMU inzwischen abgeschickt wurde will ich mal meine Projektidee vorstellen.

Wie unschwer an meinem Avatarbild zu sehen, beschäftige ich mich mit der Fliegerrei. Habe selbst eine Sportpilotenlizens.

 

Da ich schon lange auf der Suche nach einem Lagesensor war, war der IMU genau das Richtige für mich.

Beruflich arbeite ich als Programmierer.

 

Meine Idee ist ein leichtes (Bei UL kommt es auf jedes "Gramm" an) HUD herzustellen.

 

Die Software wird nicht das größte Problem darstellen.

Das größte Problem wird die Projezierung des Bildes auf das eigenliche HUD.

Meine Idee ist dazu einen Picobeamer zu benutzen.

Leider habe ich noch keinen zum Testen in die Hand bekommen um zu schauen ob meine Idee funktioniert.

Es soll ja auch bei Sonneneinstrahlung gut lesbar sein.

Vielleicht hat jemand von euch schon einen und kann mal testen ob die Darstellung auf einer Glasscheibe ausreichend ist?

Es gibt ja die verschiedensten Typen. Große Lichtstärke (Lummen) wäre von Vorteil.

 

Was ich als Computerplatform benutze weiß ich jetzt noch nicht.

Am besten einen

Raspberry Pi oder ähnliches. Muß ich wegen der Leistung schauen.

Erkläre uns doch bitte HUD, nicht jeder möchte gleich die Websuche anschmeißen, noch hat jeder eine Fluglizenz... (Ausnahme natürlich bei den Modellbaufliegern 

Head up display.

 

Da werden quasi irgendwelche relevanten Informationen direkt auf die Windschutzscheibe geworfen, so muss man den Blick nicht vom wichtigen (die echte Welt) abwenden um die Geschwindigkeit/Neigung/usw zu sehen.

Wie mein Vorschreiber schon schrieb.

 

Head Up Display

 

Beispiele

 

Mir geht es um die Darstellung von relevanten Daten wie, Fluglage,Indicated Airspeed,Flughöhe,Kurs e.t.c

 

Wie wird denn bei einem professionellen HUD das Bild erstellt? Vom aussehen her, sieht das nach Laser o.ä. aus. Ein Pico Beamer wird da glaube ich schwerlich reichen. Die, die ich bis jetzt gesehen habe, bzw. über die ich gelesen habe, reichten gerade mal aus, um in einem abgedunkelten Raum ein kleines Bild gerade so anzuzeigen.

Es gibt schon Picobeamer die mit Laser arbeiten.

Ausserdem muß man auch sehen das die Entfernung zur "Leinwand" ziehmlich klein ist in so einem Cockpit.

 

Bei herkömlichen HUD werden die Informationen via CRT Bildschirm projiziert.

 

Hab das ganze scon mal in meinem Auto mit meinem Galaxy S2 getestet.

Funktionierte ziehmlich gut wenn es etwas dunkler war.

Aber das ist kein Vergleich. Hat ja nur ein OLED Display.

 

Die Anfänger vom HUD gab es schon im 1. WW. Waren dann im 2.WW richtig verbreitet und nannten sich damals Reflexvisier.

Damals wurde nur ein Fadenkreuz ins Blickfeld projiziert.

 

Strahlengang eines deutschen Revi C12/A, Baujahr 1937

 

weitere Informationen unter

bei wikipedia

Wie groß darf die Projektionsfläche im Cockpit sein ?

 

Als PC werfe ich mal als Alternative zum RaspPi einen Windows/Linux fähigen PC in die Arena:

http://www.zotac.com/index.php?page=shop.product_details&flypage=flypage_images-SRW.tpl&product_id=380&category_id=156&option=com_virtuemart&Itemid=100284&lang=de

 

Verbrauch ab etwa 11 (Leerlauf) bis 25 Watt.

Die Projektionsfläche wird eine extra Scheibe sein.

Sie soll nicht das gesamte Frontfeld belegen.

Muß ich schauen. Schätze mal so Breite zwischen 20 und 30 cm.

Höhe muß ich dann auch schauen.

So. Will mal den aktuellen Stand meines Projektes vorstellen.

Hab inzwischen Verbindung zum IMU aufgenommen und bekomme meine gewünschten Daten.

 

Hab das Beispiel etwas modifiziert.

 

Beim Start verbindet sich das Programm zum Brick. Fragt die vorhandenen Brick's (in meinem Fall nur der IMU) ab und connectetd automatisch zum gefundenem IMU (falls vorhanden)

Ausserdem kann man in der Kommandozeile verschiedene Argumente angeben.

 

-Host  Rechnername oder IP

-Port  XXX Port auf dem der Deamon hört (falls einanderer eingestellt)

-Period XXX  Peridode für die Callbackmethode

? Ausgabe einer Kurzen Hilfe

 

Mann selber muss nicht mehr die UID eingeben. Diese erfragt das Programm selber.

 

Jetzt versuche ich die grafische Ausgabe zu Erzeugen. Also das eigentliche HUD.

Will dazu die Grafische Benutzerschnittstellen GTKmm benutzen.

Bekomme aber diese Verf...... nicht eingebunden.

Sagt mir schon beim Compilieren das die Datei gtkmm.h nicht gefunden wird.

 

P.S.

F-Secure identifiziert den Demon immer noch als Keylogger.

 

#include <gtkmm.h> 

 

Obwohl schon im Projektverzeichnis enthalten.

#include <stdio.h>
#include <math.h>

#include "ip_connection.h"
#include "brick_imu.h"

#include <string.h>
#include <mbstring.h>
#include <malloc.h>

#define MAX_STRING 255

char*	Programmpath= NULL;
char*	HOST		= NULL;
int		PORT		= 4223; // Demon Standardport
int		Periode		= 100;

int16_t		pitch		= 0;
int16_t		roll		= 0;
int16_t		yaw			= 0;
int16_t		heading		= 0;

IPConnection*	ipcon	= NULL;
IMU*			imu		= NULL;
char*			UID		= NULL;

void cb_quaternion(float x, float y, float z, float w)
{
/****************************************************************************/
/*						Antwort auf	Quaternionabfrage  						*/
/****************************************************************************/
float roll  = atan2(2*y*w - 2*x*z, 1 - 2*y*y - 2*z*z);
float pitch = atan2(2*x*w - 2*y*z, 1 - 2*x*x - 2*z*z);
float yaw   = asin(2*x*y + 2*z*w);
printf("x: %f\ty: %f\tz: %f\tw: %f\t\n", x, y, z, w);
printf("roll: %f\tpitch: %f\tyaw: %f\t\n\n", roll, pitch, yaw);
/*
pi = math.atan2(2.0*(y*z - w*x), 1.0 - 2.0*(x*x + y*y));
ro = math.atan2(2.0*(x*z + w*y), 1.0 - 2.0*(x*x + y*y));
ya = math.atan2(2.0*(x*y + w*z), 1.0 - 2.0*(x*x + z*z));

di = app.dir.get();
if (di == 0)
{
	pi = -pi,
}
if(di == 1)
{
	pi, ro = -ro, -pi;
}
if(di == 2)
{
	ro = -ro;
}
if(di == 3)
{
	pi, ro = ro, pi;
}
*/
}

void cb_alldata(int16_t acc_x, int16_t acc_y, int16_t acc_z, int16_t mag_x, int16_t mag_y, int16_t mag_z, int16_t ang_x, int16_t ang_y, int16_t ang_z, int16_t temperature)
{
/****************************************************************************/
/*						Antwort auf	Abfrage aller Daten 					*/
/****************************************************************************/
float Temp = (float)temperature/100;
printf("acc_x: %d\nacc_y: %d\nacc_z: %d\nmag_x: %d\nmag_x: %d\nmag_z: %d\nang_x: %d\nang_y: %d\nang_z: %d\ntemperature: %f\n\n", acc_x, acc_y, acc_z, mag_x, mag_y, mag_z, ang_x, ang_y, ang_z,Temp);
}

void cb_orientation(int16_t vroll, int16_t vpitch, int16_t vyaw)
{
printf("cb_orientation\n");
/****************************************************************************/
/*						Antwort auf	Orientationabfrage  					*/
/****************************************************************************/
roll	= vroll	/100;
pitch	= vpitch/100;
yaw		= vyaw	/100;

printf("roll: %d\tpitch: %d\tyaw: %d\n\n", roll, pitch, yaw);
}

void cb_enumerate(char* device_uid, char* device_name, uint8_t device_stack_id, bool is_new)
{
/****************************************************************************/
/*				Antwort auf	Komponentenabfrage (Bricks,Bricklets) 			*/
/****************************************************************************/
printf("device_uid: %s\tdevice_name: %s\tdevice_stack_id: %d\t is_new: %d\n\n", device_uid, device_name, device_stack_id,is_new);

/****************************************************************************/
/*						Testen ob IMU Brick gefunden						*/
/****************************************************************************/
unsigned char* Test1;
unsigned char* Test2;
Test2 = (unsigned char*)"IMU Brick";
Test1 = (unsigned char*)device_name;
if(_mbsnbcmp(Test1,Test2,9)==0)
{
	printf("IMU gefunden\n");
	/****************************************************************************/
	/*							IMU Brick einbinden								*/
	/****************************************************************************/
	UID = (char *)malloc((strlen(device_uid)-1) * sizeof(char));
	size_t n =	 (strlen(device_uid)-1) * sizeof(char);
	if(UID)
	{
		_strset( UID, 0 ); 
//			strncpy(UID, device_uid, strlen(device_uid)-1);
//			_strset_s( UID,n, 0 ); 
		strncpy_s(UID,strlen(device_uid),  device_uid, strlen(device_uid)-1);
		/****************************************************************************/
		/*							IMU Brick erstellen								*/
		/****************************************************************************/
		if(!imu)
		{
			imu = new IMU();
		}
		imu_create(imu, UID); 

		/****************************************************************************/
		/*				IMU Brick zur IP Connection hinzufügen						*/
		/****************************************************************************/
		if(ipcon_add_device(ipcon, imu) < 0)
		{
			fprintf(stderr, "Could not connect to Brick\n");
			exit(1);
		}

		/****************************************************************************/
		/*					Ausgabegeschwindigkeit einstellen in ms					*/
		/****************************************************************************/
//			printf("Periode %d\n",Periode);
		imu_set_quaternion_period(	imu, Periode);
		imu_set_all_data_period(	imu, Periode);
			imu_set_orientation_period(	imu, Periode);
		/****************************************************************************/
		/*						IMU Brick Callback erstellen						*/
		/****************************************************************************/
//			imu_register_callback(imu,IMU_CALLBACK_ALL_DATA		, cb_alldata);
//			imu_register_callback(imu,IMU_CALLBACK_QUATERNION	, cb_quaternion);
		imu_register_callback(imu,IMU_CALLBACK_ORIENTATION	, cb_orientation);
	}
}
}

int main( int argc, char *argv[] )
{
Programmpath = (char *)malloc((MAX_STRING) * sizeof(char));
strcpy(Programmpath, argv[0]);

HOST = (char *)malloc((MAX_STRING) * sizeof(char));
strcpy(HOST, "localhost");

    if( argc > 1 )
    {
	for( int i = 1; i < argc; i++ )
	{
		_strlwr( argv[i] ); 
		unsigned char* Test1;
		Test1 = (unsigned char*)argv[i];
		unsigned char* Test2 = (unsigned char*)"?";
		if(_mbsnbcmp(Test1,Test2,1)==0)
		{
			fprintf(stderr, "\nTest.exe -Host Hostname -Port XXX -Periode XXX\"\n\n\t-Host Hostname\tIP or computername on that of the BRICK Demaon runs ( Default localhost )\n\t-Port XXX\tPort with that of the BRICK Demaon runs ( Default 4223 )\n\t-Periode XXX\tCycle period ( Default 100 )\n");
			exit( 1 );
		}

		Test2 = (unsigned char*)"-host";
		if(_mbsnbcmp(Test1,Test2,5)==0)
		{
			strcpy(HOST, argv[i+1]);
		}
		Test2 = (unsigned char*)"-port";
		if(_mbsnbcmp(Test1,Test2,5)==0)
		{
			PORT = atoi(argv[i+1]);
		}
		Test2 = (unsigned char*)"-period";
		if(_mbsnbcmp(Test1,Test2,5)==0)
		{
			Periode = atoi(argv[i+1]);
		}
	}
}
/****************************************************************************/
/*							IPConnection erstellen							*/
/****************************************************************************/

if(!ipcon)
{
	ipcon = new IPConnection();
}
if(ipcon_create(ipcon, HOST, PORT) < 0)
{
	fprintf(stderr, "Could not create connection\n");
	exit(1);
}
//	printf("Test %s\t %d\n",HOST, PORT);
/****************************************************************************/
/*					Komponenten (Bricks,Bricklets) abfragen					*/
/****************************************************************************/
ipcon_enumerate(ipcon,cb_enumerate);

printf("Press ctrl+c to close\n");
ipcon_join_thread(ipcon); // Join mainloop of ip connection
}

probiermal

anstatt

 

#include <gtkmm.h> 

 

ein

#include "gtkmm.h" 

 

wenn ich mich recht erinnere sind die <> Zeichen für systembibliotheken

Hatte ich auch schon probiert. Der selbe Effekt.

1>z:\software\visual studio 2008\projects\imutest\gtkmm.h(87) : fatal error C1083: Datei (Include) kann nicht geöffnet werden: "glibmm.h": No such file or directory

da beschwert er sich aber dass

 

glibmm.h

 

nicht da ist gibt es denn die Datei.

wie wäre es den mit qt

 

 

Danke. Glatt übersehen.

 

Hmmm. Aber diese Meldung kommt auch wenn die geforderte Datei + Verzeichnis im Projektordner ist.

 

QT?

Hmmm. Gleich mal beschnüffeln.

Der BrickViewer verwendet z.B. Qt und lässt sich sicher als Basis für eigene Dinge verwenden

So. Hab mich mal mit QT beschäftigt.

Gibts ja auch als MS Visualstudio AddOn. (Da ich beruflich damit arbeite)

 

Hab jetzt die graphische Anzeige für die Horizontlage, also Rollen und Nick, implemetiert.

Funktioniert schon. Noch unter Windows.

Als nächstes der Kompass und die Höhe.

Für die Höhe gibt es noch kein Brick oder

Für die Höhe will ich dann später einen Drucksensor nehmen.

Vorerst nehme ich ein GPS Modul über USB.

So. Mal ein kleiner Screenshot vom aktuellem Stand.

Die 3 Zahlen links sind nur die Werte für mich im Moment um die Werte lesen zu können.

 

Na das hat doch schon große Ähnlichkeit zu den Flugsimulatoren die ich kenne ^^

 

Sieht gut aus!

Das liegt daran dsa die Flugsimulatoren sich an der Realität orientieren.

HUD kommen ja ursprünglich aus der Militärluftfahrt.

Mal ne einfache und kurze Frage zum IMU.

Wo ist Norden also vorn und wo ist oben.

Das solltet ihr vielleicht mit auf die Platine drucken.

FlyingDoc: Soweit ich es getestet habe ist das bei meinen Brick (ohne Umrechnungen) mit dem USB Stecker Richtung Süden mit den Leds nach unten...

So. Hab mir gestern mal nen einfachen Kompass für knapp 10 Euro geholt um zu vergleichen.

Feststellung.

USB Stecker liegt Richtung West.

Nö, kann ich nicht bestätigen:

 

Die Y-Achse zeigt nach Norden, x-Achse nach Osten, und damit USB-Buchse nach Süden. Also eigentlich wie bei Real_Black, aber ich schaue auf die LEDs !

Eigentlich sollte das doch bei allen IMU-Bricks gleich sein, oder?

Ich hab jetzt schon öfters gelesen, dass der USB-Stecker nach Süden zeigt.

@FlyingDoc: Kannst du denn störende Einflüsse auschließen?

 

Wäre beim Fliegen ja schon relevant, dass es in die richtige Richtung geht :-D