Variable im Register verändern

siecpp

Was meinst du mit Verzögerung? Soll sich das Flugzeug zeitlich später neigen? soll die Neigung begrenzt werden?

FrEEzE2046

siecpp schrieb:

Wenn ich das richtig sehe erzeugst du immer einen Thread und wartest dann darauf, das der fertig ist.

Siehst du richtig. Macht überhaupt keinen Sinn

Mit Verzögerung meint er wohl, dass das Flugzeug nicht sofort "volles rohr" nach oben/unten ziehen soll, sondern der Grad des Steigens zunimmt ... oder so ähnlich.

siecpp

FrEEzE2046 schrieb:

Mit Verzögerung meint er wohl, dass das Flugzeug nicht sofort "volles rohr" nach oben/unten ziehen soll, sondern der Grad des Steigens zunimmt ... oder so ähnlich.

Das würde ja heißen den Joystickausschlag uber die Zeit zu integrieren (bzw zu addieren, da das ja diskret ist).

laura84

Also die Threads brauche ich, da ich eine Art Timer bauen musste um diese Verzögerung zu gestalten. Die Versögerung meinte ich so, dass wenn der Joystick ganz nach rechts gedrückt wird, bekomme ich ja den Wert +1.0 zurückgegeben. Das Flugzeug soll aber nicht sofort zur Seite kippen sondern immer nur 5 Grad pro Sekunde nach rechts geneigt werden. Wenn ich nur halb nach rechts drücke soll auch nur 2.5 Grad pro Sekunde geneigt werden.
Ich wollte das so machen, dass ich den Rückgabe Wert des Joysticks mal 5 rechne und dann pro Sekunde diesen Wert immer einmal aufaddiere. Leider funktioniert das eben nicht. Außerdem sollte das ja aufhören wenn der Joystick in eine andere Richtung gedrückt wird, bzw. einfach losgelassen wird.
Warum sollte das mit den Threads keinen Sinn machen? Ich bin irgendwann auf die Schlussfolgerung gekommen dass es ohne Threads nicht machbar ist. Man muss aber auch dazu sagen dass das mein erstes Programm in Richtung Multithreading ist und ich deswegen einiges falsch gemacht haben könnte.

siecpp

laura84 schrieb:

Also die Threads brauche ich, da ich eine Art Timer bauen musste um diese Verzögerung zu gestalten. Die Versögerung meinte ich so, dass wenn der Joystick ganz nach rechts gedrückt wird, bekomme ich ja den Wert +1.0 zurückgegeben. Das Flugzeug soll aber nicht sofort zur Seite kippen sondern immer nur 5 Grad pro Sekunde nach rechts geneigt werden. Wenn ich nur halb nach rechts drücke soll auch nur 2.5 Grad pro Sekunde geneigt werden.
Ich wollte das so machen, dass ich den Rückgabe Wert des Joysticks mal 5 rechne und dann pro Sekunde diesen Wert immer einmal aufaddiere.

OK ich denke fals ich dich richtig verstehe ist es das, was ich mit integrieren gemeint habe.

laura84 schrieb:

Leider funktioniert das eben nicht. Außerdem sollte das ja aufhören wenn der Joystick in eine andere Richtung gedrückt wird, bzw. einfach losgelassen wird..

Das müsste doch implizit funktionieren. Wenn der Joystick Null liefert wird die Neigung beibehalten, wenn der Wert negativ ist wird die Neigung verringert. Ich denke das Problem ist, das du einfach losprogrammiert hast ohne genau zu wissen was du tun willst. Das geht meistens in die Hose. Du solltest dir erstmal überlegen wie die Lösung konzeptionell funktionieren soll.

laura84 schrieb:

Warum sollte das mit den Threads keinen Sinn machen?

Threads machen bei deiner Lösung keinen Sinn. Threads sind dazu da, Dinge parallel zu machen. So wie du das gemacht hast, läuft aber immer nur ein Thread. Was soll das bringen?

laura84 schrieb:

Ich bin irgendwann auf die Schlussfolgerung gekommen dass es ohne Threads nicht machbar ist.

Ich denke Threads könnten durchaus nützlich sein bei dem was du machen möchtest aber nicht bei dem was du machst

