home *** CD-ROM | disk | FTP | other *** search
/ Aminet 10 / aminetcdnumber101996.iso / Aminet / dev / src / SerialClass1_0.lha / SerialClass.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-11  |  9.1 KB  |  414 lines
  1. #include "SerialClass.h"
  2. #ifndef DEBUG
  3. #define DEBUG
  4. #endif
  5.  
  6. //    Paul Cimino 1995
  7. //    C++ Class to make basic Amiga serial port access a little easier
  8. //    This code is being released into the public domain
  9. //    feel free to improve upon it, however I ask that you :
  10. //        1) Redistribute the improved code
  11. //        2) Fully document changes to the code :
  12. //            A) Why the changes were made
  13. //            B) Document where your code is added
  14. //            C) Don't remove my code, rather comment it out
  15. //        3) Send me a copy (cimino@mdso.vf.ge.com or if that
  16. //            mail id goes away, 73677,1761@compuserve.com )
  17. //
  18. //     It would be great if someone familiar with Asynchronous
  19. //    Transfer Mode (ATM) and other useful protocals could
  20. //     expand this into a truly useful Class
  21. //
  22. //    Thanks go to J. Edward Hanway for his OptMouse ver 1.2 code
  23. //
  24. //
  25. //
  26. SerialClass::SerialClass(char *device, char *portN, int unit, int Baud, int Bits,
  27.     int Stop, Parity Par, HandShake Hand, int HighSpeed, int Share)
  28. {
  29.         // set OPEN status
  30.         isOpen = 0;
  31.         
  32.     // assign the device name
  33.     deviceName = new char [strlen(device)+1];
  34.     strcpy(deviceName, device);
  35.  
  36.     // Default Unit number
  37.     unitNum = unit;
  38.  
  39.     // assign the port name
  40.     if (portN == 0) {
  41.         portName = new char [strlen(deviceName)+5];// just in case the unit 
  42.             // number is ridiculously huge
  43.         sprintf(portName, "%s%d\0", deviceName, unitNum);
  44.     } else {
  45.         portName = new char [strlen(portN)+1];
  46.         strcpy(portName, portN);
  47.     }
  48.  
  49.     // Open the port
  50.     if (!open()) 
  51.     {
  52.         cerr << "Sorry, problem openning the port" << endl;
  53.         cerr << "Port in use ? " << endl;
  54.         cerr << "Here's a good place in the code to add throws\n";
  55.         cerr << "and catches for exception handling !" << endl;
  56.         exit(0);
  57.     } else {
  58. #ifdef DEBUG
  59.         cout << "Default port successfully opened as : ";
  60.         cout << deviceName << " Unit : " << unitNum << endl;
  61. #endif
  62.     }
  63.         
  64.     // set the parameters after openning the port
  65.     setBaud(Baud);
  66.     setBits(Bits);
  67.     setStop(Stop);
  68.     setParity(Par);
  69.     setHand(Hand);
  70.     setHighSpeed(HighSpeed);
  71.     setShare(Share);
  72.  
  73.  
  74. }
  75.  
  76. SerialClass::~SerialClass()
  77. {
  78.     // close the device
  79.     if (isOpen) close();
  80.  
  81.     // Reclaim the device name memory
  82.     if (deviceName) delete [] deviceName;
  83.         
  84.         if (portName) delete [] portName;
  85.     if (deviceName) delete [] deviceName;
  86.     if (port) delete port;
  87.     if (iob) delete iob;
  88.         
  89. }
  90.  
  91.  
  92. int
  93. SerialClass::open(void)
  94. { 
  95.     port = CreatePort(portName, 0);
  96.     if (port) {
  97.         iob = CreateExtIO(port, sizeof(struct IOExtSer));
  98.         if (iob) {
  99.             isOpen = !OpenDevice((unsigned char *)deviceName, 
  100.                                 (unsigned long)unitNum, 
  101.                                 iob, 
  102.                                 (unsigned long)0L);
  103.         }
  104.         
  105.     }
  106.         
  107.     iob_ser = (struct IOExtSer *)iob;
  108.  
  109.     return isOpen;
  110. }
  111.     
  112. void
  113. SerialClass::close(void)
  114. {
  115.         if(isOpen == TRUE) {
  116.         AbortIO(iob);
  117.         CloseDevice(iob);
  118.         isOpen = FALSE;
  119.     }
  120.     if(iob) {
  121.         DeleteExtIO(iob);
  122.         iob = NULL;
  123.     }
  124.     if(port) {
  125.         DeletePort(port);
  126.         port = NULL;
  127.     }   
  128. }
  129.  
  130. void
  131. SerialClass::mDoIO(struct IORequest *iob) 
  132. {
  133. // took this function from "OptMouse", because I don't 
  134. // yet understand IO stuff or pragma calls
  135.  
  136.     register LONGBITS signals, sigbit;
  137.     
  138. #pragma libcalliob->io_Device BeginIO 1e 901
  139.     
  140.     if (isOpen) {
  141.       iob->io_Flags |= IOF_QUICK;
  142.       BeginIO(iob);
  143.       if(!(iob->io_Flags & IOF_QUICK)) {
  144.           sigbit = 1L << iob->io_Message.mn_ReplyPort->mp_SigBit;
  145.           signals = Wait(sigbit | SIGBREAKF_CTRL_C);
  146.         
  147.           if(signals & sigbit) {
  148.                   GetMsg(iob->io_Message.mn_ReplyPort);
  149.           }
  150.         
  151.           if (signals & SIGBREAKF_CTRL_C) {
  152.               close();
  153.               cerr << "Problem in mDoIO, SIGBREAKF_CTRL_C encountered";
  154.               cerr << "\nClosing port" << endl;
  155.           }
  156.       }
  157.    }  
  158. }
  159.     
  160.  
  161. int
  162. SerialClass::setBaud(int BAUD) 
  163. {
  164.     IOB_SER->io_Baud = BAUD;
  165.         setParams();
  166.         
  167.     return BAUD;
  168. }
  169.  
  170. int
  171. SerialClass::setBits(int BITS) 
  172. {
  173.     IOB_SER->io_ReadLen = (unsigned char)BITS;
  174.         IOB_SER->io_WriteLen = (unsigned char)BITS;
  175.         setParams();
  176.         
  177.     return BITS;
  178. }
  179.  
  180. int
  181. SerialClass::setStop(int BITS) 
  182. {
  183.     IOB_SER->io_StopBits = (unsigned char)BITS;
  184.         setParams();
  185.         
  186.     return BITS;
  187. }
  188.  
  189. Parity
  190. SerialClass::setParity(Parity par) 
  191. {
  192.  
  193.     // first, clear the affected bits
  194.     IOB_SER->io_SerFlags &= ~(SERF_PARTY_ON|SERF_PARTY_ODD);
  195.     IOB_SER->io_ExtFlags &= ~(SEXTF_MSPON|SEXTF_MARK);
  196.  
  197.     switch (par) {
  198.                 case NONE : // do nothing;
  199.                         break;
  200.         case EVEN : IOB_SER->io_SerFlags |= SERF_PARTY_ON;
  201.             break;
  202.         case ODD : IOB_SER->io_SerFlags |= SERF_PARTY_ON|SERF_PARTY_ODD;
  203.             break;
  204.         case MARK : IOB_SER->io_SerFlags |= SERF_PARTY_ON;
  205.                         IOB_SER->io_ExtFlags |= SEXTF_MSPON|SEXTF_MARK;
  206.             break;
  207.                 case SPACE : IOB_SER->io_SerFlags |= SERF_PARTY_ON;
  208.                         IOB_SER->io_ExtFlags |= SEXTF_MSPON;
  209.                         break;
  210.         default :
  211.             cerr << "Invalid Parity, should be 0, 1, 2, 3, 4" << endl;
  212.             cerr << "For NONE, EVEN, ODD, MARK, SPACE" << endl;
  213.                         cerr << " YOU used : " << (int) par << endl;
  214.     }
  215.  
  216.         setParams();
  217.         
  218.     return par;
  219. }
  220.  
  221. HandShake
  222. SerialClass::setHand(HandShake hand) 
  223. {
  224.  
  225.     // first, clear the affected bits
  226.     IOB_SER->io_SerFlags &= ~(SERF_7WIRE);
  227.  
  228.     switch (hand) {
  229.                 case NONE : // do nothing;
  230.                         break;
  231.         case RTSCTS : IOB_SER->io_SerFlags |= SERF_7WIRE;
  232.             break;
  233.         default :
  234.             cerr << "Invalid Handshaking, should be 0, 1" << endl;
  235.             cerr << "For NONE, RTSCTS" << endl;
  236.                         cerr << " YOU used : " << (int) hand << endl;
  237.     }
  238.  
  239.         setParams();
  240.         
  241.     return hand;
  242. }
  243.  
  244. int
  245. SerialClass::setHighSpeed(int FLAG) 
  246. {
  247.  
  248.     // first, clear the affected bits
  249.     IOB_SER->io_SerFlags &= ~(SERF_RAD_BOOGIE);
  250.  
  251.     switch (FLAG) {
  252.                 case FALSE : // do nothing;
  253.                         break;
  254.         case TRUE : IOB_SER->io_SerFlags |= SERF_RAD_BOOGIE;
  255.             break;
  256.         default :
  257.             cerr << "Invalid High Speed Flag, should be 0, 1" << endl;
  258.             cerr << "For FALSE, TRUE" << endl;
  259.                         cerr << " YOU used : " << FLAG << endl;
  260.     }
  261.  
  262.         setParams();
  263.     return FLAG;
  264. }
  265.  
  266. int
  267. SerialClass::setShare(int FLAG) 
  268. {
  269.  
  270.     // first, clear the affected bits
  271.     IOB_SER->io_SerFlags &= ~(SERF_SHARED);
  272.  
  273.     switch (FLAG) {
  274.                 case FALSE : // do nothing;
  275.                         break;
  276.         case TRUE : IOB_SER->io_SerFlags |= SERF_SHARED;
  277.             break;
  278.         default :
  279.             cerr << "Invalid Share Flag, should be 0, 1" << endl;
  280.             cerr << "For FALSE, TRUE" << endl;
  281.                         cerr << " YOU used : " << FLAG << endl;
  282.     }
  283.  
  284.         setParams();
  285.           return FLAG;
  286. }
  287.  
  288. void 
  289. SerialClass::setParams(void)
  290. {
  291.         // set the serial port parameters
  292.         IOB_SER->IOSer.io_Command = SDCMD_SETPARAMS;
  293.         mDoIO(iob);
  294. }
  295.  
  296. UBYTE
  297. SerialClass::readByte(void)
  298. {
  299.     UBYTE    ch = 0;
  300.  
  301.     IOB_SER->IOSer.io_Command = CMD_READ;
  302.     IOB_SER->IOSer.io_Length = 1;
  303.     IOB_SER->IOSer.io_Data = (APTR) &ch;
  304.  
  305.     // (Maybe use BeginIO ?)
  306.         // BeginIO(iob);
  307.     mDoIO(iob);
  308.         
  309.     return ch;
  310. }
  311.  
  312. UBYTE *
  313. SerialClass::read(int numBytes)
  314. {
  315.     UBYTE    *chPtr = new UBYTE[numBytes];
  316.  
  317.     IOB_SER->IOSer.io_Command = CMD_READ;
  318.     IOB_SER->IOSer.io_Length = numBytes;
  319.     IOB_SER->IOSer.io_Data = (APTR) chPtr;
  320.  
  321.     // (Maybe use BeginIO ?)
  322.     mDoIO(iob);
  323.         
  324.     return chPtr;
  325. }
  326.  
  327. // Reads text from the serial port until NULL or the termination character
  328. // is received
  329. UBYTE *
  330. SerialClass::read(char termination)
  331. {
  332.     UBYTE    ch, *newPtr, *tmpPtr;
  333.     int    i, size = 1;
  334.  
  335.     newPtr = new UBYTE [size];
  336.  
  337.     IOB_SER->IOSer.io_Command = CMD_READ;
  338.     IOB_SER->IOSer.io_Length = 1;
  339.     IOB_SER->IOSer.io_Data = (APTR) &ch;
  340.  
  341.     do {
  342.         // (Maybe use BeginIO ?)
  343.         mDoIO(iob);
  344.  
  345.         newPtr[size - 1] = ch; // save the character to the end of a string
  346.         tmpPtr = new UBYTE [size]; // allocate room to save the string
  347.         tmpPtr = newPtr;
  348.         newPtr = 0; // remove the new string
  349.         newPtr = new UBYTE [size+1]; // reallocate string with more room
  350.         for (i = 0; i < size; i++) newPtr[i] = tmpPtr[i]; // move string back
  351.         delete [] tmpPtr; // reclaim memory
  352.         size++; // increment size
  353. cout << ch << "Size is " << size << endl;    
  354.     } while (ch != termination);
  355.         
  356.     // terminate the string
  357.     newPtr[size - 1] = 0;
  358.  
  359.     return newPtr;
  360. }
  361.  
  362.  
  363. UBYTE
  364. SerialClass::writeByte(UBYTE ch)
  365. {
  366.     IOB_SER->IOSer.io_Command = CMD_WRITE;
  367.     IOB_SER->IOSer.io_Length = 1;
  368.     IOB_SER->IOSer.io_Data = (APTR) &ch;
  369.        
  370. #ifdef DEBUG
  371.         cout << "Ready to send a character" << endl;
  372. #endif
  373.     // (Maybe use BeginIO ?)
  374.     mDoIO(iob);
  375. //        cout << "Trying SendIO first " << endl;
  376. //        SendIO(iob);
  377. //        cout << "Now trying DoIO" << endl;
  378. //        DoIO(iob);
  379.         
  380. #ifdef DEBUG
  381.         cout << "Character sent" << endl;
  382. #endif
  383.     return ch;
  384. }
  385.  
  386. UBYTE *
  387. SerialClass::writeData(UBYTE *data, int size)
  388. {
  389.     int i;
  390.         
  391. #ifdef DEBUG
  392.         cout << "Data is " << (char *)data << " size is " << size << endl;
  393. #endif    
  394.         for (i = 0; i < size; i++) writeByte(data[i]);
  395.  
  396.     return data;
  397. }
  398.  
  399. char *
  400. SerialClass::write(char *data, char terminationChar)
  401. {
  402.     int i = 0;
  403.         
  404.         while (data[i] != terminationChar) writeByte(data[i++]);
  405.  
  406.     return data;
  407. }
  408.  
  409. void 
  410. SerialClass::setParameters(void) { 
  411.         IOB_SER->IOSer.io_Command = SDCMD_SETPARAMS; // get ready to set serial port parameters
  412.     mDoIO(iob); // DO IT !
  413. }
  414.