Autor Beitrag
Ducky
Hält's aus hier
Beiträge: 11



BeitragVerfasst: Fr 25.06.04 16:55 
Hallo an alle,
ich hoffe mir kann jemand helfen ! :?

Ich Arbeite an einem Project in dem ich einiges an Hardware ansteuern muß, leider klappt nicht alles so wie ich es mir vorstelle. (wie verwunderlich) :wink:

Nun zu meinem Problem:

Durch Ausscheiden eines Mitentwicklers habe ich seine bisher geleistete Arbeit weiter entwickelt.
Seit einigen Wochen denke ich das die classen zur Laufzeit nicht sauber erstellt werden.
Da es ein recht komplexes Project ist und es im prinzip der Firma Gehört in der ich Arbeite möchte ich nur Teile des Source zeigen.
Hier also erst mal das wo ich den fehler vermute.


ausblenden volle Höhe Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
unit Hardware;  { definiert Objekte für Etikettierer, Scanner u.s.w. }
                { Stand: 09.01.03 -1 }
{$define DII }

interface

uses
  Contnrs, Classes, Forms, Windows, uCiaComPort, ExtCtrls, Dialogs, Math;

Type
  TFoerderVS     = (V_kein,
                    V_Absenkeinheit,
                    V_Dreheinheit,
                    V_Vakuum,
                    V_Separator,
                    V_Hubeinheit,
                    V_Endlage,
                    V_QuerfoerdernVor,
                    V_QuerfoerdernZurueck,
                    L_1,
                    L_2,
                    L_3,
                    L_4,
                    L_5,
                    L_6,
                    L_7,
                    L_8);

  TGeraeteID     = (ID_leer,                               { unbelegte Schnittstelle }
                    ID_LogoCMOS, ID_LogoCAN, ID_Willett,   { Etikettierer }
                    ID_LS1220, ID_LS4000, ID_LS2000,       { Scanner }
                    ID_QS16,                               { Waage }
                    ID_Foerderer,                          { Förderanlage }
                    ID_Leuze,                              { Transponder }
                    ID_Tiris,                              { Leuze }
                    ID_Trigger,
                    ID_Error);                             { für Fehler bei der HW-Erkennung }

  TAdresse       = (Adr_00 = 0,
                    Adr_E1 = 1,
                    Adr_E2 = 2,
                    Adr_E3 = 3,
                    Adr_E4 = 4,                            { 4 Etikettierer-Schnittstellen }
                    Adr_S1 = 5,
                    Adr_S2 = 6,
                    Adr_S3 = 7,
                    Adr_S4 = 8,                            { 8 serielle Schnittstellen }
                    Adr_S5 = 9,
                    Adr_S6 = 10,
                    Adr_S7 = 11,
                    Adr_S8 = 12,
                    Adr_T1 = 13,
                    Adr_T2 = 14);                          { 2 Trigger }

  TEtiStatus = (est_Stop, est_Ready, est_Error, est_Zyklus);

  TGeraet    = class (TComponent)
                 private
                   FAdresse : TAdresse;
                   TriggerBit1 : Integer;
                   Triggerbit2 : Integer;
                   FName : string;
                   FData : string;
                   Timer : TTimer;
                   FOnData : TNotifyEvent;
                   ComPort : TCiaComPort;
                   procedure TriggerAus (Sender:TObject); virtual;
                   function Detect : TGeraeteID;
                   function GetData : string; virtual;
              published
                   property ID : TGeraeteID read Detect ;

                   { um was für ein Gerät handelt es sich? }
                   property Name : string read FName write FName;
                   { bel. Name für das Gerät }
                   property Adresse : TAdresse read FAdresse write FAdresse;
                   { die Steckdosen-Nr., an die das Gerät angeschlossen ist }
                   property Data : string read GetData;
                   { Nutzdaten: Barcode, Gewicht oder Transponder-Inhalt }
                   property OnData : TNotifyEvent read FOnData write FOnData;
                   function Trigger : Boolean; virtual;
                   function Ausgang(Wert: Boolean; Ventil:TFoerderVS): Boolean; virtual;
                   function Reset : Boolean; virtual;
               end;

  TEtikettierer = class (TGeraet)
                    private
                      StatusBit : Byte;
                      LastStatus : TEtiStatus;
                      procedure TriggerAus (Sender:TObject); override;
                      function GetStatus : TEtiStatus;
                    published
                      function Trigger : Boolean; override;
                      property Status : TEtiStatus read GetStatus;
                  end;

  T804CMOS = class (TEtikettierer)
               private
                 Zyklustimer : TTimer;
                 Vorspenden : Boolean;
                 procedure TriggerAus (Sender:TObject); override;
                 procedure Zyklus (Sender:TObject);
               published
                 function Trigger : Boolean; override;
             end;

  T804CAN = class (TEtikettierer)
              private
                Zyklustimer : TTimer;
                Vorspenden : Boolean;
                procedure TriggerAus (Sender:TObject); override;
                procedure Zyklus (Sender:TObject);
              published
                function Trigger : Boolean; override;
            end;

  TWillett = class (TEtikettierer)
               private
