API Reference: haldls

struct haldls::vx::MADCConfig::ActiveMuxInputSelectLength : public halco::common::detail::RantWrapper<ActiveMuxInputSelectLength, uint_fast8_t, 15, 0>

#include <madc.h>

Public Functions

inline explicit constexpr ActiveMuxInputSelectLength (uintmax_t const val=0) SYMBOL_VISIBLE

class haldls::vx::AD5252ChannelConfig

#include <i2c.h>

Public Types

typedef halco::hicann_dls::vx::AD5252ChannelConfigOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

AD5252ChannelConfig () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::I2CAD5252RwRegister, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::I2CAD5252RwRegister, config_size_in_words > encode () const SYMBOL_VISIBLE

WiperSetting get_value () const SYMBOL_VISIBLE

Get wiper setting for digital potentiometer.

Returns

Wiper setting

bool operator!= (AD5252ChannelConfig const &other) const SYMBOL_VISIBLE

bool operator== (AD5252ChannelConfig const &other) const SYMBOL_VISIBLE

void set_value (WiperSetting value) SYMBOL_VISIBLE

Set wiper setting for digital potentiometer.

Parameters

value – The wiper setting.

Public Static Functions

static std::array< halco::hicann_dls::vx::I2CAD5252RwRegisterOnBoard, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation}

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

WiperSetting m_value

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, AD5252ChannelConfig const &config) SYMBOL_VISIBLE

class haldls::vx::AD5252ChannelConfigPersistent

#include <i2c.h>

Public Types

typedef halco::hicann_dls::vx::AD5252ChannelConfigPersistentOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

AD5252ChannelConfigPersistent () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::I2CAD5252RwRegister, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::I2CAD5252RwRegister, config_size_in_words > encode () const SYMBOL_VISIBLE

WiperSetting get_value () const SYMBOL_VISIBLE

Get wiper setting for digital potentiometer.

Returns

Wiper setting

bool operator!= (AD5252ChannelConfigPersistent const &other) const SYMBOL_VISIBLE

bool operator== (AD5252ChannelConfigPersistent const &other) const SYMBOL_VISIBLE

void set_value (WiperSetting value) SYMBOL_VISIBLE

Set wiper setting for digital potentiometer.

Parameters

value – The wiper setting.

Public Static Functions

static std::array< halco::hicann_dls::vx::I2CAD5252RwRegisterOnBoard, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation}

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

WiperSetting m_value

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, AD5252ChannelConfigPersistent const &config) SYMBOL_VISIBLE

template<typename TL>
struct AddPickle

Add pickle support to list of classes.

tparam TL

Type list of classes to add pickle support for

template<typename ...Ts>
struct haldls::vx::AddPickle<hate::type_list<Ts...>>

#include <pickle.h>

Public Static Functions

static inline void apply(pybind11::module &parent, std::vector<std::string> const &container_names)

Add pickle support to list of classes.

Note

Specified name list has to match type list of wrapped types.

Template Parameters

T – Type of wrapped object

Parameters

• parent – Pybind11 module

• name – Name of object in python module

Private Static Functions

template<size_t I, size_t... Is>
static inline void apply_impl(pybind11::module &parent, std::vector<std::string> const &container_names, std::index_sequence<I, Is...>)

template<typename T>
static inline void apply_single(pybind11::module &parent, std::string const &name)

Add pickle support to single class.

Note

Specified name has to match object of correct wrapped type.

Template Parameters

T – Type of wrapped object

Parameters

• parent – Pybind11 module

• name – Name of object in python module

struct haldls::vx::detail::SRAMTimingConfig::AddressSetupTime : public halco::common::detail::RantWrapper<AddressSetupTime, uint_fast16_t, hate::math::pow(2, 4) - 1, 0>

#include <sram_controller.h>

Wait time for address value propagation after enable signal pull.

Public Functions

inline explicit constexpr AddressSetupTime(uintmax_t const val = 11)

class haldls::vx::ADPLL

#include <pll.h>

Container for configuration of an ADPLL (All-Digital Phased-Locked-Loop) clock generator.

The PLL features two ADPLLs with three clock outputs each. The clock outputs are routed to the PLLClockOutputBlock with four clock output ports.

Public Types

typedef halco::hicann_dls::vx::ADPLLOnDLS coordinate_type

typedef std::true_type is_leaf_node

enum Output

Outputs of the ADPLL.

Values:

enumerator core_0

enumerator core_1

enumerator dco

Public Functions

ADPLL () SYMBOL_VISIBLE

Default construct ADPLL.

double calculate_output_frequency (Output const &output, double const &f_ref=nominal_pll_f_reference) const SYMBOL_VISIBLE

Calculate the frequency for the different outputs on the ADPLL.

Frequencies are returned in Hz.

Parameters

• output – Ouput for which the frequency shoud be returned

• f_ref – Nominal reference frequency the PLL uses as input

Returns

Frequency in Hz at specified output

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

CoreDivM0 get_core_div_m0 () const SYMBOL_VISIBLE

CoreDivM1 get_core_div_m1 () const SYMBOL_VISIBLE

DcoPowerSwitch get_dco_power_switch () const SYMBOL_VISIBLE

bool get_enable () const SYMBOL_VISIBLE

Get whether the ADPLL is enabled.

Returns

Boolean value

bool get_enable_output_clock () const SYMBOL_VISIBLE

Get whether output clock is enabled.

Returns

Boolean value

bool get_enforce_lock () const SYMBOL_VISIBLE

Get whether the PLL signal is enforced to be locked.

Returns

Boolean value

FilterShift get_filter_shift () const SYMBOL_VISIBLE

bool get_lock_window () const SYMBOL_VISIBLE

Get the lock detection timing window (false: long, true: short).

Returns

Boolean value

LoopDivN get_loop_div_n () const SYMBOL_VISIBLE

LoopFilterInt get_loop_filter_int () const SYMBOL_VISIBLE

LoopFilterProp get_loop_filter_prop () const SYMBOL_VISIBLE

bool get_open_lock () const SYMBOL_VISIBLE

Get whether open loop mode of the DCO is enabled.

Returns

Boolean value

bool get_pfd_select () const SYMBOL_VISIBLE

Get whether the pfd bit is set (with/without synchronizer).

Returns

Boolean value

PreDivP0 get_pre_div_p0 () const SYMBOL_VISIBLE

PreDivP1 get_pre_div_p1 () const SYMBOL_VISIBLE

PreDivP2 get_pre_div_p2 () const SYMBOL_VISIBLE

Tune get_tune () const SYMBOL_VISIBLE

bool get_use_external_config () const SYMBOL_VISIBLE

TODO: What exactly gets this?

Returns

Boolean value

bool operator!= (ADPLL const &other) const SYMBOL_VISIBLE

bool operator== (ADPLL const &other) const SYMBOL_VISIBLE

void set_core_div_m0 (CoreDivM0 value) SYMBOL_VISIBLE

void set_core_div_m1 (CoreDivM1 value) SYMBOL_VISIBLE

void set_dco_power_switch (DcoPowerSwitch value) SYMBOL_VISIBLE

void set_enable (bool value) SYMBOL_VISIBLE

Set to enable the ADPLL.

Parameters

value – Boolean value to set

void set_enable_output_clock (bool value) SYMBOL_VISIBLE

Set whether to enable output clock.

Parameters

value – Boolean value to set

void set_enforce_lock (bool value) SYMBOL_VISIBLE

Set to enforce a locked PLL signal.

Parameters

value – Boolean value to set

void set_filter_shift (FilterShift value) SYMBOL_VISIBLE

void set_lock_window (bool value) SYMBOL_VISIBLE

Set the lock detection timing window (false: long, true: short).

Parameters

value – Boolean value to set

void set_loop_div_n (LoopDivN value) SYMBOL_VISIBLE

void set_loop_filter_int (LoopFilterInt value) SYMBOL_VISIBLE

void set_loop_filter_prop (LoopFilterProp value) SYMBOL_VISIBLE

void set_open_lock (bool value) SYMBOL_VISIBLE

Set enable open loop mode of the DCO.

Parameters

value – Boolean value to set

void set_pfd_select (bool value) SYMBOL_VISIBLE

Set the pfd bit (with/without synchronizer).

Parameters

value – Boolean value to set

void set_pre_div_p0 (PreDivP0 value) SYMBOL_VISIBLE

void set_pre_div_p1 (PreDivP1 value) SYMBOL_VISIBLE

void set_pre_div_p2 (PreDivP2 value) SYMBOL_VISIBLE

void set_tune (Tune value) SYMBOL_VISIBLE

void set_use_external_config (bool value) SYMBOL_VISIBLE

TODO: What exactly sets this?.

Parameters

value – Boolean value to set

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 2

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

CoreDivM0 m_core_div_m0

CoreDivM1 m_core_div_m1

DcoPowerSwitch m_dco_power_switch

bool m_enable

bool m_enable_output_clock

bool m_enforce_lock

FilterShift m_filter_shift

bool m_lock_window

LoopDivN m_loop_div_n

LoopFilterInt m_loop_filter_int

LoopFilterProp m_loop_filter_prop

bool m_open_lock

bool m_pfd_select

PreDivP0 m_pre_div_p0

PreDivP1 m_pre_div_p1

PreDivP2 m_pre_div_p2

Tune m_tune

bool m_use_external_config

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, ADPLL const &config) SYMBOL_VISIBLE

struct haldls::vx::SynapseCorrelationCalibQuad::AmpCalib : public halco::common::detail::RantWrapper<AmpCalib, uint8_t, 3, 0>

#include <synapse.h>

Public Functions

inline explicit constexpr AmpCalib(uintmax_t const val = 0)

template<Backend B>
struct haldls::vx::detail::backend_container_type_from_backend

#include <traits.h>

Public Types

hate::index_type_list_by_integer< static_cast< size_t >B), BackendContainerList >::type container_type

template<typename BackendContainer>
struct haldls::vx::detail::backend_from_backend_container_type

#include <traits.h>

Public Static Attributes

static constexpr static Backend backend   = static_cast<Backend>(hate::index_type_list_by_type<BackendContainer,BackendContainerList>::value)

template<typename ContainerT, typename DefaultBackendContainer, typename ...AdditionalBackendContainer>
struct haldls::vx::detail::BackendContainerBase

#include <traits.h>

Backend container trait base.

Each container has to support at least one backend container. Multiple supported backends allow specifying a default backend which is used if no backend is given at a PlaybackProgramBuilder::read/write instruction.

tparam ContainerT

Container for which to generate backend traits for

tparam DefaultBackendContainer

Default backend to use if no is given

tparam AdditionalBackendContainer

Additionally supported backends

Public Types

typedef hate::type_list<DefaultBackendContainer, AdditionalBackendContainer...> container_list

typedef DefaultBackendContainer default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table   =     generate_lookup_table<BackendContainerList>::backend_index_lookup_table

static constexpr static Backend default_backend   =     backend_from_backend_container_type<DefaultBackendContainer>::backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends   = {     backend_from_backend_container_type<DefaultBackendContainer>::backend,     backend_from_backend_container_type<AdditionalBackendContainer>::backend...}

template<typename ContainerT>
struct haldls::vx::detail::BackendContainerTrait : public haldls::vx::detail::BackendContainerBase<ContainerT, ContainerT>

#include <traits.h>

Public Types

typedef hate::type_list<ContainerT, AdditionalBackendContainer...> container_list

typedef ContainerT default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<AD5252ChannelConfig> : public haldls::vx::detail::BackendContainerBase<AD5252ChannelConfig, fisch::vx::word_access_type::I2CAD5252RwRegister>

#include <i2c.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::I2CAD5252RwRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::I2CAD5252RwRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<AD5252ChannelConfigPersistent> : public haldls::vx::detail::BackendContainerBase<AD5252ChannelConfigPersistent, fisch::vx::word_access_type::I2CAD5252RwRegister>

#include <i2c.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::I2CAD5252RwRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::I2CAD5252RwRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<ADPLL> : public haldls::vx::detail::BackendContainerBase<ADPLL, fisch::vx::word_access_type::JTAGPLLRegister, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <pll.h>

The JTAGPLLRegister backend only provides write functionality, but is safe with respect to changing the ADPLL config.

The OmnibusChipOverJTAG access provides read and write functionality but is unsafe if the omnibus clock is altered and thus reinitializes itself. During reinitialization-time, OmnibusChipOverJTAG requests are dropped.

Public Types

typedef hate::type_list<fisch::vx::word_access_type::JTAGPLLRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::JTAGPLLRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<BackgroundSpikeSource> : public haldls::vx::detail::BackendContainerBase<BackgroundSpikeSource, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <background.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<BlockPostPulse> : public haldls::vx::detail::BackendContainerBase<BlockPostPulse, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <neuron.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CADCChannelConfig> : public haldls::vx::detail::BackendContainerBase<CADCChannelConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <cadc.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CADCConfig> : public haldls::vx::detail::BackendContainerBase<CADCConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <cadc.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CADCOffsetSRAMTimingConfig> : public haldls::vx::detail::BackendContainerBase<CADCOffsetSRAMTimingConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <cadc.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CADCSampleQuad> : public haldls::vx::detail::BackendContainerBase<CADCSampleQuad, fisch::vx::word_access_type::Omnibus>

#include <cadc.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<typename Coordinates>
struct haldls::vx::detail::BackendContainerTrait<CapMemBlock<Coordinates>> : public haldls::vx::detail::BackendContainerBase<CapMemBlock<Coordinates>, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <capmem.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<typename Coordinates>
struct haldls::vx::detail::BackendContainerTrait<CapMemBlockConfig<Coordinates>> : public haldls::vx::detail::BackendContainerBase<CapMemBlockConfig<Coordinates>, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <capmem.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<typename Coordinates>
struct haldls::vx::detail::BackendContainerTrait<CapMemCell<Coordinates>> : public haldls::vx::detail::BackendContainerBase<CapMemCell<Coordinates>, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <capmem.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<ColumnCorrelationQuad> : public haldls::vx::detail::BackendContainerBase<ColumnCorrelationQuad, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<ColumnCurrentQuad> : public haldls::vx::detail::BackendContainerBase<ColumnCurrentQuad, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CommonCorrelationConfig> : public haldls::vx::detail::BackendContainerBase<haldls::vx::CommonCorrelationConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <correlation.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CommonNeuronBackendConfig> : public haldls::vx::detail::BackendContainerBase<CommonNeuronBackendConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <neuron.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CommonPADIBusConfig> : public haldls::vx::detail::BackendContainerBase<CommonPADIBusConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <padi.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CommonPhyConfigChip> : public haldls::vx::detail::BackendContainerBase<CommonPhyConfigChip, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <phy.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::OmnibusChipOverJTAG, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::OmnibusChipOverJTAG default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CommonPhyConfigFPGA> : public haldls::vx::detail::BackendContainerBase<CommonPhyConfigFPGA, fisch::vx::word_access_type::Omnibus>

#include <phy.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CommonSTPConfig> : public haldls::vx::detail::BackendContainerBase<CommonSTPConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <padi.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CommonSynramConfig> : public haldls::vx::detail::BackendContainerBase<CommonSynramConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CorrelationReset> : public haldls::vx::detail::BackendContainerBase<CorrelationReset, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CrossbarInputDropCounter> : public haldls::vx::detail::BackendContainerBase<CrossbarInputDropCounter, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <routing_crossbar.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CrossbarNode> : public haldls::vx::detail::BackendContainerBase<CrossbarNode, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <routing_crossbar.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CrossbarOutputConfig> : public haldls::vx::detail::BackendContainerBase<CrossbarOutputConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <routing_crossbar.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CrossbarOutputEventCounter> : public haldls::vx::detail::BackendContainerBase<CrossbarOutputEventCounter, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <routing_crossbar.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<CurrentDAC> : public haldls::vx::detail::BackendContainerBase<CurrentDAC, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <current_dac.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<DAC6573ChannelConfig> : public haldls::vx::detail::BackendContainerBase<DAC6573ChannelConfig, fisch::vx::word_access_type::I2CDAC6573RwRegister>

#include <i2c.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::I2CDAC6573RwRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::I2CDAC6573RwRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<DACChannel> : public haldls::vx::detail::BackendContainerBase<DACChannel, fisch::vx::word_access_type::SPIDACDataRegister>

#include <spi.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::SPIDACDataRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::SPIDACDataRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<DACControl> : public haldls::vx::detail::BackendContainerBase<DACControl, fisch::vx::word_access_type::SPIDACControlRegister>

#include <spi.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::SPIDACControlRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::SPIDACControlRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<EventRecordingConfig> : public haldls::vx::detail::BackendContainerBase<EventRecordingConfig, fisch::vx::word_access_type::Omnibus>

#include <fpga.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<ExternalPPUMemoryByte> : public haldls::vx::detail::BackendContainerBase<ExternalPPUMemoryByte, fisch::vx::word_access_type::Omnibus>

#include <fpga.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<ExternalPPUMemoryQuad> : public haldls::vx::detail::BackendContainerBase<ExternalPPUMemoryQuad, fisch::vx::word_access_type::Omnibus>

#include <fpga.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<FPGADeviceDNA> : public haldls::vx::detail::BackendContainerBase<FPGADeviceDNA, fisch::vx::word_access_type::Omnibus>

#include <fpga.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<HicannARQStatus> : public haldls::vx::detail::BackendContainerBase<HicannARQStatus, fisch::vx::word_access_type::Omnibus>

#include <arq.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<INA219Config> : public haldls::vx::detail::BackendContainerBase<INA219Config, fisch::vx::word_access_type::I2CINA219RwRegister>

#include <i2c.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::I2CINA219RwRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::I2CINA219RwRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<INA219Status> : public haldls::vx::detail::BackendContainerBase<INA219Status, fisch::vx::word_access_type::I2CINA219RoRegister>

#include <i2c.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::I2CINA219RoRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::I2CINA219RoRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<JTAGClockScaler> : public haldls::vx::detail::BackendContainerBase<JTAGClockScaler, fisch::vx::word_access_type::JTAGClockScaler>

#include <jtag.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::JTAGClockScaler, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::JTAGClockScaler default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<JTAGIdCode> : public haldls::vx::detail::BackendContainerBase<JTAGIdCode, fisch::vx::word_access_type::JTAGIdCode>

#include <jtag.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::JTAGIdCode, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::JTAGIdCode default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<MADCConfig> : public haldls::vx::detail::BackendContainerBase<MADCConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <madc.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<MADCControl> : public haldls::vx::detail::BackendContainerBase<MADCControl, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <madc.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<typename Coordinates>
struct haldls::vx::detail::BackendContainerTrait<NeuronBackendConfig<Coordinates>> : public haldls::vx::detail::BackendContainerBase<NeuronBackendConfig<Coordinates>, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <neuron.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<NeuronBackendSRAMTimingConfig> : public haldls::vx::detail::BackendContainerBase<NeuronBackendSRAMTimingConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <neuron.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<NeuronReset> : public haldls::vx::detail::BackendContainerBase<NeuronReset, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <neuron.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<NeuronSRAMTimingConfig> : public haldls::vx::detail::BackendContainerBase<NeuronSRAMTimingConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <neuron.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<NullPayloadReadable> : public haldls::vx::detail::BackendContainerBase<NullPayloadReadable, fisch::vx::word_access_type::NullPayloadReadable>

#include <null_payload_readable.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::NullPayloadReadable, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::NullPayloadReadable default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PADIEvent> : public haldls::vx::detail::BackendContainerBase<PADIEvent, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <padi.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PadMultiplexerConfig> : public haldls::vx::detail::BackendContainerBase<PadMultiplexerConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <readout.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PerfTest> : public haldls::vx::detail::BackendContainerBase<PerfTest, fisch::vx::word_access_type::Omnibus>

#include <perftest.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PerfTestStatus> : public haldls::vx::detail::BackendContainerBase<PerfTestStatus, fisch::vx::word_access_type::Omnibus>

#include <perftest.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PhyConfigChip> : public haldls::vx::detail::BackendContainerBase<PhyConfigChip, fisch::vx::word_access_type::JTAGPhyRegister>

#include <phy.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::JTAGPhyRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::JTAGPhyRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PhyConfigFPGA> : public haldls::vx::detail::BackendContainerBase<PhyConfigFPGA, fisch::vx::word_access_type::Omnibus>

#include <phy.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PhyStatus> : public haldls::vx::detail::BackendContainerBase<PhyStatus, fisch::vx::word_access_type::Omnibus>

#include <phy.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PLLSelfTest> : public haldls::vx::detail::BackendContainerBase<PLLSelfTest, fisch::vx::word_access_type::JTAGPLLRegister, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <pll.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::JTAGPLLRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::JTAGPLLRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PLLSelfTestStatus> : public haldls::vx::detail::BackendContainerBase<PLLSelfTestStatus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <pll.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::OmnibusChipOverJTAG, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::OmnibusChipOverJTAG default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PollingOmnibusBlock> : public haldls::vx::detail::BackendContainerBase<PollingOmnibusBlock, fisch::vx::word_access_type::PollingOmnibusBlock>

#include <block.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::PollingOmnibusBlock, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::PollingOmnibusBlock default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PollingOmnibusBlockConfig> : public haldls::vx::detail::BackendContainerBase<PollingOmnibusBlockConfig, fisch::vx::word_access_type::Omnibus>

#include <block.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PPUControlRegister> : public haldls::vx::detail::BackendContainerBase<PPUControlRegister, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <ppu.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PPUMemory> : public haldls::vx::detail::BackendContainerBase<PPUMemory, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <ppu.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PPUMemoryBlock> : public haldls::vx::detail::BackendContainerBase<PPUMemoryBlock, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <ppu.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PPUMemoryWord> : public haldls::vx::detail::BackendContainerBase<PPUMemoryWord, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <ppu.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<PPUStatusRegister> : public haldls::vx::detail::BackendContainerBase<PPUStatusRegister, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <ppu.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<ReadoutSourceSelection> : public haldls::vx::detail::BackendContainerBase<ReadoutSourceSelection, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <readout.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<ResetChip> : public haldls::vx::detail::BackendContainerBase<ResetChip, fisch::vx::word_access_type::ResetChip>

#include <reset.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::ResetChip, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::ResetChip default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<ResetJTAGTap> : public haldls::vx::detail::BackendContainerBase<ResetJTAGTap, fisch::vx::word_access_type::ResetJTAGTap>

#include <jtag.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::ResetJTAGTap, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::ResetJTAGTap default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<ShiftRegister> : public haldls::vx::detail::BackendContainerBase<ShiftRegister, fisch::vx::word_access_type::SPIShiftRegister>

#include <spi.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::SPIShiftRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::SPIShiftRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SpikeCounterRead> : public haldls::vx::detail::BackendContainerBase<SpikeCounterRead, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <neuron.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SpikeCounterReset> : public haldls::vx::detail::BackendContainerBase<SpikeCounterReset, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <neuron.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SpikePack1ToChip> : public haldls::vx::detail::BackendContainerBase<SpikePack1ToChip, fisch::vx::word_access_type::SpikePack1ToChip>

#include <event.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::SpikePack1ToChip, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::SpikePack1ToChip default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SpikePack2ToChip> : public haldls::vx::detail::BackendContainerBase<SpikePack2ToChip, fisch::vx::word_access_type::SpikePack2ToChip>

#include <event.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::SpikePack2ToChip, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::SpikePack2ToChip default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SpikePack3ToChip> : public haldls::vx::detail::BackendContainerBase<SpikePack3ToChip, fisch::vx::word_access_type::SpikePack3ToChip>

#include <event.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::SpikePack3ToChip, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::SpikePack3ToChip default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SynapseBiasSelection> : public haldls::vx::detail::BackendContainerBase<SynapseBiasSelection, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SynapseCorrelationCalibQuad> : public haldls::vx::detail::BackendContainerBase<SynapseCorrelationCalibQuad, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SynapseDriverConfig> : public haldls::vx::detail::BackendContainerBase<SynapseDriverConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse_driver.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SynapseDriverSRAMTimingConfig> : public haldls::vx::detail::BackendContainerBase<SynapseDriverSRAMTimingConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse_driver.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SynapseLabelQuad> : public haldls::vx::detail::BackendContainerBase<SynapseLabelQuad, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SynapseQuad> : public haldls::vx::detail::BackendContainerBase<SynapseQuad, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SynapseWeightQuad> : public haldls::vx::detail::BackendContainerBase<SynapseWeightQuad, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <synapse.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SystimeSync> : public haldls::vx::detail::BackendContainerBase<SystimeSync, fisch::vx::word_access_type::SystimeSync>

#include <systime.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::SystimeSync, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::SystimeSync default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<SystimeSyncBase> : public haldls::vx::detail::BackendContainerBase<SystimeSyncBase, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <systime.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<TCA9554Config> : public haldls::vx::detail::BackendContainerBase<TCA9554Config, fisch::vx::word_access_type::I2CTCA9554RwRegister>

#include <i2c.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::I2CTCA9554RwRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::I2CTCA9554RwRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<TCA9554Inputs> : public haldls::vx::detail::BackendContainerBase<TCA9554Inputs, fisch::vx::word_access_type::I2CTCA9554RoRegister>

#include <i2c.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::I2CTCA9554RoRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::I2CTCA9554RoRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<Timer> : public haldls::vx::detail::BackendContainerBase<Timer, fisch::vx::word_access_type::Timer>

#include <timer.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Timer, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Timer default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<v2::NeuronConfig> : public haldls::vx::detail::BackendContainerBase<v2::NeuronConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <neuron.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<v2::NeuronResetQuad> : public haldls::vx::detail::BackendContainerBase<v2::NeuronResetQuad, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <neuron.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<v2::PLLClockOutputBlock> : public haldls::vx::detail::BackendContainerBase<v2::PLLClockOutputBlock, fisch::vx::word_access_type::JTAGPLLRegister, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <pll.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::JTAGPLLRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::JTAGPLLRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<v2::ReferenceGeneratorConfig> : public haldls::vx::detail::BackendContainerBase<v2::ReferenceGeneratorConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <capmem.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<v3::NeuronConfig> : public haldls::vx::detail::BackendContainerBase<v3::NeuronConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <neuron.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<v3::NeuronResetQuad> : public haldls::vx::detail::BackendContainerBase<v3::NeuronResetQuad, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <neuron.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<v3::PLLClockOutputBlock> : public haldls::vx::detail::BackendContainerBase<v3::PLLClockOutputBlock, fisch::vx::word_access_type::JTAGPLLRegister, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <pll.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::JTAGPLLRegister, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::JTAGPLLRegister default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<v3::ReferenceGeneratorConfig> : public haldls::vx::detail::BackendContainerBase<v3::ReferenceGeneratorConfig, fisch::vx::word_access_type::Omnibus, fisch::vx::word_access_type::OmnibusChipOverJTAG>

#include <capmem.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<VectorGeneratorControl> : public haldls::vx::detail::BackendContainerBase<VectorGeneratorControl, fisch::vx::word_access_type::Omnibus>

#include <vector_generator.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<VectorGeneratorFIFOWord> : public haldls::vx::detail::BackendContainerBase<VectorGeneratorFIFOWord, fisch::vx::word_access_type::Omnibus>

#include <vector_generator.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<VectorGeneratorLUTEntry> : public haldls::vx::detail::BackendContainerBase<VectorGeneratorLUTEntry, fisch::vx::word_access_type::Omnibus>

#include <vector_generator.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<VectorGeneratorNotificationAddress> : public haldls::vx::detail::BackendContainerBase<VectorGeneratorNotificationAddress, fisch::vx::word_access_type::Omnibus>

#include <vector_generator.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

template<>
struct haldls::vx::detail::BackendContainerTrait<VectorGeneratorTrigger> : public haldls::vx::detail::BackendContainerBase<VectorGeneratorTrigger, fisch::vx::word_access_type::Omnibus>

#include <vector_generator.h>

Public Types

typedef hate::type_list<fisch::vx::word_access_type::Omnibus, AdditionalBackendContainer...> container_list

typedef fisch::vx::word_access_type::Omnibus default_container

Public Static Functions

static inline constexpr static bool valid (Backend backend)

Public Static Attributes

static constexpr static auto backend_index_lookup_table

static constexpr static Backend default_backend

static constexpr static std::array< Backend, sizeof...(AdditionalBackendContainer)+1 > valid_backends

class haldls::vx::BackgroundSpikeSource

#include <background.h>

Background spike source on chip.

Two modes are supported, either regular spiking or binned Poisson spike-train generation. While with the former the emitted NeuronLabel is configurable and stays fixed, with the latter, the lower eight bits of the emitted NeuronLabel can bit-wise be replaced by randomly generated values.

Public Types

typedef halco::hicann_dls::vx::BackgroundSpikeSourceOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

BackgroundSpikeSource () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_enable () const SYMBOL_VISIBLE

Get enable value.

On change of disabled -> enabled the random seed is copied to the random number generator and the period is initialized with the full period which is decremented on every clock cycle. The first spike or bin is therefore reached with a full period delay after the enable change.

Returns

Boolean value

bool get_enable_random () const SYMBOL_VISIBLE

Get enable random spike train generation.

On true, every period a bin evaluation in a binned Poisson generator is performed. In addition the enabled mask bits are randomized on spike ocurrence. On false, every period a spike is emitted leading to a regular spike-train.

Returns

Boolean value

Mask get_mask () const SYMBOL_VISIBLE

Get neuron label randomization mask.

The value has no effect on regular spike generation.

Returns

Mask

halco::hicann_dls::vx::NeuronLabel get_neuron_label () const SYMBOL_VISIBLE

Get neuron label used for emitted spikes.

On Poisson spike generation, it serves as a base of which the lower eight bits can bit-wise be replaced by random values using the mask.

Returns

NeuronLabel

Period get_period () const SYMBOL_VISIBLE

Get period value.

It represents the ISI for regular spiking and the bin interval for Poisson spike generation.

Returns

Period

Rate get_rate () const SYMBOL_VISIBLE

Get Poisson spike generation rate factor.

The mean ISI is divided by (rate / 255). The value has no effect on regular spike generation.

Returns

Rate

Seed get_seed () const SYMBOL_VISIBLE

Get random seed value.

The value has no effect on regular spike generation.

Returns

Seed

bool operator!= (BackgroundSpikeSource const &other) const SYMBOL_VISIBLE

bool operator== (BackgroundSpikeSource const &other) const SYMBOL_VISIBLE

void set_enable (bool value) SYMBOL_VISIBLE

Set enable value.

On change of disabled -> enabled the random seed is copied to the random number generator and the period is initialized with the full period which is decremented on every clock cycle. The first spike or bin is therefore reached with a full period delay after the enable change.

Parameters

value – Boolean value

void set_enable_random (bool value) SYMBOL_VISIBLE

Set enable random spike train generation.

On true, every period a bin evaluation in a binned Poisson generator is performed. In addition the enabled mask bits are randomized on spike ocurrence. On false, every period a spike is emitted leading to a regular spike-train.

Parameters

value – Boolean value

void set_mask (Mask const &value) SYMBOL_VISIBLE

Set neuron label randomization mask.

The value has no effect on regular spike generation.

Parameters

value – Mask

void set_neuron_label (halco::hicann_dls::vx::NeuronLabel const &value) SYMBOL_VISIBLE

Set neuron label used for emitted spikes.

On Poisson spike generation, it serves as a base of which the lower eight bits can bit-wise be replaced by random values using the mask.

Parameters

value – NeuronLabel

void set_period (Period const &value) SYMBOL_VISIBLE

Set period value.

It represents the ISI for regular spiking and the bin interval for Poisson spike generation.

Parameters

value – Period

void set_rate (Rate const &value) SYMBOL_VISIBLE

Set Poisson spike generation rate factor.

The mean ISI is divided by (rate / 255). The value has no effect on regular spike generation.

Parameters

value – Rate

void set_seed (Seed const &value) SYMBOL_VISIBLE

Set random seed value.

The value has no effect on regular spike generation.

Parameters

value – Seed

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 3

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::hardware, hxcomm::vx::Target::simulation}

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_enable

bool m_enable_random

Mask m_mask

halco::hicann_dls::vx::NeuronLabel m_neuron_label

Period m_period

Rate m_rate

Seed m_seed

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, BackgroundSpikeSource const &config) SYMBOL_VISIBLE

class haldls::vx::Barrier

#include <barrier.h>

Public Functions

Barrier () SYMBOL_VISIBLE

fisch::vx::word_access_type::Barrier encode () const SYMBOL_VISIBLE

bool get_enable_jtag () const SYMBOL_VISIBLE

bool get_enable_omnibus () const SYMBOL_VISIBLE

bool get_enable_systime () const SYMBOL_VISIBLE

bool operator!= (Barrier const &other) const SYMBOL_VISIBLE

bool operator== (Barrier const &other) const SYMBOL_VISIBLE

void set_enable_jtag (bool value) SYMBOL_VISIBLE

void set_enable_omnibus (bool value) SYMBOL_VISIBLE

void set_enable_systime (bool value) SYMBOL_VISIBLE

Public Static Attributes

static SYMBOL_VISIBLE const Barrier jtag

static SYMBOL_VISIBLE const Barrier omnibus

static SYMBOL_VISIBLE const Barrier systime

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_enable_jtag

bool m_enable_omnibus

bool m_enable_systime

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, Barrier const &config) SYMBOL_VISIBLE

class haldls::vx::BlockPostPulse

#include <neuron.h>

Container to send post pulses to one half of the neurons (left/right).

Enable post_overwrite in the neurons to forward the pulse into the synapse array. The timing this pulse arrives may not be precise, it may vary between neurons in the block.

Public Types

typedef halco::hicann_dls::vx::BlockPostPulseOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

BlockPostPulse () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (BlockPostPulse const &other) const SYMBOL_VISIBLE

bool operator== (BlockPostPulse const &other) const SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &block) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &block) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, BlockPostPulse const &config) SYMBOL_VISIBLE

struct haldls::vx::CapMemBlockConfig::BoostA : public halco::common::detail::RantWrapper<BoostA, uint_fast16_t, 65535, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<BoostA, uint_fast16_t, 65535, 0>::rant_t rant_t

Public Functions

inline explicit constexpr BoostA()

inline explicit constexpr BoostA(uintmax_t const val)

struct haldls::vx::CapMemBlockConfig::BoostB : public halco::common::detail::RantWrapper<BoostB, uint_fast16_t, 65535, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<BoostB, uint_fast16_t, 65535, 0>::rant_t rant_t

Public Functions

inline explicit constexpr BoostB()

inline explicit constexpr BoostB(uintmax_t const val)

struct haldls::vx::CapMemBlockConfig::BoostFactor : public halco::common::detail::RantWrapper<BoostFactor, uint_fast16_t, 15, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<BoostFactor, uint_fast16_t, 15, 0>::rant_t rant_t

Public Functions

inline explicit constexpr BoostFactor()

inline explicit constexpr BoostFactor(uintmax_t const val)

struct haldls::vx::INA219Status::BusVoltage : public halco::common::detail::RantWrapper<BusVoltage, uint_fast16_t, 4000, 0>

#include <i2c.h>

Bus voltage with linear conversion and LSB = 4mV.

Public Functions

inline explicit constexpr BusVoltage(uintmax_t const val = 0)

float toUncalibratedVoltage () const SYMBOL_VISIBLE

Convert to uncalibrated voltage V.

class haldls::vx::CADCChannelConfig

#include <cadc.h>

CADC container with channel-local digital offset config.

Public Types

typedef halco::hicann_dls::vx::CADCChannelConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

CADCChannelConfig()

Default constructor.

template<typename WordT>
void decode(std::array<WordT, config_size_in_words> const &data)

template<typename WordT>
std::array<WordT, config_size_in_words> encode() const

Offset get_offset() const

Get Offset value.

Returns

Offset value

bool operator!=(CADCChannelConfig const &other) const

bool operator==(CADCChannelConfig const &other) const

void set_offset(Offset value)

Set Offset value.

Parameters

value – Offset value

Public Static Functions

template<typename AddressT>
static std::array<AddressT, config_size_in_words> addresses(coordinate_type const &word)

Public Static Attributes

static constexpr size_t config_size_in_words = 1

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::hardware}

Protected Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t const version)

Protected Attributes

Offset m_offset

Friends

friend class cereal::access

inline friend std::ostream &operator<<(std::ostream &os, CADCChannelConfig const &config)

class haldls::vx::CADCConfig

#include <cadc.h>

CADC container with global digital config for a vertical half.

Public Types

typedef halco::hicann_dls::vx::CADCConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

CADCConfig () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

DeadTime get_dead_time () const SYMBOL_VISIBLE

Get DeadTime value common for both CADC in a vertical half.

Returns

DeadTime value

bool get_enable () const SYMBOL_VISIBLE

Get enable value for the CADC.

Returns

Boolean value

ResetWait get_reset_wait () const SYMBOL_VISIBLE

Get ResetWait value common for both CADC in a vertical half.

Returns

ResetWait value

bool operator!= (CADCConfig const &other) const SYMBOL_VISIBLE

bool operator== (CADCConfig const &other) const SYMBOL_VISIBLE

void set_dead_time (DeadTime value) SYMBOL_VISIBLE

Set DeadTime value common for both CADC in a vertical half.

Parameters

value – DeadTime value

void set_enable (bool value) SYMBOL_VISIBLE

Set enable value for the CADC.

Parameters

value – Boolean value

void set_reset_wait (ResetWait value) SYMBOL_VISIBLE

Set ResetWait value common for both CADC in a vertical half.

Parameters

value – ResetWait value

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Protected Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Protected Attributes

DeadTime m_dead_time

bool m_enable

ResetWait m_reset_wait

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CADCConfig const &config) SYMBOL_VISIBLE

class haldls::vx::CADCOffsetSRAMTimingConfig : public haldls::vx::detail::SRAMTimingConfig

#include <cadc.h>

Public Types

typedef halco::hicann_dls::vx::CADCOffsetSRAMTimingConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

template<typename AddressT> std::array< AddressT, config_size_in_words > addresses (coordinate_type const &word) const SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

AddressSetupTime get_address_setup_time () const SYMBOL_VISIBLE

EnableWidth get_enable_width () const SYMBOL_VISIBLE

ReadDelay get_read_delay () const SYMBOL_VISIBLE

