cadc.h

Go to the documentation of this file.

#pragma once
#include "halco/common/geometry.h"
#include "halco/hicann-dls/vx/cadc.h"
#include "haldls/cerealization.h"
#include "haldls/vx/genpybind.h"
#include "haldls/vx/sram_controller.h"
#include "haldls/vx/traits.h"
#include "hate/visibility.h"
 
#ifndef __ppu__
#include "hxcomm/vx/target.h"
#endif
 
namespace fisch::vx {
class Omnibus;
class OmnibusChipOverJTAG;
} // namespace fisch::vx
 
namespace halco::hicann_dls::vx {
class OmnibusAddress;
} // namespace halco::hicann_dls::vx
 
namespace haldls {
namespace vx GENPYBIND_TAG_HALDLS_VX {
 
class GENPYBIND(visible) CADCConfig
{
public:
    typedef std::true_type is_leaf_node;
    typedef halco::hicann_dls::vx::CADCConfigOnDLS coordinate_type;
 
    struct GENPYBIND(inline_base("*")) ResetWait
        : public halco::common::detail::RantWrapper<ResetWait, uint_fast16_t, 255, 0>
    {
        constexpr explicit ResetWait(uintmax_t const val = 100) GENPYBIND(implicit_conversion) :
            rant_t(val)
        {}
    };
 
    struct GENPYBIND(inline_base("*")) DeadTime
        : public halco::common::detail::RantWrapper<DeadTime, uint_fast16_t, 255, 0>
    {
        constexpr explicit DeadTime(uintmax_t const val = 20) GENPYBIND(implicit_conversion) :
            rant_t(val)
        {}
    };
 
    CADCConfig() SYMBOL_VISIBLE;
 
    GENPYBIND(getter_for(enable))
    bool get_enable() const SYMBOL_VISIBLE;
 
    GENPYBIND(setter_for(enable))
    void set_enable(bool value) SYMBOL_VISIBLE;
 
    GENPYBIND(getter_for(reset_wait))
    ResetWait get_reset_wait() const SYMBOL_VISIBLE;
 
    GENPYBIND(setter_for(reset_wait))
    void set_reset_wait(ResetWait value) SYMBOL_VISIBLE;
 
    GENPYBIND(getter_for(dead_time))
    DeadTime get_dead_time() const SYMBOL_VISIBLE;
 
    GENPYBIND(setter_for(dead_time))
    void set_dead_time(DeadTime value) SYMBOL_VISIBLE;
 
    bool operator==(CADCConfig const& other) const SYMBOL_VISIBLE;
    bool operator!=(CADCConfig const& other) const SYMBOL_VISIBLE;
 
    GENPYBIND(stringstream)
    friend std::ostream& operator<<(std::ostream& os, CADCConfig const& config) SYMBOL_VISIBLE;
 
    static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
    template <typename AddressT>
    static std::array<AddressT, config_size_in_words> addresses(coordinate_type const& word)
        SYMBOL_VISIBLE GENPYBIND(hidden);
    template <typename WordT>
    std::array<WordT, config_size_in_words> encode() const SYMBOL_VISIBLE GENPYBIND(hidden);
    template <typename WordT>
    void decode(std::array<WordT, config_size_in_words> const& data) SYMBOL_VISIBLE
        GENPYBIND(hidden);
 
protected:
    friend class cereal::access;
    template <typename Archive>
    void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
 
    bool m_enable;
    ResetWait m_reset_wait;
    DeadTime m_dead_time;
};
 
EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CADCConfig)
 
namespace detail {
 
template <>
struct BackendContainerTrait<CADCConfig>
    : public BackendContainerBase<
          CADCConfig,
          fisch::vx::word_access_type::Omnibus,
          fisch::vx::word_access_type::OmnibusChipOverJTAG>
{};
 
} // namespace detail
 
class SYMBOL_VISIBLE CADCChannelConfig
{
public:
    typedef std::true_type is_leaf_node;
    typedef typename halco::hicann_dls::vx::CADCChannelConfigOnDLS coordinate_type;
#ifndef __ppu__
    constexpr static auto unsupported_read_targets GENPYBIND(hidden) = {
        hxcomm::vx::Target::hardware};
#endif
 
    struct GENPYBIND(inline_base("*")) Offset
        : public halco::common::detail::RantWrapper<Offset, int_fast16_t, 127, -128>
    {
        typedef halco::common::detail::RantWrapper<Offset, int_fast16_t, 127, -128> rant_t;
        constexpr explicit Offset(intmax_t const val = 0) GENPYBIND(implicit_conversion) :
            rant_t(val)
        {}
    };
 
    CADCChannelConfig();
 
    GENPYBIND(getter_for(offset))
    Offset get_offset() const;
 
    GENPYBIND(setter_for(offset))
    void set_offset(Offset value);
 
    bool operator==(CADCChannelConfig const& other) const;
    bool operator!=(CADCChannelConfig const& other) const;
 
    GENPYBIND(stringstream)
    friend std::ostream& operator<<(std::ostream& os, CADCChannelConfig const& config)
    {
        os << "CADCChannelConfig(" << config.m_offset << ")";
        return os;
    }
 
