GrblGenerator.cpp

/*
** Copyright (C) 2020 Sylvain Fargier
**
** 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-02-16T11:51:45+01:00
**     Author: Sylvain Fargier <fargie_s> <sylvain.fargier@cern.ch>
**
*/
 
#include "GrblGenerator.hpp"
 
#include <cmath>
#include <iomanip>
#include <ios>
#include <iostream>
#include <sstream>
 
#include <logger/Logger.hpp>
 
using namespace logger;
 
static const std::string s_loggerCat{"grbl:gen"};
 
namespace grbl {
 
namespace gen {
 
const Modal DistanceMode::Relative{DistanceMode::modalGroup, "G91"};
const Modal DistanceMode::Absolute{DistanceMode::modalGroup, "G90"};
 
const Modal MotionMode::Rapid{MotionMode::modalGroup, "G0"};
const Modal MotionMode::Linear{MotionMode::modalGroup, "G1"};
 
const Modal NonModal::Dwell{NonModal::modalGroup, "G4"};
const Modal NonModal::AbsoluteOverride{NonModal::modalGroup, "G53"};
const Modal NonModal::SetCoordinateOffset{NonModal::modalGroup, "G92"};
const Modal NonModal::ResetCoordinateOffset{NonModal::modalGroup, "G92.1"};
const Modal NonModal::ClearCoordinateOffset{NonModal::modalGroup, "G92.2"};
const Modal NonModal::RestoreCoordinateOffset{NonModal::modalGroup, "G92.3"};
 
Modal DigitalOut::on(uint8_t port, bool immediate)
{
    std::string val = "M" + std::string(immediate ? "64" : "62");
    val += "P" + std::to_string(port);
    return Modal{DigitalOut::modalGroup, val};
}
 
Modal DigitalOut::off(uint8_t port, bool immediate)
{
    std::string val = "M" + std::string(immediate ? "65" : "63");
    val += "P" + std::to_string(port);
    return Modal{DigitalOut::modalGroup, val};
}
 
Modal CoordinateSystem::set(uint8_t system)
{
    char out[]{'G', '5', '4', 0};
    if (system >= 54)
        out[2] += (system - 54);
    else
        out[2] += (system);
    return Modal{CoordinateSystem::modalGroup, out};
}
 
Modal NonModal::SetCoordinate(int8_t system, bool relative)
{
    char parg[]{'P', '0', 0};
    if (system >= 54)
        parg[1] += system - 54 + 1;
    else if (system >= 0)
        parg[1] += system + 1;
 
    const char *larg = relative ? "L20" : "L2";
 
    return Modal{NonModal::modalGroup, (std::string("G10") + larg) + parg};
}
 
Modal NonModal::GoHome(uint8_t index)
{
    return Modal{NonModal::modalGroup, (index == 0) ? "G28" : "G30"};
}
 
Modal NonModal::SetHome(uint8_t index)
{
    return Modal{NonModal::modalGroup, (index == 0) ? "G28.1" : "G30.1"};
}
 
const std::string Realtime::Reset = "\x18";
const std::string Realtime::CycleStart = "\x81";
const std::string Realtime::FeedHold = "\x82";
const std::string Realtime::StatusReport = "?";
const std::string System::ParserState = "$G";        // $G
const std::string System::Jog = "$J";                // $J
const std::string System::NGCParams = "$#";          // $#
const std::string System::Settings = "$$";           // $$
const std::string System::AllSettings = "$+";        // $+
const std::string System::ToggleBlockDelete = "$B";  // $B
const std::string System::ToggleSingleBlock = "$S";  // $S
const std::string System::ToggleOptionalStop = "$O"; // $O
const std::string System::CheckMode = "$C";          // $C
const std::string System::DisableLock = "$X";        // $X
const std::string System::Home = "$H";    // $H $HX $HY $HZ $HA $HB $HC
const std::string System::Help = "$HELP"; // $HELP
const std::string System::Sleep = "$SLP"; // $SLP
const std::string System::SetToolReference = "$TLR";        // $TLR
const std::string System::ToolProbeWorkpiece = "$TLR";      // $TLR
const std::string System::BuildInfo = "$I";                 // $I
const std::string System::AllBuildInfo = "$I+";             // $I+
const std::string System::SettingsReset = "$RST";           // $RST
const std::string System::StartupLines = "$N";              // $N $N0 $N1
const std::string System::EnumerateAlarms = "$EA";          // $EA
const std::string System::EnumerateErrors = "$EE";          // $EE
const std::string System::EnumerateGroups = "$EG";          // $EG
const std::string System::EnumerateSettings = "$ES";        // $ES
const std::string System::EnumerateAll = "$E*";             // $E*
const std::string System::EnumeratePins = "$PINS";          // $PINS
const std::string System::ReportLastSignalsEvent = "$LEV";  // $LEV
const std::string System::ReportCurrentLimitState = "$LIM"; // $LIM
const std::string System::ReportSpindleData = "$SD";        // $SD
const std::string System::SpindleResetData = "$SR";         // $SR
 
const Logger &operator<<(const Logger &logger, const Modal &modal)
{
    if (logger.isEnabled())
    {
        logger << "Modal(" << modal.group << ", " << modal.value << ")";
    }
    return logger;
}
const Logger &operator<<(const Logger &logger, const Position &pos)
{
    if (logger.isEnabled())
    {
        logger << "Position(" << pos.axis << std::fixed << std::setprecision(3)
               << pos.value << logger::clearflags << ")";
    }
    return logger;
}
std::string to_string(ModalGroup group)
{
    switch (group)
    {
    case ModalGroup::NonModal: return "NonModal";
    case ModalGroup::MotionMode: return "MotionMode";
    case ModalGroup::PlaneSelect: return "PlaneSelect";
    case ModalGroup::DistanceMode: return "DistanceMode";
    case ModalGroup::ArcIJKDistanceMode: return "ArcIJKDistanceMode";
    case ModalGroup::FeedRateMode: return "FeedRateMode";
    case ModalGroup::Units: return "Units";
    case ModalGroup::CutterRadiusCompensation:
        return "CutterRadiusCompensation";
    case ModalGroup::ToolLengthOffset: return "ToolLengthOffset";
    case ModalGroup::CCRetractMode: return "CCRetractMode";
    case ModalGroup::Scaling: return "Scaling";
    case ModalGroup::CoordinateSystem: return "CoordinateSystem";
    case ModalGroup::ControlMode: return "ControlMode";
    case ModalGroup::SpindleSpeedMode: return "SpindleSpeedMode";
    case ModalGroup::LatheDiameterMode: return "LatheDiameterMode";
 
    case ModalGroup::ProgramFlow: return "ProgramFlow";
    case ModalGroup::ToolChange: return "ToolChange";
    case ModalGroup::SpindleTurning: return "SpindleTurning";
    case ModalGroup::CoolantControl: return "CoolantControl";
    case ModalGroup::Override: return "Override";
    case ModalGroup::DigitalOut: return "DigitalOut";
    default: return "Unknown";
    }
}
 
std::string System::setSetting(SettingId settingId, const std::string &value)
{
    std::ostringstream ss;
    ss << "$" << settingId << "=" << value;
    return ss.str();
}
 
} // namespace gen
 
struct GeneratorData
{
    typedef std::map<grbl::Axis, grbl_float_t> PositionsMap;
    typedef std::map<gen::ModalGroup, std::string> ModalsMap;
 
