GrblPlatform_Base.cpp

/*
 * Copyright (C) 2022 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: 2022-07-14
 *     Author: Michal Mysior <mmysior> <michal.mysior@cern.ch>
 *
 */
 
#include <chrono>
 
#include <ccut/async.hpp>
#include <logger/Logger.hpp>
 
#include "GrblAxis.hpp"
#include "GrblGpio.hpp"
#include "GrblPlatform.hpp"
#include "GrblPlatformDevice.hpp"
#include "device/Axis.hpp"
#include "platform/specialized/GrblPlatform/GrblTrigger.hpp"
#include "util/SettingParser.hpp"
#include "util/grbl/GrblDeviceBase.hpp"
#include "util/grbl/GrblGenerator.hpp"
#include "util/grbl/GrblParser.hpp"
 
using namespace logger;
using namespace std::chrono;
using grbl::GrblParser;
 
static const std::string s_resolutionSettingName{"travel resolution"};
static const std::string s_loggerCat{"smc:platform:grbl"};
 
namespace smc {
namespace internal {
 
PlatformBase::DeviceTypeList GrblPlatform::getSupportedDevices() const
{
    return DeviceTypeList{DeviceType::AXIS, DeviceType::TRIGGER,
                          DeviceType::GPIO, DeviceType::PLATFORM};
}
 
PlatformBase::DeviceList GrblPlatform::generateDevices(
    const DeviceTypeList &deviceType)
{
    DeviceList ret;
    if (deviceType.count(DeviceType::AXIS))
    {
        std::shared_ptr<GrblPlatform> self(
            std::static_pointer_cast<GrblPlatform>(shared_from_this()));
 
        std::future<std::list<GrblAxis::Shared>> f =
            run<std::list<GrblAxis::Shared>>(
                [self](ImmediateCmd &cmd, const Context &ctx) {
                    std::list<GrblAxis::Shared> ret;
                    self->generateAxes(ctx, ctx.binfo.axisCount, ret);
                    cmd.prom->get<std::list<GrblAxis::Shared>>().set_value(ret);
                });
        if (f.wait_for(milliseconds(3000)) == std::future_status::timeout)
        {
            error(s_loggerCat) << "failed to generate Axes";
            return DeviceList();
        }
        std::list<GrblAxis::Shared> axisList{f.get()};
        for (GrblAxis::Shared axis : axisList)
        {
            /* load parts from config */
            axis->getConfig(s_resolutionSettingName).wait();
            ret.push_back(axis);
        }
    }
    bool hasTriggers = deviceType.count(DeviceType::TRIGGER);
    bool hasGpios = deviceType.count(DeviceType::GPIO);
    if (hasTriggers || hasGpios)
    {
        std::shared_ptr<GrblPlatform> self(
            std::static_pointer_cast<GrblPlatform>(shared_from_this()));
 
        std::future<std::list<DeviceBase::Shared>> f =
            run<std::list<DeviceBase::Shared>>(
                [self, hasTriggers, hasGpios](ImmediateCmd &cmd, Context &ctx) {
                    std::list<GrblParser::PinInfo> pinfo;
                    ctx.device->send(grbl::gen::System::EnumeratePins,
                                     [&pinfo](const std::string &line) {
                                         return GrblParser::parsePinInfo(line,
                                                                         pinfo);
                                     });
                    std::list<DeviceBase::Shared> ret;
                    if (hasGpios)
                    {
                        std::list<GrblGpio::Shared> gpios;
                        self->generateGpios(ctx, pinfo, gpios);
                        ret.insert(ret.end(), gpios.begin(), gpios.end());
                    }
                    if (hasTriggers)
                    {
                        std::list<GrblTrigger::Shared> triggers;
                        self->generateTriggers(ctx, pinfo, triggers);
                        ret.insert(ret.end(), triggers.begin(), triggers.end());
                    }
                    cmd.prom->get<std::list<DeviceBase::Shared>>().set_value(
                        ret);
                });
 
        if (f.wait_for(milliseconds(3000)) == std::future_status::timeout)
        {
            error(s_loggerCat) << "failed to generate Gpios and Triggers";
            return DeviceList();
        }
        std::list<DeviceBase::Shared> devices{f.get()};
        ret.insert(ret.end(), devices.begin(), devices.end());
    }
    if (deviceType.count(DeviceType::PLATFORM))
    {
        ret.emplace_back(new GrblPlatformDevice{
            m_ctx->prefix + m_ctx->id + "/platform", shared_from_this()});
    }
    return ret;
}
 
void GrblPlatform::generateTriggers(
    Context &ctx,
    const std::list<grbl::GrblParser::PinInfo> &pins,
    std::list<GrblTrigger::Shared> &out)
{
    const std::string platformUrl = ctx.prefix + ctx.id;
 
    for (const GrblParser::PinInfo &pinInfo : pins)
    {
        if (pinInfo.description == "Hardware Trigger")
        {
            const std::string url = platformUrl + "/trigger";
            out.emplace_back(new GrblTrigger{url, shared_from_this()});
            {
                std::lock_guard<std::mutex> l(m_lock);
                m_trigger.first = platformUrl;
                m_trigger.second = pinInfo.pin;
            }
 
            // Add Triggered motion setting
            ctx.localSetting["Triggered motion"] = {
                [](Context &ctx, const std::string &value) {
                    ctx.triggeredMotion = SettingParser::parse<bool>(value);
                },
                [](const Context &ctx) -> std::string {
                    return ctx.triggeredMotion ? "1" : "0";
                },
            };
        }
    }
}
 
void GrblPlatform::generateGpios(const Context &ctx,
                                 const std::list<grbl::GrblParser::PinInfo> &pins,
                                 std::list<GrblGpio::Shared> &out)
{
    const std::string platformUrl = ctx.prefix + ctx.id;
 
    for (const GrblParser::PinInfo &pinInfo : pins)
    {
        if (pinInfo.description == "Pause/Resume")
        {
            const std::string url = platformUrl + "/gpio/pauseResume";
            out.emplace_back(new GrblGpio{url, shared_from_this()});
            {
                std::lock_guard<std::mutex> l(m_lock);
                m_gpioMap[url] = pinInfo.pin;
            }
        }
    }
}
 
void GrblPlatform::generateAxes(const Context &ctx,
                                size_t axesCount,
                                std::list<GrblAxis::Shared> &out)
{
    const std::string platformUrl = ctx.prefix + ctx.id + "/axis/";
 
    for (size_t i = 0; i < axesCount; ++i)
    {
        const grbl::Axis grblAxis = static_cast<grbl::Axis>(i);
        const std::string url = platformUrl + grbl::to_string(grblAxis);
        grbl::SettingId resolutionSettingId = -1;
        try
        {
            resolutionSettingId =
                ctx.findSetting(s_resolutionSettingName, grblAxis).id;
        }
        catch (const Exception &ex)
        {
            logger::warning(s_loggerCat)
                << "failed to retrieve " << s_resolutionSettingName << ": "
                << ex.what();
        }
 
        out.emplace_back(new GrblAxis{url, shared_from_this()});
        {
            std::lock_guard<std::mutex> l(m_lock);
            m_axisMap[url] = AxisData{
                grblAxis, units::value_t{units::mm, std::nan("initial value")},
                resolutionSettingId,
                units::value_t{units::STEPS_PER_MILLIMETER, -1.0}};
        }
    }
}
 
std::future<void> GrblPlatform::send(const std::string &grblCmd,
                                     std::function<bool(const std::string &)> msg,
                                     const std::chrono::milliseconds &timeout)
{
    return run<void>(
        [this, grblCmd, msg, timeout](ImmediateCmd &cmd, Context &ctx) {
            grbl::ErrorCode rc = ctx.device->send(grblCmd, msg, timeout);
            ctx.checkReply(rc);
            cmd.prom->get<void>().set_value();
        });
}
 
} // namespace internal
} // namespace smc