Autor Beitrag
Prilo
Hält's aus hier
Beiträge: 1



BeitragVerfasst: Sa 10.04.04 14:20 
Hallo Gemeinde,
ich habe mir ein Modul zum Messen und Steuern an der seriellen Schnittstelle zugelegt.
Es ist allerdings nur ein Beispielcoding in Pascal (DOS) dabei und ich würde das Modul gerne unter WinX unter Delphi ansprechen.
Wie kann ich das Teil mit Hilfe kvon API anprechen?

Hier die Beschreibung:
6 analoge Spannungsmesseingänge (0 V bis 5 V/10 Bit)
8 Digitalleitungen, die wahlweise als Ein- oder Ausgänge
Die Datenübertragung zwischen dem PC und dem M232-Messmodul erfolgt mit ei­ner Datenrate von 2400 Baud, keinem Stoppbit und keiner Parität. Vom PC aus wird die Daten-übertragung gesteuert, indem der PC einen Befehl an das Messmodul sendet, das daraufhin eine Antwort zurücksendet.
Ein Befehl beginnt immer mit den „SOH“ - Zeichen (ASCII l), die den An­fang eines Befehls darstellen und endet mit einem „CR“ - Zeichen (ASCII 13), worauf­hin das M232 den Befehl antwortet.
Zum Beispiel sendet der PC ,,[SOH]a2[CR]", woraufhin das Messmodul den Wandlerwert für den Analogein­gang „AN2" liefert und z. B. „1A[ACK]" zurücksendet. Der Wandlerwert für den Analogeingang beträgt dann „1A“ in hexa­dezimaler Schreibweise, was einem Wert von „26“ in dezimaler Schreibweise entspricht.