//                 procedure TriggerAus (Sender:TObject); override;
               published
//                 function Trigger : Boolean; override;
             end;

  TScanner = class (TGeraet)
               private
                 procedure OnBarcode (Sender:TObject);
                 function GetBarcode : string;
                 function GetAIM : string;
                 procedure TriggerAus (Sender:TObject); override;
               published
                 function Trigger : Boolean; override;
                 property Barcode : string read GetBarcode;
                 property AIM : string read GetAIM;
             end;

  TTrigger = class (TGeraet)
               private
                 Timer : TTimer;
                 Enabled : Boolean;
                 StatCnt : Byte;
                 procedure Check (Sender: TObject);
               published
                 function Trigger : Boolean; override;
                 function Status : Boolean;
             end;

  TWaage = class (TGeraet)
             private
             istabil : integer;
             iGewvergleich : integer;
             igewicht : integer;
             wcomport : TCiaComPort;
             procedure OnGewicht (Sender:TObject);
              function GetGewicht : string;
             published
               function Trigger : Boolean; override;
               property stabil  : integer read istabil write istabil;
               property Gewvergleich : integer read iGewvergleich write iGewvergleich;
               property Gewichti : integer read igewicht write igewicht;
               property Gewicht : string read GetGewicht;
           end;

  TTiris = class (TGeraet)
             private
               FTiris : string;
               DataVollstaendig : Boolean;
               Procedure OnTiris (Sender:TObject);
               Procedure OnSent (Sender:TObject);
               function GetData : string; override;
               procedure WriteData (Data:string);
             published
               property Data : string read GetData write WriteData;
               function Trigger : Boolean; override;
           end;

  TLeuze = class (TGeraet)
             private
               FLeuze : string;
               DataVollstaendig : Boolean;
               Procedure OnLeuze (Sender:TObject);
            // Procedure OnSent (Sender:TObject);
               function GetData : string; override;
            // procedure WriteData (Data:string);
            // function WriteConfig : String;
             published
               property Data : string read GetData;// write WriteData;
               function Trigger : Boolean; override;
               function Reset : Boolean; override;
           end;

  TFoerder = class (TGeraet)
               private
                 procedure TriggerEingang (Sender: TObject);
                 procedure OnFoerderer (Sender:TObject);
                 function GetData : string; override;
               published
                 function Trigger : boolean; override;
                 function Ausgang(Wert: Boolean; Ventil:TFoerderVS) : Boolean;
                 property Data : string read GetData;
             end;

  TStempel = class (TGeraet)
               private
                 StempelTimer : TTimer;
                 procedure Stempel_Aus (Sender:TObject);
                 procedure SetTimer (Zeit:Integer);
               published
                 property StempelZeit : Integer write SetTimer;
                 function Trigger : Boolean; override;
             end;

  TSteckd = Record
              Geraet : TGeraet;
              Typ    : TGeraeteID;
            end;

  TComPara = Record
               Baudrate : Integer;
               StopBits : TStopBits;    { = (sbOne, sbOne_5, sbTwo) }
               DataBits : Byte;
               Parity   : TParity;      { = (ptNone, ptOdd, ptEven, ptMark, ptSpace) }
             end;












