home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / cppcom.com / SERIALPO.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-14  |  4.5 KB  |  169 lines
  1. /***************************************************************************
  2. These C++ classes are copyright 1990, by William Herrera.
  3.  
  4. All those who put this code or its derivatives in a commercial product MUST
  5. mention this copyright in their documentation for users of the products in
  6. which this code or its derivative classes are used.  Otherwise, this code
  7. may be freely distributed and freely used for any purpose.
  8.  
  9. Enhancements: 1991 by David Orme
  10.     *  General cleanup.
  11.             - I/O now takes advantage of C++ overloading.
  12.             - Serial port I/O functionality now only in Serial class.
  13.             - Modem functionality now only in Modem class.
  14.     *  Possible to easily implement file Xfr prots now.
  15.     *  CCITT CRC-16 class added                            -- 2-20-1991
  16.     *  BIOS Timer class added                                -- 2-22-1991
  17.     *  Optional timeout on all input routines added    -- 2-25-1991
  18.  
  19. ***************************************************************************/
  20.  
  21. // file serialpo.cpp class definitions for SerialPort.
  22.  
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25.  
  26. #include "serialpo.hpp"
  27.  
  28. SerialPort::SerialPort(int portnum, int speed, parity_t p,
  29.                          int sbits, int dbits, boolean trans)
  30. {
  31.     port_number = portnum;
  32.     switch(port_number)
  33.     {
  34.         case 1: 
  35.             com = new COM1;
  36.             break;          
  37.         case 2: 
  38.             com = new COM2;
  39.             break;        
  40.         case 3: 
  41.             com = new COM3;
  42.             break;        
  43.         case 4: 
  44.             com = new COM4;
  45.             break;
  46.         default:
  47.             fputs("SerialPort error: constructor cannot initialize"
  48.                     " port number given", stderr);
  49.             exit(-1);
  50.     }    
  51.     com->SetBaudRate(speed);
  52.     com->SetParity(p);
  53.     com->SetStopBits(sbits);
  54.     com->SetDataBits(dbits);
  55.     translatenewline = trans;
  56.     lastin_wascr = false;
  57. }
  58.  
  59. SerialPort::~SerialPort() 
  60. { 
  61.     delete com;
  62. }
  63.  
  64. uart * SerialPort::GetUART() { return com; }
  65.  
  66. void SerialPort::SetSpeed(int s) { com->SetSpeed(s); }
  67. int SerialPort::GetSpeed() { return com->GetSpeed(); }
  68.  
  69. void SerialPort::SetParity(parity_t p) { com->SetParity(p); }
  70. parity_t SerialPort::GetParity() { return com->GetParity(); }
  71.  
  72. void SerialPort::SetStopBits(int s) { com->SetStopBits(s); }
  73. int SerialPort::GetStopBits() { return com->GetStopBits(); }
  74.  
  75. void SerialPort::SetDataBits(int s) { com->SetStopBits(s); }
  76. int SerialPort::GetDataBits() { return com->GetStopBits(); }
  77.  
  78. void SerialPort::PurgeInput() { com->PurgeInput(); }
  79. void SerialPort::FlushOutput() { com->FlushOutput(); }
  80. void SerialPort::PurgeOutput() { com->PurgeOutput(); }
  81.  
  82. boolean SerialPort::CarrierPresent() { return com->CarrierPresent(); }
  83.       
  84. void SerialPort::RaiseDTR() { com->SetDTR(true); }
  85. void SerialPort::DropDTR() { com->SetDTR(false); }
  86.  
  87.  
  88. void SerialPort::Pause(int ms) { com->Pause(ms); }
  89. void SerialPort::Break(int ms) { com->Break(ms); }
  90.  
  91. void SerialPort::SetDoIfNoCarrier(void (*f)()) { com->SetDoIfNoCarrier(f); }
  92. void SerialPort::SetDoOnRing(void (*f)()) { com->SetDoOnRing(f); }
  93.  
  94. boolean SerialPort::InputEmpty() { return com->InputEmpty(); }
  95. boolean SerialPort::OutputEmpty() { return com->OutputEmpty(); }
  96. boolean SerialPort::OutputReady() { return com->OutputReady(); }
  97.  
  98.  
  99. // These are the binary read/write functions -- they don't do
  100. // \r\n xlation.
  101.  
  102. void SerialPort::Write(void * p,int n)
  103. {
  104.     // will only write up to number that can fit into queue, up to max of n.
  105.     while(n > 0)
  106.     {
  107.         Send(*((char *)p)++);
  108.         --n;        
  109.     }
  110. }
  111.  
  112. int SerialPort::Read(char * p, int n, float secs)
  113. {
  114.     // will only read up to number in queue, up to max of n chars.
  115.     int i = 0;
  116.     T.Set(secs);                            // Set timeout timer
  117.     while(n-- > 0 && (!T.TimeOut() || com->InputEmpty()) )
  118.     {
  119.         while (!T.TimeOut() && com->InputEmpty());
  120.         if (com->InputEmpty())
  121.             break;
  122.         *p++ = com->GetChar();
  123.         i++;
  124.     }
  125.     return i;
  126.     // returns number actually read.
  127. }
  128.  
  129.  
  130. // The send and recieve functions below are set up to allow 
  131. // optional carriage return/linefeed translation of '\r\n' <--> '\n'
  132. // if translatenewline is true.
  133.  
  134. int SerialPort::Receive(char& ch, float secs)
  135. {
  136.     T.Set(secs);            // Set timeout timer
  137.  
  138.     while(!lastin_wascr && com->InputEmpty() && !T.TimeOut());
  139.  
  140.     if (!lastin_wascr && com->InputEmpty())
  141.         return -1;
  142.  
  143.     if(lastin_wascr)
  144.     {
  145.         ch = '\n';
  146.         lastin_wascr = false;
  147.     }
  148.     else
  149.     {
  150.         ch = char(com->GetChar());
  151.         if(translatenewline && ch == '\r')
  152.             lastin_wascr = true;
  153.     }
  154.     return 1;
  155. }
  156.  
  157. void SerialPort::Send(char ch)
  158. {
  159.     com->SendChar(ch);
  160.     if(translatenewline && ch == '\r')    
  161.         com->SendChar('\n'); 
  162. }
  163.  
  164. void SerialPort::Send(char * s) { while(*s) com->SendChar(*s++); }
  165.  
  166.  
  167. // end of file Serialpo.cpp
  168.  
  169.