SubdeviceBackend.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
 
#include "DeviceBackendImpl.h"
#include "NumericAddressedRegisterCatalogue.h"
 
#include <mutex>
#include <string>
 
namespace ChimeraTK {
  class SubdeviceRegisterAccessor;
 
  class SubdeviceBackend : public DeviceBackendImpl {
   public:
    explicit SubdeviceBackend(std::map<std::string, std::string> parameters);
 
    void open() override;
 
    void close() override;
 
    std::string readDeviceInfo() override {
      return "Subdevice"; 
    }
 
    static boost::shared_ptr<DeviceBackend> createInstance(
        std::string address, std::map<std::string, std::string> parameters);
 
    RegisterCatalogue getRegisterCatalogue() const override;
 
    MetadataCatalogue getMetadataCatalogue() const override;
 
    std::set<DeviceBackend::BackendID> getInvolvedBackendIDs() override;
 
   protected:
    friend class SubdeviceRegisterAccessor;
 
    enum class Type {
      area,           //< address space is visible as an area in the target device
      threeRegisters, //< use three registers (address, data and status) in target
                      //< device. status must be 0 when idle
      twoRegisters,   //< same as three registers but without status
      areaHandshake   //< address space visible as an area in the target device, and wait on status 0
    };
 
    std::mutex mutex;
 
    Type type;
 
    size_t timeout{10000};
 
    std::string targetAlias;
 
    boost::shared_ptr<ChimeraTK::DeviceBackend> targetDevice;
 
    std::string targetArea;
 
    std::string targetAddress, targetData, targetControl;
 
    size_t sleepTime{100};
 
    size_t addressToDataDelay{0};
 
    NumericAddressedRegisterCatalogue _registerMap;
    MetadataCatalogue _metadataCatalogue;
 
    void verifyRegisterAccessorSize(const NumericAddressedRegisterInfo& info, size_t& numberOfWords,
        size_t wordOffsetInRegister, bool enforceAlignment);
 
    template<typename UserType>
    boost::shared_ptr<NDRegisterAccessor<UserType>> getRegisterAccessor_impl(
        const RegisterPath& registerPathName, size_t numberOfWords, size_t wordOffsetInRegister, AccessModeFlags flags);
    DEFINE_VIRTUAL_FUNCTION_TEMPLATE_VTABLE_FILLER(SubdeviceBackend, getRegisterAccessor_impl, 4);
 
    template<typename UserType>
    boost::shared_ptr<NDRegisterAccessor<UserType>> getRegisterAccessor_area(
        const RegisterPath& registerPathName, size_t numberOfWords, size_t wordOffsetInRegister, AccessModeFlags flags);
 
    template<typename UserType>
    boost::shared_ptr<NDRegisterAccessor<UserType>> getRegisterAccessor_synchronized(
        const RegisterPath& registerPathName, size_t numberOfWords, size_t wordOffsetInRegister,
        const AccessModeFlags& flags);
 
    void obtainTargetBackend();
 
    void setExceptionImpl() noexcept override;
 
    void activateAsyncRead() noexcept override;
 
    bool needAreaParam() { return type == Type::area || type == Type::areaHandshake; }
    bool needStatusParam() { return type == Type::threeRegisters || type == Type::areaHandshake; }
 
    // helper for reducing code duplication among template specializations
    boost::shared_ptr<SubdeviceRegisterAccessor> getRegisterAccessor_helper(const NumericAddressedRegisterInfo& info,
        size_t numberOfWords, size_t wordOffsetInRegister, AccessModeFlags flags);
  };
 
} // namespace ChimeraTK