Entwickler-Ecke :: Thema anzeigen - Frage wegen delphi4 in delphi7 umwandeln

Pkan - Di 18.10.05 21:56
Titel: Frage wegen delphi4 in delphi7 umwandeln

hey Leute ich komm abelut nicht mehr weiter! :(
Ich Schreibe gerad ein Programm welches die Werte von einer Messkarte abfragt und diese dann Graphisch darsetllt und logt. Die leztern beiden Sachen sind kein Problem, jedoch sind alle bisherigen Programme für diese Messkarte in basic/pascal/ delphi 4.
siehe Link http://www.click.onlinehome.de/des8k12b.html#Done
Ich hab nun versucht mit dem Delphi4 source Stückchen die deklaration für die com und die variablen/proceduren Ansteuerung festzulegen. Allerdings komm ich nicht weiter. Ein Kollege meinte das es große unterschiede in der Programmierung zwischen Delpi4 und 7 gibt. Kann mir jemand weiter helfen der diesen delphi4 code(nochmal im ""Anhang"") vlt delpi7 tauglich machen könnte?
MfG PKaN
und schon mal ein Dankeschön für den der mir helfen kann!

der Delphi 4 code

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

TYPE
    tComNr = 1..4;    {COM 1 bis COM 4}
    tChNr = 1..8;     {Kanal 1 bis Kanal 4}

tMessCom = object
    CONSTRUCTOR Init( ComNr: tComNr);
    PROCEDURE SetPortAdress (ComNr: tComNr);
    FUNCTION Activ_Port: tComNr;
    PROCEDURE SetChannel(KanalNr:tChNr);
    FUNCTION GetHoldValue: WORD;
    FUNCTION GetValue(KanalNr:tChNr): REAL; virtual;
    DESTRUCTOR Done; virtual;
end;

Moderiert von raziel: Delphi-Tags hinzugefügt.

AndyB - Di 18.10.05 22:08
Titel: Re: Frage wegen delphi4 in delphi7 umwandeln

Pkan hat folgendes geschrieben:

Kann mir jemand weiter helfen der diesen delphi4 code(nochmal im ""Anhang"") vlt delpi7 tauglich machen könnte?

Welchen Code? Ich sehe da nur die Objekt-Deklaration. Objekte sind aber schon seit Delphi 1 durch Klassen verdrängt und ersetzt. Delphi versteht sie aber trotzdem noch.

der Delphi 7 code

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

TYPE
    tComNr = 1..4;    {COM 1 bis COM 4}
    tChNr = 1..8;     {Kanal 1 bis Kanal 4}

tMessCom = object
    CONSTRUCTOR Init( ComNr: tComNr);
    PROCEDURE SetPortAdress (ComNr: tComNr);
    FUNCTION Activ_Port: tComNr;
    PROCEDURE SetChannel(KanalNr:tChNr);
    FUNCTION GetHoldValue: WORD;
    FUNCTION GetValue(KanalNr:tChNr): REAL; virtual;
    DESTRUCTOR Done; virtual;
end;

Im Endeffekt habe ich nichts verändert, da diese Deklaration auch noch in Delphi 7 (und sogar Delphi 2005) gültig ist.^

Im übrigen: Diese verlinkte Modul ist nur für Windows 9x zu gebrauchen. Bei NT basierten Systemen (WinNT/2000/XP/2003/Vista) steigt es aus, weil diese keinen direkten Hardwarezugriff erlauben.

Pkan - Di 18.10.05 22:25

mhhhh
ja habs nochmal versucht...und zwar das ganze Stück nicht unter dem von delphi generieten typ geschrieben sondern unter einen eigennen, nach der implementation!
jetzt funktioniern die 3 zeilen :

tComNr = 1..4; {COM 1 bis COM 4}
tChNr = 1..8; {Kanal 1 bis Kanal 4}

tMessCom = object

Bei der nächsten Zeile ( CONSTRUCTOR Init( ComNr: tComNr);)dritt leider folgender Fehler auf!
[Fehler] Unit1.pas(28): Ungenügende Forward- oder External-Deklaration: 'tMessCom.Init'
leider verstehe ich nciht was delphi mir damit sagen möchte!
Wäre echt nett wenn du mir bei diesen Problem helfen könntet.

AndyB - Mi 19.10.05 00:42

Pkan hat folgendes geschrieben:

Ungenügende Forward- oder External-Deklaration: 'tMessCom.Init'

Ich übersetze dir das mal:
Der Konstruktor 'Init' von 'tMessCom' wurde zwar deklariert, es fehlt aber der eigentliche Code.

Wenn programmieren so einfach wäre:

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:

type
  TMyBetriebssystem = object
    constructor Init;
    destructor Done;
    procedure ErzeugeUndStarteProgramm_AutoCAD;
    procedure ErzeugeUndStarteProgramm_Oracle10;
  end;

Und schon habe ich mein AutoCAD und meine eigene Oracle10 Datenbank erstellt, kompiliert und gestartet. Und das alles in meinem eigenen Betriebsystem.

Jetzt muss ich diese Funktionen halt dummerweise auch noch implementierern (mit Code füllen). Und daran wird es wohl scheitern.

Kurzum: Du kannst von einem Compiler nicht verlangen, dass er den Code für die erfindet. Also musst du schon mehr als nur diese Objekt-Deklaration in eine Datei schreiben. Auch Delphi 4 kann mit dieser mehr als spärlichen Deklaration nicht das geringste anfangen. Ich suche dir jetzt nicht den Link auf die gesamte Datei, die übrigens auch von der von dir verlinkten Seite heruntergeladen werden kann, heraus. Das musst du schon selbst machen.

Pkan - Mi 19.10.05 11:42

Erstmal danke...jetzt kenn ich schonmal den Zusammenhang!
Den Link( http://www.click.onlinehome.de/source/messcom.txt ) kenn ich schon aber delphi bringt mir immer 2 Fehler, die ich nicht beheben kann:
[Fehler] MessCom.pas(82): Undefinierter Bezeichner: 'ResetStopWatch'
[Fehler] MessCom.pas(121): Undefinierter Bezeichner: 'ReadStopWatch'

Ich glaube ich sollte mir echt mal ein gutes Delphi Buch kaufen(kennst du manchmal eins*g*)
Um nochmal auf dem Programm zurück zukommen, wenn ich das richtig versteh ist die nur ein Simulations-Programm ich möchte aber eins schreiben das die Messkarte anspricht und echte Werte bekommt!. kann man dieses Simulations-Programm dementsprechend umschreiben?
MfG

Lannes - Mi 19.10.05 12:01

Hallo,

du musst die Unit utility [http://www.click.onlinehome.de/source/utility.txt] mit einbinden.
Die Procedur ResetStopWatch ist darin enthalten

Pkan - Mi 19.10.05 13:27

Ja aber utility benötigt -> crt, dos, graph;(uses)
Ich habe keine Ahnung wo ich diese Datein wiederum herbekomm sollte. selbst google war nicht hilfeich :-(
Das sind doch massenhaft für so ein kleines Programm! Ist das normal?
MfG

AndyB - Mi 19.10.05 15:00

Pkan hat folgendes geschrieben:

Das sind doch massenhaft für so ein kleines Programm! Ist das normal?

Schon mal ein VCL-Programm gesehen, das nichts anderes enthält als ein leeres Formular? Da werden viel mehr Units eingebunden.

Ich bin jetzt einfach mal so gnädig (hatte gerade nichts besseres zu tun)

Die Unit funktioniert aber nur unter Windows 95/98/ME. Für Windows NT/2000/XP/Vista brauchst du einen Gerätetreiber, der die Ports dann für dich anspricht. Ansonsten bekommst du EPriviliged Exceptions um die Ohren geschlagen.

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:

{ FB Inf OSZ ET1, messCom.pas, 05.12.2000 Bluhm                }
{Unit für die 8-Kanal-Datenerfassung (Messkarte als Objekt)   }
unit MessCom;

interface

uses
  SysUtils;

type
  TComNr = 1..4;   { Portadressen für die serielle Schnittstelle }
  TChNr = 1..8;

  TMessCom = class(TObject)
  private
    Channel: Byte;                 { aktiver Messkanal }
    com: Word;                   { lokale Variable für COM1 .. COM4 }
    REF: Real;                   { Referenzspannung = 5,000 V }
    Value: array[1..8] of Word;    { letzten Messwerte (12Bits) }
  public
    constructor Create(ComNr: TComNr);
    { Auswahl der seriellen Schnittstelle 'ComNr'=(Com1 .. Com4)}
    procedure SetPortAdress(ComNr: TComNr);
    { Auswahl der seriellen Schnittstelle 'ComNr'=(Com1 .. Com4)}
    function Activ_Port: TComNr;                   { gibt die aktive Port-Nr.(Com1 .. Com4) zurück }
    procedure SetChannel(KanalNr: TChNr);
    { 'KanalNr' gibt den Kanal an, von dem der Messwert geholt wird}
    procedure Hold;                                 { (AD-Wandlung starten) }
    function GetHoldValue: Word;                   { letzten 12-Bit-Wert vom aktiven Kanal zurückgegeben }
    function GetValue(KanalNr: TChNr): REAL; virtual;
    { aktuellen Messwert von 'KanalNr'= 1..8               }
    { oder letzten Messwert 'KanalNr'= 0 (>8) zurückgegeben}
  end;

function vMessCom: String;

function Peek(Adresse: Word): Byte;
  { liefert den Inhalt der angefragten Portdresse }
procedure Poke(Adresse: Word; Wert: Byte);
  { setzt an der genannten Portadresse den bezeichneten Wert }

  {#####################################################################################################}

implementation

const
  maske: array[1..8] of Word =           {  1111 0111 0000 = $0F7?}
    ($0F71, $0F73, $0F79, $0F7B, $0F75, $0F77, $0F7D, $0F7F);
  pause = 0.01;                     { SampelTime in s }

var
  StopWatch: TDateTime;

procedure ResetStopWatch;
begin
  StopWatch := Now;
end;

function ReadStopWatch: TDateTime;
begin
  Result := Now - StopWatch;
end;

function Peek(Adresse: Word): Byte;
asm
  mov dx, Adresse
  in al, dx
end;

procedure Poke(Adresse: Word; Wert: Byte);
// [EAX]   Adresse
// [EDX]   Wert
asm
  xchg eax, edx
  out dx, al
end;

{#####################################################################################################}
function vMessCom: String;  { Namenkonvention -> 'V+Unitname'}
begin   {  Version; letzte Änderung; Autor  }
  vMessCom := '2.2; 05.12.2000; Bluhm'
end;

{#####################################################################################################}
constructor TMessCom.Create(ComNr: TComNr);
begin
  inherited Create;
  REF := 5.0;
  Channel := 1;
  SetPortAdress(ComNr);
end;

{#####################################################################################################}
procedure TMessCom.SetPortAdress(ComNr: TComNr);
var
  i: TChNr;
begin
  for i := 1 to 8 do Value[i] := $0000;
  case ComNr of
    1: com := $3F8;
    2: com := $2F8;
    3: com := $3E8;
    4: com := $2E8;
    else 
      Halt($0200);
  end;
  SetChannel(Channel);
end;

{#####################################################################################################}
function TMessCom.Activ_Port: TComNr;
begin
  case com of
    $3F8: Result := 1;
    $2F8: Result := 2;
    $3E8: Result := 3;
    $2E8: Result := 4;
  else
    raise Exception.Create('Ungültiger Port');
  end;
end;

{#####################################################################################################}
procedure TMessCom.Hold;                       {AD-Wandlung starten}
begin
  Poke(COM + 4, $01 or Peek(COM + 4));       { SClk (DTR) auf HIGH }
  { Kanal Wandlung starten }
  Poke(COM + 4, $FD and Peek(COM + 4));      { DIN und CS (RTS) auf HIGH }
  Poke(COM + 4, $02 or Peek(COM + 4));      { DIN geht (RTS) auf LOW }
  ResetStopWatch;
end;

{#####################################################################################################}
procedure TMessCom.SetChannel(KanalNr: TChNr);    {Kanal initialisieren}
var
  i: Byte;
  KAdr: Word;         {  1111 0111 0001 = $0F71 ... $0F7F  Auswahl des Messkanals}
begin
  if KanalNr in [1..8] then
  begin
    Channel := KanalNr;
    KAdr := maske[Channel];            { Kanaladresse einstellen }
    for i := 0 to 11 do               { Schleife 12 mal, da 12 BitAdresse }
    begin
      Poke(COM + 4, $FE and Peek(COM + 4));   { SClk und CS (DTR) auf LOW}
      if (KAdr shr i) and $0001 = $0001   { Kanaladresse wird seriell uebertragen } then
        Poke(COM + 4, $02 or Peek(COM + 4))  { RTS auf HIGH }
      else 
        Poke(COM + 4, $FD and Peek(COM + 4)); { RTS auf LOW }
      Poke(COM + 4, $01 or Peek(COM + 4));         { SClk (DTR) auf HIGH }
    end;
    Hold;                                   { Kanal Wandlung starten }
  end;
end;

{#####################################################################################################}
function TMessCom.GetHoldValue: Word;
begin
  GetHoldValue := Value[Channel];
end;

{#####################################################################################################}
function TMessCom.GetValue(KanalNr: TChNr): REAL;
var
  i: Byte;
  KAdr: Word;     { 1111 0111 0001 = $0F71 ... $0F7F  je nach Messkanal }
  Bits: Word;                             { DatenBits von der Messkarte }
begin
  if not (KanalNr = Channel) then SetChannel(KanalNr);
  if (ReadStopWatch > Pause) then
  begin
    KAdr := maske[Channel];                       { Kanaladresse einstellen }
    Bits := $0000;
    for i := 0 to 11 do                      { Schleife 12 mal, da 12 Bits }
    begin
      Poke(COM + 4, $FE and Peek(COM + 4));  { SClk und CS (DTR) auf LOW }
      if (KAdr shr i) and $0001 = $0001  { Kanaladresse wird seriell übertragen } then
        Poke(COM + 4, $02 or Peek(COM + 4))   { RTS auf HIGH }
      else 
        Poke(COM + 4, $FD and Peek(COM + 4));  { RTS auf LOW }
      Poke(COM + 4, $01 or Peek(COM + 4));          { SClk (DTR) auf HIGH }
      if (Peek(COM + 6) and $10) = $10  { Datenbits vom Messwert seriell einlesen } then
        Bits := Bits shl 1                     { DOT (CTS) auf High }
      else 
        Bits := (Bits shl 1) or $01;           { DOT (CTS) auf Low }
    end;        { Ende 'FOR'            Kanal gesetzt und alter Messwert übertragen }
    Hold;                                      { Kanal Wandlung starten }
    Value[Channel] := Bits;
  end;
  {Zahlenwert ausrechnen (für LTC 1090 und 1290)}
  GetValue := Value[Channel] / $0FFF * REF;
end;

end.

Pkan - Mi 19.10.05 17:06

Vielen Dank....ist echt Super von dir...Ich versuch das jetzt einzubinden und nen Gerätetreiber zu finden.
nochmal THX
PkaN

AndyB - Mi 19.10.05 18:42

Pkan hat folgendes geschrieben:

und nen Gerätetreiber zu finden.

Mit dem musst du dann aber die gesamte Unit anders implementieren. Und diese Aufgabe nehme ich dir auf keinen fall ab.