bool operator!= (CADCOffsetSRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator!= (SRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator== (CADCOffsetSRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator== (SRAMTimingConfig const &other) const SYMBOL_VISIBLE

void set_address_setup_time (AddressSetupTime value) SYMBOL_VISIBLE

void set_enable_width (EnableWidth value) SYMBOL_VISIBLE

void set_read_delay (ReadDelay value) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 2

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CADCOffsetSRAMTimingConfig const &config) SYMBOL_VISIBLE

class haldls::vx::CADCSampleQuad

#include <cadc.h>

CADC container of four CADC samples.

Public Types

typedef halco::hicann_dls::vx::CADCSampleQuadOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

CADCSampleQuad () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::Omnibus, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, write_config_size_in_words > encode () const SYMBOL_VISIBLE

Value get_sample (halco::hicann_dls::vx::EntryOnQuad const &coord) const SYMBOL_VISIBLE

Get sample value.

Parameters

coord – Sample on quad coordinate

Returns

Value value

bool operator!= (CADCSampleQuad const &other) const SYMBOL_VISIBLE

bool operator== (CADCSampleQuad const &other) const SYMBOL_VISIBLE

void set_sample (halco::hicann_dls::vx::EntryOnQuad const &coord, Value value) SYMBOL_VISIBLE

Set sample value.

Parameters

• coord – Sample on quad coordinate

• value – Value value

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words > read_addresses (coordinate_type const &word) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words > write_addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 1

static constexpr size_t write_config_size_in_words = 0

Protected Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Protected Attributes

halco::common::typed_array<Value, halco::hicann_dls::vx::EntryOnQuad> m_samples

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CADCSampleQuad const &config) SYMBOL_VISIBLE

struct haldls::vx::MADCConfig::CalibrationWaitValue : public halco::common::detail::RantWrapper<CalibrationWaitValue, uint_fast16_t, 1023, 0>

#include <madc.h>

Public Functions

inline explicit constexpr CalibrationWaitValue (uintmax_t const val=0) SYMBOL_VISIBLE

struct ReferenceGeneratorConfig::CapMemAmplifier : public halco::common::detail::RantWrapper<CapMemAmplifier, uint_fast8_t, 63, 0>, public halco::common::detail::RantWrapper<CapMemAmplifier, uint_fast8_t, 63, 0>

#include <capmem.h>

Public Functions

inline explicit constexpr CapMemAmplifier(uintmax_t const val = 40)

inline explicit constexpr CapMemAmplifier(uintmax_t const val = 40)

template<typename Coordinates>
class haldls::vx::CapMemBlock : public haldls::vx::DifferentialWriteTrait

#include <capmem.h>

Public Types

typedef Coordinates::CapMemBlockOnDLS coordinate_type

typedef std::false_type has_local_data

Public Functions

CapMemBlock()

CapMemCell<Coordinates>::value_type get_cell(typename Coordinates::CapMemCellOnCapMemBlock const &cell) const

bool operator!=(CapMemBlock const &other) const

bool operator==(CapMemBlock const &other) const

void set_cell(typename Coordinates::CapMemCellOnCapMemBlock const &cell, typename CapMemCell<Coordinates>::value_type const &value)

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

halco::common::typed_heap_array<CapMemCell<Coordinates>, typename Coordinates::CapMemCellOnCapMemBlock> m_capmem_cells

Friends

friend class cereal::access

inline friend std::ostream &operator<<(std::ostream &os, CapMemBlock<Coordinates> const &block)

template<typename Coordinates>
class haldls::vx::CapMemBlockConfig : public haldls::vx::DifferentialWriteTrait

#include <capmem.h>

Public Types

typedef Coordinates::CapMemBlockConfigOnDLS coordinate_type

typedef CapMemBlockConfigIOutSelect IOutSelect

typedef std::true_type is_leaf_node

typedef CapMemBlockConfigVRefSelect VRefSelect

Public Functions

CapMemBlockConfig()

template<typename WordT>
void decode(std::array<WordT, config_size_in_words> const &data)

template<typename WordT>
std::array<WordT, config_size_in_words> encode() const

BoostA get_boost_a() const

BoostB get_boost_b() const

BoostFactor get_boost_factor() const

CurrentCellRes get_current_cell_res() const

Coordinates::CapMemCellOnCapMemBlock get_debug_capmem_coord() const

IOutSelect get_debug_i_out_select() const

LevelShifterBias get_debug_level_shifter_bias() const

OutAmpBias get_debug_out_amp_bias() const

bool get_debug_readout_enable() const

SourceFollowerBias get_debug_source_follower_bias() const

VRefSelect get_debug_v_ref_select() const

bool get_enable_autoboost() const

bool get_enable_boost() const

bool get_enable_capmem() const

PauseCounter get_pause_counter() const

PrescalePause get_prescale_pause() const

PrescaleRamp get_prescale_ramp() const

PulseA get_pulse_a() const

PulseB get_pulse_b() const

SubCounter get_sub_counter() const

VGlobalBias get_v_global_bias() const

bool operator!=(CapMemBlockConfig const &other) const

bool operator==(CapMemBlockConfig const &other) const

void set_boost_a(BoostA const &value)

void set_boost_b(BoostB const &value)

void set_boost_factor(BoostFactor const &value)

void set_current_cell_res(CurrentCellRes const &value)

void set_debug_capmem_coord(typename Coordinates::CapMemCellOnCapMemBlock const &value)

void set_debug_i_out_select(IOutSelect const &value)

void set_debug_level_shifter_bias(LevelShifterBias const &value)

void set_debug_out_amp_bias(OutAmpBias const &value)

void set_debug_readout_enable(bool const value)

void set_debug_source_follower_bias(SourceFollowerBias const &value)

void set_debug_v_ref_select(VRefSelect const &value)

void set_enable_autoboost(bool const value)

void set_enable_boost(bool const value)

void set_enable_capmem(bool const value)

void set_pause_counter(PauseCounter const &value)

void set_prescale_pause(PrescalePause const &value)

void set_prescale_ramp(PrescaleRamp const &value)

void set_pulse_a(PulseA const &value)

void set_pulse_b(PulseB const &value)

void set_sub_counter(SubCounter const &value)

void set_v_global_bias(VGlobalBias const &value)

Public Static Functions

template<typename AddressT>
static std::array<AddressT, config_size_in_words> addresses(coordinate_type const &coord)

Public Static Attributes

static constexpr size_t config_size_in_words = 10

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::hardware}

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

BoostA m_boost_a

BoostB m_boost_b

BoostFactor m_boost_factor

CurrentCellRes m_current_cell_res

Coordinates::CapMemCellOnCapMemBlock m_debug_capmem_coord

IOutSelect m_debug_i_out_select

LevelShifterBias m_debug_level_shifter_bias

OutAmpBias m_debug_out_amp_bias

bool m_debug_readout_enable

SourceFollowerBias m_debug_source_follower_bias

VRefSelect m_debug_v_ref_select

bool m_enable_autoboost

bool m_enable_boost

bool m_enable_capmem

PauseCounter m_pause_counter

PrescalePause m_prescale_pause

PrescaleRamp m_prescale_ramp

PulseA m_pulse_a

PulseB m_pulse_b

SubCounter m_sub_counter

VGlobalBias m_v_global_bias

Friends

friend class cereal::access

inline friend std::ostream &operator<<(std::ostream &os, CapMemBlockConfig<Coordinates> const &config)

template<typename Coordinates>
class haldls::vx::CapMemCell : public haldls::vx::DifferentialWriteTrait

#include <capmem.h>

Public Types

typedef Coordinates::CapMemCellOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef std::variant<Value, DisableRefresh> value_type

Public Functions

inline explicit CapMemCell(value_type const &value = Value())

template<typename WordT>
void decode(std::array<WordT, config_size_in_words> const &data)

template<typename WordT>
std::array<WordT, config_size_in_words> encode() const

value_type get_value() const

bool operator!=(CapMemCell const &other) const

bool operator==(CapMemCell const &other) const

void set_value(value_type const &value)

Public Static Functions

template<typename AddressT>
static std::array<AddressT, config_size_in_words> addresses(coordinate_type const &cell)

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

value_type m_value

Friends

friend class cereal::access

inline friend std::ostream &operator<<(std::ostream &os, CapMemCell const &cell)

struct ReferenceGeneratorConfig::CapMemOffset : public halco::common::detail::RantWrapper<CapMemOffset, uint_fast8_t, 63, 0>, public halco::common::detail::RantWrapper<CapMemOffset, uint_fast8_t, 63, 0>

#include <capmem.h>

Public Functions

inline explicit constexpr CapMemOffset(uintmax_t const val = 1)

inline explicit constexpr CapMemOffset(uintmax_t const val = 1)

struct ReferenceGeneratorConfig::CapMemSlope : public halco::common::detail::RantWrapper<CapMemSlope, uint_fast8_t, 63, 0>, public halco::common::detail::RantWrapper<CapMemSlope, uint_fast8_t, 63, 0>

#include <capmem.h>

Public Functions

inline explicit constexpr CapMemSlope(uintmax_t const val = 11)

inline explicit constexpr CapMemSlope(uintmax_t const val = 11)

struct haldls::vx::PLLSelfTest::CheckRange : public halco::common::detail::RantWrapper<CheckRange, uint_fast16_t, 15, 0>

#include <pll.h>

Acceptance range for the internal counter compared to the expected counter.

Decides to let the test PASS or FAIL.

Public Functions

inline explicit constexpr CheckRange(uintmax_t const val = 0)

struct haldls::vx::PLLSelfTest::CheckValue : public halco::common::detail::RantWrapper<CheckValue, uint_fast16_t, 1048575, 0>

#include <pll.h>

Expected counter value within the 2^(p + 2) reference cycles.

counter_value = (f_clk / f ref) * 2^(p + 2)

Public Functions

inline explicit constexpr CheckValue(uintmax_t const val = 0)

class haldls::vx::v2::PLLClockOutputBlock::ClockOutput

#include <pll.h>

Public Functions

ClockOutput () SYMBOL_VISIBLE

Default construct PLL clock output.

bool get_enable_bypass () const SYMBOL_VISIBLE

Get whether the output is set to bypass mode.

If enabled, the FPGA clock is passed through to the output.

Returns

Boolean value

bool get_enable_output () const SYMBOL_VISIBLE

Get whether output is enabled.

Returns

Boolean value

halco::hicann_dls::vx::ADPLLOnDLS get_select_adpll () const SYMBOL_VISIBLE

Get coordinate of selected ADPLL to route to output.

Returns

coord Coordinate of ADPLL to select

ADPLL::Output get_select_adpll_output () const SYMBOL_VISIBLE

Get which output of selected ADPLL to route to output.

Returns

ADPLL output

bool operator!= (ClockOutput const &other) const SYMBOL_VISIBLE

bool operator== (ClockOutput const &other) const SYMBOL_VISIBLE

void set_enable_bypass (bool value) SYMBOL_VISIBLE

Set enable value of the bypass mode.

If enabled, the FPGA clock is passed through to the output.

Parameters

value – Boolean value to set

void set_enable_output (bool value) SYMBOL_VISIBLE

Set enable value of output.

Parameters

value – Boolean value to set

void set_select_adpll (halco::hicann_dls::vx::ADPLLOnDLS const &coord) SYMBOL_VISIBLE

Set select which ADPLL to route to output.

Parameters

coord – Coordinate of ADPLL to select

void set_select_adpll_output (ADPLL::Output const value) SYMBOL_VISIBLE

Set which output of selected ADPLL to route to output.

Parameters

value – ADPLL output

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

halco::hicann_dls::vx::ADPLLOnDLS m_adpll

ADPLL::Output m_adpll_output

bool m_enable_bypass

bool m_enable_output

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, ClockOutput const &config) SYMBOL_VISIBLE

class haldls::vx::v3::PLLClockOutputBlock::ClockOutput

#include <pll.h>

Public Functions

ClockOutput () SYMBOL_VISIBLE

Default construct PLL clock output.

bool get_enable_bypass () const SYMBOL_VISIBLE

Get whether the output is set to bypass mode.

If enabled, the FPGA clock is passed through to the output.

Returns

Boolean value

bool get_enable_output () const SYMBOL_VISIBLE

Get whether output is enabled.

Returns

Boolean value

halco::hicann_dls::vx::ADPLLOnDLS get_select_adpll () const SYMBOL_VISIBLE

Get coordinate of selected ADPLL to route to output.

Returns

coord Coordinate of ADPLL to select

ADPLL::Output get_select_adpll_output () const SYMBOL_VISIBLE

Get which output of selected ADPLL to route to output.

Returns

ADPLL output

bool operator!= (ClockOutput const &other) const SYMBOL_VISIBLE

bool operator== (ClockOutput const &other) const SYMBOL_VISIBLE

void set_enable_bypass (bool value) SYMBOL_VISIBLE

Set enable value of the bypass mode.

If enabled, the FPGA clock is passed through to the output.

Parameters

value – Boolean value to set

void set_enable_output (bool value) SYMBOL_VISIBLE

Set enable value of output.

Parameters

value – Boolean value to set

void set_select_adpll (halco::hicann_dls::vx::ADPLLOnDLS const &coord) SYMBOL_VISIBLE

Set select which ADPLL to route to output.

Parameters

coord – Coordinate of ADPLL to select

void set_select_adpll_output (ADPLL::Output const value) SYMBOL_VISIBLE

Set which output of selected ADPLL to route to output.

Parameters

value – ADPLL output

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

halco::hicann_dls::vx::ADPLLOnDLS m_adpll

ADPLL::Output m_adpll_output

bool m_enable_bypass

bool m_enable_output

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, ClockOutput const &config) SYMBOL_VISIBLE

struct haldls::vx::CommonNeuronBackendConfig::ClockScale : public halco::common::detail::RantWrapper<ClockScale, uint_fast8_t, 15, 0>

#include <neuron.h>

The ClockScale determines the range of the clock and at its precision It’s an exponential power-of-two clock scaling factor: For a given reference clock of f_clk = 250MHz, the resulting frequency is f_clk / (2 ^ (clock_scale + 1)).

This enables clock frequencies from 125MHz (clock_scale = 0) to ~4kHz (clock_scale = 15) See documentation and implementation of RefractoryTime for more background information.

Public Functions

inline explicit constexpr ClockScale(uintmax_t const val = 0)

class haldls::vx::ColumnCorrelationQuad : public haldls::vx::DifferentialWriteTrait

#include <synapse.h>

Public Types

typedef halco::hicann_dls::vx::ColumnCorrelationQuadOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

ColumnCorrelationQuad () SYMBOL_VISIBLE

Default constructor.

template<typename WordT>
void decode(std::array<WordT, config_size_in_words> const &data)

template<typename WordT>
std::array<WordT, config_size_in_words> encode() const

ColumnCorrelationSwitch get_switch (halco::hicann_dls::vx::EntryOnQuad const &correlation_switch) const SYMBOL_VISIBLE

bool operator!= (ColumnCorrelationQuad const &other) const SYMBOL_VISIBLE

bool operator== (ColumnCorrelationQuad const &other) const SYMBOL_VISIBLE

void set_switch (halco::hicann_dls::vx::EntryOnQuad const &correlation_switch, ColumnCorrelationSwitch const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT>
static std::array<AddressT, config_size_in_words> addresses(coordinate_type const &block)

Public Static Attributes

static constexpr size_t config_size_in_words = 4

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

halco::common::typed_array<ColumnCorrelationSwitch, halco::hicann_dls::vx::EntryOnQuad> m_switches

Friends

friend class cereal::access

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::ColumnCorrelationRow >

friend std::ostream & operator<< (std::ostream &, ColumnCorrelationQuad const &) SYMBOL_VISIBLE

struct haldls::vx::ColumnCorrelationQuad::ColumnCorrelationSwitch

#include <synapse.h>

Public Functions

ColumnCorrelationSwitch () SYMBOL_VISIBLE

Default constructor.

bool get_enable_cadc_neuron_readout_acausal () const SYMBOL_VISIBLE

Get enable value for connecting the neuron’s readout circuit to the respective acausal CADC channel.

Keep in mind that the neuron’s readout amplifier must be enabled and biased, but the neuron must not be connected to the readout chain via the collective lines. Otherwise the neurons will be shorted.

Returns

Boolean enable value

bool get_enable_cadc_neuron_readout_causal () const SYMBOL_VISIBLE

Get enable value for connecting the neuron’s readout circuit to the respective causal CADC channel.

Keep in mind that the neuron’s readout amplifier must be enabled and biased, but the neuron must not be connected to the readout chain via the collective lines. Otherwise the neurons will be shorted.

Returns

Boolean enable value

bool get_enable_debug_acausal () const SYMBOL_VISIBLE

Get enable value for connecting acausal correlation to shared debug line.

Returns

Boolean enable value

bool get_enable_debug_causal () const SYMBOL_VISIBLE

Get enable value for connecting causal correlation to shared debug line.

Returns

Boolean enable value

bool get_enable_internal_acausal () const SYMBOL_VISIBLE

Get enable value for the connection between the internal acausal line and the CADC channel.

Returns

Boolean enable value

bool get_enable_internal_causal () const SYMBOL_VISIBLE

Get enable value for the connection between the internal causal line and the CADC channel.

Returns

Boolean enable value

bool operator!= (ColumnCorrelationSwitch const &other) const SYMBOL_VISIBLE

bool operator== (ColumnCorrelationSwitch const &other) const SYMBOL_VISIBLE

void set_enable_cadc_neuron_readout_acausal (bool value) SYMBOL_VISIBLE

Set enable value for connecting the neuron’s readout circuit to the respective acausal CADC channel.

Keep in mind that the neuron’s readout amplifier must be enabled and biased, but the neuron must not be connected to the readout chain via the collective lines. Otherwise the neurons will be shorted.

Parameters

value – Boolean enable value

void set_enable_cadc_neuron_readout_causal (bool value) SYMBOL_VISIBLE

Set enable value for connecting the neuron’s readout circuit to the respective causal CADC channel.

Keep in mind that the neuron’s readout amplifier must be enabled and biased, but the neuron must not be connected to the readout chain via the collective lines. Otherwise the neurons will be shorted.

Parameters

value – Boolean enable value

void set_enable_debug_acausal (bool value) SYMBOL_VISIBLE

Set enable value for connecting acausal correlation to shared debug line.

Parameters

value – Boolean enable value

void set_enable_debug_causal (bool value) SYMBOL_VISIBLE

Set enable value for connecting causal correlation to shared debug line.

Parameters

value – Boolean enable value

void set_enable_internal_acausal (bool value) SYMBOL_VISIBLE

Set enable value for the connection between the internal acausal line and the CADC channel.

Parameters

value – Boolean enable value

void set_enable_internal_causal (bool value) SYMBOL_VISIBLE

Set enable value for the connection between the internal causal line and the CADC channel.

Parameters

value – Boolean enable value

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_enable_cadc_neuron_readout_acausal

bool m_enable_cadc_neuron_readout_causal

bool m_enable_debug_acausal

bool m_enable_debug_causal

bool m_enable_internal_acausal

bool m_enable_internal_causal

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, ColumnCorrelationSwitch const &config) SYMBOL_VISIBLE

class haldls::vx::ColumnCurrentQuad : public haldls::vx::DifferentialWriteTrait

#include <synapse.h>

Public Types

typedef halco::hicann_dls::vx::ColumnCurrentQuadOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

ColumnCurrentQuad () SYMBOL_VISIBLE

Default constructor.

template<typename WordT>
void decode(std::array<WordT, config_size_in_words> const &data)

template<typename WordT>
std::array<WordT, config_size_in_words> encode() const

ColumnCurrentSwitch get_switch (halco::hicann_dls::vx::EntryOnQuad const &current_switch) const SYMBOL_VISIBLE

bool operator!= (ColumnCurrentQuad const &other) const SYMBOL_VISIBLE

bool operator== (ColumnCurrentQuad const &other) const SYMBOL_VISIBLE

void set_switch (halco::hicann_dls::vx::EntryOnQuad const &current_switch, ColumnCurrentSwitch const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT>
static std::array<AddressT, config_size_in_words> addresses(coordinate_type const &block)

Public Static Attributes

static constexpr size_t config_size_in_words = 2

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

halco::common::typed_array<ColumnCurrentSwitch, halco::hicann_dls::vx::EntryOnQuad> m_switches

Friends

friend class cereal::access

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::ColumnCurrentRow >

friend std::ostream & operator<< (std::ostream &os, ColumnCurrentQuad const &config) SYMBOL_VISIBLE

struct haldls::vx::ColumnCurrentQuad::ColumnCurrentSwitch

#include <synapse.h>

Public Functions

ColumnCurrentSwitch () SYMBOL_VISIBLE

Default constructor.

bool get_enable_debug_excitatory () const SYMBOL_VISIBLE

Get enable value for column-global excitatory synaptic current debug-line readout.

In case the neuron’s synaptic input circuit is disconnected, the current pulses originating from the synapse circuits can be read out. Note that current measuring equipment (i. e. source meter) is needed for this measurement. Also note that the readout line is shared amongst multiple synapse columns. Enabling the readout switch will short the synaptic columns, which is however non-destructive.

Returns

Boolean enable value

bool get_enable_debug_inhibitory () const SYMBOL_VISIBLE

Get enable value for column-global inhibitory synaptic current debug-line readout.

In case the neuron’s synaptic input circuit is disconnected, the current pulses originating from the synapse circuits can be read out. Note that current measuring equipment (i. e. source meter) is needed for this measurement. Also note that the readout line is shared amongst multiple synapse columns. Enabling the readout switch will short the synaptic columns, which is however non-destructive.

Returns

Boolean enable value

bool get_enable_synaptic_current_excitatory () const SYMBOL_VISIBLE

Get enable value for forwarding the excitatory synaptic currents of a whole column to the respective neuron’s synaptic input.

Returns

Boolean enable value

bool get_enable_synaptic_current_inhibitory () const SYMBOL_VISIBLE

Get enable value for forwarding the inhibitory synaptic currents of a whole column to the respective neuron’s synaptic input.

Returns

Boolean enable value

bool operator!= (ColumnCurrentSwitch const &other) const SYMBOL_VISIBLE

bool operator== (ColumnCurrentSwitch const &other) const SYMBOL_VISIBLE

void set_enable_debug_excitatory (bool value) SYMBOL_VISIBLE

Set enable value for column-global excitatory synaptic current debug-line readout.

In case the neuron’s synaptic input circuit is disconnected, the current pulses originating from the synapse circuits can be read out. Note that current measuring equipment (i. e. source meter) is needed for this measurement. Also note that the readout line is shared amongst multiple synapse columns. Enabling the readout switch will short the synaptic columns, which is however non-destructive.

Parameters

value – Boolean enable value

void set_enable_debug_inhibitory (bool value) SYMBOL_VISIBLE

Set enable value for column-global inhibitory synaptic current debug-line readout.

In case the neuron’s synaptic input circuit is disconnected, the current pulses originating from the synapse circuits can be read out. Note that current measuring equipment (i. e. source meter) is needed for this measurement. Also note that the readout line is shared amongst multiple synapse columns. Enabling the readout switch will short the synaptic columns, which is however non-destructive.

Parameters

value – Boolean enable value

void set_enable_synaptic_current_excitatory (bool value) SYMBOL_VISIBLE

Set enable value for forwarding the excitatory synaptic currents of a whole column to the respective neuron’s synaptic input.

Parameters

value – Boolean enable value

void set_enable_synaptic_current_inhibitory (bool value) SYMBOL_VISIBLE

Set enable value for forwarding the inhibitory synaptic currents of a whole column to the respective neuron’s synaptic input.

Parameters

value – Boolean enable value

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_enable_debug_excitatory

bool m_enable_debug_inhibitory

bool m_enable_synaptic_current_excitatory

bool m_enable_synaptic_current_inhibitory

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &, ColumnCurrentSwitch const &) SYMBOL_VISIBLE

class haldls::vx::CommonCorrelationConfig

#include <correlation.h>

Correlation reset and readout timing configuration container.

Public Types

typedef halco::hicann_dls::vx::CommonCorrelationConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef halco::common::typed_array<halco::hicann_dls::vx::CapMemBlockOnHemisphere, halco::hicann_dls::vx::CapMemBlockOnHemisphere> RampOffsets

Define the source of the CADC ramp offset voltages.

enum ResetMode

Switch between normal and auto-calibrating correlation reset.

Values:

enumerator normal

enumerator auto_calibrating

Public Functions

CommonCorrelationConfig () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

ResetDuration get_reset_duration () const SYMBOL_VISIBLE

Duration of correlation reset for synapses (+3 ppu clock cycles).

Determines how long the measurement capacitor is connected to the reset voltage.

ResetFallTime get_reset_fall_time () const SYMBOL_VISIBLE

Wait time in PPU clock cycles after disabling the correlation column reset enable.

ResetMode get_reset_mode () const SYMBOL_VISIBLE

Reset mode for correlation storage capacitors.

Defaults to normal mode.

SenseDelay get_sense_delay () const SYMBOL_VISIBLE

Wait time in PPU clock cycles between connecting the outputs of a synapse to the CADC inputs and starting the CADC read.

bool operator!= (CommonCorrelationConfig const &other) const SYMBOL_VISIBLE

bool operator== (CommonCorrelationConfig const &other) const SYMBOL_VISIBLE

return_value_policy (reference)) RampOffsets const &get_cadc_v_offset_assignment() const SYMBOL_VISIBLE

void set_cadc_v_offset_assignment (RampOffsets const &value) SYMBOL_VISIBLE

void set_reset_duration (ResetDuration value) SYMBOL_VISIBLE

void set_reset_fall_time (ResetFallTime value) SYMBOL_VISIBLE

void set_reset_mode (ResetMode value) SYMBOL_VISIBLE

void set_sense_delay (SenseDelay value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 4

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

RampOffsets m_cadc_v_offset_assignment

ResetDuration m_reset_duration

ResetFallTime m_reset_fall_time

ResetMode m_reset_mode

SenseDelay m_sense_delay

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CommonCorrelationConfig const &config) SYMBOL_VISIBLE

class haldls::vx::CommonNeuronBackendConfig : public haldls::vx::DifferentialWriteTrait

#include <neuron.h>

Read/write access to common neuron parameters.

Public Types

typedef halco::hicann_dls::vx::CommonNeuronBackendConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

CommonNeuronBackendConfig () SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

ClockScale get_clock_scale_adaptation_pulse () const SYMBOL_VISIBLE

ClockScale get_clock_scale_fast () const SYMBOL_VISIBLE

ClockScale get_clock_scale_post_pulse () const SYMBOL_VISIBLE

ClockScale get_clock_scale_slow () const SYMBOL_VISIBLE

bool get_enable_clocks () const SYMBOL_VISIBLE

bool get_enable_event_registers () const SYMBOL_VISIBLE

bool get_force_reset () const SYMBOL_VISIBLE

bool get_sample_positive_edge (halco::hicann_dls::vx::NeuronEventOutputOnNeuronBackendBlock coord) const SYMBOL_VISIBLE

WaitFireNeuron get_wait_fire_neuron () const SYMBOL_VISIBLE

WaitGlobalPostPulse get_wait_global_post_pulse () const SYMBOL_VISIBLE

WaitSpikeCounterRead get_wait_spike_counter_read () const SYMBOL_VISIBLE

WaitSpikeCounterReset get_wait_spike_counter_reset () const SYMBOL_VISIBLE

bool operator!= (CommonNeuronBackendConfig const &other) const SYMBOL_VISIBLE

bool operator== (CommonNeuronBackendConfig const &other) const SYMBOL_VISIBLE

void set_clock_scale_adaptation_pulse (ClockScale const val) SYMBOL_VISIBLE

void set_clock_scale_fast (ClockScale const val) SYMBOL_VISIBLE

void set_clock_scale_post_pulse (ClockScale const val) SYMBOL_VISIBLE

void set_clock_scale_slow (ClockScale const val) SYMBOL_VISIBLE

void set_enable_clocks (bool val) SYMBOL_VISIBLE

void set_enable_event_registers (bool val) SYMBOL_VISIBLE

void set_force_reset (bool val) SYMBOL_VISIBLE

void set_sample_positive_edge (halco::hicann_dls::vx::NeuronEventOutputOnNeuronBackendBlock coord, bool val) SYMBOL_VISIBLE

void set_wait_fire_neuron (WaitFireNeuron const val) SYMBOL_VISIBLE

void set_wait_global_post_pulse (WaitGlobalPostPulse const val) SYMBOL_VISIBLE

void set_wait_spike_counter_read (WaitSpikeCounterRead const val) SYMBOL_VISIBLE

void set_wait_spike_counter_reset (WaitSpikeCounterReset const val) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 2

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

ClockScale m_clock_scale_adapt_pulse

ClockScale m_clock_scale_fast

ClockScale m_clock_scale_post_pulse

ClockScale m_clock_scale_slow

bool m_en_clocks

bool m_en_event_regs

bool m_force_reset

halco::common::typed_array<bool, halco::hicann_dls::vx::NeuronEventOutputOnNeuronBackendBlock> m_sample_pos_edge

WaitFireNeuron m_wait_fire_neuron

WaitGlobalPostPulse m_wait_global_post_pulse

WaitSpikeCounterRead m_wait_spike_counter_read

WaitSpikeCounterReset m_wait_spike_counter_reset

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CommonNeuronBackendConfig const &config) SYMBOL_VISIBLE

class haldls::vx::CommonPADIBusConfig : public haldls::vx::DifferentialWriteTrait

#include <padi.h>

Configuration for a PADI bus block.

Each of the four buses can be configured to accept events from the PADI event trigger register or from the SPL1 merger matrix. Additionally the timing of PADI pulses can be modified.

Public Types

typedef halco::hicann_dls::vx::CommonPADIBusConfigOnDLS coordinate_type

typedef halco::common::typed_array<DacenPulseExtension, halco::hicann_dls::vx::PADIBusOnPADIBusBlock> dacen_pulse_extension_type

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::PADIBusOnPADIBusBlock> enable_extended_timing_type

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::PADIBusOnPADIBusBlock> enable_spl1_type

halco::common::typed_array< bool, halco::hicann_dls::vx::PADIBusOnPADIBusBlock > expose_as (_enable_extended_timing_type))

halco::common::typed_array< bool, halco::hicann_dls::vx::PADIBusOnPADIBusBlock > expose_as (_enable_spl1_type))

typedef std::true_type is_leaf_node

Public Functions

CommonPADIBusConfig () SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (CommonPADIBusConfig const &other) const SYMBOL_VISIBLE

bool operator== (CommonPADIBusConfig const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) dacen_pulse_extension_type const &get_dacen_pulse_extension() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) enable_extended_timing_type const &get_enable_extended_timing() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) enable_spl1_type const &get_enable_spl1() const SYMBOL_VISIBLE

void set_dacen_pulse_extension (dacen_pulse_extension_type const &value) SYMBOL_VISIBLE

void set_enable_extended_timing (enable_extended_timing_type const &value) SYMBOL_VISIBLE

void set_enable_spl1 (enable_spl1_type const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::hardware}

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

dacen_pulse_extension_type m_dacen_pulse_extension

enable_extended_timing_type m_enable_extended_timing

enable_spl1_type m_enable_spl1

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CommonPADIBusConfig const &event) SYMBOL_VISIBLE

class haldls::vx::CommonPhyConfigChip

#include <phy.h>

Container for configuration of enable values for the chip-side PHYs.

Public Types

typedef halco::hicann_dls::vx::CommonPhyConfigChipOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

CommonPhyConfigChip () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::OmnibusChipOverJTAG, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::OmnibusChipOverJTAG, config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_enable_phy (halco::hicann_dls::vx::PhyConfigChipOnDLS const &coord) const SYMBOL_VISIBLE

bool operator!= (CommonPhyConfigChip const &other) const SYMBOL_VISIBLE

bool operator== (CommonPhyConfigChip const &other) const SYMBOL_VISIBLE

void set_enable_phy (halco::hicann_dls::vx::PhyConfigChipOnDLS const &coord, bool value) SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusChipOverJTAGAddress, config_size_in_words > addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

halco::common::typed_array<bool, halco::hicann_dls::vx::PhyConfigChipOnDLS> m_enable_phy

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CommonPhyConfigChip const &config) SYMBOL_VISIBLE

class haldls::vx::CommonPhyConfigFPGA

#include <phy.h>

Container for configuration of enable values for the FPGA-side PHYs.

Public Types

typedef halco::hicann_dls::vx::CommonPhyConfigFPGAOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

CommonPhyConfigFPGA () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_enable_phy (halco::hicann_dls::vx::PhyConfigFPGAOnDLS const &coord) const SYMBOL_VISIBLE

bool operator!= (CommonPhyConfigFPGA const &other) const SYMBOL_VISIBLE

bool operator== (CommonPhyConfigFPGA const &other) const SYMBOL_VISIBLE

void set_enable_phy (halco::hicann_dls::vx::PhyConfigFPGAOnDLS const &coord, bool value) SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, config_size_in_words > addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

halco::common::typed_array<bool, halco::hicann_dls::vx::PhyConfigFPGAOnDLS> m_enable_phy

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CommonPhyConfigFPGA const &config) SYMBOL_VISIBLE

class haldls::vx::CommonSTPConfig : public haldls::vx::DifferentialWriteTrait

#include <padi.h>

Common STP configuration shared by synapse drivers per vertical half.

It allows to enable/disable and set the speed for the recovery clock.

Public Types

typedef halco::hicann_dls::vx::CommonSTPConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

CommonSTPConfig () SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_enable_recovery_clock () const SYMBOL_VISIBLE

Enable recovery clock for the STP circuit.

RecoveryClockSpeed get_recovery_clock_speed () const SYMBOL_VISIBLE

Set the scaler for the recovery clock.

bool operator!= (CommonSTPConfig const &other) const SYMBOL_VISIBLE

bool operator== (CommonSTPConfig const &other) const SYMBOL_VISIBLE

void set_enable_recovery_clock (bool const value) SYMBOL_VISIBLE

void set_recovery_clock_speed (RecoveryClockSpeed const value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::hardware, hxcomm::vx::Target::simulation}

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_enable_recovery_clock

RecoveryClockSpeed m_recovery_clock_speed

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CommonSTPConfig const &event) SYMBOL_VISIBLE

class haldls::vx::CommonSynramConfig : public haldls::vx::DifferentialWriteTrait

#include <synapse.h>

Public Types

typedef halco::hicann_dls::vx::CommonSynramConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

CommonSynramConfig () SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

PCConf get_pc_conf_east () const SYMBOL_VISIBLE

PCConf get_pc_conf_west () const SYMBOL_VISIBLE

WConf get_w_conf_east () const SYMBOL_VISIBLE

WConf get_w_conf_west () const SYMBOL_VISIBLE

WaitCtrClear get_wait_ctr_clear () const SYMBOL_VISIBLE

bool operator!= (CommonSynramConfig const &other) const SYMBOL_VISIBLE

bool operator== (CommonSynramConfig const &other) const SYMBOL_VISIBLE

void set_pc_conf_east (PCConf const &value) SYMBOL_VISIBLE

void set_pc_conf_west (PCConf const &value) SYMBOL_VISIBLE

void set_w_conf_east (WConf const &value) SYMBOL_VISIBLE

void set_w_conf_west (WConf const &value) SYMBOL_VISIBLE

void set_wait_ctr_clear (WaitCtrClear const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 3

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

PCConf m_pc_conf_east

PCConf m_pc_conf_west

WConf m_w_conf_east

WConf m_w_conf_west

WaitCtrClear m_wait_ctr_clear

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CommonSynramConfig const &config) SYMBOL_VISIBLE

struct haldls::vx::MADCConfig::ConversionCyclesOffset : public halco::common::detail::RantWrapper<ConversionCyclesOffset, uint_fast8_t, 15, 0>

#include <madc.h>

Public Functions

inline explicit constexpr ConversionCyclesOffset (uintmax_t const val=12) SYMBOL_VISIBLE

struct haldls::vx::ADPLL::CoreDivM0 : public halco::common::detail::RantWrapper<CoreDivM0, uint_fast16_t, 31, 1>

#include <pll.h>

Divider to set the output frequency f_clk_core0 (Together with PreDivP1).

f_clk_core0 = f_dco / (P1 * M0).

Public Functions

inline explicit constexpr CoreDivM0(uintmax_t const val = 1)

struct haldls::vx::ADPLL::CoreDivM1 : public halco::common::detail::RantWrapper<CoreDivM1, uint_fast16_t, 31, 1>

#include <pll.h>

Divider to set the output frequency f_clk_core1 (Together with PreDivP1).

f_clk_core1 = f_dco / (P1 * M1).

Public Functions

inline explicit constexpr CoreDivM1(uintmax_t const val = 2)

class haldls::vx::CorrelationReset

#include <synapse.h>

Container to trigger reset of correlation measurements on a synapse quad.

Public Types

typedef halco::hicann_dls::vx::CorrelationResetOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

CorrelationReset () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (CorrelationReset const &other) const SYMBOL_VISIBLE

bool operator== (CorrelationReset const &other) const SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CorrelationReset const &config) SYMBOL_VISIBLE

struct haldls::vx::SpikeCounterRead::Count : public halco::common::detail::RantWrapper<Count, uint_fast16_t, 255, 0>

#include <neuron.h>

Count of rate counter.

Public Functions

inline explicit constexpr Count(uintmax_t const val = 0)

struct haldls::vx::PLLSelfTestStatus::CounterValue : public halco::common::detail::RantWrapper<CounterValue, uint_fast16_t, 1048575, 0>

#include <pll.h>

Measured counter value in previous self-test execution.

Public Functions

inline explicit constexpr CounterValue(uintmax_t const val = 0)

struct haldls::vx::PhyStatus::CRCErrorCount : public halco::common::detail::BaseType<CRCErrorCount, uint32_t>

#include <phy.h>

Number of CRC errors since last reset.

Public Functions

inline explicit constexpr CRCErrorCount(uintmax_t const val = 0)

class haldls::vx::CrossbarInputDropCounter

#include <routing_crossbar.h>

Crossbar input drop counter accumulating drops at all outputs for which the drop counter accumulation is enabled in the corresponding CrossbarNode.

Public Types

typedef halco::hicann_dls::vx::CrossbarInputOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

CrossbarInputDropCounter () SYMBOL_VISIBLE

Default constructor.

CrossbarInputDropCounter (Value value) SYMBOL_VISIBLE

Construct from value.

Parameters

value – Value

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

Value get_value () const SYMBOL_VISIBLE

Get accumulated drop counter value.

Returns

Value

bool operator!= (CrossbarInputDropCounter const &other) const SYMBOL_VISIBLE

bool operator== (CrossbarInputDropCounter const &other) const SYMBOL_VISIBLE

void set_value (Value value) SYMBOL_VISIBLE

Set accumulated drop counter value.

Parameters

value – Value

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 1

static constexpr size_t write_config_size_in_words = 0

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

Value m_value

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CrossbarInputDropCounter const &config) SYMBOL_VISIBLE

class haldls::vx::CrossbarNode

#include <routing_crossbar.h>

Node of the crossbar routing events from a CrossbarInputOnDLS to a CrossbarOutputOnDLS.

A event is routed exactly if the following statement is true: (event_label & mask) == target

Public Types

typedef halco::hicann_dls::vx::CrossbarNodeOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef halco::hicann_dls::vx::NeuronLabel neuron_label_type

Public Functions

CrossbarNode () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_enable_drop_counter () const SYMBOL_VISIBLE

neuron_label_type get_mask () const SYMBOL_VISIBLE

Get mask to apply with a logical bit-wise AND operation onto incoming event labels.

Returns

NeuronLabel

neuron_label_type get_target () const SYMBOL_VISIBLE

Get target to compare masked incoming event labels to with a bit-wise equality operation.

Returns

NeuronLabel

bool operator!= (CrossbarNode const &other) const SYMBOL_VISIBLE

bool operator== (CrossbarNode const &other) const SYMBOL_VISIBLE

void set_enable_drop_counter (bool value) SYMBOL_VISIBLE

void set_mask (neuron_label_type value) SYMBOL_VISIBLE

Set mask to apply with a bit-wise AND operation onto incoming event labels.

Parameters

value – NeuronLabel

void set_target (neuron_label_type value) SYMBOL_VISIBLE

Set target to compare masked incoming event labels to with a bit-wise equality operation.

Parameters

value – NeuronLabel

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

static const SYMBOL_VISIBLE CrossbarNode drop_all

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::hardware}

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_enable_drop_counter

