AsyncAxisController.cpp

/*
** Copyright (C) 2023 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: 2023-10-26T11:44:27
** Author: Sylvain Fargier <sylvain.fargier@cern.ch>
*/
 
#include "AsyncAxisController.hpp"
 
#include OATPP_CODEGEN_BEGIN(ApiController)
 
using namespace oatpp::web::protocol::http;
using namespace oatpp::async;
using namespace smc;
 
AsyncAxisController::AsyncAxisController(
    std::shared_ptr<ObjectMapper> &objectMapper) :
    SmcController(objectMapper)
{
    addTag(*this, "axis");
}
 
void AsyncAxisController::addParams(
    const std::shared_ptr<oatpp::web::server::api::Endpoint::Info> &info)
{
    info->pathParams.add<String>("id").addExample("Grbl axis X",
                                                  String("grbl://1/axis/X"));
 
    {
        auto &param = info->queryParams.add<String>("unit")
                          .addExample("mm", String("mm"))
                          .addExample("steps", String("steps"));
 
        param.required = false;
        param.description = "request unit";
    }
}
 
Action AsyncAxisController::getPosition::act()
{
    const std::string unit = request->getQueryParameter("unit").getValue("mm");
    auto deviceStore(controller->deviceStore.lock());
    if (deviceStore)
    {
        smc::Axis::Shared axis = deviceStore->getDevice<smc::Axis>(
            ccut::urldecode(request->getPathVariable("id").getValue("")));
 
        auto future = axis->getPosition(
            smc::from_string<smc::units::Unit>(unit));
        return smc::debug::wait(future.share())
            .callbackTo(&getPosition::onResult);
    }
    return _return(
        controller->createResponse(Status::CODE_500, "no deviceStore"));
}
 
Action AsyncAxisController::getPosition::onResult(
    const smc::units::value_t &value)
{
    return _return(
        controller->createDtoResponse(Status::CODE_200, Float64(value.value)));
}
 
Action AsyncAxisController::putPosition::act()
{
    return request
        ->readBodyToDtoAsync<Float64>(controller->getDefaultObjectMapper())
        .callbackTo(&putPosition::onMoveTo);
}
 
Action AsyncAxisController::putPosition::onMoveTo(const Float64 &position)
{
    const std::string unit = request->getQueryParameter("unit").getValue("mm");
    auto deviceStore(controller->deviceStore.lock());
    if (deviceStore)
    {
        smc::Axis::Shared axis = deviceStore->getDevice<smc::Axis>(
            ccut::urldecode(request->getPathVariable("id").getValue("")));
 
        auto future = axis->moveTo(
            smc::units::value_t{smc::from_string<smc::units::Unit>(unit),
                                position.getValue(std::nan("invalid"))});
 
        if (future.wait_for(std::chrono::milliseconds(0)) !=
            std::future_status::timeout)
        {
            future.get(); // throw if needed
        }
        return _return(controller->createResponse(Status::CODE_200, "done"));
    }
 
    return _return(
        controller->createResponse(Status::CODE_500, "no deviceStore"));
}
 
Action AsyncAxisController::postPosition::act()
{
    return request
        ->readBodyToDtoAsync<Float64>(controller->getDefaultObjectMapper())
        .callbackTo(&postPosition::onMoveBy);
}
Action AsyncAxisController::postPosition::onMoveBy(const Float64 &position)
{
    const std::string unit = request->getQueryParameter("unit").getValue("mm");
    auto deviceStore(controller->deviceStore.lock());
    if (deviceStore)
    {
        smc::Axis::Shared axis = deviceStore->getDevice<smc::Axis>(
            ccut::urldecode(request->getPathVariable("id").getValue("")));
 
        auto future = axis->moveBy(
            smc::units::value_t{smc::from_string<smc::units::Unit>(unit),
                                position.getValue(std::nan("invalid"))});
 
        if (future.wait_for(std::chrono::milliseconds(0)) !=
            std::future_status::timeout)
        {
            future.get(); // throw if needed
        }
        return _return(controller->createResponse(Status::CODE_200, "done"));
    }
    return _return(
        controller->createResponse(Status::CODE_500, "no deviceStore"));
}
 
