Visual C++ CLR(.net2012) Serialport, Empfang

[Mani (Gast)]

Hallo
Ich habe eine Frage, ich habe in einer eigenen Klasse(RS232) eine RS232 
Behandlung geschrieben.
Ich kann über ein Form die RS232 einstellen, Öffnen und Schließen.
Nun möchte ich von der Klasse RS232 die empfangenden Daten 
weiterleitern.

Was ich bisher gemacht haben ist mir ein Event in meiner RS232 Klasse zu 
schreiben und nun wollte ich ganz einfach die

_serialport->DataReceived +=gcnew SerialDataReceivedEventHandler(DataReceivedHandler);

nutzen um in dem:

void DataReceivedHandler(Object^ sender,SerialDataReceivedEventArgs^ e)
{
  SerialPort^ sp = (SerialPort^)sender;
  String^ indata = sp->ReadExisting();
  Console::Write(indata);
}

mir ein Event auszulösen und die Daten im "indata" weiterzureichen um im 
Form damit zu arbeiten.

Aber leider ist der DatareceivedHandler ein eigenes Thread und ich steh 
gerad auf dem Schlauch wie ich die Daten rüberbekomme.

Hat einer eine Idee?
Invoke ist wohl ein Stichwort aber der scheint das in dem Punkt nicht zu 
kennen.

Der Handler wird in meiner RS232_init() bereit gestellt:

int RS232_class::RS232_init()
  {
    try
    {
      _serialport->DataReceived +=gcnew SerialDataReceivedEventHandler(DataReceivedHandler);
      _serialport->ReadTimeout=500;
      _serialport->WriteTimeout=500;
      _serialport->Open();
      

      RS232_class::RS232_empfang("t");

    }
    catch(System::IO::IOException^ e)
    {
      return 0;
    }
    
    
    return 1;
  }

[bluppdidupp (Gast)]

http://stackoverflow.com/questions/661561/how-to-update-the-gui-from-another-thread-in-c
...die zweite Antwort würde ich mir ansehen. "this" wäre in deinem Falle 
dann vermutlich die Form?

[Mani (Gast)]

Danke für den Link.
Glaub aber ich hab eine andere Richtung gedacht gehabt und frag mich ob 
es überhaupt geht.
Ich wollte quasi das Event abfangen in meiner RS232 Routine und die dann 
weiterleiten und selber ein Event starten, das irgendeine übergeordnete 
Form ein Event bekommt und darauf reagieren kann.
Die meisten Routinen beschäftigen sich damit das Event direkt in der 
Form einzubinden, ich wollte ein zwischenschritt über eine eigene 
Klasse.

[bluppdidupp (Gast)]

Dann musst du in deinem DataReceived-EventHandler in der RS232_class 
doch nur  dein eigenes Event feuern?

this.meinEigenesEvent.Invoke(indata);

...mit dem Thread darf sich der Nutzer der RS232_class dann rumschlagen.

[Mani (Gast)]

So dachte ich mir das auch, leider bekomm ich dann die Meldung das es 
kein statischer Member sei..
Und ein Invoke lässt er mich irgendwie nicht benutzen, oder mach ich was 
falsch mit meinem:
//  RS232_class::RS232_empfang("test");
// gibt fehler, da keine statische Member?
?

Klassendeklarationen:

//Eventhandler
delegate void RS232_EmpfangEventHandler(String^);
 
ref class RS232_class
{
private:
    static SerialPort^ _serialport = gcnew SerialPort;
 
    String^ d;
   
public:
    //
    delegate int RS232_init(SerialPort^ _serialport);
    delegate void RS232_close(SerialPort^ _serialport);
    delegate void RS232_config(SerialPort^ _serialport_in, SerialPort^ _serialport_out);
    delegate String^ RS232_getport(void);
 
    //
    event RS232_EmpfangEventHandler^ RS232_empfang;
 
    //interne
    void RS232(void);
    bool RS232_anfrage_open(void);
    int RS232_init();
    void RS232_close();
    void RS232_config(SerialPort^ _serialport_in);
    String^ RS232_getport(void);
 
    bool RS232_senden(String^ Sin);
};  


  void DataReceivedHandler(Object^ sender,SerialDataReceivedEventArgs^ e)
{
    SerialPort^ sp = (SerialPort^)sender;
    String^ indata = sp->ReadExisting();
    Console::Write(indata);
 
//  RS232_class::RS232_empfang("test");
// gibt fehler, da keine statische Member?
}

Methoden:

 
int RS232_class::RS232_init()
    {
        String^ s;
        s="test hallo";
        try
        {
            _serialport->DataReceived +=gcnew SerialDataReceivedEventHandler(DataReceivedHandler);
            _serialport->ReadTimeout=500;
            _serialport->WriteTimeout=500;
            _serialport->WriteBufferSize=100;
            _serialport->Open();
 
//          Console::WriteLine(Thread::CurrentThread->GetData);
            RS232_class::RS232_empfang("test");
        }
        catch(System::IO::IOException^ e)
        {
            return 0;
        }
       
       
        return 1;
    }