laura84 schrieb:

Man muss aber auch dazu sagen dass das mein erstes Programm in Richtung Multithreading ist und ich deswegen einiges falsch gemacht haben könnte.

Der Punkt ist, dass deim Programm kein Multithreading macht.

laura84

siecpp schrieb:

Threads machen bei deiner Lösung keinen Sinn. Threads sind dazu da, Dinge parallel zu machen. So wie du das gemacht hast, läuft aber immer nur ein Thread. Was soll das bringen?
Ich denke Threads könnten durchaus nützlich sein bei dem was du machen möchtest aber nicht bei dem was du machst
Der Punkt ist, dass deim Programm kein Multithreading macht.

Okay, jetzt wohl nicht mehr, da hast du recht. Ich hatte vorher in der main die Abfrage der Werte in einer endlos-while-Schleife und wollte gleichzeitig einen Wert ändern der in dieser Schleife genutzt wurde, deshalb hatte ich mich fürs (damals war es noch ein) Multithreading entschieden. Gestern habe ich dann die Endlosschleife abgeändert in eine zeitlich begrenzte Abfrage, seitdem ist mein Programm wohl kein Multithreading Programm mehr.

Mittlerweile klappt alles, also auch die Verzögerung habe ich gerade hinbekommen. Ich programmiere meistens einfach so drauf los, obwohl mir hier schon vorher bewusst war was ich erreichen möchte. Trotzdem bin ich wohl eher der Try-and-Error Typ. Ich programmiere aber auch noch nicht sehr lange.

Das einzige Problem dass ich jetzt noch habe ist die Ausgabe. Die will einfach nicht klappen. Momentan möchte ich die Werte ja einfach nur mal angezeigt bekommen, aber durch diese ständigen Abfragen musste ich ja ein

system ("cls");

einbauen, sonst könnte man ja gar nichts mehr sehen. Allerdings gibt er mir jetzt nicht die veränderten Werte aus. Weißt du wpran das liegen könnte?

siecpp

laura84 schrieb:

Allerdings gibt er mir jetzt nicht die veränderten Werte aus. Weißt du wpran das liegen könnte?

meinst du diese stelle im code?

printf ("                        ");
        printf ("%+.1f ", aend[j]);

Wird da garnichts ausgegeben oder nur nicht das, was du möchtest? Was sagt der Debugger? Wesshalb benutzt du printf und nicht cout?

laura84

Ja genau die Stelle meinte ich, allerdings hab ich die erste Zeile jetzt weg gelassen, weil sie mittlerweile überflüssig ist. Außerdem hab ich herausgefunden dass es mir kurz ausgegeben wird, aber dann durch den "cls" Befehl gleich wieder gelöscht wird.

siecpp schrieb:

Wesshalb benutzt du printf und nicht cout?

Naja um ehrlich zu sein weil ich nicht wüsste wie ich sonst diese Zeilen ausgeben könnte:

printf ("Joystick is \"%s\"\n\n", js->getName());

printf ("%+.1f ", ax[j]);

Also das Begrenzen der float Variablen geht wohl irgendwie mit

setprecision

aber das geht bei mir irgendwie nicht, da gibt er dann mal keine Nachkommastelle an oder auch mal zwei, wie er gerade will. Deshalb nutze ich printf.

Mittlerweile ist mir noch aufgefallen, dass die Verzögerung jetzt wohl klappt, aber nur beim ersten mal Joystick bewegen und wenn ich dann wieder auf Null gehe ruft er mir nie wieder den Thread auf, egal wie ich den Joystick bewege. Außerdem wird immer nur eine Achse beachtet, wenn ich gleichzeitig nach oben und nach rechts drücke nimmt er nur die Achse die zuerst btätigt wurde.

Ich poste jetzt nochmal meinen Code, weil ich den jetzt nochmal abgeändert hab, vielleicht kannst du mir ja doch noch irgendwie helfen auch wenns total unübersichtlich ist.

#define WIN32_LEAN_AND_MEAN

#include <js.h>
#include <windows.h>
#include <stdio.h>
#include <windowsx.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

CRITICAL_SECTION csQueueInAccess;

#define MAX_THREADS 3

jsJoystick *js;
float      *ax;