[/code]
Hier das Pascal-Coding:
ausblenden volle Höhe 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:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
(**************************************************************************
//**  Demoprogramm zum RS232-Meámodul M232      14.10.97                   **
//**  (c) ELV UK LTD                                                       **
//**  Datei           : M232.PAS                                           **
//**  letzte Žnderung : 14.10.97                                           **
//***************************************************************************
//  !! Hinweis: Der Ablauf f�r das serielle Senden und den serielle Empfang
//  ist durch die Software gesteuert (polling).
//  Dazu muá der PC in einer Schleife laufen und die empfangenen Zeichen vom
//  Meámodul einzeln von der seriellen Schnittstelle lesen.
//  Wird das Demoprogramm nun unter Windows ausgef�hrt, so wird dem Programm
//  die Rechenzeit von Windows zugeteilt, so daá šbertagungsfehler auftreten
//  k”nnen, da Zeichen vom PC verschluckt werden.                           *)


Program M232;

uses  CRT, DOS;


var   portadresse  : word; { Portadresse des LPT-Portes }
      port_nr      : byte;
      ser_array    : array[0..20] of byte;
      ser_zeiger   : byte;
      ende         : boolean;
      dig_kanal    : byte;
      dig_ausg     : array[0..7] of boolean;
      zaehler_ein  : boolean;
      abgleichmode : boolean;
      t            : byte;
      Parameter    : String[7];

const ESC = 27;
      SOH = 1;
      ACK = 6;
      NAK = 21;
      CR  = 13;



Procedure Cursor_off;
(* Diese Prozedur macht den Cursor unsichtbar *)
var regs : registers;
Begin
  Regs.AH := $01;
  Regs.CH := $FF;
  Regs.CL := $FF;
  Intr($10,Regs);
End;


Procedure Cursor_on;
(* Diese Prozedur macht den Cursor wieder sichtbar *)
var regs : registers;
Begin
  Regs.AH := $01;
  Regs.CH := $06;
  Regs.CL := $07;
  Intr($10,Regs);
End;



function init_sio (port_nr : byte) : boolean;
{ initialisiert die serielle Schnittstelle
  Einganbe : port_nr : 1..4 Nummer des COM-portes  }
var w : word;
begin
  portadresse := 0;
  { Basisadresse des COM-portes ermitteln }
  case port_nr of
    1: portadresse := memw[$40:0];
    2: portadresse := memw[$40:2];
    3: portadresse := memw[$40:4];
    4: portadresse := memw[$40:8];
  end;
  if portadresse<>0 then
  begin
    port[portadresse+3]:=$80;
    w:=115200 div 2400;      { 2400 Baud }
    port[portadresse  ]:=LO(w);
    port[portadresse+1]:=HI(w);
    port[portadresse+3]:=$3;
    port[portadresse+1]:=0;
    port[portadresse+4]:=0;
    w:=port[portadresse];
    init_sio:=true;         { Initialisierung ok }
  end else init_sio:=false; { COM-Port nicht vorhanden }
end;


procedure sio_out (zeichen : byte);
var u : word;
begin
  u:=0;
  { max. 100ms warten, is vorheriges Zeichen fertig gesendet ist }
  while (port[portadresse+5]AND$40 = 0) AND (u<100) do
  begin
    delay (1);
    inc(u);
  end;
  delay (1);
  { Zeichen in das Senderegister schreiben }
  port[portadresse] := zeichen;
end;


function read_sio : boolean;
{ lesen einer Antwort vom M232
  R�ckgabe : false : fehler (timeout / kein ACK/NAK empfangen )
             true  : ok }
var ret, antw_empf : boolean;
    timeout        : longint;
begin
  ret       := true;   { noch kein Fehler }
  timeout   := 0;      { Timeoutz„hler }
  antw_empf := false;
  ser_zeiger := 0;

  { solange wiederholen, bis Antwort empfangen oder Timeout erreicht }
  while (ret) and (not antw_empf) do
  begin
    if (port[portadresse+5] and 1) <> 0 then
    begin
      { Zeichen liegt vor }
      timeout:=0;     { Timeoutz„hler r�cksetzten }
      ser_array[ser_zeiger] := port[portadresse]; { Zeichen ablegen }
      { ACK ode NAK kennzeichenen das Ende der ANtwort }
      if (ser_array[ser_zeiger]=ACK) or (ser_array[ser_zeiger]=NAK) then antw_empf:=true;
      inc (ser_zeiger);
    end;
    inc(timeout);
    { Schleife beenden, wenn Timeout erreicht oder der sereielle Puffer
      �berlaufen ist }
    if (timeout>1000000)or(ser_zeiger>50) then ret:=false;
  end;
  read_sio := ret;
end;


procedure menue;
begin
  clrscr;
  writeln ('-------------------------------------------------------------------------------');
  writeln ('-                                                                             -');
  writeln ('-   RS 232-Meámodul   Demo-/Abgleichprogramm   V1.0  10.97 (c) ELV UK LTD     -');
  writeln ('-   Meámodul an COM  gefunden       Version :                                 -');
  writeln ('-                                                                             -');
  writeln ('-------------------------------------------------------------------------------');
  writeln ('-   +++++ DIGITAL ++++++                ++++++++++++ ANALOG ++++++++++++      -');
  writeln ('-   + Port + ein + aus +                + Port +       Wandlerwert     +      -');
  writeln ('-   ++++++++++++++++++++                ++++++++++++++++++++++++++++++++      -');
  writeln ('-   + IO0  +     +  H  + <--            + AD0  +     (hex)       (dez) +      -');
  writeln ('-   + IO1  +     +  H  +                + AD1  +     (hex)       (dez) +      -');
  writeln ('-   + IO2  +     +  H  +                + AD2  +     (hex)       (dez) +      -');
  writeln ('-   + IO3  +     +  H  +                + AD3  +     (hex)       (dez) +      -');
  writeln ('-   + IO4  +     +  H  +                + AD4  +     (hex)       (dez) +      -');
  writeln ('-   + IO5  +     +  H  +                + AD5  +     (hex)       (dez) +      -');
  writeln ('-   + IO6  +     +  H  +                ++++++++++++++++++++++++++++++++      -');
  writeln ('-   + IO7  +     +  H  +                                                      -');
  writeln ('-   ++++++++++++++++++++                                                      -');
  writeln ('-   <Cursor auf/ab> : Port wechseln     <A> Abgleichmode ein/aus : aus        -');
  writeln ('-   <ENTER>         : Zustand „ndern        (nur Kanal AN0 wandeln)           -');
  writeln ('-                                                                             -');
  writeln ('-   Z„hlerstand :      (hex)        (dez)                                     -');
  writeln ('-   <Z> : Z„hler ein/aus : aus          <R> : Z„hler r�cksetzen               -');
  writeln ('-------------------------------------------------------------------------------');
  gotoxy (20,4);
  writeln (port_nr); { Portnummer ausgeben }
end;



procedure tastaturauswertung;
var c, t, dez : byte;
begin
  if keypressed then
  begin
    c := ord(readkey);
    case c of
      0      : begin(* Pfeiltaste gedr�ckt *)
                 c := ord(readkey);
                 case c of
                 80 : begin (* Cursor ab --> n„chsten dig. Kanal *)
                       gotoxy (26,10+dig_kanal);
                       writeln ('   ');        (* alten Pfeil �berschreiben *)
                       inc (dig_kanal);        (* Kanal +1 *)
                       if dig_kanal>7 then dig_kanal:=0; (* Bereichskontrolle *)
                       gotoxy (26,10+dig_kanal);
                       writeln ('<--');        (* neune Pfeil schreiben *)
                      end;
                 72 : begin (* Cursor auf --> vorherigen dig. Kanal *)
                       gotoxy (26,10+dig_kanal); (* alten Pfeil �berschreiben *)
                       writeln ('   ');
                       if dig_kanal=0 then dig_kanal:=8; (* Bereichskontrolle *)
                       dec (dig_kanal);               (* Kanal -1 *)
                       gotoxy (26,10+dig_kanal);
                       writeln ('<--');        (* neune Pfeil schreiben *)
                      end;
                 END;
               end;
      90,122 : begin (* Taste Z --> Z„hler ein/aus *)
                 sio_out (SOH);
                 sio_out (ord('Z'));
                 gotoxy (28,23);
                 if zaehler_ein then  (* Z„hler ein ? *)
                 begin
                   zaehler_ein := false; (* Z„hler ausschalten *)
                   write ('aus');        (* Anzeige *)
                   sio_out (ord('0'));   (* V24-Ausgabe *)
                 end else
                 begin
                   zaehler_ein := true;  (* Z„hler einschalten *)
                   write ('ein');        (* Anzeige *)
                   sio_out (ord('1'));   (* V24-Ausgabe *)
                 end;
                 sio_out (CR);
                 read_sio;
               end;
      82,114 : begin (* Taste R --> „hler ein und R�cksetzen *)
                 gotoxy (28,23);
                 zaehler_ein := true; (* Z„hler einschalten *)
                 write ('ein');       (* Ausgabe            *)
                 sio_out (SOH);       (* V24-Ausgabe        *)
                 sio_out (ord('Z'));
                 sio_out (ord('1'));
                 sio_out (CR);
                 read_sio;
               end;
      97,65  : begin (* Taste A --> Abgelchmode ein/aus *)
                 gotoxy (68,19);
                 if abgleichmode then  (* Abgleichmode ein ? *)
                 begin
                   abgleichmode := false; (* Abgelichmode aus *)
                   write ('aus');         (* Anzeige *)
                 end else
                 begin
                   abgleichmode := true;  (* Abgleichmode ein *)
                   write ('ein');         (* Anzeige *)
                 end;
                 for t:=0 to 5 do         (* Ausgabefenster l”schen *)
                 begin
                   gotoxy (50,10+t);
                   write ('   ');
                   gotoxy (61,10+t);
                   write ('    ');
                 end;
               end;
      CR     : begin (* ENTER-Taste --> zustand des digitalen Ausgangs wechseln  *)
                 gotoxy (21,10+dig_kanal);
                 if dig_ausg[dig_kanal] then (* Kanal High ? *)
                 begin
                   dig_ausg[dig_kanal]:=false;  (* Kanal low *)
                   write ('L');
                 end else
                 begin
                   dig_ausg[dig_kanal]:=true;  (* Kanal high *)
                   write ('H');
                 end;
                 (* Ausgabe auf das Meámodul *)
                 dez := 0;
                 for t:=7 downto 0 do
                 begin
                   dez := dez shl 1;
                   if dig_ausg[t] then inc(dez);
                 end;
                 sio_out (SOH);
                 sio_out (ord('W'));
                 (* dezimalwert in HEX wandeln *)
                 t := (dez shr 4) AND 15;
                 if t<10 then sio_out (t+ord('0'))
                    else      sio_out (t-10+ord('A'));
                 t := dez AND 15;
                 if t<10 then sio_out (t+ord('0'))
                    else      sio_out (t-10+ord('A'));
                 sio_out (CR);
                 read_sio;
               end;
      ESC    : ende:=true (* ESC-Taste *)
    end;
  end;
end;


function m232_ok : boolean;
(* �berpr�ft die serielle Verbindung *)
begin
  sio_out(SOH);
  sio_out (ord('v')); (* Versionsstring vom M22 anfordern *)
  sio_out (CR);
  read_sio;
  (* Versionsstring pr�fen *)
  if (ser_array[0]=ord('M')) and (ser_array[1]=ord('2'))
    and (ser_array[2]=ord('3')) and (ser_array[3]=ord('2'))
    then m232_ok := true else m232_ok:=false;
end;


function hex2dez : word;
(* liest einen HEX-Wet aus dem seriellen Puffer und wandelt diesen in
   einen dezimalwert um *)
var ret : word;
    st  : byte;
begin
   st  := 0; (* ab Position 0 aus dem Puffer lesen *)
   ret := 0;
   (* solange Zeichen aus dem Puffer lesen, bis kein Zeichen '0'..'9','A'..'F'
      gelese wird *)
   while ( ( (ser_array[st]>=ord('0')) and (ser_array[st]<=ord('9') ) )
        or ( (ser_array[st]>=ord('A')) and (ser_array[st]<=ord('F') ) ) ) do
   begin
     ret := ret shl 4; (* 4 Bit nach links schieben *)
     (* untere 4 Bit dazu *)
     if ( (ser_array[st]>=ord('0')) and (ser_array[st]<=ord('9')) ) then
           ret := ret + (ser_array[st]-ord('0'))
     else  ret := ret + (ser_array[st]-ord('A')+10);
     inc(st);     (* n„chste Stelle im Puffer *)
   end;
   hex2dez := ret;
end;


procedure puts;
(* Ausgabe des seriellen Buffer *)
var st : byte;
begin
  st :=0;
  while (ser_array[st]<>0) do
  begin
    write (chr(ser_array[st]));
    inc (st);
  end;
end;


procedure ablauf;
(* Programmschleife *)
var dez : word;
    t   : byte;
begin
  (* serielle Schnittstelle initialisieren *)
  if not init_sio(port_nr) then
  begin
    (* Schnittstelle konnte nicht initalisiert werden *)
    clrscr;
    writeln;
    writeln;
    writeln ('  ELV-M22-Demoprogramm  V1.0');
    writeln ('  (c) by ELV UK LTD 10.97');
    writeln;
    writeln ('  COM',port_nr,' -Port nicht gefunden');
    writeln;
    writeln ('  Hilfe mit  M232 /?');
    halt (1); (* Programm verlassen *)
  end;
  (* šbertragung zum Meámodul pr�fen *)
  if not m232_ok then
  begin
    clrscr;
    writeln;
    writeln;
    writeln ('  ELV-M232-Demoprogramm  V1.0');
    writeln ('  (c) by ELV UK LTD 10.97');
    writeln;
    writeln ('  Meámodul M22 an COM',port_nr,' nicht gefunden');
    writeln;
    writeln ('  Hilfe mit  M232 /?');
    halt (2); (* Programm verlassen *)
  end;
  cursor_off; (* cursor l”schen *)
  gotoxy (47,4);
  ser_array[ser_zeiger-1]:=0; (* ACK-Zeichen l”schen *)
  puts;       (* Versionsntring anzegen *)

  (* Beginn der Programmschleife *)
  while not ende do
  begin
    sio_out (SOH);      (* Wandlerwert f�r Kanal AD0 anfordern *)
    sio_out (ord('a'));
    sio_out (ord('0'));
    sio_out (CR);
    read_sio;           (* Antwort lesen *)
    gotoxy (50,10);
    ser_array [ser_zeiger-2]:=0; (* die letzten beiden Zeichen l”schen *)
    puts;                        (* Antwort ausgeben *)
    dez := hex2dez;               (* in dezimal wandeln *)
    gotoxy (61,10);
    write (dez:4);               (* ausgeben *)
    gotoxy (74,15);
    write ('  ');
    gotoxy (74,10);
    write ('<-');



    (* Wenn der Abgeichmode nciht aktiv st, die Werte f�r die anderen
       Analogeing„nge eefalls ausgeben *)
    if not abgleichmode then
    begin

      for t:= 1 to 5 do
      begin
        sio_out (SOH);      (* Wandlerwert f�r Kanal AD0 anfordern *)
        sio_out (ord('a'));
        sio_out (ord('0')+t);
        sio_out (CR);
        read_sio;           (* Antwort lesen *)
        gotoxy (50,10+t);
        ser_array [ser_zeiger-2]:=0; (* die letzten beiden Zeichen l”schen *)
        puts;                        (* Antwort ausgeben *)
        dez := hex2dez;               (* in dezimal wandeln *)
        gotoxy (61,10+t);
        write (dez:4);               (* ausgeben *)
        gotoxy (74,9+t);
        write ('  ');
        gotoxy (74,10+t);
        write ('<-');
      end;


      (* Zustand der Datenleitungen abrufen *)
      sio_out (SOH);
      sio_out (ord('w'));
      sio_out (CR);
      read_sio;             (* Antwort lesen *)
      ser_array [ser_zeiger-1]:=0; (* letzte Zeichen l”schen *)
      dez := hex2dez;
      (* Ausgabe der Zust„nde der einzelnen Bits *)
      for t:=0 to 7 do
      begin
        gotoxy (15,10+t);
        if (dez and 1)<>0 then write ('H') else write ('L');
        dez := dez shr 1;
      end;

      (* Z„hlerstand abrufen *)
      sio_out (SOH);
      sio_out (ord('z'));
      sio_out (CR);
      read_sio;             (* Antwort lesen *)
      ser_array [ser_zeiger-1]:=0; (* letzte Zeichen l”schen *)
      gotoxy (19,22);
      puts;
      dez := hex2dez;
      gotoxy (31,22);
      write (dez:5);
    end;
    tastaturauswertung;
  end;
  cursor_on;
end;


begin
  ende         := false;
  for dig_kanal:=0 to 7 do dig_ausg[dig_kanal]:=true;
  dig_kanal    := 0;
  abgleichmode := false;
  port_nr      := 2; (* default COM2 *)

  (* �bergabeparameter auswerten *)
  t := 1;
  While (t <= ParamCount) Do
    Begin
      If (Length(ParamStr(t)) >= 2) And (Pos('/',ParamStr(t)) = 1) Then
        Begin
          Parameter := Copy(ParamStr(t), 2,1);
          Case UpCase(Parameter[1]) Of
            '?','H' : Begin  { Hilfe ausgeben }
                       clrscr;
                       writeln;
                       writeln;
                       writeln ('   ELV-M232-Demoprogramm    V1.0');
                       writeln ('   (c) by ELV UK LTD  10.97');
                       writeln;
                       writeln ('   Programmaufruf: M232 /[COM Nr] /?');
                       writeln;
                       writeln ('   [COM Nr.] : Gibt die Nummer der Seriellen Schnittstelle [1..4] an, mit der');
                       writeln ('               das Meámodul verbunden ist.');
                       writeln ('               Wird der Parameter nicht angegeben, so wird das Modul an');
                       writeln ('               COM 2 gesucht');
                       writeln ('   /?        : Diese Meldung ausgeben');
                       writeln;
                       writeln ('   Beispiel  : M232 /1  : Das Meámodul ist an COM 1 angeschlossen');
                       Halt(0);
                      End;

            '1'..'4' : port_nr := ord(Parameter[1]) - ord('0');
          End;     (*  von Case  *)
        End;
    Inc(t);
  End;

  menue;  (* Bildschirm aufbauen *)
  ablauf; (* Programmablauf *)
  clrscr;


Schon mal Danke!
Prilo
Luckie
Ehemaliges Mitglied
Erhaltene Danke: 1



BeitragVerfasst: Sa 10.04.04 14:23 
Unter Windows wird das so nichts. Da nur Treiber das Recht haben die Hardware direkt anzusprechen. Und Treiber mit Delphi wird nichts geben. Aber es gibt bei Torry Treiber DLL's zusammen mit einer Delphi Kompo.