MGrblPlatform_Base.cpp

/*
 * 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-07-13
 *     Author: Michal Mysior <mmysior> <michal.mysior@cern.ch>
 *
 */
 
#include <memory>
#include <mutex>
#include <vector>
 
#include <ccut/async.hpp>
 
#include "MGrblAxis.hpp"
#include "MGrblGpio.hpp"
#include "MGrblMainTrigger.hpp"
#include "MGrblPlatform.hpp"
#include "MGrblPlatformDevice.hpp"
#include "device/DeviceBase.hpp"
 
namespace smc {
namespace internal {
 
PlatformBase::DeviceTypeList MGrblPlatform::getSupportedDevices() const
{
    return DeviceTypeList{DeviceType::AXIS, DeviceType::TRIGGER,
                          DeviceType::GPIO, DeviceType::PLATFORM};
}
 
PlatformBase::DeviceList MGrblPlatform::generateDevices(
    const DeviceTypeList &deviceType)
{
    DeviceList ret;
    std::vector<GrblPlatform::Shared> platforms{getPlatforms()};
 
    // cppcheck-suppress [knownConditionTrueFalse]
    if (platforms.empty())
        return ret;
 
    if (deviceType.count(DeviceType::AXIS))
    {
        DeviceList axes;
        for (const std::shared_ptr<GrblPlatform> &p : platforms)
        {
            /* override keep only last */
            axes = p->generateDevices(DeviceTypeList{DeviceType::AXIS});
        }
 
        for (auto &axis : axes)
        {
            ret.emplace_back(createAxis(axis->uid(), platforms.back()));
        }
    }
 
    if (deviceType.count(DeviceType::TRIGGER))
    {
        bool hasTriggers = false;
        for (size_t i = 0; i < platforms.size(); i++)
        {
            DeviceList triggers = platforms[i]->generateDevices(
                DeviceTypeList{DeviceType::TRIGGER});
            if (triggers.size() == 1)
            {
                const std::string platformUrl = triggers.front()->uid() + "/" +
                    std::to_string(i);
                ret.emplace_back(std::make_shared<MGrblTrigger>(
                    platformUrl, shared_from_this(), platforms[i]));
                {
                    std::lock_guard<std::mutex> guard{m_lock};
                    m_triggers[platformUrl] = i;
                }
                hasTriggers = true;
            }
        }
 
        if (hasTriggers)
        {
            ret.emplace_back(std::make_shared<MGrblMainTrigger>(
                m_mainTriggerUrl, shared_from_this()));
        }
    }
    if (deviceType.count(DeviceType::GPIO))
    {
        for (size_t i = 0; i < platforms.size(); i++)
        {
            DeviceList gpios = platforms[i]->generateDevices(
                DeviceTypeList{DeviceType::GPIO});
 
            // Check for Pause/Resume
            decltype(gpios)::const_iterator it = std::find_if(
                gpios.begin(), gpios.end(), [](DeviceBase::Shared d) {
                    return (d->uid().find("pauseResume") != std::string::npos);
                });
            if (it != gpios.end())
            {
                const std::string platformUrl = (*it)->uid() + "/" +
                    std::to_string(i);
                ret.emplace_back(std::make_shared<MGrblGpio>(
                    platformUrl, shared_from_this(), platforms[i]));
                {
                    std::lock_guard<std::mutex> guard{m_lock};
                    m_gpios[platformUrl] = i;
                }
            }
        }
    }
    if (deviceType.count(DeviceType::PLATFORM))
    {
        ret.emplace_back(std::make_shared<MGrblPlatformDevice>(
            m_ctx->prefix + m_ctx->id + "/platform", shared_from_this(),
            platforms.front()));
    }
    return ret;
}
 
void MGrblPlatform::setNotificationWorker(
    const NotificationWorker::Shared &worker)
{
    PlatformBase::setNotificationWorker(worker);
    for (const std::shared_ptr<GrblPlatform> &p : getPlatforms())
        p->setNotificationWorker(worker);
}
 
} // namespace internal
} // namespace smc