int count  = 0;
int count2 = 0;
int count3 = 0;
int count4 = 0;

int index = 0;

float aend[3];
float ausg[3];

int b;
int j;

DWORD WINAPI ThreadFunc(LPVOID data)
{
	EnterCriticalSection(&csQueueInAccess);

		while (0.05 < ax[j] || ax[j] < -0.05)
		{
			count4 = count3 + 1;
			Sleep(1000);

			while (count4>count3 && (0.05 < ax[j] || ax[j] < -0.05))
			{
				aend[j] = ax[j] * 5;
				ausg[j] += aend[j];
				js->read (&b, ax);
				ax[j] = floorf(ax[j]*100 + .5)/100.;
			}

			aend[j] = 0;
			ausg[j] = 0;
		}

		printf ("%+.1f ", ausg[j]);

	return((DWORD)data);

	LeaveCriticalSection(&csQueueInAccess);

}

int main ( int, char ** )
{
 	HANDLE hThread[MAX_THREADS];
	DWORD  dwThreadID[MAX_THREADS];

	InitializeCriticalSection(&csQueueInAccess);

	jsInit ();

	js = new jsJoystick (0);

	if (js->notWorking ())
		printf ("Joystick not detected\n");
	else
		printf ("Joystick is \"%s\"\n\n", js->getName());

	if (js->notWorking ()) 
		exit (1);

	ax = new float [js->getNumAxes ()];

	count2 = count + 1;
	Sleep (30);
	while (count2>count)
	{
		printf ("Joystick test program.\n");
		printf ("~~~~~~~~~~~~~~~~~~~~~~\n\n");

		printf ("+---------JS----------");

		printf ("+----------------+\n");

		printf ("| Btns ");

		for (j = 0 ; j < 3 ; j++)
			printf ("Ax:%d ", j);

		for ( ; j < 3 ; j++ )
			printf ("     ");

		printf ("|");

		printf ("   Aenderung    |\n");

		printf ("+---------------------");

		printf ("+----------------+\n");

		js->read (&b, ax);

		printf ("| %04x ", b);

		for (j = 0 ; j < 3 ; j++)
		{
			ax[j] = floorf(ax[j]*100 + .5)/100.;
			printf ("%+.1f ", ax[j]);
		}

		printf("| ");

		for (index = 0; index < 2; index++)
		{

			for (j = 0; j < 2; j++)
			{

				if (0.05 < ax[j] || ax[j] < -0.05)
				{
					hThread[index] = CreateThread(NULL,				
												  0,				
												  ThreadFunc,		
												  (LPVOID)index,	
												  0,				
												  &dwThreadID[index]);

					WaitForSingleObject(hThread[index], 15);
					CloseHandle(hThread[index]);
				}

			}
		}

		system("cls");
	}

	DeleteCriticalSection(&csQueueInAccess);

	getchar();
	return 0;
}

siecpp

laura84 schrieb:

Naja um ehrlich zu sein weil ich nicht wüsste wie ich sonst diese Zeilen ausgeben könnte:
printf ("Joystick is \"%s\"\n\n", js->getName());
printf ("%+.1f ", ax[j]);

cout << "Joystick is \"" << js->getName() << ""\" << endl << endl;

cout << setprecision(2) << ax[j];

laura84 schrieb:

Mittlerweile ist mir noch aufgefallen, dass die Verzögerung jetzt wohl klappt, aber nur beim ersten mal Joystick bewegen und wenn ich dann wieder auf Null gehe ruft er mir nie wieder den Thread auf, egal wie ich den Joystick bewege. Außerdem wird immer nur eine Achse beachtet, wenn ich gleichzeitig nach oben und nach rechts drücke nimmt er nur die Achse die zuerst btätigt wurde.

Ich blicke da leider immer noch nicht ganz durch. Vielleicht kannst du das mal kommentieren. Was ich aber denke ist, dass du aus den Schleifen nie wieder rauskommst, weil sich die Bedingung wärend der Schleife nicht ändert. Auch das j bleibt immer gleich. Vielleicht ist das der Grund, warum immer nur eine Achse beachtet wird. Ich denke langsam dämmert mir, was du machen möchtest. Du möchtest wahrscheinlich alle Threads parallel laufen lassen, wartest mit dem starten des nächsten Threads aber immer, bis der letzte fertig ist, was nie passiert.

