4. Thread mit RS232

Thread mit RS232

  • F

    Ich habe einen Thread erstellt unt getestet, und eigendlich geht das auch alles.
    Das Problem liegt aber in folgendem.
    Wenn ich das Programm starte, kann ich sie serielle Schnittstelle öffnen, und meinen Ventilator anschmeissen, und wieder aus, alles OK. Meldungen für an und aus
    werden ausgegeben.(Hauptthread)

    Wenn ich den Thread starte, und danach den Lüfter an oder ausschalten möchte, geht das nicht mehr! Es kommen zwar noch die Meldungen Lüfter an bzw. aus, aber die serielle Schnittstelle macht nichts mehr!

    Da ich das im Hauptthread habe dürfte das doch kein Problem sein mit der Deklaration der Schnittstelle, oder?

    Woran kann das liegen?

    0
  • B

    vielleicht bin ich der einzige, aber aus deinem text lese ich nur, dass dein ein und ausschalten nicht klapt.. weder, wo ungefähr der fehler liegen könnte, noch was du in deinen thread machst, noch sonstige infos..
    versuche doch mal das problem genäuer zu schildern und auch etwas von deiner ansteuerungsumgebung.. (zB was macht thread1 und thread2?)

    BigNeal

    0
  • F

    Hm,
    das ist im moment noch eine Programmierübung, und im Thread 2 wird eigendlich nichts gemacht, (Ein Zähler zählt bis 100000, und gibt dann einen Wert auf das Memo Feld aus).

    Das Problem liegt darin, das die Ansteuerung solange über RS232 Tadelos funktioniert, bis ich den 2. Thread über einen SpeedButton Starte.
    Danach läuft der 2. Thread, gibt den Wert aus, und der 1. Thread läuft nicht mehr richtig.
    Die Meldungen kommen noch, das die Ansteuerung erfolgt, aber sie erfolgt nicht mehr über die RS232. Der Lüfter bleibt entweder an, oder aus, je nachdem wann ich den Thread starte.
    Ich habe mich hierbei an die Programmiervorlage zum Thread aus der Builder Hilfe gehalten, hier auf der Seite.
    Die Ansteuerung erfolgt üher die port.dll.

    Den relevanten Code füge ich hier mal ein.

    Unit1.cpp

    #include <vcl.h>
#pragma hdrstop
#include "com.cpp"
#include <conio.h>
#include <iostream.h>
#include <windows.h>
#include "Unit1.h"
#include "Unit2.h"
//#include <time.h>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
bool timer=true, pause=false;

void __fastcall TForm1::SpeedButton6Click(TObject *Sender)
{
  FNewThread =  new PWM(false); //Jetzt haben wir eine in der ganzen Klasse sichtbare Instanz.
  FNewThread->OnTerminate = DeleteThread;
}

void __fastcall TForm1::DeleteThread(TObject* Sender)
{
       FNewThread->Terminate();
}

    unit1.h

    #ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Buttons.hpp>
#include <ExtCtrls.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Von der IDE verwaltete Komponenten
        TMemo *Memo1;
        TSpeedButton *SpeedButton1;
        TSpeedButton *SpeedButton2;
        TSpeedButton *SpeedButton3;
        TSpeedButton *SpeedButton4;
        TSpeedButton *SpeedButton5;
        TSpeedButton *SpeedButton6;
        TTimer *Timer1;
        TTimer *Timer2;
        TSpeedButton *SpeedButton7;
        void __fastcall SpeedButton1Click(TObject *Sender);
        void __fastcall SpeedButton2Click(TObject *Sender);
        void __fastcall SpeedButton3Click(TObject *Sender);
        void __fastcall SpeedButton4Click(TObject *Sender);
        void __fastcall SpeedButton5Click(TObject *Sender);
        void __fastcall SpeedButton6Click(TObject *Sender);
        void __fastcall Timer1Timer(TObject *Sender);
        void __fastcall Timer2Timer(TObject *Sender);
        void __fastcall SpeedButton7Click(TObject *Sender);
private:	// Anwender-Deklarationen
        TThread* FNewThread; //Vorfahrobject kann alle abgeleiteten Nachfahren transportieren.
        void __fastcall DeleteThread(TObject* Sender);
public:		// Anwender-Deklarationen
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

    Unit2.cpp

    #include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------