[bluppdidupp (Gast)]

Ist ja auch kein statischer Member - "RS232_class::" wird nicht 
benötigt.

In C# würde man einfach sowas scheiben:

if (RS232_empfang!=null) // Ist überhaupt ein Event-Listener registriert?
{
   // Japp - Event feuern:
   RS232_empfang("Daten");
}

[Mani (Gast)]

Hmm nehm ich RS232_empfang(); direkt, meckert er das er das nicht kennt.

void DataReceivedHandler(Object^ sender,SerialDataReceivedEventArgs^ e)
{
  SerialPort^ sp = (SerialPort^)sender;
  String^ indata = sp->ReadExisting();
  Console::Write(indata);
  
//  Console::WriteLine(Thread::CurrentThread->GetData);
  RS232_empfang("test");
  

}

Meldung:
1>RS232.cpp(24): error C3861: "RS232_empfang": Bezeichner wurde nicht 
gefunden.


Oder versteh ich das falsch?

[bluppdidupp (Gast)]

Hmm, dein DataReceivedHandler() scheint außerhalb der Klasse definiert 
zu sein? Sollte der nicht unter private stehen?

[Mani (Gast)]

Hmm in einem Buch das ich genommen hatte wurd das Eventsystem so 
beschrieben, das der Handler zum auslösen außerhalb der Klasse stehen 
soll..

Wenn ich mir ein Handler in der Datareceived erstell stürzt es ab, 
vermutlich weils ins nirgendwo hinzeigt.

Auch wenn ich mein Datareceived Handler unter Privat setz innerhalb 
meiner Klasse, findet der mein RS232_empfang nicht innerhalb der 
Datareceived.

Bisher fand ich alles ziemlich Logisch und Nachvollziehbar aber gerade 
stehe ich auf dem Schlauch.
Mein Event funktioniert auch, weil es innerhalb von RS232_init wird eins 
geworfen und im Form kann ich das abfangen und auf der Console ausgeben.

Ich hab Console als Debugmonitor drin, neben der Form.

[bluppdidupp (Gast)]

Gut das scheint wohl eine C++/CLI Besonderheit zu sein.
In C# wäre es nichtmal möglich Funktionen außerhalb einer Klasse zu 
definieren ;D

Dann muss wohl jemand mit C++/CLI Kenntnissen her ;D

[Mani (Gast)]

Ich schätz das es einfach eine globale Variable ist, bzw ein gloaber 
Verweis. Danke dir aber für deine Tipps.
Ich glaub irgendwann geh ich auch nach C#, wollte nur erstmal ein 
Grundgerüst bauen bei CLI.

Hoffe einer hat noch eine Idee zu dem Problem, ich schein wohl 
irgendetwas zu übersehen oder hab was falsch verstanden.

[Mani (Gast)]

Ich mal wieder..
Ich habe es mal in C# versucht was zu coden.

namespace RS232_serialport
{
    public delegate void RS232_Receive_Handler(string datain);//object sender, EventArgs e);

    public class RS232
    {
        private SerialPort SP = new SerialPort("COM1");
        public RS232_Receive_Handler _RS232_receive_handler;

        public RS232()
        {

        }

        public void RS232_init()
        {
            SP.BaudRate = 9600;
            SP.Parity = Parity.None;
            SP.StopBits = StopBits.One;
            SP.DataBits = 8;
            SP.Handshake = Handshake.None;
            SP.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

            SP.Open();
            RS232_empfang("teststring");
        }

        public bool RS232_isopen()
        {
            if (SP.IsOpen) { return true; }
            return false;
        }

        public void RS232_close()
        {
            SP.Close();
        }

        public void RS232_empfang(string datain)
        {
           _RS232_receive_handler(datain);
        }

        public void RS232_cons(string datain)
        {
            RS232_empfang(datain);
        }

        private static void DataReceivedHandler(object sender,SerialDataReceivedEventArgs e)
        {
            RS232 _rs232 = new RS232();

            SerialPort sp = (SerialPort)sender;
            string indata = sp.ReadExisting();
       //     Console.WriteLine("Data Received:");
            //    Console.Write(indata);
            //_rs232.RS232_cons(indata);
            
        }

    }
}

Einglich alles wie in C++ nur in C# geschrieben. Aber ich bekomme eine 
Nullexception, sobald ich von der Datareveice ins RS232_empfang(datain); 
geht, da in RS232_empfang scheinbar die 
"_RS232_receive_handler(datain);" nicht mehr auffingbar ist.
Hat einer eine Idee?
Invoke geht bei den Punkt irgendwie nicht und ich find meist nur direkt 
in GUI hilfe in Verbindung mit Invoke.

Ich will einglich die Daten aus dem Reveicehandler rausschicken zu 
meinem eigenen Handler, der dann in einer Gui extra verwaltet wird.

Ist das ungewöhnlich die ganze RS232 geschichte in eine extra Klasse zu 
verpacken, wo auch die ganze Datenverarbeitung drin steckt?
In der GUI wollt ich dann einglich nur aufrufe machen, zb RS232_config, 
init...