neuron_label_type m_mask

neuron_label_type m_target

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CrossbarNode const &config) SYMBOL_VISIBLE

class haldls::vx::CrossbarOutputConfig

#include <routing_crossbar.h>

Public Types

typedef halco::hicann_dls::vx::CrossbarOutputConfigOnDLS coordinate_type

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::CrossbarOutputOnDLS> enable_event_counter_type

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::CrossbarL2OutputOnDLS> enable_slow_type

typedef std::true_type is_leaf_node

Public Functions

CrossbarOutputConfig () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (CrossbarOutputConfig const &other) const SYMBOL_VISIBLE

bool operator== (CrossbarOutputConfig const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) enable_event_counter_type const &get_enable_event_counter() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) enable_slow_type const &get_enable_slow() const SYMBOL_VISIBLE

void set_enable_event_counter (enable_event_counter_type const &value) SYMBOL_VISIBLE

Set enable value for event counters.

Parameters

value – Boolean values

void set_enable_slow (enable_slow_type const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::hardware}

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

enable_event_counter_type m_enable_event_counter

enable_slow_type m_enable_slow

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CrossbarOutputConfig const &config) SYMBOL_VISIBLE

class haldls::vx::CrossbarOutputEventCounter

#include <routing_crossbar.h>

Crossbar output event counter counting events routed to an output.

Public Types

typedef halco::hicann_dls::vx::CrossbarOutputOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

CrossbarOutputEventCounter () SYMBOL_VISIBLE

Default constructor.

CrossbarOutputEventCounter (Value value) SYMBOL_VISIBLE

Construct from value.

Parameters

value – Value

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

Value get_value () const SYMBOL_VISIBLE

Get event counter value.

Returns

Value

bool operator!= (CrossbarOutputEventCounter const &other) const SYMBOL_VISIBLE

bool operator== (CrossbarOutputEventCounter const &other) const SYMBOL_VISIBLE

void set_value (Value value) SYMBOL_VISIBLE

Set event counter value.

Parameters

value – Value

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 1

static constexpr size_t write_config_size_in_words = 0

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

Value m_value

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CrossbarOutputEventCounter const &config) SYMBOL_VISIBLE

struct haldls::vx::CurrentDAC::Current : public halco::common::detail::BaseType<Current, uint8_t>

#include <current_dac.h>

Value of current DAC.

Public Functions

inline explicit constexpr Current(uintmax_t const val = 0)

struct haldls::vx::CapMemBlockConfig::CurrentCellRes : public halco::common::detail::RantWrapper<CurrentCellRes, uint_fast16_t, 63, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<CurrentCellRes, uint_fast16_t, 63, 0>::rant_t rant_t

Public Functions

inline explicit constexpr CurrentCellRes()

inline explicit constexpr CurrentCellRes(uintmax_t const val)

class haldls::vx::CurrentDAC

#include <current_dac.h>

Configuration of the current DAC of the readout chain.

Public Types

typedef halco::hicann_dls::vx::CurrentDACOnDLS coordinate_type

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::HemisphereOnDLS> HemisphereType

typedef std::true_type is_leaf_node

enum Sign

Decide whether current is sourced or sinked.

Values:

enumerator source

enumerator sink

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::SynapticInputOnNeuron> SynapseTargetType

Public Functions

CurrentDAC () SYMBOL_VISIBLE

Default constructor with all inputs disabled.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &words) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

HemisphereType get_connect_neuron () const SYMBOL_VISIBLE

Enable mux connection to neuron array current stimulus of corresponding hemisphere.

SynapseTargetType get_connect_synapse () const SYMBOL_VISIBLE

Enable mux connection to synapse.

Current get_current () const SYMBOL_VISIBLE

Value of current DAC.

bool get_enable_current () const SYMBOL_VISIBLE

Enable current source.

Sign get_sign () const SYMBOL_VISIBLE

Select sign of current.

bool operator!= (CurrentDAC const &other) const SYMBOL_VISIBLE

bool operator== (CurrentDAC const &other) const SYMBOL_VISIBLE

void set_connect_neuron (HemisphereType value) SYMBOL_VISIBLE

void set_connect_synapse (SynapseTargetType value) SYMBOL_VISIBLE

void set_current (Current value) SYMBOL_VISIBLE

void set_enable_current (bool value) SYMBOL_VISIBLE

void set_sign (Sign value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

HemisphereType m_connect_neuron

SynapseTargetType m_connect_synapse

Current m_current

bool m_enable_current

Sign m_sign

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, CurrentDAC const &config) SYMBOL_VISIBLE

class haldls::vx::DAC6573ChannelConfig

#include <i2c.h>

Public Types

typedef halco::hicann_dls::vx::DAC6573ChannelOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

inline DAC6573ChannelConfig(Value const &value = Value())

Default constructor.

void decode (std::array< fisch::vx::word_access_type::I2CDAC6573RwRegister, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::I2CDAC6573RwRegister, config_size_in_words > encode () const SYMBOL_VISIBLE

Value get_value () const SYMBOL_VISIBLE

Get DAC channel value.

Returns

Value

bool operator!= (DAC6573ChannelConfig const &other) const SYMBOL_VISIBLE

bool operator== (DAC6573ChannelConfig const &other) const SYMBOL_VISIBLE

void set_value (Value value) SYMBOL_VISIBLE

Set DAC channel value.

Parameters

value – Value to set

Public Static Functions

static std::array< halco::hicann_dls::vx::I2CDAC6573RwRegisterOnBoard, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation}

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

Value m_value

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, DAC6573ChannelConfig const &config) SYMBOL_VISIBLE

class haldls::vx::DACChannel : public haldls::vx::DifferentialWriteTrait

#include <spi.h>

Container for individual configuration of the value of a DAC channel of the xBoard DACs.

Public Types

typedef halco::hicann_dls::vx::DACChannelOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

inline DACChannel(Value const &value = Value())

Construct DAC channel with value.

Parameters

value – Value to construct with

void decode (std::array< fisch::vx::word_access_type::SPIDACDataRegister, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::SPIDACDataRegister, write_config_size_in_words > encode () const SYMBOL_VISIBLE

Value get_value () const SYMBOL_VISIBLE

Get DAC channel value.

Returns

Value to get

bool operator!= (DACChannel const &other) const SYMBOL_VISIBLE

bool operator== (DACChannel const &other) const SYMBOL_VISIBLE

void set_value (Value value) SYMBOL_VISIBLE

Set DAC channel value.

Parameters

value – Value to set

Public Static Functions

static std::array< halco::hicann_dls::vx::SPIDACDataRegisterOnBoard, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::SPIDACDataRegisterOnBoard, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

Value m_value

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, DACChannel const &config) SYMBOL_VISIBLE

class haldls::vx::DACControl : public haldls::vx::DifferentialWriteTrait

#include <spi.h>

Container for enabling DAC channels of a xBoard DAC.

Public Types

typedef halco::hicann_dls::vx::DACOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

DACControl () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::SPIDACControlRegister, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::SPIDACControlRegister, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_enable_channel (halco::hicann_dls::vx::DACChannelOnDAC const &channel) const SYMBOL_VISIBLE

Get DAC channel enable value.

Parameters

channel – Channel to get value for

Returns

Boolean value

bool operator!= (DACControl const &other) const SYMBOL_VISIBLE

bool operator== (DACControl const &other) const SYMBOL_VISIBLE

void set_enable_channel (halco::hicann_dls::vx::DACChannelOnDAC const &channel, bool value) SYMBOL_VISIBLE

Set DAC channel enable value.

Parameters

• channel – Channel to set value for

• value – Boolean value to set

Public Static Functions

static std::array< halco::hicann_dls::vx::SPIDACControlRegisterOnBoard, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::SPIDACControlRegisterOnBoard, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 2

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

halco::common::typed_array<bool, halco::hicann_dls::vx::DACChannelOnDAC> m_enable_channel

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, DACControl const &config) SYMBOL_VISIBLE

struct haldls::vx::CommonPADIBusConfig::DacenPulseExtension : public halco::common::detail::RantWrapper<DacenPulseExtension, uint_fast16_t, 15, 0>

#include <padi.h>

Public Functions

inline explicit constexpr DacenPulseExtension(uintmax_t const val = 0)

struct haldls::vx::ADPLL::DcoPowerSwitch : public halco::common::detail::RantWrapper<DcoPowerSwitch, uint_fast16_t, 63, 0>

#include <pll.h>

Number of activated PMOS header power switches during DCO operation.

Public Functions

inline explicit constexpr DcoPowerSwitch(uintmax_t const val = 63)

struct haldls::vx::CADCConfig::DeadTime : public halco::common::detail::RantWrapper<DeadTime, uint_fast16_t, 255, 0>

#include <cadc.h>

Dead time in cycles after linear ramp increase to wait for signal propagation to every channel to prevent cutting off leaf channel ramps too early.

Public Functions

inline explicit constexpr DeadTime(uintmax_t const val = 20)

struct haldls::vx::detail::PhyConfigBase::DebugOutputs : public halco::common::detail::RantWrapper<DebugOutputs, uint_fast32_t, 1, 0>

#include <phy.h>

Public Functions

inline explicit constexpr DebugOutputs(uintmax_t const val = 0)

class DifferentialWriteTrait

#include <traits.h>

Trait signalling derived-from container type support differential write operation.

Subclassed by haldls::vx::CapMemBlock< Coordinates >, haldls::vx::CapMemBlockConfig< Coordinates >, haldls::vx::CapMemCell< Coordinates >, haldls::vx::ColumnCorrelationQuad, haldls::vx::ColumnCurrentQuad, haldls::vx::CommonNeuronBackendConfig, haldls::vx::CommonPADIBusConfig, haldls::vx::CommonSTPConfig, haldls::vx::CommonSynramConfig, haldls::vx::DACChannel, haldls::vx::DACControl, haldls::vx::NeuronBackendConfig< Coordinates >, haldls::vx::PPUControlRegister, haldls::vx::ShiftRegister, haldls::vx::SynapseCorrelationCalibQuad, haldls::vx::SynapseDriverConfig, haldls::vx::SynapseLabelQuad, haldls::vx::SynapseQuad, haldls::vx::SynapseWeightQuad, haldls::vx::v2::NeuronConfig, haldls::vx::v3::NeuronConfig

struct haldls::vx::CapMemCell::DisableRefresh : public halco::common::detail::RantWrapper<DisableRefresh, uint_fast16_t, 1023, 1023>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<DisableRefresh, uint_fast16_t, 1023, 1023>::rant_t rant_t

Public Functions

inline explicit constexpr DisableRefresh()

inline explicit constexpr DisableRefresh(uintmax_t const val)

struct haldls::vx::detail::SRAMTimingConfig::EnableWidth : public halco::common::detail::RantWrapper<EnableWidth, uint_fast16_t, hate::math::pow(2, 4) - 1, 0>

#include <sram_controller.h>

Duration of enable signal pull.

Public Functions

inline explicit constexpr EnableWidth(uintmax_t const val = 11)

struct haldls::vx::PerfTestStatus::ErrorWord : public halco::common::detail::RantWrapper<ErrorWord, uint_fast32_t, 0xffffffff, 0>

#include <perftest.h>

First non-consecutive payload.

Public Functions

inline explicit constexpr ErrorWord(uintmax_t const val = 0)

struct haldls::vx::VectorGeneratorControl::EventPack : public halco::common::detail::RantWrapper<EventPack, uint_fast8_t, 3, 1>

#include <vector_generator.h>

Event packing to use.

Public Functions

inline explicit constexpr EventPack(uintmax_t const val = 1)

class haldls::vx::EventRecordingConfig

#include <fpga.h>

Container for the event (spikes, MADC samples) recording configuration register.

Public Types

typedef halco::hicann_dls::vx::EventRecordingConfigOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit  EventRecordingConfig () SYMBOL_VISIBLE

void decode (std::array< fisch::vx::word_access_type::Omnibus, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_enable_event_recording () const SYMBOL_VISIBLE

Get enable event recording.

Returns

bool

bool operator!= (EventRecordingConfig const &other) const SYMBOL_VISIBLE

bool operator== (EventRecordingConfig const &other) const SYMBOL_VISIBLE

std::array< halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words > read_addresses (coordinate_type const &word) const SYMBOL_VISIBLE

void set_enable_event_recording (bool value) SYMBOL_VISIBLE

Set enable_event_recording.

Parameters

value – bool to set

std::array< halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words > write_addresses (coordinate_type const &word) const SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 1

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_enable_event_recording

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, EventRecordingConfig const &config) SYMBOL_VISIBLE

class haldls::vx::ExternalPPUMemoryByte

#include <fpga.h>

Public Types

typedef halco::hicann_dls::vx::ExternalPPUMemoryByteOnFPGA coordinate_type

typedef std::true_type is_leaf_node

typedef uint8_t raw_type

Public Functions

inline explicit ExternalPPUMemoryByte(Value value = Value())

void decode (coordinate_type const &coord, std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > encode (coordinate_type const &coord) const SYMBOL_VISIBLE

Value get_value () const SYMBOL_VISIBLE

bool operator!= (ExternalPPUMemoryByte const &other) const SYMBOL_VISIBLE

bool operator== (ExternalPPUMemoryByte const &other) const SYMBOL_VISIBLE

void set_value (Value const &value) SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, config_size_in_words > addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Value m_value

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, ExternalPPUMemoryByte const &config) SYMBOL_VISIBLE

class haldls::vx::ExternalPPUMemoryQuad

#include <fpga.h>

Public Types

typedef halco::hicann_dls::vx::ExternalPPUMemoryQuadOnFPGA coordinate_type

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::EntryOnQuad> Enables

typedef std::true_type is_leaf_node

typedef halco::common::typed_array<Value, halco::hicann_dls::vx::EntryOnQuad> Quad

typedef ExternalPPUMemoryByte::Value Value

Public Functions

ExternalPPUMemoryQuad () SYMBOL_VISIBLE

void decode (std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > encode () const SYMBOL_VISIBLE

Enables const  & get_enables () const SYMBOL_VISIBLE

Quad const  & get_quad () const SYMBOL_VISIBLE

bool operator!= (ExternalPPUMemoryQuad const &other) const SYMBOL_VISIBLE

bool operator== (ExternalPPUMemoryQuad const &other) const SYMBOL_VISIBLE

void set_enables (Enables const &enables) SYMBOL_VISIBLE

void set_quad (Quad const &quad) SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, config_size_in_words > addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Enables m_enables

Quad m_quad

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, ExternalPPUMemoryQuad const &config) SYMBOL_VISIBLE

struct haldls::vx::ADPLL::FilterShift : public halco::common::detail::RantWrapper<FilterShift, uint_fast16_t, 3, 0>

#include <pll.h>

Loop filter gain boost by 2^n during lock-in, leads to lock time reduction.

Public Functions

inline explicit constexpr FilterShift(uintmax_t const val = 3)

class haldls::vx::FPGADeviceDNA

#include <fpga.h>

Container for reading out the unique identifier of the FPGA.

Public Types

typedef halco::hicann_dls::vx::FPGADeviceDNAOnFPGA coordinate_type

typedef std::true_type is_leaf_node

template<typename TL>
struct gen_is_read_and_writeable_lookup_table

Generate lookup table from backend to readable and writable property.

template<typename ...Ts>
struct haldls::vx::detail::gen_is_read_and_writeable_lookup_table<hate::type_list<Ts...>>

#include <is_read_and_writable.h>

Public Static Attributes

static constexpr static std::array< bool, sizeof...(Ts)> value  = {(fisch::vx::IsReadable<decltype(fisch::vx::container_cast(std::declval<Ts>()))>::value &&fisch::vx::IsWritable<decltype(fisch::vx::container_cast(std::declval<Ts>()))>::value)...}

template<typename TL>
struct generate_lookup_table

template<typename ...Ts>
struct haldls::vx::detail::BackendContainerBase::generate_lookup_table<hate::type_list<Ts...>>

#include <traits.h>

Public Types

typedef std::array<Backend, sizeof...(Ts)> table_type

Public Static Functions

template<size_t I, size_t... Is> static inline constexpr static table_type gen (table_type table, std::index_sequence< I, Is... >)

Public Static Attributes

static constexpr static auto backend_index_lookup_table   =       gen(table_type(), std::make_index_sequence<sizeof...(Ts)>())

struct haldls::vx::PADIEvent::HagenActivation : public halco::common::detail::RantWrapper<HagenActivation, uint_fast16_t, 31, 0>

#include <padi.h>

Activation payload in Hagen-mode.

The lower five bits of the six-bit EventAddress payload are used to modulate the pulselength.

Public Functions

inline explicit constexpr HagenActivation(uintmax_t const val = 0)

struct haldls::vx::PADIEvent::HagenAddress : public halco::common::detail::RantWrapper<HagenAddress, uint_fast16_t, 1, 0>

#include <padi.h>

Address in Hagen-mode.

The highest bit of the six-bit EventAddress payload is used as label.

Public Functions

inline explicit constexpr HagenAddress(uintmax_t const val = 0)

struct haldls::vx::SynapseDriverConfig::HagenDACOffset : public halco::common::detail::RantWrapper<HagenDACOffset, uint_fast8_t, 63, 0>

#include <synapse_driver.h>

Public Functions

inline explicit constexpr HagenDACOffset(uintmax_t const val = 0)

template<typename T, typename = void>
struct HasLocalData : public std::false_type

#include <traits.h>

template<typename T>
struct HasLocalData<T, typename boost::enable_if_has_type<typename T::has_local_data>::type> : public T::has_local_data

#include <traits.h>

template<typename T>
struct HasLocalData<T, typename boost::enable_if_has_type<typename T::is_leaf_node>::type> : public T::is_leaf_node

#include <traits.h>

class haldls::vx::HicannARQStatus

#include <arq.h>

Public Types

typedef halco::hicann_dls::vx::HicannARQStatusOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

HicannARQStatus () SYMBOL_VISIBLE

void decode (std::array< fisch::vx::word_access_type::Omnibus, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, write_config_size_in_words > encode () const SYMBOL_VISIBLE

ReadCount get_read_count () const SYMBOL_VISIBLE

RxCount get_rx_count () const SYMBOL_VISIBLE

TxCount get_tx_count () const SYMBOL_VISIBLE

WriteCount get_write_count () const SYMBOL_VISIBLE

bool operator!= (HicannARQStatus const &other) const SYMBOL_VISIBLE

bool operator== (HicannARQStatus const &other) const SYMBOL_VISIBLE

void set_read_count (ReadCount value) SYMBOL_VISIBLE

void set_rx_count (RxCount value) SYMBOL_VISIBLE

void set_tx_count (TxCount value) SYMBOL_VISIBLE

void set_write_count (WriteCount value) SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 4

static constexpr size_t write_config_size_in_words = 0

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

ReadCount m_read_count

RxCount m_rx_count

TxCount m_tx_count

WriteCount m_write_count

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, HicannARQStatus const &config) SYMBOL_VISIBLE

class haldls::vx::HighspeedLinkNotification

#include <event.h>

Highspeed-Link notification from chip.

Public Functions

HighspeedLinkNotification() = default

Default constructor.

HighspeedLinkNotification (fisch::vx::HighspeedLinkNotification const &data) SYMBOL_VISIBLE

Construct a HighspeedLinkNotification from the data representation.

Parameters

data – Data to use

bool get_check_error () const SYMBOL_VISIBLE

Get if check error occured.

Returns

Boolean value

bool get_crc_error () const SYMBOL_VISIBLE

Get if crc error occured.

Returns

Boolean value

bool get_crc_recover () const SYMBOL_VISIBLE

Get if crc is recovered.

Returns

Boolean value

bool get_decode_error () const SYMBOL_VISIBLE

Get if decode error occured.

Returns

Boolean value

FPGATime get_fpga_time () const SYMBOL_VISIBLE

Get FPGA time.

Returns

FPGATime value

bool get_link_up () const SYMBOL_VISIBLE

Get if link is up.

Returns

Boolean value

halco::hicann_dls::vx::PhyStatusOnFPGA get_phy () const SYMBOL_VISIBLE

Get sample value.

Returns

Value value

bool operator!= (HighspeedLinkNotification const &other) const SYMBOL_VISIBLE

bool operator== (HighspeedLinkNotification const &other) const SYMBOL_VISIBLE

void set_check_error (bool value) SYMBOL_VISIBLE

Set if check error occured.

Parameters

value – Boolean value to set

void set_crc_error (bool value) SYMBOL_VISIBLE

Set if crc error occured.

Parameters

value – Boolean value to set

void set_crc_recover (bool value) SYMBOL_VISIBLE

Set if crc is recovered.

Parameters

value – Boolean value to set

void set_decode_error (bool value) SYMBOL_VISIBLE

Set if decode error occured.

Parameters

value – Boolean value to set

void set_fpga_time (FPGATime value) SYMBOL_VISIBLE

Set FPGA time.

Parameters

value – FPGATime value to set

void set_link_up (bool value) SYMBOL_VISIBLE

Set if link is up.

Parameters

value – Boolean value to set

void set_phy (halco::hicann_dls::vx::PhyStatusOnFPGA value) SYMBOL_VISIBLE

Set sample value.

Parameters

value – Value sample value to set

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

bool m_check_error = {false}

bool m_crc_error = {false}

bool m_crc_recover = {false}

bool m_decode_error = {false}

FPGATime m_fpga_time = {}

bool m_link_up = {false}

halco::hicann_dls::vx::PhyStatusOnFPGA m_phy = {}

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, HighspeedLinkNotification const &sample) SYMBOL_VISIBLE

class haldls::vx::INA219Config

#include <i2c.h>

Public Types

enum ADCMode

ADC resolution and number of samples.

Values:

enumerator bits9

enumerator bits10

enumerator bits11

enumerator bits12

enumerator bits12_samples1

enumerator bits12_samples2

enumerator bits12_samples4

enumerator bits12_samples8

enumerator bits12_samples16

enumerator bits12_samples32

enumerator bits12_samples64

enumerator bits12_samples128

typedef halco::hicann_dls::vx::INA219ConfigOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

INA219Config () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::I2CINA219RwRegister, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::I2CINA219RwRegister, config_size_in_words > encode () const SYMBOL_VISIBLE

ADCMode get_bus_adc_mode () const SYMBOL_VISIBLE

Get bus ADC mode value.

Returns

Value

ADCMode get_shunt_adc_mode () const SYMBOL_VISIBLE

Get shunt ADC mode value.

Returns

Value

bool operator!= (INA219Config const &other) const SYMBOL_VISIBLE

bool operator== (INA219Config const &other) const SYMBOL_VISIBLE

void set_bus_adc_mode (ADCMode value) SYMBOL_VISIBLE

Set bus ADC mode value.

Parameters

value – Value

void set_shunt_adc_mode (ADCMode value) SYMBOL_VISIBLE

Set shunt ADC mode value.

Parameters

value – Value

Public Static Functions

static std::array< halco::hicann_dls::vx::I2CINA219RwRegisterOnBoard, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation}

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

ADCMode m_bus_adc_mode

ADCMode m_shunt_adc_mode

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, INA219Config const &config) SYMBOL_VISIBLE

class haldls::vx::INA219Status

#include <i2c.h>

Public Types

typedef halco::hicann_dls::vx::INA219StatusOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

INA219Status () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::I2CINA219RoRegister, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::I2CINA219RoRegister, write_config_size_in_words > encode () const SYMBOL_VISIBLE

BusVoltage get_bus_voltage () const SYMBOL_VISIBLE

Get bus voltage value.

Returns

Value

bool get_bus_voltage_overflow () const SYMBOL_VISIBLE

Get bus voltage overflow value.

Returns

Value

ShuntVoltage get_shunt_voltage () const SYMBOL_VISIBLE

Get shunt voltage value.

Returns

Value

bool operator!= (INA219Status const &other) const SYMBOL_VISIBLE

bool operator== (INA219Status const &other) const SYMBOL_VISIBLE

void set_bus_voltage (BusVoltage value) SYMBOL_VISIBLE

Set bus voltage value.

Parameters

value – Value

void set_bus_voltage_overflow (bool value) SYMBOL_VISIBLE

Set bus voltage overflow value.

Parameters

value – Value

void set_shunt_voltage (ShuntVoltage value) SYMBOL_VISIBLE

Set shunt voltage value.

Parameters

value – Value

UncalibratedPower toUncalibratedPower () const SYMBOL_VISIBLE

Convert bus and shunt voltage to uncalibrated power value.

The voltages are assumed to be correct, the shunt resistance defaults to the expected value of 0.027 Ohm.

Public Static Functions

static std::array< halco::hicann_dls::vx::I2CINA219RoRegisterOnBoard, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::I2CINA219RoRegisterOnBoard, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 2

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation}

static constexpr size_t write_config_size_in_words = 0

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

BusVoltage m_bus_voltage

bool m_bus_voltage_overflow

ShuntVoltage m_shunt_voltage

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, INA219Status const &config) SYMBOL_VISIBLE

struct haldls::vx::PerfTestStatus::InOrder : public halco::common::detail::RantWrapper<InOrder, uint_fast32_t, 0xffffffff, 0>

#include <perftest.h>

Number of words received in order.

Public Functions

inline explicit constexpr InOrder(uintmax_t const val = 0)

struct haldls::vx::NeuronBackendConfig::InputClock : public halco::common::detail::RantWrapper<InputClock, uint_fast8_t, 1, 0>

#include <neuron.h>

There are two independent but equivalent clocks available.

Both clocks can be configured as desired for the use case. See e.g. RefractoryTime

Public Types

typedef halco::common::detail::RantWrapper<InputClock, uint_fast8_t, 1, 0> rant_t

Public Functions

inline explicit constexpr InputClock()

inline explicit constexpr InputClock(uintmax_t const val)

template<typename T, typename = void>
struct IsReadable : public std::false_type

#include <is_readable.h>

template<typename T>
struct IsReadable<T, std::enable_if_t<hate::is_in_type_list<T, NonLeafNodeReadableContainerList>::value>> : public std::true_type

#include <is_readable.h>

template<typename T>
struct IsReadable<T, typename boost::enable_if_has_type<decltype(T::config_size_in_words)>::type> : public std::true_type

#include <is_readable.h>

template<typename T>
struct haldls::vx::detail::IsReadable<T, typename boost::enable_if_has_type<decltype(T::read_config_size_in_words)>::type>

#include <is_readable.h>

Public Static Attributes

static constexpr static bool value   = T::read_config_size_in_words

template<typename T, typename = void>
struct IsWriteable : public std::false_type

#include <is_writeable.h>

template<typename T>
struct IsWriteable<T, std::enable_if_t<hate::is_in_type_list<T, NonLeafNodeWriteableContainerList>::value>> : public std::true_type

#include <is_writeable.h>

template<typename T>
struct IsWriteable<T, typename boost::enable_if_has_type<decltype(T::config_size_in_words)>::type> : public std::true_type

#include <is_writeable.h>

template<typename T>
struct haldls::vx::detail::IsWriteable<T, typename boost::enable_if_has_type<decltype(T::write_config_size_in_words)>::type>

#include <is_writeable.h>

Public Static Attributes

static constexpr static bool value   = T::write_config_size_in_words

template<typename T>
struct haldls::vx::detail::IsWriteReadable

#include <is_writereadable.h>

Public Static Attributes

static constexpr static bool value   = IsReadable<T>::value && IsWriteable<T>::value

class haldls::vx::JTAGClockScaler

#include <jtag.h>

Container writing JTAG clock-scaler value.

Public Types

typedef halco::hicann_dls::vx::JTAGClockScalerOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit  JTAGClockScaler (Value value=Value()) SYMBOL_VISIBLE

Construct scaler with value.

Parameters

value – Value to construct scaler with

void decode (std::array< fisch::vx::word_access_type::JTAGClockScaler, read_config_size_in_words > const &data) SYMBOL_VISIBLE

Decode read words into container config.

Parameters

data – Array of word values

std::array< fisch::vx::word_access_type::JTAGClockScaler, write_config_size_in_words > encode () const SYMBOL_VISIBLE

Get container config encoded in writable words.

Returns

Array of word values

bool operator!= (JTAGClockScaler const &other) const SYMBOL_VISIBLE

bool operator== (JTAGClockScaler const &other) const SYMBOL_VISIBLE

void set (Value value) SYMBOL_VISIBLE

Set clock-scaler value.

Parameters

value – Clock-scaler value to set

Public Static Functions

static std::array< halco::hicann_dls::vx::JTAGClockScalerOnDLS, read_config_size_in_words > read_addresses (coordinate_type const &word) SYMBOL_VISIBLE

Get word addresses for encoding a read.

Returns

Array of addresses

static std::array< halco::hicann_dls::vx::JTAGClockScalerOnDLS, write_config_size_in_words > write_addresses (coordinate_type const &word) SYMBOL_VISIBLE

Get word addresses for encoding a write.

Returns

Array of addresses

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

Number of words for read access.

static constexpr size_t write_config_size_in_words = 1

Number of words for write access.

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

Value m_value

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, JTAGClockScaler const &config) SYMBOL_VISIBLE

class haldls::vx::JTAGIdCode

#include <jtag.h>

Container for reading the JTAG IDCODE.

Public Types

typedef halco::hicann_dls::vx::JTAGIdCodeOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

JTAGIdCode () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::JTAGIdCode, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::JTAGIdCode, write_config_size_in_words > encode () const SYMBOL_VISIBLE

ManufacturerId get_manufacturer_id () const SYMBOL_VISIBLE

Get JEDEC Manufacturer ID code, Heidelberg University has ‘0x057’.

PartNumber get_part_number () const SYMBOL_VISIBLE

Get device identification number.

Version get_version () const SYMBOL_VISIBLE

Get hardware revision number, starting from 0.

bool operator!= (JTAGIdCode const &other) const SYMBOL_VISIBLE

bool operator== (JTAGIdCode const &other) const SYMBOL_VISIBLE

void set_manufacturer_id (ManufacturerId value) SYMBOL_VISIBLE

Set JEDEC Manufacturer ID code, Heidelberg University has ‘0x057’.

void set_part_number (PartNumber value) SYMBOL_VISIBLE

Set device identification number.

void set_version (Version value) SYMBOL_VISIBLE

Set hardware revision number, starting from 0.

Public Static Functions

static std::array< halco::hicann_dls::vx::JTAGIdCodeOnDLS, read_config_size_in_words > read_addresses (coordinate_type const &word) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::JTAGIdCodeOnDLS, write_config_size_in_words > write_addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 1

static constexpr size_t write_config_size_in_words = 0

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

ManufacturerId m_manufacturer_id

PartNumber m_part_number

Version m_version

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, JTAGIdCode const &config) SYMBOL_VISIBLE

struct haldls::vx::CapMemBlockConfig::LevelShifterBias : public halco::common::detail::RantWrapper<LevelShifterBias, uint_fast16_t, 15, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<LevelShifterBias, uint_fast16_t, 15, 0>::rant_t rant_t

Public Functions

inline explicit constexpr LevelShifterBias()

inline explicit constexpr LevelShifterBias(uintmax_t const val)

struct haldls::vx::ADPLL::LoopDivN : public halco::common::detail::RantWrapper<LoopDivN, uint_fast16_t, 31, 1>

#include <pll.h>

Divider to set the frequency of the DCO f_dco (Together with PreDivP0).

f_dco = P0 * N * f_ref.

Public Functions

inline explicit constexpr LoopDivN(uintmax_t const val = 10)

struct haldls::vx::ADPLL::LoopFilterInt : public halco::common::detail::RantWrapper<LoopFilterInt, uint_fast16_t, 31, 1>

#include <pll.h>

Integral part of the PID controller for the DCO.

Public Functions

inline explicit constexpr LoopFilterInt(uintmax_t const val = 2)

struct haldls::vx::ADPLL::LoopFilterProp : public halco::common::detail::RantWrapper<LoopFilterProp, uint_fast16_t, 31, 1>

#include <pll.h>

Proportional part of the PID controller for the DCO.

Public Functions

inline explicit constexpr LoopFilterProp(uintmax_t const val = 8)

struct haldls::vx::MADCConfig::MADCClockScaleValue : public halco::common::detail::RantWrapper<MADCClockScaleValue, uint_fast16_t, 4095, 0>

#include <madc.h>

Public Functions

inline explicit constexpr MADCClockScaleValue (uintmax_t const val=0) SYMBOL_VISIBLE

class haldls::vx::MADCConfig

#include <madc.h>

Configuration container for MADC and related circuitry.

Public Types

typedef halco::hicann_dls::vx::MADCConfigOnDLS coordinate_type

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::HemisphereOnDLS> hemisphere_type

typedef halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection input_selection_type

typedef std::true_type is_leaf_node

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::SynapticInputOnNeuron> synapse_target_type

Public Functions

MADCConfig () SYMBOL_VISIBLE

Default constructor for the MADC config.

The default values are in a usable state, the MADC is connected to the SourceMultiplexerOnReadoutSourceSelection(0). Only the number of samples to record is required to be set.

template<typename AddressT>
std::array<AddressT, config_size_in_words> addresses(coordinate_type const &coord) const

double calculate_sample_rate (double const &madc_base_frequency) const SYMBOL_VISIBLE

Accessors for the sampling rate of the madc in Hz.

The calculation considers the following settings of the MADC state:

• m_sample_duration_adjust

• m_enable_madc_clock_scaling

• m_madc_clock_scale_value

Parameters

madc_base_frequency – Base frequency of the madc, which can be obtained from the ADPLL settings and PLLClockOutputBlock.

Returns

Double describing the madc sample rate

template<typename WordT>
void decode(std::array<WordT, config_size_in_words> const &data)

template<typename WordT>
std::array<WordT, config_size_in_words> encode() const

input_selection_type get_active_mux_initially_selected_input () const SYMBOL_VISIBLE

Set the initially selected input of the active mux.

Caution: the property is called initially_selected_amp in RTL.

ActiveMuxInputSelectLength get_active_mux_input_select_length () const SYMBOL_VISIBLE

Set the number of samples the mux’s inputs are selected for in direct succession.

In the following example the MADC would record four samples on one input, before the mux switches to the other one: input 0: |||| |||| … input 1: |||| |||| …

Caution: the property is called amp_select_length in RTL.

CalibrationWaitValue get_calibration_wait_value () const SYMBOL_VISIBLE

Accessors for the built-in calibration’s timing of the MADC.

bool get_connect_pads_to_madc () const SYMBOL_VISIBLE

bool get_connect_preamp_to_madc () const SYMBOL_VISIBLE

bool get_connect_preamp_to_pads () const SYMBOL_VISIBLE

ConversionCyclesOffset get_conversion_cycles_offset () const SYMBOL_VISIBLE

Configuration for the conversion cycles offset.

This seems to be redundant to sample_duration_adjust. Both settings are summed up in hardware.

Caution: the meaning of this setting was reverse engineered due to a lack of documentation!

bool get_enable_active_mux_amplifiers () const SYMBOL_VISIBLE

bool get_enable_calibration () const SYMBOL_VISIBLE

Accessors for the built-in self-calibration.

bool get_enable_dummy_data () const SYMBOL_VISIBLE

bool get_enable_iconv_amplifier () const SYMBOL_VISIBLE

Accessors for the configuration of the current conversion circuit.

The first property enables the internal amplifier of the circuit. The other properties allow to connect either the direct neuron access or the synaptic debug lines.

bool get_enable_madc_clock_scaling () const SYMBOL_VISIBLE

Accessors for the clock scaling configuration.

The clock is derived from a PLL madc_clk output.

bool get_enable_sar_reset_on_fall () const SYMBOL_VISIBLE

Configuration of the MADC’s SAR reset timing.

SamplingWindowTiming get_iconv_sampling_window_end () const SYMBOL_VISIBLE

SamplingWindowTiming get_iconv_sampling_window_start () const SYMBOL_VISIBLE

MADCClockScaleValue get_madc_clock_scale_value () const SYMBOL_VISIBLE

NumberOfSamples get_number_of_samples () const SYMBOL_VISIBLE

Accessors for the number of samples recorded by the MADC.

The MADC records a fixed number of samples as long as it is not configured to sample continuously (c.f. enable_sample_continously).

Caution: this property is called num_samples in the RTL description.

PowerupWaitValue get_powerup_wait_value () const SYMBOL_VISIBLE

Configuration of the powerup wait value.

This MADC remains in the wake up state for a number of MADC clock cycles determined by this property before transitioning to the READY state (via ENABLE).

PreampGainCapacitorSize get_preamp_gain_capacitor_size () const SYMBOL_VISIBLE

Accessors for the preamplifier’s gain selection capacitor.

SamplingWindowTiming get_preamp_sampling_window_end () const SYMBOL_VISIBLE

SamplingWindowTiming get_preamp_sampling_window_start () const SYMBOL_VISIBLE

Accessors for the timing of the sampling phase for both, the (voltage recording) preamp and the current conversion circuit.

The sampling window is determined by the timing of its rising and falling edge.

Caution: these properties are called phi_vga_toggle[0,1] and phi_2quadrant_toggle[0,1] for the preamp and current conversion, respectively.

SampleDurationAdjust get_sample_duration_adjust () const SYMBOL_VISIBLE

Accessors for the sample duration adjustment.

This seems to be redundant to conversion_cycles_offset. Both settings are summed up in hardware.

Caution: the property is called sample_adjust in RTL. Caution: the meaning of this setting was reverse engineered due to a lack of documentation!

bool get_sample_on_positive_edge () const SYMBOL_VISIBLE

SARResetLength get_sar_reset_length () const SYMBOL_VISIBLE

SARResetWait get_sar_reset_wait () const SYMBOL_VISIBLE

bool get_signal_selection_connect_active_mux () const SYMBOL_VISIBLE

bool get_signal_selection_connect_current_meter () const SYMBOL_VISIBLE

Accessors for the preamp mux located before the preamplifier.

This mux has four (pairs of) inputs: the active mux (for voltage measurements), the current conversion circuit, two debug lines (which might be applied to the chip’s pads), and the preamplifier. The first two serve as signal sources, the latter as a sink. The pads may serve as either. To connect two (or more) sources/sinks, the user must connect any of them.

Caution: the respective properties are called fmc_2_quadrant, fmc_act_mux, fmc_debug, and fmc_to_vga.

bool get_signal_selection_connect_debug () const SYMBOL_VISIBLE

bool get_signal_selection_connect_preamp () const SYMBOL_VISIBLE

bool operator!= (MADCConfig const &other) const SYMBOL_VISIBLE

bool operator== (MADCConfig const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) hemisphere_type const &get_connect_iconv_neuron() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) hemisphere_type const &get_enable_pseudo_differential_reference() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) synapse_target_type const &get_connect_iconv_synapse() const SYMBOL_VISIBLE

void set_active_mux_initially_selected_input (input_selection_type const &value) SYMBOL_VISIBLE

void set_active_mux_input_select_length (ActiveMuxInputSelectLength const &value) SYMBOL_VISIBLE

void set_calibration_wait_value (CalibrationWaitValue const &value) SYMBOL_VISIBLE

void set_connect_iconv_neuron (hemisphere_type const &value) SYMBOL_VISIBLE

void set_connect_iconv_synapse (synapse_target_type const &value) SYMBOL_VISIBLE

void set_connect_pads_to_madc (bool const value) SYMBOL_VISIBLE

void set_connect_preamp_to_madc (bool const value) SYMBOL_VISIBLE

void set_connect_preamp_to_pads (bool const value) SYMBOL_VISIBLE