siecpp

Eine zusätzlich Anmerkung: Falls du wirklich alle Threads parallel laufen lassen möchtest, kannst du das natürlich nicht mit der globalen Variable j machen, da diese für alle Threads gleich ist und somit jeder Thread dasselbe machen würde, Du müsstest statdessen jedem thread sein eigenes j als parameter mitgeben.

siecpp

Bei näherem überlegen bin ich mir nicht mehr sicher, ob du Threads parallel laufen lassen möchtest. Vielleicht vergisst du nur, die Werte für ax in der Schleife neu zu lesen. Ich denke das Problem ist, dass ax in der Schleife konstant ist.

Wobei ich sehe gerade. Das machst du schon. Daran kann es nicht liegen.

laura84

Oh man ich weis es langsam selber nicht mehr. Bin mittlerweile schon total verwirrt und mach immer mehr kaputt als das es besser wird.

cout << setprecision(2) << ax[j];

Funktioniert leider nicht so richtig, da ich auch wenn der Wert Null ist gerne "0.0" da stehen haben würde und nicht nur "0". Alle Anderen "fprint" habe ich jetzt aber durch "cout" ersetzt. Danke für den Code.

Also ich frag in den Schleifen schon nochmal neu ab. Das komische ist wenn ich Haltepunkte setze und es dann Schritt für Schritt ablaufen lasse funktioniert es. Zwar nur beim ersten mal Joystick bewegen und auch nur für eine Achse, aber es funktioniert. Wenn ich das Programm ohen Haltepunkte laufen lasse, dann spinnt es total rum und gibt immer irgend einen Schmarrn aus.

Komisch ist auch dass wenn er in die Thread Funktion reinspringt, beim debuggen, dann springt er manchmal einfach so wieder in die main und dann wieder in die Thread Funktion, an irgendeinem Punkt. Das ist wirklich total komisch, denn er hat überhaupt keinen Grund dafür.

Ich verzweifel langsam an diesem Programm!

siecpp

laura84 schrieb:

Oh man ich weis es langsam selber nicht mehr. Bin mittlerweile schon total verwirrt und mach immer mehr kaputt als das es besser wird.

Wenn du es nicht weist wer dann? Wenn das Konzept falsch oder nicht erkennbar ist, bringt es meistens nichts an einzelnen Codezeilen runzudoktorn. Mach lieber mal ne Pause oder schlaf ne nacht drüber und überlege dir dann nochmal ein Lösungskonzept und skizziere das in pseudocode oder anders.

laura84 schrieb:

cout << setprecision(2) << ax[j];
Funktioniert leider nicht so richtig, da ich auch wenn der Wert Null ist gerne "0.0" da stehen haben würde und nicht nur "0".

Es funktioniert schon richtig, es mach aber nicht was du möchtest Es gibt für alles eine Lösung:

cout << fixed << setprecision(2) << ax[j];

laura84 schrieb:

Das komische ist wenn ich Haltepunkte setze und es dann Schritt für Schritt ablaufen lasse funktioniert es". Zwar nur beim ersten mal Joystick bewegen und auch nur für eine Achse, aber es funktioniert. Wenn ich das Programm ohen Haltepunkte laufen lasse, dann spinnt es total rum und gibt immer irgend einen Schmarrn aus.

Das hört sich nach nem Synchronisationsproblem zwischen den Threads an. Dürfte aber eigentlich nicht sein.

laura84 schrieb:

Komisch ist auch dass wenn er in die Thread Funktion reinspringt, beim debuggen, dann springt er manchmal einfach so wieder in die main und dann wieder in die Thread Funktion, an irgendeinem Punkt. Das ist wirklich total komisch, denn er hat überhaupt keinen Grund dafür.

Womit debuggst du denn? Wird dir angezeigt, dass zwei Threads laufen? Wenn er wieder in die main springt läuft dann der zweite Thread noch?

laura84

So, ich hab jetzt nochmal 3 Nächte drüber geschlafen. Ich hab nochmal drüber nachgedacht und alles neu aufgesetzt.

