deviceinfo.h

/*******************************************************************************
 * Copyright (c) 2023 Allied Vision Technologies GmbH
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *******************************************************************************/
 
#ifndef VISIONTRANSFER_DEVICEINFO_H
#define VISIONTRANSFER_DEVICEINFO_H
 
#include <string>
 
namespace visiontransfer {
 
class DeviceStatus {
public:
    DeviceStatus()
        : lastFps(0.0), jumboSize(0), currentCaptureSource(""), validStatus(false) { }
    DeviceStatus(double lastFps, unsigned int jumboSize, const std::string& currentCaptureSource)
        : lastFps(lastFps), jumboSize(jumboSize), currentCaptureSource(currentCaptureSource), validStatus(true) { }
    bool isValid() const { return validStatus; }
    double getLastFps() const { return lastFps; }
    unsigned int getJumboMtu() const { return jumboSize; }
    unsigned int getJumboFramesEnabled() const { return jumboSize > 0; }
    std::string getCurrentCaptureSource() const { return currentCaptureSource; }
private:
    double lastFps; // Most recent FPS report, or 0.0 if N/A
    unsigned int jumboSize; // Jumbo MTU, or 0 if Jumbo mode disabled
    std::string currentCaptureSource; // for targeted instructions
    bool validStatus; // whether the status record contains actual data
};
 
class DeviceInfo {
public:
    enum DeviceModel {
        SCENESCAN,
        SCENESCAN_PRO,
        SCARLET,
        RUBY
    };
 
    enum NetworkProtocol {
        PROTOCOL_TCP,
        PROTOCOL_UDP
    };
 
    DeviceInfo(): ip(""), protocol(PROTOCOL_TCP), fwVersion(""), model(SCENESCAN),
        compatible(false) {
    }
 
    DeviceInfo(const char* ip, NetworkProtocol protocol, const char* fwVersion,
         DeviceModel model, bool compatible)
        : ip(ip), protocol(protocol), fwVersion(fwVersion), model(model),
        compatible(compatible) {
    }
 
    DeviceInfo(const char* ip, NetworkProtocol protocol, const char* fwVersion,
         DeviceModel model, bool compatible, const DeviceStatus& status)
        : ip(ip), protocol(protocol), fwVersion(fwVersion), model(model),
        compatible(compatible), status(status){
    }
 
    std::string getIpAddress() const {return ip;}
 
    NetworkProtocol getNetworkProtocol() const {return protocol;}
 
    std::string getFirmwareVersion() const {return fwVersion;}
 
    DeviceModel getModel() const {return model;}
 
    DeviceStatus getStatus() const { return status; }
 
    bool isCompatible() const {return compatible;}
 
    std::string toString() const {
        std::string ret = ip +  "; ";
        switch(model) {
            case SCENESCAN_PRO: ret += "SceneScan Pro"; break;
            case SCENESCAN: ret += "SceneScan"; break;
            case SCARLET: ret += "Scarlet"; break;
            case RUBY: ret += "Ruby"; break;
            default: ret += "Unknown"; break;
        }
 
        ret += "; " + fwVersion + "; " + (compatible ? "compatible" : "incompatible");
        return ret;
    }
 
    bool operator == (const DeviceInfo& other) const {
        return ip == other.ip && protocol == other.protocol && fwVersion == other.fwVersion
            && model == other.model && compatible == other.compatible;
    }
 
private:
    std::string ip;
    NetworkProtocol protocol;
    std::string fwVersion;
    DeviceModel model;
    bool compatible;
    // Extended device status / health info
    DeviceStatus status;
};
 
} // namespace
 
#endif