void set_conversion_cycles_offset (ConversionCyclesOffset const &value) SYMBOL_VISIBLE

void set_enable_active_mux_amplifiers (bool const value) SYMBOL_VISIBLE

void set_enable_calibration (bool const value) SYMBOL_VISIBLE

void set_enable_dummy_data (bool const value) SYMBOL_VISIBLE

void set_enable_iconv_amplifier (bool const value) SYMBOL_VISIBLE

void set_enable_madc_clock_scaling (bool const value) SYMBOL_VISIBLE

void set_enable_pseudo_differential_reference (hemisphere_type const &value) SYMBOL_VISIBLE

void set_enable_sar_reset_on_fall (bool const value) SYMBOL_VISIBLE

void set_iconv_sampling_window_end (SamplingWindowTiming const &value) SYMBOL_VISIBLE

void set_iconv_sampling_window_start (SamplingWindowTiming const &value) SYMBOL_VISIBLE

void set_madc_clock_scale_value (MADCClockScaleValue const &value) SYMBOL_VISIBLE

void set_number_of_samples (NumberOfSamples const &value) SYMBOL_VISIBLE

void set_powerup_wait_value (PowerupWaitValue const &value) SYMBOL_VISIBLE

void set_preamp_gain_capacitor_size (PreampGainCapacitorSize const &value) SYMBOL_VISIBLE

void set_preamp_sampling_window_end (SamplingWindowTiming const &value) SYMBOL_VISIBLE

void set_preamp_sampling_window_start (SamplingWindowTiming const &value) SYMBOL_VISIBLE

void set_sample_duration_adjust (SampleDurationAdjust const &value) SYMBOL_VISIBLE

void set_sample_on_positive_edge (bool const value) SYMBOL_VISIBLE

void set_sar_reset_length (SARResetLength const &value) SYMBOL_VISIBLE

void set_sar_reset_wait (SARResetWait const &value) SYMBOL_VISIBLE

void set_signal_selection_connect_active_mux (bool const value) SYMBOL_VISIBLE

void set_signal_selection_connect_current_meter (bool const value) SYMBOL_VISIBLE

void set_signal_selection_connect_debug (bool const value) SYMBOL_VISIBLE

void set_signal_selection_connect_preamp (bool const value) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 10

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t const)

Private Members

input_selection_type m_active_mux_initially_selected_input

ActiveMuxInputSelectLength m_active_mux_input_select_length

CalibrationWaitValue m_calibration_wait_value

hemisphere_type m_connect_iconv_neuron

synapse_target_type m_connect_iconv_synapse

bool m_connect_pads_to_madc

bool m_connect_preamp_to_madc

bool m_connect_preamp_to_pads

ConversionCyclesOffset m_conversion_cycles_offset

bool m_enable_active_mux_amplifiers

bool m_enable_calibration

bool m_enable_dummy_data

bool m_enable_iconv_amplifier

bool m_enable_madc_clock_scaling

hemisphere_type m_enable_pseudo_differential_reference

bool m_enable_sar_reset_on_fall

SamplingWindowTiming m_iconv_sampling_window_end

SamplingWindowTiming m_iconv_sampling_window_start

MADCClockScaleValue m_madc_clock_scale_value

NumberOfSamples m_number_of_samples

PowerupWaitValue m_powerup_wait_value

PreampGainCapacitorSize m_preamp_gain_capacitor_size

SamplingWindowTiming m_preamp_sampling_window_end

SamplingWindowTiming m_preamp_sampling_window_start

SampleDurationAdjust m_sample_duration_adjust

bool m_sample_on_positive_edge

SARResetLength m_sar_reset_length

SARResetWait m_sar_reset_wait

bool m_signal_selection_connect_active_mux

bool m_signal_selection_connect_current_meter

bool m_signal_selection_connect_debug

bool m_signal_selection_connect_preamp

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, MADCConfig const &config) SYMBOL_VISIBLE

class haldls::vx::MADCControl

#include <madc.h>

Container for MADC control state machine.

Flow chart of state machine: https://chat.bioai.eu/visions/pl/s4o4mq36xtyeigtzkw9kgfihcc FIXME: Add more explanatory description (issue #3471)

Public Types

typedef halco::hicann_dls::vx::MADCControlOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

MADCControl () SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_enable_continuous_sampling () const SYMBOL_VISIBLE

Let the MADC sample continuously.

bool get_enable_iconv_amplifier () const SYMBOL_VISIBLE

Enable switched capacitor amplifier for current measurements.

bool get_enable_power_down_after_sampling () const SYMBOL_VISIBLE

Let the MADC power down after it finished sampling.

bool get_enable_pre_amplifier () const SYMBOL_VISIBLE

Enable switched capacitor pre-amplifier for voltage measurements.

bool get_start_recording () const SYMBOL_VISIBLE

Start a recording.

bool get_stop_recording () const SYMBOL_VISIBLE

Stop a currently active recording.

bool get_wake_up () const SYMBOL_VISIBLE

Wake up the MADC.

bool operator!= (MADCControl const &other) const SYMBOL_VISIBLE

bool operator== (MADCControl const &other) const SYMBOL_VISIBLE

void set_enable_continuous_sampling (bool const value) SYMBOL_VISIBLE

void set_enable_iconv_amplifier (bool const value) SYMBOL_VISIBLE

void set_enable_power_down_after_sampling (bool const value) SYMBOL_VISIBLE

void set_enable_pre_amplifier (bool const value) SYMBOL_VISIBLE

void set_start_recording (bool const value) SYMBOL_VISIBLE

void set_stop_recording (bool const value) SYMBOL_VISIBLE

void set_wake_up (bool const value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_enable_continuous_sampling

bool m_enable_iconv_amplifier

bool m_enable_power_down_after_sampling

bool m_enable_pre_amplifier

bool m_start_recording

bool m_stop_recording

bool m_wake_up

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, MADCControl const &event) SYMBOL_VISIBLE

class haldls::vx::MADCSampleFromChip

#include <event.h>

MADCSample from chip.

It is comprised of the sample value, FPGA and chip time annotation.

Public Types

typedef halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection Channel

Channel selected on the active multiplexer for which this sample was acquired.

Public Functions

MADCSampleFromChip() = default

Default constructor.

inline MADCSampleFromChip(fisch::vx::MADCSampleFromChip const &data)

Construct an MADC sample from the data representation.

Parameters

data – Data to use

inline MADCSampleFromChip(Value const &value, Channel const &channel, FPGATime const &fpga_time, ChipTime const &chip_time)

Construct MADC sample from chip via a value, FPGA and chip time information.

Parameters

• value – sample value to use

• channel – channel from which the value was sampled

• fpga_time – FPGATime to use

• chip_time – ChipTime to use

bool operator!= (MADCSampleFromChip const &other) const SYMBOL_VISIBLE

bool operator== (MADCSampleFromChip const &other) const SYMBOL_VISIBLE

Public Members

Channel channel

Channel from which this sample was obtained.

ChipTime chip_time

Chip time.

FPGATime fpga_time

FPGA time.

Value value

Sample value.

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t const version)

Friends

friend class cereal::access

friend struct detail::MADCSampleFromChipChecker

friend std::ostream & operator<< (std::ostream &os, MADCSampleFromChip const &sample) SYMBOL_VISIBLE

struct MADCSampleFromChipChecker

#include <event.h>

struct haldls::vx::detail::PhyConfigBase::ManualDelay : public halco::common::detail::RantWrapper<ManualDelay, uint_fast32_t, 15, 0>

#include <phy.h>

Public Functions

inline explicit constexpr ManualDelay(uintmax_t const val = 0)

struct haldls::vx::JTAGIdCode::ManufacturerId : public halco::common::detail::RantWrapper<ManufacturerId, uint_fast16_t, 2047, 0>

#include <jtag.h>

JEDEC Manufacturer ID code, Heidelberg University has ‘0x057’.

Public Functions

inline explicit constexpr ManufacturerId(uintmax_t const val = 0)

struct haldls::vx::BackgroundSpikeSource::Mask : public halco::common::detail::RantWrapper<Mask, uint_fast16_t, hate::math::pow(2, 8) - 1, 0>

#include <background.h>

NeuronLabel bit randomization mask.

The lower eight bits of the set neuron label can be replaced by random values on every spike output. Enabled bits lead to replacement by random values.

Public Functions

inline explicit constexpr Mask(uintmax_t const val = 0)

struct haldls::vx::v2::NeuronConfig::MembraneCapacitorSize : public halco::common::detail::RantWrapper<MembraneCapacitorSize, uint_fast8_t, 63, 0>

#include <neuron.h>

Size of membrane capacitor.

Maximal size is ~2.3pF.

Public Functions

inline explicit constexpr MembraneCapacitorSize(uintmax_t const val = 0)

struct haldls::vx::v3::NeuronConfig::MembraneCapacitorSize : public halco::common::detail::RantWrapper<MembraneCapacitorSize, uint_fast8_t, 63, 0>

#include <neuron.h>

Size of membrane capacitor.

Maximal size is ~2.3pF.

Public Functions

inline explicit constexpr MembraneCapacitorSize(uintmax_t const val = 0)

struct haldls::vx::NeuronBackendAddressOut : public halco::common::detail::RantWrapper<NeuronBackendAddressOut, uint_fast16_t, 255, 0>

#include <neuron.h>

Address of the spikes sent out by a neuron.

Public Types

typedef halco::common::detail::RantWrapper<NeuronBackendAddressOut, uint_fast16_t, 255, 0> rant_t

Public Functions

inline explicit constexpr NeuronBackendAddressOut(uintmax_t const val = 0)

template<typename Coordinates>
class haldls::vx::NeuronBackendConfig : public haldls::vx::DifferentialWriteTrait

#include <neuron.h>

Read/write access to the NeuronBackend container.

All relevant settings of the NeuronBackend can be accessed and set via the NeuronBackendConfig. The choice of the parameters (e.g. RefractoryTime) depends on the use case of the user and the targeted biological model/experiment. Implementation examples are yet to be written and will then be found in the CI test environment.

Public Types

typedef NeuronBackendAddressOut AddressOut

typedef Coordinates::NeuronBackendConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

NeuronBackendConfig()

template<typename WordT>
void decode(std::array<WordT, config_size_in_words> const &data)

template<typename WordT>
std::array<WordT, config_size_in_words> encode() const

AddressOut get_address_out() const

bool get_connect_fire_bottom() const

bool get_connect_fire_from_right() const

bool get_connect_fire_to_right() const

bool get_enable_adaptation_pulse() const

bool get_enable_bayesian_0() const

bool get_enable_bayesian_1() const

bool get_enable_bayesian_extension() const

bool get_enable_neuron_master() const

Enable the fire output of a neuron.

If the threshold comparator creates a fire signal, all connected neurons receive a fire input. Even if no neurons are connected, this setting needs to be switched on in order to process the fire signal. If this setting is disabled, spikes will not trigger post pulses in the synapses.

bool get_enable_neuron_slave() const

bool get_enable_spike_out() const

bool get_post_overwrite() const

RefractoryTime get_refractory_time() const

ResetHoldoff get_reset_holdoff() const

InputClock get_select_input_clock() const

bool operator!=(NeuronBackendConfig const &other) const

bool operator==(NeuronBackendConfig const &other) const

void set_address_out(AddressOut addr)

void set_connect_fire_bottom(bool val)

void set_connect_fire_from_right(bool val)

void set_connect_fire_to_right(bool val)

void set_enable_adaptation_pulse(bool val)

void set_enable_bayesian_0(bool val)

void set_enable_bayesian_1(bool val)

void set_enable_bayesian_extension(bool val)

void set_enable_neuron_master(bool val)

void set_enable_neuron_slave(bool val)

void set_enable_spike_out(bool val)

void set_post_overwrite(bool val)

void set_refractory_time(RefractoryTime val)

void set_reset_holdoff(ResetHoldoff val)

void set_select_input_clock(InputClock src)

Public Static Functions

template<typename AddressT>
static std::array<AddressT, config_size_in_words> addresses(coordinate_type const &neuron)

Public Static Attributes

static constexpr size_t config_size_in_words = 4

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation}

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

AddressOut m_address_out

bool m_connect_fire_bottom

bool m_connect_fire_from_right

bool m_connect_fire_to_right

bool m_en_0_baesian

bool m_en_1_baesian

bool m_en_adapt_pulse

bool m_en_baesian_extension

bool m_en_neuron_master

bool m_en_neuron_slave

bool m_en_spike_out

bool m_post_overwrite

RefractoryTime m_refractory_time

ResetHoldoff m_reset_holdoff

InputClock m_select_input_clock

Friends

friend class cereal::access

inline friend std::ostream &operator<<(std::ostream &os, NeuronBackendConfig<Coordinates> const &config)

class haldls::vx::NeuronBackendSRAMTimingConfig : public haldls::vx::detail::SRAMTimingConfig

#include <neuron.h>

Public Types

typedef halco::hicann_dls::vx::NeuronBackendSRAMTimingConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

template<typename AddressT> std::array< AddressT, config_size_in_words > addresses (coordinate_type const &word) const SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

AddressSetupTime get_address_setup_time () const SYMBOL_VISIBLE

EnableWidth get_enable_width () const SYMBOL_VISIBLE

ReadDelay get_read_delay () const SYMBOL_VISIBLE

bool operator!= (NeuronBackendSRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator!= (SRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator== (NeuronBackendSRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator== (SRAMTimingConfig const &other) const SYMBOL_VISIBLE

void set_address_setup_time (AddressSetupTime value) SYMBOL_VISIBLE

void set_enable_width (EnableWidth value) SYMBOL_VISIBLE

void set_read_delay (ReadDelay value) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 2

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation, hxcomm::vx::Target::hardware}

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, NeuronBackendSRAMTimingConfig const &config) SYMBOL_VISIBLE

class haldls::vx::v2::NeuronConfig : public haldls::vx::DifferentialWriteTrait

#include <neuron.h>

Public Types

typedef halco::hicann_dls::vx::v2::NeuronConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

enum ReadoutSource

Source of readout output.

Values:

enumerator membrane

enumerator exc_synin

enumerator inh_synin

enumerator adaptation

Public Functions

NeuronConfig () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_connect_bottom () const SYMBOL_VISIBLE

bool get_connect_membrane_right () const SYMBOL_VISIBLE

bool get_connect_soma () const SYMBOL_VISIBLE

bool get_connect_soma_right () const SYMBOL_VISIBLE

bool get_enable_adaptation () const SYMBOL_VISIBLE

bool get_enable_bypass_excitatory () const SYMBOL_VISIBLE

bool get_enable_bypass_inhibitory () const SYMBOL_VISIBLE

bool get_enable_divide_multicomp_conductance_bias () const SYMBOL_VISIBLE

bool get_enable_exponential () const SYMBOL_VISIBLE

bool get_enable_fire () const SYMBOL_VISIBLE

bool get_enable_leak_degeneration () const SYMBOL_VISIBLE

bool get_enable_leak_division () const SYMBOL_VISIBLE

bool get_enable_leak_multiplication () const SYMBOL_VISIBLE

bool get_enable_membrane_offset () const SYMBOL_VISIBLE

bool get_enable_multicomp_conductance () const SYMBOL_VISIBLE

bool get_enable_multiply_multicomp_conductance_bias () const SYMBOL_VISIBLE

bool get_enable_pause () const SYMBOL_VISIBLE

bool get_enable_readout () const SYMBOL_VISIBLE

bool get_enable_readout_amplifier () const SYMBOL_VISIBLE

bool get_enable_reset_degeneration () const SYMBOL_VISIBLE

bool get_enable_reset_division () const SYMBOL_VISIBLE

bool get_enable_reset_multiplication () const SYMBOL_VISIBLE

bool get_enable_strong_fire () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_excitatory () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_excitatory_high_resistance () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_excitatory_small_capacitor () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_inhibitory () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_inhibitory_high_resistance () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_inhibitory_small_capacitor () const SYMBOL_VISIBLE

bool get_enable_threshold_comparator () const SYMBOL_VISIBLE

bool get_enable_unbuffered_access () const SYMBOL_VISIBLE

bool get_invert_adaptation_a () const SYMBOL_VISIBLE

bool get_invert_adaptation_b () const SYMBOL_VISIBLE

bool get_invert_membrane_offset () const SYMBOL_VISIBLE

MembraneCapacitorSize get_membrane_capacitor_size () const SYMBOL_VISIBLE

ReadoutSource get_readout_source () const SYMBOL_VISIBLE

bool operator!= (NeuronConfig const &other) const SYMBOL_VISIBLE

bool operator== (NeuronConfig const &other) const SYMBOL_VISIBLE

void set_connect_bottom (bool value) SYMBOL_VISIBLE

void set_connect_membrane_right (bool value) SYMBOL_VISIBLE

void set_connect_soma (bool value) SYMBOL_VISIBLE

void set_connect_soma_right (bool value) SYMBOL_VISIBLE

void set_enable_adaptation (bool value) SYMBOL_VISIBLE

void set_enable_bypass_excitatory (bool value) SYMBOL_VISIBLE

void set_enable_bypass_inhibitory (bool value) SYMBOL_VISIBLE

void set_enable_divide_multicomp_conductance_bias (bool value) SYMBOL_VISIBLE

void set_enable_exponential (bool value) SYMBOL_VISIBLE

void set_enable_fire (bool value) SYMBOL_VISIBLE

void set_enable_leak_degeneration (bool value) SYMBOL_VISIBLE

void set_enable_leak_division (bool value) SYMBOL_VISIBLE

void set_enable_leak_multiplication (bool value) SYMBOL_VISIBLE

void set_enable_membrane_offset (bool value) SYMBOL_VISIBLE

void set_enable_multicomp_conductance (bool value) SYMBOL_VISIBLE

void set_enable_multiply_multicomp_conductance_bias (bool value) SYMBOL_VISIBLE

void set_enable_pause (bool value) SYMBOL_VISIBLE

void set_enable_readout (bool value) SYMBOL_VISIBLE

void set_enable_readout_amplifier (bool value) SYMBOL_VISIBLE

void set_enable_reset_degeneration (bool value) SYMBOL_VISIBLE

void set_enable_reset_division (bool value) SYMBOL_VISIBLE

void set_enable_reset_multiplication (bool value) SYMBOL_VISIBLE

void set_enable_strong_fire (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_excitatory (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_excitatory_high_resistance (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_excitatory_small_capacitor (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_inhibitory (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_inhibitory_high_resistance (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_inhibitory_small_capacitor (bool value) SYMBOL_VISIBLE

void set_enable_threshold_comparator (bool value) SYMBOL_VISIBLE

void set_enable_unbuffered_access (bool value) SYMBOL_VISIBLE

void set_invert_adaptation_a (bool value) SYMBOL_VISIBLE

void set_invert_adaptation_b (bool value) SYMBOL_VISIBLE

void set_invert_membrane_offset (bool value) SYMBOL_VISIBLE

void set_membrane_capacitor_size (MembraneCapacitorSize value) SYMBOL_VISIBLE

void set_readout_source (ReadoutSource value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 6

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation}

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_connect_bottom

bool m_connect_membrane_right

bool m_connect_soma

bool m_connect_somata

bool m_en_adapt

bool m_en_byp_exc

bool m_en_byp_inh

bool m_en_comp_cond

bool m_en_comp_cond_div

bool m_en_comp_cond_mul

bool m_en_exp

bool m_en_fire

bool m_en_leak_deg

bool m_en_leak_div

bool m_en_leak_mul

bool m_en_mem_off

bool m_en_pause

bool m_en_readout

bool m_en_readout_amp

bool m_en_reset_deg

bool m_en_reset_div

bool m_en_reset_mul

bool m_en_strong_fire

bool m_en_synin_exc

bool m_en_synin_exc_high_res

bool m_en_synin_exc_small_cap

bool m_en_synin_inh

bool m_en_synin_inh_high_res

bool m_en_synin_inh_small_cap

bool m_en_thresh_comp

bool m_en_unbuf_access

bool m_invert_adapt_a

bool m_invert_adapt_b

bool m_invert_current

MembraneCapacitorSize m_mem_cap_size

ReadoutSource m_readout_select

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, NeuronConfig const &config) SYMBOL_VISIBLE

class haldls::vx::v3::NeuronConfig : public haldls::vx::DifferentialWriteTrait

#include <neuron.h>

Public Types

typedef halco::hicann_dls::vx::v3::NeuronConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

enum ReadoutSource

Source of readout output.

Values:

enumerator membrane

enumerator exc_synin

enumerator inh_synin

enumerator adaptation

Public Functions

NeuronConfig () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_connect_bottom () const SYMBOL_VISIBLE

bool get_connect_membrane_right () const SYMBOL_VISIBLE

bool get_connect_soma () const SYMBOL_VISIBLE

bool get_connect_soma_right () const SYMBOL_VISIBLE

bool get_enable_adaptation () const SYMBOL_VISIBLE

bool get_enable_bypass_excitatory () const SYMBOL_VISIBLE

bool get_enable_bypass_inhibitory () const SYMBOL_VISIBLE

bool get_enable_divide_multicomp_conductance_bias () const SYMBOL_VISIBLE

bool get_enable_exponential () const SYMBOL_VISIBLE

bool get_enable_fire () const SYMBOL_VISIBLE

bool get_enable_leak_degeneration () const SYMBOL_VISIBLE

bool get_enable_leak_division () const SYMBOL_VISIBLE

bool get_enable_leak_multiplication () const SYMBOL_VISIBLE

bool get_enable_membrane_offset () const SYMBOL_VISIBLE

bool get_enable_multicomp_conductance () const SYMBOL_VISIBLE

bool get_enable_multiply_multicomp_conductance_bias () const SYMBOL_VISIBLE

bool get_enable_pause () const SYMBOL_VISIBLE

bool get_enable_readout () const SYMBOL_VISIBLE

bool get_enable_readout_amplifier () const SYMBOL_VISIBLE

bool get_enable_reset_degeneration () const SYMBOL_VISIBLE

bool get_enable_reset_division () const SYMBOL_VISIBLE

bool get_enable_reset_multiplication () const SYMBOL_VISIBLE

bool get_enable_strong_fire () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_excitatory () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_excitatory_coba_mode () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_excitatory_high_resistance () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_excitatory_small_capacitance () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_inhibitory () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_inhibitory_coba_mode () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_inhibitory_high_resistance () const SYMBOL_VISIBLE

bool get_enable_synaptic_input_inhibitory_small_capacitance () const SYMBOL_VISIBLE

bool get_enable_threshold_comparator () const SYMBOL_VISIBLE

bool get_enable_unbuffered_access () const SYMBOL_VISIBLE

bool get_invert_adaptation_a () const SYMBOL_VISIBLE

bool get_invert_adaptation_b () const SYMBOL_VISIBLE

bool get_invert_membrane_offset () const SYMBOL_VISIBLE

MembraneCapacitorSize get_membrane_capacitor_size () const SYMBOL_VISIBLE

ReadoutSource get_readout_source () const SYMBOL_VISIBLE

bool operator!= (NeuronConfig const &other) const SYMBOL_VISIBLE

bool operator== (NeuronConfig const &other) const SYMBOL_VISIBLE

void set_connect_bottom (bool value) SYMBOL_VISIBLE

void set_connect_membrane_right (bool value) SYMBOL_VISIBLE

void set_connect_soma (bool value) SYMBOL_VISIBLE

void set_connect_soma_right (bool value) SYMBOL_VISIBLE

void set_enable_adaptation (bool value) SYMBOL_VISIBLE

void set_enable_bypass_excitatory (bool value) SYMBOL_VISIBLE

void set_enable_bypass_inhibitory (bool value) SYMBOL_VISIBLE

void set_enable_divide_multicomp_conductance_bias (bool value) SYMBOL_VISIBLE

void set_enable_exponential (bool value) SYMBOL_VISIBLE

void set_enable_fire (bool value) SYMBOL_VISIBLE

void set_enable_leak_degeneration (bool value) SYMBOL_VISIBLE

void set_enable_leak_division (bool value) SYMBOL_VISIBLE

void set_enable_leak_multiplication (bool value) SYMBOL_VISIBLE

void set_enable_membrane_offset (bool value) SYMBOL_VISIBLE

void set_enable_multicomp_conductance (bool value) SYMBOL_VISIBLE

void set_enable_multiply_multicomp_conductance_bias (bool value) SYMBOL_VISIBLE

void set_enable_pause (bool value) SYMBOL_VISIBLE

void set_enable_readout (bool value) SYMBOL_VISIBLE

void set_enable_readout_amplifier (bool value) SYMBOL_VISIBLE

void set_enable_reset_degeneration (bool value) SYMBOL_VISIBLE

void set_enable_reset_division (bool value) SYMBOL_VISIBLE

void set_enable_reset_multiplication (bool value) SYMBOL_VISIBLE

void set_enable_strong_fire (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_excitatory (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_excitatory_coba_mode (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_excitatory_high_resistance (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_excitatory_small_capacitance (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_inhibitory (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_inhibitory_coba_mode (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_inhibitory_high_resistance (bool value) SYMBOL_VISIBLE

void set_enable_synaptic_input_inhibitory_small_capacitance (bool value) SYMBOL_VISIBLE

void set_enable_threshold_comparator (bool value) SYMBOL_VISIBLE

void set_enable_unbuffered_access (bool value) SYMBOL_VISIBLE

void set_invert_adaptation_a (bool value) SYMBOL_VISIBLE

void set_invert_adaptation_b (bool value) SYMBOL_VISIBLE

void set_invert_membrane_offset (bool value) SYMBOL_VISIBLE

void set_membrane_capacitor_size (MembraneCapacitorSize value) SYMBOL_VISIBLE

void set_readout_source (ReadoutSource value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 6

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation}

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_connect_bottom

bool m_connect_membrane_right

bool m_connect_soma

bool m_connect_somata

bool m_en_adapt

bool m_en_byp_exc

bool m_en_byp_inh

bool m_en_comp_cond

bool m_en_comp_cond_div

bool m_en_comp_cond_mul

bool m_en_exp

bool m_en_fire

bool m_en_leak_deg

bool m_en_leak_div

bool m_en_leak_mul

bool m_en_mem_off

bool m_en_pause

bool m_en_readout

bool m_en_readout_amp

bool m_en_reset_deg

bool m_en_reset_div

bool m_en_reset_mul

bool m_en_strong_fire

bool m_en_synin_exc

bool m_en_synin_exc_coba

bool m_en_synin_exc_high_res

bool m_en_synin_exc_small_cap

bool m_en_synin_inh

bool m_en_synin_inh_coba

bool m_en_synin_inh_high_res

bool m_en_synin_inh_small_cap

bool m_en_thresh_comp

bool m_en_unbuf_access

bool m_invert_adapt_a

bool m_invert_adapt_b

bool m_invert_current

MembraneCapacitorSize m_mem_cap_size

ReadoutSource m_readout_select

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, NeuronConfig const &config) SYMBOL_VISIBLE

class haldls::vx::NeuronReset

#include <neuron.h>

Container to trigger reset of a single neuron.

Public Types

typedef halco::hicann_dls::vx::NeuronResetOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

NeuronReset () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (NeuronReset const &other) const SYMBOL_VISIBLE

bool operator== (NeuronReset const &other) const SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, NeuronReset const &config) SYMBOL_VISIBLE

class haldls::vx::v2::NeuronResetQuad

#include <neuron.h>

Container to trigger reset of a quad of neurons at once.

Currently, also the correlation in the corresponding synapse quad in row zero is reset. This behaviour will be fixed for HX-v2 (issue 3346).

Public Types

typedef halco::hicann_dls::vx::v2::NeuronResetQuadOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

NeuronResetQuad () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (NeuronResetQuad const &other) const SYMBOL_VISIBLE

bool operator== (NeuronResetQuad const &other) const SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, NeuronResetQuad const &config) SYMBOL_VISIBLE

class haldls::vx::v3::NeuronResetQuad

#include <neuron.h>

Container to trigger reset of a quad of neurons at once.

Currently, also the correlation in the corresponding synapse quad in row zero is reset. This behaviour will be fixed for HX-v3 (issue 3346).

Public Types

typedef halco::hicann_dls::vx::v3::NeuronResetQuadOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

NeuronResetQuad () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (NeuronResetQuad const &other) const SYMBOL_VISIBLE

bool operator== (NeuronResetQuad const &other) const SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, NeuronResetQuad const &config) SYMBOL_VISIBLE

class haldls::vx::NeuronSRAMTimingConfig : public haldls::vx::detail::SRAMTimingConfig

#include <neuron.h>

Public Types

typedef halco::hicann_dls::vx::NeuronSRAMTimingConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

template<typename AddressT> std::array< AddressT, config_size_in_words > addresses (coordinate_type const &word) const SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

AddressSetupTime get_address_setup_time () const SYMBOL_VISIBLE

EnableWidth get_enable_width () const SYMBOL_VISIBLE

ReadDelay get_read_delay () const SYMBOL_VISIBLE

bool operator!= (NeuronSRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator!= (SRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator== (NeuronSRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator== (SRAMTimingConfig const &other) const SYMBOL_VISIBLE

void set_address_setup_time (AddressSetupTime value) SYMBOL_VISIBLE

void set_enable_width (EnableWidth value) SYMBOL_VISIBLE

void set_read_delay (ReadDelay value) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 2

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation}

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, NeuronSRAMTimingConfig const &config) SYMBOL_VISIBLE

class haldls::vx::NullPayloadReadable

#include <null_payload_readable.h>

Public Types

typedef halco::hicann_dls::vx::NullPayloadReadableOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

NullPayloadReadable() = default

void decode (std::array< fisch::vx::word_access_type::NullPayloadReadable, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::NullPayloadReadable, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (NullPayloadReadable const &other) const SYMBOL_VISIBLE

bool operator== (NullPayloadReadable const &other) const SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::NullPayloadReadableOnFPGA, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::NullPayloadReadableOnFPGA, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 1

static constexpr size_t write_config_size_in_words = 0

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, NullPayloadReadable const &config) SYMBOL_VISIBLE

struct haldls::vx::MADCConfig::NumberOfSamples : public halco::common::detail::RantWrapper<NumberOfSamples, uint_fast16_t, 65535, 0>

#include <madc.h>

Public Functions

inline explicit constexpr NumberOfSamples (uintmax_t const val=0) SYMBOL_VISIBLE

struct haldls::vx::CADCChannelConfig::Offset : public halco::common::detail::RantWrapper<Offset, int_fast16_t, 127, -128>

#include <cadc.h>

Offset value to add to measurement.

Public Types

typedef halco::common::detail::RantWrapper<Offset, int_fast16_t, 127, -128> rant_t

Public Functions

inline explicit constexpr Offset(intmax_t const val = 0)

struct haldls::vx::SynapseDriverConfig::Offset : public halco::common::detail::RantWrapper<Offset, uint_fast8_t, 15, 0>

#include <synapse_driver.h>

Public Functions

inline explicit constexpr Offset(uintmax_t const val = 0)

struct haldls::vx::PhyStatus::OnlineTime : public halco::common::detail::BaseType<OnlineTime, uint32_t>

#include <phy.h>

Online time in cycles since last reset.

Public Functions

inline explicit constexpr OnlineTime(uintmax_t const val = 0)

struct haldls::vx::CapMemBlockConfig::OutAmpBias : public halco::common::detail::RantWrapper<OutAmpBias, uint_fast16_t, 15, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<OutAmpBias, uint_fast16_t, 15, 0>::rant_t rant_t

Public Functions

inline explicit constexpr OutAmpBias()

inline explicit constexpr OutAmpBias(uintmax_t const val)

class haldls::vx::PADIEvent

#include <padi.h>

A container for the PADI event trigger register.

There exists one trigger register per block of PADI buses. Events carry the actual event address, a row select address to determine the target synapse driver row, and a mask to specify the set of PADI buses to fire the event on.

Public Types

typedef halco::hicann_dls::vx::PADIEventOnDLS coordinate_type

using EventAddress = haldls::vx::SynapseLabelValue

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::PADIBusOnPADIBusBlock> fire_bus_type

typedef std::true_type is_leaf_node

Public Functions

PADIEvent () SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

EventAddress get_event_address () const SYMBOL_VISIBLE

Set event address, which is eventually forwarded to synapses.

HagenActivation get_hagen_activation () const SYMBOL_VISIBLE

Set Hagen-mode activation payload, which is eventually forwarded to synapses.

This setting accesses the lower five bits of the EventAddress.

HagenAddress get_hagen_address () const SYMBOL_VISIBLE

Set Hagen-mode address, which is eventually forwarded to synapses.

This setting accesses the highest bit of the EventAddress.

RowSelectAddress get_row_select_address () const SYMBOL_VISIBLE

Set row select address determining the synapse driver which is supposed to fire.

Note that each synapse driver can be configured to match only parts of the row select address.

bool operator!= (PADIEvent const &other) const SYMBOL_VISIBLE

bool operator== (PADIEvent const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) fire_bus_type const &get_fire_bus() const SYMBOL_VISIBLE

void set_event_address (EventAddress const value) SYMBOL_VISIBLE

void set_fire_bus (fire_bus_type const &value) SYMBOL_VISIBLE

void set_hagen_activation (HagenActivation const value) SYMBOL_VISIBLE

void set_hagen_address (HagenAddress const value) SYMBOL_VISIBLE

void set_row_select_address (RowSelectAddress const value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

EventAddress m_event_address

fire_bus_type m_fire_bus

RowSelectAddress m_row_select_address

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PADIEvent const &event) SYMBOL_VISIBLE

struct haldls::vx::SpikeLabel::PADILabel : public halco::common::detail::RantWrapper<PADILabel, uint_fast16_t, 0x3ff, 0>

#include <event.h>

Label type processed by PADI-bus, bits 0-10.

Public Functions

inline explicit constexpr PADILabel(uintmax_t const val = 0)

class haldls::vx::PadMultiplexerConfig

#include <readout.h>

A configuration container for the top-level readout mux, selecting the connections between an analog readout pad and different components on the chip.

There are two equal instances of this mux on the chip, one for each of the two pads.

Public Types

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection> buffer_type

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::CapMemBlockOnDLS> capmem_quadrant_type

typedef halco::hicann_dls::vx::PadMultiplexerConfigOnDLS coordinate_type

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::HemisphereOnDLS> hemisphere_type

typedef std::true_type is_leaf_node

Public Functions

PadMultiplexerConfig () SYMBOL_VISIBLE

Default constructor with all inputs disabled.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &words) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_cadc_debug_acausal_to_synapse_intermediate_mux () const SYMBOL_VISIBLE

Enable connection of acausal CADC debug line to intermediate mux.

To reach the pad, the connection between the synapse intermediate mux and the pad has to be enabled as well.

bool get_cadc_debug_causal_to_synapse_intermediate_mux () const SYMBOL_VISIBLE

Enable connection of causal CADC debug line to intermediate mux.

To reach the pad, the connection between the synapse intermediate mux and the pad has to be enabled as well.

bool get_cadc_v_ramp_mux_to_pad () const SYMBOL_VISIBLE

Enable connection of cadc_v_ramp_mux to pad.

bool get_capmem_i_out_mux_to_capmem_intermediate_mux () const SYMBOL_VISIBLE

Enable connection of capmem_i_out_mux to intermediate mux.

To reach the pad, the connection between the CapMem intermediate mux and the pad has to be enabled as well.

bool get_capmem_intermediate_mux_to_pad () const SYMBOL_VISIBLE

Enable connection of CapMem intermediate mux to pad.

The intermediate mux selects between different capmem-specific sources.

bool get_capmem_v_out_mux_to_capmem_intermediate_mux () const SYMBOL_VISIBLE

Enable connection of capmem_v_out_mux to intermediate mux.

To reach the pad, the connection between the CapMem intermediate mux and the pad has to be enabled as well.

bool get_capmem_v_ref_mux_to_capmem_intermediate_mux () const SYMBOL_VISIBLE

Enable connection of capmem_v_ref_mux to intermediate mux.

To reach the pad, the connection between the CapMem intermediate mux and the pad has to be enabled as well.

bool get_debug_to_pad () const SYMBOL_VISIBLE

Enable connection of debug lines to pad.

Enabling this connection on pad 0 connects the debug_plus line to that pad, enabling this connection on pad 1 connects the debug_minus line to that pad.

bool get_neuron_i_stim_mux_to_pad () const SYMBOL_VISIBLE

Enable connection of neuron unbuffered membrane access neuron_i_stim_mux to pad.

bool get_synapse_intermediate_mux_to_pad () const SYMBOL_VISIBLE

Enable connection of synapse intermediate mux to pad.

The intermediate mux selects between different sources in the synapse array, namely the debug lines at the synaptic input and the correlation readout.

bool get_synin_debug_excitatory_to_synapse_intermediate_mux () const SYMBOL_VISIBLE

Enable connection of excitatory synaptic input debug line to intermediate mux.

To reach the pad, the connection between the synapse intermediate mux and the pad has to be enabled as well.

bool get_synin_debug_inhibitory_to_synapse_intermediate_mux () const SYMBOL_VISIBLE

Enable connection of inhibitory synaptic input debug line to intermediate mux.

To reach the pad, the connection between the synapse intermediate mux and the pad has to be enabled as well.

bool operator!= (PadMultiplexerConfig const &other) const SYMBOL_VISIBLE

bool operator== (PadMultiplexerConfig const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) buffer_type const &get_buffer_to_pad() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) capmem_quadrant_type const &get_cadc_v_ramp_mux() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) capmem_quadrant_type const &get_capmem_i_out_mux() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) capmem_quadrant_type const &get_capmem_v_out_mux() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) capmem_quadrant_type const &get_capmem_v_ref_mux() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) hemisphere_type const &get_neuron_i_stim_mux() const SYMBOL_VISIBLE

void set_buffer_to_pad (buffer_type const &value) SYMBOL_VISIBLE

void set_cadc_debug_acausal_to_synapse_intermediate_mux (bool value) SYMBOL_VISIBLE

void set_cadc_debug_causal_to_synapse_intermediate_mux (bool value) SYMBOL_VISIBLE

void set_cadc_v_ramp_mux (capmem_quadrant_type const &value) SYMBOL_VISIBLE

void set_cadc_v_ramp_mux_to_pad (bool value) SYMBOL_VISIBLE

void set_capmem_i_out_mux (capmem_quadrant_type const &value) SYMBOL_VISIBLE

void set_capmem_i_out_mux_to_capmem_intermediate_mux (bool value) SYMBOL_VISIBLE

void set_capmem_intermediate_mux_to_pad (bool value) SYMBOL_VISIBLE

void set_capmem_v_out_mux (capmem_quadrant_type const &value) SYMBOL_VISIBLE

void set_capmem_v_out_mux_to_capmem_intermediate_mux (bool value) SYMBOL_VISIBLE

void set_capmem_v_ref_mux (capmem_quadrant_type const &value) SYMBOL_VISIBLE

void set_capmem_v_ref_mux_to_capmem_intermediate_mux (bool value) SYMBOL_VISIBLE

void set_debug_to_pad (bool value) SYMBOL_VISIBLE

void set_neuron_i_stim_mux (hemisphere_type const &value) SYMBOL_VISIBLE

void set_neuron_i_stim_mux_to_pad (bool value) SYMBOL_VISIBLE

void set_synapse_intermediate_mux_to_pad (bool value) SYMBOL_VISIBLE

void set_synin_debug_excitatory_to_synapse_intermediate_mux (bool value) SYMBOL_VISIBLE

void set_synin_debug_inhibitory_to_synapse_intermediate_mux (bool value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 2

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

buffer_type m_buffer_to_pad

bool m_cadc_debug_acausal_to_inter

bool m_cadc_debug_causal_to_inter

capmem_quadrant_type m_cadc_v_ramp_mux

bool m_cadc_v_ramp_mux_to_pad

capmem_quadrant_type m_capmem_i_out_mux

bool m_capmem_i_out_mux_to_inter

bool m_capmem_inter_mux_to_pad

capmem_quadrant_type m_capmem_v_out_mux

bool m_capmem_v_out_mux_to_inter

capmem_quadrant_type m_capmem_v_ref_mux

bool m_capmem_v_ref_mux_to_inter

bool m_debug_to_pad

hemisphere_type m_neuron_i_stim_mux

bool m_neuron_i_stim_mux_to_pad

bool m_synapse_inter_mux_to_pad

bool m_synin_debug_excitatory_to_inter

bool m_synin_debug_inhibitory_to_inter

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PadMultiplexerConfig const &config) SYMBOL_VISIBLE

struct haldls::vx::JTAGIdCode::PartNumber : public halco::common::detail::RantWrapper<PartNumber, uint_fast16_t, 65535, 0>

#include <jtag.h>

Device identification number.

Public Functions

inline explicit constexpr PartNumber(uintmax_t const val = 0)

struct haldls::vx::CapMemBlockConfig::PauseCounter : public halco::common::detail::RantWrapper<PauseCounter, uint_fast32_t, 4294967295, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<PauseCounter, uint_fast32_t, 4294967295, 0>::rant_t rant_t

Public Functions

inline explicit constexpr PauseCounter()

inline explicit constexpr PauseCounter(uintmax_t const val)

struct haldls::vx::CommonSynramConfig::PCConf : public halco::common::detail::RantWrapper<PCConf, uint_fast16_t, 15, 0>

#include <synapse.h>

Precharge configuration.

A higher value results in a shorter time. See: Hock, Matthias. (2014). Modern Semiconductor Technologies for Neuromorphic Hardware, p.26ff, p.156f, http://doi.org/10.11588/heidok.00017129.

Public Functions

inline explicit constexpr PCConf(uintmax_t const val = 8)

class haldls::vx::PerfTest

#include <perftest.h>

Container for enabling highspeed perf test.

Words transfering an increasing counter value are sent. The received word count is expected to be equal to the sent count and all received words are expected to be in order. The test execution does not block playback execution.

Public Types

typedef halco::hicann_dls::vx::PerfTestOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit  PerfTest (bool value=false) SYMBOL_VISIBLE

Construct perf test with enable value.

Parameters

value – Enable value of test execution

void decode (std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_enable () const SYMBOL_VISIBLE

Get enable value of test execution.

Returns

value Boolean value

bool operator!= (PerfTest const &other) const SYMBOL_VISIBLE

bool operator== (PerfTest const &other) const SYMBOL_VISIBLE

void set_enable (bool value) SYMBOL_VISIBLE

Set enable value of test execution.

Parameters

value – Boolean value

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, config_size_in_words > addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

bool m_enable

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PerfTest const &config) SYMBOL_VISIBLE

class haldls::vx::PerfTestStatus

#include <perftest.h>

Container for perf test result readout.

Public Types

typedef halco::hicann_dls::vx::PerfTestStatusOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PerfTestStatus () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::Omnibus, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, write_config_size_in_words > encode () const SYMBOL_VISIBLE

ErrorWord get_error_word () const SYMBOL_VISIBLE

Get index of first non-consecutive word.

Returns

ErrorWord index value

InOrder get_in_order () const SYMBOL_VISIBLE

Get number of words received in order.

Returns

InOrder counter value

Received get_received () const SYMBOL_VISIBLE

Get number of successfully received words.

Returns

Received counter value

Sent get_sent () const SYMBOL_VISIBLE

Get number of successfully sent words.

Returns

Sent counter value

bool operator!= (PerfTestStatus const &other) const SYMBOL_VISIBLE

bool operator== (PerfTestStatus const &other) const SYMBOL_VISIBLE

void set_error_word (ErrorWord value) SYMBOL_VISIBLE

Set index of first non-consecutive word.

Parameters

value – ErrorWord index value

void set_in_order (InOrder value) SYMBOL_VISIBLE

Set number of words received in order.

Parameters

value – InOrder counter value

void set_received (Received value) SYMBOL_VISIBLE

Set number of successfully received words.

Parameters

value – Received counter value

void set_sent (Sent value) SYMBOL_VISIBLE

Set number of successfully sent words.

Parameters

value – Sent counter value

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words > read_addresses (coordinate_type const &word) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words > write_addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 4

static constexpr size_t write_config_size_in_words = 0

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

ErrorWord m_error_word

InOrder m_in_order

Received m_received

Sent m_sent

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PerfTestStatus const &config) SYMBOL_VISIBLE

struct haldls::vx::BackgroundSpikeSource::Period : public halco::common::detail::RantWrapper<Period, uint_fast32_t, hate::math::pow(2, 16) - 1, 0>

#include <background.h>

Inter-spike interval for regular and inter-bin interval for Poisson spike generation.

The period is set in units of clock cycles.

Public Functions

inline explicit constexpr Period(uintmax_t const val = 0)

class haldls::vx::detail::PhyConfigBase

#include <phy.h>

Common base class for PhyConfig of the FPGA- and chip-side PHYs.

Subclassed by haldls::vx::PhyConfigChip, haldls::vx::PhyConfigFPGA

Public Types

typedef std::true_type is_leaf_node

Public Functions

DebugOutputs get_debug_outputs () const SYMBOL_VISIBLE

bool get_enable_auto_init () const SYMBOL_VISIBLE

bool get_enable_ber_loopback () const SYMBOL_VISIBLE

bool get_enable_bit_slip () const SYMBOL_VISIBLE

bool get_enable_clock_pre_alignment () const SYMBOL_VISIBLE

bool get_enable_delay_cell_measurement () const SYMBOL_VISIBLE

bool get_enable_des_recal () const SYMBOL_VISIBLE

bool get_enable_force_lvds_power_up () const SYMBOL_VISIBLE

bool get_enable_force_start () const SYMBOL_VISIBLE

bool get_enable_initialization_master_mode () const SYMBOL_VISIBLE

bool get_enable_loopback_en () const SYMBOL_VISIBLE

bool get_enable_manual_training_mode () const SYMBOL_VISIBLE

bool get_enable_manual_tx_data_valid_for_init () const SYMBOL_VISIBLE

bool get_enable_transmission_without_idle_pattern () const SYMBOL_VISIBLE

ManualDelay get_manual_delay () const SYMBOL_VISIBLE

VBias get_vbias () const SYMBOL_VISIBLE

bool operator!= (PhyConfigBase const &other) const SYMBOL_VISIBLE

bool operator== (PhyConfigBase const &other) const SYMBOL_VISIBLE

void set_debug_outputs (DebugOutputs value) SYMBOL_VISIBLE

void set_enable_auto_init (bool value) SYMBOL_VISIBLE

void set_enable_ber_loopback (bool value) SYMBOL_VISIBLE

void set_enable_bit_slip (bool value) SYMBOL_VISIBLE

void set_enable_clock_pre_alignment (bool value) SYMBOL_VISIBLE

void set_enable_delay_cell_measurement (bool value) SYMBOL_VISIBLE

void set_enable_des_recal (bool value) SYMBOL_VISIBLE

void set_enable_force_lvds_power_up (bool value) SYMBOL_VISIBLE

void set_enable_force_start (bool value) SYMBOL_VISIBLE

void set_enable_initialization_master_mode (bool value) SYMBOL_VISIBLE

void set_enable_loopback_en (bool value) SYMBOL_VISIBLE

void set_enable_manual_training_mode (bool value) SYMBOL_VISIBLE

void set_enable_manual_tx_data_valid_for_init (bool value) SYMBOL_VISIBLE

void set_enable_transmission_without_idle_pattern (bool value) SYMBOL_VISIBLE

void set_manual_delay (ManualDelay value) SYMBOL_VISIBLE

void set_vbias (VBias value) SYMBOL_VISIBLE

Protected Functions

PhyConfigBase () SYMBOL_VISIBLE

template<typename Archive> void cerealize_impl (Archive &ar) SYMBOL_VISIBLE

uint32_t pack () const SYMBOL_VISIBLE

void unpack (uint32_t value) SYMBOL_VISIBLE

Protected Attributes

DebugOutputs m_debug_outputs

bool m_enable_auto_init

bool m_enable_ber_loopback

bool m_enable_bit_slip

bool m_enable_clock_pre_alignment

bool m_enable_delay_cell_measurement

bool m_enable_des_recal

bool m_enable_force_lvds_power_up

bool m_enable_force_start

bool m_enable_initialization_master_mode

bool m_enable_loopback_en

bool m_enable_manual_training_mode

bool m_enable_manual_tx_data_valid_for_init

bool m_enable_transmission_without_idle_pattern

ManualDelay m_manual_delay

VBias m_vbias

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PhyConfigBase const &config) SYMBOL_VISIBLE

class haldls::vx::PhyConfigChip : public haldls::vx::detail::PhyConfigBase

#include <phy.h>

Container for individual configuration of chip-side PHYs.

Public Types

typedef halco::hicann_dls::vx::PhyConfigChipOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PhyConfigChip () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::JTAGPhyRegister, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::JTAGPhyRegister, write_config_size_in_words > encode () const SYMBOL_VISIBLE

DebugOutputs get_debug_outputs () const SYMBOL_VISIBLE

bool get_enable_auto_init () const SYMBOL_VISIBLE

bool get_enable_ber_loopback () const SYMBOL_VISIBLE

bool get_enable_bit_slip () const SYMBOL_VISIBLE

bool get_enable_clock_pre_alignment () const SYMBOL_VISIBLE

bool get_enable_delay_cell_measurement () const SYMBOL_VISIBLE

bool get_enable_des_recal () const SYMBOL_VISIBLE

bool get_enable_force_lvds_power_up () const SYMBOL_VISIBLE

bool get_enable_force_start () const SYMBOL_VISIBLE

bool get_enable_initialization_master_mode () const SYMBOL_VISIBLE

bool get_enable_loopback_en () const SYMBOL_VISIBLE

bool get_enable_manual_training_mode () const SYMBOL_VISIBLE

bool get_enable_manual_tx_data_valid_for_init () const SYMBOL_VISIBLE

bool get_enable_transmission_without_idle_pattern () const SYMBOL_VISIBLE

ManualDelay get_manual_delay () const SYMBOL_VISIBLE

VBias get_vbias () const SYMBOL_VISIBLE

bool operator!= (PhyConfigBase const &other) const SYMBOL_VISIBLE

bool operator!= (PhyConfigChip const &other) const SYMBOL_VISIBLE

bool operator== (PhyConfigBase const &other) const SYMBOL_VISIBLE

bool operator== (PhyConfigChip const &other) const SYMBOL_VISIBLE

void set_debug_outputs (DebugOutputs value) SYMBOL_VISIBLE

void set_enable_auto_init (bool value) SYMBOL_VISIBLE

void set_enable_ber_loopback (bool value) SYMBOL_VISIBLE

void set_enable_bit_slip (bool value) SYMBOL_VISIBLE

void set_enable_clock_pre_alignment (bool value) SYMBOL_VISIBLE

void set_enable_delay_cell_measurement (bool value) SYMBOL_VISIBLE

void set_enable_des_recal (bool value) SYMBOL_VISIBLE

void set_enable_force_lvds_power_up (bool value) SYMBOL_VISIBLE

void set_enable_force_start (bool value) SYMBOL_VISIBLE

void set_enable_initialization_master_mode (bool value) SYMBOL_VISIBLE

void set_enable_loopback_en (bool value) SYMBOL_VISIBLE

void set_enable_manual_training_mode (bool value) SYMBOL_VISIBLE

void set_enable_manual_tx_data_valid_for_init (bool value) SYMBOL_VISIBLE

void set_enable_transmission_without_idle_pattern (bool value) SYMBOL_VISIBLE

void set_manual_delay (ManualDelay value) SYMBOL_VISIBLE

void set_vbias (VBias value) SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::JTAGPhyRegisterOnDLS, read_config_size_in_words > read_addresses (coordinate_type const &word) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::JTAGPhyRegisterOnDLS, write_config_size_in_words > write_addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Protected Functions

template<typename Archive> void cerealize_impl (Archive &ar) SYMBOL_VISIBLE

uint32_t pack () const SYMBOL_VISIBLE

void unpack (uint32_t value) SYMBOL_VISIBLE

Protected Attributes

DebugOutputs m_debug_outputs

bool m_enable_auto_init

bool m_enable_ber_loopback

bool m_enable_bit_slip

bool m_enable_clock_pre_alignment

bool m_enable_delay_cell_measurement

bool m_enable_des_recal

bool m_enable_force_lvds_power_up

bool m_enable_force_start

bool m_enable_initialization_master_mode

bool m_enable_loopback_en

bool m_enable_manual_training_mode

bool m_enable_manual_tx_data_valid_for_init

bool m_enable_transmission_without_idle_pattern

ManualDelay m_manual_delay

VBias m_vbias

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PhyConfigChip const &config) SYMBOL_VISIBLE

class haldls::vx::PhyConfigFPGA : public haldls::vx::detail::PhyConfigBase

#include <phy.h>

Container for individual configuration of FPGA-side PHYs.

Public Types

typedef halco::hicann_dls::vx::PhyConfigFPGAOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PhyConfigFPGA () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > encode () const SYMBOL_VISIBLE

DebugOutputs get_debug_outputs () const SYMBOL_VISIBLE

bool get_enable_auto_init () const SYMBOL_VISIBLE

bool get_enable_ber_loopback () const SYMBOL_VISIBLE

bool get_enable_bit_slip () const SYMBOL_VISIBLE

bool get_enable_clock_pre_alignment () const SYMBOL_VISIBLE

bool get_enable_delay_cell_measurement () const SYMBOL_VISIBLE

bool get_enable_des_recal () const SYMBOL_VISIBLE

bool get_enable_force_lvds_power_up () const SYMBOL_VISIBLE

bool get_enable_force_start () const SYMBOL_VISIBLE

bool get_enable_initialization_master_mode () const SYMBOL_VISIBLE

bool get_enable_loopback_en () const SYMBOL_VISIBLE

bool get_enable_manual_training_mode () const SYMBOL_VISIBLE

bool get_enable_manual_tx_data_valid_for_init () const SYMBOL_VISIBLE

bool get_enable_transmission_without_idle_pattern () const SYMBOL_VISIBLE

ManualDelay get_manual_delay () const SYMBOL_VISIBLE

VBias get_vbias () const SYMBOL_VISIBLE

bool operator!= (PhyConfigBase const &other) const SYMBOL_VISIBLE

bool operator!= (PhyConfigFPGA const &other) const SYMBOL_VISIBLE

bool operator== (PhyConfigBase const &other) const SYMBOL_VISIBLE

bool operator== (PhyConfigFPGA const &other) const SYMBOL_VISIBLE

void set_debug_outputs (DebugOutputs value) SYMBOL_VISIBLE

void set_enable_auto_init (bool value) SYMBOL_VISIBLE

void set_enable_ber_loopback (bool value) SYMBOL_VISIBLE

void set_enable_bit_slip (bool value) SYMBOL_VISIBLE

void set_enable_clock_pre_alignment (bool value) SYMBOL_VISIBLE

void set_enable_delay_cell_measurement (bool value) SYMBOL_VISIBLE

void set_enable_des_recal (bool value) SYMBOL_VISIBLE

void set_enable_force_lvds_power_up (bool value) SYMBOL_VISIBLE

void set_enable_force_start (bool value) SYMBOL_VISIBLE

void set_enable_initialization_master_mode (bool value) SYMBOL_VISIBLE

void set_enable_loopback_en (bool value) SYMBOL_VISIBLE

void set_enable_manual_training_mode (bool value) SYMBOL_VISIBLE

void set_enable_manual_tx_data_valid_for_init (bool value) SYMBOL_VISIBLE

void set_enable_transmission_without_idle_pattern (bool value) SYMBOL_VISIBLE

void set_manual_delay (ManualDelay value) SYMBOL_VISIBLE

void set_vbias (VBias value) SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, config_size_in_words > addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Protected Functions

template<typename Archive> void cerealize_impl (Archive &ar) SYMBOL_VISIBLE

uint32_t pack () const SYMBOL_VISIBLE

void unpack (uint32_t value) SYMBOL_VISIBLE

Protected Attributes

DebugOutputs m_debug_outputs

bool m_enable_auto_init

bool m_enable_ber_loopback

bool m_enable_bit_slip

bool m_enable_clock_pre_alignment

bool m_enable_delay_cell_measurement

bool m_enable_des_recal

bool m_enable_force_lvds_power_up

bool m_enable_force_start

bool m_enable_initialization_master_mode

bool m_enable_loopback_en

bool m_enable_manual_training_mode

bool m_enable_manual_tx_data_valid_for_init

bool m_enable_transmission_without_idle_pattern

ManualDelay m_manual_delay

VBias m_vbias

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PhyConfigFPGA const &config) SYMBOL_VISIBLE

