WeArtMessages.h

Go to the documentation of this file.

 
#pragma once
 
#include "WeArtCommon.h"
#include <string>
#include <vector>
#include <cassert>
#include <map>
#include "nlohmann/json.hpp"
 
// Utility Methods, called to serialize/deserialize types
HandSide StringToHandside(std::string& str);
 
std::string HandsideToString(HandSide hs);
 
std::string CalibrationHandSideToString(HandSide hs);
 
HandSide StringToCalibrationHandSide(std::string& str);
 
ActuationPoint StringToActuationPoint(std::string& str);
 
std::string ActuationPointToString(ActuationPoint ap);
 
TrackingType StringToTrackingType(const std::string& str);
 
std::string TrackingTypeToString(TrackingType trackType);
 
std::string MiddlewareStatusToString(MiddlewareStatus status);
 
class WeArtMessage {
public:
    virtual std::string getID() = 0;
    
    virtual void setHandSide(HandSide hs) = 0;
 
    virtual void setActuationPoint(ActuationPoint ap) = 0;
 
    virtual std::string serialize() = 0;
    virtual void deserialize(std::string message) = 0;
};
 
class WeArtCsvMessage : public WeArtMessage {
public:
    const char field_separator = ':';
 
    virtual std::vector<std::string> getValues() = 0;
    virtual void setValues(std::vector<std::string>& values) = 0;
 
    virtual std::string serialize() override;
    virtual void deserialize(std::string message) override;
};
 
class WeArtJsonMessage : public WeArtMessage {
public:
    WeArtJsonMessage();
 
    virtual std::string serialize() override;
    virtual void deserialize(std::string message) override;
    std::uint64_t timestamp() { return _timestamp; }
 
    virtual void setHandSide(HandSide hs) override {};
    virtual void setActuationPoint(ActuationPoint ap) override {};
 
protected:
    virtual nlohmann::json serializePayload() { return nlohmann::json(); }
    virtual void deserializePayload(nlohmann::json payload) {}
    std::uint64_t _timestamp;
};
 
 
class WeArtMessageNoParams : public WeArtCsvMessage {
public:
    virtual void setHandSide(HandSide hs) override {};
    virtual void setActuationPoint(ActuationPoint ap) override {};
 
    // This message carries no values.
    virtual std::vector<std::string> getValues() override {
        return std::vector<std::string>();
    };
    virtual void setValues(std::vector<std::string>& values) override {};
};
 
class WeArtMessageHandSpecific : public WeArtCsvMessage {
public:
    HandSide getHand() {
        return handSide;
    }
protected:
    HandSide handSide;
public:
    virtual void setHandSide(HandSide hs) override {
        handSide = hs;
    };
    virtual void setActuationPoint(ActuationPoint ap) override {};
};
 
class WeArtMessageObjectSpecific : public WeArtCsvMessage {
public:
    HandSide getHand() {
        return handSide;
    }
 
    virtual void setHandSide(HandSide hs) override {
        handSide = hs;
    };
 
    ActuationPoint getActuationPoint() {
        return actuationPoint;
    }
 
    virtual void setActuationPoint(ActuationPoint ap) override {
        actuationPoint = ap;
    };
 
 
protected:
    HandSide handSide;
    ActuationPoint actuationPoint;
};
 
 
class StartFromClientMessage : public WeArtMessageNoParams {
public:
    static constexpr const char* ID = "StartFromClient";
 
    StartFromClientMessage(TrackingType trackType = TrackingType::WEART_HAND) : _trackType(trackType) {}
 
    virtual std::string getID() override {
        return ID;
    };
 
    virtual std::vector<std::string> getValues() override;
    virtual void setValues(std::vector<std::string>& values) override;
private:
    TrackingType _trackType;
};
 
class StopFromClientMessage : public WeArtMessageNoParams {
public:
    static constexpr const char* ID = "StopFromClient";
 
    virtual std::string getID() override {
        return ID;
    };
};
 
class StartCalibrationMessage : public WeArtMessageNoParams {
public:
    static constexpr const char* ID = "StartCalibration";
 
    virtual std::string getID() override {
        return ID;
    }
};
 
class StopCalibrationMessage : public WeArtMessageNoParams {
public:
    static constexpr const char* ID = "StopCalibration";
 
