This-Pointer in anderen Pointer schreiben C++

[locutus]

Hi,

ich hab gerade ein Problem:

und zwar möchte - nein, muss - ich ein Programm schreiben, welches über den Com-Port mit einem µC kommuniziert. Das ganze Projekt ist in Visual Studio 2010 (Ultimate über die msdnaa) erstellt, einiges funktioniert auch schon, aber:

Ich möchte eigentlich ganz gerne diese Funktion: SerialPort.DataReceived Event (System.IO.Ports) nutzen, um dadurch eben bei Inputs entsprechende Handlungen auslösen zu können. Nur: egal was ich mache, ich kann die datareceviedhandler-Funktion nur als static definieren, sonst meckert der Compiler rum. in der Static-Funktion darf ich aber wiederrum nicht den this-Operator nutzen, welchen ich eigentlich brauche, um bestimmte Steuerelemente in Abhängigkeit vom Input zu verändern.

Daher bin ich nach einigem Nachdenken auf die Idee gekommen "schreibst doch einfach die Adressen von den Elementen, auf welche du mit this sonst zugreifst, in neue, globale pointer und nutzt die dann" - gesagt, getan, aber: jetzt bekomm ich andauernd den Fehler "'&' erwartet L-Wert", jedoch habe ich keine Ahnung, warum.

hier mal die entsprechenden Code-Auszüge:

// ganz am Anfang der header-Datei:
bool* startenable; //ich hatte es auch schon mit int versucht, 
bool* zielvarenable; //aber da ists genau das gleiche

//in der Routine zur Initialisierung des Com-Ports:
startenable = &this->starte->Enabled; //das sind Buttons, welche abhängig vom
zielvarenable = &this->zielvariable->Enabled; //Input geschaltet werden sollen

//und in der Datareceviedhandler-Funktion:
*startenable = true;
*zielvarenable = true;

kann mir da wer sagen, woran das liegt bzw. wie ich das Problem lösen könnte? Ich hab heut schon den ganzen Tag damit verbracht, die MSDN-Resourcen zu durchsuchen (nicht nur zu diesem Problem, da waren noch ein paar andere Dinge, die nicht so ganz wollten und deren Lösung auch ewig gebraucht hat), konnte aber absolut nichts dazu finden.

 

[jogo141]

Also ich habe keine Ahnung von MSDN. Aus deiner Beschreibung lese ich jedoch heraus, dass es von der Klasse, deren 'this' du gerne hättest, maximal eine Instanz gibt. Wenn ich richtig liege, dann frage ich mich, warum du daraus nicht einen Singleton machst. Der bietet ja bekanntlich eine getInstance() das jederzeit den this-Pointer liefert.

Hoffe geholfen zu haben

 

[locutus]

ich hab ehrlich gesagt nicht allzu tiefgreifende kenntnisse von klassen in c - vor zwei jahren hab ich mal java inklusive klassen gemacht, seitdem aber nur noch c bzw. c++ (und asm) ohne klassen...

vom prinzip her gibt es von der klasse her allerdings glaub ich nur eine instanz, ja.

die eigentlichen dateien, in denen ich arbeite, wurden von visual studio selbst erstellt (was den enormen vorteil hat, dass ich die buttons, text-boxen und co. direkt grafisch platzieren konnte und eben nur noch mit funktionen füllen musste), von daher weis ich auch nur bedingt, wie das ganze eigentlich genau initialisiert wird. natürlich hat das auch seine nachteile, für mich als "gelegenheitsprogrammierer" ists allerdings ganz praktisch.

auch weis ich nicht so recht, wie ich das ganze in ein singleton verwandeln könnte - und wie ich das dann weiter ausnutzen könnte - am liebsten wäre es mir ja fast, wenn ich einfach aus der static-funktion eine nicht-statische funktion aufrufen könnte - aber auch da meckert der compiler nur rum. -.-

 

[biernase]

So ganz verstehe ich nicht wirklich was Du so vorhast.
Was hast Du denn als Vorlage gewählt (MFC, WindowsForm Win32Konsole) ?
Und warum nimmst Du nicht gleich C#?
Also bei Deinem MSDN-Link kannst Du doch grob die Funktion "Daten empfangen" von der SerialPort-Klasse nachschauen.
Wo hast Du den da einen this Pointer entdeckt ???
Welche Steuerelemente willst Du denn wie ändern ?
Buttons kannst Du doch in der static Funktion mit button_xyz.Enable = false oder true aktiv setzen.

 

[jogo141]

Mit MSDN kann dir biernase, glaube ich, mehr helfen.

Falls du es gebrauchen kannst, zu Singleton gibt's was auf Wikipedia.

 

[locutus]

es sollte windowsForm sein - zumindest konnte ich direkt nach erstellen die objekte auf der oberfläche anordnen wie ich wollte.

