port.h

/***************************************************************************
 *   Copyright (C) 2005 by David Saxton                                    *
 *   david@bluehaze.org                                                    *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/

#ifndef PORT_H
#define PORT_H

#include <qstringlist.h>

#include <termios.h>

class Port
{
        public:
                enum ProbeResult
                {
                        ExistsAndRW             = 1 << 0,
                        ExistsButNotRW  = 1 << 1,
                        DoesntExist             = 1 << 2
                };
                
                Port();
                virtual ~Port();
                
                static QStringList ports( unsigned probeResult );
};


class SerialPort : public Port
{
        public:
                enum Pin
                {
                        CD              = 1, // Carrier detect
                        RD              = 2, // Recieved data
                        TD              = 3, // Transmitted data
                        DTR             = 4, // Data terminal ready
                        GND             = 5, // Signal ground
                        DSR             = 6, // Data set ready
                        RTS             = 7, // Request to send
                        CTS             = 8, // Clear to send
                        RI              = 9, // Ring indicator
                };
                
                SerialPort();
                ~SerialPort();
                
                void setPinState( Pin pin, bool state );
                bool pinState( Pin pin );
                
                static ProbeResult probe( const QString & port );
                static QStringList ports( unsigned probeResult );
                bool openPort( const QString & port, speed_t baudRate );
                void closePort();
                
        protected:
                termios m_previousState;
                
                int m_file;
};


class ParallelPort : public Port
{
        public:
                enum Pin
                {
                        // Data Register
                        //   Offset: Base + 0
                        //   Readable / writable
                        PIN02 = 1 << 0,         // Data 0
                        PIN03 = 1 << 1,         // Data 1
                        PIN04 = 1 << 2,         // Data 2
                        PIN05 = 1 << 3,         // Data 3
                        PIN06 = 1 << 4,         // Data 4
                        PIN07 = 1 << 5,         // Data 5
                        PIN08 = 1 << 6,         // Data 6
                        PIN09 = 1 << 7,         // Data 7
                        DATA_PINS = PIN02 | PIN03 | PIN04 | PIN05 | PIN06
                                         | PIN07 | PIN08 | PIN09,
                        
                        // Status Register
                        //   Offset: Base + 1
                        //   Read only
                        PIN15 = 1 << 11,        // Error
                        PIN13 = 1 << 12,        // Online
                        PIN12 = 1 << 13,        // Paper End
                        PIN10 = 1 << 14,        // Ack
                        PIN11 = 1 << 15,        // Busy
                        STATUS_PINS = PIN15 | PIN13 | PIN12 | PIN10 | PIN11,
                        
                        // Control Register
                        //   Offset: Base + 2
                        //   Readable / writable
                        PIN01 = 1 << 16,        // Strobe
                        PIN14 = 1 << 17,        // Auto Feed
                        PIN16 = 1 << 18,        // Init
                        PIN17 = 1 << 19,        // Select
                        CONTROL_PINS = PIN01 | PIN14 | PIN16 | PIN17,
                        
                        
                        // Pins 18 to 25 are ground
                };
                
                enum Register
                {
                        Data    = 0,
                        Status  = 1,
                        Control = 2,
                };
                
                enum Direction
                {
                        Input = 0,
                        Output = 1,
                };
                
                ParallelPort();
                ~ParallelPort();
                
                bool openPort( const QString & port );
                void closePort();
                
                //BEGIN Pin-oriented operations
                void setPinState( int pins, bool state );
                int pinState( int pins );
                void setDataState( uchar pins, bool state );
                void setControlState( uchar pins, bool state );
                //END Pin-oriented operations
                
                
                //BEGIN Register-oriented operations
                uchar readFromRegister( Register reg );
                void writeToData( uchar value );
                void writeToControl( uchar value );
                //END Register-oriented operations
                
                
                //BEGIN Changing pin directions
                void setDataDirection( Direction dir );
                void setControlDirection( int pins, Direction dir );
                //END Changing pin directions
                
                static ProbeResult probe( const QString & port );
                static QStringList ports( unsigned probeResult );
                
        protected:
                void writeToRegister( Register reg, uchar value );
                void reset();
                
                uchar m_reg[3];
                
                int m_inputPins;
                
                int m_outputPins;
                
                int m_file;
};

#endif

---