class haldls::vx::PhyStatus

#include <phy.h>

Public Types

typedef halco::hicann_dls::vx::PhyStatusOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PhyStatus () SYMBOL_VISIBLE

void decode (std::array< fisch::vx::word_access_type::Omnibus, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, write_config_size_in_words > encode () const SYMBOL_VISIBLE

CRCErrorCount get_crc_error_count () const SYMBOL_VISIBLE

OnlineTime get_online_time () const SYMBOL_VISIBLE

RxCount get_rx_count () const SYMBOL_VISIBLE

RxDroppedCount get_rx_dropped_count () const SYMBOL_VISIBLE

TxCount get_tx_count () const SYMBOL_VISIBLE

bool operator!= (PhyStatus const &other) const SYMBOL_VISIBLE

bool operator== (PhyStatus const &other) const SYMBOL_VISIBLE

void set_crc_error_count (CRCErrorCount value) SYMBOL_VISIBLE

void set_online_time (OnlineTime value) SYMBOL_VISIBLE

void set_rx_count (RxCount value) SYMBOL_VISIBLE

void set_rx_dropped_count (RxDroppedCount value) SYMBOL_VISIBLE

void set_tx_count (TxCount value) SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 5

static constexpr size_t write_config_size_in_words = 0

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

CRCErrorCount m_crc_error_count

OnlineTime m_online_time

RxCount m_rx_count

RxDroppedCount m_rx_dropped_count

TxCount m_tx_count

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PhyStatus const &config) SYMBOL_VISIBLE

class haldls::vx::v2::PLLClockOutputBlock

#include <pll.h>

Container for configuration of the clock outputs of the PLL.

Public Types

typedef halco::hicann_dls::vx::PLLClockOutputBlockOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PLLClockOutputBlock () SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

ClockOutput const  & get_clock_output (halco::hicann_dls::vx::PLLClockOutputOnDLS const &coord) const SYMBOL_VISIBLE

Get clock output configuration.

Parameters

coord – Coordinate of clock output to get

Returns

Configuration of clock output

bool operator!= (PLLClockOutputBlock const &other) const SYMBOL_VISIBLE

bool operator== (PLLClockOutputBlock const &other) const SYMBOL_VISIBLE

void set_clock_output (halco::hicann_dls::vx::PLLClockOutputOnDLS const &coord, ClockOutput const &config) SYMBOL_VISIBLE

Set clock output configuration.

Parameters

• coord – Coordinate of clock output to set

• config – Configuration of clock output to set

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

halco::common::typed_array<ClockOutput, halco::hicann_dls::vx::PLLClockOutputOnDLS> m_output

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PLLClockOutputBlock const &config) SYMBOL_VISIBLE

class haldls::vx::v3::PLLClockOutputBlock

#include <pll.h>

Container for configuration of the clock outputs of the PLL.

Public Types

typedef halco::hicann_dls::vx::PLLClockOutputBlockOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PLLClockOutputBlock () SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

ClockOutput const  & get_clock_output (halco::hicann_dls::vx::PLLClockOutputOnDLS const &coord) const SYMBOL_VISIBLE

Get clock output configuration.

Parameters

coord – Coordinate of clock output to get

Returns

Configuration of clock output

halco::hicann_dls::vx::PLLClockOutputOnDLS const  & get_spl1_source () const SYMBOL_VISIBLE

Get SPL1 / Omnibus clock source.

Returns

Clock source for SPL1 / Omnibus clock.

bool operator!= (PLLClockOutputBlock const &other) const SYMBOL_VISIBLE

bool operator== (PLLClockOutputBlock const &other) const SYMBOL_VISIBLE

void set_clock_output (halco::hicann_dls::vx::PLLClockOutputOnDLS const &coord, ClockOutput const &config) SYMBOL_VISIBLE

Set clock output configuration.

Parameters

• coord – Coordinate of clock output to set

• config – Configuration of clock output to set

void set_spl1_source (halco::hicann_dls::vx::PLLClockOutputOnDLS const &coord) SYMBOL_VISIBLE

Set SPL1 / Omnibus clock source.

Parameters

coord – Coordinate of clock source for SPL1 / Omnibus.

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

halco::common::typed_array<ClockOutput, halco::hicann_dls::vx::PLLClockOutputOnDLS> m_output

bool m_switch_spl1_to_madc

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PLLClockOutputBlock const &config) SYMBOL_VISIBLE

class haldls::vx::PLLSelfTest

#include <pll.h>

Container for configuration and triggering of the PLL internal self test.

Public Types

typedef halco::hicann_dls::vx::PLLSelfTestOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PLLSelfTest () SYMBOL_VISIBLE

Default construct PLL self test.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

CheckRange get_check_range () const SYMBOL_VISIBLE

CheckValue get_check_value () const SYMBOL_VISIBLE

bool get_clock_enable () const SYMBOL_VISIBLE

Get wheter the clock is enabled for the self-test.

Before executing a valid test, this has to be written to be false.

Returns

Boolean value

PreScalerP get_pre_scaler_p () const SYMBOL_VISIBLE

halco::hicann_dls::vx::PLLClockOutputOnDLS get_select_source () const SYMBOL_VISIBLE

Get selected source output to test.

Returns

Selected PLLClockOutputOnDLS

bool operator!= (PLLSelfTest const &other) const SYMBOL_VISIBLE

bool operator== (PLLSelfTest const &other) const SYMBOL_VISIBLE

void set_check_range (CheckRange value) SYMBOL_VISIBLE

void set_check_value (CheckValue value) SYMBOL_VISIBLE

void set_clock_enable (bool value) SYMBOL_VISIBLE

Set to enable the clock for the self-test.

Before executing a valid test, this has to be written to be false.

Parameters

value – Boolean value to set

void set_pre_scaler_p (PreScalerP value) SYMBOL_VISIBLE

void set_select_source (halco::hicann_dls::vx::PLLClockOutputOnDLS value) SYMBOL_VISIBLE

Set selected source output to test.

Parameters

To – be selected PLLClockOutputOnDLS

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

CheckRange m_check_range

CheckValue m_check_value

bool m_clock_enable

PreScalerP m_pre_scaler_p

halco::hicann_dls::vx::PLLClockOutputOnDLS m_select_source

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PLLSelfTest const &config) SYMBOL_VISIBLE

class haldls::vx::PLLSelfTestStatus

#include <pll.h>

Container of PLL self-test status data.

Public Types

typedef halco::hicann_dls::vx::PLLSelfTestStatusOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PLLSelfTestStatus () SYMBOL_VISIBLE

Default construct a PLL self-test status.

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

CounterValue get_counter_value () const SYMBOL_VISIBLE

Get self-test clock period counter value.

Returns

Counter value

bool get_finished () const SYMBOL_VISIBLE

Get if self-test exectution finished before this containers’ read.

This flag only produces reliable information on the first validly finished self test after power cycle.

Returns

Boolean value

bool get_success () const SYMBOL_VISIBLE

Get if self-test execution was successful.

Returns

Boolean value

bool operator!= (PLLSelfTestStatus const &other) const SYMBOL_VISIBLE

bool operator== (PLLSelfTestStatus const &other) const SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 1

static constexpr size_t write_config_size_in_words = 0

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

CounterValue m_counter_value

bool m_finished

bool m_success

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PLLSelfTestStatus const &config) SYMBOL_VISIBLE

class haldls::vx::PollingOmnibusBlock

#include <block.h>

Container for polling block operation on a Omnibus address.

Compare given value from address in FPGA register file masked with expected target result.

Public Types

typedef halco::hicann_dls::vx::PollingOmnibusBlockOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PollingOmnibusBlock (bool enable_expects_equality=true) SYMBOL_VISIBLE

Resolve block if value is true (*address & mask == target) or if value is false (*address & mask != target).

fisch::vx::word_access_type::PollingOmnibusBlock encode () const SYMBOL_VISIBLE

bool get_enable_expects_equality () const SYMBOL_VISIBLE

Get enable expects equality value.

Resolve block if value is true (*address & mask == target) or if value is false (*address & mask != target).

Returns

Boolean value

bool operator!= (PollingOmnibusBlock const &other) const SYMBOL_VISIBLE

bool operator== (PollingOmnibusBlock const &other) const SYMBOL_VISIBLE

void set_enable_expects_equality (bool value) SYMBOL_VISIBLE

Get enable expects equality value.

Resolve block if value is true (*address & mask == target) or if value is false (*address & mask != target).

Returns

Boolean value

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

bool m_enable_expects_equality

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PollingOmnibusBlock const &config) SYMBOL_VISIBLE

class haldls::vx::PollingOmnibusBlockConfig

#include <block.h>

Public Types

typedef halco::hicann_dls::vx::OmnibusAddress Address

typedef halco::hicann_dls::vx::PollingOmnibusBlockConfigOnFPGA coordinate_type

typedef std::true_type is_leaf_node

typedef fisch::vx::word_access_type::Omnibus::Word Value

Public Functions

PollingOmnibusBlockConfig () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > encode () const SYMBOL_VISIBLE

Address get_address () const SYMBOL_VISIBLE

Value get_mask () const SYMBOL_VISIBLE

Value get_target () const SYMBOL_VISIBLE

bool operator!= (PollingOmnibusBlockConfig const &other) const SYMBOL_VISIBLE

bool operator== (PollingOmnibusBlockConfig const &other) const SYMBOL_VISIBLE

void set_address (Address value) SYMBOL_VISIBLE

void set_mask (Value value) SYMBOL_VISIBLE

void set_target (Value value) SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 3

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::hardware, hxcomm::vx::Target::simulation}

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Private Members

Address m_address

Value m_mask

Value m_target

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PollingOmnibusBlockConfig const &config) SYMBOL_VISIBLE

struct haldls::vx::MADCConfig::PowerupWaitValue : public halco::common::detail::RantWrapper<PowerupWaitValue, uint_fast16_t, 1023, 0>

#include <madc.h>

Public Functions

inline explicit constexpr PowerupWaitValue (uintmax_t const val=96) SYMBOL_VISIBLE

class haldls::vx::PPUControlRegister : public haldls::vx::DifferentialWriteTrait

#include <ppu.h>

Public Types

typedef halco::hicann_dls::vx::PPUControlRegisterOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PPUControlRegister () SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_cache_controller_enable () const SYMBOL_VISIBLE

bool get_force_clock_off () const SYMBOL_VISIBLE

bool get_force_clock_on () const SYMBOL_VISIBLE

bool get_inhibit_reset () const SYMBOL_VISIBLE

bool operator!= (PPUControlRegister const &other) const SYMBOL_VISIBLE

bool operator== (PPUControlRegister const &other) const SYMBOL_VISIBLE

void set_cache_controller_enable (bool const value) SYMBOL_VISIBLE

void set_force_clock_off (bool const value) SYMBOL_VISIBLE

void set_force_clock_on (bool const value) SYMBOL_VISIBLE

void set_inhibit_reset (bool const value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_cache_controller_enable

bool m_force_clock_off

bool m_force_clock_on

bool m_inhibit_reset

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &, PPUControlRegister const &) SYMBOL_VISIBLE

class haldls::vx::PPUMemory

#include <ppu.h>

Public Types

typedef halco::hicann_dls::vx::PPUMemoryOnDLS coordinate_type

typedef std::false_type has_local_data

typedef halco::common::typed_heap_array<PPUMemoryWord, halco::hicann_dls::vx::PPUMemoryWordOnPPU> words_type

Public Functions

explicit  PPUMemory (words_type const &words=words_type()) SYMBOL_VISIBLE

PPUMemoryBlock get_block (halco::hicann_dls::vx::PPUMemoryBlockOnPPU const &block_coord) const SYMBOL_VISIBLE

PPUMemoryWord::Value get_word (halco::hicann_dls::vx::PPUMemoryWordOnPPU const &pos) const SYMBOL_VISIBLE

words_type get_words () const SYMBOL_VISIBLE

void load_from_file (std::string const &filename) SYMBOL_VISIBLE

Load a (stripped) PPU program from a file.

The program is located at the beginning of the memory with words above the program’s size set to zero.

Parameters

filename – Name of file to load

bool operator!= (PPUMemory const &other) const SYMBOL_VISIBLE

bool operator== (PPUMemory const &other) const SYMBOL_VISIBLE

void set_block (halco::hicann_dls::vx::PPUMemoryBlockOnPPU const &block_coord, PPUMemoryBlock const &block) SYMBOL_VISIBLE

void set_word (halco::hicann_dls::vx::PPUMemoryWordOnPPU const &pos, PPUMemoryWord::Value const &word) SYMBOL_VISIBLE

void set_words (words_type const &words) SYMBOL_VISIBLE

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

words_type m_words

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PPUMemory const &pm) SYMBOL_VISIBLE

class haldls::vx::PPUMemoryBlock

#include <ppu.h>

Public Types

typedef halco::hicann_dls::vx::PPUMemoryBlockOnDLS coordinate_type

typedef std::false_type has_local_data

typedef halco::hicann_dls::vx::PPUMemoryBlockSize size_type

typedef std::vector<PPUMemoryWord> words_type

Public Functions

explicit  PPUMemoryBlock (size_type size=size_type(halco::hicann_dls::vx::PPUMemoryWordOnPPU::size)) SYMBOL_VISIBLE

PPUMemoryWord const  & at (size_t index) const SYMBOL_VISIBLE

PPUMemoryWord & at (size_t index) SYMBOL_VISIBLE

PPUMemoryBlock get_subblock (size_t begin, size_type length) const SYMBOL_VISIBLE

words_type const  & get_words () const SYMBOL_VISIBLE

bool operator!= (PPUMemoryBlock const &other) const SYMBOL_VISIBLE

bool operator== (PPUMemoryBlock const &other) const SYMBOL_VISIBLE

PPUMemoryWord const  & operator[] (size_t index) const SYMBOL_VISIBLE

PPUMemoryWord & operator[] (size_t index) SYMBOL_VISIBLE

void set_subblock (size_t begin, PPUMemoryBlock const &subblock) SYMBOL_VISIBLE

void set_words (words_type const &words) SYMBOL_VISIBLE

size_type size () const SYMBOL_VISIBLE

std::string to_string () const SYMBOL_VISIBLE

Print words as string discarding non-printable characters.

Returns

Printable characters as string in order according to PPU endianess

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

words_type m_words

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PPUMemoryBlock const &pmb) SYMBOL_VISIBLE

class haldls::vx::PPUMemoryWord

#include <ppu.h>

Public Types

typedef halco::hicann_dls::vx::PPUMemoryWordOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef uint32_t raw_type

Public Functions

explicit  PPUMemoryWord (Value value=Value()) SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

Value get_value () const SYMBOL_VISIBLE

bool operator!= (PPUMemoryWord const &other) const SYMBOL_VISIBLE

bool operator== (PPUMemoryWord const &other) const SYMBOL_VISIBLE

void set_value (Value const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

Value m_value

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, PPUMemoryWord const &pmw) SYMBOL_VISIBLE

class haldls::vx::PPUStatusRegister

#include <ppu.h>

Public Types

typedef halco::hicann_dls::vx::PPUStatusRegisterOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PPUStatusRegister () SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_sleep () const SYMBOL_VISIBLE

bool operator!= (PPUStatusRegister const &other) const SYMBOL_VISIBLE

bool operator== (PPUStatusRegister const &other) const SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 1

static constexpr size_t write_config_size_in_words = 0

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_sleep

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &, PPUStatusRegister const &) SYMBOL_VISIBLE

struct haldls::vx::MADCConfig::PreampGainCapacitorSize : public halco::common::detail::RantWrapper<PreampGainCapacitorSize, uint_fast8_t, 31, 0>

#include <madc.h>

Public Functions

inline explicit constexpr PreampGainCapacitorSize (uintmax_t const val=31) SYMBOL_VISIBLE

struct haldls::vx::ADPLL::PreDivP0 : public halco::common::detail::RantWrapper<PreDivP0, uint_fast16_t, 4, 2>

#include <pll.h>

Divider to set the frequency of the DCO f_dco (Together with LoopDivN).

f_dco = P0 * N * f_ref.

Public Functions

inline explicit constexpr PreDivP0(uintmax_t const val = 2)

struct haldls::vx::ADPLL::PreDivP1 : public halco::common::detail::RantWrapper<PreDivP1, uint_fast16_t, 4, 2>

#include <pll.h>

Divider for f_clk_core0 and f_clk_core1.

For f_clk_core0: CoreDivM0 for f_clk_core0 = f_dco / (P1 * M0). For f_clk_core1: CoreDivM1 for f_clk_core1 = f_dco / (P1 * M1).

Public Functions

inline explicit constexpr PreDivP1(uintmax_t const val = 2)

struct haldls::vx::ADPLL::PreDivP2 : public halco::common::detail::RantWrapper<PreDivP2, uint_fast16_t, 4, 2>

#include <pll.h>

Divider to set the output frequency f_clk_dco.

f_clk_dco = f_dco / P2.

Public Functions

inline explicit constexpr PreDivP2(uintmax_t const val = 2)

struct haldls::vx::CapMemBlockConfig::PrescalePause : public halco::common::detail::RantWrapper<PrescalePause, uint_fast16_t, 6, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<PrescalePause, uint_fast16_t, 6, 0>::rant_t rant_t

Public Functions

inline explicit constexpr PrescalePause()

inline explicit constexpr PrescalePause(uintmax_t const val)

struct haldls::vx::CapMemBlockConfig::PrescaleRamp : public halco::common::detail::RantWrapper<PrescaleRamp, uint_fast16_t, 6, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<PrescaleRamp, uint_fast16_t, 6, 0>::rant_t rant_t

Public Functions

inline explicit constexpr PrescaleRamp()

inline explicit constexpr PrescaleRamp(uintmax_t const val)

struct haldls::vx::PLLSelfTest::PreScalerP : public halco::common::detail::RantWrapper<PreScalerP, uint_fast16_t, 15, 0>

#include <pll.h>

Selects counting window of the self test.

Counts within 2^(p + 2) reference cycles.

Public Functions

inline explicit constexpr PreScalerP(uintmax_t const val = 0)

struct haldls::vx::CapMemBlockConfig::PulseA : public halco::common::detail::RantWrapper<PulseA, uint_fast16_t, 65535, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<PulseA, uint_fast16_t, 65535, 0>::rant_t rant_t

Public Functions

inline explicit constexpr PulseA()

inline explicit constexpr PulseA(uintmax_t const val)

struct haldls::vx::CapMemBlockConfig::PulseB : public halco::common::detail::RantWrapper<PulseB, uint_fast16_t, 65535, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<PulseB, uint_fast16_t, 65535, 0>::rant_t rant_t

Public Functions

inline explicit constexpr PulseB()

inline explicit constexpr PulseB(uintmax_t const val)

struct haldls::vx::BackgroundSpikeSource::Rate : public halco::common::detail::RantWrapper<Rate, uint_fast16_t, hate::math::pow(2, 8) - 1, 0>

#include <background.h>

Rate of spike output in the Poisson spike generation mode, without effect in regular mode.

Every period, a random 8-bit number is compared to the rate value and a spike is generated if the random value is smaller-equal than the configured rate. This leads to a mean ISI of (period / (rate / 255)) and disabled spike output on rate = 0.

Public Functions

inline explicit constexpr Rate(uintmax_t const val = 0)

struct haldls::vx::HicannARQStatus::ReadCount : public halco::common::detail::BaseType<ReadCount, uint32_t>

#include <arq.h>

Number of words submitted to the ARQ from the Chip.

Public Functions

inline explicit constexpr ReadCount(uintmax_t const val = 0)

struct haldls::vx::detail::SRAMTimingConfig::ReadDelay : public halco::common::detail::RantWrapper<ReadDelay, uint_fast16_t, hate::math::pow(2, 8) - 1, 0>

#include <sram_controller.h>

Wait time after enable signal pull for cells to drive their value until read.

Public Functions

inline explicit constexpr ReadDelay(uintmax_t const val = 120)

class haldls::vx::ReadoutSourceSelection

#include <readout.h>

Configuration container for the two mux and buffer blocks for voltage readout.

Allows selection of various signal sources on chip and drives the signals. To reach the pads, the buffer_to_pad option in the PadMultiplexerConfig needs to be set.

Some of the selectable voltages in this container can also be selected in the PadMultiplexerConfig directly. Note that there the connection is direct, not buffered, while here the signal is amplified. Do not enable both connections, as there will be feedback otherwise!

Public Types

typedef halco::hicann_dls::vx::ReadoutSourceSelectionOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection> source_multiplexer_type

Public Functions

ReadoutSourceSelection () SYMBOL_VISIBLE

Default constructor with both buffers and muxes disabled.

template<typename WordT>
void decode(std::array<WordT, config_size_in_words> const &data)

template<typename WordT>
std::array<WordT, config_size_in_words> encode() const

SourceMultiplexer get_buffer (halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection const &buffer) const SYMBOL_VISIBLE

bool operator!= (ReadoutSourceSelection const &other) const SYMBOL_VISIBLE

bool operator== (ReadoutSourceSelection const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) source_multiplexer_type const &get_enable_buffer_to_pad() const SYMBOL_VISIBLE

void set_buffer (halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection const &buffer, SourceMultiplexer const &value) SYMBOL_VISIBLE

void set_enable_buffer_to_pad (source_multiplexer_type const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT>
static std::array<AddressT, config_size_in_words> addresses(coordinate_type const &block)

Public Static Attributes

static constexpr size_t config_size_in_words = 2

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

halco::common::typed_array<SourceMultiplexer, halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection> m_buffers

source_multiplexer_type m_enable_buffer_to_pad

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, ReadoutSourceSelection const &config) SYMBOL_VISIBLE

struct haldls::vx::PerfTestStatus::Received : public halco::common::detail::RantWrapper<Received, uint_fast32_t, 0xffffffff, 0>

#include <perftest.h>

Number of words received.

Public Functions

inline explicit constexpr Received(uintmax_t const val = 0)

struct haldls::vx::SynapseDriverConfig::Recovery : public halco::common::detail::RantWrapper<Recovery, uint_fast8_t, 15, 0>

#include <synapse_driver.h>

Public Functions

inline explicit constexpr Recovery(uintmax_t const val = 0)

