HardwareAdapterSerialPort.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include <QtSerialPort/QSerialPort>
#include <QtSerialPort/QSerialPortInfo>
 
#include "stdafx.h"
#include "HardwareAdapter.h"
 
namespace DynExp
{
    class HardwareAdapterSerialPort;
 
    class SerialPortException : public SerialCommunicationException
    {
    public:
        SerialPortException(std::string Description, const int ErrorCode,
            const std::source_location Location = std::source_location::current()) noexcept
            : SerialCommunicationException(std::move(Description), ErrorCode, Location)
        {}
    };
 
    class HardwareAdapterSerialPortParams : public QSerialCommunicationHardwareAdapterParams
    {
    public:
        HardwareAdapterSerialPortParams(ItemIDType ID, const DynExpCore& Core) : QSerialCommunicationHardwareAdapterParams(ID, Core) {}
 
        virtual ~HardwareAdapterSerialPortParams() = default;
 
        virtual const char* GetParamClassTag() const noexcept override { return "HardwareAdapterSerialPortParams"; }
 
        Param<TextList> PortName = { *this, {}, "PortName", "Port",
            "Name of the serial port to be assigned to this hardware adapter" };            
        Param<QSerialPort::BaudRate> BaudRate = { *this, Util::QtEnumToTextValueList<QSerialPort::BaudRate>(0, 0, 4), "BaudRate", "Baud rate",
            "Data rate in bits per second", true, QSerialPort::Baud9600 };                  
        Param<QSerialPort::DataBits> DataBits = { *this, Util::QtEnumToTextValueList<QSerialPort::DataBits>(0, 0, 4), "DataBits", "Data bits",
            "Number of data bits in each character", true, QSerialPort::Data8 };            
        Param<QSerialPort::StopBits> StopBits = { *this, Util::QtEnumToTextValueList<QSerialPort::StopBits>(0, 0, 0, 4), "StopBits", "Stop bits",
            "Number of stop bits after each character", true, QSerialPort::OneStop };       
        Param<QSerialPort::Parity> Parity = { *this, Util::QtEnumToTextValueList<QSerialPort::Parity>(0, 0, 0, 6), "Parity", "Parity",
            "Error detection method", true, QSerialPort::NoParity };                        
 
    private:
        void ConfigureParamsImpl(dispatch_tag<QSerialCommunicationHardwareAdapterParams>) override final;
 
        virtual void ConfigureParamsImpl(dispatch_tag<HardwareAdapterSerialPortParams>) {}  
    };
 
    class HardwareAdapterSerialPortConfigurator : public QSerialCommunicationHardwareAdapterConfigurator
    {
    public:
        using ObjectType = HardwareAdapterSerialPort;
        using ParamsType = HardwareAdapterSerialPortParams;
 
        HardwareAdapterSerialPortConfigurator() = default;
        virtual ~HardwareAdapterSerialPortConfigurator() = default;
 
    private:
        virtual DynExp::ParamsBasePtrType MakeParams(ItemIDType ID, const DynExpCore& Core) const override { return DynExp::MakeParams<HardwareAdapterSerialPortConfigurator>(ID, Core); }
    };
 
    class HardwareAdapterSerialPortWorker : public QSerialCommunicationHardwareAdapterWorker
    {
        Q_OBJECT
 
    public:
        HardwareAdapterSerialPortWorker();
        virtual ~HardwareAdapterSerialPortWorker() {}
 
    public slots:
        void Init(QString PortName, QSerialPort::BaudRate BaudRate, QSerialPort::DataBits DataBits,
            QSerialPort::StopBits StopBits, QSerialPort::Parity Parity);
 
    private slots:
        void OnDataAvailable();             
 
    private:
        bool CheckError(const std::source_location Location = std::source_location::current()) const;
 
        virtual void OpenChild() override;
        virtual void CloseChild() override;
        virtual void ResetChild() override;
        virtual void ClearChild() override;
        virtual void FlushChild() override;
        virtual void ReadChild() override;
        virtual void WriteChild(const QString& String) override;
        virtual void Write_endl_Child() override;
 
        QSerialPort Port;                   
    };
 
    class HardwareAdapterSerialPort : public QSerialCommunicationHardwareAdapter
    {
        Q_OBJECT
 
    public:
        using ParamsType = HardwareAdapterSerialPortParams;                                             
        using ConfigType = HardwareAdapterSerialPortConfigurator;                                       
 
        constexpr static auto Name() noexcept { return "Serial Port"; }                                 
 
        static auto Enumerate();
 
        HardwareAdapterSerialPort(const std::thread::id OwnerThreadID, ParamsBasePtrType&& Params);     
        virtual ~HardwareAdapterSerialPort() = default;
 
        virtual std::string GetName() const override { return Name(); }
 
    private:
        QWorkerPtrType MakeWorker() override;
        void InitWorker() override { Init(); }
 
        void RegisterQTypesAsMetaTypes();
 
        void Init();                                                                                    
 
        void ResetImpl(dispatch_tag<QSerialCommunicationHardwareAdapter>) override final;
        virtual void ResetImpl(dispatch_tag<HardwareAdapterSerialPort>) {}                              
 
    signals:
 
        void InitSig(QString PortName, QSerialPort::BaudRate BaudRate, QSerialPort::DataBits DataBits,
            QSerialPort::StopBits StopBits, QSerialPort::Parity Parity);
    };
}