cvtdevice.h

이 파일의 문서화 페이지로 가기

#ifndef _CVT_DEVICE_
#define _CVT_DEVICE_

#include <iostream>
#include <string> 
#include <glog/logging.h>

#include "cvtcode.h"
#include "cvtdevicespec.h"
#include "cvtcommand.h"

using namespace std;

namespace stdcvt {

/*
 @brief CvtDevice 는 개별 장비를 추상화한 클래스이다.
*/
class CvtDevice {
private:
    string _id;             
    CvtDeviceSpec _devspec; 
    devstat_t _status;      

protected:
    void _copy(CvtDevice *pdevice) {
        _id = pdevice->_id;
        _devspec.copy (pdevice->getspec ());
        _status = pdevice->_status;
    }

public:

    CvtDevice(string devid, CvtDeviceSpec *pdevspec, devstat_t devstatus) {
        _id = devid;
        _devspec.copy (pdevspec);
        _status = devstatus;
    }

    CvtDevice(string devid, devtype_t devtype, 
        devsec_t section, devtarget_t target, devstat_t devstatus) 
        : _devspec(devtype, section, target) {

        _id = devid;
        _status = devstatus;
    }

    virtual ~CvtDevice() {
    }

    string getid() {
        return _id;
    }

    CvtDeviceSpec *getspec() {
        return &_devspec;
    }

    devstat_t getstatus () {
        return _status;
    }

    devstat_t setstatus (devstat_t devstatus) {
        _status = devstatus;
        return _status;
    }

    string tostring() {
        return "CvtDevice(" + _id + ") [" +  _devspec.tostring() 
            + "], status : " + std::to_string(_status);
    }
    
    virtual CvtDevice *clone() = 0;

    virtual bool copy(CvtDevice *pdevice) = 0;

    static devgroup_t getgroup(devtype_t devtype) {
        return (devgroup_t) (devtype / 10000);
    }
};

/*
 @brief CvtSensor는 CvtDevice를 상속하여, 개별 센서를 추상화한 클래스이다.
*/
class CvtSensor : public CvtDevice {
private:
    obsunit_t _unit;          
    double _value;            

public:
    CvtSensor (string devid, CvtDeviceSpec *pdevspec, 
                    devstat_t devstatus, obsunit_t unit) 
        : CvtDevice (devid, pdevspec, devstatus) {
        _unit = unit;
        _value = 0;
    }

    CvtSensor (string devid, devtype_t devtype, devsec_t section, 
        devtarget_t target, devstat_t devstatus, obsunit_t unit) 
        : CvtDevice (devid, devtype, section, target, devstatus) {
        _unit = unit;
        _value = 0;
    }

    CvtDevice *clone() {
        CvtSensor *psensor = new CvtSensor(getid(), getspec(), getstatus(), _unit);
        if (psensor) {
            psensor->writeobservation (_value);
            return (CvtDevice *)psensor;
        }
        return nullptr;
    }

    bool copy(CvtDevice *pdevice) {
        CvtSensor *psensor = dynamic_cast<CvtSensor *>(pdevice);
        if (psensor) {
            _copy (pdevice);
            _unit = psensor->_unit;
            _value = psensor->_value;
            return true;
        }
        return false;
    }

    obsunit_t getunit () {
        return _unit;
    }

    obsunit_t setunit (obsunit_t unit) {
        _unit = unit;
        return _unit;
    }

    double writeobservation (double value) {
        _value = value;
        return _value;
    }

    double readobservation () {
        return _value;
    }

    string tostring() {
        return "CvtSensor [" + CvtDevice::tostring () 
            + "] observation : " + std::to_string (_value) 
            + ", unit : " + std::to_string (_unit);
    }
};

/*
 @brief CvtActuator는 CvtDevice를 상속하여, 개별 구동기를 추상화한 클래스이다.
*/
class CvtActuator : public CvtDevice {
private:
    int _lastcmdid;     
    bool _onoff;        

protected:
    void setcommand (CvtCommand *pcmd) {
        _lastcmdid = pcmd->getid ();
    }

public:
    CvtActuator(string devid, CvtDeviceSpec *pdevspec, devstat_t devstatus) 
        : CvtDevice (devid, pdevspec, devstatus) {
        _lastcmdid = -1;
        _onoff = false; // off
    }

