MGrblAxis.cpp

/*
** Copyright (C) 2025 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: 2025-04-17T11:31:20
** Author: Sylvain Fargier <sylvain.fargier@cern.ch>
*/
 
#include "MGrblAxis.hpp"
 
#include <ccut/async.hpp>
 
#include "MGrblPlatform.hpp"
#include "util/grbl/GrblDeviceBase.hpp"
#include "util/grbl/GrblGenerator.hpp"
 
using namespace logger;
using namespace smc;
using namespace smc::internal;
using namespace smc::units;
using ImmediateCmd = MGrblPlatform::ImmediateCmd;
 
MGrblAxis::MGrblAxis(const std::string &uid,
                     const std::shared_ptr<MGrblPlatform> &mgrbl,
                     const std::shared_ptr<GrblPlatform> &grbl) :
    GrblAxis(uid, grbl),
    m_mgrbl{mgrbl}
{}
 
void MGrblAxis::updateInstance() const
{
    std::shared_ptr<MGrblPlatform> mgrbl(m_mgrbl.lock());
    if (!mgrbl)
        throw Exception(ErrorCode::Canceled, "platform stopped (deleted)");
 
    mgrbl->updateInstance(const_cast<MGrblAxis &>(*this));
}
 
std::future<void> MGrblAxis::moveTo(const units::Value &position) const
{
    try
    {
        updateInstance();
        return GrblAxis::moveTo(position);
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error(ex);
    }
}
 
std::future<void> MGrblAxis::moveBy(const units::Value &distance) const
{
    try
    {
        updateInstance();
        return GrblAxis::moveBy(distance);
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error(ex);
    }
}
 
std::future<void> MGrblAxis::stop() const
{
    try
    {
        updateInstance();
        return GrblAxis::stop();
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error(ex);
    }
}
 
std::future<void> MGrblAxis::pause() const
{
    try
    {
        updateInstance();
        return GrblAxis::pause();
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error(ex);
    }
}
 
std::future<void> MGrblAxis::resume() const
{
    try
    {
        updateInstance();
        return GrblAxis::resume();
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error(ex);
    }
}
 
std::future<units::value_t> MGrblAxis::getPosition(units::unit_t unit) const
{
    try
    {
        updateInstance();
        return GrblAxis::getPosition(unit);
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error<units::value_t>(ex);
    }
}
 
units::value_t MGrblAxis::lastPosition(units::unit_t unit) const
{
    updateInstance();
    return GrblAxis::lastPosition(unit);
}
 
std::future<void> MGrblAxis::setActualPosition(const units::Value &position) const
{
    try
    {
        updateInstance();
        return GrblAxis::setActualPosition(position);
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error(ex);
    }
}
 
std::future<void> MGrblAxis::takeReference(
    const std::chrono::milliseconds &timeout) const
{
    try
    {
        updateInstance();
        return GrblAxis::takeReference(timeout);
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error(ex);
    }
}
 
std::future<Axis::State> MGrblAxis::getState() const
{
    try
    {
        updateInstance();
        return GrblAxis::getState();
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error<Axis::State>(ex);
    }
}
 
std::future<std::set<std::string>> MGrblAxis::listConfig() const
{
    try
    {
        updateInstance();
        return GrblAxis::listConfig();
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error<std::set<std::string>>(ex);
    }
}
 
std::future<std::string> MGrblAxis::getConfig(const std::string &name) const
{
    try
    {
        updateInstance();
        return GrblAxis::getConfig(name);
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error<std::string>(ex);
    }
}
 
std::future<void> MGrblAxis::setConfig(const std::string &name,
                                       const std::string &value) const
{
    try
    {
        std::shared_ptr<MGrblPlatform> mgrbl(m_mgrbl.lock());
        if (!mgrbl)
            throw Exception(ErrorCode::Canceled, "platform stopped (deleted)");
 
        const std::string uid{this->uid()};
        std::shared_ptr<GrblPlatform> grbl{mgrbl->getFirstInstance()};
        grbl::Axis grblAxis = grbl->getAxis(uid);
 
        return mgrbl->run<void>([name, value, grblAxis, uid,
                                 mgrbl](ImmediateCmd &cmd,
                                        MGrblPlatform::Context &ctx) {
            grbl::SettingId id;
            mgrbl->runOnInstance(
                ctx,
                [&name, &grblAxis, &id](GrblPlatform::Shared &,
                                        GrblPlatform::Context &ctx) {
                    id = ctx.findSetting(name, grblAxis).id;
                },
                true);
 
            const std::string settingCmd = grbl::gen::System::setSetting(id,
                                                                         value);
            mgrbl->runOnInstance(
                ctx,
                [&settingCmd, &uid, &id, &value](GrblPlatform::Shared &grbl,
                                                 GrblPlatform::Context &ctx) {
                    grbl::ErrorCode rc = ctx.device->send(settingCmd);
                    ctx.checkReply(rc);
                    grbl->updateAxisSetting(uid, id, value);
                });
            cmd.prom->get<void>().set_value();
        });
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error<void>(ex);
    }
}
 
bool MGrblAxis::canConvert(const units::Value &value, units::unit_t unit) const
{
    updateInstance();
    return GrblAxis::canConvert(value, unit);
}
 
bool MGrblAxis::convert(units::Value &value, units::unit_t unit) const
{
    updateInstance();
    return GrblAxis::convert(value, unit);
}