Ich möchte folgendes Problem in den Griff bekommen, ich weiss aber nicht, was die beste Lösung dafür ist, folgendes:

Ich möchte gerne "variabel" mehrere Schleifendurchläufe (Repeat->Until, oder do while ...) programmieren. Diese Schleifendurchläufe schicken dann ständig bestimmte Werte an mein USB-Port. Diese muss ich per Button stoppen, aber auch wieder fortführen können. Das Problem liegt darin, da ich mehrere Schleifen gleichzeitig fahren möchte, soll man da mit mehreren Timern, Threads oder gar mit etwas anderem hantieren???
Welches ist die eleganteste Lösung dafür, weiterhin muss ich nämlich auch auf die Geschwindigkeit der Schleifendurchläufe, sowie auf bestimmte Parameter, die in der Schleife eine große Rolle spielen, einwirken können, dieses natürlich in Echtzeit, ohne dass das Hauptprogramm dadurch beeinflusst wird.

Wer kann mir da einen guten rat, oder vielleicht sogar einen kl. Quelltext zur Verfügung stellen????

Vielen dank schonmal im voraus.

IMHO ist das am besten mit Threads zu lösen. Allerdings solltest du dir bewusst sein, dass auch bei Threads niemals zwei Schleifen genau gleichzeitig ausgeführt werden, sondern nur die Rechenzeit zwischen den Threads aufgeteilt und ständig zwischen den Threads hin und her gewechselt wird.

MfG
Binärbaum

Nimm Threads, damit müsste das am besten gehen. du kannst dem Thread dann ach propertys verpassen, auf die er dann zugreifen kann. Einfach den Konstruktor überschreiben ...

Zitat von fit4net:

wie viele threads kann ich denn überhaupt gleichzeitig laufen lassen?????

Auf einem NT-System können glaub' ich so bis zu 1024 Threads laufen, mach dir da mal keine Sorgen ...

Ich bekomme nach einiger Ziet immer eine Fehlermeldung, ist aber verschieden, mal eher und manchmal etwas später:
Da stimmt etwas mit der canvas-fkt. nicht, was mache ich denn da falsch????

Fehlermeldung:
Im Projekt ...... Meldung: 'Leinwand/Bild erlaubt kein Zeichen'......

WARUM????


Programmcode (ausschnitt):

function Thread1(p: Pointer): Integer;
var
lblCounter: TStaticText;
xpos:integer;
xpos_up:integer;
begin
// Variablen initialisieren
xpos:=dmxblock[4];
xpos_up:=0;
lblCounter := PTThreadParameter(p)^.FLabel;
// Code ausführen
with form1.paintbox1.Canvas do
begin
while bRunning = 0 do
begin
lblCounter.Caption := IntToStr(xpos);
if (xpos<255) and (xpos_up=0) then
begin
xpos:=xpos+1;
end
else xpos_up:=1;
if (xpos > 0) and (xpos_up=1) then
begin
xpos:=xpos-1;
end
else xpos_up:=0;

dmxblock[4]:=xpos;
dmx_result:= DasHardCommand(DHC_DMXOUT, 512, @dmxblock);
moveto(xpos,dmxblock[5]);
Pixels[xpos,dmxblock[5]] := clred;

sleep(xtimer);
end;
end;
// freigeben des Speichers für die Struktur auf der der zeiger zeigt
FreeMem(p);
end;

Mach das am Besten mit dem TThread-Objekt, ist einfach übersichtlicher.
Und bite schließe deine Quellcodes in [delphi][/delphi] -Tags ein.

In dem Thread überschreibst du dann den Konstruktor, und setzt deine Parameter. Dann kanns losgehen.

Alles, was sichtbar ist, muss mittels synchronize() aufgerufen werden.

Zitat von fit4net:

wie wandel ich diesen thread denn nun um, dass es mit dem sycronize hinhaut, ich bin da noch nicht sooooo fit????

So ähnlich:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TMyThread: class (TThread)
Ergebnis: String;

procedure Execute; override;
procedure VCL_Result;
end;


procedure TMyThread.Execute;
begin
  // Der Threadcode

  Ergebnis := 'fertig';
  synchronize (VCL_Result);
end;

procedure VCL_Result,
begin
Form1.Label1.Caption := Ergebnis;
end;

P.S. "11"