    virtual std::string getID() override {
        return ID;
    }
};
 
class CalibrationStatusMessage : public WeArtMessageHandSpecific {
public:
    static constexpr const char* ID = "CalibrationStatus";
 
    virtual std::string getID() override {
        return ID;
    }
 
    CalibrationStatus getStatus() {
        return status;
    }
 
    virtual std::vector<std::string> getValues() override;
 
    virtual void setValues(std::vector<std::string>& values) override;
 
protected:
    CalibrationStatus status;
};
 
class CalibrationResultMessage : public WeArtMessageHandSpecific {
public:
    static constexpr const char* ID = "CalibrationResult";
 
    virtual std::string getID() override {
        return ID;
    }
 
    bool getSuccess() {
        return success;
    }
 
    virtual std::vector<std::string> getValues() override;
 
    virtual void setValues(std::vector<std::string>& values) override;
 
protected:
    bool success;
};
 
class ExitMessage : public WeArtMessageNoParams {
public:
    static constexpr const char* ID = "exit";
 
    virtual std::string getID() override {
        return std::string("exit");
    };
};
 
class DisconnectMessage : public WeArtMessageNoParams {
public:
    static constexpr const char* ID = "disconnect";
 
    virtual std::string getID() override {
        return ID;
    };
};
 
class SetTemperatureMessage : public WeArtMessageObjectSpecific {
public:
    static constexpr const char* ID = "temperature";
 
    SetTemperatureMessage(const float t) : temperature(t) {};
    SetTemperatureMessage() {};
    virtual std::string getID() override {
        return ID;
    };
 
    virtual std::vector<std::string> getValues() override;
 
    virtual void setValues(std::vector<std::string>& values) override;
 
protected:
    float temperature;
};
 
class StopTemperatureMessage : public WeArtMessageObjectSpecific {
public:
    static constexpr const char* ID = "stopTemperature";
 
    virtual std::string getID() override {
        return ID;
    };
 
    virtual std::vector<std::string> getValues() override;
 
    virtual void setValues(std::vector<std::string>& values) override;
};
 
class SetForceMessage : public WeArtMessageObjectSpecific {
public:
    static constexpr const char* ID = "force";
 
    SetForceMessage(const float f[3]) : force{ f[0], f[1], f[2] } {};
    SetForceMessage() {};
    virtual std::string getID() override {
        return ID;
    };
 
    virtual std::vector<std::string> getValues() override;
 
    virtual void setValues(std::vector<std::string>& values) override;
 
protected:
    float force[3];
};
 
class StopForceMessage : public WeArtMessageObjectSpecific {
public:
    static constexpr const char* ID = "stopForce";
 
    virtual std::string getID() override {
        return ID;
    };
 
    virtual std::vector<std::string> getValues() override;
 
    virtual void setValues(std::vector<std::string>& values) override;
};
 
class SetTextureMessage : public WeArtMessageObjectSpecific {
public:
    static constexpr const char* ID = "texture";
 
    SetTextureMessage(const int idx, const float vel, const float vol) : index(idx), velocity{ 0.5f, 0.0f, vel }, volume(vol) {};
    SetTextureMessage() {};
    virtual std::string getID() override {
        return ID;
    };
 
    virtual std::vector<std::string> getValues() override;
 
    virtual void setValues(std::vector<std::string>& values) override;
 
protected:
    int index;
    float velocity[3] = { 0.5f, 0.0f, 0.0f };
    float volume;
};
 
class StopTextureMessage : public WeArtMessageObjectSpecific {
public:
    static constexpr const char* ID = "stopTexture";
 
    virtual std::string getID() override {
        return ID;
    };
 
    virtual std::vector<std::string> getValues() override;
 
    virtual void setValues(std::vector<std::string>& values) override;
};
 
class TrackingMessage : public WeArtMessageNoParams {
public:
    static constexpr const char* ID = "Tracking";
 
    virtual std::string getID() override {
        return std::string(ID);
    };
 
    struct Angles {
        float X;
        float Y;
        float Z;
    };
 
    virtual std::vector<std::string> getValues() override;
 
    virtual void setValues(std::vector<std::string>& values) override;
 
    TrackingType GetType() {
        return _trackingType;
    }
 
