(*---------------------------------------------------------------------**

** **

** COMMUNICATIONS HARDWARE ADDRESSES **

** **

** These are specific to IBM PCs and close compatibles. **

** **

**---------------------------------------------------------------------*)

const

UART_THR = $00; { offset from base of UART Registers for IBM PC }

UART_RBR = $00;

UART_IER = $01;

UART_IIR = $02;

UART_LCR = $03;

UART_MCR = $04;

UART_LSR = $05;

UART_MSR = $06;

I8088_IMR = $21; { port address of the Interrupt Mask Register }

COM1_Base = $03F8; { port addresses for the UART }

COM2_Base = $02F8;

COM3_Base = $03E8;

COM4_Base = $02E8;

COM1_Irq = 4; { Interrupt line for the UART }

COM2_Irq = 3;

COM3_Irq = 4;

COM4_Irq = 3;

RS232_Base = $0400; { Address of RS 232 com port pointer }

MaxComPorts = 4; { Four ports allowed by this code }

const

{ Port addresses of each com port }

default_com_base:array[1..maxcomports] of word =

( COM1_Base, COM2_Base, COM3_Base, COM4_Base );

{ IRQ line for each port }

default_com_irq:array[1..maxcomports] of integer =

( COM1_Irq, COM2_Irq, COM3_Irq, COM4_Irq );

{----------------------------------------------------------------------}

{ }

{ COMMUNICATIONS BUFFER VARIABLES }

{ }

{ The communications buffers are implemented as circular (ring) }

{ buffers, or double-ended queues. The asynchronous I/O routines }

{ enter characters in the receive buffer as they arrive at the }

{ serial port. Higher-level routines may extract characters from }

{ the receive buffer at leisure. Higher-level routines insert }

{ characters into the send buffer. The asynchronous I/O routines }

{ then send characters out the serial port when possible. }

{ }

{----------------------------------------------------------------------}

const

timeout = 256; { TimeOut value }

async_xon = ^Q; { XON character }

async_xoff = ^S; { XOFF character }

async_overrun_error = 2; { overrun }

async_parity_error = 4; { parity error }

async_framing_error = 8; { framing error }

async_break_found = 16; { break interrupt }

async_cts = $10; { Clear to send }

async_dsr = $20; { Data set ready }

type

async_buffer_type = array[0..1] of char; { I/O buffer type for serial port }

async_ptr = ^async_buffer_type;

var

com_base:array[1..maxcomports] of word; { Port addresses for serial ports }

com_irq:array[1..maxcomports] of integer; { IRQ line for each serial port }

const async_buffer_max=5120;

var

async_buffer:array[0..async_buffer_max] of char;

async_buffer_ptr : async_ptr; { Input buffer address }

async_obuffer_ptr : async_ptr; { Output buffer address }

async_open_flag : boolean; { true if port opened }

async_port, { current open port number (1 -- 4) }

async_base, { base for current open port }

async_irq, { IRQ for current open port }

async_rs232 : integer; { RS232 address for current port }

async_buffer_overflow : boolean; { True if buffer overflow has happened }

async_buffer_used, { Amount of input buffer used so far }

async_maxbufferused : integer; { Maximum amount of input buffer used }

{ Async_Buffer empty if Head = Tail }

async_buffer_head, { Loc in Async_Buffer to put next char }

async_buffer_tail, { Loc in Async_Buffer to get next char }

async_buffer_newtail : integer; { For updating tail value }

async_obuffer_overflow : boolean; { True if buffer overflow has happened }

async_obuffer_used, { Amount of output buffer used }

async_maxobufferused : integer; { Max amount of output buffer used }

{ Async_OBuffer empty if Head = Tail }

async_obuffer_head, { Loc in Async_OBuffer to put next char }

async_obuffer_tail, { Loc in Async_OBuffer to get next char }

async_obuffer_newtail : integer; { For updating tail value }

async_buffer_low, { Low point in receive buffer for XON }

async_buffer_high, { High point in receive buffer for XOFF}

async_buffer_high_2 : integer; { Emergency point for XOFF }

async_xoff_sent, { If XOFF sent }

async_send_xoff, { TRUE to send XOFF ASAP }

async_xoff_received, { If XOFF received }

async_xoff_rec_display, { If XOFF received }

async_xon_rec_display : boolean; { If XOFF received }

async_baud_rate : word; { Current baud rate }

async_save_iaddr : pointer; { Save previous serial interrupt status}

async_do_cts, { TRUE to do clear-to-send checking }

async_do_dsr, { TRUE to do data-set-ready checking }

async_do_xonxoff, { TRUE to do XON/XOFF flow checking }

async_hard_wired_on : boolean; { TRUE if hard-wired connection }

async_break_length : integer; { Length of break in 1/10 seconds }

async_line_status, { Line Status Reg at interrupt }

async_modem_status, { Modem Status Reg at interrupt }

async_line_error_flags : byte; { Line status bits accumulated }

async_buffer_size, { Stores input buffer size }

async_obuffer_size, { Stores output buffer size }

async_uart_IER, { Interrupt enable register address }

async_uart_IIR, { Interrupt ID register address }

async_uart_MSR, { Modem status register address }

async_uart_LSR, { Line status register address }

async_output_delay, { Delay in ms when output buffer full }

async_onemsdelay : integer; { Loop count value to effect 1 ms delay}

async_send_addr : async_ptr; { pointer to Async_Send routine }