comm.hpp

这个程序是用于通讯的

    int AllocBuffers(int RxBufSz, int TxBufSz, int UseFarMem = 0);
    int FreeBuffers();              // free ring buffers function
                                    // reset default buffers function
    static void SetDefaultBuffers(int RxDefSz, int TxDefSz, int DefMem = 0);

                                    // open with full port definition
    int Open(int ComBase, int IRQNbr, int InterruptVctr, char *Params = "");
    int Open(int ComN, char *Params = ""); // open COM1 or COM2

    int Close();                    // close & leave DTR/RTS in pre-open state
    int Close(int DTR, int RTS);    // close with option to force DTR/RTS

    void Release();                 // disable interrupt operation
    void Restart();                 // resume interrupt mode of operation

    void PortAddress(int BaseAdrs); // set port base address
    int PortAddress();              // get port base address

    int Tx(char Ch);                // transmit character
    int Tx(char *String);           // transmit string
    int Tx(char *Block, int NbrBytes); // transmit block

    int Rx();                       // receive character
    int Rx(char *Block, int MaxNbrBytes); // receive block until maxbytes
                                    // rx blk until delim or maxbytes
    int Rx(char *Block, int MaxNbrBytes, char Delim, int IncludeDelim = 1);

    int Peek(int Offset = 0);       // peek receive buffer (index opt)

    int Status(int Mask = 0xffff);  // get port status (Stat1/Stat2)
    void Reset();                   // reset parity,framing,char/bufr overrun
    char Error(int Mask = 0x0f);    // test for parity,frame,char/bufr overrun

    int Params(char *Params);       // set port parameters
    char *Params();                 // get port parameters

    void RxFlush();                 // flush receive buffer
    void TxFlush();                 // flush transmit buffer

    void HardFlow(int Mask);        // set/reset hardware flow options

    void XFlow(int Mask);           // set/reset XON/XOFF flow control
    char XFlow();                   // read XON/XOFF flow settings (bitmapped)
                                    // set XON/XOFF trip levels
    int XTrip(int XoffLevel, int XonLevel, int RepeatLevel);
    void XoffReset();               // forced reset of XOFF received condition
    void XoffSet();                 // simulate XOFF received
    char XoffRxd();                 // test for XOFF received
    char XoffTxd();                 // test for XOFF transmitted

    void Dtr(int Enable);           // set/reset DTR line
    void Rts(int Enable);           // set/reset RTS line
    char Msr();                     // get value of modem status register
    char Cts();                     // get status of CTS line
    char Dsr();                     // get status of DSR line
    char Carrier();                 // get status of carrier detect line

    void Break(int Enable);         // set or reset breaking condition
    char Break();                   // check if break signal received

    char Regs(int UARTreg, int Value = -1); // raw R/W of UART regs

    int RxLevel();                  // get number bytes in receive buffer
    int TxAvailable();              // get bytes available in transmit buffer
    char TxEmpty();                 // test for transmit buffer empty

    void RxMask(char Mask);         // set strip mask for incoming chars
    void FlushBadChars(int Flag);   // set handling for chars with errs
    char FlushBadChars();           // get setting chars with errs
};

/////////////////////////////////////////////////////////////////////////
//  E X T E R N A L   A S M   F U N C T I O N S                        //
/////////////////////////////////////////////////////////////////////////
  extern "C" {
int async_open(AsyncPort *, int, int, int, char *); // open async port
int async_close(AsyncPort *);              // close async port
int async_tx(AsyncPort *, char);           // transmit character
int async_txblk(AsyncPort *, char *, int); // transmit a block
int async_rx(AsyncPort *);                 // receive a character
int async_rxblk(AsyncPort *, char *, int); // receive a block
int async_rxblkch(AsyncPort *, char *, int, char, int); // rx blk till char
int async_stat(AsyncPort *, int);          // get stat1/stat2 bytes
int async_setbpds(AsyncPort *, char *);    // change line parameters
void async_rxflush(AsyncPort *);           // flush the receive buffer
void async_txflush(AsyncPort *);           // flush the transmit buffer
void async_msrflow(AsyncPort *, int);      // set MSR related flw cntrl
void async_xflow(AsyncPort *, int);        // XON/OFF protocl on/off
void async_xoffclr(AsyncPort *);           // manually clr XOFF rx'd
void async_xoffset(AsyncPort *);           // manually set XOFF rx'd
void async_dtr(AsyncPort *, int);          // DTR on/off
void async_rts(AsyncPort *, int);          // RTS on/off
void async_sndbrk(AsyncPort *, int);       // Set/clr tx modem brk sgnl
void async_stop(AsyncPort *);              // halts interrupt operation
void async_restart(AsyncPort *);           // re-init an already open port
int async_peek(AsyncPort *, int);          // peek indexed char in rx buffer
int async_regs(AsyncPort *, int, int);     // direct read/write of port regs
void async_FIFOrxlvl(AsyncPort *, int);    // set rx FIFO trigger level
void async_FIFOtxlvl(AsyncPort *, int);    // set max sent per tx intrpt
  }