sprachlich hab ich nirgendwo eine einstellmöglichkeit gefunden, bei visual studio 2010 hab ich aber auch kein c#-projekt öffnen können, also da scheints nicht mit klar zu kommen.
mal abgesehen davon hab ich keine ahnung von C#.

und zum thema this-pointer: an mehreren stellen habe ich grob den befehl
this->button1->Enabled = true bzw. false; //ist zumindest so, wies in der doku steht und die buttons sind bei mir aber noch umbenannt
ausserdem ist das zweite, was umgeschaltet werden soll, eine textbox.

denn: ich schalte die buttons ab, so lange sie nicht benutzt werden sollen. gleichzeitig kann ich nicht das gesamte programm so lange blockieren, bis die gegenstelle zurückmeldet "ich bin da, wo ich hin soll", weshalb ich praktisch die buttons von einem interrupt aktivieren lassen muss. (und noch andere tasks ausführen lassen möchte, welche aber eben alle in dem einen fenster passieren sollen)
wenn es irgendwas helfen würde, würde ich den gesamten quelltext hier rein stellen, aber ich denke mal, das würde dann den ganzen rahmen doch etwas überladen.

nachdem ich jetzt noch mal etwas zeit hatte, dieses button_xyz zu testen, muss ich leider sagen: geht nicht.


im endeffekt sieht der (für diesen teil wohl wichtige) code so aus:

#pragma once