function AutoDetect : Boolean;
{ Fragt sämtliche Schnittstellen ab un instanziiert die entspr. TGeraet-Objekte }
Var
  Adresse      : TAdresse;
  dummy        : TGeraet;
  TestGer      : TGeraet;
  Sonstige     : TGeraet;
  Etikettierer : TEtikettierer;
  Scanner      : TScanner;
  Waage        : TWaage;
  Tiris        : TTiris;
  Leuze        : TLeuze;
  Foerderer    : TFoerder;
  Typ          : TGeraeteID;
  i            : TFoerderVS;

begin
{$IFDEF DII }
  if not HW_Detect then
    Application.MessageBox('Digital-I/O Karte nicht erkannt','Autodetect',MB_OK);
{$ENDIF }
  Result := True;
  ErrorStatus := 0;
  TestGer := TGeraet.Create(dummy);
  for Adresse := Adr_E1 to Adr_S8 do begin
    TestGer.Adresse := Adresse;
    Typ := TestGer.ID;
    if Typ = ID_Error then begin
      Result := False;
//      ErrorStatus := Ord (Adresse+1001);
    end;
    Case Typ of
      ID_LogoCMOS             : begin
                                  Etikettierer := T804CMOS.Create(Dummy);
                                  Etikettierer.Adresse := Adresse;
                                  with (Etikettierer as T804CMOS) do begin
                                    Vorspenden := False;
                                    TriggerBit1 := 2*(Ord(Adresse)-1);
                                    if Ord(Adresse)=2 then
                                      TriggerBit2 := 39
                                    else
                                      TriggerBit2 := Triggerbit1 + 1;
                                    StatusBit := 2*Ord(Adresse) + 38;
                                    Timer := TTimer.Create(SteckdListe[Adresse]);
                                    Timer.Interval := 750;
                                    Timer.Enabled := False;
                                    Timer.OnTimer := TriggerAus;
                                    ZyklusTimer := TTimer.Create(SteckdListe[Adresse]);
                                    Zyklustimer.Interval := 20;
                                    Zyklustimer.Enabled := False;
                                    Zyklustimer.OnTimer := Zyklus;
                                    Name := IDToStr (Typ) + ' an ' + IntToStr (Ord (Adresse));
                                  //  Detect;
                                  end;
                                  SteckdListe[Adresse] := Etikettierer;
                                end;
      ID_LogoCAN              : begin
                                  Etikettierer := T804CAN.Create(dummy);
                                    Etikettierer.Adresse := Adresse;
                                  with (Etikettierer as T804Can) do begin
                                    Vorspenden := False;
                                    TriggerBit1 := 2*(Ord(Adresse)-1);
                                    if Ord(Adresse)=2 then
                                      TriggerBit2 := 39
                                    else
                                      TriggerBit2 := Triggerbit1 + 1;
                                    StatusBit := 2*Ord(Adresse) + 38;
                                    Timer := TTimer.Create(SteckdListe[Adresse]);
                                    Timer.Interval := 3000;
                                    Timer.Enabled := False;
                                    Timer.OnTimer := TriggerAus;
                                    ZyklusTimer := TTimer.Create(SteckdListe[Adresse]);
                                    Zyklustimer.Interval := 20;
                                    Zyklustimer.Enabled := False;
                                    Zyklustimer.OnTimer := Zyklus;
                                    Name := IDToStr (Typ) + ' an ' + IntToStr (Ord (Adresse));
                                  //  Detect;
                                  end;
                                  SteckdListe[Adresse] := Etikettierer;
                                end;
      ID_Willett              : begin
                                  Etikettierer := TWillett.Create(dummy);
                                    Etikettierer.Adresse := Adresse;
                                  with Etikettierer do begin
                                    TriggerBit1 := 2*Ord(Adresse) - 1;
                                    Timer := TTimer.Create(SteckdListe[Adresse]);
                                    Timer.Interval := 1000;
                                    Timer.Enabled := False;
                                    Timer.OnTimer := TriggerAus;
                                    Name := IDToStr (Typ) + ' an ' + IntToStr (Ord (Adresse));
                                  //  Detect;
                                  end;
                                  SteckdListe[Adresse] := Etikettierer;
                                end;
      ID_LS1220..ID_LS2000    : begin
                                  Scanner := TScanner.Create(dummy);
                                    Scanner.Adresse := Adresse;
                                  with Scanner do begin
                                    ComPort := TCiaComPort.Create(SteckdListe[Adresse]);
                                    ComPort.Baudrate := ScannerPara.BaudRate;
                                    ComPort.ByteSize := ScannerPara.DataBits;
                                    ComPort.Parity := ScannerPara.Parity;
                                    ComPort.StopBits := ScannerPara.StopBits;
                                    ComPort.Port := RemapComPort (Ord (FAdresse)-4);
                                    ComPort.OnDataAvailable := OnBarcode;
                                    Timer := TTimer.Create(SteckdListe[Adresse]);
                                    Timer.Interval := 3000;
                                    Timer.Enabled := False;
                                    Timer.OnTimer := Scanner.TriggerAus;
                                    Triggerbit1 := Ord(Adresse)+3;
                                    Name := IDToStr (Typ) + ' an ' + IntToStr (Ord (Adresse)-4);
                                  //  Detect;
                                  end;
                                  SteckdListe[Adresse] := Scanner;
                                end;
     ID_QS16                 : begin
                                  Waage := TWaage.Create(Waage);
                                  Waage.Adresse := Adresse;
                                  Waage.Name := IDToStr (Typ) + ' an ' + IntToStr (Ord (Adresse)-4);
                                //  Waage.Detect;
                                  SteckdListe[Adresse] := Waage;
                                end;
      ID_Tiris                : begin
                                  Tiris := TTiris.Create(Tiris);
                                  Tiris.Adresse := Adresse;
                                  Tiris.Name := IDToStr (Typ) + ' an ' + IntToStr (Ord (Adresse)-4);
                                //  Tiris.Detect;
                                  SteckdListe[Adresse] := Tiris;
                                end;
      ID_Leuze                : begin
                                  Leuze := TLeuze.Create(Leuze);
                                  Leuze.Adresse := Adresse;
                                  Leuze.Name := IDToStr (Typ) + ' an ' + IntToStr (Ord (Adresse)-4);
                                  SteckdListe[Adresse] := Leuze;
                                end;

      ID_Foerderer            : begin
                                  Foerderer := TFoerder.Create(Foerderer);
                                  Foerderer.Adresse := Adresse;
                                  Foerderer.Name := IDToStr (Typ) + ' an ' + IntToStr (Ord (Adresse)-4);
                                  SteckdListe[Adresse] := Foerderer;
                                  SteckdListe[Adresse].OnData := frmtestfoerder.OnHardwareData;
                                  //Foerderer.Timer := TTimer.Create(SteckdListe[Adresse]);
                                  //Foerderer.Timer.Interval := 100;
                                  //Foerderer.Timer.Enabled := true;
                                  //Foerderer.Timer.OnTimer := Foerderer.TriggerEingang;
                                  with Foerderer do
                                    begin
                                      ComPort := TCiaComPort.Create(SteckdListe[Adresse]);
                                      ComPort.Baudrate := FoerderPara.BaudRate;
                                      ComPort.ByteSize := FoerderPara.DataBits;
                                      ComPort.Parity := FoerderPara.Parity;
                                      ComPort.StopBits := FoerderPara.StopBits;
                                      ComPort.Port := RemapComPort (Ord (FAdresse)-4);
                                      ComPort.OnDataAvailable := OnFoerderer;
                                      ComPort.LineMode := True;
                                      ComPort.LineEnd := #06#03;
                                      ComPort.Open := True;
                                    end;
                                    //  Timer := TTimer.Create(SteckdListe[Adresse]);
                                    //  Timer.Interval := 100;
                                    //  Timer.Enabled := true;
                                    //  Timer.OnTimer := Foerderer.TriggerEingang;
                                    //Triggerbit1 := Ord(Adresse)+3;
                                   //  Detect;

                                  For i := V_Absenkeinheit to V_QuerfoerdernZurueck do
                                    begin
                                      if Foerderer.Ausgang(false,i) then
                                    end;
                                    Foerderer.Ausgang(true,V_QuerfoerdernZurueck);
                                    sleep(500);
                                  //  Foerderer.Ausgang(false,V_QuerfoerdernZurueck);
                                end;

      else                      begin { unbekanntes Gerät }
                                  Sonstige := TGeraet.Create(Sonstige);
                                  Sonstige.Adresse := Adresse;
                                //  Sonstige.Detect;
                                  Sonstige.Name := 'Fehler? an ' + IntToStr (Ord (Adresse)-4);
                                  SteckdListe[Adresse] := Sonstige;
                                end;
    end;
  end;

  Trigger1 := TTrigger.Create(Trigger1);
  Trigger1.Adresse := Adr_T1;
