API Reference: haldls

template<typename ContainerT, typename = void>
struct HasLocalData : public std::false_type

#include <has_local_data.h>

template<typename ContainerT>
struct haldls::HasLocalData<ContainerT, typename boost::enable_if_has_type<typename ContainerT::has_local_data>::type>

#include <has_local_data.h>

Public Static Attributes

static constexpr bool value = ContainerT::has_local_data::value

template<typename ContainerT, typename = void>
struct IsLeafNode : public std::false_type

#include <is_leaf_node.h>

template<typename ContainerT>
struct haldls::IsLeafNode<ContainerT, typename boost::enable_if_has_type<typename ContainerT::is_leaf_node>::type>

#include <is_leaf_node.h>

Public Static Attributes

static constexpr bool value = ContainerT::is_leaf_node::value

class haldls::vx::AD5252ChannelConfig : public haldls::vx::ContainerBase<AD5252ChannelConfig>

#include <i2c.h>

Public Types

typedef EncodableBase<AD5252ChannelConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<AD5252ChannelConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<AD5252ChannelConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<AD5252ChannelConfig, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

AD5252ChannelConfig()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

WiperSetting get_value() const

Get wiper setting for digital potentiometer.

Returns

Wiper setting

bool operator!=(AD5252ChannelConfig const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(AD5252ChannelConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(WiperSetting value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 1

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

Private Functions

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

Private Members

WiperSetting m_value

Friends

friend struct cereal::access

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

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)

class haldls::vx::AD5252ChannelConfigPersistent : public haldls::vx::ContainerBase<AD5252ChannelConfigPersistent>

#include <i2c.h>

Public Types

typedef EncodableBase<AD5252ChannelConfigPersistent, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<AD5252ChannelConfigPersistent, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<AD5252ChannelConfigPersistent, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<AD5252ChannelConfigPersistent, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

AD5252ChannelConfigPersistent()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

WiperSetting get_value() const

Get wiper setting for digital potentiometer.

Returns

Wiper setting

bool operator!=(AD5252ChannelConfigPersistent const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(AD5252ChannelConfigPersistent const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(WiperSetting value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 1

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

Private Functions

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

Private Members

WiperSetting m_value

Friends

friend struct cereal::access

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

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)

template<typename TL>
struct AddPickle

Add pickle support to list of classes.

Template Parameters

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

class haldls::vx::ADPLL : public haldls::vx::ContainerBase<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 EncodableBase<ADPLL, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ADPLL, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ADPLL, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<ADPLL, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

enum class Output

Outputs of the ADPLL.

Values:

enumerator core_0

enumerator core_1

enumerator dco

Public Functions

ADPLL()

Default construct ADPLL.

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

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

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

CoreDivM0 get_core_div_m0() const

CoreDivM1 get_core_div_m1() const

DcoPowerSwitch get_dco_power_switch() const

bool get_enable() const

Get whether the ADPLL is enabled.

Returns

Boolean value

bool get_enable_output_clock() const

Get whether output clock is enabled.

Returns

Boolean value

bool get_enforce_lock() const

Get whether the PLL signal is enforced to be locked.

Returns

Boolean value

FilterShift get_filter_shift() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

bool get_lock_window() const

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

Returns

Boolean value

LoopDivN get_loop_div_n() const

LoopFilterInt get_loop_filter_int() const

LoopFilterProp get_loop_filter_prop() const

bool get_open_lock() const

Get whether open loop mode of the DCO is enabled.

Returns

Boolean value

bool get_pfd_select() const

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

Returns

Boolean value

PreDivP0 get_pre_div_p0() const

PreDivP1 get_pre_div_p1() const

PreDivP2 get_pre_div_p2() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

Tune get_tune() const

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool get_use_external_config() const

TODO: What exactly gets this?

Returns

Boolean value

bool operator!=(ADPLL const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(ADPLL const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_core_div_m0(CoreDivM0 value)

void set_core_div_m1(CoreDivM1 value)

void set_dco_power_switch(DcoPowerSwitch value)

void set_enable(bool value)

Set to enable the ADPLL.

Parameters

value – Boolean value to set

void set_enable_output_clock(bool value)

Set whether to enable output clock.

Parameters

value – Boolean value to set

void set_enforce_lock(bool value)

Set to enforce a locked PLL signal.

Parameters

value – Boolean value to set

void set_filter_shift(FilterShift value)

void set_lock_window(bool value)

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

Parameters

value – Boolean value to set

void set_loop_div_n(LoopDivN value)

void set_loop_filter_int(LoopFilterInt value)

void set_loop_filter_prop(LoopFilterProp value)

void set_open_lock(bool value)

Set enable open loop mode of the DCO.

Parameters

value – Boolean value to set

void set_pfd_select(bool value)

Set the pfd bit (with/without synchronizer).

Parameters

value – Boolean value to set

void set_pre_div_p0(PreDivP0 value)

void set_pre_div_p1(PreDivP1 value)

void set_pre_div_p2(PreDivP2 value)

void set_tune(Tune value)

void set_use_external_config(bool value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 2

Private Functions

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

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 struct cereal::access

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

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)

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::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)

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::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::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)

class haldls::vx::BackgroundSpikeSource : public haldls::vx::ContainerBase<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 EncodableBase<BackgroundSpikeSource, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<BackgroundSpikeSource, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<BackgroundSpikeSource, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<BackgroundSpikeSource, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

BackgroundSpikeSource()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable() const

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

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

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

Mask get_mask() const

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

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

Get period value.

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

Returns

Period

Rate get_rate() const

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

Get random seed value.

The value has no effect on regular spike generation.

Returns

Seed

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(BackgroundSpikeSource const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(BackgroundSpikeSource const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable(bool value)

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)

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)

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)

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)

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)

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)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 3

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

Private Functions

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

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 struct cereal::access

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

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::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)

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::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)

class haldls::vx::Barrier : public haldls::vx::BlockUntilBase<Barrier>

#include <barrier.h>

Public Types

typedef Encodable::BackendCocoListVariant BackendCocoListVariant

typedef Encodable::BackendContainerListVariant BackendContainerListVariant

typedef Encodable::BackendCoordinateListVariant BackendCoordinateListVariant

typedef Encodable::Coordinate Coordinate

typedef halco::hicann_dls::vx::BarrierOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

Barrier()

virtual std::unique_ptr<BlockUntil> clone_block_until() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable_jtag() const

bool get_enable_multi_fpga() const

bool get_enable_omnibus() const

bool get_enable_systime() const

bool get_enable_systime_correction() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(Barrier const &other) const