    PositionsMap positions;
    ModalsMap modals;
    std::string errorString;
};
 
Generator::Generator() : m_data(new GeneratorData) {}
 
std::string Generator::str() const
{
    if (!m_data->errorString.empty())
        return std::string();
 
    std::ostringstream oss;
    for (const GeneratorData::ModalsMap::value_type &it : m_data->modals)
        oss << it.second;
 
    oss << std::fixed << std::setprecision(3);
 
    for (const GeneratorData::PositionsMap::value_type &it : m_data->positions)
        oss << to_string(it.first) << it.second;
 
    return oss.str();
}
 
bool Generator::fail() const
{
    return !m_data->errorString.empty();
}
 
const std::string &Generator::errorString() const
{
    return m_data->errorString;
}
 
const Generator &Generator::operator<<(const gen::Modal &modal) const
{
    if (!fail())
    {
        // debug(s_loggerCat) << " << " << modal;
        GeneratorData &data = *m_data;
        GeneratorData::ModalsMap::const_iterator it = data.modals.find(
            modal.group);
        if (it == data.modals.cend())
            data.modals[modal.group] = modal.value;
        else if (it->second != modal.value)
        {
            data.errorString = "modal command conflict: " + it->second +
                " and " + modal.value;
            error(s_loggerCat) << data.errorString;
        }
    }
    return *this;
}
 
const Generator &Generator::operator<<(const gen::Position &pos) const
{
    if (!fail())
    {
        // debug(s_loggerCat) << " << " << pos;
        GeneratorData &data = *m_data;
        GeneratorData::PositionsMap::iterator it = data.positions.find(pos.axis);
        if (it == data.positions.cend())
            data.positions[pos.axis] = pos.value;
        else if (fabs(it->second - pos.value) >=
                 0.001) // take in account grbl precision
        {
            std::ostringstream oss;
            oss << "position conflict on " << to_string(it->first)
                << " axis: " << std::fixed << std::setprecision(3) << it->second
                << " and " << pos.value;
 
            data.errorString = oss.str();
            error(s_loggerCat) << data.errorString;
        }
        else
        {
            it->second = pos.value;
        }
    }
    return *this;
}
 
} // namespace grbl