struct haldls::vx::CommonSTPConfig::RecoveryClockSpeed : public halco::common::detail::RantWrapper<RecoveryClockSpeed, uint_fast16_t, 15, 0>

#include <padi.h>

Public Functions

inline explicit constexpr RecoveryClockSpeed(uintmax_t const val = 0)

struct ReferenceGeneratorConfig::ReferenceControl : public halco::common::detail::RantWrapper<ReferenceControl, uint_fast8_t, 63, 0>, public halco::common::detail::RantWrapper<ReferenceControl, uint_fast8_t, 63, 0>

#include <capmem.h>

Public Functions

inline explicit constexpr ReferenceControl(uintmax_t const val = 10)

inline explicit constexpr ReferenceControl(uintmax_t const val = 10)

class ReferenceGeneratorConfig

#include <capmem.h>

Public Types

typedef halco::common::typed_array<CapMemAmplifier, halco::hicann_dls::vx::CapMemBlockOnDLS> capmem_amplifier_type

typedef halco::common::typed_array<CapMemAmplifier, halco::hicann_dls::vx::CapMemBlockOnDLS> capmem_amplifier_type

typedef halco::common::typed_array<CapMemOffset, halco::hicann_dls::vx::CapMemBlockOnDLS> capmem_offset_type

typedef halco::common::typed_array<CapMemOffset, halco::hicann_dls::vx::CapMemBlockOnDLS> capmem_offset_type

typedef halco::common::typed_array<CapMemSlope, halco::hicann_dls::vx::CapMemBlockOnDLS> capmem_slope_type

typedef halco::common::typed_array<CapMemSlope, halco::hicann_dls::vx::CapMemBlockOnDLS> capmem_slope_type

typedef halco::hicann_dls::vx::ReferenceGeneratorConfigOnDLS coordinate_type

typedef halco::hicann_dls::vx::ReferenceGeneratorConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef std::true_type is_leaf_node

Public Functions

explicit  ReferenceGeneratorConfig () SYMBOL_VISIBLE

Default config of reference generator.

explicit  ReferenceGeneratorConfig () SYMBOL_VISIBLE

Default config of reference generator.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

bool const  & get_enable_internal_reference () const SYMBOL_VISIBLE

Set enable for internal reference current generation.

bool const  & get_enable_internal_reference () const SYMBOL_VISIBLE

Set enable for internal reference current generation.

bool const  & get_enable_reference_input () const SYMBOL_VISIBLE

Set enable for input of reference current from pad.

bool const  & get_enable_reference_input () const SYMBOL_VISIBLE

Set enable for input of reference current from pad.

bool const  & get_enable_reference_output () const SYMBOL_VISIBLE

Set enable for output of reference current to pad.

bool const  & get_enable_reference_output () const SYMBOL_VISIBLE

Set enable for output of reference current to pad.

bool const  & get_enable_reset () const SYMBOL_VISIBLE

Set reset signal for resistor control of reference current generation.

The reset can be used after powerup to reach a working state.

bool const  & get_enable_reset () const SYMBOL_VISIBLE

Set reset signal for resistor control of reference current generation.

The reset can be used after powerup to reach a working state.

ReferenceControl get_reference_control () const SYMBOL_VISIBLE

Set reference current generation DAC value.

ReferenceControl get_reference_control () const SYMBOL_VISIBLE

Set reference current generation DAC value.

ResistorControl get_resistor_control () const SYMBOL_VISIBLE

Set reference current generation resistor value.

ResistorControl get_resistor_control () const SYMBOL_VISIBLE

Set reference current generation resistor value.

bool operator!= (ReferenceGeneratorConfig const &other) const SYMBOL_VISIBLE

bool operator!= (ReferenceGeneratorConfig const &other) const SYMBOL_VISIBLE

bool operator== (ReferenceGeneratorConfig const &other) const SYMBOL_VISIBLE

bool operator== (ReferenceGeneratorConfig const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) capmem_amplifier_type const &get_capmem_amplifier() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) capmem_amplifier_type const &get_capmem_amplifier() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) capmem_offset_type const &get_capmem_offset() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) capmem_offset_type const &get_capmem_offset() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) capmem_slope_type const &get_capmem_slope() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) capmem_slope_type const &get_capmem_slope() const SYMBOL_VISIBLE

void set_capmem_amplifier (capmem_amplifier_type const &value) SYMBOL_VISIBLE

void set_capmem_amplifier (capmem_amplifier_type const &value) SYMBOL_VISIBLE

void set_capmem_offset (capmem_offset_type const &value) SYMBOL_VISIBLE

void set_capmem_offset (capmem_offset_type const &value) SYMBOL_VISIBLE

void set_capmem_slope (capmem_slope_type const &value) SYMBOL_VISIBLE

void set_capmem_slope (capmem_slope_type const &value) SYMBOL_VISIBLE

void set_enable_internal_reference (bool value) SYMBOL_VISIBLE

void set_enable_internal_reference (bool value) SYMBOL_VISIBLE

void set_enable_reference_input (bool value) SYMBOL_VISIBLE

void set_enable_reference_input (bool value) SYMBOL_VISIBLE

void set_enable_reference_output (bool value) SYMBOL_VISIBLE

void set_enable_reference_output (bool value) SYMBOL_VISIBLE

void set_enable_reset (bool value) SYMBOL_VISIBLE

void set_enable_reset (bool value) SYMBOL_VISIBLE

void set_reference_control (ReferenceControl value) SYMBOL_VISIBLE

void set_reference_control (ReferenceControl value) SYMBOL_VISIBLE

void set_resistor_control (ResistorControl value) SYMBOL_VISIBLE

void set_resistor_control (ResistorControl value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 9

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

capmem_amplifier_type m_capmem_amplifier

capmem_offset_type m_capmem_offset

capmem_slope_type m_capmem_slope

bool m_enable_internal_reference

bool m_enable_reference_input

bool m_enable_reference_output

bool m_enable_reset

ReferenceControl m_reference_control

ResistorControl m_resistor_control

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, ReferenceGeneratorConfig const &config) SYMBOL_VISIBLE

friend std::ostream & operator<< (std::ostream &os, ReferenceGeneratorConfig const &config) SYMBOL_VISIBLE

struct haldls::vx::NeuronBackendConfig::RefractoryTime : public halco::common::detail::RantWrapper<RefractoryTime, uint_fast16_t, 255, 0>

#include <neuron.h>

The refractory time can be configured to be used for different applications (short and long) Refactory Periods usually range from 0 to 5 ms.

Accounting for the speedup they correspond to 5 µs in hardware time. Some special applications like NMDA require significantly longer times.

tau_ref = RefractoryTime * 1/f_clock

Use case 1 (standard): tau_min = 0.1µs => f_clock = 10MHz tau_max = 12.7µs (12.7ms bio time) Use case 2 (NMDA): f_clock = 4kHz -> tau_max = 127ms (127s bio time) Use case 3 (short): f_clock = 250MHz -> tau_min = 4ns (4µs in bio time)

Note

The reset conductance is limited and thus will not pull down the membrane in 4 ns! The fastest analog “reset time constant” is approx. 0.5 μs.

Note

The reset is released at least one clock cycle before the end of the refractory period. To avoid unexpected behavior the refractory period may not be too small, compare ResetHoldoff.

Public Types

typedef halco::common::detail::RantWrapper<RefractoryTime, uint_fast16_t, 255, 0> rant_t

Public Functions

inline explicit constexpr RefractoryTime()

inline explicit constexpr RefractoryTime(uintmax_t const val)

struct haldls::vx::VectorGeneratorControl::ResendCount : public halco::common::detail::RantWrapper<ResendCount, uint_fast8_t, 15, 0>

#include <vector_generator.h>

Number of times to resend same input.

Public Functions

inline explicit constexpr ResendCount(uintmax_t const val = 0)

class haldls::vx::ResetChip

#include <reset.h>

Container for setting the reset pin of the chip.

Public Types

typedef halco::hicann_dls::vx::ResetChipOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit  ResetChip (bool value=false) SYMBOL_VISIBLE

Construct chip reset with boolean value.

On true, the chip reset is enabled.

Parameters

value – Boolean value

void decode (std::array< fisch::vx::word_access_type::ResetChip, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::ResetChip, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (ResetChip const &other) const SYMBOL_VISIBLE

bool operator== (ResetChip const &other) const SYMBOL_VISIBLE

void set (bool value) SYMBOL_VISIBLE

Set chip reset.

On true, the chip reset is enabled.

Parameters

value – Boolean value

Public Static Functions

static std::array< halco::hicann_dls::vx::ResetChipOnDLS, read_config_size_in_words > read_addresses (coordinate_type const &word) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::ResetChipOnDLS, write_config_size_in_words > write_addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

bool m_value

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, ResetChip const &config) SYMBOL_VISIBLE

struct haldls::vx::CommonCorrelationConfig::ResetDuration : public halco::common::detail::RantWrapper<ResetDuration, uint_fast16_t, hate::math::pow(2, 12) - 1, 0>

#include <correlation.h>

Duration of correlation reset for synapses (+3 ppu clock cycles).

Determines how long the measurement capacitor is connected to the reset voltage.

Public Functions

inline explicit constexpr ResetDuration(uintmax_t const val = 200)

struct haldls::vx::CommonCorrelationConfig::ResetFallTime : public halco::common::detail::RantWrapper<ResetFallTime, uint_fast16_t, hate::math::pow(2, 12) - 1, 0>

#include <correlation.h>

Wait time in PPU clock cycles after disabling the correlation column reset enable.

Public Functions

inline explicit constexpr ResetFallTime(uintmax_t const val = 5)

struct haldls::vx::NeuronBackendConfig::ResetHoldoff : public halco::common::detail::RantWrapper<ResetHoldoff, uint_fast8_t, 15, 0>

#include <neuron.h>

ResetHoldoff period: Adjusts the time delta between the reset and the refractory period.

The reset is released before the end of the refractory time.

The refractory-counter starts at a value of (0xFF - refractory_time) and is increased every clock cycle until its maximum value of 0xFF is reached; this time describes the refractory period. The reset is not active during the whole refractory period. The time in which the reset is not active is called ‘reset-holdoff time’ The time difference between reset and refractory period is configured by comparison of the five LSBs of the refractory counter to a mask: the reset stops as soon as the mask matches the LSB of the refractory counter and all MSB of the refractory counter are set. The mask is composed of a zero as LSB and the four bit reset-holdoff.

Due to the fact that the lowest bit is always set to zero, there is always a period in which the reset is not active during the refractory period. This period is minimal if the reset-holdoff is maximal. In general the reset period is (0x1F - reset_holdoff << 1) clock cycles shorter than the refractory period.

Example: The reset is turned off before the end of the refractory period. As the neuron is still refractory, no new spike is registered, although the fire signal is still high. Only after the end of the refractory period the circuits accepts new fire signals.

Note: Setting a small refractory counter value in combination with a reset holdoff will result in glitchy behaviour, as the counter value triggering the end of the reset will never be reached if refractory_counter < (0x1F - reset_holdoff << 1).

Public Types

typedef halco::common::detail::RantWrapper<ResetHoldoff, uint_fast8_t, 15, 0> rant_t

Public Functions

inline explicit constexpr ResetHoldoff()

inline explicit constexpr ResetHoldoff(uintmax_t const val)

class haldls::vx::ResetJTAGTap

#include <jtag.h>

Container for resetting JTAG state-machine.

Public Types

typedef halco::hicann_dls::vx::ResetJTAGTapOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

ResetJTAGTap () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::ResetJTAGTap, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::ResetJTAGTap, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (ResetJTAGTap const &other) const SYMBOL_VISIBLE

bool operator== (ResetJTAGTap const &other) const SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::ResetJTAGTapOnDLS, read_config_size_in_words > read_addresses (coordinate_type const &word) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::ResetJTAGTapOnDLS, write_config_size_in_words > write_addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t const version)

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, ResetJTAGTap const &config) SYMBOL_VISIBLE

struct haldls::vx::CADCConfig::ResetWait : public halco::common::detail::RantWrapper<ResetWait, uint_fast16_t, 255, 0>

#include <cadc.h>

Wait time in cycles after ramp drop to compensate for analog low-pass filtering of ramp signal and preventing the drop of the last ramp to cause interference in the next linear ramp increase.

Public Functions

inline explicit constexpr ResetWait(uintmax_t const val = 100)

struct ReferenceGeneratorConfig::ResistorControl : public halco::common::detail::RantWrapper<ResistorControl, uint_fast8_t, 63, 0>, public halco::common::detail::RantWrapper<ResistorControl, uint_fast8_t, 63, 0>

#include <capmem.h>

Public Functions

inline explicit constexpr ResistorControl(uintmax_t const val = 40)

inline explicit constexpr ResistorControl(uintmax_t const val = 40)

struct haldls::vx::SynapseDriverConfig::RowAddressCompareMask : public halco::common::detail::RantWrapper<RowAddressCompareMask, uint_fast8_t, 31, 0>

#include <synapse_driver.h>

Public Functions

inline explicit constexpr RowAddressCompareMask(uintmax_t const val = 0b11111)

struct haldls::vx::PADIEvent::RowSelectAddress : public halco::common::detail::RantWrapper<RowSelectAddress, uint_fast16_t, 31, 0>

#include <padi.h>

Public Functions

inline explicit constexpr RowSelectAddress(uintmax_t const val = 0)

struct haldls::vx::HicannARQStatus::RxCount : public halco::common::detail::BaseType<RxCount, uint32_t>

#include <arq.h>

Number of words sent from the ARQ from the Chip to the FPGA.

Public Functions

inline explicit constexpr RxCount(uintmax_t const val = 0)

struct haldls::vx::PhyStatus::RxCount : public halco::common::detail::BaseType<RxCount, uint32_t>

#include <phy.h>

Number of rx words from Chip since last reset.

Public Functions

inline explicit constexpr RxCount(uintmax_t const val = 0)

struct haldls::vx::PhyStatus::RxDroppedCount : public halco::common::detail::BaseType<RxDroppedCount, uint32_t>

#include <phy.h>

Number of dropped rx words.

Public Functions

inline explicit constexpr RxDroppedCount(uintmax_t const val = 0)

struct haldls::vx::MADCConfig::SampleDurationAdjust : public halco::common::detail::RantWrapper<SampleDurationAdjust, uint_fast8_t, 7, 0>

#include <madc.h>

Public Functions

inline explicit constexpr SampleDurationAdjust (uintmax_t const val=5) SYMBOL_VISIBLE

struct haldls::vx::MADCConfig::SamplingWindowTiming : public halco::common::detail::RantWrapper<SamplingWindowTiming, uint_fast8_t, 31, 0>

#include <madc.h>

Public Functions

inline explicit constexpr SamplingWindowTiming (uintmax_t const val=0) SYMBOL_VISIBLE

struct haldls::vx::MADCConfig::SARResetLength : public halco::common::detail::RantWrapper<SARResetLength, uint_fast8_t, 3, 0>

#include <madc.h>

Public Functions

inline explicit constexpr SARResetLength (uintmax_t const val=0) SYMBOL_VISIBLE

struct haldls::vx::MADCConfig::SARResetWait : public halco::common::detail::RantWrapper<SARResetWait, uint_fast8_t, 3, 0>

#include <madc.h>

Public Functions

inline explicit constexpr SARResetWait (uintmax_t const val=3) SYMBOL_VISIBLE

struct haldls::vx::BackgroundSpikeSource::Seed : public halco::common::detail::RantWrapper<Seed, uint_fast64_t, hate::math::pow(2, 32) - 1, 0>

#include <background.h>

Random seed for random number generation.

Only the lower 16 bit of the generator are used on every draw.

Public Functions

inline explicit constexpr Seed(uintmax_t const val = 0)

struct haldls::vx::CommonCorrelationConfig::SenseDelay : public halco::common::detail::RantWrapper<SenseDelay, uint_fast16_t, hate::math::pow(2, 12) - 1, 0>

#include <correlation.h>

Wait time in PPU clock cycles between connecting the outputs of a synapse to the CADC inputs and starting the CADC read.

Public Functions

inline explicit constexpr SenseDelay(uintmax_t const val = 1)

struct haldls::vx::PerfTestStatus::Sent : public halco::common::detail::RantWrapper<Sent, uint_fast32_t, 0xffffffff, 0>

#include <perftest.h>

Number of words sent successfully.

Public Functions

inline explicit constexpr Sent(uintmax_t const val = 0)

class haldls::vx::ShiftRegister : public haldls::vx::DifferentialWriteTrait

#include <spi.h>

Container for configuration of the 24-bit wide shift register controlling six VDD switches, the selection of the ADC source, ADC power down and reset pins, six LEDs, routing two DAC channels to a differential debug line and the CapMem reference current connection.

Information about the routing can be found in the xBoard wiki under https://brainscales-r.kip.uni-heidelberg.de/projects/symap2ic/wiki/xboard.

Public Types

enum AnalogReadoutMux1Input

Values:

enumerator off

enumerator readout_chain_0

enumerator readout_chain_1

enumerator mux_rfu_0

enum AnalogReadoutMux2Input

Values:

enumerator off

enumerator v_reset

enumerator vdd_res_meas

enumerator mux_dac_25

enum AnalogReadoutMux3Input

Values:

enumerator off

enumerator i_ref

enumerator mux_rfu_1

enumerator mux_rfu_2

typedef halco::hicann_dls::vx::ShiftRegisterOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

ShiftRegister () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::SPIShiftRegister, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::SPIShiftRegister, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_enable_adc_power_down () const SYMBOL_VISIBLE

Get enable value of the ADC power-down pin.

The behavior can be controlled in the ADC container.

See

ADC

Returns

Boolean value

bool get_enable_adc_reset () const SYMBOL_VISIBLE

Get enable value of the ADC reset pin.

See

ADC

Returns

Boolean value

bool get_enable_dac_to_readout_0 () const SYMBOL_VISIBLE

Get enable value for the DAC-powered Readout0 debug line.

Returns

Boolean value

bool get_enable_dac_to_readout_1 () const SYMBOL_VISIBLE

Get enable value for the DAC-powered Readout1 debug line.

Returns

Boolean value

bool get_enable_i_ref_board () const SYMBOL_VISIBLE

Get enable value for connecting the DAC generating the CapMem reference current to the chip carrier board.

Returns

Boolean value

bool get_enable_led (halco::hicann_dls::vx::LEDOnBoard const &coord) const SYMBOL_VISIBLE

Get enable value for the specified LED.

Parameters

coord – Coordinate of LED to get enable value for

Returns

Boolean value

bool get_enable_measure_i_ref () const SYMBOL_VISIBLE

Get enable value for connecting the CapMem reference current to ground via a 2.2MOhm resistor for a current measurement with the ADC.

Returns

Boolean value

bool get_enable_vdd (halco::hicann_dls::vx::VDDOnBoard const &coord) const SYMBOL_VISIBLE

Get enable value for the specified VDD line.

Parameters

coord – Coordinate of VDD line to get enable value for

Returns

Boolean value

AnalogReadoutMux1Input get_select_analog_readout_mux_1_input () const SYMBOL_VISIBLE

Get the source selection for the first analog readout MUX.

Returns

Selected input

AnalogReadoutMux2Input get_select_analog_readout_mux_2_input () const SYMBOL_VISIBLE

Get the source selection for the second analog readout MUX.

Returns

Selected input

AnalogReadoutMux3Input get_select_analog_readout_mux_3_input () const SYMBOL_VISIBLE

Get the source selection for the third analog readout MUX.

Returns

Selected input

bool operator!= (ShiftRegister const &other) const SYMBOL_VISIBLE

bool operator== (ShiftRegister const &other) const SYMBOL_VISIBLE

void set_enable_adc_power_down (bool value) SYMBOL_VISIBLE

Get enable value of the ADC power-down pin.

The behavior can be controlled in the ADC container.

See

ADC

Parameters

value – Boolean value

void set_enable_adc_reset (bool value) SYMBOL_VISIBLE

Set enable value of the ADC reset pin.

See

ADC

Parameters

value – Boolean value

void set_enable_dac_to_readout_0 (bool value) SYMBOL_VISIBLE

Set enable value for the DAC-powered Readout0 debug line.

Parameters

value – Boolean value

void set_enable_dac_to_readout_1 (bool value) SYMBOL_VISIBLE

Set enable value for the DAC-powered Readout0 debug line.

Parameters

value – Boolean value

void set_enable_i_ref_board (bool value) SYMBOL_VISIBLE

Set enable value for connecting the DAC generating the CapMem reference current to the chip carrier board.

Parameters

value – Boolean value

void set_enable_led (halco::hicann_dls::vx::LEDOnBoard const &coord, bool value) SYMBOL_VISIBLE

Get enable value for the specified LED.

Parameters

• coord – Coordinate of LED to set enable value for

• value – Boolean value

void set_enable_measure_i_ref (bool value) SYMBOL_VISIBLE

Set enable value for connecting the CapMem reference current to ground via a 2.2MOhm resistor for a current measurement with the ADC.

Parameters

value – Boolean value

void set_enable_vdd (halco::hicann_dls::vx::VDDOnBoard const &coord, bool value) SYMBOL_VISIBLE

Set enable value for the specified VDD line.

Parameters

• coord – Coordinate of VDD line to set enable value for

• value – Boolean value

void set_select_analog_readout_mux_1_input (AnalogReadoutMux1Input value) SYMBOL_VISIBLE

Set the source selection for the first analog readout MUX.

Parameters

value – Input to be selected

void set_select_analog_readout_mux_2_input (AnalogReadoutMux2Input value) SYMBOL_VISIBLE

Set the source selection for the second analog readout MUX.

Parameters

value – Input to be selected

void set_select_analog_readout_mux_3_input (AnalogReadoutMux3Input value) SYMBOL_VISIBLE

Set the source selection for the third analog readout MUX.

Parameters

value – Input to be selected

Public Static Functions

static std::array< halco::hicann_dls::vx::SPIShiftRegisterOnBoard, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::SPIShiftRegisterOnBoard, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_enable_adc_power_down

bool m_enable_adc_reset

bool m_enable_dac_to_readout_0

bool m_enable_dac_to_readout_1

bool m_enable_i_ref_board

halco::common::typed_array<bool, halco::hicann_dls::vx::LEDOnBoard> m_enable_led

bool m_enable_measure_i_ref

halco::common::typed_array<bool, halco::hicann_dls::vx::VDDOnBoard> m_enable_vdd

AnalogReadoutMux1Input m_mux_1

AnalogReadoutMux2Input m_mux_2

AnalogReadoutMux3Input m_mux_3

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, ShiftRegister const &config) SYMBOL_VISIBLE

struct haldls::vx::INA219Status::ShuntVoltage : public halco::common::detail::RantWrapper<ShuntVoltage, int16_t, 4000, -4000>

#include <i2c.h>

Shunt voltage with linear conversion and LSB = 10uV.

Public Functions

inline explicit constexpr ShuntVoltage(intmax_t const val = 0)

float toUncalibratedVoltage () const SYMBOL_VISIBLE

Convert to uncalibrated voltage V.

struct haldls::vx::VectorGeneratorControl::SourceCount : public halco::common::detail::RantWrapper<SourceCount, uint_fast8_t, 2, 1>

#include <vector_generator.h>

Number of sources to use.

Public Functions

inline explicit constexpr SourceCount(uintmax_t const val = 1)

struct haldls::vx::CapMemBlockConfig::SourceFollowerBias : public halco::common::detail::RantWrapper<SourceFollowerBias, uint_fast16_t, 15, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<SourceFollowerBias, uint_fast16_t, 15, 0>::rant_t rant_t

Public Functions

inline explicit constexpr SourceFollowerBias()

inline explicit constexpr SourceFollowerBias(uintmax_t const val)

struct haldls::vx::ReadoutSourceSelection::SourceMultiplexer

#include <readout.h>

Public Types

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::HemisphereOnDLS> hemisphere_type

Public Functions

SourceMultiplexer () SYMBOL_VISIBLE

Default constructor with all inputs disabled.

bool get_cadc_debug_acausal () const SYMBOL_VISIBLE

Connect CADC acausal debug line to mux.

bool get_cadc_debug_causal () const SYMBOL_VISIBLE

Connect CADC causal debug line to mux.

bool get_current_dac () const SYMBOL_VISIBLE

Connect output line of idac_i_out to mux.

This current-dac in the readout section can also be connected to neuron membranes or the synaptic input, to mux.

bool get_debug_minus () const SYMBOL_VISIBLE

Connect debug_minus line to mux.

bool get_debug_plus () const SYMBOL_VISIBLE

Connect debug_plus line to mux.

bool get_synin_debug_excitatory () const SYMBOL_VISIBLE

Connect synaptic input excitatory debug line to mux.

bool get_synin_debug_inhibitory () const SYMBOL_VISIBLE

Connect synaptic input inhibitory debug line to mux.

bool operator!= (SourceMultiplexer const &other) const SYMBOL_VISIBLE

bool operator== (SourceMultiplexer const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) hemisphere_type const &get_neuron_even() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) hemisphere_type const &get_neuron_odd() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) hemisphere_type const &get_synapse_driver_debug() const SYMBOL_VISIBLE

void set_cadc_debug_acausal (bool value) SYMBOL_VISIBLE

void set_cadc_debug_causal (bool value) SYMBOL_VISIBLE

void set_current_dac (bool value) SYMBOL_VISIBLE

void set_debug_minus (bool value) SYMBOL_VISIBLE

void set_debug_plus (bool value) SYMBOL_VISIBLE

void set_neuron_even (hemisphere_type const &value) SYMBOL_VISIBLE

void set_neuron_odd (hemisphere_type const &value) SYMBOL_VISIBLE

void set_synapse_driver_debug (hemisphere_type const &value) SYMBOL_VISIBLE

void set_synin_debug_excitatory (bool value) SYMBOL_VISIBLE

void set_synin_debug_inhibitory (bool value) SYMBOL_VISIBLE

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_cadc_debug_acausal

bool m_cadc_debug_causal

bool m_current_dac

bool m_debug_minus

bool m_debug_plus

hemisphere_type m_neuron_even

hemisphere_type m_neuron_odd

hemisphere_type m_synapse_driver_debug

bool m_synin_debug_excitatory

bool m_synin_debug_inhibitory

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SourceMultiplexer const &config) SYMBOL_VISIBLE

friend class ReadoutSourceSelection

class haldls::vx::SpikeCounterRead

#include <neuron.h>

Container to read the spike counter of a single neuron.

Public Types

typedef halco::hicann_dls::vx::SpikeCounterReadOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

SpikeCounterRead () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

Count get_count () const SYMBOL_VISIBLE

Get count, i.e.

number of spikes since last reset.

Returns

Count

bool get_overflow () const SYMBOL_VISIBLE

bool operator!= (SpikeCounterRead const &other) const SYMBOL_VISIBLE

bool operator== (SpikeCounterRead const &other) const SYMBOL_VISIBLE

void set_count (Count const cnt) SYMBOL_VISIBLE

void set_overflow (bool const ovrflw) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 1

static constexpr size_t write_config_size_in_words = 0

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

Count m_count

bool m_overflow

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SpikeCounterRead const &config) SYMBOL_VISIBLE

class haldls::vx::SpikeCounterReset

#include <neuron.h>

Container to reset the spike counter of a single neuron.

Public Types

typedef halco::hicann_dls::vx::SpikeCounterResetOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

SpikeCounterReset () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, read_config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (SpikeCounterReset const &other) const SYMBOL_VISIBLE

bool operator== (SpikeCounterReset const &other) const SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, read_config_size_in_words > read_addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

template<typename AddressT> static std::array< AddressT, write_config_size_in_words > write_addresses (coordinate_type const &neuron) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SpikeCounterReset const &config) SYMBOL_VISIBLE

class haldls::vx::SpikeFromChip

#include <event.h>

Spike from chip.

It is comprised of its label, FPGA and chip time annotation.

Public Functions

SpikeFromChip() = default

Default constructor.

inline SpikeFromChip(fisch::vx::SpikeFromChip const &data)

Construct a spike from chip from the data respresentation.

Parameters

data – Data to use

inline SpikeFromChip(SpikeLabel const &label, FPGATime const &fpga_time, ChipTime const &chip_time)

Construct spike from chip via a label, FPGA and chip time information.

Parameters

• label – SpikeLabel to use

• fpga_time – FPGATime to use

• chip_time – ChipTime to use

bool operator!= (SpikeFromChip const &other) const SYMBOL_VISIBLE

bool operator== (SpikeFromChip const &other) const SYMBOL_VISIBLE

Public Members

ChipTime chip_time

Chip time.

FPGATime fpga_time

FPGA time.

SpikeLabel label

Spike label.

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t const version)

Friends

friend class cereal::access

friend struct detail::SpikeFromChipChecker

friend std::ostream & operator<< (std::ostream &os, SpikeFromChip const &spike) SYMBOL_VISIBLE

struct SpikeFromChipChecker

#include <event.h>

struct haldls::vx::SpikeLabel : public halco::common::detail::BaseType<SpikeLabel, uint16_t>

#include <event.h>

Public Functions

inline explicit constexpr SpikeLabel(value_type const value = value_type())

NeuronBackendAddressOut get_neuron_backend_address_out () const SYMBOL_VISIBLE

Configurable neuron backend output label, bits 0-7.

halco::hicann_dls::vx::NeuronEventOutputOnDLS get_neuron_event_output () const SYMBOL_VISIBLE

Neuron event output of on-chip neurons, bits 8-10.

halco::hicann_dls::vx::NeuronLabel get_neuron_label () const SYMBOL_VISIBLE

Label type processed by Crossbar, bits 0-13.

PADILabel get_padi_label () const SYMBOL_VISIBLE

PADI-bus label, bits 0-10.

PADIEvent::RowSelectAddress get_row_select_address () const SYMBOL_VISIBLE

Configurable row select address on PADIBus, bits 6-10.

halco::hicann_dls::vx::SPL1Address get_spl1_address () const SYMBOL_VISIBLE

SPL1-label, bits 14-15.

SynapseLabelValue get_synapse_label () const SYMBOL_VISIBLE

Configurable synapse address, bits 0-5.

void set_neuron_backend_address_out (NeuronBackendAddressOut value) SYMBOL_VISIBLE

void set_neuron_event_output (halco::hicann_dls::vx::NeuronEventOutputOnDLS value) SYMBOL_VISIBLE

void set_neuron_label (halco::hicann_dls::vx::NeuronLabel value) SYMBOL_VISIBLE

void set_padi_label (PADILabel value) SYMBOL_VISIBLE

void set_row_select_address (PADIEvent::RowSelectAddress) SYMBOL_VISIBLE

void set_spl1_address (halco::hicann_dls::vx::SPL1Address value) SYMBOL_VISIBLE

void set_synapse_label (SynapseLabelValue value) SYMBOL_VISIBLE

class haldls::vx::SpikePack1ToChip

#include <event.h>

Public Types

typedef halco::hicann_dls::vx::SpikePack1ToChipOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef std::array<SpikeLabel, 1> labels_type

Public Functions

SpikePack1ToChip () SYMBOL_VISIBLE

Default constructor.

explicit  SpikePack1ToChip (labels_type const &labels) SYMBOL_VISIBLE

• Construct spike pack with labels. *

Parameters

labels – Array of SpikeLabel values to use

void decode (std::array< fisch::vx::word_access_type::SpikePack1ToChip, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::SpikePack1ToChip, write_config_size_in_words > encode () const SYMBOL_VISIBLE

labels_type get_labels () const SYMBOL_VISIBLE

• Get spike labels. *

Returns

Array of SpikeLabel

bool operator!= (SpikePack1ToChip const &other) const SYMBOL_VISIBLE

bool operator== (SpikePack1ToChip const &other) const SYMBOL_VISIBLE

void set_labels (labels_type const &value) SYMBOL_VISIBLE

• Set spike labels. *

Parameters

value – Array of SpikeLabel to set

Public Static Functions

static std::array< halco::hicann_dls::vx::SpikePack1ToChipOnDLS, read_config_size_in_words > read_addresses (coordinate_type const &word) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::SpikePack1ToChipOnDLS, write_config_size_in_words > write_addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr static size_t read_config_size_in_words   = 0

static constexpr static size_t write_config_size_in_words   = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

labels_type m_impl

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SpikePack1ToChip const &config) SYMBOL_VISIBLE

class haldls::vx::SpikePack2ToChip

#include <event.h>

Public Types

typedef halco::hicann_dls::vx::SpikePack2ToChipOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef std::array<SpikeLabel, 2> labels_type

Public Functions

SpikePack2ToChip () SYMBOL_VISIBLE

Default constructor.

explicit  SpikePack2ToChip (labels_type const &labels) SYMBOL_VISIBLE

• Construct spike pack with labels. *

Parameters

labels – Array of SpikeLabel values to use

void decode (std::array< fisch::vx::word_access_type::SpikePack2ToChip, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::SpikePack2ToChip, write_config_size_in_words > encode () const SYMBOL_VISIBLE

labels_type get_labels () const SYMBOL_VISIBLE

• Get spike labels. *

Returns

Array of SpikeLabel

bool operator!= (SpikePack2ToChip const &other) const SYMBOL_VISIBLE

bool operator== (SpikePack2ToChip const &other) const SYMBOL_VISIBLE

void set_labels (labels_type const &value) SYMBOL_VISIBLE

• Set spike labels. *

Parameters

value – Array of SpikeLabel to set

Public Static Functions

static std::array< halco::hicann_dls::vx::SpikePack2ToChipOnDLS, read_config_size_in_words > read_addresses (coordinate_type const &word) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::SpikePack2ToChipOnDLS, write_config_size_in_words > write_addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr static size_t read_config_size_in_words   = 0

static constexpr static size_t write_config_size_in_words   = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

labels_type m_impl

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SpikePack2ToChip const &config) SYMBOL_VISIBLE

class haldls::vx::SpikePack3ToChip

#include <event.h>

Public Types

typedef halco::hicann_dls::vx::SpikePack3ToChipOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef std::array<SpikeLabel, 3> labels_type

Public Functions

SpikePack3ToChip () SYMBOL_VISIBLE

Default constructor.

explicit  SpikePack3ToChip (labels_type const &labels) SYMBOL_VISIBLE

• Construct spike pack with labels. *

Parameters

labels – Array of SpikeLabel values to use

void decode (std::array< fisch::vx::word_access_type::SpikePack3ToChip, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::SpikePack3ToChip, write_config_size_in_words > encode () const SYMBOL_VISIBLE

labels_type get_labels () const SYMBOL_VISIBLE

• Get spike labels. *

Returns

Array of SpikeLabel

bool operator!= (SpikePack3ToChip const &other) const SYMBOL_VISIBLE

bool operator== (SpikePack3ToChip const &other) const SYMBOL_VISIBLE

void set_labels (labels_type const &value) SYMBOL_VISIBLE

• Set spike labels. *

Parameters

value – Array of SpikeLabel to set

Public Static Functions

static std::array< halco::hicann_dls::vx::SpikePack3ToChipOnDLS, read_config_size_in_words > read_addresses (coordinate_type const &word) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::SpikePack3ToChipOnDLS, write_config_size_in_words > write_addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr static size_t read_config_size_in_words   = 0

static constexpr static size_t write_config_size_in_words   = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

labels_type m_impl

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SpikePack3ToChip const &config) SYMBOL_VISIBLE

class haldls::vx::detail::SRAMTimingConfig

#include <sram_controller.h>

Configuration of full-custom SRAM timing.

                    enable width
                    |---------------|

address _____/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯_________ enable ________________/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯_________ ^ |——-|———-| address read delay setup time

Subclassed by haldls::vx::CADCOffsetSRAMTimingConfig, haldls::vx::NeuronBackendSRAMTimingConfig, haldls::vx::NeuronSRAMTimingConfig, haldls::vx::SynapseDriverSRAMTimingConfig

Public Types

typedef std::true_type is_leaf_node

Public Functions

SRAMTimingConfig () SYMBOL_VISIBLE

Default constructor.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

AddressSetupTime get_address_setup_time () const SYMBOL_VISIBLE

EnableWidth get_enable_width () const SYMBOL_VISIBLE

ReadDelay get_read_delay () const SYMBOL_VISIBLE

bool operator!= (SRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator== (SRAMTimingConfig const &other) const SYMBOL_VISIBLE

void set_address_setup_time (AddressSetupTime value) SYMBOL_VISIBLE

void set_enable_width (EnableWidth value) SYMBOL_VISIBLE

void set_read_delay (ReadDelay value) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 2

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t) SYMBOL_VISIBLE

Private Members

AddressSetupTime m_address_setup_time

EnableWidth m_enable_width

ReadDelay m_read_delay

Friends

friend class cereal::access

struct haldls::vx::CapMemBlockConfig::SubCounter : public halco::common::detail::RantWrapper<SubCounter, uint_fast16_t, 65535, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<SubCounter, uint_fast16_t, 65535, 0>::rant_t rant_t

Public Functions

inline explicit constexpr SubCounter()

inline explicit constexpr SubCounter(uintmax_t const val)

class haldls::vx::SynapseBiasSelection

#include <synapse.h>

Public Types

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::CapMemBlockOnDLS> bias_selection_type

typedef halco::hicann_dls::vx::SynapseBiasSelectionOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit  SynapseBiasSelection () SYMBOL_VISIBLE

Construct Synapse Bias Selection container with all internal biases enabled.

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &words) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (SynapseBiasSelection const &other) const SYMBOL_VISIBLE

bool operator== (SynapseBiasSelection const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) bias_selection_type const &get_enable_internal_dac_bias() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) bias_selection_type const &get_enable_internal_output_bias() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) bias_selection_type const &get_enable_internal_ramp_bias() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) bias_selection_type const &get_enable_internal_store_bias() const SYMBOL_VISIBLE

void set_enable_internal_dac_bias (bias_selection_type const &value) SYMBOL_VISIBLE

void set_enable_internal_output_bias (bias_selection_type const &value) SYMBOL_VISIBLE

void set_enable_internal_ramp_bias (bias_selection_type const &value) SYMBOL_VISIBLE

void set_enable_internal_store_bias (bias_selection_type const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::hardware, hxcomm::vx::Target::simulation}

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bias_selection_type m_int_dac_bias

bias_selection_type m_int_output_bias

bias_selection_type m_int_ramp_bias

bias_selection_type m_int_store_bias

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SynapseBiasSelection const &config) SYMBOL_VISIBLE

class haldls::vx::SynapseCorrelationCalibQuad : public haldls::vx::DifferentialWriteTrait

#include <synapse.h>

Public Types

typedef halco::common::typed_array<AmpCalib, halco::hicann_dls::vx::EntryOnQuad> amp_calibs_type

typedef halco::hicann_dls::vx::SynapseCorrelationCalibQuadOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef halco::common::typed_array<TimeCalib, halco::hicann_dls::vx::EntryOnQuad> time_calibs_type

Public Functions

SynapseCorrelationCalibQuad () SYMBOL_VISIBLE

template<typename WordT>
void decode(std::array<WordT, config_size_in_words> const &data)

template<typename WordT>
std::array<WordT, config_size_in_words> encode() const

bool operator!= (SynapseCorrelationCalibQuad const &other) const SYMBOL_VISIBLE

bool operator== (SynapseCorrelationCalibQuad const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) amp_calibs_type const &get_amp_calibs() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) time_calibs_type const &get_time_calibs() const SYMBOL_VISIBLE

void set_amp_calibs (amp_calibs_type const &value) SYMBOL_VISIBLE