virtual bool operator!=(BlockUntil const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(Barrier const &other) const

virtual bool operator==(BlockUntil const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_jtag(bool value)

void set_enable_multi_fpga(bool value)

void set_enable_omnibus(bool value)

void set_enable_systime(bool value)

void set_enable_systime_correction(bool value)

Public Static Functions

static std::array<halco::hicann_dls::vx::BarrierOnFPGA, write_config_size_in_words> write_addresses(coordinate_type const &coord)

Public Static Attributes

static const Barrier jtag

static const Barrier multi_fpga

static const Barrier omnibus

static const Barrier systime

static const Barrier systime_correction

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Private Members

bool m_enable_jtag

bool m_enable_multi_fpga

bool m_enable_omnibus

bool m_enable_systime

bool m_enable_systime_correction

Friends

friend struct cereal::access

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

class haldls::vx::BlockPostPulse : public haldls::vx::ContainerBase<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 EncodableBase<BlockPostPulse, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<BlockPostPulse, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<BlockPostPulse, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<BlockPostPulse, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

BlockPostPulse()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(BlockPostPulse const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(BlockPostPulse const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Friends

friend struct cereal::access

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

struct haldls::vx::BlockUntil : public haldls::vx::Encodable

#include <block_until.h>

BlockUntil base class to use for polymorphism in en-/decoding.

Subclassed by haldls::vx::EncodableBase< Barrier, BlockUntil >, haldls::vx::EncodableBase< Derived, BlockUntil >, haldls::vx::EncodableBase< PollingOmnibusBlock, BlockUntil >, haldls::vx::EncodableBase< Value, BlockUntil >

Public Types

typedef std::variant<> BackendCocoListVariant

Backend-container-coordinate-pair list variant.

Note

Autogenerated collection of types skipped in documentation.

typedef std::variant<> BackendContainerListVariant

Backend-container list variant.

Note

Autogenerated collection of types skipped in documentation.

typedef std::variant<> BackendCoordinateListVariant

Backend-coordinate list variant.

Note

Autogenerated collection of types skipped in documentation.

typedef halco::common::Coordinate Coordinate

Public Functions

virtual ~BlockUntil() = 0

virtual std::unique_ptr<BlockUntil> clone_block_until() const = 0

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const = 0

Clone data.

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const = 0

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const = 0

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const = 0

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const = 0

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(BlockUntil const &other) const = 0

virtual bool operator!=(Encodable const &other) const = 0

virtual bool operator==(BlockUntil const &other) const = 0

virtual bool operator==(Encodable const &other) const = 0

virtual std::ostream &print(std::ostream &os) const = 0

Print to ostream.

Friends

friend std::ostream &operator<<(std::ostream &os, BlockUntil const &block_until)

Ostream operator.

template<typename Derived, typename Base = BlockUntil>
struct haldls::vx::BlockUntilBase : public haldls::vx::EncodableBase<Derived, BlockUntil>

#include <block_until.h>

BlockUntil base class implementing encode_{read,write}, decode_read via CRTP.

Template Parameters

• Derived – Derived class type

• Base – Base class type of which to generate a derived class. Needed in order to forward to EncodableBase because inheritance aside the Encodable (which would be base of EncodableBase) leads to non-linear inheritance tree and problems with association of implemented interface.

Public Types

typedef Encodable::BackendCocoListVariant BackendCocoListVariant

typedef Encodable::BackendContainerListVariant BackendContainerListVariant

typedef Encodable::BackendCoordinateListVariant BackendCoordinateListVariant

typedef Encodable::Coordinate Coordinate

Public Functions

virtual std::unique_ptr<BlockUntil> clone_block_until() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(BlockUntil const &other) const

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(BlockUntil const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

class haldls::vx::CADCChannelConfig : public haldls::vx::ContainerBase<CADCChannelConfig>

#include <cadc.h>

CADC container with channel-local digital offset config.

Public Types

typedef EncodableBase<CADCChannelConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CADCChannelConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CADCChannelConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CADCChannelConfig, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

CADCChannelConfig()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

Offset get_offset() const

Get Offset value.

Returns

Offset value

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(CADCChannelConfig const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CADCChannelConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

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 size_t constexpr config_size_in_words = 1

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

Private Functions

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

Private Members

Offset m_offset

Friends

friend struct cereal::access

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

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)

class haldls::vx::CADCConfig : public haldls::vx::ContainerBase<CADCConfig>

#include <cadc.h>

CADC container with global digital config for a vertical half.

Public Types

typedef EncodableBase<CADCConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CADCConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CADCConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CADCConfig, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

CADCConfig()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

DeadTime get_dead_time() const

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

Returns

DeadTime value

bool get_enable() const

Get enable value for the CADC.

Returns

Boolean value

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ResetWait get_reset_wait() const

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

Returns

ResetWait value

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(CADCConfig const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CADCConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_dead_time(DeadTime value)

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

Parameters

value – DeadTime value

void set_enable(bool value)

Set enable value for the CADC.

Parameters

value – Boolean value

void set_reset_wait(ResetWait value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Protected Functions

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

Protected Attributes

DeadTime m_dead_time

bool m_enable

ResetWait m_reset_wait

Friends

friend struct cereal::access

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

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::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)

class haldls::vx::CADCOffsetSRAMTimingConfig : public haldls::vx::detail::SRAMTimingConfig, public haldls::vx::ContainerBase<CADCOffsetSRAMTimingConfig>

#include <cadc.h>

Public Types

typedef EncodableBase<CADCOffsetSRAMTimingConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CADCOffsetSRAMTimingConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CADCOffsetSRAMTimingConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CADCOffsetSRAMTimingConfig, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

AddressSetupTime get_address_setup_time() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ReadDelay get_read_delay() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

WriteWidth get_write_width() const

bool operator!=(CADCOffsetSRAMTimingConfig const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SRAMTimingConfig const &other) const

bool operator==(CADCOffsetSRAMTimingConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SRAMTimingConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_address_setup_time(AddressSetupTime value)

void set_read_delay(ReadDelay value)

void set_write_width(WriteWidth value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 2

Private Functions

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

Friends

friend struct cereal::access

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

class haldls::vx::CADCSampleQuad : public haldls::vx::ContainerBase<CADCSampleQuad>

#include <cadc.h>

CADC container of four CADC samples.

Public Types

typedef EncodableBase<CADCSampleQuad, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CADCSampleQuad, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CADCSampleQuad, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CADCSampleQuad, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

CADCSampleQuad()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

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

Get sample value.

Parameters

coord – Sample on quad coordinate

Returns

Value value

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(CADCSampleQuad const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CADCSampleQuad const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

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

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)

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 0

Protected Functions

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

Protected Attributes

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

Friends

friend struct cereal::access

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

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)

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

#include <capmem.h>

Public Types

typedef EncodableBase<CapMemBlock<Coordinates>, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CapMemBlock<Coordinates>, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CapMemBlock<Coordinates>, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CapMemBlock<Coordinates>, Container>::Coordinate Coordinate

typedef Coordinates::CapMemBlockOnDLS coordinate_type

typedef std::false_type has_local_data

Public Functions

CapMemBlock()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

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

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(CapMemBlock const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CapMemBlock const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

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

Private Functions

template<class Archive, typename T>
friend void serialize(Archive &ar, CapMemBlock<T> &value, std::uint32_t const version)

Private Members

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

Friends

friend struct 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, public haldls::vx::ContainerBase<CapMemBlockConfig<Coordinates>>

#include <capmem.h>

Public Types

typedef EncodableBase<CapMemBlockConfig<Coordinates>, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CapMemBlockConfig<Coordinates>, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CapMemBlockConfig<Coordinates>, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CapMemBlockConfig<Coordinates>, Container>::Coordinate Coordinate

typedef Coordinates::CapMemBlockConfigOnDLS coordinate_type

typedef CapMemBlockConfigIOutSelect IOutSelect

typedef std::true_type is_leaf_node

typedef CapMemBlockConfigVRefSelect VRefSelect

Public Functions

CapMemBlockConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

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

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

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

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

VGlobalBias get_v_global_bias() const

bool operator!=(CapMemBlockConfig const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CapMemBlockConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

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 size_t constexpr config_size_in_words = 10

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

Private Functions

template<class Archive, typename T>
friend void serialize(Archive &ar, CapMemBlockConfig<T> &value, 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

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

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::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)

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::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)

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::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::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::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::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)

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<typename Coordinates>
class haldls::vx::CapMemCell : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<CapMemCell<Coordinates>>

#include <capmem.h>

Public Types

typedef EncodableBase<CapMemCell<Coordinates>, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CapMemCell<Coordinates>, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CapMemCell<Coordinates>, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CapMemCell<Coordinates>, Container>::Coordinate Coordinate

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())

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

value_type get_value() const

bool operator!=(CapMemCell const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CapMemCell const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

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 size_t constexpr config_size_in_words = 1

Private Functions

template<class Archive, typename T>
friend void serialize(Archive &ar, CapMemCell<T> &value, std::uint32_t const version)

Private Members

value_type m_value

Friends

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

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::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)

class haldls::vx::CapMemSRAMTimingConfig : public haldls::vx::detail::SRAMTimingConfig, public haldls::vx::ContainerBase<CapMemSRAMTimingConfig>

#include <capmem.h>

Public Types

typedef EncodableBase<CapMemSRAMTimingConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CapMemSRAMTimingConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CapMemSRAMTimingConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CapMemSRAMTimingConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::CapMemSRAMTimingConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

CapMemSRAMTimingConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

AddressSetupTime get_address_setup_time() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ReadDelay get_read_delay() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

WriteWidth get_write_width() const

bool operator!=(CapMemSRAMTimingConfig const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SRAMTimingConfig const &other) const

bool operator==(CapMemSRAMTimingConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SRAMTimingConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_address_setup_time(AddressSetupTime value)

void set_read_delay(ReadDelay value)

void set_write_width(WriteWidth value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 2

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

Private Functions

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

Friends

friend struct cereal::access

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

class haldls::vx::ColumnCorrelationQuad : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<ColumnCorrelationQuad>

#include <synapse.h>

Public Types

typedef EncodableBase<ColumnCorrelationQuad, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ColumnCorrelationQuad, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ColumnCorrelationQuad, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<ColumnCorrelationQuad, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

ColumnCorrelationQuad()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

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

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(ColumnCorrelationQuad const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(ColumnCorrelationQuad const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

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

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 4

Private Functions

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

Private Members

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

Friends

friend struct cereal::access

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

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

struct haldls::vx::ColumnCorrelationQuad::ColumnCorrelationSwitch

#include <synapse.h>

Public Functions

ColumnCorrelationSwitch()

Default constructor.

bool get_enable_cadc_neuron_readout_acausal() const

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

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

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

Returns

Boolean enable value

bool get_enable_debug_causal() const

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

Returns

Boolean enable value

bool get_enable_internal_acausal() const

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

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

bool operator==(ColumnCorrelationSwitch const &other) const

void set_enable_cadc_neuron_readout_acausal(bool value)

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)

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)

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

Parameters

value – Boolean enable value

void set_enable_debug_causal(bool value)

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

Parameters

value – Boolean enable value

void set_enable_internal_acausal(bool value)

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)

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)

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)

class haldls::vx::ColumnCurrentQuad : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<ColumnCurrentQuad>

#include <synapse.h>

Public Types

typedef EncodableBase<ColumnCurrentQuad, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ColumnCurrentQuad, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ColumnCurrentQuad, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<ColumnCurrentQuad, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

ColumnCurrentQuad()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

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

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(ColumnCurrentQuad const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(ColumnCurrentQuad const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

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

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 2

Private Functions

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

Private Members

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

Friends

friend struct cereal::access

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

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

struct haldls::vx::ColumnCurrentQuad::ColumnCurrentSwitch

#include <synapse.h>

Public Functions

ColumnCurrentSwitch()

Default constructor.

bool get_enable_debug_excitatory() const

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

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

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

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

bool operator==(ColumnCurrentSwitch const &other) const

void set_enable_debug_excitatory(bool value)

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)

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)

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)

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)

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&)

class haldls::vx::CommonCorrelationConfig : public haldls::vx::ContainerBase<CommonCorrelationConfig>

#include <correlation.h>

Correlation reset and readout timing configuration container.

Public Types

typedef EncodableBase<CommonCorrelationConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CommonCorrelationConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CommonCorrelationConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CommonCorrelationConfig, Container>::Coordinate Coordinate

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 class ResetMode : uint_fast8_t

Switch between normal and auto-calibrating correlation reset.

Values:

enumerator normal

enumerator auto_calibrating

Public Functions

CommonCorrelationConfig()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

RampOffsets const &get_cadc_v_offset_assignment() const

Ramp offset voltages for the CADCs.

The analog parameter v_offset can be switched between the left and right quadrants. This allows using a low voltage for measurements that is shared for both CADC ramps, and a different high voltage during auto-calibrating reset.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ResetDuration get_reset_duration() const

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

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

ResetMode get_reset_mode() const

Reset mode for correlation storage capacitors.

Defaults to normal mode.

SenseDelay get_sense_delay() const

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

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(CommonCorrelationConfig const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CommonCorrelationConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_cadc_v_offset_assignment(RampOffsets const &value)

void set_reset_duration(ResetDuration value)

void set_reset_fall_time(ResetFallTime value)

void set_reset_mode(ResetMode value)

void set_sense_delay(SenseDelay value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 4

Private Functions

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

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 std::ostream &operator<<(std::ostream &os, CommonCorrelationConfig const &config)

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::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)

class haldls::vx::CommonNeuronBackendConfig : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<CommonNeuronBackendConfig>

#include <neuron.h>

Read/write access to common neuron parameters.

Public Types

typedef EncodableBase<CommonNeuronBackendConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CommonNeuronBackendConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CommonNeuronBackendConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CommonNeuronBackendConfig, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

CommonNeuronBackendConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

ClockScale get_clock_scale_adaptation_pulse() const

ClockScale get_clock_scale_fast() const

ClockScale get_clock_scale_post_pulse() const

ClockScale get_clock_scale_slow() const

bool get_enable_clocks() const

bool get_enable_event_registers() const

bool get_force_reset() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

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

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

WaitFireNeuron get_wait_fire_neuron() const

WaitGlobalPostPulse get_wait_global_post_pulse() const

WaitSpikeCounterRead get_wait_spike_counter_read() const

WaitSpikeCounterReset get_wait_spike_counter_reset() const

bool operator!=(CommonNeuronBackendConfig const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CommonNeuronBackendConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_clock_scale_adaptation_pulse(ClockScale const val)

void set_clock_scale_fast(ClockScale const val)

void set_clock_scale_post_pulse(ClockScale const val)

void set_clock_scale_slow(ClockScale const val)

void set_enable_clocks(bool val)

void set_enable_event_registers(bool val)

void set_force_reset(bool val)

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

void set_wait_fire_neuron(WaitFireNeuron const val)

void set_wait_global_post_pulse(WaitGlobalPostPulse const val)

void set_wait_spike_counter_read(WaitSpikeCounterRead const val)

void set_wait_spike_counter_reset(WaitSpikeCounterReset const val)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 2

Private Functions

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

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 struct cereal::access

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

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)

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)

class haldls::vx::CommonPADIBusConfig : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<CommonPADIBusConfig>

#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 EncodableBase<CommonPADIBusConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CommonPADIBusConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CommonPADIBusConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CommonPADIBusConfig, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

CommonPADIBusConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

dacen_pulse_extension_type const &get_dacen_pulse_extension() const

Extend the timing used to generate the dacen pulses for the synapses.

The longer the pulse, the larger the resulting synaptic weights. In particular useful for triggering the neuron’s bypass mode. It is not recommended to use it for weight scaling!

enable_extended_timing_type const &get_enable_extended_timing() const

Enable extended timing to allow the STP circuit to fully deplete the virtual neurotransmitter partition.

Back-to-back events are not possible in this configuration. Handle with care!

enable_spl1_type const &get_enable_spl1() const

Configure the individual buses to accept SPL1 events instead of PADI events.

Note that these options are mutually exclusive!

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(CommonPADIBusConfig const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CommonPADIBusConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_dacen_pulse_extension(dacen_pulse_extension_type const &value)

void set_enable_extended_timing(enable_extended_timing_type const &value)

void set_enable_spl1(enable_spl1_type 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 size_t constexpr config_size_in_words = 1

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

Private Functions

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

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 struct cereal::access

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

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)

class haldls::vx::CommonPhyConfigChip : public haldls::vx::ContainerBase<CommonPhyConfigChip>

#include <phy.h>

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

Public Types

typedef EncodableBase<CommonPhyConfigChip, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CommonPhyConfigChip, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CommonPhyConfigChip, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CommonPhyConfigChip, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

CommonPhyConfigChip()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

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

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(CommonPhyConfigChip const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CommonPhyConfigChip const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

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

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

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

Friends

friend struct cereal::access

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

class haldls::vx::CommonPhyConfigFPGA : public haldls::vx::ContainerBase<CommonPhyConfigFPGA>

#include <phy.h>

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

Public Types

typedef EncodableBase<CommonPhyConfigFPGA, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CommonPhyConfigFPGA, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CommonPhyConfigFPGA, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CommonPhyConfigFPGA, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

CommonPhyConfigFPGA()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

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

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(CommonPhyConfigFPGA const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CommonPhyConfigFPGA const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

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

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

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

Friends

friend struct cereal::access

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

class haldls::vx::CommonSTPConfig : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<CommonSTPConfig>

#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 EncodableBase<CommonSTPConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CommonSTPConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CommonSTPConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CommonSTPConfig, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

CommonSTPConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable_recovery_clock() const

Enable recovery clock for the STP circuit.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

RecoveryClockSpeed get_recovery_clock_speed() const

Set the scaler for the recovery clock.

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool operator!=(CommonSTPConfig const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CommonSTPConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_recovery_clock(bool const value)

void set_recovery_clock_speed(RecoveryClockSpeed 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 size_t constexpr config_size_in_words = 1

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

Private Functions

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

Private Members

bool m_enable_recovery_clock

RecoveryClockSpeed m_recovery_clock_speed

Friends

friend struct cereal::access

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

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)

class haldls::vx::CommonSynramConfig : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<CommonSynramConfig>

#include <synapse.h>

Public Types

typedef EncodableBase<CommonSynramConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CommonSynramConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CommonSynramConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CommonSynramConfig, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

CommonSynramConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

PCConf get_pc_conf_east() const

PCConf get_pc_conf_west() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

WConf get_w_conf_east() const

WConf get_w_conf_west() const

WaitCtrClear get_wait_ctr_clear() const

bool operator!=(CommonSynramConfig const &other) const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator==(CommonSynramConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_pc_conf_east(PCConf const &value)

void set_pc_conf_west(PCConf const &value)

void set_w_conf_east(WConf const &value)

void set_w_conf_west(WConf const &value)

void set_wait_ctr_clear(WaitCtrClear 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 size_t constexpr config_size_in_words = 3

Private Functions

template<class Archive>
friend void serialize(Archive &ar, CommonSynramConfig &value, 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 struct cereal::access

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

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)

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::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::Container : public haldls::vx::Encodable

#include <container.h>

Container base class to use for polymorphism in en-/decoding.

Subclassed by haldls::vx::EncodableBase< AD5252ChannelConfig, Container >, haldls::vx::EncodableBase< AD5252ChannelConfigPersistent, Container >, haldls::vx::EncodableBase< ADPLL, Container >, haldls::vx::EncodableBase< BackgroundSpikeSource, Container >, haldls::vx::EncodableBase< BlockPostPulse, Container >, haldls::vx::EncodableBase< CADCChannelConfig, Container >, haldls::vx::EncodableBase< CADCConfig, Container >, haldls::vx::EncodableBase< CADCOffsetSRAMTimingConfig, Container >, haldls::vx::EncodableBase< CADCSampleQuad, Container >, haldls::vx::EncodableBase< CapMemBlock< Coordinates >, Container >, haldls::vx::EncodableBase< CapMemBlockConfig< Coordinates >, Container >, haldls::vx::EncodableBase< CapMemCell< Coordinates >, Container >, haldls::vx::EncodableBase< CapMemSRAMTimingConfig, Container >, haldls::vx::EncodableBase< ColumnCorrelationQuad, Container >, haldls::vx::EncodableBase< ColumnCurrentQuad, Container >, haldls::vx::EncodableBase< CommonCorrelationConfig, Container >, haldls::vx::EncodableBase< CommonNeuronBackendConfig, Container >, haldls::vx::EncodableBase< CommonPADIBusConfig, Container >, haldls::vx::EncodableBase< CommonPhyConfigChip, Container >, haldls::vx::EncodableBase< CommonPhyConfigFPGA, Container >, haldls::vx::EncodableBase< CommonSTPConfig, Container >, haldls::vx::EncodableBase< CommonSynramConfig, Container >, haldls::vx::EncodableBase< Derived, Container >, haldls::vx::EncodableBase< CorrelationReset, Container >, haldls::vx::EncodableBase< CrossbarInputDropCounter, Container >, haldls::vx::EncodableBase< CrossbarNode, Container >, haldls::vx::EncodableBase< CrossbarOutputConfig, Container >, haldls::vx::EncodableBase< CrossbarOutputEventCounter, Container >, haldls::vx::EncodableBase< CurrentDAC, Container >, haldls::vx::EncodableBase< DAC6573ChannelConfig, Container >, haldls::vx::EncodableBase< DACChannel, Container >, haldls::vx::EncodableBase< DACControl, Container >, haldls::vx::EncodableBase< EventRecordingConfig, Container >, haldls::vx::EncodableBase< ExternalPPUDRAMMemoryByte, Container >, haldls::vx::EncodableBase< ExternalPPUDRAMMemoryQuad, Container >, haldls::vx::EncodableBase< ExternalPPUMemoryByte, Container >, haldls::vx::EncodableBase< ExternalPPUMemoryQuad, Container >, haldls::vx::EncodableBase< FPGADeviceDNA, Container >, haldls::vx::EncodableBase< FPGASystimeSyncActiveState, Container >, haldls::vx::EncodableBase< FPGASystimeSyncLastAsicSystime, Container >, haldls::vx::EncodableBase< FPGASystimeSyncLastRTT, Container >, haldls::vx::EncodableBase< FPGASystimeSyncNumRetries, Container >, haldls::vx::EncodableBase< HicannARQStatus, Container >, haldls::vx::EncodableBase< INA219Config, Container >, haldls::vx::EncodableBase< INA219Status, Container >, haldls::vx::EncodableBase< InstructionTimeoutConfig, Container >, haldls::vx::EncodableBase< JTAGClockScaler, Container >, haldls::vx::EncodableBase< JTAGIdCode, Container >, haldls::vx::EncodableBase< MADCConfig, Container >, haldls::vx::EncodableBase< MADCControl, Container >, haldls::vx::EncodableBase< NeuronBackendConfig< Coordinates >, Container >, haldls::vx::EncodableBase< NeuronBackendSRAMTimingConfig, Container >, haldls::vx::EncodableBase< NeuronReset, Container >, haldls::vx::EncodableBase< NeuronSRAMTimingConfig, Container >, haldls::vx::EncodableBase< NullPayloadReadable, Container >, haldls::vx::EncodableBase< PADIEvent, Container >, haldls::vx::EncodableBase< PLLSelfTest, Container >, haldls::vx::EncodableBase< PLLSelfTestStatus, Container >, haldls::vx::EncodableBase< PPUControlRegister, Container >, haldls::vx::EncodableBase< PPUMemory, Container >, haldls::vx::EncodableBase< PPUMemoryBlock, Container >, haldls::vx::EncodableBase< PPUMemoryWord, Container >, haldls::vx::EncodableBase< PPUStatusRegister, Container >, haldls::vx::EncodableBase< PadMultiplexerConfig, Container >, haldls::vx::EncodableBase< PerfTest, Container >, haldls::vx::EncodableBase< PerfTestStatus, Container >, haldls::vx::EncodableBase< PhyConfigChip, Container >, haldls::vx::EncodableBase< PhyConfigFPGA, Container >, haldls::vx::EncodableBase< PhyStatus, Container >, haldls::vx::EncodableBase< PollingOmnibusBlockConfig, Container >, haldls::vx::EncodableBase< ReadoutSourceSelection, Container >, haldls::vx::EncodableBase< ResetChip, Container >, haldls::vx::EncodableBase< ResetJTAGTap, Container >, haldls::vx::EncodableBase< ShiftRegister, Container >, haldls::vx::EncodableBase< SpikeCounterRead, Container >, haldls::vx::EncodableBase< SpikeCounterReset, Container >, haldls::vx::EncodableBase< SpikeIOConfig, Container >, haldls::vx::EncodableBase< SpikeIOInputRoute, Container >, haldls::vx::EncodableBase< SpikeIOOutputRoute, Container >, haldls::vx::EncodableBase< SpikePack1ToChip, Container >, haldls::vx::EncodableBase< SpikePack2ToChip, Container >, haldls::vx::EncodableBase< SpikePack3ToChip, Container >, haldls::vx::EncodableBase< SynapseBiasSelection, Container >, haldls::vx::EncodableBase< SynapseCorrelationCalibQuad, Container >, haldls::vx::EncodableBase< SynapseDriverConfig, Container >, haldls::vx::EncodableBase< SynapseDriverSRAMTimingConfig, Container >, haldls::vx::EncodableBase< SynapseLabelQuad, Container >, haldls::vx::EncodableBase< SynapseQuad, Container >, haldls::vx::EncodableBase< SynapseWeightQuad, Container >, haldls::vx::EncodableBase< SystimeCorrectionBarrierConfig, Container >, haldls::vx::EncodableBase< SystimeSync, Container >, haldls::vx::EncodableBase< SystimeSyncBase, Container >, haldls::vx::EncodableBase< TCA9554Config, Container >, haldls::vx::EncodableBase< TCA9554Inputs, Container >, haldls::vx::EncodableBase< Timer, Container >, haldls::vx::EncodableBase< VectorGeneratorControl, Container >, haldls::vx::EncodableBase< VectorGeneratorFIFOWord, Container >, haldls::vx::EncodableBase< VectorGeneratorLUTEntry, Container >, haldls::vx::EncodableBase< VectorGeneratorNotificationAddress, Container >, haldls::vx::EncodableBase< VectorGeneratorTrigger, Container >, haldls::vx::EncodableBase< NeuronConfig, Container >, haldls::vx::EncodableBase< NeuronResetQuad, Container >, haldls::vx::EncodableBase< PLLClockOutputBlock, Container >, haldls::vx::EncodableBase< ReferenceGeneratorConfig, Container >, haldls::vx::EncodableBase< GlobalMergerMatrixInputDropCounter, Container >, haldls::vx::EncodableBase< GlobalMergerMatrixNode, Container >, haldls::vx::EncodableBase< GlobalMergerMatrixOutputConfig, Container >, haldls::vx::EncodableBase< GlobalMergerMatrixOutputEventCounter, Container >, haldls::vx::EncodableBase< NeuronLabelToGL1EventLUTEntry, Container >

Public Types

typedef Encodable::BackendCocoListVariant BackendCocoListVariant

typedef Encodable::BackendContainerListVariant BackendContainerListVariant

typedef Encodable::BackendCoordinateListVariant BackendCoordinateListVariant

typedef Encodable::Coordinate Coordinate

Public Functions

virtual ~Container() = 0

virtual std::unique_ptr<Container> clone_container() const = 0

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const = 0

Clone data.

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate) = 0

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const = 0

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const = 0

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const = 0

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const = 0

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const = 0

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const = 0

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Encodable const &other) const = 0

virtual bool operator==(Encodable const &other) const = 0

virtual std::ostream &print(std::ostream &os) const = 0

Print to ostream.

Friends

friend std::ostream &operator<<(std::ostream &os, Container const &container)

Ostream operator.

template<typename Derived, typename Base = Container>
struct haldls::vx::ContainerBase : public haldls::vx::EncodableBase<Derived, Container>

#include <container.h>

Container base class implementing encode_read, decode_read via CRTP.

Template Parameters

• Derived – Derived class type

• Base – Base class type of which to generate a derived class. Needed in order to forward to EncodableBase because inheritance aside the Encodable (which would be base of EncodableBase) leads to non-linear inheritance tree and problems with association of implemented interface.

Public Types

typedef EncodableBase<Derived, Base>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<Derived, Base>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<Derived, Base>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<Derived, Base>::Coordinate Coordinate

Public Functions

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

class haldls::vx::CorrelationReset : public haldls::vx::ContainerBase<CorrelationReset>

#include <synapse.h>

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

Public Types

typedef EncodableBase<CorrelationReset, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CorrelationReset, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CorrelationReset, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CorrelationReset, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

CorrelationReset()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

bool operator!=(CorrelationReset const &other) const

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(Container const &other) const

bool operator==(CorrelationReset const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Friends

friend struct cereal::access

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

class haldls::vx::CrossbarInputDropCounter : public haldls::vx::ContainerBase<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 EncodableBase<CrossbarInputDropCounter, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CrossbarInputDropCounter, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CrossbarInputDropCounter, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CrossbarInputDropCounter, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

CrossbarInputDropCounter()

Default constructor.

CrossbarInputDropCounter(Value value)

Construct from value.

Parameters

value – Value

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

Get accumulated drop counter value.

Returns

Value

virtual bool operator!=(Container const &other) const

bool operator!=(CrossbarInputDropCounter const &other) const

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(Container const &other) const

bool operator==(CrossbarInputDropCounter const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value value)

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)

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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)

class haldls::vx::CrossbarNode : public haldls::vx::ContainerBase<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 EncodableBase<CrossbarNode, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CrossbarNode, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CrossbarNode, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CrossbarNode, Container>::Coordinate Coordinate

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()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable_drop_counter() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

neuron_label_type get_mask() const

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

Returns

NeuronLabel

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

neuron_label_type get_target() const

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

Returns

NeuronLabel

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

bool operator!=(CrossbarNode const &other) const

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(Container const &other) const

bool operator==(CrossbarNode const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_drop_counter(bool value)

void set_mask(neuron_label_type value)

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

Parameters

value – NeuronLabel

void set_target(neuron_label_type value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 1

static const CrossbarNode drop_all

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

Private Functions

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

Private Members

bool m_enable_drop_counter

neuron_label_type m_mask

neuron_label_type m_target

Friends

friend struct cereal::access

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

class haldls::vx::CrossbarOutputConfig : public haldls::vx::ContainerBase<CrossbarOutputConfig>

#include <routing_crossbar.h>

Public Types

typedef EncodableBase<CrossbarOutputConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CrossbarOutputConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CrossbarOutputConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CrossbarOutputConfig, Container>::Coordinate Coordinate

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()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

enable_event_counter_type const &get_enable_event_counter() const

Get enable value for event counters.

Returns

Boolean values

enable_slow_type const &get_enable_slow() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

bool operator!=(CrossbarOutputConfig const &other) const

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(Container const &other) const

bool operator==(CrossbarOutputConfig const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_event_counter(enable_event_counter_type const &value)

Set enable value for event counters.

Parameters

value – Boolean values

void set_enable_slow(enable_slow_type const &value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

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

Private Functions

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

Private Members

enable_event_counter_type m_enable_event_counter

enable_slow_type m_enable_slow

Friends

friend struct cereal::access

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

class haldls::vx::CrossbarOutputEventCounter : public haldls::vx::ContainerBase<CrossbarOutputEventCounter>

#include <routing_crossbar.h>

Crossbar output event counter counting events routed to an output.

Public Types

typedef EncodableBase<CrossbarOutputEventCounter, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CrossbarOutputEventCounter, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CrossbarOutputEventCounter, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CrossbarOutputEventCounter, Container>::Coordinate Coordinate

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

typedef std::true_type is_leaf_node

Public Functions

CrossbarOutputEventCounter()

Default constructor.

CrossbarOutputEventCounter(Value value)

Construct from value.

Parameters

value – Value

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

Get event counter value.

Returns

Value

virtual bool operator!=(Container const &other) const

bool operator!=(CrossbarOutputEventCounter const &other) const

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(Container const &other) const

bool operator==(CrossbarOutputEventCounter const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value value)

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)

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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)

class haldls::vx::CurrentDAC : public haldls::vx::ContainerBase<CurrentDAC>

#include <current_dac.h>

Configuration of the current DAC of the readout chain.

Public Types

typedef EncodableBase<CurrentDAC, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<CurrentDAC, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<CurrentDAC, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<CurrentDAC, Container>::Coordinate Coordinate

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 class Sign : uint_fast8_t

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()

Default constructor with all inputs disabled.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

HemisphereType const &get_connect_neuron() const

Enable mux connection to neuron array current stimulus of corresponding hemisphere.

SynapseTargetType const &get_connect_synapse() const

Enable mux connection to synapse.

Current get_current() const

Value of current DAC.

bool get_enable_current() const

Enable current source.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

Sign get_sign() const

Select sign of current.

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

bool operator!=(CurrentDAC const &other) const

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(Container const &other) const

bool operator==(CurrentDAC const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_connect_neuron(HemisphereType value)

void set_connect_synapse(SynapseTargetType value)

void set_current(Current value)

void set_enable_current(bool value)

void set_sign(Sign value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

HemisphereType m_connect_neuron

SynapseTargetType m_connect_synapse

Current m_current

bool m_enable_current

Sign m_sign

Friends

friend struct cereal::access

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

struct haldls::vx::CurrentDAC::Current : public halco::common::detail::RantWrapper<Current, uint_fast16_t, 255, 0>

#include <current_dac.h>

Value of current DAC.

Public Functions

inline explicit constexpr Current(uintmax_t const val = 0)

class haldls::vx::DAC6573ChannelConfig : public haldls::vx::ContainerBase<DAC6573ChannelConfig>

#include <i2c.h>

Public Types

typedef EncodableBase<DAC6573ChannelConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<DAC6573ChannelConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<DAC6573ChannelConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<DAC6573ChannelConfig, Container>::Coordinate Coordinate

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.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

Get DAC channel value.

Returns

Value

virtual bool operator!=(Container const &other) const

bool operator!=(DAC6573ChannelConfig const &other) const

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(Container const &other) const

bool operator==(DAC6573ChannelConfig const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 1

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

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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)

class haldls::vx::DACChannel : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<DACChannel>

#include <spi.h>

Container for individual configuration of the value of a DAC channel of the xBoard DACs.

Public Types

typedef EncodableBase<DACChannel, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<DACChannel, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<DACChannel, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<DACChannel, Container>::Coordinate Coordinate

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

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

Get DAC channel value.

Returns

Value to get

virtual bool operator!=(Container const &other) const

bool operator!=(DACChannel const &other) const

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(Container const &other) const

bool operator==(DACChannel const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value value)

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)

static std::array<halco::hicann_dls::vx::SPIDACDataRegisterOnBoard, write_config_size_in_words> write_addresses(coordinate_type const &coord)

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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)

class haldls::vx::DACControl : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<DACControl>

#include <spi.h>

Container for enabling DAC channels of a xBoard DAC.

Public Types

typedef EncodableBase<DACControl, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<DACControl, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<DACControl, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<DACControl, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::DACOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

DACControl()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable_channel(halco::hicann_dls::vx::DACChannelOnDAC const &channel) const

Get DAC channel enable value.

Parameters

channel – Channel to get value for

Returns

Boolean value

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

bool operator!=(DACControl const &other) const

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(Container const &other) const

bool operator==(DACControl const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_channel(halco::hicann_dls::vx::DACChannelOnDAC const &channel, bool value)

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)

static std::array<halco::hicann_dls::vx::SPIDACControlRegisterOnBoard, write_config_size_in_words> write_addresses(coordinate_type const &coord)

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 2

Private Functions

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

Private Members

halco::common::typed_array<bool, halco::hicann_dls::vx::DACChannelOnDAC> m_enable_channel

Friends

friend struct cereal::access

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

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

#include <traits.h>

Public Types

typedef 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 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.

Template Parameters

• ContainerT – Container for which to generate backend traits for

• DefaultBackendContainer – Default backend to use if no is given

• AdditionalBackendContainer – Additionally supported backends

Public Types

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

typedef DefaultBackendContainer default_container

Public Static Functions

static inline constexpr bool valid(Backend backend)

Public Static Attributes

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

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

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

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 table_type gen(table_type table, std::index_sequence<I, Is...>)

Public Static Attributes

static constexpr auto backend_index_lookup_table = gen(table_type(), std::make_index_sequence<sizeof...(Ts)>())

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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

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

#include <barrier.h>

Public Types

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

typedef fisch::vx::word_access_type::Barrier default_container

Public Static Functions

static inline constexpr bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<CapMemSRAMTimingConfig> : public haldls::vx::detail::BackendContainerBase<CapMemSRAMTimingConfig, 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<ExternalPPUDRAMMemoryByte> : public haldls::vx::detail::BackendContainerBase<ExternalPPUDRAMMemoryByte, 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<ExternalPPUDRAMMemoryQuad> : public haldls::vx::detail::BackendContainerBase<ExternalPPUDRAMMemoryQuad, 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<FPGASystimeSyncActiveState> : public haldls::vx::detail::BackendContainerBase<FPGASystimeSyncActiveState, 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<FPGASystimeSyncLastAsicSystime> : public haldls::vx::detail::BackendContainerBase<FPGASystimeSyncLastAsicSystime, 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<FPGASystimeSyncLastRTT> : public haldls::vx::detail::BackendContainerBase<FPGASystimeSyncLastRTT, 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<FPGASystimeSyncNumRetries> : public haldls::vx::detail::BackendContainerBase<FPGASystimeSyncNumRetries, 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<InstructionTimeoutConfig> : public haldls::vx::detail::BackendContainerBase<InstructionTimeoutConfig, 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<SpikeIOConfig> : public haldls::vx::detail::BackendContainerBase<SpikeIOConfig, 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<SpikeIOInputRoute> : public haldls::vx::detail::BackendContainerBase<SpikeIOInputRoute, 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<SpikeIOOutputRoute> : public haldls::vx::detail::BackendContainerBase<SpikeIOOutputRoute, 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<SystimeCorrectionBarrierConfig> : public haldls::vx::detail::BackendContainerBase<SystimeCorrectionBarrierConfig, 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

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

#include <timer.h>

Public Types

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

typedef fisch::vx::word_access_type::WaitUntil default_container

Public Static Functions

static inline constexpr bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

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

#include <global_merger_matrix.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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

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

#include <global_merger_matrix.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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

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

#include <global_merger_matrix.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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

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

#include <global_merger_matrix.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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<v4::NeuronConfig> : public haldls::vx::detail::BackendContainerBase<v4::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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

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

#include <global_merger_matrix.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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<v4::NeuronResetQuad> : public haldls::vx::detail::BackendContainerBase<v4::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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<v4::PLLClockOutputBlock> : public haldls::vx::detail::BackendContainerBase<v4::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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

template<>
struct haldls::vx::detail::BackendContainerTrait<v4::ReferenceGeneratorConfig> : public haldls::vx::detail::BackendContainerBase<v4::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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

static constexpr 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 bool valid(Backend backend)

Public Static Attributes

static constexpr auto backend_index_lookup_table

static constexpr Backend default_backend

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

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 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 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 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 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 bool value = IsReadable<T>::value && IsWriteable<T>::value

struct MADCSampleFromChipChecker

#include <event.h>

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

bool get_enable_auto_init() const

bool get_enable_ber_loopback() const

bool get_enable_bit_slip() const

bool get_enable_clock_pre_alignment() const

bool get_enable_delay_cell_measurement() const

bool get_enable_des_recal() const

bool get_enable_force_lvds_power_up() const

bool get_enable_force_start() const

bool get_enable_initialization_master_mode() const

bool get_enable_loopback_en() const

bool get_enable_manual_training_mode() const

bool get_enable_manual_tx_data_valid_for_init() const

bool get_enable_transmission_without_idle_pattern() const

ManualDelay get_manual_delay() const

VBias get_vbias() const

bool operator!=(PhyConfigBase const &other) const

bool operator==(PhyConfigBase const &other) const

void set_debug_outputs(DebugOutputs value)

void set_enable_auto_init(bool value)

void set_enable_ber_loopback(bool value)

void set_enable_bit_slip(bool value)

void set_enable_clock_pre_alignment(bool value)

void set_enable_delay_cell_measurement(bool value)

void set_enable_des_recal(bool value)

void set_enable_force_lvds_power_up(bool value)

void set_enable_force_start(bool value)

void set_enable_initialization_master_mode(bool value)

void set_enable_loopback_en(bool value)

void set_enable_manual_training_mode(bool value)

void set_enable_manual_tx_data_valid_for_init(bool value)

void set_enable_transmission_without_idle_pattern(bool value)

void set_manual_delay(ManualDelay value)

void set_vbias(VBias value)

Protected Functions

PhyConfigBase()

uint32_t pack() const

void unpack(uint32_t value)

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

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 std::ostream &operator<<(std::ostream &os, PhyConfigBase const &config)

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)

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::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)

struct SpikeFromChipChecker

#include <event.h>

class haldls::vx::detail::SRAMTimingConfig

#include <sram_controller.h>

Configuration of full-custom SRAM timing.

Read:

address _____/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯_________ enable ________________/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯_________ |——-&#8212;|————&#8212;| address read delay setup time

Write:

address _____/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯_________ enable ________________/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯_________ |——-&#8212;|————&#8212;| address write width setup time

Subclassed by haldls::vx::CADCOffsetSRAMTimingConfig, haldls::vx::CapMemSRAMTimingConfig, haldls::vx::NeuronBackendSRAMTimingConfig, haldls::vx::NeuronSRAMTimingConfig, haldls::vx::SynapseDriverSRAMTimingConfig

Public Types

typedef std::true_type is_leaf_node

Public Functions

SRAMTimingConfig()

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

AddressSetupTime get_address_setup_time() const

ReadDelay get_read_delay() const

WriteWidth get_write_width() const

bool operator!=(SRAMTimingConfig const &other) const

bool operator==(SRAMTimingConfig const &other) const

void set_address_setup_time(AddressSetupTime value)

void set_read_delay(ReadDelay value)

void set_write_width(WriteWidth value)

Public Static Attributes

static size_t constexpr config_size_in_words = 2

Private Functions

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

Private Members

AddressSetupTime m_address_setup_time

ReadDelay m_read_delay

WriteWidth m_write_width

Friends

friend struct cereal::access

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)

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)

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

#include <sram_controller.h>

Duration of enable signal pull.

Public Functions

inline explicit constexpr WriteWidth(uintmax_t const val = 11)

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.

Template Parameters

ContainerT – Non-const-specified type of the container.

Public Static Functions

template<typename ContainerU, typename CoordinateU, typename VisitorT>
static inline void call(ContainerU &config, CoordinateU const &coord, VisitorT &&visitor)

Template Parameters

• ContainerU – Type of the container, should be equal to ContainerT up to a const-specifier or hate::Empty<ContainerT>.

• CoordinateU – Type of the container, should be equal to ContainerT up to a const-specifier or hate::Empty<CoordinateT>.

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, hate::Empty<typename ContainerT::coordinate_type> coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(ContainerT &config, typename CapMemBlock<Coordinates>::coordinate_type const &coord, VisitorT &&visitor)

template<typename VisitorT>
static inline void call(hate::Empty<CapMemBlock<Coordinates>> 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, hate::Empty<PPUMemory::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, PPUMemory::coordinate_type const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline void call(hate::Empty<ContainerT> const &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, hate::Empty<PPUMemoryBlock::coordinate_type> const &coord, VisitorT &&visitor)

template<typename ContainerT, typename VisitorT>
static inline std::enable_if_t<!hate::is_empty_v<ContainerT>> call(ContainerT &config, PPUMemoryBlock::coordinate_type const &coord, VisitorT &&visitor)

template<typename VisitorT>
static inline void call(hate::Empty<PPUMemoryBlock> const &config, PPUMemoryBlock::coordinate_type const &coord, VisitorT &&visitor)

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::v3::NeuronConfig, haldls::vx::v4::NeuronConfig

struct haldls::vx::Encodable

#include <encodable.h>

Encodable base class to use for polymorphism.

An encodable can be encoded to write instructions in the backend, where a write is an instruction without determinisitc response. Base class to Container and BlockUntil.

Subclassed by haldls::vx::BlockUntil, haldls::vx::Container, haldls::vx::EncodableBase< Derived, Base >

Public Types

typedef std::variant<> BackendCocoListVariant

Backend-container-coordinate-pair list variant.

Note

Autogenerated collection of types skipped in documentation.

typedef std::variant<> BackendContainerListVariant

Backend-container list variant.

Note

Autogenerated collection of types skipped in documentation.

typedef std::variant<> BackendCoordinateListVariant

Backend-coordinate list variant.

Note

Autogenerated collection of types skipped in documentation.

typedef halco::common::Coordinate Coordinate

Public Functions

virtual ~Encodable() = 0

virtual std::unique_ptr<Encodable> clone_encodable() const = 0

Clone data.

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const = 0

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const = 0

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const = 0

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const = 0

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Encodable const &other) const = 0

virtual bool operator==(Encodable const &other) const = 0

virtual std::ostream &print(std::ostream &os) const = 0

Print to ostream.

Friends

friend std::ostream &operator<<(std::ostream &os, Encodable const &encodable)

Ostream operator.

template<typename Derived, typename Base = Encodable>
struct haldls::vx::EncodableBase : public haldls::vx::Encodable

#include <encodable.h>

Encodable base class implementing encode_write (and others) via CRTP.

Subclassed by haldls::vx::BlockUntilBase< Barrier >, haldls::vx::BlockUntilBase< PollingOmnibusBlock >, haldls::vx::BlockUntilBase< Value >, haldls::vx::ContainerBase< AD5252ChannelConfig >, haldls::vx::ContainerBase< AD5252ChannelConfigPersistent >, haldls::vx::ContainerBase< ADPLL >, haldls::vx::ContainerBase< BackgroundSpikeSource >, haldls::vx::ContainerBase< BlockPostPulse >, haldls::vx::ContainerBase< CADCChannelConfig >, haldls::vx::ContainerBase< CADCConfig >, haldls::vx::ContainerBase< CADCOffsetSRAMTimingConfig >, haldls::vx::ContainerBase< CADCSampleQuad >, haldls::vx::ContainerBase< CapMemBlock< Coordinates > >, haldls::vx::ContainerBase< CapMemBlockConfig< Coordinates > >, haldls::vx::ContainerBase< CapMemCell< Coordinates > >, haldls::vx::ContainerBase< CapMemSRAMTimingConfig >, haldls::vx::ContainerBase< ColumnCorrelationQuad >, haldls::vx::ContainerBase< ColumnCurrentQuad >, haldls::vx::ContainerBase< CommonCorrelationConfig >, haldls::vx::ContainerBase< CommonNeuronBackendConfig >, haldls::vx::ContainerBase< CommonPADIBusConfig >, haldls::vx::ContainerBase< CommonPhyConfigChip >, haldls::vx::ContainerBase< CommonPhyConfigFPGA >, haldls::vx::ContainerBase< CommonSTPConfig >, haldls::vx::ContainerBase< CommonSynramConfig >, haldls::vx::ContainerBase< CorrelationReset >, haldls::vx::ContainerBase< CrossbarInputDropCounter >, haldls::vx::ContainerBase< CrossbarNode >, haldls::vx::ContainerBase< CrossbarOutputConfig >, haldls::vx::ContainerBase< CrossbarOutputEventCounter >, haldls::vx::ContainerBase< CurrentDAC >, haldls::vx::ContainerBase< DAC6573ChannelConfig >, haldls::vx::ContainerBase< DACChannel >, haldls::vx::ContainerBase< DACControl >, haldls::vx::ContainerBase< EventRecordingConfig >, haldls::vx::ContainerBase< ExternalPPUDRAMMemoryByte >, haldls::vx::ContainerBase< ExternalPPUDRAMMemoryQuad >, haldls::vx::ContainerBase< ExternalPPUMemoryByte >, haldls::vx::ContainerBase< ExternalPPUMemoryQuad >, haldls::vx::ContainerBase< FPGADeviceDNA >, haldls::vx::ContainerBase< FPGASystimeSyncActiveState >, haldls::vx::ContainerBase< FPGASystimeSyncLastAsicSystime >, haldls::vx::ContainerBase< FPGASystimeSyncLastRTT >, haldls::vx::ContainerBase< FPGASystimeSyncNumRetries >, haldls::vx::ContainerBase< HicannARQStatus >, haldls::vx::ContainerBase< INA219Config >, haldls::vx::ContainerBase< INA219Status >, haldls::vx::ContainerBase< InstructionTimeoutConfig >, haldls::vx::ContainerBase< JTAGClockScaler >, haldls::vx::ContainerBase< JTAGIdCode >, haldls::vx::ContainerBase< MADCConfig >, haldls::vx::ContainerBase< MADCControl >, haldls::vx::ContainerBase< NeuronBackendConfig< Coordinates > >, haldls::vx::ContainerBase< NeuronBackendSRAMTimingConfig >, haldls::vx::ContainerBase< NeuronReset >, haldls::vx::ContainerBase< NeuronSRAMTimingConfig >, haldls::vx::ContainerBase< NullPayloadReadable >, haldls::vx::ContainerBase< PADIEvent >, haldls::vx::ContainerBase< PLLSelfTest >, haldls::vx::ContainerBase< PLLSelfTestStatus >, haldls::vx::ContainerBase< PPUControlRegister >, haldls::vx::ContainerBase< PPUMemory >, haldls::vx::ContainerBase< PPUMemoryBlock >, haldls::vx::ContainerBase< PPUMemoryWord >, haldls::vx::ContainerBase< PPUStatusRegister >, haldls::vx::ContainerBase< PadMultiplexerConfig >, haldls::vx::ContainerBase< PerfTest >, haldls::vx::ContainerBase< PerfTestStatus >, haldls::vx::ContainerBase< PhyConfigChip >, haldls::vx::ContainerBase< PhyConfigFPGA >, haldls::vx::ContainerBase< PhyStatus >, haldls::vx::ContainerBase< PollingOmnibusBlockConfig >, haldls::vx::ContainerBase< ReadoutSourceSelection >, haldls::vx::ContainerBase< ResetChip >, haldls::vx::ContainerBase< ResetJTAGTap >, haldls::vx::ContainerBase< ShiftRegister >, haldls::vx::ContainerBase< SpikeCounterRead >, haldls::vx::ContainerBase< SpikeCounterReset >, haldls::vx::ContainerBase< SpikeIOConfig >, haldls::vx::ContainerBase< SpikeIOInputRoute >, haldls::vx::ContainerBase< SpikeIOOutputRoute >, haldls::vx::ContainerBase< SpikePack1ToChip >, haldls::vx::ContainerBase< SpikePack2ToChip >, haldls::vx::ContainerBase< SpikePack3ToChip >, haldls::vx::ContainerBase< SynapseBiasSelection >, haldls::vx::ContainerBase< SynapseCorrelationCalibQuad >, haldls::vx::ContainerBase< SynapseDriverConfig >, haldls::vx::ContainerBase< SynapseDriverSRAMTimingConfig >, haldls::vx::ContainerBase< SynapseLabelQuad >, haldls::vx::ContainerBase< SynapseQuad >, haldls::vx::ContainerBase< SynapseWeightQuad >, haldls::vx::ContainerBase< SystimeCorrectionBarrierConfig >, haldls::vx::ContainerBase< SystimeSync >, haldls::vx::ContainerBase< SystimeSyncBase >, haldls::vx::ContainerBase< TCA9554Config >, haldls::vx::ContainerBase< TCA9554Inputs >, haldls::vx::ContainerBase< Timer >, haldls::vx::ContainerBase< VectorGeneratorControl >, haldls::vx::ContainerBase< VectorGeneratorFIFOWord >, haldls::vx::ContainerBase< VectorGeneratorLUTEntry >, haldls::vx::ContainerBase< VectorGeneratorNotificationAddress >, haldls::vx::ContainerBase< VectorGeneratorTrigger >, haldls::vx::ContainerBase< NeuronConfig >, haldls::vx::ContainerBase< NeuronResetQuad >, haldls::vx::ContainerBase< PLLClockOutputBlock >, haldls::vx::ContainerBase< ReferenceGeneratorConfig >, haldls::vx::ContainerBase< GlobalMergerMatrixInputDropCounter >, haldls::vx::ContainerBase< GlobalMergerMatrixNode >, haldls::vx::ContainerBase< GlobalMergerMatrixOutputConfig >, haldls::vx::ContainerBase< GlobalMergerMatrixOutputEventCounter >, haldls::vx::ContainerBase< NeuronLabelToGL1EventLUTEntry >, haldls::vx::BlockUntilBase< Derived, Base >, haldls::vx::ContainerBase< Derived, Base >

Public Types

typedef Encodable::BackendCocoListVariant BackendCocoListVariant

typedef Encodable::BackendContainerListVariant BackendContainerListVariant

typedef Encodable::BackendCoordinateListVariant BackendCoordinateListVariant

typedef Encodable::Coordinate Coordinate

Public Functions

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

class haldls::vx::EventRecordingConfig : public haldls::vx::ContainerBase<EventRecordingConfig>

#include <fpga.h>

Container for the event (spikes, MADC samples) recording configuration register.

Public Types

typedef EncodableBase<EventRecordingConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<EventRecordingConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<EventRecordingConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<EventRecordingConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::EventRecordingConfigOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit EventRecordingConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable_event_recording() const

Get enable event recording.

Returns

bool

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(EventRecordingConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(EventRecordingConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_event_recording(bool value)

Set enable_event_recording.

Parameters

value – bool to set

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Private Members

bool m_enable_event_recording

Friends

friend struct cereal::access

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

class haldls::vx::ExternalPPUDRAMMemoryByte : public haldls::vx::ContainerBase<ExternalPPUDRAMMemoryByte>

#include <fpga.h>

Public Types

typedef EncodableBase<ExternalPPUDRAMMemoryByte, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ExternalPPUDRAMMemoryByte, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ExternalPPUDRAMMemoryByte, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<ExternalPPUDRAMMemoryByte, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::ExternalPPUDRAMMemoryByteOnFPGA coordinate_type

typedef std::true_type is_leaf_node

typedef uint8_t raw_type

typedef std::false_type supports_empty_coordinate

Public Functions

inline explicit ExternalPPUDRAMMemoryByte(Value value = Value())

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

std::array<fisch::vx::word_access_type::Omnibus, config_size_in_words> encode(coordinate_type const &coord) const

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(ExternalPPUDRAMMemoryByte const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(ExternalPPUDRAMMemoryByte const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value const &value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

struct haldls::vx::ExternalPPUDRAMMemoryByte::Value : public halco::common::detail::BaseType<Value, uint8_t>

#include <fpga.h>

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

class haldls::vx::ExternalPPUDRAMMemoryQuad : public haldls::vx::ContainerBase<ExternalPPUDRAMMemoryQuad>

#include <fpga.h>

Public Types

typedef EncodableBase<ExternalPPUDRAMMemoryQuad, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ExternalPPUDRAMMemoryQuad, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ExternalPPUDRAMMemoryQuad, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<ExternalPPUDRAMMemoryQuad, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::ExternalPPUDRAMMemoryQuadOnFPGA 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 ExternalPPUDRAMMemoryByte::Value Value

Public Functions

ExternalPPUDRAMMemoryQuad()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

Enables const &get_enables() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

Quad const &get_quad() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(ExternalPPUDRAMMemoryQuad const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(ExternalPPUDRAMMemoryQuad const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enables(Enables const &enables)

void set_quad(Quad const &quad)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

Enables m_enables

Quad m_quad

Friends

friend struct cereal::access

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

class haldls::vx::ExternalPPUMemoryByte : public haldls::vx::ContainerBase<ExternalPPUMemoryByte>

#include <fpga.h>

Public Types

typedef EncodableBase<ExternalPPUMemoryByte, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ExternalPPUMemoryByte, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ExternalPPUMemoryByte, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<ExternalPPUMemoryByte, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::ExternalPPUMemoryByteOnFPGA coordinate_type

typedef std::true_type is_leaf_node

typedef uint8_t raw_type

typedef std::false_type supports_empty_coordinate

Public Functions

inline explicit ExternalPPUMemoryByte(Value value = Value())

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

std::array<fisch::vx::word_access_type::Omnibus, config_size_in_words> encode(coordinate_type const &coord) const

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(ExternalPPUMemoryByte const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(ExternalPPUMemoryByte const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value const &value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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)

class haldls::vx::ExternalPPUMemoryQuad : public haldls::vx::ContainerBase<ExternalPPUMemoryQuad>

#include <fpga.h>

Public Types

typedef EncodableBase<ExternalPPUMemoryQuad, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ExternalPPUMemoryQuad, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ExternalPPUMemoryQuad, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<ExternalPPUMemoryQuad, Container>::Coordinate Coordinate

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()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

Enables const &get_enables() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

Quad const &get_quad() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(ExternalPPUMemoryQuad const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(ExternalPPUMemoryQuad const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enables(Enables const &enables)

void set_quad(Quad const &quad)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

Enables m_enables

Quad m_quad

Friends

friend struct cereal::access

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

class haldls::vx::FPGADeviceDNA : public haldls::vx::ContainerBase<FPGADeviceDNA>

#include <fpga.h>

Container for reading out the unique identifier of the FPGA.

Public Types

typedef EncodableBase<FPGADeviceDNA, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<FPGADeviceDNA, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<FPGADeviceDNA, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<FPGADeviceDNA, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::FPGADeviceDNAOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit FPGADeviceDNA(Value value = Value())

Construct FPGA identifier with value.

Parameters

value – Value to construct with

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

Get value.

Returns

Value

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(FPGADeviceDNA const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(FPGADeviceDNA const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value value)

Set value.

Parameters

value – Value to set

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 2

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

struct haldls::vx::FPGADeviceDNA::Value : public halco::common::detail::RantWrapper<Value, uint64_t, (1ull << 57) - 1, 0>

#include <fpga.h>

Identifier value type.

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

class haldls::vx::FPGASystimeSyncActiveState : public haldls::vx::ContainerBase<FPGASystimeSyncActiveState>

#include <fpga.h>

Container for reading out the last active-state of the systime-sync FSM.

Public Types

typedef EncodableBase<FPGASystimeSyncActiveState, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<FPGASystimeSyncActiveState, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<FPGASystimeSyncActiveState, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<FPGASystimeSyncActiveState, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::FPGASystimeSyncActiveStateOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit FPGASystimeSyncActiveState(bool active_state = false)

Construct Systime-Sync try-count with active_state.

Parameters

active_state – bool to construct with

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_active_state() const

Get active_state.

Returns

bool

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(FPGASystimeSyncActiveState const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(FPGASystimeSyncActiveState const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_active_state(bool active_state)

Set active_state.

Parameters

active_state – bool to set

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

bool m_active_state

Friends

friend struct cereal::access

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

class haldls::vx::FPGASystimeSyncLastAsicSystime : public haldls::vx::ContainerBase<FPGASystimeSyncLastAsicSystime>

#include <fpga.h>

Container for reading out the last systime received from the ASIC on the FPGA.

Public Types

typedef EncodableBase<FPGASystimeSyncLastAsicSystime, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<FPGASystimeSyncLastAsicSystime, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<FPGASystimeSyncLastAsicSystime, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<FPGASystimeSyncLastAsicSystime, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::FPGASystimeSyncLastAsicSystimeOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit FPGASystimeSyncLastAsicSystime(Systime value = Systime())

Construct Systime-Sync try-count with value.

Parameters

value – Systime to construct with

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Systime get_value() const

Get value.

Returns

Systime

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(FPGASystimeSyncLastAsicSystime const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(FPGASystimeSyncLastAsicSystime const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Systime value)

Set value.

Parameters

value – Systime to set

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 2

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

Systime m_value

Friends

friend struct cereal::access

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

struct haldls::vx::FPGASystimeSyncLastAsicSystime::Systime : public halco::common::detail::RantWrapper<Systime, uint64_t, (1ull << 43) - 1, 0>

#include <fpga.h>

Systime value type.

Public Functions

inline explicit constexpr Systime(uintmax_t const val = 0)

class haldls::vx::FPGASystimeSyncLastRTT : public haldls::vx::ContainerBase<FPGASystimeSyncLastRTT>

#include <fpga.h>

Container for reading out the last systime-sync RTT on the FPGA.

Public Types

typedef EncodableBase<FPGASystimeSyncLastRTT, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<FPGASystimeSyncLastRTT, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<FPGASystimeSyncLastRTT, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<FPGASystimeSyncLastRTT, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::FPGASystimeSyncLastRTTOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit FPGASystimeSyncLastRTT(Systime value = Systime())

Construct Systime-Sync try-count with value.

Parameters

value – Systime to construct with

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Systime get_value() const

Get value.

Returns

Systime

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(FPGASystimeSyncLastRTT const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(FPGASystimeSyncLastRTT const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Systime value)

Set value.

Parameters

value – Systime to set

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 2

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

Systime m_value

Friends

friend struct cereal::access

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

struct haldls::vx::FPGASystimeSyncLastRTT::Systime : public halco::common::detail::RantWrapper<Systime, uint64_t, (1ull << 43) - 1, 0>

#include <fpga.h>

Systime value type.

Public Functions

inline explicit constexpr Systime(uintmax_t const val = 0)

class haldls::vx::FPGASystimeSyncNumRetries : public haldls::vx::ContainerBase<FPGASystimeSyncNumRetries>

#include <fpga.h>

Container for writing the number of retries for the systime-sync on the FPGA.

Public Types

typedef EncodableBase<FPGASystimeSyncNumRetries, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<FPGASystimeSyncNumRetries, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<FPGASystimeSyncNumRetries, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<FPGASystimeSyncNumRetries, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::FPGASystimeSyncNumRetriesOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit FPGASystimeSyncNumRetries(Value value = Value())

Construct Systime-Sync try-count with value.

Parameters

value – Value to construct with

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

Get value.

Returns

Value

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(FPGASystimeSyncNumRetries const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(FPGASystimeSyncNumRetries const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value value)

Set value.

Parameters

value – Value to set

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

struct haldls::vx::FPGASystimeSyncNumRetries::Value : public halco::common::detail::RantWrapper<Value, uint8_t, 15, 0>

#include <fpga.h>

Try-count value type.

Public Functions

inline explicit constexpr Value(uintmax_t const val = 3)

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 : public haldls::vx::ContainerBase<HicannARQStatus>

#include <arq.h>

Public Types

typedef EncodableBase<HicannARQStatus, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<HicannARQStatus, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<HicannARQStatus, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<HicannARQStatus, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::HicannARQStatusOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

HicannARQStatus()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ReadCount get_read_count() const

RxCount get_rx_count() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

TxCount get_tx_count() const

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

WriteCount get_write_count() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(HicannARQStatus const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(HicannARQStatus const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_read_count(ReadCount value)

void set_rx_count(RxCount value)

void set_tx_count(TxCount value)

void set_write_count(WriteCount value)

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 4

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

ReadCount m_read_count

RxCount m_rx_count

TxCount m_tx_count

WriteCount m_write_count

Friends

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

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::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::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::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)

class haldls::vx::HighspeedLinkNotification

#include <event.h>

Highspeed-Link notification from chip.

Public Functions

HighspeedLinkNotification() = default

Default constructor.

HighspeedLinkNotification(fisch::vx::HighspeedLinkNotification const &data)

Construct a HighspeedLinkNotification from the data representation.

Parameters

data – Data to use

bool get_check_error() const

Get if check error occured.

Returns

Boolean value

bool get_crc_error() const

Get if crc error occured.

Returns

Boolean value

bool get_crc_recover() const

Get if crc is recovered.

Returns

Boolean value

bool get_decode_error() const

Get if decode error occured.

Returns

Boolean value

FPGATime get_fpga_time() const

Get FPGA time.

Returns

FPGATime value

bool get_link_up() const

Get if link is up.

Returns

Boolean value

halco::hicann_dls::vx::PhyStatusOnFPGA get_phy() const

Get sample value.

Returns

Value value

bool operator!=(HighspeedLinkNotification const &other) const

bool operator==(HighspeedLinkNotification const &other) const

void set_check_error(bool value)

Set if check error occured.

Parameters

value – Boolean value to set

void set_crc_error(bool value)

Set if crc error occured.

Parameters

value – Boolean value to set

void set_crc_recover(bool value)

Set if crc is recovered.

Parameters

value – Boolean value to set

void set_decode_error(bool value)

Set if decode error occured.

Parameters

value – Boolean value to set

void set_fpga_time(FPGATime value)

Set FPGA time.

Parameters

value – FPGATime value to set

void set_link_up(bool value)

Set if link is up.

Parameters

value – Boolean value to set

void set_phy(halco::hicann_dls::vx::PhyStatusOnFPGA value)

Set sample value.

Parameters

value – Value sample value to set

Private Functions

template<typename Archive>
friend void serialize(Archive &ar, HighspeedLinkNotification &value, 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 struct cereal::access

friend std::ostream &operator<<(std::ostream &os, HighspeedLinkNotification const &sample)

class haldls::vx::INA219Config : public haldls::vx::ContainerBase<INA219Config>

#include <i2c.h>

Public Types

enum class 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 EncodableBase<INA219Config, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<INA219Config, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<INA219Config, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<INA219Config, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::INA219ConfigOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

INA219Config()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

ADCMode get_bus_adc_mode() const

Get bus ADC mode value.

Returns

Value

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ADCMode get_shunt_adc_mode() const

Get shunt ADC mode value.

Returns

Value

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(INA219Config const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(INA219Config const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_bus_adc_mode(ADCMode value)

Set bus ADC mode value.

Parameters

value – Value

void set_shunt_adc_mode(ADCMode value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 1

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

Private Functions

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

Private Members

ADCMode m_bus_adc_mode

ADCMode m_shunt_adc_mode

Friends

friend struct cereal::access

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

class haldls::vx::INA219Status : public haldls::vx::ContainerBase<INA219Status>

#include <i2c.h>

Public Types

typedef EncodableBase<INA219Status, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<INA219Status, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<INA219Status, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<INA219Status, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::INA219StatusOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

INA219Status()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

BusVoltage get_bus_voltage() const

Get bus voltage value.

Returns

Value

bool get_bus_voltage_overflow() const

Get bus voltage overflow value.

Returns

Value

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ShuntVoltage get_shunt_voltage() const

Get shunt voltage value.

Returns

Value

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(INA219Status const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(INA219Status const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_bus_voltage(BusVoltage value)

Set bus voltage value.

Parameters

value – Value

void set_bus_voltage_overflow(bool value)

Set bus voltage overflow value.

Parameters

value – Value

void set_shunt_voltage(ShuntVoltage value)

Set shunt voltage value.

Parameters

value – Value

UncalibratedPower toUncalibratedPower() const

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)

static std::array<halco::hicann_dls::vx::I2CINA219RoRegisterOnBoard, write_config_size_in_words> write_addresses(coordinate_type const &coord)

Public Static Attributes

static size_t constexpr read_config_size_in_words = 2

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

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

BusVoltage m_bus_voltage

bool m_bus_voltage_overflow

ShuntVoltage m_shunt_voltage

Friends

friend struct cereal::access

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

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

Convert to uncalibrated voltage [V] (i.e.

ideal conversion).

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

Convert to uncalibrated voltage [V] (i.e.

ideal conversion).

struct haldls::vx::INA219Status::UncalibratedPower

#include <i2c.h>

Uncalibrated power [W].

Public Functions

float calculate() const

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)

class haldls::vx::InstructionTimeoutConfig : public haldls::vx::ContainerBase<InstructionTimeoutConfig>

#include <fpga.h>

Container for the configuration of the playback instruction timeout duration.

Public Types

typedef EncodableBase<InstructionTimeoutConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<InstructionTimeoutConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<InstructionTimeoutConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<InstructionTimeoutConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::InstructionTimeoutConfigOnFPGA coordinate_type

typedef std::true_type is_leaf_node

typedef Timer::Value Value

Public Functions

explicit InstructionTimeoutConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

Get value.

Returns

Duration value

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(InstructionTimeoutConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(InstructionTimeoutConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value value)

Set value.

Parameters

Duration – value

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

class haldls::vx::JTAGClockScaler : public haldls::vx::ContainerBase<JTAGClockScaler>

#include <jtag.h>

Container writing JTAG clock-scaler value.

Public Types

typedef EncodableBase<JTAGClockScaler, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<JTAGClockScaler, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<JTAGClockScaler, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<JTAGClockScaler, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::JTAGClockScalerOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit JTAGClockScaler(Value value = Value())

Construct scaler with value.

Parameters

value – Value to construct scaler with

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

Decode read words into container config.

Parameters

data – Array of word values

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

Get container config encoded in writable words.

Returns

Array of word values

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(JTAGClockScaler const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(JTAGClockScaler const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set(Value value)

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)

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)

Get word addresses for encoding a write.

Returns

Array of addresses

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

Number of words for read access.

static size_t constexpr write_config_size_in_words = 1

Number of words for write access.

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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 = 6)

class haldls::vx::JTAGIdCode : public haldls::vx::ContainerBase<JTAGIdCode>

#include <jtag.h>

Container for reading the JTAG IDCODE.

Public Types

typedef EncodableBase<JTAGIdCode, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<JTAGIdCode, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<JTAGIdCode, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<JTAGIdCode, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::JTAGIdCodeOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

JTAGIdCode()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ManufacturerId get_manufacturer_id() const

Get JEDEC Manufacturer ID code, Heidelberg University has ‘0x057’.

PartNumber get_part_number() const

Get device identification number.

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Version get_version() const

Get hardware revision number, starting from 0.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(JTAGIdCode const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(JTAGIdCode const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_manufacturer_id(ManufacturerId value)

Set JEDEC Manufacturer ID code, Heidelberg University has ‘0x057’.

void set_part_number(PartNumber value)

Set device identification number.

void set_version(Version value)

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)

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

ManufacturerId m_manufacturer_id

PartNumber m_part_number

Version m_version

Friends

friend struct cereal::access

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

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::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::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)

class haldls::vx::MADCConfig : public haldls::vx::ContainerBase<MADCConfig>

#include <madc.h>

Configuration container for MADC and related circuitry.

Public Types

typedef EncodableBase<MADCConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<MADCConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<MADCConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<MADCConfig, Container>::Coordinate Coordinate

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()

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.

double calculate_sample_rate(double const &madc_base_frequency) const

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

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

input_selection_type get_active_mux_initially_selected_input() const

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

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

Accessors for the built-in calibration’s timing of the MADC.

hemisphere_type const &get_connect_iconv_neuron() const

synapse_target_type const &get_connect_iconv_synapse() const

bool get_connect_pads_to_madc() const

bool get_connect_preamp_to_madc() const

bool get_connect_preamp_to_pads() const

ConversionCyclesOffset get_conversion_cycles_offset() const

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

bool get_enable_calibration() const

Accessors for the built-in self-calibration.

bool get_enable_dummy_data() const

bool get_enable_iconv_amplifier() const

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

Accessors for the clock scaling configuration.

The clock is derived from a PLL madc_clk output.

hemisphere_type const &get_enable_pseudo_differential_reference() const

Accessors for the configuration of the pseudo-differential reference antenna.

bool get_enable_sar_reset_on_fall() const

Configuration of the MADC’s SAR reset timing.

SamplingWindowTiming get_iconv_sampling_window_end() const

SamplingWindowTiming get_iconv_sampling_window_start() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

MADCClockScaleValue get_madc_clock_scale_value() const

NumberOfSamples get_number_of_samples() const

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

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

Accessors for the preamplifier’s gain selection capacitor.

SamplingWindowTiming get_preamp_sampling_window_end() const

SamplingWindowTiming get_preamp_sampling_window_start() const

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

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

SARResetLength get_sar_reset_length() const

SARResetWait get_sar_reset_wait() const

bool get_signal_selection_connect_active_mux() const

bool get_signal_selection_connect_current_meter() const

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

bool get_signal_selection_connect_preamp() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(MADCConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(MADCConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_active_mux_initially_selected_input(input_selection_type const &value)

void set_active_mux_input_select_length(ActiveMuxInputSelectLength const &value)

void set_calibration_wait_value(CalibrationWaitValue const &value)

void set_connect_iconv_neuron(hemisphere_type const &value)

void set_connect_iconv_synapse(synapse_target_type const &value)

void set_connect_pads_to_madc(bool const value)

void set_connect_preamp_to_madc(bool const value)

void set_connect_preamp_to_pads(bool const value)

void set_conversion_cycles_offset(ConversionCyclesOffset const &value)

void set_enable_active_mux_amplifiers(bool const value)

void set_enable_calibration(bool const value)

void set_enable_dummy_data(bool const value)

void set_enable_iconv_amplifier(bool const value)

void set_enable_madc_clock_scaling(bool const value)

void set_enable_pseudo_differential_reference(hemisphere_type const &value)

void set_enable_sar_reset_on_fall(bool const value)

void set_iconv_sampling_window_end(SamplingWindowTiming const &value)

void set_iconv_sampling_window_start(SamplingWindowTiming const &value)

void set_madc_clock_scale_value(MADCClockScaleValue const &value)

void set_number_of_samples(NumberOfSamples const &value)

void set_powerup_wait_value(PowerupWaitValue const &value)

void set_preamp_gain_capacitor_size(PreampGainCapacitorSize const &value)

void set_preamp_sampling_window_end(SamplingWindowTiming const &value)

void set_preamp_sampling_window_start(SamplingWindowTiming const &value)

void set_sample_duration_adjust(SampleDurationAdjust const &value)

void set_sample_on_positive_edge(bool const value)

void set_sar_reset_length(SARResetLength const &value)

void set_sar_reset_wait(SARResetWait const &value)

void set_signal_selection_connect_active_mux(bool const value)

void set_signal_selection_connect_current_meter(bool const value)

void set_signal_selection_connect_debug(bool const value)

void set_signal_selection_connect_preamp(bool 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 size_t constexpr config_size_in_words = 10

Private Functions

template<class Archive>
friend void serialize(Archive &ar, MADCConfig &value, 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 struct cereal::access

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

class haldls::vx::MADCControl : public haldls::vx::ContainerBase<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 EncodableBase<MADCControl, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<MADCControl, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<MADCControl, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<MADCControl, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::MADCControlOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

MADCControl()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable_continuous_sampling() const

Let the MADC sample continuously.

bool get_enable_iconv_amplifier() const

Enable switched capacitor amplifier for current measurements.

bool get_enable_power_down_after_sampling() const

Let the MADC power down after it finished sampling.

bool get_enable_pre_amplifier() const

Enable switched capacitor pre-amplifier for voltage measurements.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

bool get_start_recording() const

Start a recording.

bool get_stop_recording() const

Stop a currently active recording.

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

bool get_wake_up() const

Wake up the MADC.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(MADCControl const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(MADCControl const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_continuous_sampling(bool const value)

void set_enable_iconv_amplifier(bool const value)

void set_enable_power_down_after_sampling(bool const value)

void set_enable_pre_amplifier(bool const value)

void set_start_recording(bool const value)

void set_stop_recording(bool const value)

void set_wake_up(bool const value)

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

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 struct cereal::access

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

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

bool operator==(MADCSampleFromChip const &other) const

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>
friend void serialize(Archive &ar, MADCSampleFromChip &value, std::uint32_t const version)

Friends

friend struct cereal::access

friend struct detail::MADCSampleFromChipChecker

friend std::ostream &operator<<(std::ostream &os, MADCSampleFromChip const &sample)

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)

template<typename Coordinates>
struct haldls::vx::NeuronBackendConfig : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<NeuronBackendConfig<Coordinates>>

#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 halco::hicann_dls::vx::NeuronBackendAddressOut AddressOut

typedef EncodableBase<NeuronBackendConfig<Coordinates>, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<NeuronBackendConfig<Coordinates>, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<NeuronBackendConfig<Coordinates>, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<NeuronBackendConfig<Coordinates>, Container>::Coordinate Coordinate

typedef Coordinates::NeuronBackendConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

NeuronBackendConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

AddressOut get_address_out() const

Lower 8 bit of the output spike address.

The upper 5 bit are determined by the position of the neuron.

bool get_connect_fire_bottom() const

Connect fire signal to the opposite hemisphere.

bool get_connect_fire_from_right() const

Connect fire signal from the right adjacent neuron.

This setting is currently broken, cf. issue 3858.

bool get_connect_fire_to_right() const

Connect fire signal to the right adjacent neuron.

Implemented as a uni-directional driver, overwrites any state of the neuron to the right.

bool get_enable_adaptation_pulse() const

Enable output of a pulse to the adaptation circuitry, allowing for spike-triggered adaptation.

bool get_enable_bayesian_0() const

Switch between different logic operations in the bayesian extension.

There are four different operating modes, encoded by enable bits 0 and 1: en_0 en_1 mode 0 0 neuron_refrac (local refractory state only) 1 0 neuron_refrac AND neuron_fire_connect 0 1 NOT neuron_refrac XOR neuron_fire_connect 1 1 neuron_refrac MULLER C-ELEMENT neuron_fire_connect

bool get_enable_bayesian_1() const

Switch between different logic operations in the bayesian extension.

There are four different operating modes, encoded by enable bits 0 and 1: en_0 en_1 mode 0 0 neuron_refrac (local refractory state only) 1 0 neuron_refrac AND neuron_fire_connect 0 1 NOT neuron_refrac XOR neuron_fire_connect 1 1 neuron_refrac MULLER C-ELEMENT neuron_fire_connect

bool get_enable_bayesian_extension() const

Use the bayesian logic module for generating post pulses.

If disabled, the neuron_fire_connect signal is used to trigger post pulses.

bool get_enable_neuron_master() const

Write the local fire output to the common neuron_fire_connect line.

If the threshold comparator creates a fire signal, all connected neurons receive a fire input.

In order for the fire signal to trigger a post pulse for the synapses, either this setting can be used, or the bayesian extensions need to be enabled.

bool get_enable_neuron_slave() const

Receive fire signals from a connected master neuron via neuron_fire_connect, i.e.

receive refractory state from there.

bool get_enable_spike_out() const

Enable spike packet output.

Required e.g. for recurrent networks, but not required for the spike counter and post pulses.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

bool get_post_overwrite() const

Use an external debug post pulse exclusively, disable the internal pulse generation.

RefractoryTime get_refractory_time() const

Refractory counter setting.

ResetHoldoff get_reset_holdoff() const

Bits 4, 3, 2, 1 (but not 0) of the refractory counter to release the reset at.

For a full explanation, refer to the ResetHoldoff type.

InputClock get_select_input_clock() const

Switch between the two refractory clocks provided by the common neuron backend.

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(NeuronBackendConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(NeuronBackendConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

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 size_t constexpr config_size_in_words = 4

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

Private Functions

template<class Archive, typename T>
friend void serialize(Archive &ar, NeuronBackendConfig<T> &value, 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_bayesian

bool m_en_1_bayesian

bool m_en_adapt_pulse

bool m_en_bayesian_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 struct cereal::access

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

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)

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::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::NeuronBackendSRAMTimingConfig : public haldls::vx::detail::SRAMTimingConfig, public haldls::vx::ContainerBase<NeuronBackendSRAMTimingConfig>

#include <neuron.h>

Public Types

typedef EncodableBase<NeuronBackendSRAMTimingConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<NeuronBackendSRAMTimingConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<NeuronBackendSRAMTimingConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<NeuronBackendSRAMTimingConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::NeuronBackendSRAMTimingConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

AddressSetupTime get_address_setup_time() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ReadDelay get_read_delay() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

WriteWidth get_write_width() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(NeuronBackendSRAMTimingConfig const &other) const

bool operator!=(SRAMTimingConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(NeuronBackendSRAMTimingConfig const &other) const

bool operator==(SRAMTimingConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_address_setup_time(AddressSetupTime value)

void set_read_delay(ReadDelay value)

void set_write_width(WriteWidth value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 2

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

Private Functions

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

Friends

friend struct cereal::access

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

class haldls::vx::NeuronReset : public haldls::vx::ContainerBase<NeuronReset>

#include <neuron.h>

Container to trigger reset of a single neuron.

Public Types

typedef EncodableBase<NeuronReset, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<NeuronReset, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<NeuronReset, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<NeuronReset, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::NeuronResetOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

NeuronReset()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(NeuronReset const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(NeuronReset const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Friends

friend struct cereal::access

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

class haldls::vx::NeuronSRAMTimingConfig : public haldls::vx::detail::SRAMTimingConfig, public haldls::vx::ContainerBase<NeuronSRAMTimingConfig>

#include <neuron.h>

Public Types

typedef EncodableBase<NeuronSRAMTimingConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<NeuronSRAMTimingConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<NeuronSRAMTimingConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<NeuronSRAMTimingConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::NeuronSRAMTimingConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

AddressSetupTime get_address_setup_time() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ReadDelay get_read_delay() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

WriteWidth get_write_width() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(NeuronSRAMTimingConfig const &other) const

bool operator!=(SRAMTimingConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(NeuronSRAMTimingConfig const &other) const

bool operator==(SRAMTimingConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_address_setup_time(AddressSetupTime value)

void set_read_delay(ReadDelay value)

void set_write_width(WriteWidth value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 2

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

Private Functions

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

Friends

friend struct cereal::access

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

class haldls::vx::NullPayloadReadable : public haldls::vx::ContainerBase<NullPayloadReadable>

#include <null_payload_readable.h>

Public Types

typedef EncodableBase<NullPayloadReadable, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<NullPayloadReadable, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<NullPayloadReadable, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<NullPayloadReadable, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::NullPayloadReadableOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

NullPayloadReadable() = default

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(NullPayloadReadable const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(NullPayloadReadable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

Public Static Functions

static std::array<halco::hicann_dls::vx::NullPayloadReadableOnFPGA, read_config_size_in_words> read_addresses(coordinate_type const &coord)

static std::array<halco::hicann_dls::vx::NullPayloadReadableOnFPGA, write_config_size_in_words> write_addresses(coordinate_type const &coord)

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Friends

friend struct cereal::access

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

class haldls::vx::PADIEvent : public haldls::vx::ContainerBase<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 EncodableBase<PADIEvent, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PADIEvent, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PADIEvent, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PADIEvent, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::PADIEventOnDLS coordinate_type

using EventAddress = halco::hicann_dls::vx::SynapseLabel

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

typedef std::true_type is_leaf_node

using RowSelectAddress = halco::hicann_dls::vx::PADIRowSelectAddress

Public Functions

PADIEvent()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

EventAddress get_event_address() const

Set event address, which is eventually forwarded to synapses.

fire_bus_type const &get_fire_bus() const

Set mask determining the padi bus(es) to fire the event on.

HagenActivation get_hagen_activation() const

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

Set Hagen-mode address, which is eventually forwarded to synapses.

This setting accesses the highest bit of the EventAddress.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

RowSelectAddress get_row_select_address() const

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.

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PADIEvent const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PADIEvent const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_event_address(EventAddress const value)

void set_fire_bus(fire_bus_type const &value)

void set_hagen_activation(HagenActivation const value)

void set_hagen_address(HagenAddress const value)

void set_row_select_address(RowSelectAddress const value)

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Private Members

EventAddress m_event_address

fire_bus_type m_fire_bus

RowSelectAddress m_row_select_address

Friends

friend struct cereal::access

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

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)

class haldls::vx::PadMultiplexerConfig : public haldls::vx::ContainerBase<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 EncodableBase<PadMultiplexerConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PadMultiplexerConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PadMultiplexerConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

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 EncodableBase<PadMultiplexerConfig, Container>::Coordinate Coordinate

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()

Default constructor with all inputs disabled.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

buffer_type const &get_buffer_to_pad() const

Enable connection of voltage readout buffers to pad.

The connections to the voltage readout muxes/buffers are handled in the ReadoutSourceSelection container.

bool get_cadc_debug_acausal_to_synapse_intermediate_mux() const

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

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.

capmem_quadrant_type const &get_cadc_v_ramp_mux() const

Select CADC v_ramp outputs per quadrant.

bool get_cadc_v_ramp_mux_to_pad() const

Enable connection of cadc_v_ramp_mux to pad.

capmem_quadrant_type const &get_capmem_i_out_mux() const

Select CapMem i_out outputs per quadrant.

bool get_capmem_i_out_mux_to_capmem_intermediate_mux() const

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

Enable connection of CapMem intermediate mux to pad.

The intermediate mux selects between different capmem-specific sources.

capmem_quadrant_type const &get_capmem_v_out_mux() const

Select CapMem v_out outputs per quadrant.

bool get_capmem_v_out_mux_to_capmem_intermediate_mux() const

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.

capmem_quadrant_type const &get_capmem_v_ref_mux() const

Select CapMem v_ref outputs per quadrant.

bool get_capmem_v_ref_mux_to_capmem_intermediate_mux() const

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

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.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

hemisphere_type const &get_neuron_i_stim_mux() const

Select neuron unbuffered membrane access i_stim per hemisphere.

bool get_neuron_i_stim_mux_to_pad() const

Enable connection of neuron unbuffered membrane access neuron_i_stim_mux to pad.

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

bool get_synapse_intermediate_mux_to_pad() const

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

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

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.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PadMultiplexerConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PadMultiplexerConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_buffer_to_pad(buffer_type const &value)

void set_cadc_debug_acausal_to_synapse_intermediate_mux(bool value)

void set_cadc_debug_causal_to_synapse_intermediate_mux(bool value)

void set_cadc_v_ramp_mux(capmem_quadrant_type const &value)

void set_cadc_v_ramp_mux_to_pad(bool value)

void set_capmem_i_out_mux(capmem_quadrant_type const &value)

void set_capmem_i_out_mux_to_capmem_intermediate_mux(bool value)

void set_capmem_intermediate_mux_to_pad(bool value)

void set_capmem_v_out_mux(capmem_quadrant_type const &value)

void set_capmem_v_out_mux_to_capmem_intermediate_mux(bool value)

void set_capmem_v_ref_mux(capmem_quadrant_type const &value)

void set_capmem_v_ref_mux_to_capmem_intermediate_mux(bool value)

void set_debug_to_pad(bool value)

void set_neuron_i_stim_mux(hemisphere_type const &value)

void set_neuron_i_stim_mux_to_pad(bool value)

void set_synapse_intermediate_mux_to_pad(bool value)

void set_synin_debug_excitatory_to_synapse_intermediate_mux(bool value)

void set_synin_debug_inhibitory_to_synapse_intermediate_mux(bool value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 2

Private Functions

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

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 struct cereal::access

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

class haldls::vx::PerfTest : public haldls::vx::ContainerBase<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 EncodableBase<PerfTest, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PerfTest, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PerfTest, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PerfTest, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::PerfTestOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit PerfTest(bool value = false)

Construct perf test with enable value.

Parameters

value – Enable value of test execution

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable() const

Get enable value of test execution.

Returns

value Boolean value

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PerfTest const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PerfTest const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable(bool value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

bool m_enable

Friends

friend struct cereal::access

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

class haldls::vx::PerfTestStatus : public haldls::vx::ContainerBase<PerfTestStatus>

#include <perftest.h>

Container for perf test result readout.

Public Types

typedef EncodableBase<PerfTestStatus, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PerfTestStatus, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PerfTestStatus, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PerfTestStatus, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::PerfTestStatusOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PerfTestStatus()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

ErrorWord get_error_word() const

Get index of first non-consecutive word.

Returns

ErrorWord index value

InOrder get_in_order() const

Get number of words received in order.

Returns

InOrder counter value

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

Received get_received() const

Get number of successfully received words.

Returns

Received counter value

Sent get_sent() const

Get number of successfully sent words.

Returns

Sent counter value

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PerfTestStatus const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PerfTestStatus const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_error_word(ErrorWord value)

Set index of first non-consecutive word.

Parameters

value – ErrorWord index value

void set_in_order(InOrder value)

Set number of words received in order.

Parameters

value – InOrder counter value

void set_received(Received value)

Set number of successfully received words.

Parameters

value – Received counter value

void set_sent(Sent value)

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)

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 4

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

ErrorWord m_error_word

InOrder m_in_order

Received m_received

Sent m_sent

Friends

friend struct cereal::access

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

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::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::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::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::PhyConfigChip : public haldls::vx::detail::PhyConfigBase, public haldls::vx::ContainerBase<PhyConfigChip>

#include <phy.h>

Container for individual configuration of chip-side PHYs.

Public Types

typedef EncodableBase<PhyConfigChip, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PhyConfigChip, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PhyConfigChip, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PhyConfigChip, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::PhyConfigChipOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PhyConfigChip()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

DebugOutputs get_debug_outputs() const

bool get_enable_auto_init() const

bool get_enable_ber_loopback() const

bool get_enable_bit_slip() const

bool get_enable_clock_pre_alignment() const

bool get_enable_delay_cell_measurement() const

bool get_enable_des_recal() const

bool get_enable_force_lvds_power_up() const

bool get_enable_force_start() const

bool get_enable_initialization_master_mode() const

bool get_enable_loopback_en() const

bool get_enable_manual_training_mode() const

bool get_enable_manual_tx_data_valid_for_init() const

bool get_enable_transmission_without_idle_pattern() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ManualDelay get_manual_delay() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

VBias get_vbias() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PhyConfigBase const &other) const

bool operator!=(PhyConfigChip const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PhyConfigBase const &other) const

bool operator==(PhyConfigChip const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_debug_outputs(DebugOutputs value)

void set_enable_auto_init(bool value)

void set_enable_ber_loopback(bool value)

void set_enable_bit_slip(bool value)

void set_enable_clock_pre_alignment(bool value)

void set_enable_delay_cell_measurement(bool value)

void set_enable_des_recal(bool value)

void set_enable_force_lvds_power_up(bool value)

void set_enable_force_start(bool value)

void set_enable_initialization_master_mode(bool value)

void set_enable_loopback_en(bool value)

void set_enable_manual_training_mode(bool value)

void set_enable_manual_tx_data_valid_for_init(bool value)

void set_enable_transmission_without_idle_pattern(bool value)

void set_manual_delay(ManualDelay value)

void set_vbias(VBias value)

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Protected Functions

uint32_t pack() const

void unpack(uint32_t value)

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

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>
friend void serialize(Archive &ar, PhyConfigChip &value, std::uint32_t const version)

Friends

friend struct cereal::access

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

class haldls::vx::PhyConfigFPGA : public haldls::vx::detail::PhyConfigBase, public haldls::vx::ContainerBase<PhyConfigFPGA>

#include <phy.h>

Container for individual configuration of FPGA-side PHYs.

Public Types

typedef EncodableBase<PhyConfigFPGA, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PhyConfigFPGA, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PhyConfigFPGA, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PhyConfigFPGA, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::PhyConfigFPGAOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PhyConfigFPGA()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

DebugOutputs get_debug_outputs() const

bool get_enable_auto_init() const

bool get_enable_ber_loopback() const

bool get_enable_bit_slip() const

bool get_enable_clock_pre_alignment() const

bool get_enable_delay_cell_measurement() const

bool get_enable_des_recal() const

bool get_enable_force_lvds_power_up() const

bool get_enable_force_start() const

bool get_enable_initialization_master_mode() const

bool get_enable_loopback_en() const

bool get_enable_manual_training_mode() const

bool get_enable_manual_tx_data_valid_for_init() const

bool get_enable_transmission_without_idle_pattern() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ManualDelay get_manual_delay() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

VBias get_vbias() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PhyConfigBase const &other) const

bool operator!=(PhyConfigFPGA const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PhyConfigBase const &other) const

bool operator==(PhyConfigFPGA const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_debug_outputs(DebugOutputs value)

void set_enable_auto_init(bool value)

void set_enable_ber_loopback(bool value)

void set_enable_bit_slip(bool value)

void set_enable_clock_pre_alignment(bool value)

void set_enable_delay_cell_measurement(bool value)

void set_enable_des_recal(bool value)

void set_enable_force_lvds_power_up(bool value)

void set_enable_force_start(bool value)

void set_enable_initialization_master_mode(bool value)

void set_enable_loopback_en(bool value)

void set_enable_manual_training_mode(bool value)

void set_enable_manual_tx_data_valid_for_init(bool value)

void set_enable_transmission_without_idle_pattern(bool value)

void set_manual_delay(ManualDelay value)

void set_vbias(VBias value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Protected Functions

uint32_t pack() const

void unpack(uint32_t value)

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

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>
friend void serialize(Archive &ar, PhyConfigFPGA &value, std::uint32_t const version)

Friends

friend struct cereal::access

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

class haldls::vx::PhyStatus : public haldls::vx::ContainerBase<PhyStatus>

#include <phy.h>

Public Types

typedef EncodableBase<PhyStatus, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PhyStatus, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PhyStatus, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PhyStatus, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::PhyStatusOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PhyStatus()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

CRCErrorCount get_crc_error_count() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

OnlineTime get_online_time() const

RxCount get_rx_count() const

RxDroppedCount get_rx_dropped_count() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

TxCount get_tx_count() const

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PhyStatus const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PhyStatus const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_crc_error_count(CRCErrorCount value)

void set_online_time(OnlineTime value)

void set_rx_count(RxCount value)

void set_rx_dropped_count(RxDroppedCount value)

void set_tx_count(TxCount value)

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 5

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

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 struct cereal::access

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

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)

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::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::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)

class haldls::vx::PLLSelfTest : public haldls::vx::ContainerBase<PLLSelfTest>

#include <pll.h>

Container for configuration and triggering of the PLL internal self test.

Public Types

typedef EncodableBase<PLLSelfTest, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PLLSelfTest, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PLLSelfTest, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PLLSelfTest, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::PLLSelfTestOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PLLSelfTest()

Default construct PLL self test.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

CheckRange get_check_range() const

CheckValue get_check_value() const

bool get_clock_enable() const

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

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

PreScalerP get_pre_scaler_p() const

halco::hicann_dls::vx::PLLClockOutputOnDLS get_select_source() const

Get selected source output to test.

Returns

Selected PLLClockOutputOnDLS

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PLLSelfTest const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PLLSelfTest const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_check_range(CheckRange value)

void set_check_value(CheckValue value)

void set_clock_enable(bool value)

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)

void set_select_source(halco::hicann_dls::vx::PLLClockOutputOnDLS value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

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 struct cereal::access

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

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_fast32_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)

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)

class haldls::vx::PLLSelfTestStatus : public haldls::vx::ContainerBase<PLLSelfTestStatus>

#include <pll.h>

Container of PLL self-test status data.

Public Types

typedef EncodableBase<PLLSelfTestStatus, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PLLSelfTestStatus, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PLLSelfTestStatus, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PLLSelfTestStatus, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::PLLSelfTestStatusOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PLLSelfTestStatus()

Default construct a PLL self-test status.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

CounterValue get_counter_value() const

Get self-test clock period counter value.

Returns

Counter value

bool get_finished() const

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

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

bool get_success() const

Get if self-test execution was successful.

Returns

Boolean value

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PLLSelfTestStatus const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PLLSelfTestStatus const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

CounterValue m_counter_value

bool m_finished

bool m_success

Friends

friend struct cereal::access

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

struct haldls::vx::PLLSelfTestStatus::CounterValue : public halco::common::detail::RantWrapper<CounterValue, uint_fast32_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)

class haldls::vx::PollingOmnibusBlock : public haldls::vx::BlockUntilBase<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 Encodable::BackendCocoListVariant BackendCocoListVariant

typedef Encodable::BackendContainerListVariant BackendContainerListVariant

typedef Encodable::BackendCoordinateListVariant BackendCoordinateListVariant

typedef Encodable::Coordinate Coordinate

typedef halco::hicann_dls::vx::PollingOmnibusBlockOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PollingOmnibusBlock(bool enable_expects_equality = true)

Resolve block if value is true (*address & mask == target) or if value is false (*address & mask != target).

virtual std::unique_ptr<BlockUntil> clone_block_until() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable_expects_equality() const

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

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(BlockUntil const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PollingOmnibusBlock const &other) const

virtual bool operator==(BlockUntil const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PollingOmnibusBlock const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_expects_equality(bool value)

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

Public Static Functions

static std::array<halco::hicann_dls::vx::PollingOmnibusBlockOnFPGA, write_config_size_in_words> write_addresses(coordinate_type const &coord)

Public Static Attributes

static size_t constexpr write_config_size_in_words = 1

Private Functions

template<class Archive>
friend void serialize(Archive &ar, PollingOmnibusBlock &value, std::uint32_t)

Private Members

bool m_enable_expects_equality

Friends

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

class haldls::vx::PollingOmnibusBlockConfig : public haldls::vx::ContainerBase<PollingOmnibusBlockConfig>

#include <block.h>

Public Types

typedef halco::hicann_dls::vx::OmnibusAddress Address

typedef EncodableBase<PollingOmnibusBlockConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PollingOmnibusBlockConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PollingOmnibusBlockConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PollingOmnibusBlockConfig, Container>::Coordinate Coordinate

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()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

Address get_address() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

Value get_mask() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

Value get_target() const

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PollingOmnibusBlockConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PollingOmnibusBlockConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_address(Address value)

void set_mask(Value value)

void set_target(Value value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 3

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

Private Functions

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

Private Members

Address m_address

Value m_mask

Value m_target

Friends

friend struct cereal::access

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

class haldls::vx::PPUControlRegister : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<PPUControlRegister>

#include <ppu.h>

Public Types

typedef EncodableBase<PPUControlRegister, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PPUControlRegister, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PPUControlRegister, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PPUControlRegister, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::PPUControlRegisterOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PPUControlRegister()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_cache_controller_enable() const

bool get_force_clock_off() const

bool get_force_clock_on() const

bool get_inhibit_reset() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PPUControlRegister const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PPUControlRegister const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_cache_controller_enable(bool const value)

void set_force_clock_off(bool const value)

void set_force_clock_on(bool const value)

void set_inhibit_reset(bool 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 size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

bool m_cache_controller_enable

bool m_force_clock_off

bool m_force_clock_on

bool m_inhibit_reset

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream&, PPUControlRegister const&)

class haldls::vx::PPUMemory : public haldls::vx::ContainerBase<PPUMemory>

#include <ppu.h>

Public Types

typedef EncodableBase<PPUMemory, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PPUMemory, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PPUMemory, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PPUMemory, Container>::Coordinate Coordinate

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())

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

PPUMemoryBlock get_block(halco::hicann_dls::vx::PPUMemoryBlockOnPPU const &block_coord) const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

PPUMemoryWord::Value get_word(halco::hicann_dls::vx::PPUMemoryWordOnPPU const &pos) const

words_type get_words() const

void load_from_file(std::string const &filename)

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

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PPUMemory const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PPUMemory const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_block(halco::hicann_dls::vx::PPUMemoryBlockOnPPU const &block_coord, PPUMemoryBlock const &block)

void set_word(halco::hicann_dls::vx::PPUMemoryWordOnPPU const &pos, PPUMemoryWord::Value const &word)

void set_words(words_type const &words)

Private Functions

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

Private Members

words_type m_words

Friends

friend std::ostream &operator<<(std::ostream &os, PPUMemory const &pm)

class haldls::vx::PPUMemoryBlock : public haldls::vx::ContainerBase<PPUMemoryBlock>

#include <ppu.h>

Public Types

typedef EncodableBase<PPUMemoryBlock, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PPUMemoryBlock, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PPUMemoryBlock, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PPUMemoryBlock, Container>::Coordinate Coordinate

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))

PPUMemoryWord &at(size_t index)

PPUMemoryWord const &at(size_t index) const

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

PPUMemoryBlock get_subblock(size_t begin, size_type length) const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

words_type const &get_words() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PPUMemoryBlock const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PPUMemoryBlock const &other) const

PPUMemoryWord &operator[](size_t index)

PPUMemoryWord const &operator[](size_t index) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_subblock(size_t begin, PPUMemoryBlock const &subblock)

void set_words(words_type const &words)

size_type size() const

std::string to_string() const

Print words as string discarding non-printable characters.

Returns

Printable characters as string in order according to PPU endianess

Private Functions

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

Private Members

words_type m_words

Friends

friend std::ostream &operator<<(std::ostream &os, PPUMemoryBlock const &pmb)

class haldls::vx::PPUMemoryWord : public haldls::vx::ContainerBase<PPUMemoryWord>

#include <ppu.h>

Public Types

typedef EncodableBase<PPUMemoryWord, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PPUMemoryWord, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PPUMemoryWord, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PPUMemoryWord, Container>::Coordinate Coordinate

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())

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PPUMemoryWord const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PPUMemoryWord const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value const &value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

Value m_value

Friends

friend std::ostream &operator<<(std::ostream &os, PPUMemoryWord const &pmw)

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)

class haldls::vx::PPUStatusRegister : public haldls::vx::ContainerBase<PPUStatusRegister>

#include <ppu.h>

Public Types

typedef EncodableBase<PPUStatusRegister, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PPUStatusRegister, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PPUStatusRegister, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PPUStatusRegister, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::PPUStatusRegisterOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PPUStatusRegister()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

bool get_sleep() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PPUStatusRegister const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PPUStatusRegister const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

bool m_sleep

Friends

friend struct cereal::access

friend std::ostream &operator<<(std::ostream&, PPUStatusRegister const&)

class haldls::vx::ReadoutSourceSelection : public haldls::vx::ContainerBase<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 EncodableBase<ReadoutSourceSelection, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ReadoutSourceSelection, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ReadoutSourceSelection, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<ReadoutSourceSelection, Container>::Coordinate Coordinate

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()

Default constructor with both buffers and muxes disabled.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

SourceMultiplexer get_buffer(halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection const &buffer) const

source_multiplexer_type const &get_enable_buffer_to_pad() const

Enable buffer after the muxes, connecting to the pads (c.f.

PadMultiplexerConfig container). The active mux, which can be connected to the MADC, is reached even without enabling this buffer.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(ReadoutSourceSelection const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(ReadoutSourceSelection const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_buffer(halco::hicann_dls::vx::SourceMultiplexerOnReadoutSourceSelection const &buffer, SourceMultiplexer const &value)

void set_enable_buffer_to_pad(source_multiplexer_type const &value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 2

Private Functions

template<class Archive>
friend void serialize(Archive &ar, ReadoutSourceSelection &value, 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 struct cereal::access

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

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()

Default constructor with all inputs disabled.

bool get_cadc_debug_acausal() const

Connect CADC acausal debug line to mux.

bool get_cadc_debug_causal() const

Connect CADC causal debug line to mux.

bool get_current_dac() const

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

Connect debug_minus line to mux.

bool get_debug_plus() const

Connect debug_plus line to mux.

hemisphere_type const &get_neuron_even() const

Connect analog neuron readout for even neurons (0, 2, …, 254) to mux.

hemisphere_type const &get_neuron_odd() const

Connect analog neuron readout for odd neurons (1, 3, …, 255) to mux.

hemisphere_type const &get_synapse_driver_debug() const

Connect synapse driver debug voltage readout to mux.

bool get_synin_debug_excitatory() const

Connect synaptic input excitatory debug line to mux.

bool get_synin_debug_inhibitory() const

Connect synaptic input inhibitory debug line to mux.

bool operator!=(SourceMultiplexer const &other) const

bool operator==(SourceMultiplexer const &other) const

void set_cadc_debug_acausal(bool value)

void set_cadc_debug_causal(bool value)

void set_current_dac(bool value)

void set_debug_minus(bool value)

void set_debug_plus(bool value)

void set_neuron_even(hemisphere_type const &value)

void set_neuron_odd(hemisphere_type const &value)

void set_synapse_driver_debug(hemisphere_type const &value)

void set_synin_debug_excitatory(bool value)

void set_synin_debug_inhibitory(bool value)

Private Functions

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

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)

friend class ReadoutSourceSelection

class haldls::vx::ResetChip : public haldls::vx::ContainerBase<ResetChip>

#include <reset.h>

Container for setting the reset pin of the chip.

Public Types

typedef EncodableBase<ResetChip, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ResetChip, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ResetChip, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<ResetChip, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::ResetChipOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit ResetChip(bool value = false)

Construct chip reset with boolean value.

On true, the chip reset is enabled.

Parameters

value – Boolean value

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(ResetChip const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(ResetChip const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set(bool value)

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)

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Private Members

bool m_value

Friends

friend struct cereal::access

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

class haldls::vx::ResetJTAGTap : public haldls::vx::ContainerBase<ResetJTAGTap>

#include <jtag.h>

Container for resetting JTAG state-machine.

Public Types

typedef EncodableBase<ResetJTAGTap, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ResetJTAGTap, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ResetJTAGTap, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<ResetJTAGTap, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::ResetJTAGTapOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

ResetJTAGTap()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(ResetJTAGTap const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(ResetJTAGTap const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Friends

friend struct cereal::access

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

class haldls::vx::ShiftRegister : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<ShiftRegister>

#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 class AnalogReadoutMux1Input

Values:

enumerator off

enumerator readout_chain_0

enumerator readout_chain_1

enumerator mux_rfu_0

enum class AnalogReadoutMux2Input

Values:

enumerator off

enumerator v_reset

enumerator vdd_res_meas

enumerator mux_dac_25

enum class AnalogReadoutMux3Input

Values:

enumerator off

enumerator i_ref

enumerator mux_rfu_1

enumerator mux_rfu_2

typedef EncodableBase<ShiftRegister, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ShiftRegister, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ShiftRegister, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<ShiftRegister, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::ShiftRegisterOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

ShiftRegister()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable_adc_power_down() const

Get enable value of the ADC power-down pin.

The behavior can be controlled in the ADC container.

See also

ADC

Returns

Boolean value

bool get_enable_adc_reset() const

Get enable value of the ADC reset pin.

See also

ADC

Returns

Boolean value

bool get_enable_dac_to_readout_0() const

Get enable value for the DAC-powered Readout0 debug line.

Returns

Boolean value

bool get_enable_dac_to_readout_1() const

Get enable value for the DAC-powered Readout1 debug line.

Returns

Boolean value

bool get_enable_i_ref_board() const

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

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

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

Get enable value for the specified VDD line.

Parameters

coord – Coordinate of VDD line to get enable value for

Returns

Boolean value

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

AnalogReadoutMux1Input get_select_analog_readout_mux_1_input() const

Get the source selection for the first analog readout MUX.

Returns

Selected input

AnalogReadoutMux2Input get_select_analog_readout_mux_2_input() const

Get the source selection for the second analog readout MUX.

Returns

Selected input

AnalogReadoutMux3Input get_select_analog_readout_mux_3_input() const

Get the source selection for the third analog readout MUX.

Returns

Selected input

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(ShiftRegister const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(ShiftRegister const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_adc_power_down(bool value)

Get enable value of the ADC power-down pin.

The behavior can be controlled in the ADC container.

See also

ADC

Parameters

value – Boolean value

void set_enable_adc_reset(bool value)

Set enable value of the ADC reset pin.

See also

ADC

Parameters

value – Boolean value

void set_enable_dac_to_readout_0(bool value)

Set enable value for the DAC-powered Readout0 debug line.

Parameters

value – Boolean value

void set_enable_dac_to_readout_1(bool value)

Set enable value for the DAC-powered Readout0 debug line.

Parameters

value – Boolean value

void set_enable_i_ref_board(bool value)

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)

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)

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)

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)

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)

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)

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)

static std::array<halco::hicann_dls::vx::SPIShiftRegisterOnBoard, write_config_size_in_words> write_addresses(coordinate_type const &coord)

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

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 struct cereal::access

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

class haldls::vx::SpikeCounterRead : public haldls::vx::ContainerBase<SpikeCounterRead>

#include <neuron.h>

Container to read the spike counter of a single neuron.

Public Types

typedef EncodableBase<SpikeCounterRead, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SpikeCounterRead, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SpikeCounterRead, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SpikeCounterRead, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SpikeCounterReadOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

SpikeCounterRead() = default

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

Count get_count() const

Get count, i.e.

number of spikes since last reset.

Returns

Count

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

bool get_overflow() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SpikeCounterRead const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SpikeCounterRead const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_count(Count const cnt)

void set_overflow(bool const ovrflw)

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

Count m_count

bool m_overflow = {false}

Friends

friend struct cereal::access

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

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)

class haldls::vx::SpikeCounterReset : public haldls::vx::ContainerBase<SpikeCounterReset>

#include <neuron.h>

Container to reset the spike counter of a single neuron.

Public Types

typedef EncodableBase<SpikeCounterReset, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SpikeCounterReset, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SpikeCounterReset, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SpikeCounterReset, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SpikeCounterResetOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

SpikeCounterReset()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SpikeCounterReset const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SpikeCounterReset const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Friends

friend struct cereal::access

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

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(halco::hicann_dls::vx::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

bool operator==(SpikeFromChip const &other) const

Public Members

ChipTime chip_time

Chip time.

FPGATime fpga_time

FPGA time.

halco::hicann_dls::vx::SpikeLabel label

Spike label.

Private Functions

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

Friends

friend struct cereal::access

friend struct detail::SpikeFromChipChecker

friend std::ostream &operator<<(std::ostream &os, SpikeFromChip const &spike)

class haldls::vx::SpikeIOConfig : public haldls::vx::ContainerBase<SpikeIOConfig>

#include <fpga.h>

Configuration registers for on-FPGA SpikeIO.

Public Types

typedef EncodableBase<SpikeIOConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SpikeIOConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SpikeIOConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SpikeIOConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SpikeIOConfigOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit SpikeIOConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

DataRateScaler const &get_data_rate_scaler() const

Get data rate scaling value for serial output.

bool get_enable_internal_loopback() const

Get enable of internal serial loopback.

bool get_enable_rx() const

Get global enable of serial input.

bool get_enable_tx() const

Get global enable of serial output.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SpikeIOConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SpikeIOConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_data_rate_scaler(DataRateScaler value)

Set data rate scaling value for serial output.

void set_enable_internal_loopback(bool value)

Set enable of internal serial loopback.

void set_enable_rx(bool value)

Set global enable of serial input.

void set_enable_tx(bool value)

Set global enable of serial output.

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

DataRateScaler m_data_rate_scaler

bool m_enable_internal_loopback

bool m_enable_rx

bool m_enable_tx

Friends

friend struct cereal::access

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

struct haldls::vx::SpikeIOConfig::DataRateScaler : public halco::common::detail::RantWrapper<DataRateScaler, uint_fast16_t, (1 << 16) - 1, 1>

#include <fpga.h>

Public Functions

inline explicit constexpr DataRateScaler(uintmax_t const val = 1)

class haldls::vx::SpikeIOInputRoute : public haldls::vx::ContainerBase<SpikeIOInputRoute>

#include <fpga.h>

On-chip target spike address for events received via the on-fpga SpikeIO module.

Public Types

typedef EncodableBase<SpikeIOInputRoute, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SpikeIOInputRoute, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SpikeIOInputRoute, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SpikeIOInputRoute, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SpikeIOInputRouteOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit SpikeIOInputRoute()

explicit SpikeIOInputRoute(halco::hicann_dls::vx::SpikeLabel label)

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

halco::hicann_dls::vx::SpikeLabel const &get_target() const

Get target spike label.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SpikeIOInputRoute const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SpikeIOInputRoute const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_target(halco::hicann_dls::vx::SpikeLabel value)

Set target spike label.

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

static constexpr halco::hicann_dls::vx::SpikeLabel SILENT{halco::hicann_dls::vx::SpikeLabel::max}

Discard events with this target.

Private Functions

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

Private Members

halco::hicann_dls::vx::SpikeLabel m_target

Friends

friend struct cereal::access

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

class haldls::vx::SpikeIOOutputRoute : public haldls::vx::ContainerBase<SpikeIOOutputRoute>

#include <fpga.h>

Serial address target for events sent via the on-fpga SpikeIO module.

Public Types

typedef EncodableBase<SpikeIOOutputRoute, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SpikeIOOutputRoute, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SpikeIOOutputRoute, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SpikeIOOutputRoute, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SpikeIOOutputRouteOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit SpikeIOOutputRoute()

explicit SpikeIOOutputRoute(halco::hicann_dls::vx::SpikeIOAddress serial_address)

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

halco::hicann_dls::vx::SpikeIOAddress const &get_target() const

Get target spike label.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SpikeIOOutputRoute const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SpikeIOOutputRoute const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_target(halco::hicann_dls::vx::SpikeIOAddress value)

Set target spike label.

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

static constexpr halco::hicann_dls::vx::SpikeIOAddress SILENT{halco::hicann_dls::vx::SpikeIOAddress::max}

Discard events with this target.

Private Functions

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

Private Members

halco::hicann_dls::vx::SpikeIOAddress m_target

Friends

friend struct cereal::access

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

class haldls::vx::SpikePack1ToChip : public haldls::vx::ContainerBase<SpikePack1ToChip>

#include <event.h>

Public Types

typedef EncodableBase<SpikePack1ToChip, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SpikePack1ToChip, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SpikePack1ToChip, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SpikePack1ToChip, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SpikePack1ToChipOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef std::array<halco::hicann_dls::vx::SpikeLabel, 1> labels_type

Public Functions

SpikePack1ToChip()

Default constructor.

explicit SpikePack1ToChip(labels_type const &labels)

• Construct spike pack with labels. *

Parameters

labels – Array of SpikeLabel values to use

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

labels_type get_labels() const

• Get spike labels. *

Returns

Array of SpikeLabel

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SpikePack1ToChip const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SpikePack1ToChip const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_labels(labels_type const &value)

• 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)

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

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>
friend void serialize(Archive &ar, SpikePack1ToChip &value, std::uint32_t const version)

Private Members

labels_type m_impl

Friends

friend struct cereal::access

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

class haldls::vx::SpikePack2ToChip : public haldls::vx::ContainerBase<SpikePack2ToChip>

#include <event.h>

Public Types

typedef EncodableBase<SpikePack2ToChip, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SpikePack2ToChip, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SpikePack2ToChip, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SpikePack2ToChip, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SpikePack2ToChipOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef std::array<halco::hicann_dls::vx::SpikeLabel, 2> labels_type

Public Functions

SpikePack2ToChip()

Default constructor.

explicit SpikePack2ToChip(labels_type const &labels)

• Construct spike pack with labels. *

Parameters

labels – Array of SpikeLabel values to use

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

labels_type get_labels() const

• Get spike labels. *

Returns

Array of SpikeLabel

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SpikePack2ToChip const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SpikePack2ToChip const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_labels(labels_type const &value)

• 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)

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

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>
friend void serialize(Archive &ar, SpikePack2ToChip &value, std::uint32_t const version)

Private Members

labels_type m_impl

Friends

friend struct cereal::access

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

class haldls::vx::SpikePack3ToChip : public haldls::vx::ContainerBase<SpikePack3ToChip>

#include <event.h>

Public Types

typedef EncodableBase<SpikePack3ToChip, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SpikePack3ToChip, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SpikePack3ToChip, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SpikePack3ToChip, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SpikePack3ToChipOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef std::array<halco::hicann_dls::vx::SpikeLabel, 3> labels_type

Public Functions

SpikePack3ToChip()

Default constructor.

explicit SpikePack3ToChip(labels_type const &labels)

• Construct spike pack with labels. *

Parameters

labels – Array of SpikeLabel values to use

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

labels_type get_labels() const

• Get spike labels. *

Returns

Array of SpikeLabel

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SpikePack3ToChip const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SpikePack3ToChip const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_labels(labels_type const &value)

• 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)

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

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>
friend void serialize(Archive &ar, SpikePack3ToChip &value, std::uint32_t const version)

Private Members

labels_type m_impl

Friends

friend struct cereal::access

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

class haldls::vx::SynapseBiasSelection : public haldls::vx::ContainerBase<SynapseBiasSelection>

#include <synapse.h>

Public Types

typedef EncodableBase<SynapseBiasSelection, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SynapseBiasSelection, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SynapseBiasSelection, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::CapMemBlockOnDLS> bias_selection_type

typedef EncodableBase<SynapseBiasSelection, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SynapseBiasSelectionOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit SynapseBiasSelection()

Construct Synapse Bias Selection container with all internal biases enabled.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bias_selection_type const &get_enable_internal_dac_bias() const

Set enable for internal synapse DAC bias current.

bias_selection_type const &get_enable_internal_output_bias() const

Set enable for internal synapse correlation output bias current.

bias_selection_type const &get_enable_internal_ramp_bias() const

Set enable for internal synapse correlation ramp bias current.

bias_selection_type const &get_enable_internal_store_bias() const

Set enable for internal synapse correlation store bias current.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SynapseBiasSelection const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SynapseBiasSelection const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_internal_dac_bias(bias_selection_type const &value)

void set_enable_internal_output_bias(bias_selection_type const &value)

void set_enable_internal_ramp_bias(bias_selection_type const &value)

void set_enable_internal_store_bias(bias_selection_type 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 size_t constexpr config_size_in_words = 1

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

Private Functions

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

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 struct cereal::access

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

class haldls::vx::SynapseCorrelationCalibQuad : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseCorrelationCalibQuad>

#include <synapse.h>

Public Types

typedef halco::common::typed_array<AmpCalib, halco::hicann_dls::vx::EntryOnQuad> amp_calibs_type

typedef EncodableBase<SynapseCorrelationCalibQuad, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SynapseCorrelationCalibQuad, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SynapseCorrelationCalibQuad, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SynapseCorrelationCalibQuad, Container>::Coordinate Coordinate

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()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

amp_calibs_type const &get_amp_calibs() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

time_calibs_type const &get_time_calibs() const

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SynapseCorrelationCalibQuad const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SynapseCorrelationCalibQuad const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_amp_calibs(amp_calibs_type const &value)

void set_time_calibs(time_calibs_type const &value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 2

Private Functions

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

Private Members

amp_calibs_type m_amp_calibs

time_calibs_type m_time_calibs

Friends

friend struct 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)

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)

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::SynapseDriverConfig : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseDriverConfig>

#include <synapse_driver.h>

Public Types

typedef EncodableBase<SynapseDriverConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SynapseDriverConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SynapseDriverConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SynapseDriverConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SynapseDriverOnDLS coordinate_type

typedef std::true_type is_leaf_node

enum class RowMode

Values:

enumerator disabled

enumerator excitatory

enumerator inhibitory

enumerator excitatory_and_inhibitory

Public Functions

SynapseDriverConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable_address_out() const

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

Enable charge sharing for larger STP utilization values (broken).

bool get_enable_hagen_dac() const

Enable the DAC converting a hagen activation to an STP voltage.

bool get_enable_hagen_modulation() const

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

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

Enable padi bus receiver.

bool get_enable_recovery() const

Enable STP recovery circuit.

bool get_enable_renewing() const

Enable renewing synapses for LIF sampling (broken due to faulty circuit).

bool get_enable_stp() const

Enable STP circuit.

HagenDACOffset get_hagen_dac_offset() const

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.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

Offset get_offset() const

Calibration value for dacen pulse width.

Recovery get_recovery() const

Set STP recovery time constant.

RowAddressCompareMask get_row_address_compare_mask() const

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

Set bottom row mode.

RowMode get_row_mode_top() const

Set top row mode.

TargetVoltages get_select_target_voltages() const

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.

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Utilization get_utilization() const

Set strength of STP utilization.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SynapseDriverConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SynapseDriverConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_address_out(bool const value)

void set_enable_charge_sharing(bool const value)

void set_enable_hagen_dac(bool value)

void set_enable_hagen_modulation(bool const value)

void set_enable_readout(bool const value)

void set_enable_receiver(bool const value)

void set_enable_recovery(bool const value)

void set_enable_renewing(bool const value)

void set_enable_stp(bool const value)

void set_hagen_dac_offset(HagenDACOffset value)

void set_offset(Offset const value)

void set_recovery(Recovery const value)

void set_row_address_compare_mask(RowAddressCompareMask const value)

void set_row_mode_bottom(RowMode value)

void set_row_mode_top(RowMode value)

void set_select_target_voltages(TargetVoltages const value)

void set_utilization(Utilization const value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 3

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

Private Functions

void from_bitfield(SynapseDriverConfigBitfield const &bitfield)

SynapseDriverConfigBitfield to_bitfield() const

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

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 struct cereal::access

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

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)

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::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::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::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)

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)

class haldls::vx::SynapseDriverSRAMTimingConfig : public haldls::vx::detail::SRAMTimingConfig, public haldls::vx::ContainerBase<SynapseDriverSRAMTimingConfig>

#include <synapse_driver.h>

Public Types

typedef EncodableBase<SynapseDriverSRAMTimingConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SynapseDriverSRAMTimingConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SynapseDriverSRAMTimingConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SynapseDriverSRAMTimingConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SynapseDriverSRAMTimingConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

SynapseDriverSRAMTimingConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

AddressSetupTime get_address_setup_time() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ReadDelay get_read_delay() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

WriteWidth get_write_width() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SRAMTimingConfig const &other) const

bool operator!=(SynapseDriverSRAMTimingConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SRAMTimingConfig const &other) const

bool operator==(SynapseDriverSRAMTimingConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_address_setup_time(AddressSetupTime value)

void set_read_delay(ReadDelay value)

void set_write_width(WriteWidth value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 2

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

Private Functions

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

Friends

friend struct cereal::access

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

class haldls::vx::SynapseLabelQuad : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseLabelQuad>

#include <synapse.h>

Public Types

typedef EncodableBase<SynapseLabelQuad, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SynapseLabelQuad, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SynapseLabelQuad, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SynapseLabelQuad, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SynapseLabelQuadOnDLS coordinate_type

typedef std::true_type is_leaf_node

typedef halco::hicann_dls::vx::SynapseLabel Value

typedef halco::common::typed_array<Value, halco::hicann_dls::vx::EntryOnQuad> values_type

Public Functions

SynapseLabelQuad()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

values_type const &get_values() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SynapseLabelQuad const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SynapseLabelQuad const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_values(values_type const &value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

values_type m_values

Friends

friend struct 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)

class haldls::vx::SynapseQuad : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseQuad>

#include <synapse.h>

Public Types

typedef SynapseCorrelationCalibQuad::amp_calibs_type amp_calibs_type

typedef SynapseCorrelationCalibQuad::AmpCalib AmpCalib

typedef EncodableBase<SynapseQuad, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SynapseQuad, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SynapseQuad, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SynapseQuad, Container>::Coordinate Coordinate

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()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

amp_calibs_type const &get_amp_calibs() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

labels_type const &get_labels() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

time_calibs_type const &get_time_calibs() const

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

weights_type const &get_weights() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SynapseQuad const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SynapseQuad const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_amp_calibs(amp_calibs_type const &value)

void set_labels(labels_type const &value)

void set_time_calibs(time_calibs_type const &value)

void set_weights(weights_type const &value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 2

Private Functions

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

Private Members

amp_calibs_type m_amp_calibs

labels_type m_labels

time_calibs_type m_time_calibs

weights_type m_weights

Friends

friend struct 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)

class haldls::vx::SynapseWeightQuad : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<SynapseWeightQuad>

#include <synapse.h>

Public Types

typedef EncodableBase<SynapseWeightQuad, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SynapseWeightQuad, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SynapseWeightQuad, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SynapseWeightQuad, Container>::Coordinate Coordinate

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()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

values_type const &get_values() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SynapseWeightQuad const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SynapseWeightQuad const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_values(values_type const &value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

values_type m_values

Friends

friend struct 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)

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)

class haldls::vx::SystimeCorrectionBarrierConfig : public haldls::vx::ContainerBase<SystimeCorrectionBarrierConfig>

#include <fpga.h>

Container for arming the systime-correction barrier in playback executor.

This barrier, if armed, blocks the pb-executor until a global interrupt signal is received. If unarmed, the barrier returns immediately. With an Extoll-Bitfile, this waits for a global network-Interrupt. In any other case, it will just return immediately.

Public Types

typedef EncodableBase<SystimeCorrectionBarrierConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SystimeCorrectionBarrierConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SystimeCorrectionBarrierConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SystimeCorrectionBarrierConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SystimeCorrectionBarrierConfigOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit SystimeCorrectionBarrierConfig()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable_interrupt() const

Get enable_interrupt.

Returns

bool enable_interrupt

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SystimeCorrectionBarrierConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SystimeCorrectionBarrierConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_interrupt(bool enable_interrupt)

Set enable_interrupt.

Parameters

bool – enable_interrupt

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Private Members

bool m_enable_interrupt

Friends

friend struct cereal::access

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

class haldls::vx::SystimeSync : public haldls::vx::ContainerBase<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 EncodableBase<SystimeSync, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SystimeSync, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SystimeSync, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SystimeSync, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SystimeSyncOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

SystimeSync(bool do_sync = true)

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_do_sync() const

Get systime sync enable value.

On true, systime sync is triggered, on false only a systime update response is emitted.

Returns

Boolean value

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SystimeSync const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SystimeSync const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_do_sync(bool value)

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)

static std::array<coordinate_type, write_config_size_in_words> write_addresses(coordinate_type const &word)

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Private Members

bool m_do_sync

Friends

friend std::ostream &operator<<(std::ostream &os, SystimeSync const &systime_sync)

class haldls::vx::SystimeSyncBase : public haldls::vx::ContainerBase<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 EncodableBase<SystimeSyncBase, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<SystimeSyncBase, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<SystimeSyncBase, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<SystimeSyncBase, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::SystimeSyncBaseOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit SystimeSyncBase(Value const value = Value())

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(SystimeSyncBase const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(SystimeSyncBase const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value const &value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 2

Private Functions

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

Private Members

Value m_value

Friends

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

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)

class haldls::vx::TCA9554Config : public haldls::vx::ContainerBase<TCA9554Config>

#include <i2c.h>

Public Types

typedef EncodableBase<TCA9554Config, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<TCA9554Config, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<TCA9554Config, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

enum class ChannelMode : bool

Values:

enumerator output

enumerator input

enum class ChannelPolarity : bool

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 EncodableBase<TCA9554Config, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::TCA9554ConfigOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

TCA9554Config()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

ChannelsModeArray const &get_channel_mode() const

Get input/output mode for all channels.

Returns

Array of channel input/output modes

ChannelsBooleanArray const &get_channel_output() const

Get output value for all channels.

Returns

Array of output values

ChannelsPolarityArray const &get_channel_polarity() const

Get polarity inversion mode of all channels.

Returns

Array of polarity inversion modes

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(TCA9554Config const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(TCA9554Config const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_channel_mode(ChannelsModeArray const &value)

Set input/output mode for all channels.

Parameters

value – Array of channel input/output modes

void set_channel_output(ChannelsBooleanArray const &value)

Set output value for all channels.

Parameters

value – Array of output values

void set_channel_polarity(ChannelsPolarityArray const &value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 3

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

Private Functions

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

Private Members

ChannelsModeArray m_mode

ChannelsBooleanArray m_output

ChannelsPolarityArray m_polarity

Friends

friend struct cereal::access

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

class haldls::vx::TCA9554Inputs : public haldls::vx::ContainerBase<TCA9554Inputs>

#include <i2c.h>

Public Types

typedef EncodableBase<TCA9554Inputs, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<TCA9554Inputs, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<TCA9554Inputs, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef halco::common::typed_array<bool, halco::hicann_dls::vx::TCA9554ChannelOnBoard> ChannelsBooleanArray

typedef EncodableBase<TCA9554Inputs, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::TCA9554InputsOnBoard coordinate_type

typedef std::true_type is_leaf_node

Public Functions

TCA9554Inputs()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

ChannelsBooleanArray const &get_channel_input() const

Get input value for all channels.

Returns

Array of channel input values

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(TCA9554Inputs const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(TCA9554Inputs const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_channel_input(ChannelsBooleanArray const &value)

Set input value for all channels.

Parameters

value – Array of channel input values

Public Static Functions

static std::array<halco::hicann_dls::vx::I2CTCA9554RoRegisterOnBoard, read_config_size_in_words> read_addresses(coordinate_type const &coord)

static std::array<halco::hicann_dls::vx::I2CTCA9554RoRegisterOnBoard, write_config_size_in_words> write_addresses(coordinate_type const &coord)

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

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

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

ChannelsBooleanArray m_input

Friends

friend struct cereal::access

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

class haldls::vx::Timer : public haldls::vx::ContainerBase<Timer>

#include <timer.h>

Container for resetting and reading the FPGA playback timer.

Public Types

typedef EncodableBase<Timer, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<Timer, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<Timer, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<Timer, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::TimerOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit Timer(Value value = Value())

Construct on-FPGA-timer with value.

Parameters

value – Value to construct with

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

Value get() const

Get timer value.

Returns

Value value

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(Timer const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(Timer const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set(Value value)

Set timer value.

Parameters

value – Value to set

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

struct haldls::vx::Timer::Value : public halco::common::detail::BaseType<Value, uint32_t>, public haldls::vx::BlockUntilBase<Value>

#include <timer.h>

Public Types

typedef Encodable::BackendCocoListVariant BackendCocoListVariant

typedef Encodable::BackendContainerListVariant BackendContainerListVariant

typedef Encodable::BackendCoordinateListVariant BackendCoordinateListVariant

typedef Encodable::Coordinate Coordinate

typedef halco::hicann_dls::vx::TimerOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

inline explicit constexpr Value(uintmax_t value = 0)

virtual std::unique_ptr<BlockUntil> clone_block_until() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(BlockUntil const &other) const

virtual bool operator!=(Encodable const &other) const

virtual bool operator==(BlockUntil const &other) const

virtual bool operator==(Encodable const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

Public Static Functions

static std::array<halco::hicann_dls::vx::WaitUntilOnFPGA, write_config_size_in_words> write_addresses(coordinate_type const &coord)

Public Static Attributes

static const Value fpga_clock_cycles_per_us

static size_t constexpr write_config_size_in_words = 1

class haldls::vx::v3::NeuronConfig : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<NeuronConfig>

#include <neuron.h>

Public Types

typedef EncodableBase<NeuronConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<NeuronConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<NeuronConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<NeuronConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::v3::NeuronConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

enum class ReadoutSource : uint_fast8_t

Source of readout output.

Values:

enumerator membrane

enumerator exc_synin

enumerator inh_synin

enumerator adaptation

Public Functions

NeuronConfig()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_connect_bottom() const

bool get_connect_membrane_right() const

bool get_connect_soma() const

bool get_connect_soma_right() const

bool get_enable_adaptation() const

bool get_enable_bypass_excitatory() const

bool get_enable_bypass_inhibitory() const

bool get_enable_divide_multicomp_conductance_bias() const

bool get_enable_exponential() const

bool get_enable_fire() const

bool get_enable_leak_degeneration() const

bool get_enable_leak_division() const

bool get_enable_leak_multiplication() const

bool get_enable_membrane_offset() const

bool get_enable_multicomp_conductance() const

bool get_enable_multiply_multicomp_conductance_bias() const

bool get_enable_pause() const

bool get_enable_readout() const

bool get_enable_readout_amplifier() const

bool get_enable_reset_degeneration() const

bool get_enable_reset_division() const

bool get_enable_reset_multiplication() const

bool get_enable_strong_fire() const

bool get_enable_synaptic_input_excitatory() const

bool get_enable_synaptic_input_excitatory_coba_mode() const

bool get_enable_synaptic_input_excitatory_high_resistance() const

bool get_enable_synaptic_input_excitatory_small_capacitance() const

bool get_enable_synaptic_input_inhibitory() const

bool get_enable_synaptic_input_inhibitory_coba_mode() const

bool get_enable_synaptic_input_inhibitory_high_resistance() const

bool get_enable_synaptic_input_inhibitory_small_capacitance() const

bool get_enable_threshold_comparator() const

bool get_enable_unbuffered_access() const

bool get_invert_adaptation_a() const

bool get_invert_adaptation_b() const

bool get_invert_membrane_offset() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

MembraneCapacitorSize get_membrane_capacitor_size() const

ReadoutSource get_readout_source() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(NeuronConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(NeuronConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_connect_bottom(bool value)

void set_connect_membrane_right(bool value)

void set_connect_soma(bool value)

void set_connect_soma_right(bool value)

void set_enable_adaptation(bool value)

void set_enable_bypass_excitatory(bool value)

void set_enable_bypass_inhibitory(bool value)

void set_enable_divide_multicomp_conductance_bias(bool value)

void set_enable_exponential(bool value)

void set_enable_fire(bool value)

void set_enable_leak_degeneration(bool value)

void set_enable_leak_division(bool value)

void set_enable_leak_multiplication(bool value)

void set_enable_membrane_offset(bool value)

void set_enable_multicomp_conductance(bool value)

void set_enable_multiply_multicomp_conductance_bias(bool value)

void set_enable_pause(bool value)

void set_enable_readout(bool value)

void set_enable_readout_amplifier(bool value)

void set_enable_reset_degeneration(bool value)

void set_enable_reset_division(bool value)

void set_enable_reset_multiplication(bool value)

void set_enable_strong_fire(bool value)

void set_enable_synaptic_input_excitatory(bool value)

void set_enable_synaptic_input_excitatory_coba_mode(bool value)

void set_enable_synaptic_input_excitatory_high_resistance(bool value)

void set_enable_synaptic_input_excitatory_small_capacitance(bool value)

void set_enable_synaptic_input_inhibitory(bool value)

void set_enable_synaptic_input_inhibitory_coba_mode(bool value)

void set_enable_synaptic_input_inhibitory_high_resistance(bool value)

void set_enable_synaptic_input_inhibitory_small_capacitance(bool value)

void set_enable_threshold_comparator(bool value)

void set_enable_unbuffered_access(bool value)

void set_invert_adaptation_a(bool value)

void set_invert_adaptation_b(bool value)

void set_invert_membrane_offset(bool value)

void set_membrane_capacitor_size(MembraneCapacitorSize value)

void set_readout_source(ReadoutSource value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 6

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

Private Functions

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

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 std::ostream &operator<<(std::ostream &os, NeuronConfig const &config)

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)

class haldls::vx::v3::NeuronResetQuad : public haldls::vx::ContainerBase<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 EncodableBase<NeuronResetQuad, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<NeuronResetQuad, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<NeuronResetQuad, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<NeuronResetQuad, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::v3::NeuronResetQuadOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

NeuronResetQuad()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(NeuronResetQuad const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(NeuronResetQuad const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Friends

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

class haldls::vx::v3::PLLClockOutputBlock : public haldls::vx::ContainerBase<PLLClockOutputBlock>

#include <pll.h>

Container for configuration of the clock outputs of the PLL.

Public Types

typedef EncodableBase<PLLClockOutputBlock, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PLLClockOutputBlock, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PLLClockOutputBlock, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PLLClockOutputBlock, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::PLLClockOutputBlockOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PLLClockOutputBlock()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

ClockOutput const &get_clock_output(halco::hicann_dls::vx::PLLClockOutputOnDLS const &coord) const

Get clock output configuration.

Parameters

coord – Coordinate of clock output to get

Returns

Configuration of clock output

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

halco::hicann_dls::vx::PLLClockOutputOnDLS const &get_spl1_source() const

Get SPL1 / Omnibus clock source.

Returns

Clock source for SPL1 / Omnibus clock.

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PLLClockOutputBlock const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PLLClockOutputBlock const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_clock_output(halco::hicann_dls::vx::PLLClockOutputOnDLS const &coord, ClockOutput const &config)

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)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

halco::common::typed_array<ClockOutput, halco::hicann_dls::vx::PLLClockOutputOnDLS> m_output

bool m_switch_spl1_to_madc

Friends

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

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

#include <pll.h>

Public Functions

ClockOutput()

Default construct PLL clock output.

bool get_enable_bypass() const

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

Get whether output is enabled.

Returns

Boolean value

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

Get coordinate of selected ADPLL to route to output.

Returns

coord Coordinate of ADPLL to select

ADPLL::Output get_select_adpll_output() const

Get which output of selected ADPLL to route to output.

Returns

ADPLL output

bool operator!=(ClockOutput const &other) const

bool operator==(ClockOutput const &other) const

void set_enable_bypass(bool value)

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)

Set enable value of output.

Parameters

value – Boolean value to set

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

Set select which ADPLL to route to output.

Parameters

coord – Coordinate of ADPLL to select

void set_select_adpll_output(ADPLL::Output const value)

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)

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)

class haldls::vx::v3::ReferenceGeneratorConfig : public haldls::vx::ContainerBase<ReferenceGeneratorConfig>

#include <capmem.h>

Public Types

typedef EncodableBase<ReferenceGeneratorConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ReferenceGeneratorConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ReferenceGeneratorConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

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<CapMemSlope, halco::hicann_dls::vx::CapMemBlockOnDLS> capmem_slope_type

typedef EncodableBase<ReferenceGeneratorConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::ReferenceGeneratorConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit ReferenceGeneratorConfig()

Default config of reference generator.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

capmem_amplifier_type const &get_capmem_amplifier() const

Set CapMem amplifier bias current (settings for each quadrant).

capmem_offset_type const &get_capmem_offset() const

Set CapMem offset current (settings for each quadrant).

capmem_slope_type const &get_capmem_slope() const

Set CapMem slope current (settings for each quadrant).

bool const &get_enable_internal_reference() const

Set enable for internal reference current generation.

bool const &get_enable_reference_input() const

Set enable for input of reference current from pad.

bool const &get_enable_reference_output() const

Set enable for output of reference current to pad.

bool const &get_enable_reset() const

Set reset signal for resistor control of reference current generation.

The reset can be used after powerup to reach a working state.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ReferenceControl get_reference_control() const

Set reference current generation DAC value.

ResistorControl get_resistor_control() const

Set reference current generation resistor value.

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(ReferenceGeneratorConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(ReferenceGeneratorConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_capmem_amplifier(capmem_amplifier_type const &value)

void set_capmem_offset(capmem_offset_type const &value)

void set_capmem_slope(capmem_slope_type const &value)

void set_enable_internal_reference(bool value)

void set_enable_reference_input(bool value)

void set_enable_reference_output(bool value)

void set_enable_reset(bool value)

void set_reference_control(ReferenceControl value)

void set_resistor_control(ResistorControl value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 9

Private Functions

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

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 std::ostream &operator<<(std::ostream &os, ReferenceGeneratorConfig const &config)

struct haldls::vx::v3::ReferenceGeneratorConfig::CapMemAmplifier : 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)

struct haldls::vx::v3::ReferenceGeneratorConfig::CapMemOffset : 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)

struct haldls::vx::v3::ReferenceGeneratorConfig::CapMemSlope : 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)

struct haldls::vx::v3::ReferenceGeneratorConfig::ReferenceControl : 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)

struct haldls::vx::v3::ReferenceGeneratorConfig::ResistorControl : 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)

class haldls::vx::v4::GlobalMergerMatrixInputDropCounter : public haldls::vx::ContainerBase<GlobalMergerMatrixInputDropCounter>

#include <global_merger_matrix.h>

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

Public Types

typedef EncodableBase<GlobalMergerMatrixInputDropCounter, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<GlobalMergerMatrixInputDropCounter, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<GlobalMergerMatrixInputDropCounter, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<GlobalMergerMatrixInputDropCounter, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::v4::GlobalMergerMatrixInputDropCounterOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

GlobalMergerMatrixInputDropCounter()

Default constructor.

GlobalMergerMatrixInputDropCounter(Value value)

Construct from value.

Parameters

value – Value

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

Get accumulated drop counter value.

Returns

Value

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(GlobalMergerMatrixInputDropCounter const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(GlobalMergerMatrixInputDropCounter const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value value)

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)

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

struct haldls::vx::v4::GlobalMergerMatrixInputDropCounter::Value : public halco::common::detail::RantWrapper<Value, uint_fast32_t, hate::math::pow(2, 16) - 1, 0>

#include <global_merger_matrix.h>

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

class haldls::vx::v4::GlobalMergerMatrixNode : public haldls::vx::ContainerBase<GlobalMergerMatrixNode>

#include <global_merger_matrix.h>

Node of the global merger matrix routing events from a GlobalMergerMatrixInputOnDLS to a GlobalMergerMatrixOutputOnDLS.

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

Public Types

typedef halco::common::typed_array<bool, GL1Index> accept_gl1_index_type

typedef EncodableBase<GlobalMergerMatrixNode, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<GlobalMergerMatrixNode, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<GlobalMergerMatrixNode, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<GlobalMergerMatrixNode, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::v4::GlobalMergerMatrixNodeOnDLS coordinate_type

typedef std::true_type is_leaf_node

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

Public Functions

GlobalMergerMatrixNode()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

accept_gl1_index_type const &get_accept_gl1_index() const

Get values for gl1 index acceptance.

Returns

Boolean values

bool get_enable_drop_counter() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

neuron_label_type get_mask() const

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

Returns

NeuronLabel

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

neuron_label_type get_target() const

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

Returns

NeuronLabel

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(GlobalMergerMatrixNode const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(GlobalMergerMatrixNode const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_accept_gl1_index(accept_gl1_index_type const &value)

Set values for gl1 index acceptance.

Parameters

value – Boolean values

void set_enable_drop_counter(bool value)

void set_mask(neuron_label_type value)

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

Parameters

value – NeuronLabel

void set_target(neuron_label_type value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 2

static const GlobalMergerMatrixNode drop_all

static constexpr size_t GMM_WIDTH = 18

static constexpr size_t IDX_WIDTH = GMM_WIDTH - hate::math::num_bits(halco::hicann_dls::vx::v4::SpikeLabel::max)

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

Private Functions

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

Private Members

accept_gl1_index_type m_accept_gl1_index

bool m_enable_drop_counter

neuron_label_type m_mask

neuron_label_type m_target

Friends

friend struct cereal::access

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

struct haldls::vx::v4::GlobalMergerMatrixNode::GL1Index : public halco::common::detail::RantWrapper<GL1Index, uint_fast32_t, hate::math::pow(2, IDX_WIDTH) - 1, 0>

#include <global_merger_matrix.h>

Public Functions

inline explicit constexpr GL1Index(uintmax_t const val = 0)

class haldls::vx::v4::GlobalMergerMatrixOutputConfig : public haldls::vx::ContainerBase<GlobalMergerMatrixOutputConfig>

#include <global_merger_matrix.h>

Public Types

typedef EncodableBase<GlobalMergerMatrixOutputConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<GlobalMergerMatrixOutputConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<GlobalMergerMatrixOutputConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<GlobalMergerMatrixOutputConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::v4::GlobalMergerMatrixOutputConfigOnDLS coordinate_type

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

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

typedef std::true_type is_leaf_node

Public Functions

GlobalMergerMatrixOutputConfig()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

enable_event_counter_type const &get_enable_event_counter() const

Get enable value for event counters.

Returns

Boolean values

enable_slow_type const &get_enable_slow() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(GlobalMergerMatrixOutputConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(GlobalMergerMatrixOutputConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_event_counter(enable_event_counter_type const &value)

Set enable value for event counters.

Parameters

value – Boolean values

void set_enable_slow(enable_slow_type const &value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

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

Private Functions

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

Private Members

enable_event_counter_type m_enable_event_counter

enable_slow_type m_enable_slow

Friends

friend struct cereal::access

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

class haldls::vx::v4::GlobalMergerMatrixOutputEventCounter : public haldls::vx::ContainerBase<GlobalMergerMatrixOutputEventCounter>

#include <global_merger_matrix.h>

GlobalMergerMatrix output event counter counting events routed to an output.

Public Types

typedef EncodableBase<GlobalMergerMatrixOutputEventCounter, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<GlobalMergerMatrixOutputEventCounter, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<GlobalMergerMatrixOutputEventCounter, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<GlobalMergerMatrixOutputEventCounter, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::v4::GlobalMergerMatrixOutputEventCounterOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

GlobalMergerMatrixOutputEventCounter()

Default constructor.

GlobalMergerMatrixOutputEventCounter(Value value)

Construct from value.

Parameters

value – Value

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

Get event counter value.

Returns

Value

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(GlobalMergerMatrixOutputEventCounter const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(GlobalMergerMatrixOutputEventCounter const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value value)

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)

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 1

static size_t constexpr write_config_size_in_words = 0

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

struct haldls::vx::v4::GlobalMergerMatrixOutputEventCounter::Value : public halco::common::detail::RantWrapper<Value, uint_fast32_t, hate::math::pow(2, 24) - 1, 0>

#include <global_merger_matrix.h>

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)

class haldls::vx::v4::NeuronConfig : public haldls::vx::DifferentialWriteTrait, public haldls::vx::ContainerBase<NeuronConfig>

#include <neuron.h>

Public Types

typedef EncodableBase<NeuronConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<NeuronConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<NeuronConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<NeuronConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::v4::NeuronConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

enum class ReadoutSource : uint_fast8_t

Source of readout output.

Values:

enumerator membrane

enumerator exc_synin

enumerator inh_synin

enumerator adaptation

Public Functions

NeuronConfig()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_connect_bottom() const

bool get_connect_membrane_right() const

bool get_connect_soma() const

bool get_connect_soma_right() const

bool get_enable_adaptation() const

bool get_enable_bypass_excitatory() const

bool get_enable_bypass_inhibitory() const

bool get_enable_divide_multicomp_conductance_bias() const

bool get_enable_exponential() const

bool get_enable_fire() const

bool get_enable_leak_degeneration() const

bool get_enable_leak_division() const

bool get_enable_leak_multiplication() const

bool get_enable_membrane_offset() const

bool get_enable_multicomp_conductance() const

bool get_enable_multiply_multicomp_conductance_bias() const

bool get_enable_pause() const

bool get_enable_readout() const

bool get_enable_readout_amplifier() const

bool get_enable_reset_degeneration() const

bool get_enable_reset_division() const

bool get_enable_reset_multiplication() const

bool get_enable_strong_fire() const

bool get_enable_synaptic_input_excitatory() const

bool get_enable_synaptic_input_excitatory_coba_mode() const

bool get_enable_synaptic_input_excitatory_high_resistance() const

bool get_enable_synaptic_input_excitatory_small_capacitance() const

bool get_enable_synaptic_input_inhibitory() const

bool get_enable_synaptic_input_inhibitory_coba_mode() const

bool get_enable_synaptic_input_inhibitory_high_resistance() const

bool get_enable_synaptic_input_inhibitory_small_capacitance() const

bool get_enable_threshold_comparator() const

bool get_enable_unbuffered_access() const

bool get_invert_adaptation_a() const

bool get_invert_adaptation_b() const

bool get_invert_membrane_offset() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

MembraneCapacitorSize get_membrane_capacitor_size() const

ReadoutSource get_readout_source() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(NeuronConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(NeuronConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_connect_bottom(bool value)

void set_connect_membrane_right(bool value)

void set_connect_soma(bool value)

void set_connect_soma_right(bool value)

void set_enable_adaptation(bool value)

void set_enable_bypass_excitatory(bool value)

void set_enable_bypass_inhibitory(bool value)

void set_enable_divide_multicomp_conductance_bias(bool value)

void set_enable_exponential(bool value)

void set_enable_fire(bool value)

void set_enable_leak_degeneration(bool value)

void set_enable_leak_division(bool value)

void set_enable_leak_multiplication(bool value)

void set_enable_membrane_offset(bool value)

void set_enable_multicomp_conductance(bool value)

void set_enable_multiply_multicomp_conductance_bias(bool value)

void set_enable_pause(bool value)

void set_enable_readout(bool value)

void set_enable_readout_amplifier(bool value)

void set_enable_reset_degeneration(bool value)

void set_enable_reset_division(bool value)

void set_enable_reset_multiplication(bool value)

void set_enable_strong_fire(bool value)

void set_enable_synaptic_input_excitatory(bool value)

void set_enable_synaptic_input_excitatory_coba_mode(bool value)

void set_enable_synaptic_input_excitatory_high_resistance(bool value)

void set_enable_synaptic_input_excitatory_small_capacitance(bool value)

void set_enable_synaptic_input_inhibitory(bool value)

void set_enable_synaptic_input_inhibitory_coba_mode(bool value)

void set_enable_synaptic_input_inhibitory_high_resistance(bool value)

void set_enable_synaptic_input_inhibitory_small_capacitance(bool value)

void set_enable_threshold_comparator(bool value)

void set_enable_unbuffered_access(bool value)

void set_invert_adaptation_a(bool value)

void set_invert_adaptation_b(bool value)

void set_invert_membrane_offset(bool value)

void set_membrane_capacitor_size(MembraneCapacitorSize value)

void set_readout_source(ReadoutSource value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 6

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

Private Functions

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

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 std::ostream &operator<<(std::ostream &os, NeuronConfig const &config)

struct haldls::vx::v4::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)

class haldls::vx::v4::NeuronLabelToGL1EventLUTEntry : public haldls::vx::ContainerBase<NeuronLabelToGL1EventLUTEntry>

#include <global_merger_matrix.h>

Public Types

typedef EncodableBase<NeuronLabelToGL1EventLUTEntry, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<NeuronLabelToGL1EventLUTEntry, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<NeuronLabelToGL1EventLUTEntry, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<NeuronLabelToGL1EventLUTEntry, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::v4::NeuronLabelToGL1EventLUTEntryOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

NeuronLabelToGL1EventLUTEntry()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

GlobalMergerMatrixNode::GL1Index get_gl1_index() const

halco::hicann_dls::vx::v4::SpikeLabel::GlobalMergerMatrixMutable get_global_merger_matrix_mutable() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(NeuronLabelToGL1EventLUTEntry const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(NeuronLabelToGL1EventLUTEntry const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_gl1_index(GlobalMergerMatrixNode::GL1Index value)

void set_global_merger_matrix_mutable(halco::hicann_dls::vx::v4::SpikeLabel::GlobalMergerMatrixMutable value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 1

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

Private Functions

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

Private Members

GlobalMergerMatrixNode::GL1Index m_gl1_index

halco::hicann_dls::vx::v4::SpikeLabel::GlobalMergerMatrixMutable m_global_merger_matrix_mutable

Friends

friend struct cereal::access

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

class haldls::vx::v4::NeuronResetQuad : public haldls::vx::ContainerBase<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-v4 (issue 3346).

Public Types

typedef EncodableBase<NeuronResetQuad, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<NeuronResetQuad, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<NeuronResetQuad, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<NeuronResetQuad, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::v4::NeuronResetQuadOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

NeuronResetQuad()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(NeuronResetQuad const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(NeuronResetQuad const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Friends

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

class haldls::vx::v4::PLLClockOutputBlock : public haldls::vx::ContainerBase<PLLClockOutputBlock>

#include <pll.h>

Container for configuration of the clock outputs of the PLL.

Public Types

typedef EncodableBase<PLLClockOutputBlock, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<PLLClockOutputBlock, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<PLLClockOutputBlock, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<PLLClockOutputBlock, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::PLLClockOutputBlockOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

PLLClockOutputBlock()

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

ClockOutput const &get_clock_output(halco::hicann_dls::vx::PLLClockOutputOnDLS const &coord) const

Get clock output configuration.

Parameters

coord – Coordinate of clock output to get

Returns

Configuration of clock output

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

halco::hicann_dls::vx::PLLClockOutputOnDLS const &get_spl1_source() const

Get SPL1 / Omnibus clock source.

Returns

Clock source for SPL1 / Omnibus clock.

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(PLLClockOutputBlock const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(PLLClockOutputBlock const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_clock_output(halco::hicann_dls::vx::PLLClockOutputOnDLS const &coord, ClockOutput const &config)

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)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

halco::common::typed_array<ClockOutput, halco::hicann_dls::vx::PLLClockOutputOnDLS> m_output

bool m_switch_spl1_to_madc

Friends

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

class haldls::vx::v4::PLLClockOutputBlock::ClockOutput

#include <pll.h>

Public Functions

ClockOutput()

Default construct PLL clock output.

bool get_enable_bypass() const

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

Get whether output is enabled.

Returns

Boolean value

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

Get coordinate of selected ADPLL to route to output.

Returns

coord Coordinate of ADPLL to select

ADPLL::Output get_select_adpll_output() const

Get which output of selected ADPLL to route to output.

Returns

ADPLL output

bool operator!=(ClockOutput const &other) const

bool operator==(ClockOutput const &other) const

void set_enable_bypass(bool value)

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)

Set enable value of output.

Parameters

value – Boolean value to set

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

Set select which ADPLL to route to output.

Parameters

coord – Coordinate of ADPLL to select

void set_select_adpll_output(ADPLL::Output const value)

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)

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)

class haldls::vx::v4::ReferenceGeneratorConfig : public haldls::vx::ContainerBase<ReferenceGeneratorConfig>

#include <capmem.h>

Public Types

typedef EncodableBase<ReferenceGeneratorConfig, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<ReferenceGeneratorConfig, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<ReferenceGeneratorConfig, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

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<CapMemSlope, halco::hicann_dls::vx::CapMemBlockOnDLS> capmem_slope_type

typedef EncodableBase<ReferenceGeneratorConfig, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::ReferenceGeneratorConfigOnDLS coordinate_type

typedef std::true_type is_leaf_node

Public Functions

explicit ReferenceGeneratorConfig()

Default config of reference generator.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

capmem_amplifier_type const &get_capmem_amplifier() const

Set CapMem amplifier bias current (settings for each quadrant).

capmem_offset_type const &get_capmem_offset() const

Set CapMem offset current (settings for each quadrant).

capmem_slope_type const &get_capmem_slope() const

Set CapMem slope current (settings for each quadrant).

bool const &get_enable_internal_reference() const

Set enable for internal reference current generation.

bool const &get_enable_reference_input() const

Set enable for input of reference current from pad.

bool const &get_enable_reference_output() const

Set enable for output of reference current to pad.

bool const &get_enable_reset() const

Set reset signal for resistor control of reference current generation.

The reset can be used after powerup to reach a working state.

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

ReferenceControl get_reference_control() const

Set reference current generation DAC value.

ResistorControl get_resistor_control() const

Set reference current generation resistor value.

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(ReferenceGeneratorConfig const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(ReferenceGeneratorConfig const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_capmem_amplifier(capmem_amplifier_type const &value)

void set_capmem_offset(capmem_offset_type const &value)

void set_capmem_slope(capmem_slope_type const &value)

void set_enable_internal_reference(bool value)

void set_enable_reference_input(bool value)

void set_enable_reference_output(bool value)

void set_enable_reset(bool value)

void set_reference_control(ReferenceControl value)

void set_resistor_control(ResistorControl value)

Public Static Functions

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

Public Static Attributes

static size_t constexpr config_size_in_words = 9

Private Functions

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

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 std::ostream &operator<<(std::ostream &os, ReferenceGeneratorConfig const &config)

struct haldls::vx::v4::ReferenceGeneratorConfig::CapMemAmplifier : 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)

struct haldls::vx::v4::ReferenceGeneratorConfig::CapMemOffset : 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)

struct haldls::vx::v4::ReferenceGeneratorConfig::CapMemSlope : 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)

struct haldls::vx::v4::ReferenceGeneratorConfig::ReferenceControl : 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)

struct haldls::vx::v4::ReferenceGeneratorConfig::ResistorControl : 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)

class haldls::vx::VectorGeneratorControl : public haldls::vx::ContainerBase<VectorGeneratorControl>

#include <vector_generator.h>

Public Types

typedef EncodableBase<VectorGeneratorControl, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<VectorGeneratorControl, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<VectorGeneratorControl, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<VectorGeneratorControl, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::VectorGeneratorControlOnFPGA coordinate_type

typedef std::true_type is_leaf_node

enum class Notification

Type of notification to send once ready.

Values:

enumerator omnibus

enumerator gpio

enum class Signal

Type(s) of signals to use.

Values:

enumerator disabled

enumerator notification

enumerator trigger_and_notification

enum class 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 class Trigger

Type of trigger signal to listen to.

Values:

enumerator omnibus

enumerator gpio

Public Functions

VectorGeneratorControl() = default

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

bool get_enable_ignore_zeros() const

Get whether to ignore events with payload of zero.

Returns

Boolean value

EventPack get_event_pack() const

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

halco::hicann_dls::vx::VectorGeneratorLUTEntryOnVectorGeneratorLUT get_lookup_table_entry_start() const

Get lookup table entry position to start from.

Returns

Entry position

Notification get_notification() const

ResendCount get_resend_count() const

Signal get_signal() const

SourceCount get_source_count() const

SourceWaits get_source_waits() const

Sources get_sources() const

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

Trigger get_trigger() const

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(VectorGeneratorControl const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(VectorGeneratorControl const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable_ignore_zeros(bool value)

Set whether to ignore events with payload of zero.

Parameters

value – Boolean value

void set_event_pack(EventPack value)

void set_lookup_table_entry_start(halco::hicann_dls::vx::VectorGeneratorLUTEntryOnVectorGeneratorLUT value)

Set lookup table entry position to start from.

Parameters

value – Entry position

void set_notification(Notification value)

void set_resend_count(ResendCount value)

void set_signal(Signal value)

void set_source_count(SourceCount value)

void set_source_waits(SourceWaits value)

void set_sources(Sources value)

void set_trigger(Trigger value)

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

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 struct cereal::access

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

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)

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)

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::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)

class haldls::vx::VectorGeneratorFIFOWord : public haldls::vx::ContainerBase<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 EncodableBase<VectorGeneratorFIFOWord, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<VectorGeneratorFIFOWord, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<VectorGeneratorFIFOWord, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<VectorGeneratorFIFOWord, Container>::Coordinate Coordinate

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()

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

Enables const &get_enable() const

Get enables for entries to write.

Returns

Values

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

Enables const &get_last() const

Get last enables.

Returns

Values

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Values const &get_values() const

Get values.

Returns

Values

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(VectorGeneratorFIFOWord const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(VectorGeneratorFIFOWord const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_enable(Enables value)

Set enables for entries to write.

Parameters

value – Values

void set_last(Enables value)

Set last enables.

Parameters

value – Values

void set_values(Values value)

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)

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Private Members

Enables m_enable

Enables m_last

Values m_values

Friends

friend struct cereal::access

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

class haldls::vx::VectorGeneratorLUTEntry : public haldls::vx::ContainerBase<VectorGeneratorLUTEntry>

#include <vector_generator.h>

Container for an entry in the lookup-table for generation of spike events from activation values.

Public Types

typedef EncodableBase<VectorGeneratorLUTEntry, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<VectorGeneratorLUTEntry, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<VectorGeneratorLUTEntry, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<VectorGeneratorLUTEntry, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::VectorGeneratorLUTEntryOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

VectorGeneratorLUTEntry() = default

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

Get value.

Returns

Value

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(VectorGeneratorLUTEntry const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(VectorGeneratorLUTEntry const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

Value m_value = {}

Friends

friend struct cereal::access

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

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)

class haldls::vx::VectorGeneratorNotificationAddress : public haldls::vx::ContainerBase<VectorGeneratorNotificationAddress>

#include <vector_generator.h>

Public Types

typedef EncodableBase<VectorGeneratorNotificationAddress, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<VectorGeneratorNotificationAddress, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<VectorGeneratorNotificationAddress, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<VectorGeneratorNotificationAddress, Container>::Coordinate Coordinate

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)

Construct notification address from word location on PPU memory.

Parameters

word – Word location

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

Value get_value() const

Get value.

Returns

Value

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(VectorGeneratorNotificationAddress const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(VectorGeneratorNotificationAddress const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

void set_value(Value value)

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)

Public Static Attributes

static size_t constexpr config_size_in_words = 1

Private Functions

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

Private Members

Value m_value = {}

Friends

friend struct cereal::access

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

class haldls::vx::VectorGeneratorTrigger : public haldls::vx::ContainerBase<VectorGeneratorTrigger>

#include <vector_generator.h>

Public Types

typedef EncodableBase<VectorGeneratorTrigger, Container>::BackendCocoListVariant BackendCocoListVariant

typedef EncodableBase<VectorGeneratorTrigger, Container>::BackendContainerListVariant BackendContainerListVariant

typedef EncodableBase<VectorGeneratorTrigger, Container>::BackendCoordinateListVariant BackendCoordinateListVariant

typedef EncodableBase<VectorGeneratorTrigger, Container>::Coordinate Coordinate

typedef halco::hicann_dls::vx::VectorGeneratorTriggerOnFPGA coordinate_type

typedef std::true_type is_leaf_node

Public Functions

VectorGeneratorTrigger() = default

Default constructor.

virtual std::unique_ptr<Container> clone_container() const

Clone container data.

virtual std::unique_ptr<Encodable> clone_encodable() const

Clone data.

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

virtual void decode_read(BackendContainerListVariant const &data, Coordinate const &coordinate)

Decode read from backend container list variant.

Parameters

• data – Backend data to decode from

• coordinate – Coordinate to container to use

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

virtual BackendCoordinateListVariant encode_read(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode read to backend coordinate list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate list variant

virtual BackendCocoListVariant encode_write(Coordinate const &coordinate, std::optional<Backend> const &backend) const

Encode write to backend coordinate-container-pair list variant.

Parameters

coordinate – Coordinate to container to use

Returns

Backend coordinate-container-pair list variant

virtual bool get_is_valid_backend(Backend backend) const

Get whether backend is valid.

Parameters

backend – Backend to check

virtual bool get_supports_differential_write() const

Get whether encodable supports differential write operation.

Used when only an abstract reference is available, maps inheritance of DifferentialWriteTrait.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_read_targets() const

Get unsupported read targets.

Used when only an abstract reference is available, maps RealContainer::unsupported_read_targets.

virtual std::initializer_list<hxcomm::vx::Target> get_unsupported_write_targets() const

Get unsupported write targets.

Used when only an abstract reference is available, maps RealEncodable::unsupported_write_targets.

virtual bool operator!=(Container const &other) const

virtual bool operator!=(Encodable const &other) const

bool operator!=(VectorGeneratorTrigger const &other) const

virtual bool operator==(Container const &other) const

virtual bool operator==(Encodable const &other) const

bool operator==(VectorGeneratorTrigger const &other) const

virtual std::ostream &print(std::ostream &os) const

Print to ostream.

Public Static Functions

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

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

Public Static Attributes

static size_t constexpr read_config_size_in_words = 0

static size_t constexpr write_config_size_in_words = 1

Private Functions

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

Friends

friend struct cereal::access

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

namespace cereal

Functions

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::AD5252ChannelConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::AD5252ChannelConfigPersistent &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::ADPLL &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::BackgroundSpikeSource &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::Barrier &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::BlockPostPulse &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CADCChannelConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CADCConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CADCOffsetSRAMTimingConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CADCSampleQuad &value, std::uint32_t const version)

template<typename Archive, typename Coordinates>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CapMemBlock<Coordinates> &value, std::uint32_t const version)

template<typename Archive, typename Coordinates>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CapMemBlockConfig<Coordinates> &value, std::uint32_t const version)

template<typename Archive, typename Coordinates>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CapMemCell<Coordinates> &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CapMemSRAMTimingConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::ColumnCorrelationQuad &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::ColumnCurrentQuad &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CommonCorrelationConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CommonNeuronBackendConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CommonPADIBusConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CommonPhyConfigChip &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CommonPhyConfigFPGA &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CommonSTPConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CommonSynramConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CorrelationReset &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CrossbarInputDropCounter &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CrossbarNode &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CrossbarOutputConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CrossbarOutputEventCounter &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::CurrentDAC &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::DAC6573ChannelConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::DACChannel &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::DACControl &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::detail::PhyConfigBase &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::detail::SRAMTimingConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::EventRecordingConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::ExternalPPUDRAMMemoryByte &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::ExternalPPUDRAMMemoryQuad &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::ExternalPPUMemoryByte &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::ExternalPPUMemoryQuad &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::FPGADeviceDNA &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::FPGASystimeSyncActiveState &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::FPGASystimeSyncLastAsicSystime &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::FPGASystimeSyncLastRTT &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::FPGASystimeSyncNumRetries &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::HicannARQStatus &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::HighspeedLinkNotification &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::INA219Config &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::INA219Status &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::InstructionTimeoutConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::JTAGClockScaler &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::JTAGIdCode &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::MADCConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::MADCControl &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::MADCSampleFromChip &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::NeuronBackendSRAMTimingConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::NeuronReset &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::NeuronSRAMTimingConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::NullPayloadReadable &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PADIEvent &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PadMultiplexerConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PerfTest &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PerfTestStatus &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PhyConfigChip &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PhyConfigFPGA &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PhyStatus &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PLLSelfTest &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PLLSelfTestStatus &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PollingOmnibusBlock &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PollingOmnibusBlockConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PPUControlRegister &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PPUMemory &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PPUMemoryBlock &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PPUMemoryWord &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::PPUStatusRegister &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::ReadoutSourceSelection &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::ResetChip &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::ResetJTAGTap &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::ShiftRegister &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SpikeCounterRead &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SpikeCounterReset &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SpikeFromChip &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SpikeIOConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SpikeIOInputRoute &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SpikeIOOutputRoute &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SpikePack1ToChip &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SpikePack2ToChip &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SpikePack3ToChip &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SynapseBiasSelection &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SynapseCorrelationCalibQuad &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SynapseDriverConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SynapseDriverSRAMTimingConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SynapseLabelQuad &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SynapseQuad &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SynapseWeightQuad &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SystimeCorrectionBarrierConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SystimeSync &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::SystimeSyncBase &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::TCA9554Config &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::TCA9554Inputs &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::Timer &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v3::NeuronConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v3::NeuronResetQuad &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v3::PLLClockOutputBlock &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v3::ReferenceGeneratorConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v4::GlobalMergerMatrixInputDropCounter &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v4::GlobalMergerMatrixNode &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v4::GlobalMergerMatrixOutputConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v4::GlobalMergerMatrixOutputEventCounter &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v4::NeuronConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v4::NeuronLabelToGL1EventLUTEntry &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v4::NeuronResetQuad &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v4::PLLClockOutputBlock &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::v4::ReferenceGeneratorConfig &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::VectorGeneratorControl &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::VectorGeneratorFIFOWord &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::VectorGeneratorLUTEntry &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::VectorGeneratorNotificationAddress &value, std::uint32_t const version)

template<typename Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &ar, haldls::vx::VectorGeneratorTrigger &value, std::uint32_t const version)

namespace fisch

namespace vx

namespace word_access_type

namespace halco

namespace common

namespace detail

namespace hicann_dls

namespace vx

namespace v3

namespace v4

namespace haldls

namespace haldls::vx

Typedefs

typedef hate::type_list<> BackendContainerList

Possible backend types to target with PlaybackProgramBuilder::read/write.

Note

Autogenerated collection of types skipped in documentation.

typedef fisch::vx::ChipTime ChipTime

typedef fisch::vx::FPGATime FPGATime

Enums

enum class Backend

Possible backends to target with PlaybackProgramBuilder::read/write.

Note

Autogenerated enumerators skipped in documentation.

Values:

enum class CapMemBlockConfigIOutSelect : uint_fast8_t

Enum inside templated class not wrapped correctly by genpybind (Issue #3699).

Values:

enumerator disabled

enumerator i_out_mux

enumerator i_out_ramp

enum class CapMemBlockConfigVRefSelect : uint_fast8_t

Enum inside templated class not wrapped correctly by genpybind (Issue #3699).

Values:

enumerator disabled

enumerator v_ref_v

enumerator v_ref_i

Functions

std::unique_ptr<Container> construct_container(Container::Coordinate const &coordinate)

Construct container from given coordinate using registry.

Parameters

coordinate – Coordinate to construct container for

Returns

Constructed container matching given coordinate

std::ostream &operator<<(std::ostream&, ADPLL::Output const&)

std::ostream &operator<<(std::ostream&, CurrentDAC::Sign const&)

std::ostream &operator<<(std::ostream &os, CapMemBlockConfigIOutSelect const &config)

std::ostream &operator<<(std::ostream &os, CapMemBlockConfigVRefSelect const &config)

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

std::ostream &operator<<(std::ostream &os, INA219Config::ADCMode const &mode)

std::ostream &operator<<(std::ostream &os, ShiftRegister::AnalogReadoutMux1Input const &config)

std::ostream &operator<<(std::ostream &os, ShiftRegister::AnalogReadoutMux2Input const &config)

std::ostream &operator<<(std::ostream &os, ShiftRegister::AnalogReadoutMux3Input const &config)

std::ostream &operator<<(std::ostream &os, SynapseDriverConfig::RowMode const &mode)

std::ostream &operator<<(std::ostream &os, typename CapMemCell<halco::hicann_dls::vx::v3::Coordinates>::value_type const &value)

std::ostream &operator<<(std::ostream &os, typename CapMemCell<halco::hicann_dls::vx::v4::Coordinates>::value_type const &value)

std::ostream &operator<<(std::ostream &os, VectorGeneratorControl::Notification const &config)

std::ostream &operator<<(std::ostream &os, VectorGeneratorControl::Signal const &config)

std::ostream &operator<<(std::ostream &os, VectorGeneratorControl::Trigger const &config)

hate::Nil register_container(std::type_index coordinate_type, std::unique_ptr<Container> (*construct_container)(Container::Coordinate const &coordinate))

Register container construction from coordinate function.

Parameters

• coordinate_type – Used type_index of coordinate

• construct_container – Function to construct container from coordinate

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, v3::PPUMemory, v3::PPUMemoryBlock, v3::CapMemBlock, lola::vx::v3::AtomicNeuron, lola::vx::v3::CADCSampleRow, lola::vx::v3::CADCSamples, lola::vx::v3::ExternalPPUMemoryBlock, lola::vx::v3::ExternalPPUDRAMMemoryBlock> 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, v3::PPUMemoryBlock, v3::PPUMemory, v3::CapMemBlock, lola::vx::v3::AtomicNeuron, lola::vx::v3::DACChannelBlock, lola::vx::v3::DACControlBlock, lola::vx::v3::ExternalPPUMemoryBlock, lola::vx::v3::ExternalPPUDRAMMemoryBlock> 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::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 CapMemBlockConfig = haldls::vx::CapMemBlockConfig<halco::hicann_dls::vx::v3::Coordinates>

using CapMemCell = haldls::vx::CapMemCell<halco::hicann_dls::vx::v3::Coordinates>

using CapMemSRAMTimingConfig = haldls::vx::CapMemSRAMTimingConfig

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 ExternalPPUDRAMMemoryByte = haldls::vx::ExternalPPUDRAMMemoryByte

using ExternalPPUDRAMMemoryQuad = haldls::vx::ExternalPPUDRAMMemoryQuad

using ExternalPPUMemoryByte = haldls::vx::ExternalPPUMemoryByte

using ExternalPPUMemoryQuad = haldls::vx::ExternalPPUMemoryQuad

using FPGADeviceDNA = haldls::vx::FPGADeviceDNA

using FPGASystimeSyncActiveState = haldls::vx::FPGASystimeSyncActiveState

using FPGASystimeSyncLastAsicSystime = haldls::vx::FPGASystimeSyncLastAsicSystime

using FPGASystimeSyncLastRTT = haldls::vx::FPGASystimeSyncLastRTT

using FPGASystimeSyncNumRetries = haldls::vx::FPGASystimeSyncNumRetries

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 InstructionTimeoutConfig = haldls::vx::InstructionTimeoutConfig

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

typedef haldls::vx::NeuronBackendConfig<halco::hicann_dls::vx::v3::Coordinates> NeuronBackendConfig

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 SpikeIOConfig = haldls::vx::SpikeIOConfig

using SpikeIOInputRoute = haldls::vx::SpikeIOInputRoute

using SpikeIOOutputRoute = haldls::vx::SpikeIOOutputRoute

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 SystimeCorrectionBarrierConfig = haldls::vx::SystimeCorrectionBarrierConfig

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

std::ostream &operator<<(std::ostream&, NeuronConfig::ReadoutSource const&)

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<# 34 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTM2MTI.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 haldls::vx::v4

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

using CapMemBlock = haldls::vx::CapMemBlock<halco::hicann_dls::vx::v4::Coordinates>

using CapMemBlockConfig = haldls::vx::CapMemBlockConfig<halco::hicann_dls::vx::v4::Coordinates>

using CapMemCell = haldls::vx::CapMemCell<halco::hicann_dls::vx::v4::Coordinates>

using CapMemSRAMTimingConfig = haldls::vx::CapMemSRAMTimingConfig

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 ExternalPPUDRAMMemoryByte = haldls::vx::ExternalPPUDRAMMemoryByte

using ExternalPPUDRAMMemoryQuad = haldls::vx::ExternalPPUDRAMMemoryQuad

using ExternalPPUMemoryByte = haldls::vx::ExternalPPUMemoryByte

using ExternalPPUMemoryQuad = haldls::vx::ExternalPPUMemoryQuad

using FPGADeviceDNA = haldls::vx::FPGADeviceDNA

using FPGASystimeSyncActiveState = haldls::vx::FPGASystimeSyncActiveState

using FPGASystimeSyncLastAsicSystime = haldls::vx::FPGASystimeSyncLastAsicSystime

using FPGASystimeSyncLastRTT = haldls::vx::FPGASystimeSyncLastRTT

using FPGASystimeSyncNumRetries = haldls::vx::FPGASystimeSyncNumRetries

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 InstructionTimeoutConfig = haldls::vx::InstructionTimeoutConfig

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

typedef haldls::vx::NeuronBackendConfig<halco::hicann_dls::vx::v4::Coordinates> NeuronBackendConfig

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

using PPUMemory = haldls::vx::PPUMemory

using PPUMemoryBlock = haldls::vx::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 SpikeIOConfig = haldls::vx::SpikeIOConfig

using SpikeIOInputRoute = haldls::vx::SpikeIOInputRoute

using SpikeIOOutputRoute = haldls::vx::SpikeIOOutputRoute

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 SystimeCorrectionBarrierConfig = haldls::vx::SystimeCorrectionBarrierConfig

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

std::ostream &operator<<(std::ostream&, NeuronConfig::ReadoutSource const&)

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

constexpr uint32_t global_merger_matrix_base_address   = {pll_base_address + 0x0002'0000}

constexpr uint32_t global_merger_matrix_input_config_to_crossbar_base_address = {neuron_label_to_gl1_index_lut_entry_base_address + 8 * 64}

constexpr uint32_t global_merger_matrix_input_drop_counter_base_address = {global_merger_matrix_input_config_to_crossbar_base_address + 4}

constexpr uint32_t global_merger_matrix_node_base_address = {global_merger_matrix_base_address + 1}

constexpr uint32_t global_merger_matrix_out_mux_base_address = {global_merger_matrix_base_address}

constexpr uint32_t global_merger_matrix_output_event_counter_base_address = {global_merger_matrix_input_drop_counter_base_address + 4}

constexpr uint32_t neuron_label_to_gl1_index_lut_entry_base_address = {global_merger_matrix_node_base_address + 54 * 2}

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::v4::detail

Typedefs

hate::type_list<# 34 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTM2MTI.x/haldls/include/haldls/vx/v4/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::v3

Typedefs

using DACChannelBlock = lola::vx::DACChannelBlock

using DACControlBlock = lola::vx::DACControlBlock

typedef lola::vx::ExternalPPUDRAMMemoryBlock ExternalPPUDRAMMemoryBlock

typedef lola::vx::ExternalPPUMemoryBlock ExternalPPUMemoryBlock

namespace std

STL namespace.

namespace T

file expand_word.h

#include <>

#include <>

Defines

EXPAND_WORD(x)

WORD_ORDER_IDENTITY(r, data, elem)

file has_local_data.h

#include <>

#include <>

file is_leaf_node.h

#include <>

#include <>

file block_until.h

#include “haldls/vx/encodable.h”

#include “haldls/vx/genpybind.h”

#include “”

#include <>

file container.h

#include “”

#include “haldls/vx/encodable.h”

#include “haldls/vx/genpybind.h”

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

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 “”

file container.h

#include “haldls/vx/v4/arq.h”

#include “haldls/vx/v4/background.h”

#include “haldls/vx/v4/block.h”

#include “haldls/vx/v4/cadc.h”

#include “haldls/vx/v4/capmem.h”

#include “haldls/vx/v4/correlation.h”

#include “haldls/vx/v4/current_dac.h”

#include “haldls/vx/v4/event.h”

#include “haldls/vx/v4/fpga.h”

#include “haldls/vx/v4/global_merger_matrix.h”

#include “haldls/vx/v4/i2c.h”

#include “haldls/vx/v4/jtag.h”

#include “haldls/vx/v4/madc.h”

#include “haldls/vx/v4/neuron.h”

#include “haldls/vx/v4/null_payload_readable.h”

#include “haldls/vx/v4/padi.h”

#include “haldls/vx/v4/perftest.h”

#include “haldls/vx/v4/phy.h”

#include “haldls/vx/v4/pll.h”

#include “haldls/vx/v4/ppu.h”

#include “haldls/vx/v4/readout.h”

#include “haldls/vx/v4/reset.h”

#include “haldls/vx/v4/routing_crossbar.h”

#include “haldls/vx/v4/spi.h”

#include “haldls/vx/v4/sram_controller.h”

#include “haldls/vx/v4/synapse.h”

#include “haldls/vx/v4/synapse_driver.h”

#include “haldls/vx/v4/systime.h”

#include “haldls/vx/v4/timer.h”

#include “haldls/vx/v4/vector_generator.h”

#include “haldls/vx/genpybind.h”

#include “”

file coordinate_to_container.h

#include <>

file encodable.h

#include “”

#include “haldls/vx/genpybind.h”

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

file genpybind.h

#include <genpybind.h>

Defines

GENPYBIND_MODULE

GENPYBIND_TAG_HALDLS_VX

GENPYBIND_TAG_HALDLS_VX_V3

GENPYBIND_TAG_HALDLS_VX_V4

file is_read_and_writable.h

#include “”

#include “”

#include “haldls/vx/traits.h”

#include “”

#include <>

#include <>

file is_readable.h

#include “”

#include “”

file is_writeable.h

#include <>

#include <>

#include “”

file is_writereadable.h

#include “haldls/vx/is_readable.h”

#include “haldls/vx/is_writeable.h”

file madc.h

#include <>

#include <>

#include “”

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/pll.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 pickle.h

#include “”

#include “”

#include <>

#include <>

#include <>

file arq.h

#include <>

#include <>

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 <>

#include <>

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include <>

#include “”

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 <>

#include “”

#include “haldls/vx/block_until.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 <>

#include <>

#include “”

#include “”

#include “”

#include “haldls/vx/block_until.h”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include <>

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 “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/sram_controller.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

#include “”

file cadc.h

#include “”

#include “haldls/vx/cadc.h”

#include “haldls/vx/genpybind.h”

file cadc.h

#include “”

#include “haldls/vx/cadc.h”

#include “haldls/vx/genpybind.h”

file capmem.h

#include <>

#include <>

#include <>

#include <>

#include <>

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/common.h”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/sram_controller.h”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include “”

#include <>

#include “”

Defines

CAPMEM_EXTERN_TEMPLATE(Coordinates)

CAPMEM_HALCO_GEOMETRY_HASH(Coordinates)

file capmem.h

#include “”

#include “”

#include “haldls/vx/capmem.h”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include <>

file capmem.h

#include “”

#include “”

#include “haldls/vx/capmem.h”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include <>

file common.h

#include “”

#include <>

#include <>

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 correlation.h

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include <>

file correlation.h

#include “haldls/vx/correlation.h”

#include “haldls/vx/genpybind.h”

file correlation.h

#include “haldls/vx/correlation.h”

#include “haldls/vx/genpybind.h”

file current_dac.h

#include <>

#include <>

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 “”

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/container.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 “”

#include <>

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 <>

#include <>

#include “”

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/common.h”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/timer.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 global_merger_matrix.h

#include <>

#include <>

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include <>

#include “”

file haldls.h

#include “haldls/vx/v3/barrier.h”

#include “haldls/vx/v3/constants.h”

#include “haldls/vx/v3/container.h”

file haldls.h

#include “haldls/vx/v4/barrier.h”

#include “haldls/vx/v4/constants.h”

#include “haldls/vx/v4/container.h”

file i2c.h

#include <>

#include <>

#include <>

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include “”

#include <>

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 jtag.h

#include <>

#include <>

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 neuron.h

#include <>

#include <>

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/sram_controller.h”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include <>

Defines

NEURON_EXTERN_TEMPLATE(Coordinates)

file neuron.h

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/neuron.h”

#include <>

file neuron.h

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/neuron.h”

#include <>

file null_payload_readable.h

#include <>

#include <>

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 <>

#include “”

file omnibus_constants.h

#include <>

#include “”

file omnibus_constants.h

#include <>

#include “”

file padi.h

#include <>

#include <>

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/synapse.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

#include “”

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 <>

#include <>

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 <>

#include <>

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 pll.h

#include <>

#include <>

#include “”

#include “”

#include “”

#include “haldls/vx/constants.h”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

file pll.h

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/pll.h”

file pll.h

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/pll.h”

file ppu.h

#include <>

#include <>

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/common.h”

#include “haldls/vx/container.h”

#include “haldls/vx/coordinate_to_container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include <>

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 pyhaldls.h

#include <>

#include <>

#include “”

#include “”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/pickle.h”

#include “haldls/vx/v3/barrier.h”

#include “haldls/vx/v3/haldls.h”

#include “”

#include <>

#include “”

Defines

PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

file pyhaldls.h

#include <>

#include <>

#include “”

#include “”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/pickle.h”

#include “haldls/vx/v4/barrier.h”

#include “haldls/vx/v4/haldls.h”

#include “”

#include <>

#include “”

Defines

PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

file readout.h

#include <>

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 <>

#include <>

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 <>

#include <>

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include <>

#include “”

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 <>

#include <>

#include “”

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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/vx/common.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include <>

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 <>

#include <>

#include “”

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/common.h”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

#include “”

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 <>

#include <>

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/sram_controller.h”

#include “haldls/vx/synapse_driver.h”

#include “haldls/vx/traits.h”

#include “”

#include “”

#include <>

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 <>

#include <>

#include “”

#include “haldls/vx/common.h”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 <>

#include <>

#include “”

#include “”

#include “”

#include “haldls/vx/block_until.h”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

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 “”

#include “haldls/vx/genpybind.h”

#include “”

#include “”

#include <>

#include <>

#include <>

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 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 <>

#include <>

#include “”

#include “”

#include “”

#include “”

#include “haldls/vx/container.h”

#include “haldls/vx/genpybind.h”

#include “haldls/vx/padi.h”

#include “haldls/vx/traits.h”

#include “”

#include <>

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTM2MTI.x/haldls

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTM2MTI.x/haldls/include/haldls

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTM2MTI.x/haldls/include

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTM2MTI.x/haldls/include/haldls/vx/v3

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTM2MTI.x/haldls/include/haldls/vx/v4

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTM2MTI.x/haldls/include/haldls/vx