GrblParser.hpp

/*
 * 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-17
 *     Author: Michal Mysior <mmysior> <michal.mysior@cern.ch>
 *
 * @todo Make command generation stream-oriented, expand commands to allow for
 * multi-motor movements.
 *
 */
 
#ifndef GRBL_PARSER_HPP__
#define GRBL_PARSER_HPP__
 
#include <cstdint>
#include <map>
#include <string>
#include <vector>
 
#include "../../Units.hpp"
#include "GrblTypes.hpp"
 
namespace grbl {
class GrblParser
{
public:
    typedef grbl::LineType LineType;
    typedef std::pair<std::string, std::string> Message;
    typedef std::pair<int, std::string> Setting;
 
    static LineType getLineType(const std::string &line);
 
    static bool parseMessage(const std::string &line, Message &message);
 
    static bool parseSetting(const std::string &line, Setting &setting);
 
    static bool parseErrorReply(const std::string &line,
                                grbl::ErrorCode &errorCode);
 
    struct State
    {
        grbl::RunState runState = RunState::Unknown;
 
        std::map<Axis, grbl_float_t> motorPositions;
 
        size_t runStateArg = 0;
        size_t motionBufferFree = 0;
        size_t charBufferFree = 0;
        size_t line = 0;
 
        State() = default;
        State(grbl::RunState rs,
              const std::map<Axis, grbl_float_t> &mp,
              size_t rsa,
              size_t mbf,
              size_t cbf,
              size_t l) :
            runState(rs),
            motorPositions(mp),
            runStateArg(rsa),
            motionBufferFree(mbf),
            charBufferFree(cbf),
            line(l)
        {}
    };
 
    static bool parseState(const std::string &line, State &state);
 
    struct BuildInfo
    {
        std::string version;
        std::string options; // FIXME: parse options and newopt
        std::string firmware;
        std::string driver;
        std::string driverVersion;
 
        size_t motionBufferSize;
        size_t charBufferSize;
        size_t axisCount;
        size_t toolsCount;
    };
 
    static bool parseBuildInfo(const std::string &line, BuildInfo &info);
 
    struct SettingGroup
    {
        int id;
        int parentId;
        std::string name;
    };
 
    static bool parseSettingGroup(const std::string &line, SettingGroup &group);
 
    struct SettingDesc
    {
        SettingId id;
        int groupId;
        std::string name;
        std::string unit;
        int datatype;
        std::string format;
        float min;
        float max;
    };
 
    static bool parseSettingDesc(const std::string &line, SettingDesc &desc);
 
    struct PinInfo
    {
        uint8_t pin;
        std::string function;
        std::string description;
        std::string port;
    };
 
    static bool parsePinInfo(const std::string &line, PinInfo &info);
 
    template<typename C>
    static bool parsePinInfo(const std::string &line, C &c)
    {
        PinInfo p;
        if (parsePinInfo(line, p))
        {
            c.push_back(p);
            return true;
        }
        return false;
    }
};
 
} // namespace grbl
 
#endif /* GRBL_PARSER_HPP__ */