/////////////////////////////////////////////////////////////////////////
//  D E F I N I T I O N    O F   I N L I N E   F U N C T I O N S       //
/////////////////////////////////////////////////////////////////////////

inline void AsyncPort::SetDefaultBuffers(int DefRxSz,int DefTxSz,int DefMem)
 { DefRxBufSz = DefRxSz, DefTxBufSz = DefTxSz, DefMemType = DefMem; }
inline void AsyncPort::PortAddress(int BaseAdrs)
 { ComBase = BaseAdrs; }
inline int AsyncPort::PortAddress()
 { return ComBase; }
inline void AsyncPort::Release()
 { async_stop(this); }
inline void AsyncPort::Restart()
 { async_restart(this); }
inline int AsyncPort::Tx(char Ch)
 { return (async_tx(this, Ch)); }
inline int AsyncPort::Tx(char *Block, int NbrBytes)
 { return (async_txblk(this, Block, NbrBytes)); }
inline int AsyncPort::Rx()
 { return (async_rx(this)); }
inline int AsyncPort::Rx(char *Block, int MaxNbrBytes)
 { return (async_rxblk(this, Block, MaxNbrBytes)); }
inline int AsyncPort::Rx(char *Block, int MaxNbrBytes, char Delim,
 int IncludeDelim)
 { return (async_rxblkch(this, Block, MaxNbrBytes, Delim, IncludeDelim)); }
inline int AsyncPort::Peek(int Offset)
 { return (async_peek(this, Offset)); }
inline int AsyncPort::Status(int Mask)
 { return (async_stat(this, Mask)); }
inline void AsyncPort::Reset()
 { Stat1 &= '\xe0'; }
inline char AsyncPort::Error(int Mask)
 { return (Stat1 & Mask); }
inline int AsyncPort::Params(char *Params)
 { return (async_setbpds(this, Params)); }
inline char * AsyncPort::Params()
 { return BPDSstr; }
inline void AsyncPort::RxFlush()
 { async_rxflush(this); }
inline void AsyncPort::TxFlush()
 { async_txflush(this); }
inline void AsyncPort::HardFlow(int Mask)
 { async_msrflow(this, Mask); }
inline void AsyncPort::XFlow(int Mask)
 { async_xflow(this, Mask); }
inline char AsyncPort::XFlow()
 { return (Stat3 & '\xe0'); }
inline void AsyncPort::XoffReset()
 { async_xoffclr(this); }
inline void AsyncPort::XoffSet()
 { async_xoffset(this); }
inline char AsyncPort::XoffRxd()
 { return (TxStat & '\x02'); }
inline char AsyncPort::XoffTxd()
 { return (Stat2 & '\x04'); }
inline void AsyncPort::Dtr(int Enable)
 { async_dtr(this, Enable); }
inline void AsyncPort::Rts(int Enable)
 { async_dtr(this, Enable); }
inline char AsyncPort::Msr()
 { return MSRVal; }
inline char AsyncPort::Cts()
 { return (MSRVal & '\x10'); }
inline char AsyncPort::Dsr()
 { return (MSRVal & '\x20'); }
inline char AsyncPort::Carrier()
 { return (MSRVal & '\x80'); }
inline void AsyncPort::Break(int Enable)
 { async_sndbrk(this, Enable); }
inline char AsyncPort::Break()
 { return (Stat1 & '\x10'); }
inline char AsyncPort::Regs(int UARTreg, int Value)
 { return async_regs(this, UARTreg, Value); }
inline int AsyncPort::RxLevel()
 { return (RxSize - RxFree); }
inline int AsyncPort::TxAvailable()
 { return (TxFree); }
inline char AsyncPort::TxEmpty()
 { return (TxStat & '\x08'); }
inline void AsyncPort::RxMask(char Mask)
 { StripMask = Mask; }
inline void AsyncPort::FlushBadChars(int Flag)
 { (Flag) ? (Stat3 |= 1) : (Stat3 &= '\xfe'); }
inline char AsyncPort::FlushBadChars()
 { return (Stat3 & 1); }
     
#endif          // COMM_HPP