    static size_t constexpr config_size_in_words GENPYBIND(hidden) = 1;
    template <typename AddressT>
    static std::array<AddressT, config_size_in_words> addresses(coordinate_type const& word)
        GENPYBIND(hidden);
    template <typename WordT>
    std::array<WordT, config_size_in_words> encode() const GENPYBIND(hidden);
    template <typename WordT>
    void decode(std::array<WordT, config_size_in_words> const& data) GENPYBIND(hidden);
 
protected:
    friend class cereal::access;
    template <typename Archive>
    void serialize(Archive& ar, std::uint32_t const version);
 
    Offset m_offset;
};
 
 
namespace detail {
 
template <>
struct BackendContainerTrait<CADCChannelConfig>
    : public BackendContainerBase<
          CADCChannelConfig,
          fisch::vx::word_access_type::Omnibus,
          fisch::vx::word_access_type::OmnibusChipOverJTAG>
{};
 
} // namespace detail
 
 
// TODO: Switch to CRTP pattern when https://github.com/kljohann/genpybind/issues/28 is solved
class GENPYBIND(visible) CADCOffsetSRAMTimingConfig : public detail::SRAMTimingConfig
{
public:
    typedef halco::hicann_dls::vx::CADCOffsetSRAMTimingConfigOnDLS coordinate_type;
 
    bool operator==(CADCOffsetSRAMTimingConfig const& other) const SYMBOL_VISIBLE;
    bool operator!=(CADCOffsetSRAMTimingConfig const& other) const SYMBOL_VISIBLE;
 
    GENPYBIND(stringstream)
    friend std::ostream& operator<<(std::ostream& os, CADCOffsetSRAMTimingConfig const& config)
        SYMBOL_VISIBLE;
 
    template <typename AddressT>
    std::array<AddressT, config_size_in_words> addresses(coordinate_type const& word) const
        SYMBOL_VISIBLE GENPYBIND(hidden);
 
private:
    friend class cereal::access;
    template <typename Archive>
    void serialize(Archive& ar, std::uint32_t);
};
 
EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CADCOffsetSRAMTimingConfig)
 
namespace detail {
 
template <>
struct BackendContainerTrait<CADCOffsetSRAMTimingConfig>
    : public BackendContainerBase<
          CADCOffsetSRAMTimingConfig,
          fisch::vx::word_access_type::Omnibus,
          fisch::vx::word_access_type::OmnibusChipOverJTAG>
{};
 
} // namespace detail
 
class GENPYBIND(visible) CADCSampleQuad
{
public:
    typedef std::true_type is_leaf_node;
    typedef halco::hicann_dls::vx::CADCSampleQuadOnDLS coordinate_type;
 
    struct GENPYBIND(inline_base("*")) Value
        : public halco::common::detail::RantWrapper<Value, uint_fast16_t, 255, 0>
    {
        constexpr explicit Value(intmax_t const val = 0) GENPYBIND(implicit_conversion) :
            rant_t(val)
        {}
    };
 
    CADCSampleQuad() SYMBOL_VISIBLE;
 
    Value get_sample(halco::hicann_dls::vx::EntryOnQuad const& coord) const SYMBOL_VISIBLE;
 
    void set_sample(halco::hicann_dls::vx::EntryOnQuad const& coord, Value value) SYMBOL_VISIBLE;
 
    bool operator==(CADCSampleQuad const& other) const SYMBOL_VISIBLE;
    bool operator!=(CADCSampleQuad const& other) const SYMBOL_VISIBLE;
 
    GENPYBIND(stringstream)
    friend std::ostream& operator<<(std::ostream& os, CADCSampleQuad const& config) SYMBOL_VISIBLE;
 
    static size_t constexpr read_config_size_in_words GENPYBIND(hidden) = 1;
    static size_t constexpr write_config_size_in_words GENPYBIND(hidden) = 0;
    static std::array<halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words>
    read_addresses(coordinate_type const& word) SYMBOL_VISIBLE GENPYBIND(hidden);
    static std::array<halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words>
    write_addresses(coordinate_type const& word) SYMBOL_VISIBLE GENPYBIND(hidden);
    std::array<fisch::vx::word_access_type::Omnibus, write_config_size_in_words> encode() const
        SYMBOL_VISIBLE GENPYBIND(hidden);
    void decode(std::array<fisch::vx::word_access_type::Omnibus, read_config_size_in_words> const&
                    data) SYMBOL_VISIBLE GENPYBIND(hidden);
 
protected:
    friend class cereal::access;
    template <typename Archive>
    void serialize(Archive& ar, std::uint32_t const version) SYMBOL_VISIBLE;
 
    halco::common::typed_array<Value, halco::hicann_dls::vx::EntryOnQuad> m_samples;
};
 
namespace detail {
 
template <>
struct BackendContainerTrait<CADCSampleQuad>
    : public BackendContainerBase<CADCSampleQuad, fisch::vx::word_access_type::Omnibus>
{};
 
} // namespace detail
 
EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CADCSampleQuad)
 
} // namespace vx
} // namespace haldls