serialport.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// External Includes
#include <nap/device.h>
#include <string.h>
#include <nap/numeric.h>
#include <nap/signalslot.h>
 
// Forward declares
namespace serial
{
    class Serial;
}
 
namespace nap
{
    enum class ESerialByteSize : int
    {
        Five            = 5,
        Six             = 6,
        Seven           = 7,
        Eight           = 8
    };
 
    enum class ESerialStopBits : int
    {
        One             = 1,
        Two             = 2,
        OnePointFive    = 3
    };
 
    enum class ESerialFlowControl : int
    {
        None            = 0,
        Software        = 1,
        Hardware        = 2
    };
 
    enum class ESerialParity : int
    {
        None            = 0,
        Odd             = 1,
        Even            = 2,
        Mark            = 3,
        Space           = 4
    };
 
 
    class NAPAPI SerialPort : public Device
    {
        RTTI_ENABLE(Device)
    public:
 
        struct Error
        {
            enum class EType : int
            {
                NoError = 0,                
                IOError = 1,                
                SerialError = 2,            
                PortError = 3               
            };
 
            bool failed()                               { return mType != EType::NoError; }
 
            const std::string& getMessage()             { return mMessage; }
 
            EType getType()                             { return mType; }
 
            void clear();
 
            EType mType = EType::NoError;               
            std::string mMessage = "";                  
        };
 
        SerialPort();
 
        // Stops the device
        virtual ~SerialPort();
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual bool start(utility::ErrorState& errorState) override;
 
        virtual void stop() override;
 
        bool isOpen() const;
 
        uint32 read(std::vector<uint8>& buffer, uint32 count, SerialPort::Error& error);
 
        uint32 read(std::vector<uint8>& buffer, SerialPort::Error& error);
 
        uint32 read(uint8* buffer, uint32 count, SerialPort::Error& error);
 
        uint32 read(std:: string& buffer, uint32 count, SerialPort::Error& error);
 
        std::string read(uint32 count, SerialPort::Error& error);
 
        uint32 readLine(std::string& buffer, uint32 length, const std::string& eol, SerialPort::Error& error);
 
        std::string readLine(uint32 length, const std::string& eol, SerialPort::Error& error);
 
        std::vector<std::string> readLines(uint32 length, const std::string& eol, SerialPort::Error& error);
 
        uint32 write(const uint8* data, uint32 count, SerialPort::Error& error);
 
        uint32 write(const std::vector<uint8>& data, SerialPort::Error& error);
 
        uint32 write(const std::string& data, SerialPort::Error& error);
 
        uint32 available();
 
        bool waitReadable();
 
        /* Block for a period of time corresponding to the transmission time of the
         * number of characters based on the present serial settings. This may be used in con-
         * junction with waitReadable to read larger blocks of data from the port.
         * @param count number of cycles to wait
         */
        void waitByteTimes(uint32 count);
 
        void flush();
 
        void flushInput();
 
        void flushOutput();
 
        void sendBreak(uint32 duration);
 
        bool waitForChange();
 
        void setBreak(bool level = true);
 
        void setRTS(bool level = true);
 
        void setDTR(bool level = true);
 
        bool getCTS();
 
        bool getDSR();
 
        bool getRI();
 
        bool getCD();
 
        Signal<SerialPort*> destructed;
 
        std::string mPortName = "COM1";                                 
        int mBaudRate = 9600;                                           
        ESerialByteSize mByteSize = ESerialByteSize::Eight;             
        ESerialFlowControl mFlowControl = ESerialFlowControl::None;     
        ESerialParity mParity = ESerialParity::None;                    
        ESerialStopBits mStopBits = ESerialStopBits::One;               
        int mReadTimeout  = 0;                                          
        int mWriteTimeout = 0;                                          
        int mInterByteTimeout = 0;                                      
        bool mAllowFailure = false;                                     
    private:
        std::unique_ptr<serial::Serial> mSerialPort;
        
    };
}