comm.cpp

串行通信编程源码

/* ******************************************************************** *
 *
 *  Set8n -- set 8 data bits, no parity
 *
 * ******************************************************************** */

UINT    Comm::Set8n(void)
{
UINT    oldline;                            // old LCR value


oldline = IN(LCR);                          // get the current LCR value

line = ((oldline & LCR_STOP) | LCR_WLEN);   // setup 8 databits, no parity
OUT(LCR, line);                             // ..and write new LCR

return(oldline);                            // return old LCR value

}



/* ******************************************************************** *
 *
 *  InstallInt -- install interrupt service routine
 *
 * ******************************************************************** */

void    Comm::InstallInt(void)
{
int     mask;                               // interrupt mask


old_comm = getvect(irq + 8);                // save old comm interrupt rtn
comm = this;                                // ..save instance address
setvect(irq + 8, comm_int);                 // ..establish new routine

mask = inportb(I8259M);                     // get current interrupt mask
mask &= ~(1 << irq);                        // determine new mask
outportb(I8259M, mask);                     // ..and put in place

}



/* ******************************************************************** *
 *
 *  DeInstallInt -- de-install interrupt service routine
 *
 * ******************************************************************** */

void    Comm::DeInstallInt(void)
{
int     mask;                               // interrupt mask


OUT(IER, 0);                                // disable UART interrupt
OUT(FCR, 0);                                // ..and fifo, if available
setvect(irq + 8, old_comm);                 // re-establish old comm rtn

mask = inportb(I8259M);                     // get current interrupt mask
mask |= (1 << irq);                         // determine new mask
outportb(I8259M, mask);                     // ..and turn off comm int

}



/* ******************************************************************** *
 *
 *  ModemChanged -- returns TRUE if the modem status register changed
 *
 * ******************************************************************** */

int     Comm::ModemChanged(void)
{
int     rtn;                                // return value


rtn = msr_changed;                          // get current status
msr_changed = 0;                            // ..and clear flag
return(rtn);                                // ..and return current status

}



/* ******************************************************************** *
 *
 *  Modem -- returns the modem status register
 *
 * ******************************************************************** */

int     Comm::Modem(void)
{

return(int_msr);                            // return last modem status

}



/* ******************************************************************** *
 *
 *  IFlow -- return status of input flow control
 *
 * ******************************************************************** */

int     Comm::IFlow(void)
{

return(i_flow);                             // rtn TRUE if input flow
                                            // ..has been restricted
}



/* ******************************************************************** **
 *
 *  Read -- read a character, the msr and lsr from the port's input queue
 *
 *  Returns: -1 = input queue was empty
 *            0 = character returned
 *            n = number of characters overflowed buffer
 *
 * ******************************************************************** */

UINT    Comm::Read(char *c,                 // queued character
                   char *m,                 // modem status register
                   char *l)                 // line status register
{


if (i_count == 0)                           // q. input queue empty?
    return(-1);                             // a. yes .. return w/err code

*c = *i_get++;                              // get char from input queue
*m = *i_get++;                              // ..then get modem status
*l = *i_get++;                              // ..then get line status
i_count--;                                  // ..finally decrement count

if (i_get > i_limit)                        // q. reached end of buffer?
    i_get = i_buf;                          // a. yes .. set to beginning

if (i_flow && (ICount() <= i_start))        // q. port need restarting?
    RTS(1);                                 // a. yes .. raise RTS line

return(((UCHAR) *l == 0xff) ?               // return with character or
                    ((*m << 8) + *c) : 0);  // ..with overflow count
                                            // ..based on lsr flag
}



/* ******************************************************************** **
 *
 *  IEmpty -- return TRUE if input queue is empty
 *
 * ******************************************************************** */

int     Comm::IEmpty(void)
{

return((i_count == 0) &&                    // TRUE if queue empty
            ((UCHAR) i_put[2] != 0xff));    // ..and not in overflow

}



/* ******************************************************************** **
 *
 *  OEmpty -- return TRUE if output queue empty
 *
 * ******************************************************************** */

int     Comm::OEmpty(void)
{

return(o_count == 0);                       // TRUE if queue empty

}



/* ******************************************************************** **
 *
 *  ICount -- get depth of the input queue
 *
 * ******************************************************************** */

UINT    Comm::ICount(void)
{

return(i_count);                            // return nbr in queue

}



/* ******************************************************************** **
 *
 *  OCount -- get depth of the output queue
 *
 * ******************************************************************** */

UINT    Comm::OCount(void)
{

return(o_count);                            // return nbr in queue

}



/* ******************************************************************** **
 *
 *  IFree -- get free space in input queue
 *
 * ******************************************************************** */

UINT    Comm::IFree(void)
{

return(i_size - i_count);                   // buffer size less in-use

}



/* ******************************************************************** **
 *
 *  OFree -- get free space in output queue
 *
 * ******************************************************************** */

UINT    Comm::OFree(void)
{

return(o_size - o_count);                   // buffer size less in-use

}



/* ******************************************************************** **
 *
 *  Write -- write a character to the output queue
 *
 * ******************************************************************** */

void    Comm::Write(int c)                  // character to queue up
{

while (NOT OFree())                         // q. room in output queue?
    ;                                       // a. no .. wait a bit

*o_put++ = c;                               // put char into output queue

if (empty_trans)                            // q. pump need priming?
    {                                       // a. yes .. try to do output
    empty_trans = 0;                        // clear empty tranmitter flag
    o_count++;                              // ..and count character

    if ((NOT flow || IN(MSR) & MSR_CTS)     // q. output flow satisfied?
                && (c = Deque()) != -1)     // ..and queue not empty?
        OUT(THR, c);                        // a. yes .. send char to port
    }

 else
    o_count++;                              // else .. count characters

if (o_put > o_limit)                        // q. reach end of buffer?
    o_put = o_buf;                          // a. yes .. set to beginning

}



/* ******************************************************************** *
 *
 *  Write -- write a string of characters to output queue
 *
 * ******************************************************************** */

void    Comm::Write(char *s)                // string of chars to output
{