void set_time_calibs (time_calibs_type const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT>
static std::array<AddressT, config_size_in_words> addresses(coordinate_type const &block)

Public Static Attributes

static constexpr size_t config_size_in_words = 2

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t version)

Private Members

amp_calibs_type m_amp_calibs

time_calibs_type m_time_calibs

Friends

friend class cereal::access

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::SynapseCorrelationCalibMatrix >

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::SynapseCorrelationCalibRow >

friend std::ostream & operator<< (std::ostream &os, SynapseCorrelationCalibQuad const &config) SYMBOL_VISIBLE

class haldls::vx::SynapseDriverConfig : public haldls::vx::DifferentialWriteTrait

#include <synapse_driver.h>

Public Types

typedef halco::hicann_dls::vx::SynapseDriverOnDLS coordinate_type

typedef std::true_type is_leaf_node

enum RowMode

Values:

enumerator disabled

enumerator excitatory

enumerator inhibitory

enumerator excitatory_and_inhibitory

Public Functions

SynapseDriverConfig () SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_enable_address_out () const SYMBOL_VISIBLE

This enables sending the five lower bits of an address to the synapses.

The MSB is always sent. This mode must be disabled for HAGEN operation.

bool get_enable_charge_sharing () const SYMBOL_VISIBLE

Enable charge sharing for larger STP utilization values (broken).

bool get_enable_hagen_dac () const SYMBOL_VISIBLE

Enable the DAC converting a hagen activation to an STP voltage.

bool get_enable_hagen_modulation () const SYMBOL_VISIBLE

Enable modulation of pulse width proportional to event address.

Note:

• Hagen DAC must also be enabled through enable_hagen_dac

• Address forwarding must be disabled through enable_address_out

• STP circuit must be enabled through enable_stp

bool get_enable_readout () const SYMBOL_VISIBLE

Enable readout source follower and connect to readout line.

The readout is shared between all instances of a vertical half. Connecting multiple instances is non-destructive but will result in faulty readings. Also note that an additional buffer per half must be biased to drive the signals further down to the readout chain.

bool get_enable_receiver () const SYMBOL_VISIBLE

Enable padi bus receiver.

bool get_enable_recovery () const SYMBOL_VISIBLE

Enable STP recovery circuit.

bool get_enable_renewing () const SYMBOL_VISIBLE

Enable renewing synapses for LIF sampling (broken due to faulty circuit).

bool get_enable_stp () const SYMBOL_VISIBLE

Enable STP circuit.

HagenDACOffset get_hagen_dac_offset () const SYMBOL_VISIBLE

Output voltage offset for the hagen mode DAC.

While the STP offsets also affect hagen usage, this setting allows calibration of dacen pulse timings in hagen mode across a larger range.

Offset get_offset () const SYMBOL_VISIBLE

Calibration value for dacen pulse width.

Recovery get_recovery () const SYMBOL_VISIBLE

Set STP recovery time constant.

RowAddressCompareMask get_row_address_compare_mask () const SYMBOL_VISIBLE

Set row select address compare mask.

The incoming row select address allows to individually address a single synapse driver. For this purpose, the events row select address (5 bit) is compared to the synapse driver index (static). The padi bus receiver can be configured to ignore (parts of) the row select address by zeroing (parts of) the row_address_compare_mask.

RowMode get_row_mode_bottom () const SYMBOL_VISIBLE

Set bottom row mode.

RowMode get_row_mode_top () const SYMBOL_VISIBLE

Set top row mode.

TargetVoltages get_select_target_voltages () const SYMBOL_VISIBLE

Select a pair of STP target voltages (vrecover, vcharge).

Each synapse driver is provided with two sets of the STP target voltages, to allow for two different parameterizations within a single array. Note that although there are only two logical arrays of synapse drivers per chip, even and odd synapse drivers are fed with disjunct analog parameters provided by the east and west capmem instances, respectively.

Utilization get_utilization () const SYMBOL_VISIBLE

Set strength of STP utilization.

bool operator!= (SynapseDriverConfig const &other) const SYMBOL_VISIBLE

bool operator== (SynapseDriverConfig const &other) const SYMBOL_VISIBLE

void set_enable_address_out (bool const value) SYMBOL_VISIBLE

void set_enable_charge_sharing (bool const value) SYMBOL_VISIBLE

void set_enable_hagen_dac (bool value) SYMBOL_VISIBLE

void set_enable_hagen_modulation (bool const value) SYMBOL_VISIBLE

void set_enable_readout (bool const value) SYMBOL_VISIBLE

void set_enable_receiver (bool const value) SYMBOL_VISIBLE

void set_enable_recovery (bool const value) SYMBOL_VISIBLE

void set_enable_renewing (bool const value) SYMBOL_VISIBLE

void set_enable_stp (bool const value) SYMBOL_VISIBLE

void set_hagen_dac_offset (HagenDACOffset value) SYMBOL_VISIBLE

void set_offset (Offset const value) SYMBOL_VISIBLE

void set_recovery (Recovery const value) SYMBOL_VISIBLE

void set_row_address_compare_mask (RowAddressCompareMask const value) SYMBOL_VISIBLE

void set_row_mode_bottom (RowMode value) SYMBOL_VISIBLE

void set_row_mode_top (RowMode value) SYMBOL_VISIBLE

void set_select_target_voltages (TargetVoltages const value) SYMBOL_VISIBLE

void set_utilization (Utilization const value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &synapse_driver) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 3

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation}

Private Functions

void from_bitfield(SynapseDriverConfigBitfield const &bitfield)

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

SynapseDriverConfigBitfield to_bitfield() const

Private Members

bool m_en_address_out

bool m_en_charge_sharing

bool m_en_hagen_dac

bool m_en_hagen_modulation

bool m_en_readout

bool m_en_receiver

bool m_en_recovery

bool m_en_renewing

bool m_en_stp

HagenDACOffset m_hagen_dac_offset

Offset m_offset

Recovery m_recovery

RowAddressCompareMask m_row_address_compare_mask

RowMode m_row_mode_bottom

RowMode m_row_mode_top

TargetVoltages m_select_target_voltages

Utilization m_utilization

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SynapseDriverConfig const &config) SYMBOL_VISIBLE

class haldls::vx::SynapseDriverSRAMTimingConfig : public haldls::vx::detail::SRAMTimingConfig

#include <synapse_driver.h>

Public Types

typedef halco::hicann_dls::vx::SynapseDriverSRAMTimingConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

template<typename AddressT> std::array< AddressT, config_size_in_words > addresses (coordinate_type const &word) const SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

AddressSetupTime get_address_setup_time () const SYMBOL_VISIBLE

EnableWidth get_enable_width () const SYMBOL_VISIBLE

ReadDelay get_read_delay () const SYMBOL_VISIBLE

bool operator!= (SRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator!= (SynapseDriverSRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator== (SRAMTimingConfig const &other) const SYMBOL_VISIBLE

bool operator== (SynapseDriverSRAMTimingConfig const &other) const SYMBOL_VISIBLE

void set_address_setup_time (AddressSetupTime value) SYMBOL_VISIBLE

void set_enable_width (EnableWidth value) SYMBOL_VISIBLE

void set_read_delay (ReadDelay value) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 2

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation, hxcomm::vx::Target::hardware}

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t)

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SynapseDriverSRAMTimingConfig const &config) SYMBOL_VISIBLE

class haldls::vx::SynapseLabelQuad : public haldls::vx::DifferentialWriteTrait

#include <synapse.h>

Public Types

typedef halco::hicann_dls::vx::SynapseLabelQuadOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef SynapseLabelValue Value

typedef halco::common::typed_array<Value, halco::hicann_dls::vx::EntryOnQuad> values_type

Public Functions

SynapseLabelQuad () SYMBOL_VISIBLE

template<typename WordT>
void decode(std::array<WordT, config_size_in_words> const &data)

template<typename WordT>
std::array<WordT, config_size_in_words> encode() const

bool operator!= (SynapseLabelQuad const &other) const SYMBOL_VISIBLE

bool operator== (SynapseLabelQuad const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) values_type const &get_values() const SYMBOL_VISIBLE

void set_values (values_type const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT>
static std::array<AddressT, config_size_in_words> addresses(coordinate_type const &block)

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t version)

Private Members

values_type m_values

Friends

friend class cereal::access

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::SynapseLabelMatrix >

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::SynapseLabelRow >

friend std::ostream & operator<< (std::ostream &os, SynapseLabelQuad const &config) SYMBOL_VISIBLE

struct haldls::vx::SynapseLabelValue : public halco::common::detail::RantWrapper<SynapseLabelValue, uint8_t, 63, 0>

#include <synapse.h>

Value type of a single synapse label configuration.

Public Functions

inline explicit constexpr SynapseLabelValue(uintmax_t const val = 0)

class haldls::vx::SynapseQuad : public haldls::vx::DifferentialWriteTrait

#include <synapse.h>

Public Types

typedef SynapseCorrelationCalibQuad::amp_calibs_type amp_calibs_type

typedef SynapseCorrelationCalibQuad::AmpCalib AmpCalib

typedef halco::hicann_dls::vx::SynapseQuadOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef SynapseLabelQuad::Value Label

typedef SynapseLabelQuad::values_type labels_type

typedef SynapseCorrelationCalibQuad::time_calibs_type time_calibs_type

typedef SynapseCorrelationCalibQuad::TimeCalib TimeCalib

typedef SynapseWeightQuad::Value Weight

typedef SynapseWeightQuad::values_type weights_type

Public Functions

SynapseQuad () SYMBOL_VISIBLE

template<typename WordT>
void decode(std::array<WordT, config_size_in_words> const &data)

template<typename WordT>
std::array<WordT, config_size_in_words> encode() const

bool operator!= (SynapseQuad const &other) const SYMBOL_VISIBLE

bool operator== (SynapseQuad const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) amp_calibs_type const &get_amp_calibs() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) labels_type const &get_labels() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) time_calibs_type const &get_time_calibs() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) weights_type const &get_weights() const SYMBOL_VISIBLE

void set_amp_calibs (amp_calibs_type const &value) SYMBOL_VISIBLE

void set_labels (labels_type const &value) SYMBOL_VISIBLE

void set_time_calibs (time_calibs_type const &value) SYMBOL_VISIBLE

void set_weights (weights_type const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT>
static std::array<AddressT, config_size_in_words> addresses(coordinate_type const &block)

Public Static Attributes

static constexpr size_t config_size_in_words = 2

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

amp_calibs_type m_amp_calibs

labels_type m_labels

time_calibs_type m_time_calibs

weights_type m_weights

Friends

friend class cereal::access

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::SynapseMatrix >

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::SynapseRow >

friend std::ostream & operator<< (std::ostream &os, SynapseQuad const &config) SYMBOL_VISIBLE

class haldls::vx::SynapseWeightQuad : public haldls::vx::DifferentialWriteTrait

#include <synapse.h>

Public Types

typedef halco::hicann_dls::vx::SynapseWeightQuadOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef halco::common::typed_array<Value, halco::hicann_dls::vx::EntryOnQuad> values_type

Public Functions

SynapseWeightQuad () SYMBOL_VISIBLE

template<typename WordT>
void decode(std::array<WordT, config_size_in_words> const &data)

template<typename WordT>
std::array<WordT, config_size_in_words> encode() const

bool operator!= (SynapseWeightQuad const &other) const SYMBOL_VISIBLE

bool operator== (SynapseWeightQuad const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) values_type const &get_values() const SYMBOL_VISIBLE

void set_values (values_type const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT>
static std::array<AddressT, config_size_in_words> addresses(coordinate_type const &block)

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t version)

Private Members

values_type m_values

Friends

friend class cereal::access

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::SynapseWeightMatrix >

friend struct haldls::vx::detail::VisitPreorderImpl< lola::vx::SynapseWeightRow >

friend std::ostream & operator<< (std::ostream &os, SynapseWeightQuad const &config) SYMBOL_VISIBLE

class haldls::vx::SystimeSync

#include <systime.h>

Container for syncronization of chip and FPGA systime.

After syncronization the FPGA will annotate responses with systime information by sending additional timing messages.

Public Types

typedef halco::hicann_dls::vx::SystimeSyncOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

SystimeSync (bool do_sync=true) SYMBOL_VISIBLE

void decode (std::array< fisch::vx::word_access_type::SystimeSync, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::SystimeSync, write_config_size_in_words > encode () const SYMBOL_VISIBLE SYMBOL_VISIBLE

bool get_do_sync () const SYMBOL_VISIBLE

Get systime sync enable value.

On true, systime sync is triggered, on false only a systime update response is emitted.

Returns

Boolean value

bool operator!= (SystimeSync const &other) const SYMBOL_VISIBLE

bool operator== (SystimeSync const &other) const SYMBOL_VISIBLE

void set_do_sync (bool value) SYMBOL_VISIBLE

Set systime sync enable value.

On true, systime sync is triggered, on false only a systime update response is emitted.

Parameters

value – Boolean value

Public Static Functions

static std::array< coordinate_type, read_config_size_in_words > read_addresses (coordinate_type const &word) SYMBOL_VISIBLE SYMBOL_VISIBLE

static std::array< coordinate_type, write_config_size_in_words > write_addresses (coordinate_type const &word) SYMBOL_VISIBLE SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<class Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

bool m_do_sync

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SystimeSync const &systime_sync) SYMBOL_VISIBLE

class haldls::vx::SystimeSyncBase

#include <systime.h>

Container for configuring the initial counter value of the systime counter in the chip and in the FPGA after the next systime syncronization operation.

Public Types

typedef halco::hicann_dls::vx::SystimeSyncBaseOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit  SystimeSyncBase (Value const value=Value()) SYMBOL_VISIBLE

template<typename WordT> void decode (std::array< WordT, config_size_in_words > const &data) SYMBOL_VISIBLE

template<typename WordT> std::array< WordT, config_size_in_words > encode () const SYMBOL_VISIBLE

Value get_value () const SYMBOL_VISIBLE

bool operator!= (SystimeSyncBase const &other) const SYMBOL_VISIBLE

bool operator== (SystimeSyncBase const &other) const SYMBOL_VISIBLE

void set_value (Value const &value) SYMBOL_VISIBLE

Public Static Functions

template<typename AddressT> static std::array< AddressT, config_size_in_words > addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 2

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

Value m_value

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, SystimeSyncBase const &config) SYMBOL_VISIBLE

struct haldls::vx::SynapseDriverConfig::TargetVoltages : public halco::common::detail::RantWrapper<TargetVoltages, uint_fast8_t, 1, 0>

#include <synapse_driver.h>

Public Functions

inline explicit constexpr TargetVoltages(uintmax_t const val = 0)

class haldls::vx::TCA9554Config

#include <i2c.h>

Public Types

enum ChannelMode

Values:

enumerator output

enumerator input

enum ChannelPolarity

Values:

enumerator normal

enumerator inverted

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::TCA9554ChannelOnBoard> ChannelsBooleanArray

typedef halco::common::typed_array<ChannelMode, halco::hicann_dls::vx::TCA9554ChannelOnBoard> ChannelsModeArray

typedef halco::common::typed_array<ChannelPolarity, halco::hicann_dls::vx::TCA9554ChannelOnBoard> ChannelsPolarityArray

typedef halco::hicann_dls::vx::TCA9554ConfigOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

TCA9554Config () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::I2CTCA9554RwRegister, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::I2CTCA9554RwRegister, config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (TCA9554Config const &other) const SYMBOL_VISIBLE

bool operator== (TCA9554Config const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) ChannelsBooleanArray const &get_channel_output() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) ChannelsModeArray const &get_channel_mode() const SYMBOL_VISIBLE

return_value_policy (reference_internal)) ChannelsPolarityArray const &get_channel_polarity() const SYMBOL_VISIBLE

void set_channel_mode (ChannelsModeArray const &value) SYMBOL_VISIBLE

Set input/output mode for all channels.

Parameters

value – Array of channel input/output modes

void set_channel_output (ChannelsBooleanArray const &value) SYMBOL_VISIBLE

Set output value for all channels.

Parameters

value – Array of output values

void set_channel_polarity (ChannelsPolarityArray const &value) SYMBOL_VISIBLE

Set polarity inversion mode of all channels.

Parameters

value – Array of polarity inversion modes

Public Static Functions

static std::array< halco::hicann_dls::vx::I2CTCA9554RwRegisterOnBoard, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 3

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation}

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

ChannelsModeArray m_mode

ChannelsBooleanArray m_output

ChannelsPolarityArray m_polarity

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, TCA9554Config const &config) SYMBOL_VISIBLE

class haldls::vx::TCA9554Inputs

#include <i2c.h>

Public Types

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::TCA9554ChannelOnBoard> ChannelsBooleanArray

typedef halco::hicann_dls::vx::TCA9554InputsOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

TCA9554Inputs () SYMBOL_VISIBLE

void decode (std::array< fisch::vx::word_access_type::I2CTCA9554RoRegister, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::I2CTCA9554RoRegister, config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (TCA9554Inputs const &other) const SYMBOL_VISIBLE

bool operator== (TCA9554Inputs const &other) const SYMBOL_VISIBLE

return_value_policy (reference_internal)) ChannelsBooleanArray const &get_channel_input() const SYMBOL_VISIBLE

void set_channel_input (ChannelsBooleanArray const &value) SYMBOL_VISIBLE

Set input value for all channels.

Parameters

value – Array of channel input values

Public Static Functions

static std::array< halco::hicann_dls::vx::I2CTCA9554RoRegisterOnBoard, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

static constexpr static auto unsupported_read_targets  = {hxcomm::vx::Target::simulation}

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

ChannelsBooleanArray m_input

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, TCA9554Inputs const &config) SYMBOL_VISIBLE

struct haldls::vx::SynapseCorrelationCalibQuad::TimeCalib : public halco::common::detail::RantWrapper<TimeCalib, uint8_t, 3, 0>

#include <synapse.h>

Public Functions

inline explicit constexpr TimeCalib(uintmax_t const val = 0)

class haldls::vx::Timer

#include <timer.h>

Container for resetting the FPGA playback timer.

Public Types

typedef halco::hicann_dls::vx::TimerOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit  Timer (Value value=Value()) SYMBOL_VISIBLE

Construct on-FPGA-timer with value.

Parameters

value – Value to construct with

void decode (std::array< fisch::vx::word_access_type::Timer, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Timer, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (Timer const &other) const SYMBOL_VISIBLE

bool operator== (Timer const &other) const SYMBOL_VISIBLE

void set (Value value) SYMBOL_VISIBLE

Set timer value.

Parameters

value – Value to set

Public Static Functions

static std::array< halco::hicann_dls::vx::TimerOnDLS, read_config_size_in_words > read_addresses (coordinate_type const &word) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::TimerOnDLS, write_config_size_in_words > write_addresses (coordinate_type const &word) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<typename Archive>
void serialize(Archive &ar, std::uint32_t const version)

Private Members

Value m_value

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, Timer const &config) SYMBOL_VISIBLE

struct haldls::vx::ADPLL::Tune : public halco::common::detail::RantWrapper<Tune, uint_fast16_t, 4095, 0>

#include <pll.h>

Tune value of the DCO.

Public Functions

inline explicit constexpr Tune(uintmax_t const val = 512)

struct haldls::vx::HicannARQStatus::TxCount : public halco::common::detail::BaseType<TxCount, uint32_t>

#include <arq.h>

Number of words sent from the ARQ from the FPGA to the Chip.

Public Functions

inline explicit constexpr TxCount(uintmax_t const val = 0)

struct haldls::vx::PhyStatus::TxCount : public halco::common::detail::BaseType<TxCount, uint32_t>

#include <phy.h>

Number of tx words to Chip since last reset.

Public Functions

inline explicit constexpr TxCount(uintmax_t const val = 0)

struct haldls::vx::INA219Status::UncalibratedPower

#include <i2c.h>

Uncalibrated power [W].

Public Functions

float calculate () const SYMBOL_VISIBLE

Public Members

float shunt_resistance = 0.027

float uncalibrated_bus_voltage

Uncalibrated bus voltage [V].

float uncalibrated_shunt_voltage

Uncalibrated shunt voltage [V].

Friends

friend std::ostream & operator<< (std::ostream &os, UncalibratedPower const &data) SYMBOL_VISIBLE

struct haldls::vx::SynapseDriverConfig::Utilization : public halco::common::detail::RantWrapper<Utilization, uint_fast8_t, 15, 0>

#include <synapse_driver.h>

Public Functions

inline explicit constexpr Utilization(uintmax_t const val = 0)

struct haldls::vx::CADCSampleQuad::Value : public halco::common::detail::RantWrapper<Value, uint_fast16_t, 255, 0>

#include <cadc.h>

CADC measurement value (offset-corrected, see CADCChannelConfig).

Public Functions

inline explicit constexpr Value(intmax_t const val = 0)

struct haldls::vx::CapMemCell::Value : public halco::common::detail::RantWrapper<Value, uint_fast16_t, 1022, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<Value, uint_fast16_t, 1022, 0>::rant_t rant_t

Public Functions

inline explicit constexpr Value()

inline explicit constexpr Value(uintmax_t const val)

struct haldls::vx::CrossbarInputDropCounter::Value : public halco::common::detail::RantWrapper<Value, uint_fast32_t, hate::math::pow(2, 16) - 1, 0>

#include <routing_crossbar.h>

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

struct haldls::vx::CrossbarOutputEventCounter::Value : public halco::common::detail::RantWrapper<Value, uint_fast32_t, hate::math::pow(2, 24) - 1, 0>

#include <routing_crossbar.h>

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

struct haldls::vx::DAC6573ChannelConfig::Value : public halco::common::detail::RantWrapper<Value, uint_fast32_t, fisch::vx::dac6573_value_max, fisch::vx::dac_value_min>

#include <i2c.h>

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

struct haldls::vx::DACChannel::Value : public halco::common::detail::RantWrapper<Value, uint_fast32_t, fisch::vx::dac_value_max, fisch::vx::dac_value_min>

#include <spi.h>

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

struct haldls::vx::ExternalPPUMemoryByte::Value : public halco::common::detail::BaseType<Value, uint8_t>

#include <fpga.h>

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

struct haldls::vx::JTAGClockScaler::Value : public halco::common::detail::RantWrapper<Value, uint_fast16_t, fisch::vx::jtag_clock_scaler_max, fisch::vx::jtag_clock_scaler_min>

#include <jtag.h>

Clock-scaler value type.

The JTAG clock scales with 1 / (value + 2).

Public Functions

inline explicit constexpr Value(uintmax_t const value = 3)

struct haldls::vx::MADCSampleFromChip::Value : public halco::common::detail::RantWrapper<Value, uint16_t, 0x3ff, 0>

#include <event.h>

Sample value.

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

struct haldls::vx::PPUMemoryWord::Value : public halco::common::detail::RantWrapper<Value, uint_fast32_t, 0xffffffff, 0>

#include <ppu.h>

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

struct haldls::vx::SynapseWeightQuad::Value : public halco::common::detail::RantWrapper<Value, uint8_t, 63, 0>

#include <synapse.h>

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

struct haldls::vx::SystimeSyncBase::Value : public halco::common::detail::RantWrapper<Value, uint64_t, 0x7ffffffffff, 0>

#include <systime.h>

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

struct haldls::vx::Timer::Value : public halco::common::detail::BaseType<Value, uint32_t>

#include <timer.h>

Public Functions

inline explicit constexpr Value(uintmax_t value = 0)

Public Static Attributes

static const Value fpga_clock_cycles_per_us SYMBOL_VISIBLE

struct haldls::vx::VectorGeneratorLUTEntry::Value : public halco::common::detail::RantWrapper<Value, uint_fast16_t, 2047, 0>

#include <vector_generator.h>

Entry value describing the bits [5, 15] of the sent spike label.

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

struct haldls::vx::detail::PhyConfigBase::VBias : public halco::common::detail::RantWrapper<VBias, uint_fast32_t, 7, 0>

#include <phy.h>

Public Functions

inline explicit constexpr VBias(uintmax_t const val = 0)

class haldls::vx::VectorGeneratorControl

#include <vector_generator.h>

Public Types

typedef halco::hicann_dls::vx::VectorGeneratorControlOnFPGA coordinate_type

typedef std::true_type is_leaf_node

enum Notification

Type of notification to send once ready.

Values:

enumerator omnibus

enumerator gpio

enum Signal

Type(s) of signals to use.

Values:

enumerator disabled

enumerator notification

enumerator trigger_and_notification

enum Source

Source to use.

Values:

enumerator omnibus

enumerator external_0

enumerator external_1

enumerator external_2

typedef halco::common::typed_array<Source, halco::hicann_dls::vx::SourceOnVectorGenerator> Sources

typedef halco::common::typed_array<Wait, halco::hicann_dls::vx::SourceOnVectorGenerator> SourceWaits

enum Trigger

Type of trigger signal to listen to.

Values:

enumerator omnibus

enumerator gpio

Public Functions

VectorGeneratorControl() = default

void decode (std::array< fisch::vx::word_access_type::Omnibus, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool get_enable_ignore_zeros () const SYMBOL_VISIBLE

Get whether to ignore events with payload of zero.

Returns

Boolean value

EventPack get_event_pack () const SYMBOL_VISIBLE

halco::hicann_dls::vx::VectorGeneratorLUTEntryOnVectorGeneratorLUT get_lookup_table_entry_start () const SYMBOL_VISIBLE

Get lookup table entry position to start from.

Returns

Entry position

Notification get_notification () const SYMBOL_VISIBLE

ResendCount get_resend_count () const SYMBOL_VISIBLE

Signal get_signal () const SYMBOL_VISIBLE

SourceCount get_source_count () const SYMBOL_VISIBLE

SourceWaits get_source_waits () const SYMBOL_VISIBLE

Sources get_sources () const SYMBOL_VISIBLE

Trigger get_trigger () const SYMBOL_VISIBLE

bool operator!= (VectorGeneratorControl const &other) const SYMBOL_VISIBLE

bool operator== (VectorGeneratorControl const &other) const SYMBOL_VISIBLE

void set_enable_ignore_zeros (bool value) SYMBOL_VISIBLE

Set whether to ignore events with payload of zero.

Parameters

value – Boolean value

void set_event_pack (EventPack value) SYMBOL_VISIBLE

void set_lookup_table_entry_start (halco::hicann_dls::vx::VectorGeneratorLUTEntryOnVectorGeneratorLUT value) SYMBOL_VISIBLE

Set lookup table entry position to start from.

Parameters

value – Entry position

void set_notification (Notification value) SYMBOL_VISIBLE

void set_resend_count (ResendCount value) SYMBOL_VISIBLE

void set_signal (Signal value) SYMBOL_VISIBLE

void set_source_count (SourceCount value) SYMBOL_VISIBLE

void set_source_waits (SourceWaits value) SYMBOL_VISIBLE

void set_sources (Sources value) SYMBOL_VISIBLE

void set_trigger (Trigger value) SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<class Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

bool m_enable_ignore_zeros = {false}

EventPack m_event_pack

halco::hicann_dls::vx::VectorGeneratorLUTEntryOnVectorGeneratorLUT m_lookup_table_entry_start = {}

Notification m_notification = {}

ResendCount m_resend_count = {}

Signal m_signal = {}

SourceCount m_source_count = {}

SourceWaits m_source_waits = {Wait(), Wait()}

Sources m_sources = {Source::omnibus, Source::omnibus}

Trigger m_trigger = {}

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, VectorGeneratorControl const &config) SYMBOL_VISIBLE

class haldls::vx::VectorGeneratorFIFOWord

#include <vector_generator.h>

Container for writing a word of (maximally) four activation values into the FIFO in front of the vector generator.

Public Types

typedef halco::hicann_dls::vx::VectorGeneratorFIFOWordOnFPGA coordinate_type

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::EntryOnQuad> Enables

typedef std::true_type is_leaf_node

typedef PADIEvent::HagenActivation Value

typedef halco::common::typed_array<Value, halco::hicann_dls::vx::EntryOnQuad> Values

Public Functions

VectorGeneratorFIFOWord () SYMBOL_VISIBLE

Default constructor.

void decode (std::array< fisch::vx::word_access_type::Omnibus, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (VectorGeneratorFIFOWord const &other) const SYMBOL_VISIBLE

bool operator== (VectorGeneratorFIFOWord const &other) const SYMBOL_VISIBLE

return_value_policy (reference)) Enables const &get_enable() const SYMBOL_VISIBLE

return_value_policy (reference)) Enables const &get_last() const SYMBOL_VISIBLE

return_value_policy (reference)) Values const &get_values() const SYMBOL_VISIBLE

void set_enable (Enables value) SYMBOL_VISIBLE

Set enables for entries to write.

Parameters

value – Values

void set_last (Enables value) SYMBOL_VISIBLE

Set last enables.

Parameters

value – Values

void set_values (Values value) SYMBOL_VISIBLE

Set values.

Parameters

value – Values

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

Enables m_enable

Enables m_last

Values m_values

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, VectorGeneratorFIFOWord const &config) SYMBOL_VISIBLE

class haldls::vx::VectorGeneratorLUTEntry

#include <vector_generator.h>

Container for an entry in the lookup-table for generation of spike events from activation values.

Public Types

typedef halco::hicann_dls::vx::VectorGeneratorLUTEntryOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

VectorGeneratorLUTEntry() = default

Default constructor.

void decode (std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > encode () const SYMBOL_VISIBLE

Value get_value () const SYMBOL_VISIBLE

Get value.

Returns

Value

bool operator!= (VectorGeneratorLUTEntry const &other) const SYMBOL_VISIBLE

bool operator== (VectorGeneratorLUTEntry const &other) const SYMBOL_VISIBLE

void set_value (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – Value

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

Value m_value = {}

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, VectorGeneratorLUTEntry const &config) SYMBOL_VISIBLE

class haldls::vx::VectorGeneratorNotificationAddress

#include <vector_generator.h>

Public Types

typedef halco::hicann_dls::vx::VectorGeneratorNotificationAddressOnFPGA coordinate_type

typedef std::true_type is_leaf_node

typedef halco::hicann_dls::vx::OmnibusAddress Value

Public Functions

VectorGeneratorNotificationAddress() = default

Default constructor.

VectorGeneratorNotificationAddress (halco::hicann_dls::vx::PPUMemoryWordOnDLS const &word) SYMBOL_VISIBLE

Construct notification address from word location on PPU memory.

Parameters

word – Word location

void decode (std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, config_size_in_words > encode () const SYMBOL_VISIBLE

Value get_value () const SYMBOL_VISIBLE

Get value.

Returns

Value

bool operator!= (VectorGeneratorNotificationAddress const &other) const SYMBOL_VISIBLE

bool operator== (VectorGeneratorNotificationAddress const &other) const SYMBOL_VISIBLE

void set_value (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – Value

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, config_size_in_words > addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t config_size_in_words = 1

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Private Members

Value m_value = {}

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, VectorGeneratorNotificationAddress const &config) SYMBOL_VISIBLE

class haldls::vx::VectorGeneratorTrigger

#include <vector_generator.h>

Public Types

typedef halco::hicann_dls::vx::VectorGeneratorTriggerOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

VectorGeneratorTrigger() = default

Default constructor.

void decode (std::array< fisch::vx::word_access_type::Omnibus, read_config_size_in_words > const &data) SYMBOL_VISIBLE

std::array< fisch::vx::word_access_type::Omnibus, write_config_size_in_words > encode () const SYMBOL_VISIBLE

bool operator!= (VectorGeneratorTrigger const &other) const SYMBOL_VISIBLE

bool operator== (VectorGeneratorTrigger const &other) const SYMBOL_VISIBLE

Public Static Functions

static std::array< halco::hicann_dls::vx::OmnibusAddress, read_config_size_in_words > read_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

static std::array< halco::hicann_dls::vx::OmnibusAddress, write_config_size_in_words > write_addresses (coordinate_type const &coord) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t read_config_size_in_words = 0

static constexpr size_t write_config_size_in_words = 1

Private Functions

template<typename Archive> void serialize (Archive &ar, std::uint32_t const version) SYMBOL_VISIBLE

Friends

friend class cereal::access

friend std::ostream & operator<< (std::ostream &os, VectorGeneratorTrigger const &config) SYMBOL_VISIBLE

struct haldls::vx::JTAGIdCode::Version : public halco::common::detail::RantWrapper<Version, uint_fast8_t, 15, 0>

#include <jtag.h>

Hardware revision number, starting from 0.

Public Functions

inline explicit constexpr Version(uintmax_t const val = 0)

struct haldls::vx::CapMemBlockConfig::VGlobalBias : public halco::common::detail::RantWrapper<VGlobalBias, uint_fast16_t, 15, 0>

#include <capmem.h>

Public Types

typedef halco::common::detail::RantWrapper<VGlobalBias, uint_fast16_t, 15, 0>::rant_t rant_t

Public Functions

inline explicit constexpr VGlobalBias()

inline explicit constexpr VGlobalBias(uintmax_t const val)

template<class ContainerT>
struct haldls::vx::detail::VisitPreorderImpl

#include <common.h>

Implementation detail of the visit_preorder() free function (q.v.).

Note

This class needs to be specialized for non-leaf-node containers, i.e. those that contain other containers.

tparam ContainerT

Non-const-specified type of the container.

Public Static Functions

template<typename ContainerU, typename VisitorT>
static inline void call(ContainerU &config, typename ContainerT::coordinate_type const &coord, VisitorT &&visitor)

Template Parameters

ContainerU – Type of the container, should be equal to ContainerT up to a const-specifier.

template<typename Coordinates>
struct haldls::vx::detail::VisitPreorderImpl<CapMemBlock<Coordinates>>

#include <capmem.h>

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, typename CapMemBlock<Coordinates>::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<PPUMemory>

#include <ppu.h>

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, PPUMemory::coordinate_type const &coord, VisitorT &&visitor)

template<>
struct haldls::vx::detail::VisitPreorderImpl<PPUMemoryBlock>

#include <ppu.h>

Public Static Functions

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, PPUMemoryBlock::coordinate_type const &coord, VisitorT &&visitor)

struct haldls::vx::VectorGeneratorControl::Wait : public halco::common::detail::RantWrapper<Wait, uint_fast8_t, 15, 0>

#include <vector_generator.h>

Wait value to use.

Public Functions

inline explicit constexpr Wait(uintmax_t const val = 0)

struct haldls::vx::CommonSynramConfig::WaitCtrClear : public halco::common::detail::RantWrapper<WaitCtrClear, uint_fast16_t, 7, 0>

#include <synapse.h>

Public Functions

inline explicit constexpr WaitCtrClear(uintmax_t const val = 4)

struct haldls::vx::CommonNeuronBackendConfig::WaitFireNeuron : public halco::common::detail::RantWrapper<WaitFireNeuron, uint_fast16_t, 255, 0>

#include <neuron.h>

Duration of pulse triggering the artificial neuron spikes.

Public Functions

inline explicit constexpr WaitFireNeuron(uintmax_t const val = 4)

struct haldls::vx::CommonNeuronBackendConfig::WaitGlobalPostPulse : public halco::common::detail::RantWrapper<WaitGlobalPostPulse, uint_fast16_t, 255, 0>

#include <neuron.h>

Duration of the pulse triggering global post pulses for all neurons connected to that backend block.

Public Functions

inline explicit constexpr WaitGlobalPostPulse(uintmax_t const val = 1)

struct haldls::vx::CommonNeuronBackendConfig::WaitSpikeCounterRead : public halco::common::detail::RantWrapper<WaitSpikeCounterRead, uint_fast16_t, 255, 0>

#include <neuron.h>

Wait time for letting the neuron backend circuits drive the counter content to the controller logic.

Public Functions

inline explicit constexpr WaitSpikeCounterRead(uintmax_t const val = 112)

struct haldls::vx::CommonNeuronBackendConfig::WaitSpikeCounterReset : public halco::common::detail::RantWrapper<WaitSpikeCounterReset, uint_fast16_t, 255, 0>

#include <neuron.h>

Duration of the pulse triggering spike counter resets.

Public Functions

inline explicit constexpr WaitSpikeCounterReset(uintmax_t const val = 4)

struct haldls::vx::CommonSynramConfig::WConf : public halco::common::detail::RantWrapper<WConf, uint_fast32_t, 255, 0>

#include <synapse.h>

Wordline activation delay.

A higher value results in a shorter delay. See: Hock, Matthias. (2014). Modern Semiconductor Technologies for Neuromorphic Hardware, p.26ff, p.156f, http://doi.org/10.11588/heidok.00017129.

Public Functions

inline explicit constexpr WConf(uintmax_t const val = 3)

struct haldls::vx::AD5252ChannelConfig::WiperSetting : public halco::common::detail::RantWrapper<WiperSetting, uint_fast16_t, std::numeric_limits<uint8_t>::max(), std::numeric_limits<uint8_t>::min()>

#include <i2c.h>

Public Functions

inline explicit constexpr WiperSetting(uintmax_t const val = 0x90)

struct haldls::vx::AD5252ChannelConfigPersistent::WiperSetting : public halco::common::detail::RantWrapper<WiperSetting, uint_fast16_t, std::numeric_limits<uint8_t>::max(), std::numeric_limits<uint8_t>::min()>

#include <i2c.h>

Public Functions

inline explicit constexpr WiperSetting(uintmax_t const val = 0x90)

struct haldls::vx::HicannARQStatus::WriteCount : public halco::common::detail::BaseType<WriteCount, uint32_t>

#include <arq.h>

Number of words submitted to the ARQ from the FPGA.

Public Functions

inline explicit constexpr WriteCount(uintmax_t const val = 0)

namespace cereal

namespace fisch

namespace vx

namespace word_access_type

namespace halco

namespace common

namespace detail

namespace hicann_dls

namespace vx

namespace v2

namespace v3

namespace haldls

namespace haldls::vx

Typedefs

hate::type_list<#define PLAYBACK_CONTAINER(Name, Type) #define LAST_PLAYBACK_CONTAINER(Name, Type) > BackendContainerList

typedef fisch::vx::ChipTime ChipTime

typedef fisch::vx::FPGATime FPGATime

Enums

enum Backend

Possible backends to target with PlaybackProgramBuilder::read/write.

Values:

enumerator PLAYBACK_CONTAINER

enumerator LAST_PLAYBACK_CONTAINER

enum CapMemBlockConfigIOutSelect

Enum inside templated class not wrapped correctly by genpybind (Issue #3699).

Values:

enumerator disabled

enumerator i_out_mux

enumerator i_out_ramp

enum CapMemBlockConfigVRefSelect

Enum inside templated class not wrapped correctly by genpybind (Issue #3699).

Values:

enumerator disabled

enumerator v_ref_v

enumerator v_ref_i

Functions

template<typename T>
void from_json(T &t, std::string const &s)

template<typename T>
void from_portablebinary(T &t, std::string const &s)

std::ostream & operator<< (std::ostream &, ADPLL::Output const &) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &, CurrentDAC::Sign const &) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, CapMemBlockConfigIOutSelect const &config) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, CapMemBlockConfigVRefSelect const &config) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, CommonCorrelationConfig::ResetMode const &config) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, INA219Config::ADCMode const &mode) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, ShiftRegister::AnalogReadoutMux1Input const &config) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, ShiftRegister::AnalogReadoutMux2Input const &config) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, ShiftRegister::AnalogReadoutMux3Input const &config) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, SynapseDriverConfig::RowMode const &mode) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, typename CapMemCell< halco::hicann_dls::vx::v2::Coordinates >::value_type const &value) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, typename CapMemCell< halco::hicann_dls::vx::v3::Coordinates >::value_type const &value) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, VectorGeneratorControl::Notification const &config) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, VectorGeneratorControl::Signal const &config) SYMBOL_VISIBLE