Jetzt habe ich also eine Endlosschleife in der ein Thread gestartet wird. Diesem möchte ich eigentlich nur sagen wir mal 30ms geben um dann wieder in die Endlosschleife zurückzukehren. Wie kann ich denn sagen "dir gebe ich immer 30ms"? Er soll eigentlich immer nur die Veränderung anschauen und dann wieder in die Endloschleife zurückkehren damit diese wieder von Vorne beginnen kann. Pro Schleifendutchlauf soll der Thread aber auch einmal gestartet werden, so lange soll dann der main Thread warten (also die 30ms).

Kann mir wer helfen das zu realisieren?

edit: Wieso wird mein Thread in der Endlosschleife eigentlich nur ein einziges mal aufgerufen, wenn ich keine Bedingung zum Aufrufen angegeben habe? Bei jedem weiteren Schleifendurchlauf wird der CreateThread Befehl eifach übergangen.

siecpp

Ich kann dir nicht ganz folgen. Poste mal deinen überarbeiteten Code.

laura84

So wie mein Code jetzt aussieht hab ich ihn aber schon wieder überarbeitet. Ich bekomme momentan immer ein Access Violation. Außerdem wird der CreateThread Befehl beim debuggen immer erstmal einfach ignoriert und erst nach

fflush (stdout);

springt er in den Thread. Das verstehe ich nicht warum er das macht. Sollte ja eigentlich zuerst den Thread abhandeln.
Ich debugge übrigens direkt mit VC++ 6.0

#define WIN32_LEAN_AND_MEAN

#include <js.h>
#include <windows.h>
#include <stdio.h>
#include <windowsx.h>
#include <stdlib.h>
#include <iostream>
#include <iomanip>

using namespace std;

CRITICAL_SECTION Section;
HANDLE hThread;
DWORD  dwThreadID;

jsJoystick *js;
float      *ax;

DWORD WINAPI ThreadFunc(LPVOID data);

int main (int argc, char **argv)
{
	jsInit ();

	js = new jsJoystick (0);

	printf ("Joystick test program.\n");
	printf ("~~~~~~~~~~~~~~~~~~~~~~\n\n");

	if (js->notWorking ())
		printf ("Joystick not detected\n");
	else
		printf ("Joystick is \"%s\"\n\n", js->getName());

	if (js->notWorking ()) 
		exit (1);

	ax = new float [js->getNumAxes ()];

	int j;

	printf ("+---------JS----------+----------------");

	printf ("+\n");

	printf ("| Btns ");

	for (j = 0 ; j < 3 ; j++)
		printf ("Ax:%d ", j);

	cout << "|   Aenderung    ";

	printf ("|\n");

	printf ("+---------------------+----------------");

	printf ("+\n");

	while (1)
	{
		int b;
		int index = 0;

		js->read (&b, ax);

		printf ("| %04x ", b);

		for (j = 0 ; j < 3 ; j++)
			printf ("%+.1f ", ax[j]);

		InitializeCriticalSection(&Section);

		hThread = CreateThread(NULL,
							   0,
							   ThreadFunc,
							   (LPVOID)index,
							   0,
							   &dwThreadID);

		WaitForSingleObject(hThread, 100);

		DeleteCriticalSection(&Section);

		printf ("|\r");
		fflush (stdout);

#ifdef WIN32
		Sleep (1);
#elif defined(sgi)
		sginap (1);
#else
		usleep (1000);
#endif

	}

	getchar();
	return 0;
}

DWORD WINAPI ThreadFunc(LPVOID data)
{
	int j;
	float aend[3] = {0, 0, 0};
	float ausg[3] = {0, 0, 0};

	cout << "| ";

	EnterCriticalSection(&Section);

	for (j = 0; j < 3; j++)
		printf ("%+.1f ", ausg[j]);

	for (j = 0; j < 3; j++)
	{
		while (0.01 < ax[j] || ax[j] < -0.01)
		{
			aend[j] = ax[j] * 5;
			ausg[j] += aend[j];
			Sleep(1000);
			printf ("%+.1f ", ausg[j]);
		}
	}

	LeaveCriticalSection(&Section);

	return((DWORD)data);	
}

laura84

