GrblGenerator.hpp

/*
** 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-16T09:29:28+01:00
**     Author: Sylvain Fargier <fargie_s> <sylvain.fargier@cern.ch>
**
*/
 
#ifndef GRBLGENERATOR_HPP__
#define GRBLGENERATOR_HPP__
 
#include <cstdint>
#include <map>
#include <memory>
 
#include <ccut/BitMask.hpp>
 
#include "GrblTypes.hpp"
 
/*
 * groups and structure taken from grblHAL core gcode.h
 */
 
namespace logger {
class Logger;
}
 
namespace grbl {
namespace gen {
 
enum class ModalGroup
{
    NonModal = 0,           // G0 {G4,G10,G28,G28.1,G30,G30.1,G53,G92,G92.1}
    MotionMode = 1,         // G1 {G0,G1,G2,G3,G38.2,G80}
    PlaneSelect = 2,        // G2 {G17,G18,G19}
    DistanceMode = 3,       // G3 {G90,G91}
    ArcIJKDistanceMode = 4, // G4 {G91.1}
    FeedRateMode = 5,       // G5 {G93,G94,G95}
    Units = 6,              // G6 {G20,G21}
    CutterRadiusCompensation = 7, // G7 {G40}
    ToolLengthOffset = 8,         // G8 {G43,G43.1,G49}
    CCRetractMode = 10,           // G10 {G98,G99}
    Scaling = 11,                 // G11 {G50,G51}
    CoordinateSystem = 12,        // G12 {G54,G55,G56,G57,G58,G59}
    ControlMode = 13,             // G13 {G61}
    SpindleSpeedMode = 14,        // G14 {G96,G97}
    LatheDiameterMode = 15,       // G16 {G7,G8}
 
    ProgramFlow = 104,    // M4 {M0,M1,M2,M30}
    ToolChange = 106,     // M6
    SpindleTurning = 107, // M7 {M3,M4,M5}
    CoolantControl = 108, // M8 {M7,M8,M9}
    Override = 109,       // M9 {M49,M50,M51,M53,M56}
    DigitalOut = 110,     // M10 {M62, M63, M64, M65}
};
std::string to_string(ModalGroup group);
 
struct Modal
{
    typedef uint8_t GroupId;
 
    ModalGroup group;
    std::string value;
};
const logger::Logger &operator<<(const logger::Logger &, const Modal &);
 
struct NonModal
{
    static constexpr ModalGroup modalGroup = ModalGroup::NonModal;
 
    static const Modal Dwell;
 
    static Modal SetCoordinate(int8_t system = -1, bool current = false);
 
    static Modal GoHome(uint8_t index = 0);
 
    static Modal SetHome(uint8_t index = 0);
    static const Modal AbsoluteOverride;
    static const Modal SetCoordinateOffset;
    static const Modal ResetCoordinateOffset;
    static const Modal ClearCoordinateOffset;
    static const Modal RestoreCoordinateOffset;
};
 
struct DistanceMode
{
    static constexpr ModalGroup modalGroup = ModalGroup::DistanceMode;
    static const Modal Relative;
    static const Modal Absolute;
};
 
struct MotionMode
{
    static constexpr ModalGroup modalGroup = ModalGroup::MotionMode;
    static const Modal Rapid;
    static const Modal Linear;
};
 
struct DigitalOut
{
    static constexpr ModalGroup modalGroup = ModalGroup::DigitalOut;
    static Modal on(uint8_t port, bool immediate = false);
    static Modal off(uint8_t port, bool immediate = false);
};
 
struct CoordinateSystem
{
    static constexpr ModalGroup modalGroup = ModalGroup::CoordinateSystem;
    static Modal set(uint8_t system);
};
 
struct Position
{
    grbl::Axis axis;
    grbl_float_t value;
};
const logger::Logger &operator<<(const logger::Logger &, const Position &);
 
struct System
{
    static const std::string ParserState;        // $G
    static const std::string Jog;                // $J
    static const std::string NGCParams;          // $#
    static const std::string Settings;           // $$
    static const std::string AllSettings;        // $+
    static const std::string ToggleBlockDelete;  // $B
    static const std::string ToggleSingleBlock;  // $S
    static const std::string ToggleOptionalStop; // $O
    static const std::string CheckMode;          // $C
    static const std::string DisableLock;        // $X
    static const std::string Home;               // $H $HX $HY $HZ $HA $HB $HC
    static const std::string Help;               // $HELP
    static const std::string Sleep;              // $SLP
    static const std::string SetToolReference;   // $TLR
    static const std::string ToolProbeWorkpiece; // $TLR
    static const std::string BuildInfo;          // $I
    static const std::string AllBuildInfo;       // $I+
    static const std::string SettingsReset;      // $RST
    static const std::string StartupLines;       // $N $N0 $N1
    static const std::string EnumerateAlarms;    // $EQ
    static const std::string EnumerateErrors;    // $EE
    static const std::string EnumerateGroups;    // $EG
    static const std::string EnumerateSettings;  // $ES
    static const std::string EnumerateAll;       // $E*
    static const std::string EnumeratePins;      // $PINS
    static const std::string ReportLastSignalsEvent;  // $LEV
    static const std::string ReportCurrentLimitState; // $LIM
    static const std::string ReportSpindleData;       // $SD
    static const std::string SpindleResetData;        // $SR
 
    static inline std::string getSetting(SettingId settingId)
    {
        return "$" + std::to_string(settingId);
    }
 
    static std::string setSetting(SettingId settingId, const std::string &value);
};
 
struct Realtime
{
    static const std::string Reset;        // 0x18 (ctrl-X)
    static const std::string CycleStart;   // 0x81 (ctrl-F)
    static const std::string FeedHold;     // 0x82 (ctrl-Y)
    static const std::string StatusReport; // ?
};
 
struct Setting
{
    enum class HomingCycleBit : uint8_t
    {
        Enable = 0x01,
        SingleAxisCommands = 0x02,
        InitLock = 0x04,
        ForceSetOrigin = 0x08,
 
        Manual = 0x20,
        OverrideLocks = 0x40,
        KeepOnReset = 0x80
    };
 
    enum class StatusReportBit : uint16_t
    {
        MachinePosition = 0x01,
        BufferState = 0x02,
        LineNumbers = 0x04,
        FeedSpeed = 0x08,
        PinState = 0x10,
        WorkCoordOffset = 0x20,
        Overrides = 0x40,
        ProbeCoordinates = 0x80,
        SyncOnWCOChange = 0x100,
        ParserState = 0x200,
        AlarmSubState = 0x400,
        RunSubState = 0x800
    };
};
 
} // namespace gen
 
struct GeneratorData;
 
class Generator
{
public:
    Generator();
    Generator(const Generator &) = default;
 
    std::string str() const;
    bool fail() const;
 
    const std::string &errorString() const;
 
    const Generator &operator<<(const gen::Modal &modal) const;
    const Generator &operator<<(const gen::Position &position) const;
 
protected:
    std::shared_ptr<GeneratorData> m_data;
};
 
} // namespace grbl
 
template<>
struct ccut_enable_bitmask<grbl::gen::Setting::StatusReportBit> : std::true_type
{};
 
#endif