//  Trigger1.Detect;
  Trigger1.Name := 'Triggertaster 1';
  Trigger1.TriggerBit1 := baTaster1;
  SteckdListe[Adr_T1] := Trigger1;
  Trigger1.Timer := TTimer.Create(SteckdListe[Adr_T1]);
  Trigger1.Timer.Interval := 10;
  Trigger1.Timer.Enabled := False;
  Trigger1.Timer.OnTimer := Trigger1.Check;
  Trigger1.Enabled := True;
  Trigger2 := TTrigger.Create(Trigger2);
  Trigger2.Adresse := Adr_T2;
//  Trigger2.Detect;
  Trigger2.Name := 'Triggertaster 2';
  Trigger2.TriggerBit1 := baTaster2;
  SteckdListe[Adr_T2] := Trigger2;
  Trigger2.Timer := TTimer.Create(SteckdListe[Adr_T2]);
  Trigger2.Timer.Interval := 10;
  Trigger2.Timer.Enabled := False;
  Trigger2.Enabled := True;
  Trigger2.Timer.OnTimer := Trigger2.Check;

  Stempel := TStempel.Create(Application);
  Stempel.SetTimer(StempelZeit);

  TestGer.Destroy;

end;



Moderiert von user profile iconPeter Lustig: Code- durch Delphi-Tags ersetzt.
Moderiert von user profile iconPeter Lustig: Topic aus VCL (Visual Component Library) verschoben am Fr 25.06.2004 um 18:05
Tilo
ontopic starontopic starontopic starontopic starofftopic starofftopic starofftopic starofftopic star
Beiträge: 1098
Erhaltene Danke: 13