    CvtActuator(string devid, devtype_t devtype, 
        devsec_t section, devtarget_t target, devstat_t devstatus) 
        : CvtDevice (devid, devtype, section, target, devstatus) {
        _lastcmdid = -1;
        _onoff = false; // off
    }

    CvtDevice *clone() {
        CvtActuator *pactuator = new CvtActuator(getid(), getspec(), getstatus());
        if (pactuator) {
            pactuator->copy (this);
            return (CvtDevice *)pactuator;
        }
        return nullptr;
    }

    bool copy(CvtDevice *pdevice) {
        CvtActuator *pactuator = dynamic_cast<CvtActuator *>(pdevice);
        if (pactuator) {
            _copy (pdevice);
            _lastcmdid = pactuator->_lastcmdid;
            _onoff = pactuator->_onoff;
            return true;
        }
        return false;
    }

    int getlastcmdid () {
        return _lastcmdid;
    }

    bool turnon () {
        _onoff = true;
        return _onoff;
    }

    bool turnoff () {
        _onoff = false;
        return _onoff;
    }

    bool getonoff () {
        return _onoff;
    }

    bool order(CvtCommand *pcmd) {
        pcmd->getonoff() ? turnon() : turnoff();
        setcommand (pcmd);
        return true;
    }

    void executed(int cmdid) {
        if (cmdid >= _lastcmdid)
            _lastcmdid = 0;
    }

    string tostring() {
        return "CvtActuator [" + CvtDevice::tostring() 
            + "], lastcmdid : " + std::to_string(getlastcmdid())
            + ", onoff : " + std::to_string(getonoff());
    }
};

/*
 @brief CvtMotor는 CvtActuator를 상속하여, 개별 모터형 구동기를 추상화한 클래스이다.
*/
class CvtMotor : public CvtActuator {
private:
    double _current;      
    double _target;       

public:
    CvtMotor (string devid, CvtDeviceSpec *pdevspec, devstat_t devstatus) 
        : CvtActuator (devid, pdevspec, devstatus) {
        _current = 0;
        _target = 0;
    }

    CvtMotor (string devid, devtype_t devtype, 
        devsec_t section, devtarget_t target, devstat_t devstatus) 
        : CvtActuator (devid, devtype, section, target, devstatus) {
        _current = 0;
        _target = 0;
    }

    CvtDevice *clone() {
        CvtMotor *pmotor = new CvtMotor(getid(), getspec(), getstatus());
        if (pmotor) {
            pmotor->copy (this);
            return (CvtDevice *)pmotor;
        }
        return nullptr;
    }

    bool copy(CvtDevice *pdevice) {
        CvtMotor *pmotor = dynamic_cast<CvtMotor *>(pdevice);
        if (pmotor) {
            pmotor->CvtActuator::copy(pdevice);
            _current = pmotor->_current;
            _target = pmotor->_target;
            return true;
        }
        return false;
    }

    double settarget(double ratio) {
        _target= ratio;
        return _target;
    }

    double gettarget() {
        return _target;
    }

    double setcurrent(double ratio) {
        _current = ratio;
        return _current;
    }

    double getcurrent() {
        return _current;
    }

    string tostring() {
        return "CvtMotor [" + CvtDevice::tostring() 
            + "], lastcmdid : " + std::to_string(getlastcmdid())
            + "], current : " + std::to_string(_current)
            + ", onoff : " + std::to_string(getonoff())
            + ", target : " + std::to_string(_target);
    }

    bool order(CvtCommand *pcmd) {
        CvtRatioCommand *prcmd = dynamic_cast<CvtRatioCommand *>(pcmd);
        if (prcmd == nullptr) {
            return false;
        }

        if (prcmd->getonoff()) {
            // on
            settarget (prcmd->getratio ());
            turnon ();
        } else {
            // off
            turnoff ();
        }
        setcommand (pcmd);
        return true;
    }
};

} // namespace stdcvt
#endif