GrblParser.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-01-19
 *     Author: Michal Mysior <mmysior> <michal.mysior@cern.ch>
 *
 */
 
#include "GrblParser.hpp"
 
#include <algorithm>
#include <cctype>
#include <cmath>
#include <sstream>
#include <string>
 
#include <ccut/Regex.hpp>
#include <ccut/utils.hpp>
#include <logger/Logger.hpp>
 
#include "Exception.hpp"
 
using ccut::Regex;
 
static const std::string s_loggerCat{"grbl:parser"};
static const Regex s_settingRegex{"^\\$([0-9]{1,3})=([^\r\n]*)"};
static const Regex s_messageRegex{"^\\[([^:]*):(.*)\\]"};
static const Regex s_errorResponse("^error:([0-9]*)\\s*$");
 
using namespace smc;
using namespace logger;
 
namespace grbl {
 
LineType GrblParser::getLineType(const std::string &line)
{
    if (line.empty())
    {
        return LineType::Unknown;
    }
    switch (line[0])
    {
    case '<': return LineType::State;
    case '$': return LineType::Setting;
    case '[': return LineType::Message;
    default:
        if (line.compare(0, 2, "ok") == 0)
        {
            return LineType::OkReply;
        }
        else if (line.compare(0, 6, "error:") == 0)
        {
            return LineType::ErrorReply;
        }
        return LineType::Unknown;
    }
}
 
bool GrblParser::parseMessage(const std::string &line, Message &message)
{
    std::vector<std::string> matches;
    matches.reserve(3);
    if (!s_messageRegex.match(line, matches))
    {
        info(s_loggerCat) << "Not a message: " << line;
        return false;
    }
 
    message = std::make_pair(matches[1], matches[2]);
    return true;
}
 
bool GrblParser::parseSetting(const std::string &line, Setting &setting)
{
    std::vector<std::string> matches;
    matches.reserve(3);
    if (!s_settingRegex.match(line, matches))
    {
        info(s_loggerCat) << "Not a setting: " << line;
        return false;
    }
 
    setting = std::make_pair(std::atoi(matches[1].c_str()), matches[2]);
    return true;
}
 
bool GrblParser::parseErrorReply(const std::string &line,
                                 grbl::ErrorCode &errorCode)
{
    std::string::size_type idx = line.find(':');
    if (idx == std::string::npos)
    {
        info(s_loggerCat) << "Not a valid error: " << line;
        return false;
    }
 
    errorCode = std::atoi(&line[idx + 1]);
    return true;
}
 
bool GrblParser::parseState(const std::string &line, State &state)
{
    std::string::size_type end = line.rfind('>');
    if (line.size() <= 2 || line[0] != '<' || end == std::string::npos)
    {
        info(s_loggerCat) << "Not a state: " << line;
        return false;
    }
 
    std::vector<std::string> split;
    split.reserve(8);
    ccut::split(line.cbegin() + 1, line.cbegin() + end, '|', split);
 
    if (split.size() == 0)
    {
        error(s_loggerCat) << "split failed";
        return false;
    }
 
    try
    {
        std::string::size_type sz = split[0].find(':');
        if (sz != std::string::npos)
        {
            const std::string &part = split[0];
            state.runState = from_string<RunState>(part.substr(0, sz));
            char *strtoulend;
            state.runStateArg = std::strtoul(&part[sz + 1], &strtoulend, 10);
            if (strtoulend != part.data() + part.length())
            {
                error(s_loggerCat) << "invalid runStateArg: " << part;
                return false;
            }
        }
        else
            state.runState = from_string<RunState>(split[0]);
 
        if (state.runState == RunState::Unknown)
        {
            error(s_loggerCat) << "invalid RunState: " << split[0];
            return false;
        }
 
        for (size_t i = 1; i < split.size(); ++i)
        {
            const std::string &part = split[i];
            if (ccut::startsWith(part, "MPos:") ||
                ccut::startsWith(part, "WPos:"))
            {
                Axis axis = Axis::X;
                std::vector<std::string> positions;
                positions.reserve(6);
                ccut::split(part.cbegin() + 5, part.cend(), ',', positions);
                for (const std::string &pos : positions)
                {
                    state.motorPositions[axis] = std::stof(pos);
                    axis = static_cast<Axis>(static_cast<int>(axis) + 1);
                }
            }
            else if (ccut::startsWith(part, "Bf:"))
            {
                std::vector<std::string> available;
                available.reserve(2);
                ccut::split(part.cbegin() + 3, part.cend(), ',', available);
                if (available.size() != 2)
                {
                    error(s_loggerCat) << "invalid buffer size: " << part;
                    return false;
                }
                state.motionBufferFree = std::stoul(available[0]);
                state.charBufferFree = std::stoul(available[1]);
            }
            else if (ccut::startsWith(part, "Ln:"))
            {
                char *strtoulend;
                state.line = std::strtoul(&part[3], &strtoulend, 10);
                if (strtoulend != part.data() + part.length())
                {
                    error(s_loggerCat) << "invalid line: " << part;
                    return false;
                }
            }
        }
    }
    catch (const std::exception &ex)
    {
        error(s_loggerCat) << "exception parsing state: " << ex.what();
        return false;
    }
    return true;
}
 
bool GrblParser::parseBuildInfo(const std::string &line,
                                GrblParser::BuildInfo &buildInfo)
{
    if (getLineType(line) != LineType::Message)
        return false;
 
    try
    {
        grbl::GrblParser::Message msg;
        if (grbl::GrblParser::parseMessage(line, msg))
        {
            if (msg.first == "OPT")
            {
                std::vector<std::string> vec;
                vec.reserve(5);
                ccut::split(msg.second, ',', vec);
                if (vec.size() < 5)
                {
                    error(s_loggerCat) << "invalid OPT in BuildInfo: " << line;
                    return false;
                }
                buildInfo.options = vec[0];
                buildInfo.motionBufferSize = std::stoul(vec[1]);
                buildInfo.charBufferSize = std::stoul(vec[2]);
                buildInfo.axisCount = std::stoul(vec[3]);
                buildInfo.toolsCount = std::stoul(vec[4]);
                return true;
            }
            else if (msg.first == "VER")
                buildInfo.version = msg.second;
            else if (msg.first == "FIRMWARE")
                buildInfo.firmware = msg.second;
            else if (msg.first == "DRIVER")
                buildInfo.driver = msg.second;
            else if (msg.first == "DRIVER VERSION")
                buildInfo.driverVersion = msg.second;
            else
            {
                info(s_loggerCat) << "Not a build info: " << line;
                return false;
            }
            return true;
        }
        return false;
    }
    catch (const std::exception &ex)
    {
        error(s_loggerCat) << "exception parsing buildInfo: " << ex.what();
    }
    return false;
}
 
bool GrblParser::parseSettingGroup(const std::string &line, SettingGroup &group)
{
    if (getLineType(line) != LineType::Message)
        return false;
 
    try
    {
        grbl::GrblParser::Message msg;
        if ((!grbl::GrblParser::parseMessage(line, msg)) ||
            (msg.first != "SETTINGGROUP"))
            return false;
 
        std::vector<std::string> vec;
        vec.reserve(3);
        ccut::split(msg.second, '|', vec);
 
        if (vec.size() < 3)
        {
            error(s_loggerCat) << "invalid SETTINGGROUP: " << line;
        }
 
        group.id = std::stoul(vec[0]);
        group.parentId = std::stoul(vec[1]);
        group.name = vec[2];
 
        return true;
    }
    catch (const std::exception &ex)
    {
        error(s_loggerCat) << "exception parsing SettingGroup" << ex.what();
    }
    return false;
}
 
bool GrblParser::parseSettingDesc(const std::string &line, SettingDesc &desc)
{
    if (getLineType(line) != LineType::Message)
        return false;
 
    try
    {
        grbl::GrblParser::Message msg;
        if ((!grbl::GrblParser::parseMessage(line, msg)) ||
            (msg.first != "SETTING"))
            return false;
 
        std::vector<std::string> vec;
        vec.reserve(8);
        ccut::split(msg.second, '|', vec);
 
        if (vec.size() < 8)
        {
            error(s_loggerCat) << "invalid SETTING: " << line;
        }
 
        desc.id = std::stoul(vec[0]);
        desc.groupId = std::stoul(vec[1]);
        desc.name = vec[2];
        desc.unit = vec[3];
        desc.datatype = std::stoul(vec[4]);
        desc.format = vec[5];
 
        desc.min = vec[6].empty() ? NAN : std::stof(vec[6]);
        desc.max = vec[7].empty() ? NAN : std::stof(vec[7]);
 
        return true;
    }
    catch (const std::exception &ex)
    {
        error(s_loggerCat) << "exception parsing SettingDesc: " << ex.what();
    }
    return false;
}
 
bool GrblParser::parsePinInfo(const std::string &line, PinInfo &info)
{
    if (getLineType(line) != LineType::Message)
        return false;
 
    try
    {
        grbl::GrblParser::Message msg;
        if ((!grbl::GrblParser::parseMessage(line, msg)) || (msg.first != "PIN"))
            return false;
 
        std::vector<std::string> vec;
        vec.reserve(3);
        ccut::split(msg.second, ',', vec);
 
        if (vec.size() < 2)
        {
            error(s_loggerCat) << "invalid PinInfo (size): " << line;
            return false;
        }
 
        std::string::const_iterator it = std::find_if(vec[0].cbegin(),
                                                      vec[0].cend(), isdigit);
        if (it == vec[0].cbegin())
        {
            info.pin = std::stoul(vec[0]);
            info.port = std::string();
        }
        else if (it != vec[0].cend())
        {
            info.port = std::string(vec[0].cbegin(), it);
            info.pin = std::stoul(std::string(it, vec[0].cend()));
        }
        else
        {
            error(s_loggerCat) << "invalid PinInfo (pin number): " << line;
            return false;
        }
        info.function = vec[1];
        info.description = (vec.size() > 2) ? vec[2] : std::string();
 
        return true;
    }
    catch (const std::exception &ex)
    {
        error(s_loggerCat) << "exception parsing PinInfo: " << ex.what();
    }
    return false;
}
 
} // namespace grbl