MockPlatform.cpp

/*
 * 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-10-29
 *     Author: Michal Mysior <mmysior> <michal.mysior@cern.ch>
 *
 */
 
#include "MockPlatform.hpp"
 
#include <mutex>
#include <sstream>
#include <string>
 
#include <ccut/yml.hpp>
#include <logger/Logger.hpp>
 
#include "Exception.hpp"
#include "MockAxis.hpp"
#include "MockGpio.hpp"
#include "MockPositionSensor.hpp"
#include "Units.hpp"
 
using namespace logger;
namespace yml = ccut::yml;
 
static const std::string s_platformPrefix = "mock://";
static const uint32_t s_motorStepsPerMM = 250;
static const float s_lvdtStepsPerDegree = 4;
static const int32_t s_lvdtConstDegrees = 90;
 
namespace smc {
 
using namespace units;
 
namespace internal {
 
const std::string MockPlatform::s_loggerCat{"smc:mock"};
 
MockPlatform::~MockPlatform() {}
 
MockPlatform::MockPlatform(const yml::NodeRef &node)
{
    yml::get(node, "id") >> yml::default_to(m_platformId, 0);
 
    yml::NodeRef elts = yml::get(node, "axis");
    if (!elts.valid())
        info(s_loggerCat) << "no axis configured";
    else if (!elts.is_seq())
        throw Exception(ErrorCode::InvalidArguments, "invalid axis type");
    else
    {
        for (yml::NodeRef elt : elts)
        {
            std::string token;
            elt >> token;
            MotorLocation motor = motorFromStr(token);
 
            std::stringstream uri;
            uri << s_platformPrefix << m_platformId << "/axis/" << motor;
            debug(s_loggerCat) << "motor created: " << uri.str();
            m_motors[uri.str()] = motor;
        }
    }
 
    elts = yml::get(node, "positions");
    if (!elts.valid())
        info(s_loggerCat) << "no positions configured";
    else if (!elts.is_seq())
        throw Exception(ErrorCode::InvalidArguments, "invalid positions type");
    else
    {
        for (yml::NodeRef elt : elts)
        {
            uint8_t token;
            elt >> token;
 
            std::stringstream uri;
            uri << s_platformPrefix << m_platformId << "/position/"
                << int(token);
            debug(s_loggerCat) << "position created: " << uri.str();
            m_lvdts[uri.str()] = token;
        }
    }
 
    elts = yml::get(node, "gpios");
    if (!elts.valid())
        info(s_loggerCat) << "no gpios configured";
    else if (!elts.is_seq())
        throw Exception(ErrorCode::InvalidArguments, "invalid gpios type");
    else
    {
        for (yml::NodeRef elt : elts)
        {
            uint8_t token;
            elt >> token;
 
            std::stringstream uri;
            uri << s_platformPrefix << m_platformId << "/gpio/" << int(token);
            debug(s_loggerCat) << "gpio created: " << uri.str();
            m_gpios[uri.str()] = token;
        }
    }
 
    // Generate list of motor positions
    for (const auto &motor : m_motors)
    {
        // All motors used initially at origin
        m_motorPositions.insert(
            std::pair<MotorLocation, units::Value::value_type>(motor.second,
                                                               0.0));
    }
 
    // Generate list of POSITION position
    for (const auto &lvdt : m_lvdts)
    {
        m_lvdtPositions.insert(std::pair<uint8_t, units::Value::value_type>(
            lvdt.second, s_lvdtConstDegrees));
    }
 
    // Generate list of GPIO states
    for (const auto &gpio : m_gpios)
    {
        m_gpioStates.insert(
            std::pair<uint8_t, io_port_t>(gpio.second, IOPort{false}));
    }
}
 
size_t MockPlatform::getPlatformId() const
{
    return (m_platformId);
}
 
void MockPlatform::setMotorPosition(const std::string &motor,
                                    units::Value::value_type destPosition)
{
    std::lock_guard<std::mutex> lock(m_lock);
    auto it = m_motors.find(motor);
 
    if (it == m_motors.end())
    {
        error(s_loggerCat)
            << "Bad motor address (" << motor
            << ") referenced on MockPlatform id: " << m_platformId;
        throw Exception(ErrorCode::InvalidArguments);
    }
 
    m_motorPositions.find(it->second)->second = destPosition;
}
 
units::Value::value_type MockPlatform::getMotorPosition(const std::string &motor)
{
    std::lock_guard<std::mutex> lock(m_lock);
    auto it = m_motors.find(motor);
 
    if (it == m_motors.end())
    {
        error(s_loggerCat)
            << "Bad motor address (" << motor
            << ") referenced on MockPlatform id: " << m_platformId;
        throw Exception(ErrorCode::InvalidArguments);
    }
 
    return m_motorPositions.find(it->second)->second;
}
 
units::Value::value_type MockPlatform::getLvdtAngle(const std::string &lvdt)
{
    std::lock_guard<std::mutex> lock(m_lock);
    auto it = m_lvdts.find(lvdt);
 
    if (it == m_lvdts.end())
    {
        error(s_loggerCat)
            << "Bad lvdt address (" << lvdt
            << ") referenced on MockPlatform id: " << m_platformId;
        throw Exception(ErrorCode::InvalidArguments);
    }
 
    return m_lvdtPositions.find(it->second)->second;
}
 
void MockPlatform::setLvdtAngle(const std::string &lvdt,
                                units::Value::value_type value)
{
    std::lock_guard<std::mutex> lock(m_lock);
    auto it = m_lvdts.find(lvdt);
 
    if (it == m_lvdts.end())
    {
        error(s_loggerCat)
            << "Bad lvdt address (" << lvdt
            << ") referenced on MockPlatform id: " << m_platformId;
        throw Exception(ErrorCode::InvalidArguments);
    }
 
    m_lvdtPositions.find(it->second)->second = value;
}
 
void MockPlatform::setGpioState(const std::string &gpio,
                                const units::io_port_t &state)
{
    std::lock_guard<std::mutex> lock(m_lock);
    auto it = m_gpios.find(gpio);
 
    if (it == m_gpios.end())
    {
        error(s_loggerCat)
            << "Bad gpio address (" << gpio
            << ") referenced on MockPlatform id: " << m_platformId;
        throw Exception(ErrorCode::InvalidArguments);
    }
 
    m_gpioStates.find(it->second)->second = state;
}
 
io_port_t MockPlatform::getGpioState(const std::string &gpio)
{
    std::lock_guard<std::mutex> lock(m_lock);
    auto it = m_gpios.find(gpio);
 
    if (it == m_gpios.end())
    {
        error(s_loggerCat)
            << "Bad gpio address (" << gpio
            << ") referenced on MockPlatform id: " << m_platformId;
        throw Exception(ErrorCode::InvalidArguments);
    }
 
    return m_gpioStates.find(it->second)->second;
}
 
std::set<DeviceBase::DeviceType> MockPlatform::getSupportedDevices() const
{
    std::set<DeviceBase::DeviceType> supported = {
        DeviceBase::DeviceType::AXIS, DeviceBase::DeviceType::POSITION_SENSOR,
        DeviceBase::DeviceType::GPIO};
    return supported;
}
 
PlatformBase::DeviceList MockPlatform::generateDevices(
    const DeviceTypeList &deviceType)
{
    DeviceList devices;
 
    if (deviceType.count(DeviceBase::DeviceType::AXIS))
    {
        for (std::pair<const std::string,
                       smc::internal::MockPlatform::MotorLocation> motorEntry :
             m_motors)
        {
            DeviceBase::Shared motor = std::make_shared<MockAxis>(
                motorEntry.first, shared_from_this());
            devices.push_back(motor);
        }
    }
    if (deviceType.count(DeviceBase::DeviceType::POSITION_SENSOR))
    {
        for (std::pair<const std::string, uint8_t> lvdtEntry : m_lvdts)
        {
            DeviceBase::Shared lvdt = std::make_shared<MockPositionSensor>(
                lvdtEntry.first, shared_from_this());
            devices.push_back(lvdt);
        }
    }
    if (deviceType.count(DeviceBase::DeviceType::GPIO))
    {
        for (std::pair<const std::string, uint8_t> gpioEntry : m_gpios)
        {
            DeviceBase::Shared gpio = std::make_shared<MockGpio>(
                gpioEntry.first, shared_from_this());
            devices.push_back(gpio);
        }
    }
 
    return devices;
}
 
} /* namespace internal */
} /* namespace smc */