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;
  template<typename RegisterRawType, typename WriteDataType>
  class SubdeviceRegisterWindowAccessor;
 
  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;
    template<typename RegisterRawType, typename WriteDataType>
    friend class SubdeviceRegisterWindowAccessor;
 
    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
      registerWindow  //< Universal interface which allows write, read and multiple chips. Includes 3reg, 2reg (not
                      //< 100 % compatible)
    };
 
    using BusyRegisterKey = std::pair<DeviceBackend*, RegisterPath>;
 
    static std::map<BusyRegisterKey, std::shared_ptr<std::mutex>> _mutexes;
    static std::mutex _mutexMapMutex; // a mutex to proptext insertions into the map with mutexes.
 
    std::shared_ptr<std::mutex> _mutex; // cache the mutex to avoid repeated lookup.
 
    Type _type;
 
    size_t _timeout{10000};
 
    std::string _targetAlias;
 
    boost::shared_ptr<ChimeraTK::DeviceBackend> _targetDevice;
 
    std::string _targetArea;
 
    std::string _targetAddress, _targetWriteData, _targetControl;
 
    std::map<std::string, std::string> _parameters;
 
    size_t _sleepTime{100};
 
    size_t _addressToDataDelay{0};
 
    size_t _chipIndex{0};
 
    NumericAddressedRegisterCatalogue _registerMap;
    MetadataCatalogue _metadataCatalogue;
 
    void verifyRegisterAccessorSize(const NumericAddressedRegisterInfo& info, size_t& numberOfWords,
        size_t wordOffsetInRegister, bool enforceAlignment);
 
    template<typename UserType>
    // NOLINTNEXTLINE(readability-identifier-naming)
    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>> getAreaRegisterAccessor(
        const RegisterPath& registerPathName, size_t numberOfWords, size_t wordOffsetInRegister, AccessModeFlags flags);
 
    template<typename UserType>
    boost::shared_ptr<NDRegisterAccessor<UserType>> getSynchronisedRegisterAccessor(
        const RegisterPath& registerPathName, size_t numberOfWords, size_t wordOffsetInRegister,
        const AccessModeFlags& flags);
 
    template<typename UserType>
    boost::shared_ptr<NDRegisterAccessor<UserType>> getRegisterWindowAccessor(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> accessorCreationHelper(const NumericAddressedRegisterInfo& info,
        size_t numberOfWords, size_t wordOffsetInRegister, AccessModeFlags flags);
  };
 
} // namespace ChimeraTK