GrblPlatform.hpp

/*
** Copyright (C) 2021 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-02-10T18:13:51+01:00
**     Author: Sylvain Fargier <sfargier> <sylvain.fargier@cern.ch>
**
*/
 
#ifndef GRBL_PLATFORM_HPP__
#define GRBL_PLATFORM_HPP__
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
 
#include <queue>
 
#include <ccut/Queue.hpp>
#include <ccut/Thread.hpp>
#include <ccut/yml.hpp>
 
#include "GrblAxis.hpp"
#include "GrblGpio.hpp"
#include "GrblTrigger.hpp"
#include "platform/PlatformBase.hpp"
#include "util/grbl/GrblParser.hpp"
#include "util/grbl/GrblTypes.hpp"
 
namespace grbl {
class GrblDeviceBase;
}
 
namespace smc {
namespace internal {
class MGrblPlatform;
class MFEPlatform;
 
class GrblPlatform : public PlatformBase, public ccut::Thread
{
public:
    typedef std::shared_ptr<GrblPlatform> Shared;
 
    typedef std::size_t Line;
    struct LocalSettingHandler;
 
    typedef std::map<std::string, LocalSettingHandler> LocalSettingMap;
 
    struct AxisData;
 
    typedef std::map<std::string, grbl::GrblParser::SettingDesc> SettingMap;
 
    struct Context;
    struct ImmediateCmd;
    struct MotionCmd;
 
    static inline PlatformBase::Shared create(const ccut::yml::NodeRef &config)
    {
        return PlatformBase::Shared(new GrblPlatform(config));
    }
 
    virtual ~GrblPlatform();
 
    inline std::shared_ptr<GrblPlatform> shared_from_this()
    {
        return std::static_pointer_cast<GrblPlatform>(
            PlatformBase::shared_from_this());
    }
 
    inline std::shared_ptr<const GrblPlatform> shared_from_this() const
    {
        return std::static_pointer_cast<const GrblPlatform>(
            PlatformBase::shared_from_this());
    }
 
    /* PlatformBase */
    DeviceTypeList getSupportedDevices() const override;
    DeviceList generateDevices(const DeviceTypeList &deviceType) override;
 
    void stop() override;
    void wake() override;
 
    static const std::chrono::milliseconds defaultInterval;
 
    std::future<void> queue(MotionCmd &&);
    template<typename T>
    std::future<T> run(std::function<void(ImmediateCmd &, Context &)> fun);
 
    std::future<void> send(const std::string &cmd,
                           std::function<bool(const std::string &)> msg = {},
                           const std::chrono::milliseconds &timeout =
                               std::chrono::milliseconds{1000});
 
    void updateAxisSetting(const std::string &axis,
                           grbl::SettingId settingId,
                           const std::string &value);
    units::Value getLastAxisPosition(const std::string &axis) const;
    units::Value getLastAxisResolution(const std::string &axis) const;
 
    uint8_t getTrigger(const std::string &uid);
    uint8_t getGpio(const std::string &uid);
    grbl::Axis getAxis(const std::string &uid);
    void clearQueues(const std::string &msg, bool clearImmediates = true);
 
    static const std::string s_loggerCat;
 
protected:
    friend class MGrblPlatform;
    friend class MFEPlatform;
    explicit GrblPlatform(const ccut::yml::NodeRef &node);
 
    AxisData &_getAxisData(const std::string &uid);
 
    mutable std::mutex m_lock;
    std::queue<MotionCmd> m_queue;
    std::queue<ImmediateCmd> m_immediate;
    std::queue<MotionCmd> m_pending;
    std::map<std::string, AxisData> m_axisMap;
    std::pair<std::string, uint8_t> m_trigger;
    std::map<std::string, uint8_t> m_gpioMap;
    ccut::Connection m_dataConn;
 
    std::unique_ptr<Context> m_ctx;
 
    explicit GrblPlatform(const std::string &prefix,
                          const std::string &id,
                          std::unique_ptr<grbl::GrblDeviceBase> &&device);
 
    /* those methods are called from `thread_func` and may access `m_ctx`  */
    void processMessage(const std::string &message);
    bool processMotion();
    bool processImmediate();
    void onStateMessage();
    void loadErrors();
    void loadAlarms();
    void loadSettingsDesc();
    void setup();
    void handleAlarm();
 
    void generateGpios(const Context &ctx,
                       const std::list<grbl::GrblParser::PinInfo> &pins,
                       std::list<GrblGpio::Shared> &out);
    void generateTriggers(Context &ctx,
                          const std::list<grbl::GrblParser::PinInfo> &pins,
                          std::list<GrblTrigger::Shared> &out);
    void generateAxes(const Context &ctx,
                      size_t axesCount,
                      std::list<GrblAxis::Shared> &out);
 
    void thread_func() override;
 
    static constexpr std::size_t maxQueueSize = 1024;
};
 
} // namespace internal
} // namespace smc
 
#include "GrblPlatform.hxx"
 
#endif