namespace Steuerung {
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
using namespace System::IO::Ports;

bool* startenable;
bool* zielvarenable;

/// 
/// Zusammenfassung für Form1
/// 
public ref class Form1 : public System::Windows::Forms::Form
{
public:
Form1(void)
{
InitializeComponent();
//
//TODO: Konstruktorcode hier hinzufügen.
//
}

protected:
/// 
/// Verwendete Ressourcen bereinigen.
/// 
~Form1()
{
if (components)
{
delete components;
}
}

/* hier steht noch etwas mehr code, der ist aber wohl irrelevant, ist im endeffekt wie die folgende zeile,
zum teil aber mit protected-suffix - s.u.*/
private: System::Windows::Forms::MaskedTextBox^ zielvariable;
protected: 

protected: //z.b. hier

private: System::Windows::Forms::Button^ starte;

private: System::ComponentModel::IContainer^ components;

private:
/// 
/// Erforderliche Designervariable.
/// 

#pragma region Windows Form Designer generated code
/// 
/// Erforderliche Methode für die Designerunterstützung.
/// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
/// 
void InitializeComponent(void)
{

this->starte = (gcnew System::Windows::Forms::Button());
this->zielvariable = (gcnew System::Windows::Forms::MaskedTextBox());
/*hier steht dann noch der ganze restliche initialisierungscode, welcher weitere 
elemente initialisiert und eigenschaften vergibt*/
}
#pragma endregion
System::IO::Ports::SerialPort^ comPort;
int value;
float eingabe;

private: System::Void label1_Click(System::Object^ sender, System::EventArgs^ e) {
}
private: System::Void button3_Click(System::Object^ sender, System::EventArgs^ e) {
this->comboBox1->Items->Clear();
this->comboBox1->Items->AddRange(SerialPort::GetPortNames());
}
private: System::Void button4_Click(System::Object^ sender, System::EventArgs^ e) {
try {
//routinen zum comport initialisieren
comPort = gcnew SerialPort(this->comboBox1->Text);
comPort->DataReceived += gcnew SerialDataReceivedEventHandler(&Steuerung::Form1::DataReceviedHandler); //hier wird die zu verwendende Int-Funktion benannt
comPort->Open();
}
catch (Exception^ x) {
//error-handler
}
}

private: static void DataReceviedHandler(System::Object^ sender, System::IO::Ports::SerialDataReceivedEventArgs^ e) {
array ^ibuffer = gcnew array(2);
System::IO::Ports::SerialPort^ cp = (System::IO::Ports::SerialPort^)sender;
cp->Read(ibuffer,0,2);
if((ibuffer[0]==255) && (ibuffer[1]==255)) { //wenn 0b1111 1111 1111 1111 gesendet wurde, dann:
this->starte->Enabled = true; //genau hier gehts nicht, auch nicht mit Button_starte.Enable = true
this->zielvariable->Enabled = true; // und hier natürlich das gleiche!

//hier sollten eben eigentlich button und eingabefeld wieder eingeschaltet werden.
}
}
/* und dann kommt noch nen bischen mehr code für andere funktionen, 
welche u.a. eben auch button starte und textfeld zielvariable deaktivieren. 

natürlich wäre es rein theoretisch möglich, mit einer blocking-funktion (z.b. while(xyz); ) auf eine antwort zu warten,
allerdings muss es zum einen möglich sein, die antwort vom externen system zu empfangen, zum anderen muss aber ein 
anderer button weiterhin klickbar sein!
*/

 

[biernase]

Also grundsätzlich gilt der this-Pointer auf das Formular,
d.h wenn Du auf this->starte zugreifen willst sollte ein Element starte vorhanden sein.
Du scheinst ja beim Klick auf Button4 (button4_Click) den Port zu Öffnen.
Dort solltest Du dann auch den Button erst mal disablen.
In der DataReceviedHandler-Funktion kannst Du dann disen Button wieder enablen.
Sorry ist jetzt spät, weiss noch nicht genau wer oder was zielvariable ist(comboBox1 ?)
Mehr morgen abend...

 

[locutus]

nicht ganz: zielvariable ist MaskedTextBox. comboBox ist das drop-down-feld, welches alle vorhandenen comports eingeschrieben bekommt und aus welchem der gewünschte gewählt sowie ausgelesen wird. (vlt. hätte ich doch den teil gleich mit posten sollen?)

Der teil, bei welchem der COM-Port geöffnet wird, ist hier jetzt auch nicht vollständig abgebildet, nur eben wegen der comPort->DataReceived += ... - zeile überhaupt drin. denn der comport läuft soweit ansonsten eigentlich, wie er soll. (und ja, erschaltet auch den öffnen-button ab)

das element starte existiert im übrigen:

private: System::Void starte_Click(System::Object^ sender, System::EventArgs^ e) {
array ^obuffer = gcnew array(2);
this->starte->Enabled = false;
this->zielvariable->Enabled = false;
try {

eingabe = Convert::ToSingle(this->zielvariable->Text);
value = Convert::ToByte(Math::Round(eingabe * 63 / 45));
obuffer[0] = value;
}
catch (Exception^ x) {
MessageBox::Show("Fehlerhafte Eingabe!");
}
try {
if ((eingabe >= 0) && (45 >= eingabe)) {
comPort->Write(obuffer,0,1);
}
else {
MessageBox::Show("Eingegebenes Ziel ausserhalb des Bereichs (0 ... 45) mm !");
}
}
catch (Exception^ y) {
MessageBox::Show("Fehler beim Senden!");
}
}

um das, was ich machen will, noch mal genau zu beschreiben: nachdem dieser button geklickt wurde, wird die gewünschte position codiert und meinem µC die berechnete Position gesendet. danach soll diese funktion wieder verlassen werden, damit auch der button:

private: System::Void button1_Click(System::Object^ sender, System::EventArgs^ e) {
array ^obuffer = gcnew array(2);
obuffer[0] = 255;
comPort->Write(obuffer,0,1);
this->starte->Enabled = true;
this->zielvariable->Enabled = true;

geklickt werden kann (welcher dem µC sagt, dass er sofort stoppen soll, das ist auch essentiell wichtig, dass das funktioniert!).

gleichzeitig schreibt der µC aber auch aktuelle positionen (ist ja nicht so wichtig) zurück, (welche ich eigentlich auch noch, aber an anderer stelle, behandeln lassen möchte, das ist aber mehr wunsch und entsprechend werd ich mich damit erst viel später befassen) und eben - und das ist wiederrum wichtig - ein 0b 1111 1111 1111 1111 (also 2 byte mit jeweils nur 1 gefüllt) zurück, wenn er seine aufgabe erledigt hat. und genau dann sollten das eingabefeld und der sende-button wieder aktiviert werden. (was sich dann ja wiederum im DataReceviedHandler gemacht wird - oder zumindest versuche ich, das dort zu machen).

 

[biernase]

Hoppla, das wird mir momentan etwas unübersichtlich.
1.Tip von mir: Benenne die Buttons usw. nach der ungefähren Funktion, weil button1, button2 usw. sind ziemlich nichtssagend. Besser wäre btn_start, btn_send, btn_open, cb_com_ports, mtb_eingabe usw...
2. Benutze unbedingt den Debugger. Setze Breakpoints an wichtigen Stellen. Dann sieht Du auch, wie und wann und ob überhaubt der Code angesprungen wird.
Dort kannst Du dann testen ob DataReceviedHandler Daten empfängt. Wenn ja kannst Du diese Daten ja auswerten und Dort das EingabeFeld und den Button wieder aktivieren...

 

[locutus]

zu 1.: ich habe die buttons im entwurf eigentlich auch benannt - nur irgendwo hat vs das wohl nicht für jeden button in jede funktion mitgeschleift. ist zwar unübersichtlich, ich weis aber nicht, ob ich da jetzt einfach was dran ändern kann oder darf.

debugger würde ich liebend gerne verwenden - das problem ist nur, dass ich das projekt nicht compiliert bekomme, so lange ich über die this->... - funktionalität versuche, die buttons wieder zu aktivieren. genau da liegt bei mir ja gerade der hase im pfeffer!

letzten endes ist es bestimmt nur irgend eine kleinigkeit, die ich statt dem this-> eintippen müsste, damit ich direkt auf die funktionalität zugreifen könnte, auf welche ich zugreifen will.

Ich hab eben noch mal den code etwas sortiert - also eigentlich nur noch mal die funktionen umsortiert und vor jeder einzelfunktion noch mal geschrieben was sie machen soll und wann sie ausgeführt wird:


hier der eigencode: ((ich wünscht, ich wüsst jetzt nen befehl für den vbulletin-editor, um das ganze weniger zeilen anzeigen zu lassen, gerade für den 2. teil!)

#pragma endregion
System::IO::Ports::SerialPort^ comPort;
int value;
float eingabe;

/*************************************************************
** Diese Funktion wird beim Klicken von Refresh ausgeführt. **
** Aufgaben: **
** comboBox1 leeren und anschliessend mit allen vorhandenen **
** COM-Ports füllen. **
**************************************************************/
private: System::Void button3_Click(System::Object^ sender, System::EventArgs^ e) {
this->comboBox1->Items->Clear();
this->comboBox1->Items->AddRange(SerialPort::GetPortNames());
}

/************************************************************
** Diese Funktion wird beim Klicken von Select ausgeführt. **
** Aufgaben: **
** Öffnen des in comboBox1 ausgewählten COM-Ports **
** Behandeln von Fehlern beim Öffnen des COM-Ports **
*************************************************************/
private: System::Void button4_Click(System::Object^ sender, System::EventArgs^ e) {
try {
this->select->Enabled = false;
this->refresh->Enabled = false;
this->comboBox1->Enabled = false;
comPort = gcnew SerialPort(this->comboBox1->Text);
comPort->DataReceived += gcnew SerialDataReceivedEventHandler(&Steuerung::Form1::DataReceviedHandler);
comPort->Open();
//startenable = &(this->starte->Enabled);
//zielvarenable = &this->zielvariable->Enabled;
this->kalibrieren->Enabled = true;
this->kalibladen->Enabled = true;
}
catch (Exception^ x) {
MessageBox::Show("Konnte Verbindung nicht herstellen!");
this->kalibrieren->Enabled = false;
this->kalibladen->Enabled = false;
this->refresh->Enabled = true;
this->select->Enabled = true;
this->comboBox1->Enabled = true;
try {
void Dispose(bool disposing);
}
catch (Exception^ y) {}
}
}

/**************************************************************************
** Diese Funktion wird aufgerufen, sobald der Sendebuffer Daten enthält. **
** Aufgaben: **
** Auswertung des Dateneingangs und von Diesem Abhängig ein reaktivieren **
** des Verfahren-Buttons und der Ziel-Eingabe-Box. **
***************************************************************************/
private: static void DataReceviedHandler(System::Object^ sender, System::IO::Ports::SerialDataReceivedEventArgs^ e) {
array ^ibuffer = gcnew array(2);
System::IO::Ports::SerialPort^ cp = (System::IO::Ports::SerialPort^)sender;
cp->Read(ibuffer,0,2);
if((ibuffer[0]==255) && (ibuffer[1]==255)) {
this->starte->Enabled = true;
this->zielvariable->Enabled = true;
}
}

/********************************************************************
** Dieser Funktion wird beim Klicken von Anhalten ausgeführt. **
** Aufgaben: ** 
** Senden von 0xFF an Steuerung zum Anhalten des Gerätes. ** 
** Reaktivieren des Verfahren-Buttons und der Positionseingabebox. **
*********************************************************************/
private: System::Void button1_Click(System::Object^ sender, System::EventArgs^ e) {
array ^obuffer = gcnew array(2);
obuffer[0] = 255;
comPort->Write(obuffer,0,1);
this->starte->Enabled = true;
this->zielvariable->Enabled = true;
}

/************************************************************************
** Diese Funktion wird beim Klicken von Kalibrierung Laden ausgeführt. **
** Aufgaben: **
** Positionsangaben aus Datei einlesen und Programm zur Verfügung **
** stellen. **
** Diese Funktion ist zur Zeit nicht implementiert!! **
*************************************************************************/
private: System::Void button6_Click(System::Object^ sender, System::EventArgs^ e) {
this->kalibrieren->Enabled = false;
this->kalibladen->Enabled = false;
this->starte->Enabled = true;
this->stoppe->Enabled = true; 
this->zielvariable->Enabled = true;
}

/********************************************************************
** Diese Funktion wird beim Klicken von Kalibrieren ausgeführt. **
** Aufgaben: **
** Steuerung jede mögliche Position anfahren lassen und Positions- **
** wert empfangen sowie auswerten und in Datei schreiben. **
** Diese Funktion ist zur Zeit nicht implementiert!! **
*********************************************************************/
private: System::Void button5_Click(System::Object^ sender, System::EventArgs^ e) {
this->kalibrieren->Enabled = false;
this->kalibladen->Enabled = false;
this->starte->Enabled = true;
this->stoppe->Enabled = true; 
this->zielvariable->Enabled = true;
}

/************************************************************************
** Diese Funktion wird beim Klicken von Verfahren ausgeführt. **
** Aufgaben: **
** aus Eingabefeld zielvariable (MaskedTextBox1) Eingabewert einlesen, **
** überprüfen, ob Eingabewert innerhalb Spezifikationen liegt, **
** Codieren der Eingabe und Senden an Steuerung. **
*************************************************************************/
private: System::Void starte_Click(System::Object^ sender, System::EventArgs^ e) {
array ^obuffer = gcnew array(2);
this->starte->Enabled = false;
this->zielvariable->Enabled = false;
try {

eingabe = Convert::ToSingle(this->zielvariable->Text);
value = Convert::ToByte(Math::Round(eingabe * 63 / 45));
obuffer[0] = value;
}
catch (Exception^ x) {
MessageBox::Show("Fehlerhafte Eingabe!");
}
try {
if ((eingabe >= 0) && (45 >= eingabe)) {
comPort->Write(obuffer,0,1);
}
else {
MessageBox::Show("Eingegebenes Ziel ausserhalb des Bereichs (0 ... 45) mm !");
}
}
catch (Exception^ y) {
MessageBox::Show("Fehler beim Senden!");
}
}


private: System::Void groupBox1_Enter(System::Object^ sender, System::EventArgs^ e) {
}
private: System::Void label1_Click(System::Object^ sender, System::EventArgs^ e) {
}
private: System::Void label3_Click(System::Object^ sender, System::EventArgs^ e) {
}
private: System::Void comboBox1_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e) {
}
private: System::Void zielvariable_MaskInputRejected(System::Object^ sender, System::Windows::Forms::MaskInputRejectedEventArgs^ e) {

}
};
}

und der Code, der vorne weg von VS selbst erzeugt wurde:

#pragma once

namespace Steuerung {
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
using namespace System::IO::Ports;

bool* startenable;
bool* zielvarenable;

/// 
/// Zusammenfassung für Form1
/// 
public ref class Form1 : public System::Windows::Forms::Form
{
public:
Form1(void)
{
InitializeComponent();
//
//TODO: Konstruktorcode hier hinzufügen.
//
}

protected:
/// 
/// Verwendete Ressourcen bereinigen.
/// 
~Form1()
{
if (components)
{
delete components;
}
}
private: System::Windows::Forms::Button^ stoppe;
private: System::Windows::Forms::MaskedTextBox^ zielvariable;
protected: 

protected: 

private: System::Windows::Forms::GroupBox^ groupBox1;
private: System::Windows::Forms::Button^ starte;

private: System::Windows::Forms::PictureBox^ pictureBox1;
private: System::Windows::Forms::ProgressBar^ progressBar1;

private: System::Windows::Forms::ComboBox^ comboBox1;
private: System::Windows::Forms::Button^ refresh;

private: System::Windows::Forms::Button^ select;



private: System::Windows::Forms::GroupBox^ groupBox2;
private: System::Windows::Forms::Label^ label1;
private: System::Windows::Forms::Label^ label2;
private: System::Windows::Forms::OpenFileDialog^ openFileDialog1;
private: System::Windows::Forms::GroupBox^ groupBox3;


private: System::Windows::Forms::Button^ kalibladen;


private: System::Windows::Forms::GroupBox^ groupBox4;
private: System::Windows::Forms::StatusStrip^ statusStrip1;
private: System::Windows::Forms::ToolStripStatusLabel^ toolStripStatusLabel1;
private: System::Windows::Forms::SaveFileDialog^ saveFileDialog1;
private: System::Windows::Forms::Button^ kalibrieren;


private: System::ComponentModel::IContainer^ components;

private:
/// 
/// Erforderliche Designervariable.
/// 

#pragma region Windows Form Designer generated code
/// 
/// Erforderliche Methode für die Designerunterstützung.
/// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
/// 
void InitializeComponent(void)
{
this->stoppe = (gcnew System::Windows::Forms::Button());
this->zielvariable = (gcnew System::Windows::Forms::MaskedTextBox());
this->groupBox1 = (gcnew System::Windows::Forms::GroupBox());
this->label2 = (gcnew System::Windows::Forms::Label());
this->label1 = (gcnew System::Windows::Forms::Label());
this->starte = (gcnew System::Windows::Forms::Button());
this->pictureBox1 = (gcnew System::Windows::Forms::PictureBox());
this->progressBar1 = (gcnew System::Windows::Forms::ProgressBar());
this->comboBox1 = (gcnew System::Windows::Forms::ComboBox());
this->refresh = (gcnew System::Windows::Forms::Button());
this->select = (gcnew System::Windows::Forms::Button());
this->groupBox2 = (gcnew System::Windows::Forms::GroupBox());
this->openFileDialog1 = (gcnew System::Windows::Forms::OpenFileDialog());
this->groupBox3 = (gcnew System::Windows::Forms::GroupBox());
this->kalibrieren = (gcnew System::Windows::Forms::Button());
this->kalibladen = (gcnew System::Windows::Forms::Button());
this->groupBox4 = (gcnew System::Windows::Forms::GroupBox());
this->statusStrip1 = (gcnew System::Windows::Forms::StatusStrip());
this->toolStripStatusLabel1 = (gcnew System::Windows::Forms::ToolStripStatusLabel());
this->saveFileDialog1 = (gcnew System::Windows::Forms::SaveFileDialog());
this->groupBox1->SuspendLayout();
(cli::safe_cast(this->pictureBox1))->BeginInit();
this->groupBox2->SuspendLayout();
this->groupBox3->SuspendLayout();
this->groupBox4->SuspendLayout();
this->statusStrip1->SuspendLayout();
this->SuspendLayout();
// 
// stoppe
// 
this->stoppe->Enabled = false;
this->stoppe->Location = System::Drawing::Point(6, 100);
this->stoppe->Name = L"stoppe";
this->stoppe->Size = System::Drawing::Size(155, 32);
this->stoppe->TabIndex = 0;
this->stoppe->Text = L"Anhalten";
this->stoppe->UseVisualStyleBackColor = true;
this->stoppe->Click += gcnew System::EventHandler(this, &Form1::button1_Click);
// 
// zielvariable
// 
this->zielvariable->Enabled = false;
this->zielvariable->Location = System::Drawing::Point(9, 37);
this->zielvariable->Name = L"zielvariable";
this->zielvariable->Size = System::Drawing::Size(77, 20);
this->zielvariable->TabIndex = 1;
this->zielvariable->Text = L"0";
this->zielvariable->MaskInputRejected += gcnew System::Windows::Forms::MaskInputRejectedEventHandler(this, &Form1::zielvariable_MaskInputRejected);
// 
// groupBox1
// 
this->groupBox1->Controls->Add(this->label2);
this->groupBox1->Controls->Add(this->label1);
this->groupBox1->Controls->Add(this->starte);
this->groupBox1->Controls->Add(this->zielvariable);
this->groupBox1->Controls->Add(this->stoppe);
this->groupBox1->Location = System::Drawing::Point(14, 181);
this->groupBox1->Name = L"groupBox1";
this->groupBox1->Size = System::Drawing::Size(167, 139);
this->groupBox1->TabIndex = 2;
this->groupBox1->TabStop = false;
this->groupBox1->Text = L"Steuerung";
this->groupBox1->Enter += gcnew System::EventHandler(this, &Form1::groupBox1_Enter);
// 
// label2
// 
this->label2->AutoSize = true;
this->label2->Location = System::Drawing::Point(6, 21);
this->label2->Name = L"label2";
this->label2->Size = System::Drawing::Size(81, 13);
this->label2->TabIndex = 4;
this->label2->Text = L"Bauteil liegt bei:";
// 
// label1
// 
this->label1->AutoSize = true;
this->label1->Location = System::Drawing::Point(92, 40);
this->label1->Name = L"label1";
this->label1->Size = System::Drawing::Size(69, 13);
this->label1->TabIndex = 3;
this->label1->Text = L"mm auf Band";
// 
// starte
// 
this->starte->Enabled = false;
this->starte->Location = System::Drawing::Point(6, 63);
this->starte->Name = L"starte";
this->starte->Size = System::Drawing::Size(155, 31);
this->starte->TabIndex = 2;
this->starte->Text = L"Verfahren";
this->starte->UseVisualStyleBackColor = true;
this->starte->Click += gcnew System::EventHandler(this, &Form1::starte_Click);
// 
// pictureBox1
// 
this->pictureBox1->Location = System::Drawing::Point(187, 7);
this->pictureBox1->Name = L"pictureBox1";
this->pictureBox1->Size = System::Drawing::Size(329, 366);
this->pictureBox1->TabIndex = 3;
this->pictureBox1->TabStop = false;
// 
// progressBar1
// 
this->progressBar1->Location = System::Drawing::Point(8, 19);
this->progressBar1->Name = L"progressBar1";
this->progressBar1->Size = System::Drawing::Size(155, 22);
this->progressBar1->TabIndex = 3;
// 
// comboBox1
// 
this->comboBox1->FormattingEnabled = true;
this->comboBox1->Location = System::Drawing::Point(4, 19);
this->comboBox1->MaxDropDownItems = 50;
this->comboBox1->Name = L"comboBox1";
this->comboBox1->Size = System::Drawing::Size(80, 21);
this->comboBox1->Sorted = true;
this->comboBox1->TabIndex = 4;
this->comboBox1->SelectedIndexChanged += gcnew System::EventHandler(this, &Form1::comboBox1_SelectedIndexChanged);
// 
// refresh
// 
this->refresh->Location = System::Drawing::Point(90, 19);
this->refresh->Name = L"refresh";
this->refresh->Size = System::Drawing::Size(71, 23);
this->refresh->TabIndex = 5;
this->refresh->Text = L"Refresh";
this->refresh->UseVisualStyleBackColor = true;
this->refresh->Click += gcnew System::EventHandler(this, &Form1::button3_Click);
// 
// select
// 
this->select->Location = System::Drawing::Point(6, 46);
this->select->Name = L"select";
this->select->Size = System::Drawing::Size(155, 23);
this->select->TabIndex = 7;
this->select->Text = L"Select";
this->select->UseVisualStyleBackColor = true;
this->select->Click += gcnew System::EventHandler(this, &Form1::button4_Click);
// 
// groupBox2
// 
this->groupBox2->Controls->Add(this->select);
this->groupBox2->Controls->Add(this->refresh);
this->groupBox2->Controls->Add(this->comboBox1);
this->groupBox2->Location = System::Drawing::Point(14, 13);
this->groupBox2->Name = L"groupBox2";
this->groupBox2->Size = System::Drawing::Size(167, 77);
this->groupBox2->TabIndex = 8;
this->groupBox2->TabStop = false;
this->groupBox2->Text = L"COM-Port";
// 
// openFileDialog1
// 
this->openFileDialog1->FileName = L"openFileDialog1";
this->openFileDialog1->Tag = L"*.calib";
// 
// groupBox3
// 
this->groupBox3->Controls->Add(this->progressBar1);
this->groupBox3->Location = System::Drawing::Point(12, 326);
this->groupBox3->Name = L"groupBox3";
this->groupBox3->Size = System::Drawing::Size(169, 47);
this->groupBox3->TabIndex = 9;
this->groupBox3->TabStop = false;
this->groupBox3->Text = L"Fortschritt:";
// 
// kalibrieren
// 
this->kalibrieren->Enabled = false;
this->kalibrieren->Location = System::Drawing::Point(6, 21);
this->kalibrieren->Name = L"kalibrieren";
this->kalibrieren->Size = System::Drawing::Size(155, 23);
this->kalibrieren->TabIndex = 10;
this->kalibrieren->Text = L"Kalibrieren";
this->kalibrieren->UseVisualStyleBackColor = true;
this->kalibrieren->Click += gcnew System::EventHandler(this, &Form1::button5_Click);
// 
// kalibladen
// 
this->kalibladen->Enabled = false;
this->kalibladen->Location = System::Drawing::Point(6, 50);
this->kalibladen->Name = L"kalibladen";
this->kalibladen->Size = System::Drawing::Size(155, 23);
this->kalibladen->TabIndex = 11;
this->kalibladen->Text = L"Kalibrierdatei laden";
this->kalibladen->UseVisualStyleBackColor = true;
this->kalibladen->Click += gcnew System::EventHandler(this, &Form1::button6_Click);
// 
// groupBox4
// 
this->groupBox4->Controls->Add(this->kalibrieren);
this->groupBox4->Controls->Add(this->kalibladen);
this->groupBox4->Location = System::Drawing::Point(14, 96);
this->groupBox4->Name = L"groupBox4";
this->groupBox4->Size = System::Drawing::Size(167, 79);
this->groupBox4->TabIndex = 12;
this->groupBox4->TabStop = false;
this->groupBox4->Text = L"Kalibrierung";
// 
// statusStrip1
// 
this->statusStrip1->Items->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(1) {this->toolStripStatusLabel1});
this->statusStrip1->Location = System::Drawing::Point(0, 384);
this->statusStrip1->Name = L"statusStrip1";
this->statusStrip1->Size = System::Drawing::Size(521, 22);
this->statusStrip1->SizingGrip = false;
this->statusStrip1->TabIndex = 13;
this->statusStrip1->Text = L"statusStrip1";
// 
// toolStripStatusLabel1
// 
this->toolStripStatusLabel1->Name = L"toolStripStatusLabel1";
this->toolStripStatusLabel1->Size = System::Drawing::Size(118, 17);
this->toolStripStatusLabel1->Text = L"toolStripStatusLabel1";
// 
// Form1
// 
this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
this->ClientSize = System::Drawing::Size(521, 406);
this->Controls->Add(this->statusStrip1);
this->Controls->Add(this->groupBox4);
this->Controls->Add(this->groupBox3);
this->Controls->Add(this->groupBox2);
this->Controls->Add(this->pictureBox1);
this->Controls->Add(this->groupBox1);
this->FormBorderStyle = System::Windows::Forms::FormBorderStyle::Fixed3D;
this->MaximizeBox = false;
this->Name = L"Form1";
this->SizeGripStyle = System::Windows::Forms::SizeGripStyle::Hide;
this->Text = L"Greiferarmsteuerung";
this->groupBox1->ResumeLayout(false);
this->groupBox1->PerformLayout();
(cli::safe_cast(this->pictureBox1))->EndInit();
this->groupBox2->ResumeLayout(false);
this->groupBox3->ResumeLayout(false);
this->groupBox4->ResumeLayout(false);
this->statusStrip1->ResumeLayout(false);
this->statusStrip1->PerformLayout();
this->ResumeLayout(false);
this->PerformLayout();
this->comboBox1->Items->Clear();
this->comboBox1->Items->AddRange(SerialPort::GetPortNames());
}

beim kompilieren bekomm ich aber leider folgende fehlermeldungen:

Fehler 3 error C2355: 'this': Nur innerhalb nicht statischer Memberfunktionen verfügbar
Fehler 4 error C2227: Links von "->starte" muss sich ein Zeiger auf Klassen-/Struktur-/Union-/generischen Typ befinden.
Fehler 5 error C2227: Links von "->Enabled" muss sich ein Zeiger auf Klassen-/Struktur-/Union-/generischen Typ befinden.
(davor noch 2 warnungen wegen den x und y als unreferenzierte variablen, dabei sind das nur error-handler und werden nicht weiter benötigt. zusätzlich der block 3, 4, 5 noch ein 2. mal. )


ich hoffe mal, das ist so jetzt etwas übersichtlicher. wahrscheinlich würde es in nem code-editor noch mal sehr viel übersichtlicher werden, da dort ja wenigstens eine farbige hervorhebung gemacht wird...

 

[biernase]

Ich komme jetzt nicht mehr dazu das zu analysieren.

Klick doch mal in der Fehlerliste auf den Fehler und Du bekommst die Zeile angezeigt, in der der Fehler ist. Dann kommentier diese Zeilen aus und starte den Debugger, dann lass Dir in der Überwachung mal this anzeigen.
Sonst am Freitag kann ich erst wieder...

Viele Grüsse
biernase

 

[locutus]

ich hab jetzt mal - nach ewigen herumgesuche in den elementen des Buttons - folgende position für den enabled-wert gefunden:

(((System::Windows::Forms::Control^)((((System::Windows::Forms::ButtonBase^)(starte)))->ImageKey)))->Enabled

aber: wenn ich das als wert angebe und true setzen will, gibt mir der compiler trotzdem ewig viele fehler aus:

Fehler 3 error C2843: 'Steuerung::Form1::starte': Die Adresse eines nicht statischen Datenmembers oder einer Methode eines verwalteten Typs kann nicht übernommen werden
Fehler 4 error C2440: 'Typumwandlung': '' kann nicht in 'System::Windows::Forms::ButtonBase ^' konvertiert werden
Fehler 5 error C2227: Links von "->ImageKey" muss sich ein Zeiger auf Klassen-/Struktur-/Union-/generischen Typ befinden.
Fehler 6 error C2227: Links von "->Enabled" muss sich ein Zeiger auf Klassen-/Struktur-/Union-/generischen Typ befinden.


was wohl so viel heißen soll wie "Das darfst du nicht machen!" -.-
langsam glaub ich echt, ich würde wesentlich besser wegkommen, wenn ich mir jetzt visual c# aus der msdnaa ziehe und dort alles noch mal mache. vor allem auch, da visual studio 2010 auch noch .net 4.0-features zu nutzen scheint, wodurch das programm natürlich nicht gerade auf jedem rechner lauffähig wäre.

 

[biernase]

So, habe mal das Programm geladen.
1) Habe wohl nur ComPort COM1.
2) Weiss nicht was der so macht.
3) Bei mir wird bei button4 aka Select der DataReceivedHandler nicht angesprungen.
4) this im DataReceivedHandler gibt Fehlermeldung, daher auskommentiert.
5) Versuch doch mal eine Member-Variable im DataReceivedHandler zu setzen und diese nach dem Handler irgendwie auszuwerten..
6) C# kann man auch unter NET2.0 kompilieren.
7) C++ Windows Forms macht Augenkrebs

Gute N8

 

[locutus]

joa, c++ ist wirklich ziemlich unangenehm vom codelayout. -.-

die datareceivedhandler soll an und für sich nur angesprungen werden, wenn daten in den in-buffer des comports geschrieben werden. von daher müsste das verhalten vollkommen normal sein.

ich hatte mich jetzt die tage mal hingesetzt und das programm noch mal in c# aufgezogen, da hat dann letzten endes wirklich alles so funktioniert, wie es sollte. (die datareceived-handler-funktion einfach nicht als static definiert und schon gings!) also von daher läuft das programm jetzt bei mir zumindest so wie es soll - nur eben in ner anderen sprache.

allerdings verwundert es mich trotzdem auch weiterhin, dass es nicht möglich ist, aus einer static-funktion einzelne elemente des form1-fensters zu verändern.

aber vielen dank schon mal für die mühen! ^^