MGrblPlatform.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-04-28T14:19:16+02:00
**     Author: Sylvain Fargier <sfargier> <sylvain.fargier@cern.ch>
**
*/
 
#ifndef MGRBL_PLATFORM_HPP__
#define MGRBL_PLATFORM_HPP__
 
#include <future>
#include <memory>
#include <string>
 
#include <ccut/Queue.hpp>
#include <ccut/Thread.hpp>
#include <ccut/yml.hpp>
 
#include "MGrblAxis.hpp"
#include "MGrblGpio.hpp"
#include "MGrblTrigger.hpp"
#include "platform/PlatformBase.hpp"
#include "platform/specialized/GrblPlatform/GrblPlatform.hpp"
#include "util/grbl/MGrblParser.hpp"
 
namespace smc {
 
class Axis;
 
namespace internal {
class MGrblPlatform : public PlatformBase, public ccut::Thread
{
public:
    typedef std::shared_ptr<MGrblPlatform> Shared;
 
    struct Context;
    struct ImmediateCmd;
 
    static inline PlatformBase::Shared create(const ccut::yml::NodeRef &config)
    {
        return PlatformBase::Shared(new MGrblPlatform(config));
    }
 
    virtual ~MGrblPlatform();
 
    inline std::shared_ptr<MGrblPlatform> shared_from_this()
    {
        return std::static_pointer_cast<MGrblPlatform>(
            PlatformBase::shared_from_this());
    }
 
    inline std::shared_ptr<const MGrblPlatform> shared_from_this() const
    {
        return std::static_pointer_cast<const MGrblPlatform>(
            PlatformBase::shared_from_this());
    }
 
    /* PlatformBase */
    DeviceTypeList getSupportedDevices() const override;
    DeviceList generateDevices(const DeviceTypeList &deviceType) override;
    void setNotificationWorker(const NotificationWorker::Shared &worker) override;
 
    std::future<mgrbl::Layout> getLayout();
 
    void stop() override;
    void wake() override;
 
    void updateInstance(MGrblGpio &gpio) const;
 
    void updateInstance(MGrblAxis &axis) const;
 
    void updateInstance(MGrblTrigger &trigger) const;
 
    inline const std::string &mainTriggerUrl() const
    {
        return m_mainTriggerUrl;
    }
 
    std::shared_ptr<GrblPlatform> getFirstInstance() const;
 
    inline std::shared_ptr<GrblPlatform> getInstance(
        mgrbl::Instance instance) const
    {
        std::lock_guard<std::mutex> guard(m_lock);
        if (instance >= m_platforms.size())
            throw Exception(ErrorCode::InternalError,
                            "axis not bound to an instance");
        else
            return m_platforms[instance];
    }
 
    void runOnInstance(Context &ctx,
                       std::function<void(GrblPlatform::Shared &platform,
                                          GrblPlatform::Context &ctx)> fun,
                       bool onlyFirst = false) const;
 
    template<typename T>
    std::future<T> run(std::function<void(ImmediateCmd &, Context &)> fun);
 
    void loadLayout(Context &ctx);
    void getBuildInfo(Context &ctx);
 
protected:
    explicit MGrblPlatform(const ccut::yml::NodeRef &node,
                           Context *data = nullptr);
 
    void processMessage(const std::string &message);
 
    virtual MGrblAxis::Shared createAxis(
        const std::string &uid,
        const std::shared_ptr<GrblPlatform> &grbl);
 
    void thread_func() override;
 
    virtual void processUpdate(Context &ctx);
    bool processImmediate(Context &ctx);
    void createPlatforms(Context &ctx);
    void clearQueue(const std::string &msg);
 
    inline std::vector<std::shared_ptr<GrblPlatform>> getPlatforms() const
    {
        std::lock_guard<std::mutex> guard(m_lock);
        return m_platforms;
    }
 
    std::unique_ptr<Context> m_ctx;
 
    mutable std::mutex m_lock;
    std::vector<std::shared_ptr<GrblPlatform>> m_platforms;
    std::map<std::string, std::size_t> m_triggers;
    std::map<std::string, std::size_t> m_gpios;
    const std::string m_mainTriggerUrl;
    mgrbl::Layout m_layout;
    ccut::Connection m_dataConn;
    std::queue<ImmediateCmd> m_immediate;
};
 
} // namespace internal
} // namespace smc
 
#include "MGrblPlatformData.hpp"
 
#endif