C Pointer in Konstruktor übergeben und in Variable speichern

[Hoeze]

Hi,
ich möchte in der Klasse MainThread einen Pointer auf Joystate_t joySt speichern, den ich dann in der loop()-Funktion non MainThread immer wieder setzen kann. Aber wie stelle ich das an?

#include "mthread.h"

int d2 = 2; //Gas
int d3 = 3; //Querruder
int d4 = 4; //Höhenruder
int d5 = 5; //Seitenruder

JoyState_t joySt;
 
class MainThread : public Thread {
    public:
          MainThread(*Joystate_t);
    protected:
        bool loop();
        Joystate_t *joyst;
};
 
//Definition des Konstruktors
MainThread::MainThread(Joystate_t *j){
  this->joyst = j;
}

//Definition der Threadschleife
bool MainThread::loop() {
    //Die if requested:
    if(kill_flag)
        return false;
    // code ----
    
    Joystick.setState(joyst);
    this->sleep_milli(10); 
    
    // ---- code
    return true;
}

void setup() {
	pinMode(d2, INPUT);
	pinMode(d3, INPUT);
	pinMode(d4, INPUT);
	pinMode(d5, INPUT);
	//pinMode(13, OUTPUT);
	Serial.begin(115200);

	joySt.xAxis = 0;
	joySt.yAxis = 0;
	joySt.zAxis = 0;
	joySt.xRotAxis = 0;
	joySt.yRotAxis = 0;
	joySt.zRotAxis = 0;
	joySt.throttle = 0;
	joySt.rudder = 0;
	joySt.hatSw1 = 0;
	joySt.hatSw2 = 0;
	joySt.buttons = 0;

        main_thread_list->add_thread(new MainThread(&joySt));

}

bool laststate[4] = { LOW, LOW, LOW, LOW };
unsigned long startzeit[4];

void loop() {

	if (digitalRead(d2) == HIGH && laststate[0] == LOW) {
		startzeit[0] = micros();
		laststate[0] = HIGH;
	} else if (digitalRead(d2) == LOW && laststate[0] == HIGH) {
		int x = (micros() - startzeit[0] - 1012) / 3.8274;
		// if (x < 0) x = 0;
                // if (x > 255) x = 255;
		joySt.throttle = x;
		laststate[0] = LOW;
	}

        // usw.... 

}

 

[Plaste]

Sind joySt (großes S) und joyst (kleines s) so gewollt?
Das ist beim Lesen ein Graus.

Um die Ganzzahl joySt zu pointern :
int * p_joySt = &joySt // ampersand referenziert die Adresse

P.S.: Das ist C++, andere vllt mal den Titel

 

[Freezedevil]

Was hast du denn versucht und was hat dabei nicht geklappt? Ich versteh dein Problem nämlich ehrlich gesagt nicht so richtig.

In deiner Methode MainThread::loop() kannst du auf die Variable joyst doch einfach zugreifen wie du es in Zeile 30 ja auch machst. Genau so kannst du natürlich auch was neues zuweisen. In der loop() Funktion außerhalb der Klasse kommst du an die protected Member natürlich nicht ran. Da bräuchtest du dann getter/setter. Ich bezweifle allerdings, dass das deine eigentliche Frage beantwortet, da mit diese Antwort im Verhältnis zu deinem Code zu trivial vorkommt.

 

[Plaste]

Freeze, schau dir mal die Schreibweise an

Spätestens bei zusätzlicher Verwendung von joyst, joySt, joysT, joyST und JoySt wird es lustig

 

[Hoeze]

OK, im Prinzip will ich in der loop() außerhalb der Klasse ein Signal einlesen und dieses dann mit Joystick.setState(&joySt); an den Computer senden (also als Joystick-Eingabe).

Problem an der ganzen Sache war, dass der Joystick immer hin- und herspringt:
Anscheinend dauert die Übertragung zu lange, um anschließend noch schnell genug überprüfen zu können, wann genau sich das Signal ändert, somit ändert sich auch immer der Ausschlag des Joysticks.

Mein Lösungsversuch war jetzt, die Übertragung in einen neuen (simulierten) Thread auszulagern, sodass auch während die Übertragung läuft, das Signal zuverlässig ausgelesen werden kann.

Natürlich müsste dafür aber der Inhalt der Variable joySt irgendwie in der Klasse MainThread existeren.
Ich komme von java, d.h. ich hätte jetzt einen Konstruktor definiert, in dem ich einfach das entsprechende Objekt übergebe und als Instanzvariable speichere.
Da C(++) anscheinend nicht wirklich Objekte kennt, muss ich doch einen Pointer übergeben, oder?



PS: Mich hats schon gewundert, als ich bei der mthread-lib das Wort "Klasse" gelesen hab. Ich dachte Arduinos können nur C?
Ich hasse die Arduino-Ide...

 

[dcc22]

Bin zwar kein C++ Coder, aber C kann ich

 JoyState_t *joySt;

Wenn du es außerhalb der Klasse haben willst, dann machst du am besten daraus einen Pointer bei der Deklaration.
Du kannst notfalls die Variable auch im Header deklarieren, dann gilt sie überall wo du den header einbindest.
Nur wäre dies schlechter Stil, da man Variablen so weit es geht von der Außenwelt abschottet.

Ich würde empfehlen Threading zu benutzen, bzw. einen anderen Prozess zu forken.
Der code nach dem fork() z.b. erbt alles was man in der forkenden Klasse auch hatte.
Beseitigt auch Verzögerungen beim Input da die Überwachung aus dem Code ausgelagert wurde.

Hättest also ein Programm, welches sich splittet und parallel läuft. Der eine Teil überwacht die Änderungen und schreibt sie in eine Variable, der andere Teil reagiert darauf.

 

[Hoeze]

Ich würde empfehlen Threading zu benutzen, bzw. einen anderen Prozess zu forken.
Der code nach dem fork() z.b. erbt alles was man in der forkenden Klasse auch hatte.
Beseitigt auch Verzögerungen beim Input da die Überwachung aus dem Code ausgelagert wurde.

Könntest du das etwas ausführen? Wie du merkst, ich kann eigentlich KEIN C
Ich dachte ich würde Threading benutzen...

 

[dcc22]

Das geht auch, musst da einfach nur den Pointer beim thread erstellen mitgeben, also auf JoyState_t joySt zeigen. Die Variable wäre dann dem Thread bekannt und könnte von da aus verändert werden.

Arbeite selbst nur mit Linux, da würde es so gehen: http://www.tutorialspoint.com/cplusplus/cpp_multithreading.htm

 

[westef]

Sieht so aus, als würde der TO das ganze auf einem Arduino programmieren. Da gibt es vermutlich kein fork().

 

[Hoeze]

Sieht so aus, als würde der TO das ganze auf einem Arduino programmieren. Da gibt es vermutlich kein fork().

Oh tut mir leid, ja, ich programmier das auf nem Arduino Leonardo.