Units.hpp

/*
 * Copyright (C) 2021 CERN
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 *
 * Created on: 2021-11-23
 *     Author: Michal Mysior <mmysior> <michal.mysior@cern.ch>
 *
 */
 
#ifndef MOTION_CONTROLLER_UNITS_HPP__
#define MOTION_CONTROLLER_UNITS_HPP__
 
#include <chrono>
#include <cstdint>
#include <iterator>
#include <set>
#include <string>
 
#include "util/serialize.hpp"
 
namespace smc {
namespace units {
 
enum Unit
{
    UNKNOWN,
    MILLIMETERS,
    METERS,
    STEPS,
    DEGREES,
    RADIANS,
    TURNS,
    STEPS_PER_TURN,
    MILLIMETERS_PER_MINUTE,
    METERS_PER_SECOND,
    STEPS_PER_MILLIMETER,
    MILLIMETERS_PER_SECOND,
    MILLIMETERS_PER_SECOND_SQUARED,
 
    unknown = UNKNOWN,
    millimeters = MILLIMETERS,
    meters = METERS,
    steps = STEPS,
    degrees = DEGREES,
    radians = RADIANS,
    turns = TURNS,
    steps_per_turn = STEPS_PER_TURN,
    millimeters_per_minute = MILLIMETERS_PER_MINUTE,
    meters_per_second = METERS_PER_SECOND,
    steps_per_millimeter = STEPS_PER_MILLIMETER,
    millimeters_per_second = MILLIMETERS_PER_SECOND,
    millimeters_per_second_squared = MILLIMETERS_PER_SECOND_SQUARED,
 
    mm = MILLIMETERS,
    m = METERS,
    deg = DEGREES,
    rad = RADIANS,
    mm_per_min = MILLIMETERS_PER_MINUTE,
    m_per_s = METERS_PER_SECOND,
    steps_per_mm = STEPS_PER_MILLIMETER,
    mm_per_s = MILLIMETERS_PER_SECOND,
    mm_per_s2 = MILLIMETERS_PER_SECOND_SQUARED
};
 
typedef Unit unit_t;
 
struct Value
{
    typedef double value_type;
    unit_t unit;
    value_type value;
 
    Value();
    Value(unit_t unit, value_type value);
 
    bool canConvert(unit_t unit) const;
    bool convert(unit_t unit);
 
    Value &operator+=(value_type raw);
    Value &operator-=(value_type raw);
    Value &operator*=(value_type raw);
    Value &operator/=(value_type raw);
 
    std::string toString(void) const;
 
protected:
    bool checkConvert(value_type &converted, unit_t unit) const;
};
typedef Value value_t;
 
Value operator*(double raw, unit_t unit);
 
Value operator"" _mm(long double raw);
Value operator"" _m(long double raw);
Value operator"" _steps(long double raw);
Value operator"" _deg(long double raw);
Value operator"" _rad(long double raw);
Value operator"" _turns(long double raw);
Value operator"" _mm_per_min(long double raw);
Value operator"" _m_per_s(long double raw);
Value operator"" _mm_per_s(long double raw);
Value operator"" _mm_per_s2(long double raw);
Value operator"" _steps_per_mm(long double raw);
Value operator"" _steps_per_turn(long double raw);
 
Value operator*(const Value &value1, const Value &value2);
Value operator/(const Value &value1, const Value &value2);
 
template<class R, class P>
Value operator*(const Value &value, std::chrono::duration<R, P> duration);
template<class R, class P>
Value operator/(const Value &value, std::chrono::duration<R, P> duration);
 
struct IOPort
{
    IOPort(const IOPort &) = default;
    IOPort(IOPort &&) = default;
    IOPort &operator=(const IOPort &) = default;
    IOPort &operator=(IOPort &&) = default;
 
    typedef size_t size_type;
    typedef uint64_t value_type;
    typedef std::bidirectional_iterator_tag iterator_category;
    struct iterator;
    struct const_iterator;
    struct reference;
    struct const_reference;
 
    explicit IOPort() : value{0}, size{0} {}
    explicit IOPort(bool value) :
        value{value ? uint64_t{1} : uint64_t{0}},
        size{1}
    {}
    explicit IOPort(uint8_t value, size_type size = 8) :
        value{value},
        size{size}
    {}
    explicit IOPort(uint16_t value, size_type size = 16) :
        value{value},
        size{size}
    {}
    explicit IOPort(uint32_t value, size_type size = 32) :
        value{value},
        size{size}
    {}
    explicit IOPort(uint64_t value, size_type size = 64) :
        value{value},
        size{size}
    {}
 
    bool operator==(const IOPort &port) const
    {
        return value == port.value && size == port.size;
    }
    bool operator!=(const IOPort &port) const { return !(port == *this); }
 
    inline bool operator[](size_type pos) const
    {
        return ((value >> pos) & 1);
    };
    inline operator bool() const { return value; }
 
    inline reference operator[](size_type offset);
 
    inline const_iterator begin() const;
    inline const_iterator end() const;
 
    inline const_iterator const_begin() const;
    inline const_iterator const_end() const;
 
    inline iterator begin();
    inline iterator end();
 
    enum class StrFmt
    {
        AUTO,
        BIN,
        HEX
    };
 
    std::string toString(StrFmt format = StrFmt::AUTO) const;
 
    value_type value; 
    size_type size;   
};
typedef IOPort io_port_t;
 
} /* namespace units */
 
const std::string &to_string(units::Unit unit);
 
template<>
units::Unit from_string(const std::string &);
 
inline std::string to_string(const units::Value &value)
{
    return value.toString();
}
 
template<>
const std::set<units::Unit> &getEnumValues();
 
inline std::string to_string(const units::io_port_t &port)
{
    return port.toString();
}
 
template<>
units::io_port_t from_string(const std::string &);
 
} /* namespace smc */
 
#include "Units.hxx"
 
#endif /* MOTION_CONTROLLER_UNITS_HPP__ */