__fastcall PWM::PWM(bool CreateSuspended)
        : TThread(CreateSuspended)
{
 FreeOnTerminate = true;
}
//---------------------------------------------------------------------------
void __fastcall PWM::Execute()
{
 int b=0;
        //---- Hier den Thread-Code plazieren----
  Form1->Memo1->Lines->Add("-> Thread Arbeitet");
  for (int i=0; i<20000; i++){ b=i;}
    Form1->Memo1->Lines->Add (b);

}
    0
  • F

    Kennt das Problem denn keiner?

    0
  • E

    versuch es damit hier:

    void __fastcall TForm1::SpeedButton6Click(TObject *Sender)
{
  if(FNewThread != NULL)
  {
    FNewThread->Terminate();
    FNewThread = NULL;
  }
  FNewThread =  new PWM(false); //Jetzt haben wir eine in der ganzen Klasse sichtbare Instanz.
  FNewThread->OnTerminate = DeleteThread;
}

void __fastcall TForm1::DeleteThread(TObject* Sender)
{
  FNewThread->Terminate();
  FNewThread = NULL;
}
    0
  • F

    Danke Dir!!
    Habe die Veränderungen vorgenommen, hat aber leider nicht die gewünschte Wirkung.
    Allerdings habe ich bemerkt, das wenn ich den Thread starte, und anschließend den COM Port neu schließe und wieder öffne, dann geht es.

    Allerdings ist das ja nun kein Zustand, und der Fehler muß ja noch irgendwo zu finden sein.

    Fällt die daraufhin noch was ein?

    0
  • J

    Schliesst du den Comport denn auch beim Beenden des Threads?

    0
  • F

    Nein, mache ich nicht.
    Im moment ist das noch ne Übung zum Verständnis, und später soll die PWM im Thread laufen, und dort mehrere Lüfter gleichzeitig steuern.

    Aber ich verstehe nicht warum der den Zugriff verliert nur weil ich ein Schleife hochzähle.

    Was ich eben noch bemerkt habe, wenn ich den Lüfter starte, dann den Thread,
    und dann den COM Port öffne und Schliesse geht es ja kurzfristig wieder wie oben erwähnt, UND

    Sobald der Thread beendet ist, geht es wieder nicht, und ich muß den Port erneut schliessen und Öffnen.

    0
  • J

    Farnsworth schrieb:

    Nein, mache ich nicht.

    Wieso nicht? Du öffnest ihn ja auch im Thread nehme ich an?

    0
  • F

    Nein, das kommt erst später, wie gesagt im moment erfolgt die gesammte Ansteuerung im Hauptthread, und im erzeugten Thread, habe ich nur die Zählschleife ohne jegliche Ansteuerung.
    Deswegen verstehe ich das auch nicht warum er die "Verbindung verliert".
    Ich wollte eigendlich erst dieses miese Problem gelöst haben bevor ich "ernsthaft"
    weiter mache.

    0
  • J

    Achso... habs mri jetzt nochmals angeschaut: Du hast eindeutig einen Kommentar der im cpp-File jedes neuen Thread-Objektes steht nicht gelesen oder nicht befolgt. Da steht was bezüglich Synchronize. Lies es, wende es an.

    Ausserdem solltest du dem Thread mindestens ein Sleep(0) / Schleifendurchlauf beibringen, damit das Betriebssystem die Prozessorzeit besser verteilen kann.

    0
  • J

    Ausserdem frage ich mich was der Aufruf von Terminate() im OnTerminate-Ereignis soll? Schon mal geschaut wann OnTerminate ausgeführt wird?

    -junix

    0
  • F

    Ich habs mir nicht ausgedacht, habe das da im Beispiel gelesen, und es angewandt.

    Ich glaub ich gebs langsam auf, ich füge das aus dem Beispiel ein und nur Fehler, weil logischerweise die Deklarationen fehlen, aber wie werden die wieder realiesiert?

    Es muß doch irgendwo eine vernünftige Anleitung existieren die nicht die hälfte weglässt.

    Ich kann nicht einmal das Beispielprojekt selber kompilieren weil ihm jetzt auf einmal bibliotheken fehlen, obwohl hier nun auch keine anderen verwendet werden.

    0
  • F

    Ich danke die Trotzdem für deine Mühen!! 👍

    0
  • B

    mach doch mal das thread tut hier auf cplusplus.de..
    habe ich auch mal gemacht und klappte super

    0
  • F

    http://bcb-tutorial.c-plusplus.net/inhalt.html
    habe mich versucht an das zu halten.

    Wo befindet sich denn ein weiters?
    die Seite www.cplusplus.de
    ist in Überarbeitung.
    und auf der des Forum ist nur der verweis auf verschiedene Bücher über die allgemeine Programmierung.
    Habe 2 angetestet, aber nichts über Threads.

    gruß

    Farnsworth

    0
  • B

    genau das meinte ich..

    junix schrieb:

    Ausserdem solltest du dem Thread mindestens ein Sleep(0) / Schleifendurchlauf beibringen, damit das Betriebssystem die Prozessorzeit besser verteilen kann.

    junix schrieb:

    Du hast eindeutig einen Kommentar der im cpp-File jedes neuen Thread-Objektes steht nicht gelesen oder nicht befolgt. Da steht was bezüglich Synchronize. Lies es, wende es an.

    junix schrieb:

    Ausserdem frage ich mich was der Aufruf von Terminate() im OnTerminate-Ereignis soll? Schon mal geschaut wann OnTerminate ausgeführt wird?

    hast du diese kommentare mal überprüft und in deinem code angepasst?

    was brauchst du für eine RS232-Komponente?

    0
  • F

    // Wichtig: Methoden und Eigenschaften von Objekten der VCL können nur in
    // in Methoden verwendet werden, die Synchronize aufrufen, z.B.:
    //
    // Synchronize(UpdateCaption);
    //
    // wobei UpdateCaption so aussehen könnte:
    //
    // void __fastcall Unit2::UpdateCaption()
    // {
    // Form1->Caption = "In Thread aktualisiert";
    // }

    Ich gehe davon aus das ihr das meint.
    mit der Anwendung haperts so ein bißchen:(
    ich habe mich da ans Beispiel Programm gehalten aber wie gesagt da fehlen im .lib dateien (warum auch immer, nur für das Programm).
    Vielleicht kriege ich das in einer ruhigen Stunde mal hin, aber im moment versteh ich die Umsetzung nicht.

    Die Ansteuerung wird über die Port.dll gemacht die in der com.cpp deklariert wird.
    Oder was meinst du mit Komponente?

    0
  • B

    was für einen BCB hast du?
    und welche dateien fehlen?

    eine Komponente ist zum beispiel der Button den du oben aus der auswahl auf deine Form ziehen kannst.

    hast du die com.cpp selber geschrieben?

    0
  • F

    ich habe den 5.0 prof.

    vclado50.bpi
    Dss50.bpi
    VCLmid50.bpi
    webmid50.bpi
    turbodb41150.bpi

    die dateien fehlen

    die com.cpp hat mein Lehrer in der Schule geschrieben, ich habe sie nur um dts etc. erweitert.

    //Die Datei wird benötigt um auf die dll zugreifen zu können
//Funktion ladeDLL() kann als globale Funktion
//aufgerufen werden
//Port.dll muss im aktuellen Verzeichnis stehen
//Rückgabe = false - wenn DLL nicht geladen werden kann

#include <vcl.h>

HINSTANCE hdll;    			//hinstance ist ein Variablentyp der API Ebene
typedef UINT(CALLBACK *open)(char *);	//eigener Datentyp kreirt (Zeigerdatentyp auf eine Funktion) 
					//Open ist der Name Zeiger auf Char muß übergeben werden,
					//unsigned int wird zurück geliefert. 
					//Callback bringt das Betriebssystem ins Spiel
open opencom;				//Variable des neuen Datentyps wird angelegt ( Typ open)

typedef UINT (CALLBACK *read)();
read readbyte;

typedef (CALLBACK *send)(UCHAR);	//5 mal für die 5 Funktionen die wir brauchen
send sendbyte;

typedef (CALLBACK *close)();
close closecom;

typedef (CALLBACK *time_)(UINT);
time_ timeout;

typedef WORD (CALLBACK *dsr_)();
dsr_  dsr;

typedef WORD (CALLBACK *rts_)(WORD);
rts_  rts;

typedef WORD (CALLBACK *txd_)(WORD);
txd_  txd;

typedef WORD (CALLBACK *dtr_)(WORD);
dtr_  dtr;
//Die funktionen müssen mit den existierenden Funktionen verknüpft werden
//-----------------------------------------------------
bool ladeDLL (void) {
  hdll = LoadLibrary("PORT.DLL");
  if(hdll == NULL)
  {
      return false;			//wenn false, dann datei nicht gefunden
  }
  else
  {
      opencom = (open)GetProcAddress(hdll,"OPENCOM");	//übergebe den handle auf die Datei
      readbyte = (read)GetProcAddress(hdll,"READBYTE");	//Beim aufruf in c wird dann die funktion in der dll ausgeführt
      sendbyte = (send)GetProcAddress(hdll,"SENDBYTE");
      closecom = (close)GetProcAddress(hdll,"CLOSECOM");
      timeout = (time_)GetProcAddress(hdll,"TIMEOUT");
      rts = (rts_)GetProcAddress(hdll,"RTS");
      txd = (txd_)GetProcAddress(hdll,"TXD");
      dtr = (dtr_)GetProcAddress(hdll,"DTR");
      return true;
  }
}

    Also eine Komponente gibt es da nicht, das läuft direkt über diese Datei.
    Im Programm schreibe ich dann einfach txd(1); und schon liegen da 12V an.

    Soweit so gut.

    den Ventilator steuer ich dann über ein Schieberegister an.

    0
Anmelden zum Antworten