    float GetAbduction(HandSide handSide, ActuationPoint actuationPoint);
 
    float GetClosure(HandSide handSide, ActuationPoint actuationPoint);
private:
    TrackingType _trackingType;
 
    // Closures
    uint8 RightThumbClosure;
    uint8 RightIndexClosure;
    uint8 RightMiddleClosure;
    uint8 RightPalmClosure;
    uint8 LeftThumbClosure;
    uint8 LeftIndexClosure;
    uint8 LeftMiddleClosure;
    uint8 LeftPalmClosure;
 
    // Abductions
    uint8 RightThumbAbduction;
    uint8 LeftThumbAbduction;
};
 
class RawDataOn : public WeArtJsonMessage {
public:
    static constexpr const char* ID = "RAW_DATA_ON";
 
    virtual std::string getID() override { return ID; }
    virtual void setHandSide(HandSide hs) override {}
    virtual void setActuationPoint(ActuationPoint ap) override {}
};
 
class RawDataOff : public WeArtJsonMessage {
public:
    static constexpr const char* ID = "RAW_DATA_OFF";
 
    virtual std::string getID() override { return ID; }
    virtual void setHandSide(HandSide hs) override {}
    virtual void setActuationPoint(ActuationPoint ap) override {}
};
 
class RawSensorsData : public WeArtJsonMessage {
public:
    static constexpr const char* ID = "RAW_DATA";
 
    virtual std::string getID() override { return ID; };
    virtual void setHandSide(HandSide hs) override { hand = hs; }
    virtual void setActuationPoint(ActuationPoint ap) override {}
 
    HandSide getHand() { return hand; }
    bool hasSensor(ActuationPoint ap);
    SensorData getSensor(ActuationPoint ap);
 
protected:
    virtual nlohmann::json serializePayload() override;
    virtual void deserializePayload(nlohmann::json payload) override;
 
    HandSide hand;
    std::map<ActuationPoint, SensorData> sensors;
 
};
 
class AnalogSensorsData : public WeArtJsonMessage {
public:
    static constexpr const char* ID = "RAW_SENSOR_ON_MASK";
 
    virtual std::string getID() override { return ID; };
    virtual void setHandSide(HandSide hs) override { hand = hs; }
    virtual void setActuationPoint(ActuationPoint ap) override {}
 
    HandSide getHand() { return hand; }
    bool hasSensor(ActuationPoint ap);
    AnalogSensorRawData getSensor(ActuationPoint ap);
 
protected:
    virtual nlohmann::json serializePayload() override;
    virtual void deserializePayload(nlohmann::json payload) override;
 
    HandSide hand;
    std::map<ActuationPoint, AnalogSensorRawData> sensors;
};
 
class GetMiddlewareStatus : public WeArtJsonMessage {
public:
    GetMiddlewareStatus() : WeArtJsonMessage() {}
 
    static constexpr const char* ID = "MW_GET_STATUS";
    virtual std::string getID() override { return ID; };
};
 
class MiddlewareStatusMessage : public WeArtJsonMessage {
public:
    MiddlewareStatusMessage() : WeArtJsonMessage() {}
 
    static constexpr const char* ID = "MW_STATUS";
    virtual std::string getID() override { return ID; };
 
    MiddlewareStatusData data() { return _data; }
 
protected:
    virtual nlohmann::json serializePayload() override;
    virtual void deserializePayload(nlohmann::json payload) override;
 
private:
    MiddlewareStatusData _data; 
};
 
class GetDevicesStatusMessage : public WeArtJsonMessage {
public:
    GetDevicesStatusMessage() : WeArtJsonMessage() {}
    static constexpr const char* ID = "DEVICES_GET_STATUS";
    virtual std::string getID() override { return ID; };
};
 
class DevicesStatusMessage : public WeArtJsonMessage {
public:
    DevicesStatusMessage() : WeArtJsonMessage() {}
 
    static constexpr const char* ID = "DEVICES_STATUS";
    virtual std::string getID() override { return ID; };
 
    std::vector<ConnectedDeviceStatus> devices() { return _devices; }
 
protected:
    virtual nlohmann::json serializePayload() override;
    virtual void deserializePayload(nlohmann::json payload) override;
 
private:
    std::vector<ConnectedDeviceStatus> _devices;
};