Ah, das mit dem Access Violation lag wohl daran dass ich dem Thread zu wenig Zeit gegeben habe. Hab jetzt auf 500ms raufgeschraubt und dann klappt das auch wunderbar.

siecpp

laura84 schrieb:

Jetzt habe ich also eine Endlosschleife in der ein Thread gestartet wird. Diesem möchte ich eigentlich nur sagen wir mal 30ms geben um dann wieder in die Endlosschleife zurückzukehren.

Weshalb möchtest du das machen? Das ist höchstwarscheinlich keine gute Idee.

laura84 schrieb:

Er soll eigentlich immer nur die Veränderung anschauen und dann wieder in die Endloschleife zurückkehren damit diese wieder von Vorne beginnen kann.

Dann warte doch einfach bis der Thread fertig ist, quasi so ähnlich, wie du es jetzt schon machst. Natürlich kannst du auch die Schleifendurchläufe in der Thradfunktion nach oben begrenzen, falls es das ist was du möchtest.

laura84 schrieb:

Ah, das mit dem Access Violation lag wohl daran dass ich dem Thread zu wenig Zeit gegeben habe. Hab jetzt auf 500ms raufgeschraubt und dann klappt das auch wunderbar.

Wenn du in jedem Fall warte möchtest, bis der Thread fertig ist, nimm INFINITE als Zeit. Dann kannst du auch sicher sein, das immer nur ein Thread läuft und das "hin- und herspringen" entfällt. Du solltest dich vielleicht mal damit vertraut machen, wie multithreading funktioniert und wie man mehrere Threads mit VC++ 6.0 debugged. Ich verstehe noch nicht, wozu du genau die Threads brauchst. Ich denke, das was du machst könnte man auch in einem einzelnen Thread machen und du machst dir das Leben unnötig schwer.

laura84

siecpp schrieb:

Weshalb möchtest du das machen? Das ist höchstwarscheinlich keine gute Idee.

Dafür sind Threads doch da, oder? Zwei Dinge gleichzeitig zu tun.

siecpp schrieb:

Ich denke, das was du machst könnte man auch in einem einzelnen Thread machen und du machst dir das Leben unnötig schwer.

Das habe ich jetzt letzendlich auch gemacht. Funktioniert auch alles, aber eben relativ langsam. Erst fragt er den eigentlichen Wert ab, dann rechnet er die Veränderungen aus und dann fragt er wieder den Wert ab....
Dadurch geht die Anzeige immer nur sehr stockend voran, das wäre eben mit Threads nicht so gewesen, aber da habe ich das Anzeigen nicht hinbekommen, sonst alles. Und das Anzeigen funktioniert auch nur nicht weil zwischen den Threads immer willkürlich hin und her gesprungen wird, was ich immer noch nicht so ganz verstehe warum das passiert.

siecpp

laura84 schrieb:

siecpp schrieb:

Weshalb möchtest du das machen? Das ist höchstwarscheinlich keine gute Idee.

Dafür sind Threads doch da, oder? Zwei Dinge gleichzeitig zu tun.

Mit meiner Aussage meinte ich, dass es keine gute Idee ist, einen Thread quasi von außen "abzuschießen" ohne zu wissen, was der gerade gemacht hat. Wo genau du etwas gleichzeitig machst ist mir auch nicht klar.

laura84 schrieb:

Und das Anzeigen funktioniert auch nur nicht weil zwischen Threads immer willkürlich hin und her gesprungen wird, was ich immer noch nicht so ganz verstehe warum das passiert.

Wann welcher Thread ausgeführt wird bestimmt nur der Scheduler des Betriebssystems (abgesehen davon, dass man einen Thread auch gezielt schlafen legen kann). Wenn die Funktionalität deines Programmes davon abhängt, in welcher Reihenfolge die Threads ausgeführt werden, machst du etwas grundlegendes falsch. In diesem Fall musst du eintsprechende Synchronisierung sicherstellen. Auf der anderen Seite benutzt du bereits einige Funktionen zur Synchronisierung.
Ist dir klar was folgende CodeZelen machen und warum du sie an dieser Stelle benutzt?

WaitForSingleObject(hThread, 100);
//...
EnterCriticalSection(&Section);
//..
LeaveCriticalSection(&Section);