GrblPlatform_Context.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-17T10:23:16
** Author: Sylvain Fargier <sylvain.fargier@cern.ch>
*/
 
#include <ccut/utils.hpp>
#include <logger/Logger.hpp>
 
#include "GrblPlatform.hpp"
#include "util/grbl/GrblDeviceBase.hpp"
#include "util/grbl/GrblGenerator.hpp"
 
using namespace smc;
using namespace smc::internal;
using namespace logger;
 
using grbl::GrblParser;
 
GrblPlatform::Context::Context(const std::string &prefix,
                               const std::string &id) :
    prefix{prefix},
    id{id}
{}
 
std::string GrblPlatform::Context::getErrorMessage(grbl::ErrorCode code) const
{
    decltype(errors)::const_iterator it = errors.find(code);
    if (it == errors.end())
    {
        return "Unknown error: " + std::to_string(code);
    }
    return it->second;
}
 
std::string GrblPlatform::Context::getAlarmMessage(grbl::AlarmCode alarm) const
{
    decltype(alarms)::const_iterator it = alarms.find(alarm);
    if (it == alarms.end())
    {
        return "Unknown alarm: " + std::to_string(alarm);
    }
    return it->second;
}
 
void GrblPlatform::Context::checkReply(grbl::ErrorCode code)
{
    if (code != 0)
    {
        throw Exception(ErrorCode::Runtime,
                        "command failed: " + getErrorMessage(code));
    }
}
 
std::set<std::string> GrblPlatform::Context::listConfig()
{
    std::set<std::string> ret;
    std::transform(setting.begin(), setting.end(),
                   std::inserter(ret, ret.begin()),
                   [](const SettingMap::value_type &t) { return t.first; });
 
    std::transform(localSetting.begin(), localSetting.end(),
                   std::inserter(ret, ret.begin()),
                   [](const LocalSettingMap::value_type &t) { return t.first; });
 
    return ret;
}
 
std::set<std::string> GrblPlatform::Context::listConfig(grbl::Axis grblAxis)
{
    std::set<std::string> ret;
    std::string groupName = to_string(grblAxis) + "-axis";
    auto group = settingGroup.find(groupName);
    if (group != settingGroup.end())
    {
        groupName += " ";
        int groupId = group->second;
        for (const auto &s : setting)
        {
            if (s.second.groupId == groupId)
            {
                if (ccut::startsWith(s.first, groupName))
                    ret.insert(s.first.substr(groupName.size()));
                else
                    ret.insert(s.first);
            }
        }
    }
    return ret;
}
 
const GrblParser::SettingDesc &GrblPlatform::Context::findSetting(
    const std::string &name,
    grbl::Axis axis) const
{
    std::string pfx = to_string(axis) + "-axis ";
    SettingMap::const_iterator it = setting.find(pfx + name);
    if (it == setting.end())
        it = setting.find(name);
 
    if (it == setting.end())
    {
        throw Exception(ErrorCode::InvalidArguments, "no such setting: " + name);
    }
    return it->second;
}
 
const GrblParser::SettingDesc &GrblPlatform::Context::findSetting(
    const std::string &name) const
{
    SettingMap::const_iterator it = setting.find(name);
 
    if (it == setting.end())
    {
        throw Exception(ErrorCode::InvalidArguments, "no such setting: " + name);
    }
    return it->second;
}
 
void GrblPlatform::Context::setSetting(const std::string &name,
                                       const std::string &value)
{
    LocalSettingMap::const_iterator itls = localSetting.find(name);
    if (itls != localSetting.end())
    {
        itls->second.set(*this, value);
    }
    else
    {
        _sendSetSetting(findSetting(name).id, value);
    }
}
 
std::string GrblPlatform::Context::_sendGetSetting(grbl::SettingId id)
{
    std::string ret;
    grbl::ErrorCode rc = device->send(
        grbl::gen::System::getSetting(id),
        [this, id, &ret](const std::string &line) {
            if (GrblParser::getLineType(line) == grbl::LineType::Setting)
            {
                GrblParser::Setting setting;
                if ((GrblParser::parseSetting(line, setting)) &&
                    (setting.first == id))
                {
                    ret = setting.second;
                    return true;
                }
            }
            return false;
        });
    checkReply(rc);
    return ret;
}
 
void GrblPlatform::Context::_sendSetSetting(grbl::SettingId id,
                                            const std::string &value)
{
    grbl::ErrorCode rc = device->send(grbl::gen::System::setSetting(id, value));
    checkReply(rc);
}
 
bool GrblPlatform::Context::isStepperMessage(const std::string &line)
{
    return ccut::startsWith(line, "[MSG:Stepper");
}
 
void GrblPlatform::Context::sendReset()
{
    grbl::ErrorCode ret{-1};
    for (size_t i = 0; (ret != grbl::ErrorCode{0}) && (i < 3); ++i)
    {
        ret = this->device->sendRealtime(
            grbl::gen::Realtime::Reset, [](const std::string &line) {
                if (ccut::startsWith(line, "GrblHAL"))
                    throw grbl::ErrorCode{0};
                return false;
            });
        if (ret != grbl::ErrorCode{0})
        {
            warning(s_loggerCat) << "failed to reset";
            std::this_thread::sleep_for(std::chrono::milliseconds{1000});
        }
    }
    if (ret != grbl::ErrorCode{0})
        crit(s_loggerCat) << "failed to reset";
 
    /*
     * when unlock is sent before "[MSG:'$H'|'$X' to unlock]" it sometimes fails
     * with "error:9", but we want this sequence to also reset when motor is not
     * locked, so let's add a small delay and a retry on unlock */
    ret = -1;
    for (size_t i = 0; (ret != grbl::ErrorCode{0}) && (i < 3); ++i)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds{100});
        ret = this->device->send(grbl::gen::System::DisableLock);
    }
    if (ret != grbl::ErrorCode{0})
        crit(s_loggerCat) << "failed to unlock";
 
    ret = -1;
    for (size_t i = 0; (ret != grbl::ErrorCode{0}) && (i < 3); ++i)
        ret = this->device->sendRealtime(
            grbl::gen::Realtime::Reset, [](const std::string &line) {
                if (ccut::startsWith(line, "GrblHAL"))
                    throw grbl::ErrorCode{0};
                return false;
            });
    if (ret != grbl::ErrorCode{0})
        crit(s_loggerCat) << "failed to reset";
 
    /* updating state, otherwise next loop may reset again, it also ensures
     * motor state is sane */
    ret = -1;
    for (size_t i = 0; (ret != grbl::ErrorCode{0}) && (i < 3); ++i)
    {
        ret = this->device->sendRealtime(
            grbl::gen::Realtime::StatusReport,
            [this](const std::string &message) {
                if (grbl::GrblParser::getLineType(message) ==
                    grbl::LineType::State)
                {
                    this->device->dataSignal(message);
                    throw grbl::ErrorCode{0};
                }
                return false;
            });
        if (ret != grbl::ErrorCode{0})
        {
            warning(s_loggerCat) << "failed to retrieve state";
            std::this_thread::sleep_for(std::chrono::milliseconds{1000});
        }
    }
    if (ret != grbl::ErrorCode{0})
        crit(s_loggerCat) << "failed to retrieve state";
    info(s_loggerCat) << "instance reset, state: " << this->state.runState;
}