[Back to COMM SWAG index] [Back to Main SWAG index] [Original]
{
Your SWAG Collection is really good and should help programmers
enourmously. I myself have learned much from SWAG. Thanks to All!
Here is Attached one FOSSIL unit that implements almost all FOSSIL rev 5
functions in both real and protected mode. I have used it almost a year
now and the real mode operation should be free from bugs, but I added
DPMI support lately so there might be some errors. If someone finds an
error or would like to have some more information then I can be
contacted by e-mail at the following address : raul@reveko.estnet.ee
I have program which uses turbo vision and currently works with four com
ports active at the same time. I use BOCA Research Inc. multiport card
and X00 fossil driver because it supports IRQ Sharing. If I complete the
testing of my own async routines then I hope I will post it too If You
don't mind. Sorry for no documentation but all functions should easy to
understand.
Thanks again.
Raul Rebane.
}
UNIT COMFOSS;
{$C FIXED PRELOAD PERMANENT}
{$IFDEF WINDOWS}
This Unit Cannot be compiled to windows
{$ENDIF}
INTERFACE
CONST
CTS_RTS = 2; {FOSSIL RTS/CTS Flow control value }
RECV_XON_XOFF = 1; {FOSSIL XOn/XOff on receive }
SEND_XON_XOFF = 8; {FOSSIL XOn/XOff on transmit }
XON_XOFF = 9; {FOSSIL Full XOn/XOff flow Control }
Flow_NONE = 1; {No Flow control CheckBox value }
Flow_XONXOFF = 2; {XOn/XOff Flow Control CheckBox }
Flow_RTSCTS = 4; {RTS/CTS Flow Control CheckBox }
Flow_All = 6; {Both Flow Controls Checked }
TYPE
{$IFDEF DPMI}
RealModeRegs = Record
Case Integer Of
0: ( EDI, ESI, EBP, EXX, EBX, EDX, ECX, EAX: Longint;
Flags, ES, DS, FS, GS, IP, CS, SP, SS: Word) ;
1: ( DI,DIH, SI, SIH, BP, BPH, XX, XXH: Word;
Case Integer of
0: (BX, BXH, DX, DXH, CX, CXH, AX, AXH: Word);
1: (BL, BH, BLH, BHH, DL, DH, DLH, DHH,
CL, CH, CLH, CHH, AL, AH, ALH, AHH: Byte));
end;
{$ENDIF}
HandTypes = (TERM, CDRM, MODM);
ComSetupRec = record {ComPort Setup dialog datarec which has next radiobuttons }
Baud_Rate : Word; {Baud Rate index radiobutton value }
Data_Bits : Word; {Number Of DataBits radiobutton }
Stop_Bits : Word; {Number Of StopBits radiobutton }
Parity : Word; {Parity setting radiobutton }
FlowControl : Word; {FlowControl CheckBox group }
end;
PFOS_Record = ^FOS_Record;
FOS_Record = Record
StructSize : Word; {FOSSIL information structure size in bytes }
MajorVer : Byte; {Active FOSSIL's Major Version number }
MinVer : Byte; {Active FOSSIL's Minor Version number }
ID_String : Pointer; {Pointer to FOSSIL's ID String (PChar) }
InBufSize : Word; {Incoming Buffer Size in Bytes }
Rcvd_Free : Word; {Free Bytes in Incoming Buffer }
OutBufSize : Word; {Outgoing Buffer Size in Bytes }
Send_Free : Word; {Free Bytes in Outgoing Buffer }
SWidth : Byte; {Screen Width in Characters }
SHeight : Byte; {Screen Height in Characters }
BaudRate : Byte {Active BaudRate (Computer to Modem) }
End;
PortInfo = Record
Active : Boolean; {Is Port active }
Carrier : Boolean; {Do we Have a Carrier }
Handler : Pointer; {Port Handler (In My App points to Object) }
HandType : HandTypes; {Handler Type }
Baud : LongInt; {Current Port Settings }
ComParams : ComSetupRec; {Com Parameter record see above }
InfoRec : FOS_Record; {FOSSIL information record see above }
end;
Var
ActivePorts : Array[1..4] of PortInfo;
Function FOS_Install (ComPort : Byte) : Boolean;
Procedure FOS_Close (ComPort : Byte);
Procedure FOS_SetPort (ComPort : Byte; COMSET : ComSetupRec);
Procedure FOS_GetPort (Comport : Byte);
Function FOS_TxChar (ComPort : Byte; Ch : Char) : Boolean;
Procedure FOS_TxStr (ComPort : Byte; Str : String);
Function FOS_RxChar (ComPort : Byte) : Char;
Procedure FOS_RxStr (ComPort : Byte; Var S : String);
Function FOS_CharAvail (ComPort : Byte) : Boolean;
Function FOS_Carrier (ComPort : Byte) : Boolean;
Procedure FOS_DTR (ComPort : Byte; State : Boolean);
Function Hangup (Comport : Byte) : Boolean;
Procedure FOS_Timer (Var Timer_Int, Ints_PerSec : Byte; VAR ms_PerTick : Integer);
Procedure FOS_Flush (ComPort : Byte);
Procedure FOS_KillInBuf (ComPort : Byte);
Procedure FOS_KillOutBuf (ComPort : Byte);
Function FOS_TxNoWait (ComPort : Byte; Ch : Char) : Boolean;
Function FOS_Peek (ComPort : Byte) : Char;
Function FOS_PeekKey : Word;
Function FOS_KeyPressed : Boolean;
Function FOS_WaitKey : Word;
Procedure FOS_FLOW (ComPort, State : Byte);
Procedure Set_CtrlC (ComPort, State : Byte);
Function CtrlC_Check (ComPort : Byte) : Boolean;
Procedure FOS_GotoXY (X,Y : Byte);
Procedure FOS_Position (Var X,Y : Byte);
Function FOS_WhereX : Byte;
Function FOS_WhereY : Byte;
Procedure ANSI_Write (Ch : Char);
Procedure WatchDog (ComPort : Byte; Status : Boolean);
Procedure BIOS_Write (Ch : Char);
{$IFDEF DPMI}
{$ELSE}
{These functions can be implemented too under DPMI using realmode callback
services. DPMI function 0303h
AX = 0303H
DS:SI = Selector:Offset Of Your procedure/Function to call
ES:DI = Selector:Offset Of real mode call structure
This function returns
Carry Flag clear if successful
CX:DX = Segment:Offset Of realmode call address
Now You Have the realmode address for realmode app to link with Your code
When Your code gets called You Have the following:
DS:SI = Selector:Offset Of real mode SS:SP
ES:DI = Selector:Offset of real mode Call structure
SS:SP = Locked protected mode API stack
other registers undefined
On return from Your code:
Set ES:DI = Selector:Offset of real mode call structure to restore
Execute an IRET instruction
}
Function FOS_AddProc (Var P) : Boolean;
Function FOS_DelProc (Var P) : Boolean;
{$ENDIF}
Procedure Boot (Method : Boolean);
Function FOS_BlockRead (ComPort : Byte; Bytes : Word; Var Buffer) : Word;
Function FOS_BlockWrite (ComPort : Byte; Bytes : Word; Var Buffer) : Word;
Function FOS_Info (ComPort : Byte) : Boolean;
Function FOS_InFree (ComPort : Byte; Free : Word) : Boolean;
Function FOS_OutFree (ComPort : Byte; Free : Word) : Boolean;
Function FOS_Ringing (ComPort : Byte) : Boolean;
{This Function returns for You pointer to COMPORT Parameters DIALOG
Usage example:
Function SetPortParameters(ComPort) : Boolean;
Var
P : PDIALOG
Ch : Char;
DlgResult : Word;
begin
Ch := Char(ComPort + 48);
IF ActivePorts[ComPort].Active then
begin
ParamDlg := CommSettings('COM' + Ch + ' Parameters');
IF ValidView(ParamDlg) <> NIL then
begin
ParamDlg^.SetData(ActivePorts[ComPort].ComParams);
DlgResult := DeskTop^.ExecView(ParamDlg);
IF DlgResult = cmOk then
begin
IF LogAct then
begin
Writeln(LOGFILE, Clock^.DateStr + ' ' + CLock^.TimeStr + ' COM',
Char(ComPort + 48), ' parameters changed');
Flush(LOGFILE);
end;
ParamDlg^.GetData(ActivePorts[ComPort].ComParams);
FOS_SetPort(ComPort, ActivePorts[ComPort].ComParams);
Case ActivePorts[ComPort].ComParams.FlowControl of
Flow_None : FOS_Flow(ComPort, 0);
Flow_XONXOFF : FOS_Flow(ComPort, RECV_XON_XOFF OR SEND_XON_XOFF);
Flow_RTSCTS : FOS_Flow(ComPort, CTS_RTS);
Flow_All : FOS_Flow(ComPort, 11);
else
FOS_Flow(ComPort, 0); If user selected all or none CheckBoxes
end;
FOS_TxStr(ComPort, 'AT'); Send AT for framing modem
end;
Dispose(ParamDlg, Done);
end;
end
else
MessageBox(^C'Port not active.' + #13#13 + ^C'Unable to change parameters', NIL, mfError or mfOkButton);
SetPortParameters := DlgResult = cmOk;
end;
{Function CommSettings (Str : String) : PDIALOG;}
IMPLEMENTATION
{$IFDEF DPMI}
USES OBJECTS, CRT, WINAPI;
{$ELSE}
USES OBJECTS, CRT, DOS;
{$ENDIF}
VAR
{$IFDEF DPMI}
REGS : RealModeRegs;
BuffSeg : Word;
PMBuffer : Pointer;
Temp_Selector : Word;
{$ELSE}
REGS : Registers;
{$ENDIF}
SavedExitProc : Pointer;
{$IFDEF DPMI}
Function RealModeInt(IntNo : Byte; Var RealRegs : RealModeRegs) : Boolean;assembler;
asm
MOV AX, 0300h
MOV BL, [IntNo]
XOR BH, BH
XOR CX, CX
LES DI, [RealRegs]
INT 31h
JC @Error
MOV AX, 1
JMP @Exit
@Error:
MOV AX, 0
@Exit:
end;
Function SetSelector(Var Selector : Word; Base, Limit : LongInt) : Boolean;
begin
If (Selector <> 0) AND (SetSelectorBase( Selector, Base) = Selector) AND
(SetSelectorLimit(Selector, Limit) = 0) then
SetSelector:= True
else
SetSelector := False;
end;
Function AllocateLowMem(Size : Word; var PMPointer : Pointer ) : Word;
Var
TempAddr : LongInt;
begin
TempAddr := GlobalDOSAlloc(Size) ;
If TempAddr = 0 then RunError(0);
PMPointer := Ptr(LongRec(TempAddr).Lo, 0);
AllocateLowMem := LongRec(TempAddr).Hi;
end ;
Procedure FreeLowMem(Var PMPointer : Pointer ) ;
begin
GlobalDOSFree( Seg(PMPointer^));
PMPointer := nil;
end;
{$ENDIF}
Function FOS_Install (ComPort:Byte) : Boolean;
Begin
REGS.AH := $04;
REGS.CX := 0;
REGS.DX := ComPort - 1;
REGS.BX := $4F50;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
FOS_Install := REGS.AX = $1954;
ActivePorts[Comport].Active := REGS.AX = $1954;
End;
Procedure FOS_Close(ComPort : Byte);
Begin
REGS.AH := $05;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
ActivePorts[ComPort].Active := False;
End;
Procedure FOS_SetPort(ComPort : Byte; COMSET : ComSetupRec);
Var
Setting : Byte; { 1 1 1 1 1 1 1 1 }
Begin
With COMSET do
begin
Case COMSET.Baud_Rate of
0 : Setting := 224; {Default speed 9600}
1 : Setting := 128; {1200 }
2 : Setting := 160; {2400 }
3 : Setting := 192; {4800 }
4 : Setting := 224; {9600 }
5 : Setting := 0; {19200 }
6 : Setting := 32; {S38400 }
End;
Case Data_Bits of
{ 0 : Setting := Setting + 1; {6 Data}
0 : Setting := Setting + 2; {7 Data}
1 : Setting := Setting + 3 {8 Data}
End;
Case Parity of
0 : Setting := Setting + 0; {No Parity}
1 : Setting := Setting + 8; {Odd Parity}
2 : Setting := Setting + 24 {Even Parity}
End;
Case Stop_Bits of
0 : Setting := Setting + 0; {1 Stop}
1 : Setting := Setting + 4 {2 Stop}
End;
End;
REGS.AH := 0;
REGS.AL := Setting;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
End;
Procedure FOS_GetPort(ComPort : Byte);
Var
Setting : Byte;
begin
Setting := ActivePorts[ComPort].InfoRec.BaudRate;
With ActivePorts[ComPort].ComParams do
begin
Case Setting AND $E0 Of
224 : Baud_Rate := 0; {Default speed 9600}
128 : Baud_Rate := 1; {1200 }
160 : Baud_Rate := 2; {2400 }
192 : Baud_Rate := 3; {4800 }
0 : Baud_Rate := 5; {19200 }
32 : Baud_Rate := 6; {S38400 }
end;
Case Setting AND $3 of
0 : Data_Bits := 2; {6 Data}
2 : Data_Bits := 0; {7 Data}
3 : Data_Bits := 1; {8 Data}
End;
Case Setting AND $18 of
0 : Parity := 0; {No Parity}
8 : Parity := 1; {Odd Parity}
24 : Parity := 2; {Even Parity}
End;
Case Setting AND $4 of
0 : Stop_Bits := 0; {1 Stop}
4 : Stop_Bits := 1; {2 Stop}
End;
end;
end;
Function FOS_Ringing(ComPort : Byte) : Boolean;
var
TempCh : Char;
begin
FOS_Ringing := False;
REGS.AH := $0C;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
If REGS.AX = $FFFF Then
FOS_Ringing := False
else
begin
TempCh := Chr(REGS.AL);
if TempCh = #13 then
FOS_Ringing := true;
end;
end;
Function FOS_TxChar(ComPort : Byte; Ch : Char) : Boolean;
Begin
REGS.AH := $01;
REGS.AL := Ord(Ch);
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
FOS_TxChar := (REGS.AH AND $80) = $80;
End;
Procedure FOS_TxStr(ComPort : Byte; Str : String);
Var
I:Integer;
S : String;
Begin
S:= Str + #13#10;
If FOS_OutFree(ComPort, Length(S)) then
I:=FOS_BlockWrite(ComPort, Length(S), S[1])
End;
Function FOS_RxChar(ComPort : Byte) : Char;
Begin
REGS.AH := $02;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
If (REGS.AH AND $80) = $80 then
FOS_RxChar := #0
else
FOS_RxChar := Chr(REGS.AL)
End;
Procedure FOS_RxStr(ComPort : Byte; Var S : String);
Var
Ch : Char;
Count : Byte;
begin
Count := 1; {Current_Pos = 1 }
While FOS_CharAvail(ComPort) do {While Chars available do }
begin
If FOS_Peek(ComPort) <> #10 then {If NextChar = LineFeed then }
begin
S[Count] := FOS_RxChar(ComPort); {String[Current_Pos] = NextChar }
IF S[Count] <> #00 then {Ignore NULL Chars }
Inc(Count); {Increment Current_Pos }
IF Count = 255 then {If Current_Pos = Maxlen(String)}
begin
S[0] := #255; {Return MaxLen String }
Break;
end;
end;
end;
end;
Function FOS_CharAvail(ComPort : Byte) : Boolean;
Begin
REGS.AH := $03;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
FOS_CharAvail := (REGS.AH And 1) = 1
End;
Function FOS_Carrier(ComPort : Byte) : Boolean;
Begin
REGS.AH := $03;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
FOS_Carrier := (REGS.AL And 128) = 128
End;
Procedure FOS_DTR (ComPort : Byte; State : Boolean);
Begin
REGS.AH := $06;
REGS.AL := Byte(State);
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS)
{$ENDIF}
End;
Function Hangup(ComPort : Byte) : Boolean;
Begin
HangUp := False;
If Not FOS_Carrier(ComPort) Then
HangUp := True
else
begin
FOS_DTR (ComPort,False);
Delay (1000);
FOS_DTR (ComPort,True);
If FOS_Carrier(ComPort) Then
Begin
FOS_TxStr(ComPort, '+++');
Delay (1000);
FOS_TxStr(ComPort, 'ATH0'+ #10#13);
Delay(1000);
end
else
HangUp := True;
end;
If Not FOS_Carrier(ComPort) Then
HangUp := True
End;
Procedure FOS_Timer(Var Timer_Int, Ints_PerSec : Byte; VAR ms_PerTick : Integer);
Begin
REGS.AH := $07;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
Timer_Int := REGS.AL;
Ints_PerSec := REGS.AH;
ms_PerTick := REGS.DX
End;
Procedure FOS_Flush(ComPort:Byte);
Begin
REGS.AH := $08;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS)
{$ENDIF}
End;
Procedure FOS_KillOutBuf(ComPort:Byte);
Begin { Purges the OutPut Buffer }
REGS.AH := $09;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS)
{$ENDIF}
End;
Procedure FOS_KillInBuf(ComPort:Byte);
Begin { Purges the Input Buffer }
REGS.AH := $0A;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS)
{$ENDIF}
End;
Function FOS_TxNoWait(ComPort : Byte; Ch : Char) : Boolean;
Begin
REGS.AH := $0B;
REGS.AL := Ord(Ch);
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
FOS_TxNoWait := (REGS.AH AND $80) = $80;
End;
Function FOS_Peek(ComPort : Byte) : Char;
Begin
REGS.AH := $0C;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
FOS_Peek := Chr(REGS.AL)
End;
Function FOS_PeekKey : Word;
Begin
REGS.AH := $0D;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
FOS_PeekKey := REGS.AX
End;
Function FOS_KeyPressed : Boolean;
Begin
REGS.AH := $0D;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
FOS_KeyPressed := (REGS.AX <> $FFFF);
End;
Function FOS_WaitKey : Word;
Begin
REGS.AH := $0E;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
FOS_WaitKey := REGS.AX
End;
Procedure FOS_FLOW(ComPort, State : Byte);
Begin
REGS.AH := $0F;
REGS.AL := State + $F0;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS)
{$ENDIF}
End;
Procedure Set_CtrlC (ComPort, State : Byte);
Begin
REGS.AH := $10;
REGS.AL := State;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS)
{$ENDIF}
End;
Function CtrlC_Check(ComPort : Byte) : Boolean;
Begin
REGS.AH := $10;
REGS.AL := 2;
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
CtrlC_Check := Boolean(REGS.AX)
End;
Procedure FOS_GotoXY(X, Y : Byte);
Begin
REGS.AH := $11;
REGS.DH := Y - 1;
REGS.DL := X - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS)
{$ENDIF}
End;
Procedure FOS_Position (Var X,Y:Byte);
Begin
REGS.AH := $12;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
X := REGS.DL + 1;
Y := REGS.DH + 1
End;
Function FOS_WhereX : Byte;
Begin
REGS.AH := $12;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
FOS_WhereX := REGS.DL + 1
End;
Function FOS_WhereY : Byte;
Begin
REGS.AH := $12;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS);
{$ENDIF}
FOS_WhereY := REGS.DH + 1
End;
Procedure ANSI_Write(Ch : Char);
Begin
REGS.AH := $13;
REGS.AL := Ord(Ch);
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS)
{$ENDIF}
End;
Procedure WatchDog(ComPort : Byte; Status : Boolean);
Begin
REGS.AH := $14;
REGS.AL := Byte(Status);
REGS.DX := ComPort - 1;
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS)
{$ENDIF}
End;
Procedure BIOS_Write(Ch : Char);
Begin
REGS.AH := $15;
REGS.AL := Ord(Ch);
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS)
{$ENDIF}
End;
{$IFDEF DPMI}
{$ELSE}
Function FOS_AddProc(Var P) : Boolean;
Begin
REGS.AH := $16;
REGS.AL := $01;
REGS.ES := Seg(P);
REGS.DX := Ofs(P);
Intr($14, REGS);
FOS_AddProc := REGS.AX = 0
End;
{$ENDIF}
{$IFDEF DPMI}
{$ELSE}
Function FOS_DelProc(Var P) : Boolean;
Begin
REGS.AH := $16;
REGS.AL := $00;
REGS.ES := Seg (P);
REGS.DX := Ofs (P);
Intr($14, REGS);
FOS_DelProc := REGS.AX = 0
End;
{$ENDIF}
Procedure Boot(Method : Boolean);
Begin
REGS.AH := $17;
REGS.AL := Byte(Method); {Cold, Warm}
{$IFDEF DPMI}
RealModeInt($14, REGS);
{$ELSE}
Intr($14, REGS)
{$ENDIF}
End;
Function FOS_BlockRead(ComPort : Byte; Bytes : Word; Var Buffer) : Word;
Begin
REGS.AH := $18;
REGS.DX := ComPort - 1;
REGS.CX := Bytes;
{$IFDEF DPMI}
REGS.DI := 0;
REGS.ES := BuffSeg;
RealModeInt($14, REGS);
Move(PMBuffer^, Buffer, REGS.AX);
{$ELSE}
REGS.ES := Seg(Buffer);
REGS.DI := Ofs(Buffer);
Intr($14, REGS);
{$ENDIF}
FOS_BlockRead := REGS.AX
End;
Function FOS_BlockWrite(ComPort : Byte; Bytes : Word; Var Buffer) : Word;
Begin
REGS.AH := $19;
REGS.DX := ComPort - 1;
REGS.CX := Bytes;
{$IFDEF DPMI}
Move(Buffer, PMBuffer^, Bytes);
REGS.DI := 0;
REGS.ES := BuffSeg;
RealModeInt($14, REGS);
{$ELSE}
REGS.ES := Seg (Buffer);
REGS.DI := Ofs (Buffer);
Intr($14, REGS);
{$ENDIF}
FOS_BlockWrite := REGS.AX
End;
Function FOS_Info(ComPort : Byte) : Boolean;
begin
REGS.AH := $1B;
REGS.DX := ComPort - 1;
REGS.CX := SizeOf(ActivePorts[ComPort].InfoRec);
{$IFDEF DPMI}
REGS.DI := 0;
REGS.ES := BuffSeg;
RealModeInt($14, REGS);
If NOT SetSelector(Temp_Selector, PtrRec(PFOS_Record(PMBuffer)^.ID_String).Seg*LongInt(16),
PtrRec(PFOS_Record(PMBuffer)^.ID_String).Ofs + 256) then
PFOS_Record(PMBuffer)^.ID_String := Nil
else
PtrRec(PFOS_Record(PMBuffer)^.ID_String).Seg := Temp_Selector;
Move(PMBuffer^, ActivePorts[ComPort].InfoRec, SizeOf(FOS_Record));
{$ELSE}
REGS.ES := Seg(ActivePorts[ComPort].InfoRec);
REGS.DI := Ofs(ActivePorts[ComPort].InfoRec);
Intr($14, REGS);
{$ENDIF}
If (ActivePorts[ComPort].InfoRec.Rcvd_Free) <=
(ActivePorts[ComPort].InfoRec.InBufSize) then
FOS_Info := True
else
FOS_Info := False;
end;
Function FOS_InFree(ComPort : Byte; Free : Word) : Boolean;
begin
REGS.AH := $1B;
REGS.DX := ComPort - 1;
REGS.CX := SizeOf(ActivePorts[ComPort].InfoRec);
{$IFDEF DPMI}
REGS.DI := 0;
REGS.ES := BuffSeg;
RealModeInt($14, REGS);
If PFOS_Record(PMBuffer)^.Rcvd_Free > Free then
FOS_InFree := True
else
FOS_InFree := False;
{$ELSE}
REGS.ES := Seg(ActivePorts[ComPort].InfoRec);
REGS.DI := Ofs(ActivePorts[ComPort].InfoRec);
Intr($14, REGS);
If (ActivePorts[ComPort].InfoRec.Rcvd_Free) > Free then
FOS_InFree := True
else
FOS_InFree := False;
{$ENDIF}
end;
Function FOS_OutFree(ComPort : Byte; Free : Word) : Boolean;
begin
REGS.AH := $1B;
REGS.DX := ComPort - 1;
REGS.CX := SizeOf(ActivePorts[ComPort].InfoRec);
{$IFDEF DPMI}
REGS.DI := 0;
REGS.ES := BuffSeg;
RealModeInt($14, REGS);
If PFOS_Record(PMBuffer)^.Send_Free > Free then
FOS_OutFree := True
else
FOS_OutFree := False;
{$ELSE}
REGS.ES := Seg(ActivePorts[ComPort].InfoRec);
REGS.DI := Ofs(ActivePorts[ComPort].InfoRec);
Intr($14, REGS);
If (ActivePorts[ComPort].InfoRec.Send_Free) >= Free then
FOS_OutFree := True
else
FOS_OutFree := False;
{$ENDIF}
end;
procedure CustomExit; FAR;
Var
Counter : Byte;
begin
ExitProc := SavedExitProc;
For Counter := 1 to 4 do
If ActivePorts[Counter].Active then
FOS_Close(Counter);
{$IFDEF DPMI}
FreeLowMem(PMBuffer);
{$ENDIF}
end;
{FUNCTION CommSettings(Str : String) : PDialog;
var
DlgWin : PDialog;
R : TRect;
Control, Labl, Histry : PView;
Begin
R.Assign(18,2,58,18);
New(DlgWin, Init(R, Str));
R.Assign(3,2,17,9);
Control := New(PRadioButtons, Init(R,
NewSItem('~H~ardware',
NewSItem('~1~200',
NewSItem('~2~400',
NewSItem('~4~800',
NewSItem('9~6~00',
NewSItem('1~9~200',
NewSItem('3~8~400',Nil)))))))));
Control^.HelpCtx := hcSelBaudRate;
DlgWin^.Insert(Control);
R.Assign(3,1,14,2);
Labl := New(PLabel, Init(R, '~B~aud Rate ', Control));
DlgWin^.Insert(Labl);
R.Assign(20,2,27,4);
Control := New(PRadioButtons, Init(R,
NewSItem('7',
NewSItem('8',Nil))));
Control^.HelpCtx := hcSelDataBits;
DlgWin^.Insert(Control);
R.Assign(20,1,26,2);
Labl := New(PLabel, Init(R, '~D~ata ', Control));
DlgWin^.Insert(Labl);
R.Assign(30,2,37,4);
Control := New(PRadioButtons, Init(R,
NewSItem('1',
NewSItem('2',Nil))));
Control^.HelpCtx := hcSelStopBits;
DlgWin^.Insert(Control);
R.Assign(30,1,36,2);
Labl := New(PLabel, Init(R, '~S~top ', Control));
DlgWin^.Insert(Labl);
R.Assign(20,6,30,9);
Control := New(PRadioButtons, Init(R,
NewSItem('~N~one',
NewSItem('~O~dd',
NewSItem('~E~ven',Nil)))));
Control^.HelpCtx := hcSelParity;
DlgWin^.Insert(Control);
R.Assign(20,5,28,6);
Labl := New(PLabel, Init(R, '~P~arity ', Control));
DlgWin^.Insert(Labl);
R.Assign(3,11,21,14);
Control := New(PCheckboxes, Init(R,
NewSItem('None',
NewSItem('~X~ON/XOFF',
NewSItem('~R~TS/CTS',Nil)))));
Control^.HelpCtx := hcSelFlowControl;
DlgWin^.Insert(Control);
R.Assign(3,10,17,11);
Labl := New(PLabel, Init(R, '~F~low Control ', Control));
DlgWin^.Insert(Labl);
R.Assign(23,11,37,13);
Control := New(PButton, Init(R, 'Ok', cmOK, bfDefault));
DlgWin^.Insert(Control);
R.Assign(23,13,37,15);
Control := New(PButton, Init(R, 'Cancel', cmCancel, bfNormal));
DlgWin^.Insert(Control);
R.Assign(2,1,3,9);
Control := New(PStaticText, Init(R, 'Ú³³³³³³³'));
DlgWin^.Insert(Control);
R.Assign(2,9,18,10);
Control := New(PStaticText, Init(R, 'ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ'));
DlgWin^.Insert(Control);
R.Assign(17,2,18,9);
Control := New(PStaticText, Init(R, '³³³³³³³'));
DlgWin^.Insert(Control);
R.Assign(19,4,28,5);
Control := New(PStaticText, Init(R, 'ÀÄÄÄÄÄÄÄÙ'));
DlgWin^.Insert(Control);
R.Assign(29,4,38,5);
Control := New(PStaticText, Init(R, 'ÀÄÄÄÄÄÄÄÙ'));
DlgWin^.Insert(Control);
R.Assign(27,2,28,4);
Control := New(PStaticText, Init(R, '³³'));
DlgWin^.Insert(Control);
R.Assign(37,2,38,4);
Control := New(PStaticText, Init(R, '³³'));
DlgWin^.Insert(Control);
R.Assign(19,1,20,4);
Control := New(PStaticText, Init(R, 'Ú³³'));
DlgWin^.Insert(Control);
R.Assign(29,1,30,4);
Control := New(PStaticText, Init(R, 'Ú³³'));
DlgWin^.Insert(Control);
R.Assign(19,9,31,10);
Control := New(PStaticText, Init(R, 'ÀÄÄÄÄÄÄÄÄÄÄÙ'));
DlgWin^.Insert(Control);
R.Assign(19,5,20,9);
Control := New(PStaticText, Init(R, 'Ú³³³'));
DlgWin^.Insert(Control);
R.Assign(30,6,31,9);
Control := New(PStaticText, Init(R, '³³³'));
DlgWin^.Insert(Control);
R.Assign(2,14,22,15);
Control := New(PStaticText, Init(R, 'ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ'));
DlgWin^.Insert(Control);
R.Assign(21,11,22,14);
Control := New(PStaticText, Init(R, '³³³'));
DlgWin^.Insert(Control);
R.Assign(2,10,3,14);
Control := New(PStaticText, Init(R, 'Ú³³³'));
DlgWin^.Insert(Control);
R.Assign(14,1,18,2);
Control := New(PStaticText, Init(R, 'ÄÄÄ¿'));
DlgWin^.Insert(Control);
R.Assign(26,1,28,2);
Control := New(PStaticText, Init(R, 'Ä¿'));
DlgWin^.Insert(Control);
R.Assign(36,1,38,2);
Control := New(PStaticText, Init(R, 'Ä¿'));
DlgWin^.Insert(Control);
R.Assign(17,10,22,11);
Control := New(PStaticText, Init(R, 'ÄÄÄÄ¿'));
DlgWin^.Insert(Control);
R.Assign(28,5,31,6);
Control := New(PStaticText, Init(R, 'ÄÄ¿'));
DlgWin^.Insert(Control);
DlgWin^.SelectNext(False);
CommSettings := DlgWin;
end;}
Begin
{$IFDEF DPMI}
BuffSeg := AllocateLowMem(1024, PMBuffer);
Temp_Selector := AllocSelector(0);
FillChar(ActivePorts, SizeOf(ActivePorts), #00);
{$ELSE}
FillChar(ActivePorts, SizeOf(ActivePorts), #00);
{$ENDIF}
SavedExitProc := ExitProc;
ExitProc := @CustomExit;
end.
[Back to COMM SWAG index] [Back to Main SWAG index] [Original]