Win7 geg. WInXP oder sogar Win98
Rad2007
BeitragVerfasst: Fr 25.06.04 17:03 
Hallo Ducky
Frage, wieso lautet der Code in Zeile 420
Zitat:
Trigger1 := TTrigger.Create(Trigger1);

wäre
ausblenden Delphi-Quelltext
1:
Trigger1 := TTrigger.Create;					

nicht besser
Ducky Threadstarter
Hält's aus hier
Beiträge: 11



BeitragVerfasst: Fr 25.06.04 17:08 
Ich denke schon, aber da alle Geraete von TGeraet abgeleitet sind dachte ich es wird immer ein owner benötigt
Ducky Threadstarter
Hält's aus hier
Beiträge: 11



BeitragVerfasst: Fr 25.06.04 17:15 
Genauer gesagt wenn ich die Zeilen 394 - 396 reinnehme kann die klasse nicht mehr createt werden (Exeption).
wenn ich aber den umweg über einen dummy mache ( siehe Scanner) dann klappt es jedoch muß ich dann den aufruf über ( as TFoerder ) machen und das wirft ne menge Probs auf !
ErnestoChe
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 528

Win 2000 pro, CRUX 2.0
Delphi 6 Pers, Open K3
BeitragVerfasst: Fr 25.06.04 17:36 
Hallo,