Action AsyncAxisController::putCurrentPosition::act()
{
    return request
        ->readBodyToDtoAsync<Float64>(controller->getDefaultObjectMapper())
        .callbackTo(&putCurrentPosition::onSetCurrentPosition);
}
 
Action AsyncAxisController::putCurrentPosition::onSetCurrentPosition(
    const Float64 &position)
{
    const std::string unit = request->getQueryParameter("unit").getValue("mm");
    auto deviceStore(controller->deviceStore.lock());
    if (deviceStore)
    {
        smc::Axis::Shared axis = deviceStore->getDevice<smc::Axis>(
            ccut::urldecode(request->getPathVariable("id").getValue("")));
 
        auto future = axis->setActualPosition(
            smc::units::value_t{smc::from_string<smc::units::Unit>(unit),
                                position.getValue(std::nan("invalid"))});
        return smc::debug::wait(future.share())
            .next(_return(controller->createResponse(Status::CODE_200, "done")));
    }
    return _return(
        controller->createResponse(Status::CODE_500, "no deviceStore"));
}
 
Action AsyncAxisController::putStop::act()
{
    auto deviceStore(controller->deviceStore.lock());
    if (deviceStore)
    {
        smc::Axis::Shared axis = deviceStore->getDevice<smc::Axis>(
            ccut::urldecode(request->getPathVariable("id").getValue("")));
 
        auto future = axis->stop();
        return smc::debug::wait(future.share())
            .next(_return(controller->createResponse(Status::CODE_200, "done")));
    }
    return _return(
        controller->createResponse(Status::CODE_500, "no deviceStore"));
}
 
Action AsyncAxisController::putPause::act()
{
    auto deviceStore(controller->deviceStore.lock());
    if (deviceStore)
    {
        smc::Axis::Shared axis = deviceStore->getDevice<smc::Axis>(
            ccut::urldecode(request->getPathVariable("id").getValue("")));
 
        auto future = axis->pause();
        return smc::debug::wait(future.share())
            .next(_return(controller->createResponse(Status::CODE_200, "done")));
    }
    return _return(
        controller->createResponse(Status::CODE_500, "no deviceStore"));
}
 
Action AsyncAxisController::putResume::act()
{
    auto deviceStore(controller->deviceStore.lock());
    if (deviceStore)
    {
        smc::Axis::Shared axis = deviceStore->getDevice<smc::Axis>(
            ccut::urldecode(request->getPathVariable("id").getValue("")));
 
        auto future = axis->resume();
        return smc::debug::wait(future.share())
            .next(_return(controller->createResponse(Status::CODE_200, "done")));
    }
    return _return(
        controller->createResponse(Status::CODE_500, "no deviceStore"));
}
 
Action AsyncAxisController::postTakeReference::act()
{
    return request
        ->readBodyToDtoAsync<Float64>(controller->getDefaultObjectMapper())
        .callbackTo(&postTakeReference::onTakeReference);
}
 
Action AsyncAxisController::postTakeReference::onTakeReference(
    const Float64 &timeout)
{
    auto deviceStore(controller->deviceStore.lock());
    if (deviceStore)
    {
        smc::Axis::Shared axis = deviceStore->getDevice<smc::Axis>(
            ccut::urldecode(request->getPathVariable("id").getValue("")));
 
        auto future = axis->takeReference(std::chrono::milliseconds(timeout));
 
        if (future.wait_for(std::chrono::milliseconds(0)) !=
            std::future_status::timeout)
        {
            future.get(); // throw if needed
        }
 
        return _return(
            controller->createResponse(Status::CODE_200, "homing started"));
    }
    return _return(
        controller->createResponse(Status::CODE_500, "no deviceStore"));
}
 
Action AsyncAxisController::getState::act()
{
    auto deviceStore(controller->deviceStore.lock());
    if (deviceStore)
    {
        smc::Axis::Shared axis = deviceStore->getDevice<smc::Axis>(
            ccut::urldecode(request->getPathVariable("id").getValue("")));
 
        auto future = axis->getState();
 
        return smc::debug::wait(future.share()).callbackTo(&getState::onResult);
    }
    return _return(
        controller->createResponse(Status::CODE_500, "no deviceStore"));
}
 
Action AsyncAxisController::getState::onResult(const smc::Axis::State &state)
{
    return _return(controller->createDtoResponse(
        Status::CODE_200, String(smc::to_string(state))));
}