epics_metric.cc

// epics_metric.cc: Epics Metric Plugin
// Author: Eric Flumerfelt
// Last Modified: 09/25/2015
//
// An implementation of the MetricPlugin interface for Epics/ChannelAccess

#ifndef __EPICS_METRIC__
#define __EPICS_METRIC__ 1

#include <unordered_map>
#include "artdaq-utilities/Plugins/MetricMacros.hh"
#include "messagefacility/MessageLogger/MessageLogger.h"
#undef STATIC_ASSERT

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
#endif
#include <cadef.h>
#ifdef __clang__
#pragma clang diagnostic pop
#endif

namespace artdaq {
class EpicsMetric : public MetricPlugin
{
private:
    std::string prefix_;
    std::unordered_map<std::string, chid> channels_;

    bool checkChannel_(std::string name)
    {
        if (!channels_.count(name))
        {
            chid channel;
            ca_search(name.c_str(), &channel);
            auto sts = ca_pend_io(5.0);
            if (sts != ECA_NORMAL)
            {
                SEVCHK(ca_clear_channel(channel), NULL);
                mf::LogWarning("EPICS Plugin") << "Channel " << name << " not found!";
                channels_[name] = nullptr;
                return false;
            }
            channels_[name] = channel;
            return true;
        }
        return channels_[name] != nullptr;
    }

public:
    explicit EpicsMetric(fhicl::ParameterSet const& pset, std::string const& app_name)
        : MetricPlugin(pset, app_name), prefix_(pset.get<std::string>("channel_name_prefix", "artdaq")), channels_() {}

    virtual ~EpicsMetric() { MetricPlugin::stopMetrics(); }

    std::string getLibName() const override { return "epics"; }

    void stopMetrics_() override
    {
        for (auto channel : channels_)
        {
            SEVCHK(ca_clear_channel(channel.second), NULL);
        }
        channels_.clear();
    }

    void startMetrics_() override {}

    void sendMetric_(const std::string& name, const std::string& value, const std::string& unit) override
    {
        std::string caName = prefix_ + ":" + name;
        std::string tmpValue = value + " " + unit;

        if (checkChannel_(caName))
        {
            // DBR_STRING, 40 characters
            if (tmpValue.size() > 40)
            {
                tmpValue = tmpValue.erase(40);
            }
            SEVCHK(ca_put(DBR_STRING, channels_[caName], tmpValue.c_str()), NULL);
            SEVCHK(ca_flush_io(), NULL);
        }
    }

    void sendMetric_(const std::string& name, const int& value, const std::string& unit) override
    {
        // DBR_LONG
        std::string caName = prefix_ + ":" + name;
        if (unit.size() > 0)
        {
            mf::LogDebug("EPICS Plugin") << "Not sure if I can send ChannelAccess Units...configure in db instead.";
        }

        if (checkChannel_(caName))
        {
            dbr_long_t val = static_cast<dbr_long_t>(value);
            SEVCHK(ca_put(DBR_LONG, channels_[caName], &val), NULL);
            SEVCHK(ca_flush_io(), NULL);
        }
    }

    void sendMetric_(const std::string& name, const double& value, const std::string& unit) override
    {
        // DBR_DOUBLE
        std::string caName = prefix_ + ":" + name;
        if (unit.size() > 0)
        {
            mf::LogDebug("EPICS Plugin") << "Not sure if I can send ChannelAccess Units...configure in db instead.";
        }

        if (checkChannel_(caName))
        {
            dbr_double_t val = static_cast<dbr_double_t>(value);
            SEVCHK(ca_put(DBR_DOUBLE, channels_[caName], &val), NULL);
            SEVCHK(ca_flush_io(), NULL);
        }
    }

    void sendMetric_(const std::string& name, const float& value, const std::string& unit) override
    {
        // DBR_FLOAT
        std::string caName = prefix_ + ":" + name;
        if (unit.size() > 0)
        {
            mf::LogDebug("EPICS Plugin") << "Not sure if I can send ChannelAccess Units...configure in db instead.";
        }

        if (checkChannel_(caName))
        {
            dbr_float_t val = static_cast<dbr_float_t>(value);
            SEVCHK(ca_put(DBR_FLOAT, channels_[caName], &val), NULL);
            SEVCHK(ca_flush_io(), NULL);
        }
    }

    void sendMetric_(const std::string& name, const unsigned long int& value, const std::string& unit) override
    {
        // DBR_LONG, only unsigned type is only 16 bits, use widest integral field
        std::string caName = prefix_ + ":" + name;
        if (unit.size() > 0)
        {
            mf::LogDebug("EPICS Plugin") << "Not sure if I can send ChannelAccess Units...configure in db instead.";
        }

        if (checkChannel_(caName))
        {
            dbr_ulong_t val = static_cast<dbr_ulong_t>(value);
            SEVCHK(ca_put(DBR_LONG, channels_[caName], &val), NULL);
            SEVCHK(ca_flush_io(), NULL);
        }
    }
};
}  // End namespace artdaq

DEFINE_ARTDAQ_METRIC(artdaq::EpicsMetric)

#endif  // End ifndef __EPICS_METRIC__