std::ostream & operator<< (std::ostream &os, VectorGeneratorControl::Trigger const &config) SYMBOL_VISIBLE

template<typename T>
std::string to_json(T const &t)

template<typename T>
std::string to_portablebinary(T const &t)

template<class ContainerT, class CoordinateT, class VisitorT>
void visit_preorder(ContainerT &config, CoordinateT const &coord, VisitorT &&visitor)

Apply the specified visitor to all containers in a hierarchy by doing a pre-order tree traversal.

Variables

static const Timer::Value chip_reset_high_duration = Timer::Value(10)

static const Timer::Value chip_reset_low_duration = Timer::Value(100)

static constexpr uint_fast8_t minimal_madc_clock_cycles_per_sample = 12

static const double nominal_pll_f_reference = 5e7

static const Timer::Value pll_and_omnibus_settling_duration = Timer::Value(Timer::Value::fpga_clock_cycles_per_us * 100)

static const Timer::Value reference_generator_reset_duration = Timer::Value(1000)

static const Timer::Value xboard_dac_settling_duration = Timer::Value(Timer::Value::fpga_clock_cycles_per_us * 1000)

namespace haldls::vx::detail

Typedefs

typedef hate::type_list<lola::vx::SynapseCorrelationCalibRow, lola::vx::SynapseCorrelationCalibMatrix, lola::vx::SynapseLabelMatrix, lola::vx::SynapseLabelRow, lola::vx::SynapseMatrix, lola::vx::SynapseRow, lola::vx::SynapseWeightMatrix, lola::vx::SynapseWeightRow, v2::PPUMemory, v2::PPUMemoryBlock, v2::CapMemBlock, lola::vx::v2::AtomicNeuron, lola::vx::v2::CADCSampleRow, lola::vx::v2::CADCSamples, lola::vx::v2::ExternalPPUMemoryBlock, v3::PPUMemory, v3::PPUMemoryBlock, v3::CapMemBlock, lola::vx::v3::AtomicNeuron, lola::vx::v3::CADCSampleRow, lola::vx::v3::CADCSamples, lola::vx::v3::ExternalPPUMemoryBlock> NonLeafNodeReadableContainerList

typedef hate::type_list<lola::vx::CorrelationResetRow, lola::vx::SynapseRow, lola::vx::SynapseMatrix, lola::vx::SynapseWeightMatrix, lola::vx::SynapseLabelMatrix, lola::vx::SynapseCorrelationCalibMatrix, lola::vx::SynapseWeightRow, lola::vx::SynapseLabelRow, lola::vx::SynapseCorrelationCalibRow, v2::PPUMemoryBlock, v2::PPUMemory, v2::CapMemBlock, lola::vx::v2::AtomicNeuron, lola::vx::v2::DACChannelBlock, lola::vx::v2::DACControlBlock, lola::vx::v2::ExternalPPUMemoryBlock, v3::PPUMemoryBlock, v3::PPUMemory, v3::CapMemBlock, lola::vx::v3::AtomicNeuron, lola::vx::v3::DACChannelBlock, lola::vx::v3::DACControlBlock, lola::vx::v3::ExternalPPUMemoryBlock> NonLeafNodeWriteableContainerList

Functions

template<typename CoordinateT, typename ContainerT>
ContainerT coordinate_to_container(CoordinateT const&)

Construct a container instance from a given coordinate.

This function needs to be specialized for all containers, for which default construction does not suffice to match the given coordinate.

Template Parameters

CoordinateT – Coordinate type

Parameters

coord – Coordinate value

template<>
inline PPUMemoryBlock coordinate_to_container(PPUMemoryBlock::coordinate_type const &coord)

template<typename T, size_t N>
constexpr bool is_in_array(std::array<T, N> const &arr, T const &test)

constexpr bool is_read_and_writeable(Backend const b)

Get whether given backend container is readable and writable.

Parameters

b – Backend to check

Returns

Boolean value

namespace haldls::vx::v2

Typedefs

using AD5252ChannelConfig = haldls::vx::AD5252ChannelConfig

using AD5252ChannelConfigPersistent = haldls::vx::AD5252ChannelConfigPersistent

using ADPLL = haldls::vx::ADPLL

using Backend = haldls::vx::Backend

using BackendContainerList = haldls::vx::BackendContainerList

using BackgroundSpikeSource = haldls::vx::BackgroundSpikeSource

using Barrier = haldls::vx::Barrier

using BlockPostPulse = haldls::vx::BlockPostPulse

using CADCChannelConfig = haldls::vx::CADCChannelConfig

using CADCConfig = haldls::vx::CADCConfig

using CADCOffsetSRAMTimingConfig = haldls::vx::CADCOffsetSRAMTimingConfig

using CADCSampleQuad = haldls::vx::CADCSampleQuad

typedef haldls::vx::CapMemBlock<halco::hicann_dls::vx::v2::Coordinates> CapMemBlock

using CapMemCell = haldls::vx::CapMemCell<halco::hicann_dls::vx::v2::Coordinates>

using ChipTime = haldls::vx::ChipTime

using ColumnCorrelationQuad = haldls::vx::ColumnCorrelationQuad

using ColumnCurrentQuad = haldls::vx::ColumnCurrentQuad

using CommonCorrelationConfig = haldls::vx::CommonCorrelationConfig

using CommonNeuronBackendConfig = haldls::vx::CommonNeuronBackendConfig

using CommonPADIBusConfig = haldls::vx::CommonPADIBusConfig

using CommonPhyConfigChip = haldls::vx::CommonPhyConfigChip

using CommonPhyConfigFPGA = haldls::vx::CommonPhyConfigFPGA

using CommonSTPConfig = haldls::vx::CommonSTPConfig

using CommonSynramConfig = haldls::vx::CommonSynramConfig

using CorrelationReset = haldls::vx::CorrelationReset

using CrossbarInputDropCounter = haldls::vx::CrossbarInputDropCounter

using CrossbarNode = haldls::vx::CrossbarNode

using CrossbarOutputConfig = haldls::vx::CrossbarOutputConfig

using CrossbarOutputEventCounter = haldls::vx::CrossbarOutputEventCounter

using CurrentDAC = haldls::vx::CurrentDAC

using DAC6573ChannelConfig = haldls::vx::DAC6573ChannelConfig

using DACChannel = haldls::vx::DACChannel

using DACControl = haldls::vx::DACControl

using DifferentialWriteTrait = haldls::vx::DifferentialWriteTrait

using EventRecordingConfig = haldls::vx::EventRecordingConfig

using ExternalPPUMemoryByte = haldls::vx::ExternalPPUMemoryByte

using ExternalPPUMemoryQuad = haldls::vx::ExternalPPUMemoryQuad

using FPGADeviceDNA = haldls::vx::FPGADeviceDNA

using FPGATime = haldls::vx::FPGATime

using HicannARQStatus = haldls::vx::HicannARQStatus

using HighspeedLinkNotification = haldls::vx::HighspeedLinkNotification

using INA219Config = haldls::vx::INA219Config

using INA219Status = haldls::vx::INA219Status

using JTAGClockScaler = haldls::vx::JTAGClockScaler

using JTAGIdCode = haldls::vx::JTAGIdCode

using MADCConfig = haldls::vx::MADCConfig

using MADCControl = haldls::vx::MADCControl

using MADCSampleFromChip = haldls::vx::MADCSampleFromChip

using NeuronBackendConfig = haldls::vx::NeuronBackendConfig<halco::hicann_dls::vx::v2::Coordinates>

using NeuronBackendSRAMTimingConfig = haldls::vx::NeuronBackendSRAMTimingConfig

using NeuronReset = haldls::vx::NeuronReset

using NeuronSRAMTimingConfig = haldls::vx::NeuronSRAMTimingConfig

using NullPayloadReadable = haldls::vx::NullPayloadReadable

using PADIEvent = haldls::vx::PADIEvent

using PadMultiplexerConfig = haldls::vx::PadMultiplexerConfig

using PerfTest = haldls::vx::PerfTest

using PerfTestStatus = haldls::vx::PerfTestStatus

using PhyConfigChip = haldls::vx::PhyConfigChip

using PhyConfigFPGA = haldls::vx::PhyConfigFPGA

using PhyStatus = haldls::vx::PhyStatus

using PLLSelfTest = haldls::vx::PLLSelfTest

using PLLSelfTestStatus = haldls::vx::PLLSelfTestStatus

using PollingOmnibusBlock = haldls::vx::PollingOmnibusBlock

using PollingOmnibusBlockConfig = haldls::vx::PollingOmnibusBlockConfig

using PPUControlRegister = haldls::vx::PPUControlRegister

typedef haldls::vx::PPUMemory PPUMemory

typedef haldls::vx::PPUMemoryBlock PPUMemoryBlock

using PPUMemoryWord = haldls::vx::PPUMemoryWord

using PPUStatusRegister = haldls::vx::PPUStatusRegister

using ReadoutSourceSelection = haldls::vx::ReadoutSourceSelection

using ResetChip = haldls::vx::ResetChip

using ResetJTAGTap = haldls::vx::ResetJTAGTap

using ShiftRegister = haldls::vx::ShiftRegister

using SpikeCounterRead = haldls::vx::SpikeCounterRead

using SpikeCounterReset = haldls::vx::SpikeCounterReset

using SpikeFromChip = haldls::vx::SpikeFromChip

using SpikeLabel = haldls::vx::SpikeLabel

using SpikePack1ToChip = haldls::vx::SpikePack1ToChip

using SpikePack2ToChip = haldls::vx::SpikePack2ToChip

using SpikePack3ToChip = haldls::vx::SpikePack3ToChip

using SynapseBiasSelection = haldls::vx::SynapseBiasSelection

using SynapseCorrelationCalibQuad = haldls::vx::SynapseCorrelationCalibQuad

using SynapseDriverConfig = haldls::vx::SynapseDriverConfig

using SynapseDriverSRAMTimingConfig = haldls::vx::SynapseDriverSRAMTimingConfig

using SynapseLabelQuad = haldls::vx::SynapseLabelQuad

using SynapseQuad = haldls::vx::SynapseQuad

using SynapseWeightQuad = haldls::vx::SynapseWeightQuad

using SystimeSync = haldls::vx::SystimeSync

using SystimeSyncBase = haldls::vx::SystimeSyncBase

using TCA9554Config = haldls::vx::TCA9554Config

using TCA9554Inputs = haldls::vx::TCA9554Inputs

using Timer = haldls::vx::Timer

using VectorGeneratorControl = haldls::vx::VectorGeneratorControl

using VectorGeneratorFIFOWord = haldls::vx::VectorGeneratorFIFOWord

using VectorGeneratorLUTEntry = haldls::vx::VectorGeneratorLUTEntry

using VectorGeneratorNotificationAddress = haldls::vx::VectorGeneratorNotificationAddress

using VectorGeneratorTrigger = haldls::vx::VectorGeneratorTrigger

Functions

cls def(pybind11::init<::haldls::vx::v2::CapMemCell::Value >(), pybind11::arg("value")=::haldls::vx::v2::CapMemCell::Value(0)) .def(pybind11 parent attr ("CapMemCell").attr("value_type")

std::ostream & operator<< (std::ostream &, NeuronConfig::ReadoutSource const &) SYMBOL_VISIBLE

template<typename ...Ts>
auto visit_preorder(Ts&&... args) -> decltype(haldls::vx::visit_preorder(std::forward<Ts>(args)...))

Variables

static const Timer::Value chip_reset_high_duration = haldls::vx::chip_reset_high_duration

static const Timer::Value chip_reset_low_duration = haldls::vx::chip_reset_low_duration

static const Timer::Value pll_and_omnibus_settling_duration = haldls::vx::pll_and_omnibus_settling_duration

static const Timer::Value reference_generator_reset_duration = haldls::vx::reference_generator_reset_duration

static const Timer::Value xboard_dac_settling_duration = haldls::vx::xboard_dac_settling_duration

namespace haldls::vx::v2::detail

Typedefs

hate::type_list<# 33 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/haldls/include/haldls/vx/v2/pyhaldls.h" 2 haldls::vx::Barrier > pickle_types

Functions

py::list get_containers_list(py::module &m)

Variables

static std::vector<std::string> const pickle_type_names = {"Barrier"}

namespace haldls::vx::v3

Typedefs

using AD5252ChannelConfig = haldls::vx::AD5252ChannelConfig

using AD5252ChannelConfigPersistent = haldls::vx::AD5252ChannelConfigPersistent

using ADPLL = haldls::vx::ADPLL

using Backend = haldls::vx::Backend

using BackendContainerList = haldls::vx::BackendContainerList

using BackgroundSpikeSource = haldls::vx::BackgroundSpikeSource

using Barrier = haldls::vx::Barrier

using BlockPostPulse = haldls::vx::BlockPostPulse

using CADCChannelConfig = haldls::vx::CADCChannelConfig

using CADCConfig = haldls::vx::CADCConfig

using CADCOffsetSRAMTimingConfig = haldls::vx::CADCOffsetSRAMTimingConfig

using CADCSampleQuad = haldls::vx::CADCSampleQuad

typedef haldls::vx::CapMemBlock<halco::hicann_dls::vx::v3::Coordinates> CapMemBlock

using CapMemCell = haldls::vx::CapMemCell<halco::hicann_dls::vx::v3::Coordinates>

using ChipTime = haldls::vx::ChipTime

using ColumnCorrelationQuad = haldls::vx::ColumnCorrelationQuad

using ColumnCurrentQuad = haldls::vx::ColumnCurrentQuad

using CommonCorrelationConfig = haldls::vx::CommonCorrelationConfig

using CommonNeuronBackendConfig = haldls::vx::CommonNeuronBackendConfig

using CommonPADIBusConfig = haldls::vx::CommonPADIBusConfig

using CommonPhyConfigChip = haldls::vx::CommonPhyConfigChip

using CommonPhyConfigFPGA = haldls::vx::CommonPhyConfigFPGA

using CommonSTPConfig = haldls::vx::CommonSTPConfig

using CommonSynramConfig = haldls::vx::CommonSynramConfig

using CorrelationReset = haldls::vx::CorrelationReset

using CrossbarInputDropCounter = haldls::vx::CrossbarInputDropCounter

using CrossbarNode = haldls::vx::CrossbarNode

using CrossbarOutputConfig = haldls::vx::CrossbarOutputConfig

using CrossbarOutputEventCounter = haldls::vx::CrossbarOutputEventCounter

using CurrentDAC = haldls::vx::CurrentDAC

using DAC6573ChannelConfig = haldls::vx::DAC6573ChannelConfig

using DACChannel = haldls::vx::DACChannel

using DACControl = haldls::vx::DACControl

using DifferentialWriteTrait = haldls::vx::DifferentialWriteTrait

using EventRecordingConfig = haldls::vx::EventRecordingConfig

using ExternalPPUMemoryByte = haldls::vx::ExternalPPUMemoryByte

using ExternalPPUMemoryQuad = haldls::vx::ExternalPPUMemoryQuad

using FPGADeviceDNA = haldls::vx::FPGADeviceDNA

using FPGATime = haldls::vx::FPGATime

using HicannARQStatus = haldls::vx::HicannARQStatus

using HighspeedLinkNotification = haldls::vx::HighspeedLinkNotification

using INA219Config = haldls::vx::INA219Config

using INA219Status = haldls::vx::INA219Status

using JTAGClockScaler = haldls::vx::JTAGClockScaler

using JTAGIdCode = haldls::vx::JTAGIdCode

using MADCConfig = haldls::vx::MADCConfig

using MADCControl = haldls::vx::MADCControl

using MADCSampleFromChip = haldls::vx::MADCSampleFromChip

using NeuronBackendConfig = haldls::vx::NeuronBackendConfig<halco::hicann_dls::vx::v3::Coordinates>

using NeuronBackendSRAMTimingConfig = haldls::vx::NeuronBackendSRAMTimingConfig

using NeuronReset = haldls::vx::NeuronReset

using NeuronSRAMTimingConfig = haldls::vx::NeuronSRAMTimingConfig

using NullPayloadReadable = haldls::vx::NullPayloadReadable

using PADIEvent = haldls::vx::PADIEvent

using PadMultiplexerConfig = haldls::vx::PadMultiplexerConfig

using PerfTest = haldls::vx::PerfTest

using PerfTestStatus = haldls::vx::PerfTestStatus

using PhyConfigChip = haldls::vx::PhyConfigChip

using PhyConfigFPGA = haldls::vx::PhyConfigFPGA

using PhyStatus = haldls::vx::PhyStatus

using PLLSelfTest = haldls::vx::PLLSelfTest

using PLLSelfTestStatus = haldls::vx::PLLSelfTestStatus

using PollingOmnibusBlock = haldls::vx::PollingOmnibusBlock

using PollingOmnibusBlockConfig = haldls::vx::PollingOmnibusBlockConfig

using PPUControlRegister = haldls::vx::PPUControlRegister

typedef haldls::vx::PPUMemory PPUMemory

typedef haldls::vx::PPUMemoryBlock PPUMemoryBlock

using PPUMemoryWord = haldls::vx::PPUMemoryWord

using PPUStatusRegister = haldls::vx::PPUStatusRegister

using ReadoutSourceSelection = haldls::vx::ReadoutSourceSelection

using ResetChip = haldls::vx::ResetChip

using ResetJTAGTap = haldls::vx::ResetJTAGTap

using ShiftRegister = haldls::vx::ShiftRegister

using SpikeCounterRead = haldls::vx::SpikeCounterRead

using SpikeCounterReset = haldls::vx::SpikeCounterReset

using SpikeFromChip = haldls::vx::SpikeFromChip

using SpikeLabel = haldls::vx::SpikeLabel

using SpikePack1ToChip = haldls::vx::SpikePack1ToChip

using SpikePack2ToChip = haldls::vx::SpikePack2ToChip

using SpikePack3ToChip = haldls::vx::SpikePack3ToChip

using SynapseBiasSelection = haldls::vx::SynapseBiasSelection

using SynapseCorrelationCalibQuad = haldls::vx::SynapseCorrelationCalibQuad

using SynapseDriverConfig = haldls::vx::SynapseDriverConfig

using SynapseDriverSRAMTimingConfig = haldls::vx::SynapseDriverSRAMTimingConfig

using SynapseLabelQuad = haldls::vx::SynapseLabelQuad

using SynapseQuad = haldls::vx::SynapseQuad

using SynapseWeightQuad = haldls::vx::SynapseWeightQuad

using SystimeSync = haldls::vx::SystimeSync

using SystimeSyncBase = haldls::vx::SystimeSyncBase

using TCA9554Config = haldls::vx::TCA9554Config

using TCA9554Inputs = haldls::vx::TCA9554Inputs

using Timer = haldls::vx::Timer

using VectorGeneratorControl = haldls::vx::VectorGeneratorControl

using VectorGeneratorFIFOWord = haldls::vx::VectorGeneratorFIFOWord

using VectorGeneratorLUTEntry = haldls::vx::VectorGeneratorLUTEntry

using VectorGeneratorNotificationAddress = haldls::vx::VectorGeneratorNotificationAddress

using VectorGeneratorTrigger = haldls::vx::VectorGeneratorTrigger

Functions

cls def(pybind11::init<::haldls::vx::v3::CapMemCell::Value >(), pybind11::arg("value")=::haldls::vx::v3::CapMemCell::Value(0)) .def(pybind11 parent attr ("CapMemCell").attr("value_type")

std::ostream & operator<< (std::ostream &, NeuronConfig::ReadoutSource const &) SYMBOL_VISIBLE

template<typename ...Ts>
auto visit_preorder(Ts&&... args) -> decltype(haldls::vx::visit_preorder(std::forward<Ts>(args)...))

Variables

static const Timer::Value chip_reset_high_duration = haldls::vx::chip_reset_high_duration

static const Timer::Value chip_reset_low_duration = haldls::vx::chip_reset_low_duration

static const Timer::Value pll_and_omnibus_settling_duration = haldls::vx::pll_and_omnibus_settling_duration

static const Timer::Value reference_generator_reset_duration = haldls::vx::reference_generator_reset_duration

static const Timer::Value xboard_dac_settling_duration = haldls::vx::xboard_dac_settling_duration

namespace haldls::vx::v3::detail

Typedefs

hate::type_list<# 33 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/haldls/include/haldls/vx/v3/pyhaldls.h" 2 haldls::vx::Barrier > pickle_types

Functions

py::list get_containers_list(py::module &m)

Variables

static std::vector<std::string> const pickle_type_names = {"Barrier"}

namespace lola

namespace vx

namespace lola::vx::v2

Typedefs

using DACChannelBlock = lola::vx::DACChannelBlock

using DACControlBlock = lola::vx::DACControlBlock

typedef lola::vx::ExternalPPUMemoryBlock ExternalPPUMemoryBlock

namespace lola::vx::v3

Typedefs

using DACChannelBlock = lola::vx::DACChannelBlock

using DACControlBlock = lola::vx::DACControlBlock

typedef lola::vx::ExternalPPUMemoryBlock ExternalPPUMemoryBlock

namespace std

STL namespace.

namespace T

file bitfield.h

#include <boost/preprocessor/seq/for_each.hpp>#include <boost/preprocessor/seq/reverse.hpp>

Defines

BITFIELD_ORDER_IDENTITY(r, data, elem)

EXPAND_BITFIELD_ELEMENTS(x)

file cerealization.h

#include “hate/type_list.h”#include “hate/visibility.h”#include <cstdint>#include <iosfwd>#include <cereal/macros.hpp>

Defines

EXPLICIT_INSTANTIATE_CEREAL_SERIALIZE(CLASS_NAME)

EXPLICIT_INSTANTIATE_CEREAL_SERIALIZE_FREE(CLASS_NAME)

EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CLASS_NAME)

EXTERN_INSTANTIATE_CEREAL_SERIALIZE_FREE(CLASS_NAME)

file arq.h

#include <array>#include <iosfwd>#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/highspeed_link.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file arq.h

#include “haldls/vx/arq.h”#include “haldls/vx/genpybind.h”

file arq.h

#include “haldls/vx/arq.h”#include “haldls/vx/genpybind.h”

file background.h

#include <array>#include <iosfwd>#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/background.h”#include “halco/hicann-dls/vx/event.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/math.h”#include “hate/visibility.h”#include “hxcomm/vx/target.h”

file background.h

#include “haldls/vx/background.h”#include “haldls/vx/genpybind.h”

file background.h

#include “haldls/vx/background.h”#include “haldls/vx/genpybind.h”

file barrier.h

#include <iosfwd>#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file barrier.h

#include “haldls/vx/barrier.h”#include “haldls/vx/genpybind.h”

file barrier.h

#include “haldls/vx/barrier.h”#include “haldls/vx/genpybind.h”

file block.h

#include <array>#include <ostream>#include “fisch/vx/word_access/type/omnibus.h”#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/omnibus.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”#include “hxcomm/vx/target.h”

file block.h

#include “haldls/vx/block.h”#include “haldls/vx/genpybind.h”

file block.h

#include “haldls/vx/block.h”#include “haldls/vx/genpybind.h”

file cadc.h

#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”#include “hxcomm/vx/target.h”

file cadc.h

#include “halco/common/typed_array.h”#include “haldls/cerealization.h”#include “haldls/vx/cadc.h”#include “haldls/vx/genpybind.h”

file cadc.h

#include “halco/common/typed_array.h”#include “haldls/cerealization.h”#include “haldls/vx/cadc.h”#include “haldls/vx/genpybind.h”

file capmem.h

#include <array>#include <cstdint>#include <ostream>#include <sstream>#include <variant>#include “halco/common/geometry.h”#include “halco/common/iter_all.h”#include “halco/common/typed_heap_array.h”#include “halco/hicann-dls/vx/capmem.h”#include “haldls/cerealization.h”#include “haldls/vx/common.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/join.h”#include “hate/visibility.h”#include “hxcomm/vx/target.h”

Defines

CAPMEM_EXTERN_TEMPLATE(Coordinates)

CAPMEM_HALCO_GEOMETRY_HASH(Coordinates)

file capmem.h

#include “halco/hicann-dls/vx/v2/capmem.h”#include “halco/hicann-dls/vx/v2/coordinates.h”#include “haldls/cerealization.h”#include “haldls/vx/capmem.h”#include “haldls/vx/genpybind.h”

Typedefs

using CapMemBlock = haldls::vx::CapMemBlock<halco::hicann_dls::vx::v2::Coordinates>

using CapMemBlockConfig = haldls::vx::CapMemBlockConfig<halco::hicann_dls::vx::v2::Coordinates>

file capmem.h

#include “halco/hicann-dls/vx/v3/capmem.h”#include “halco/hicann-dls/vx/v3/coordinates.h”#include “haldls/cerealization.h”#include “haldls/vx/capmem.h”#include “haldls/vx/genpybind.h”

Typedefs

using CapMemBlock = haldls::vx::CapMemBlock<halco::hicann_dls::vx::v3::Coordinates>

using CapMemBlockConfig = haldls::vx::CapMemBlockConfig<halco::hicann_dls::vx::v3::Coordinates>

file common.h

#include <type_traits>#include <utility>

file common.h

#include “haldls/vx/common.h”#include “haldls/vx/genpybind.h”

file common.h

#include “haldls/vx/common.h”#include “haldls/vx/genpybind.h”

file constants.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/timer.h”

file constants.h

#include “haldls/vx/constants.h”#include “haldls/vx/genpybind.h”

file constants.h

#include “haldls/vx/constants.h”#include “haldls/vx/genpybind.h”

file coordinate_to_container.h

#include <type_traits>

file correlation.h

#include “halco/common/geometry.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/capmem.h”#include “halco/hicann-dls/vx/correlation.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/math.h”#include “hate/visibility.h”#include “haldls/cerealization.h”#include <cereal/cereal.hpp>

file correlation.h

#include “haldls/cerealization.h”#include “haldls/vx/correlation.h”#include “haldls/vx/genpybind.h”

file correlation.h

#include “haldls/cerealization.h”#include “haldls/vx/correlation.h”#include “haldls/vx/genpybind.h”

file current_dac.h

#include <array>#include <iosfwd>#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/chip.h”#include “halco/hicann-dls/vx/current_dac.h”#include “halco/hicann-dls/vx/synapse.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file current_dac.h

#include “haldls/vx/current_dac.h”#include “haldls/vx/genpybind.h”

file current_dac.h

#include “haldls/vx/current_dac.h”#include “haldls/vx/genpybind.h”

file event.h

#include “fisch/vx/event.h”#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/event.h”#include “halco/hicann-dls/vx/highspeed_link.h”#include “halco/hicann-dls/vx/readout.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/neuron.h”#include “haldls/vx/padi.h”#include “haldls/vx/synapse.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

Defines

SpikePackToChip(Num)

file event.h

#include “haldls/vx/event.h”#include “haldls/vx/genpybind.h”

file event.h

#include “haldls/vx/event.h”#include “haldls/vx/genpybind.h”

file fpga.h

#include <array>#include <iosfwd>#include “halco/common/geometry.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/fpga.h”#include “halco/hicann-dls/vx/quad.h”#include “haldls/cerealization.h”#include “haldls/vx/common.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file fpga.h

#include “haldls/vx/fpga.h”#include “haldls/vx/genpybind.h”

file fpga.h

#include “haldls/vx/fpga.h”#include “haldls/vx/genpybind.h”

file genpybind.h

#include <genpybind.h>

Defines

GENPYBIND_MODULE

GENPYBIND_TAG_HALDLS_VX

GENPYBIND_TAG_HALDLS_VX_V2

GENPYBIND_TAG_HALDLS_VX_V3

file i2c.h

#include <array>#include <iosfwd>#include <limits>#include “fisch/vx/constants.h”#include “fisch/vx/word_access/type/i2c.h”#include “halco/common/geometry.h”#include “halco/common/iter_all.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/i2c.h”#include “halco/hicann-dls/vx/ultra96.h”#include “halco/hicann-dls/vx/xboard.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/math.h”#include “hate/visibility.h”#include “hxcomm/vx/target.h”

file i2c.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/i2c.h”

file i2c.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/i2c.h”

file is_read_and_writable.h

#include “fisch/vx/container_cast.h”#include “fisch/vx/traits.h”#include “haldls/vx/traits.h”#include “hate/type_list.h”#include <array>#include <type_traits>

file is_readable.h

#include “fisch/vx/traits.h”#include “hate/type_list.h”

file is_writeable.h

#include <type_traits>#include <boost/utility/enable_if.hpp>#include “hate/type_list.h”

file is_writereadable.h

#include “haldls/vx/is_readable.h”#include “haldls/vx/is_writeable.h”

file jtag.h

#include <array>#include <iosfwd>#include “fisch/vx/constants.h”#include “fisch/vx/word_access/type/jtag.h”#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/jtag.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file jtag.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/jtag.h”

file jtag.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/jtag.h”

file madc.h

#include <array>#include <iosfwd>#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/chip.h”#include “halco/hicann-dls/vx/madc.h”#include “halco/hicann-dls/vx/readout.h”#include “halco/hicann-dls/vx/synapse.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/pll.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file madc.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/madc.h”

file madc.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/madc.h”

file neuron.h

#include <array>#include <iosfwd>#include “halco/common/geometry.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/neuron.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/sram_controller.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”#include “haldls/cerealization.h”#include “hxcomm/vx/target.h”

Defines

NEURON_EXTERN_TEMPLATE(Coordinates)

file neuron.h

#include “halco/hicann-dls/vx/v2/coordinates.h”#include “halco/hicann-dls/vx/v2/neuron.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/neuron.h”#include “haldls/cerealization.h”

file neuron.h

#include “halco/hicann-dls/vx/v3/coordinates.h”#include “halco/hicann-dls/vx/v3/neuron.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/neuron.h”#include “haldls/cerealization.h”

file null_payload_readable.h

#include <array>#include <iosfwd>#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/fpga.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file null_payload_readable.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/null_payload_readable.h”

file null_payload_readable.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/null_payload_readable.h”

file omnibus_constants.h

#include <array>#include “haldls/vx/omnibus_constants.tcc”

file omnibus_constants.h

#include <array>#include “haldls/vx/omnibus_constants.tcc”

file omnibus_constants.h

#include <array>#include “haldls/vx/omnibus_constants.tcc”

file padi.h

#include <array>#include <iosfwd>#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/padi.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/synapse.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”#include “hxcomm/vx/target.h”

file padi.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/padi.h”

file padi.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/padi.h”

file perftest.h

#include <array>#include <iosfwd>#include “fisch/vx/word_access/type/reset.h”#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/highspeed_link.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file perftest.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/perftest.h”

file perftest.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/perftest.h”

file phy.h

#include <array>#include <iosfwd>#include “halco/common/geometry.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/highspeed_link.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file phy.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/phy.h”

file phy.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/phy.h”

file pickle.h

#include <iosfwd>#include <vector>#include <pybind11/pybind11.h>#include “hate/type_list.h”

file pll.h

#include <array>#include <iosfwd>#include “halco/common/geometry.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/pll.h”#include “haldls/cerealization.h”#include “haldls/vx/constants.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file pll.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/pll.h”

file pll.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/pll.h”

file ppu.h

#include <array>#include <iosfwd>#include “halco/common/geometry.h”#include “halco/common/iter_all.h”#include “halco/common/typed_heap_array.h”#include “halco/hicann-dls/vx/ppu.h”#include “haldls/cerealization.h”#include “haldls/vx/common.h”#include “haldls/vx/coordinate_to_container.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file ppu.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/ppu.h”

file ppu.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/ppu.h”

file readout.h

#include <iosfwd>#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/capmem.h”#include “halco/hicann-dls/vx/chip.h”#include “halco/hicann-dls/vx/readout.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file readout.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/readout.h”

file readout.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/readout.h”

file reset.h

#include <array>#include <iosfwd>#include “halco/hicann-dls/vx/reset.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file reset.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/reset.h”

file reset.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/reset.h”

file routing_crossbar.h

#include <array>#include <iosfwd>#include “halco/common/geometry.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/event.h”#include “halco/hicann-dls/vx/routing_crossbar.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/math.h”#include “hate/visibility.h”#include “hxcomm/vx/target.h”

file routing_crossbar.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/routing_crossbar.h”

file routing_crossbar.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/routing_crossbar.h”

file spi.h

#include <array>#include <iosfwd>#include “fisch/vx/constants.h”#include “halco/common/geometry.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/dac.h”#include “halco/hicann-dls/vx/xboard.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file spi.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/spi.h”

file spi.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/spi.h”

file sram_controller.h

#include “haldls/cerealization.h”#include “haldls/vx/common.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/math.h”#include “hate/visibility.h”

file sram_controller.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/sram_controller.h”

file sram_controller.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/sram_controller.h”

file synapse.h

#include <array>#include <iosfwd>#include “halco/common/geometry.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/capmem.h”#include “halco/hicann-dls/vx/switch_rows.h”#include “halco/hicann-dls/vx/synapse.h”#include “haldls/cerealization.h”#include “haldls/vx/common.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”#include “hxcomm/vx/target.h”

file synapse.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/synapse.h”

file synapse.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/synapse.h”

file synapse_driver.h

#include <array>#include <iosfwd>#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/synapse_driver.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/sram_controller.h”#include “haldls/vx/synapse_driver.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”#include “haldls/cerealization.h”#include “hxcomm/vx/target.h”

file synapse_driver.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/synapse_driver.h”

file synapse_driver.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/synapse_driver.h”

file systime.h

#include <array>#include <iosfwd>#include “halco/hicann-dls/vx/timing.h”#include “haldls/vx/common.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”#include “haldls/cerealization.h”

file systime.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/systime.h”

file systime.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/systime.h”

file timer.h

#include <array>#include <iosfwd>#include “fisch/vx/word_access/type/timer.h”#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/timing.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

file timer.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/timer.h”

file timer.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/timer.h”

file traits.h

#include “fisch/vx/traits.h”#include “fisch/vx/word_access_type.h”#include “haldls/vx/genpybind.h”#include “hate/type_list.h”#include “hate/visibility.h”#include <type_traits>#include <boost/utility/enable_if.hpp>#include <boost/variant.hpp>#include “fisch/vx/container.def”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)

LAST_PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

file traits.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”

file traits.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/traits.h”

file container.h

#include “haldls/vx/v2/arq.h”#include “haldls/vx/v2/background.h”#include “haldls/vx/v2/block.h”#include “haldls/vx/v2/cadc.h”#include “haldls/vx/v2/capmem.h”#include “haldls/vx/v2/correlation.h”#include “haldls/vx/v2/current_dac.h”#include “haldls/vx/v2/event.h”#include “haldls/vx/v2/fpga.h”#include “haldls/vx/v2/i2c.h”#include “haldls/vx/v2/jtag.h”#include “haldls/vx/v2/madc.h”#include “haldls/vx/v2/neuron.h”#include “haldls/vx/v2/null_payload_readable.h”#include “haldls/vx/v2/padi.h”#include “haldls/vx/v2/perftest.h”#include “haldls/vx/v2/phy.h”#include “haldls/vx/v2/pll.h”#include “haldls/vx/v2/ppu.h”#include “haldls/vx/v2/readout.h”#include “haldls/vx/v2/reset.h”#include “haldls/vx/v2/routing_crossbar.h”#include “haldls/vx/v2/spi.h”#include “haldls/vx/v2/sram_controller.h”#include “haldls/vx/v2/synapse.h”#include “haldls/vx/v2/synapse_driver.h”#include “haldls/vx/v2/systime.h”#include “haldls/vx/v2/timer.h”#include “haldls/vx/v2/vector_generator.h”#include “haldls/vx/genpybind.h”#include “hate/visibility.h”

file container.h

#include “haldls/vx/v3/arq.h”#include “haldls/vx/v3/background.h”#include “haldls/vx/v3/block.h”#include “haldls/vx/v3/cadc.h”#include “haldls/vx/v3/capmem.h”#include “haldls/vx/v3/correlation.h”#include “haldls/vx/v3/current_dac.h”#include “haldls/vx/v3/event.h”#include “haldls/vx/v3/fpga.h”#include “haldls/vx/v3/i2c.h”#include “haldls/vx/v3/jtag.h”#include “haldls/vx/v3/madc.h”#include “haldls/vx/v3/neuron.h”#include “haldls/vx/v3/null_payload_readable.h”#include “haldls/vx/v3/padi.h”#include “haldls/vx/v3/perftest.h”#include “haldls/vx/v3/phy.h”#include “haldls/vx/v3/pll.h”#include “haldls/vx/v3/ppu.h”#include “haldls/vx/v3/readout.h”#include “haldls/vx/v3/reset.h”#include “haldls/vx/v3/routing_crossbar.h”#include “haldls/vx/v3/spi.h”#include “haldls/vx/v3/sram_controller.h”#include “haldls/vx/v3/synapse.h”#include “haldls/vx/v3/synapse_driver.h”#include “haldls/vx/v3/systime.h”#include “haldls/vx/v3/timer.h”#include “haldls/vx/v3/vector_generator.h”#include “haldls/vx/genpybind.h”#include “hate/visibility.h”

file haldls.h

#include “haldls/vx/v2/barrier.h”#include “haldls/vx/v2/constants.h”#include “haldls/vx/v2/container.h”

file haldls.h

#include “haldls/vx/v3/barrier.h”#include “haldls/vx/v3/constants.h”#include “haldls/vx/v3/container.h”

file pyhaldls.h

#include <vector>#include <pybind11/pybind11.h>#include “haldls/cerealization.tcc”#include “haldls/vx/genpybind.h”#include “haldls/cerealization.h”#include “haldls/vx/pickle.h”#include “haldls/vx/v2/barrier.h”#include “haldls/vx/v2/haldls.h”#include “hate/type_list.h”#include “haldls/vx/v2/container.def”

Defines

PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

Functions

parent attr ("Container")

parent attr ("containers")

Variables

auto typing = parent->py::module::import("typing")

file pyhaldls.h

#include <vector>#include <pybind11/pybind11.h>#include “haldls/cerealization.tcc”#include “haldls/vx/genpybind.h”#include “haldls/cerealization.h”#include “haldls/vx/pickle.h”#include “haldls/vx/v3/barrier.h”#include “haldls/vx/v3/haldls.h”#include “hate/type_list.h”#include “haldls/vx/v3/container.def”

Defines

PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

Functions

parent attr ("Container")

parent attr ("containers")

Variables

auto typing = parent->py::module::import("typing")

file vector_generator.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/vector_generator.h”

file vector_generator.h

#include “haldls/vx/genpybind.h”#include “haldls/vx/vector_generator.h”

file vector_generator.h

#include <array>#include <ostream>#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/omnibus.h”#include “halco/hicann-dls/vx/quad.h”#include “halco/hicann-dls/vx/vector_generator.h”#include “haldls/cerealization.h”#include “haldls/vx/genpybind.h”#include “haldls/vx/padi.h”#include “haldls/vx/traits.h”#include “hate/visibility.h”

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/haldls

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/haldls/include/haldls

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/haldls/include

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/haldls/include/haldls/vx/v2

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/haldls/include/haldls/vx/v3

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/haldls/include/haldls/vx