ich hab deinen Code nur kurz überflogen.

@Tilo:
Er muß einen Owner angeben da TTrigger von TGeraet abgeleitet ist, welches wiederum von TComponent abstammt. Und der Konstruktor von TComponent erwartet einen Owner als Parameter.

@Ducky
Es ist aber falsch als Owner das Objekt anzugeben, das du erstellen möchtest. Der Owner wird von TComponent deshalb verlangt, dass wenn der Owner aus dem Speicher entfernt wird auch das Objekt Trigger1 automatisch entfernt wird. Also entweder nil angeben oder z.B. die Form.

MFG

- Ernesto -
raziel
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 2453

Arch Linux
JS (WebStorm), C#, C++/CLI, C++ (VS2013)
BeitragVerfasst: Fr 25.06.04 17:42 
Ducky hat folgendes geschrieben:
Genauer gesagt wenn ich die Zeilen 394 - 396 reinnehme kann die klasse nicht mehr createt werden (Exeption).
wenn ich aber den umweg über einen dummy mache ( siehe Scanner) dann klappt es jedoch muß ich dann den aufruf über ( as TFoerder ) machen und das wirft ne menge Probs auf !

Das liegt wahrscheinlich daran, dass SteckdListe kein array of TComponent (oder einer seiner Nachfolger) ist (Genaues kann ich nicht sagen, weil ich weder eine Deklaration noch eine Erzeugung finden konnte). Als AOwner wird aber ein TComponent (oder Nachfahre) erwartet.
Dummy wiederum ist ein TComponent.
Also am besten nil übergeben, aber auf keinen Fall das zu erzeugende Objekt.

raziel

_________________
JSXGraph
Ducky Threadstarter
Hält's aus hier
Beiträge: 11



BeitragVerfasst: Fr 25.06.04 21:08 
Supie Danke,
das werd ich am montag erst mal testen, ich denke das könnte wirklich die lösung sein !!!!!!! :P


:!: :!: freu freu freu :!: :!:


SteckdListe ist ein array of TComponent also das ist schon OK.

aber trotzdem supie danke für die Tips, ich melde mich mitwoch oder donerstag ob es geklappt hat.
Ducky Threadstarter
Hält's aus hier
Beiträge: 11



BeitragVerfasst: Do 01.07.04 17:59 
@ raziel:
also, ich habe die owner als nil angegeben, und er hat nicht mehr gemäckert :D
ob es in der praxis jedoch läuft werd ich nächste woche erst sehen, dann werden wir das update einspielen
Im moment läuft es stabiel und wenn der auftrag durch ist werden wir sehen wie sich die hardware verhält.
Trotzdem nochmal besten Dank

CU Jörg
Ducky Threadstarter
Hält's aus hier
Beiträge: 11



BeitragVerfasst: Sa 31.05.08 16:55 
Titel: lang lang ists her
Wir habe das Project mitlerweile bis auf über 12MB Sourcecode erweitert (incl. Forms usw.) also 2MB compilierter Code.
Seit der Änderung läuft es bis auf ein paar Kleinigkeiten sehr Stabiel. Danke nochmals für eure Hilfe.
Somit kann ich diesen Threat jetzt schliessen. Wenn ich diesbezüglich noch fragen haben sollte dann muß ich halt nen neuen aufmachen.

Nochmal

D A N K E

euer Jörg