API Reference: fisch¶

class fisch::vx::Barrier¶

#include <barrier.h>

Container for sync operation.

Public Types

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

typedef word_access_type::Barrier Value¶

Public Functions

explicit Barrier(Value value = Value())¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get value.

Returns: Barrier value

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

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

void set(Value value)¶

Set value.

Parameters: value – Barrier value to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_value¶

Friends

friend class cereal::access

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

struct fisch::vx::word_access_type::Barrier : public halco::common::detail::RantWrapper<Barrier, uint_fast32_t, 0x7, 0>¶

#include <barrier.h>

Public Functions

inline explicit constexpr Barrier(uintmax_t const value = 0x7)¶

Public Static Attributes

static const Barrier jtag¶

static const Barrier omnibus¶

static const Barrier systime¶

struct fisch::vx::MADCSampleFromChip::Channel : public halco::common::detail::RantWrapper<Channel, uint8_t, 0x1, 0>¶

#include <event.h>

Channel selected on active multiplexer from which the sampled value was obtained.

Given as a ReadoutSourceSelection coordinate.

Public Functions

inline explicit constexpr Channel(uintmax_t const val = 0)¶

struct fisch::vx::ChipTime : public halco::common::detail::RantWrapper<ChipTime, uint64_t, 0x7ffffffffff, 0>¶

#include <chip_time.h>

Systime type for chip annotated times.

Public Functions

inline explicit constexpr ChipTime(uintmax_t const value = 0)¶

template<class ContainerT> class fisch::vx::ContainerTicket¶

#include <container_ticket.h>

Read-ticket for multiple containers.

tparam ContainerT: Container type of corresponding data

Public Types

typedef ContainerT container_type¶

Public Functions

ContainerTicket(ContainerTicket &&other) = default¶

ContainerTicket(ContainerTicket const &other) = default¶

FPGATime fpga_time() const¶

Get FPGA executor timestamp of last container response if time annotation is enabled.

If time annotation is not enabled, get message count since last time annotation or from the beginning of the response stream.

Returns: FPGATime value

std::vector<ContainerT> get() const¶

Get data of containers.

Returns: Containers filled with decoded data from playback program results

ContainerTicket &operator=(ContainerTicket &&other) = default¶

ContainerTicket &operator=(ContainerTicket const &other) = default¶

bool valid() const¶

Check whether ticket data is already available.

Returns: Boolean value

Private Functions

ContainerTicket(size_t container_count, std::shared_ptr<detail::ContainerTicketStorage<ContainerT>> storage)¶

Private Members

size_t m_container_count¶

std::shared_ptr<detail::ContainerTicketStorage<ContainerT>> m_storage¶

Friends

friend class PlaybackProgramBuilder

template<typename ContainerT> class fisch::vx::detail::ContainerTicketStorage¶

#include <container_ticket.h>

Public Types

typedef ContainerT container_type¶

Public Members

std::shared_ptr<PlaybackProgram const> m_pbp¶

size_t m_pos¶

template<typename CoordinateT> struct fisch::vx::detail::coordinate_type_to_container_type¶

#include <playback_program_builder.h>

Given a coordinate type, resolves the corresponding unique container type.

tparam CoordinateT: Coordinate type to resolve container type for

Public Types

typedef hate::index_type_list_by_integer<hate::index_type_list_by_type<CoordinateT, coordinate_list>::value, container_list>::type type¶

template<typename CoordinateT> struct fisch::vx::detail::coordinate_type_to_container_type<std::vector<CoordinateT>>¶

#include <playback_program_builder.h>

Specialization for vector<coordinate>.

The struct has to resolve a container type for vector<coordinate>, because it is always evaluated, even if the fully specified read function signature does not match.

Public Types

typedef void type¶

template<typename F> struct DecodeMessageType¶

template<typename C, typename M> struct fisch::vx::detail::DecodeMessageType<void (C::*)(M const&)>¶

#include <decode.h>

Public Types

typedef SubRangeValueType<M>::type::value_type type¶

template<typename C, typename = void> struct fisch::vx::detail::DecodeMessageTypeList¶

#include <decode.h>

Public Types

typedef hate::type_list type¶

template<typename C> struct fisch::vx::detail::DecodeMessageTypeList<C, std::void_t<decltype(&C::decode)>>¶

#include <decode.h>

Public Types

typedef hate::type_list<typename DecodeMessageType<decltype(&C::decode)>::type> type¶

struct fisch::vx::FPGATime : public halco::common::detail::RantWrapper<FPGATime, uint64_t, 0x7ffffffffff, 0>¶

#include <fpga_time.h>

Systime type for FPGA executor times.

Public Functions

inline explicit constexpr FPGATime(uintmax_t const value = 0)¶

template<typename T, typename = void> struct HasPositiveDecodeUTMessageCount : public std::false_type¶: #include <traits.h>

template<typename T> struct fisch::vx::detail::HasPositiveDecodeUTMessageCount<T, typename boost::enable_if_has_type<decltype(T::decode_ut_message_count)>::type>¶

#include <traits.h>

Public Static Attributes

static constexpr static bool value = (T::decode_ut_message_count > 0)

template<typename T, typename = void> struct HasPositiveEncodeReadUTMessageCount : public std::false_type¶: #include <traits.h>

template<typename T> struct fisch::vx::detail::HasPositiveEncodeReadUTMessageCount<T, typename boost::enable_if_has_type<decltype(T::encode_read_ut_message_count)>::type>¶

#include <traits.h>

Public Static Attributes

static constexpr static bool value = (T::encode_read_ut_message_count > 0)

template<typename T, typename = void> struct HasPositiveEncodeWriteUTMessageCount : public std::false_type¶: #include <traits.h>

template<typename T> struct fisch::vx::detail::HasPositiveEncodeWriteUTMessageCount<T, typename boost::enable_if_has_type<decltype(T::encode_write_ut_message_count)>::type>¶

#include <traits.h>

Public Static Attributes

static constexpr static bool value = (T::encode_write_ut_message_count > 0)

template<typename T, typename = void> struct HasValue : public std::false_type¶: #include <traits.h>

template<typename T> struct HasValue<T, typename boost::enable_if_has_type<typename T::Value>::type> : public std::true_type¶: #include <traits.h>

class fisch::vx::HighspeedLinkNotification¶

#include <event.h>

Notification from the FPGA-chip link.

Public Functions

inline explicit HighspeedLinkNotification(Value const &value = Value(), FPGATime const &fpga_time = FPGATime())¶

Construct FPGA-chip link notification from a value and a FPGA time.

Parameters

value – Value to store
fpga_time – FPGATime time annotation

FPGATime get_fpga_time() const¶

Get FPGA time annotation.

Returns: FPGATime time annotation

Value get_value() const¶

Get value data.

Returns: Value data

bool operator!=(HighspeedLinkNotification const &other) const¶

bool operator==(HighspeedLinkNotification const &other) const¶

void set_fpga_time(FPGATime const &value)¶

Set FPGA time annotation.

Parameters: value – FPGATime time annotation

void set_value(Value const &value)¶

Get value data.

Parameters: value – Value data

Private Functions

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

Private Members

FPGATime m_fpga_time¶

Value m_value¶

Friends

friend class cereal::access

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

class fisch::vx::I2CAD5252RwRegister : public fisch::vx::I2CRwRegister<I2CAD5252RwRegister, I2CAD5252RwRegisterValue, halco::hicann_dls::vx::I2CAD5252RwRegisterOnBoard>¶

#include <i2c.h>

Container for accessing a read-write register of a AD5252 digital potentiometer channel.

Public Types

typedef CoordinateType coordinate_type¶

typedef I2CAD5252RwRegisterValue Value¶

Public Functions

inline explicit I2CAD5252RwRegister()¶: Construct an instance with a default value.

inline explicit I2CAD5252RwRegister(Value value)¶

Construct an instance with a word value.

Parameters: value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(halco::hicann_dls::vx::I2CAD5252RwRegisterOnBoard const &coord) const¶

Value get() const¶

Get value.

Returns: I2C register value

bool operator!=(Derived const &other) const¶

bool operator==(Derived const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – I2C register value to set

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

static halco::hicann_dls::vx::OmnibusAddress get_base_address(coordinate_type const&)¶

static uint8_t get_register_address(coordinate_type const&)¶

Public Static Attributes

static constexpr size_t decode_ut_message_count = register_size_bytes ¶

static constexpr size_t encode_read_ut_message_count = 2 + register_size_bytes ¶

static constexpr size_t encode_write_ut_message_count¶

static constexpr size_t register_size_bytes = hate::math::round_up_integer_division(hate::math::num_bits(Value::max), 8)¶

Protected Attributes

Value m_data¶

Private Functions

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

Friends

friend class cereal::access

struct fisch::vx::word_access_type::I2CAD5252RwRegister : public halco::common::detail::RantWrapper<I2CAD5252RwRegister, uint_fast16_t, std::numeric_limits<uint8_t>::max(), std::numeric_limits<uint8_t>::min()>¶

#include <i2c.h>

Public Functions

inline explicit constexpr I2CAD5252RwRegister(uintmax_t const val = 0)¶

class fisch::vx::I2CDAC6573RwRegister : public fisch::vx::I2CRwRegister<I2CDAC6573RwRegister, I2CDAC6573RwRegisterValue, halco::hicann_dls::vx::I2CDAC6573RwRegisterOnBoard>¶

#include <i2c.h>

Container for accessing a read-write register of a DAC6573.

Public Types

typedef CoordinateType coordinate_type¶

typedef I2CDAC6573RwRegisterValue Value¶

Public Functions

inline explicit I2CDAC6573RwRegister()¶: Construct an instance with a default value.

inline explicit I2CDAC6573RwRegister(Value value)¶

Construct an instance with a word value.

Parameters: value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(halco::hicann_dls::vx::I2CDAC6573RwRegisterOnBoard const &coord) const¶

Value get() const¶

Get value.

Returns: I2C register value

bool operator!=(Derived const &other) const¶

bool operator==(Derived const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – I2C register value to set

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

static halco::hicann_dls::vx::OmnibusAddress get_base_address(coordinate_type const&)¶

static uint8_t get_register_address(coordinate_type const&)¶

Public Static Attributes

static constexpr size_t decode_ut_message_count = register_size_bytes ¶

static constexpr size_t encode_read_ut_message_count = 2 + register_size_bytes ¶

static constexpr size_t encode_write_ut_message_count¶

static constexpr size_t register_size_bytes = hate::math::round_up_integer_division(hate::math::num_bits(Value::max), 8)¶

Protected Attributes

Value m_data¶

Private Functions

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

Friends

friend class cereal::access

struct fisch::vx::word_access_type::I2CDAC6573RwRegister : public halco::common::detail::RantWrapper<I2CDAC6573RwRegister, uint_fast16_t, fisch::vx::dac6573_value_max, fisch::vx::dac_value_min>¶

#include <i2c.h>

Public Functions

inline explicit constexpr I2CDAC6573RwRegister(uintmax_t const val = 0)¶

class fisch::vx::I2CIdRegister : public fisch::vx::I2CRoRegister<I2CIdRegister, I2CIdRegisterValue, halco::hicann_dls::vx::I2CIdRegisterOnBoard>¶

#include <i2c.h>

Container for reading the unique ID of the chip carrier board’s EEPROM.

Public Types

typedef halco::hicann_dls::vx::I2CIdRegisterOnBoard coordinate_type¶

typedef I2CIdRegisterValue Value¶

Public Functions

inline explicit I2CIdRegister()¶: Construct an instance with a default value.

inline explicit I2CIdRegister(Value value)¶

Construct an instance with a word value.

Parameters: value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get value.

Returns: I2C register value

bool operator!=(I2CIdRegister const &other) const¶

bool operator==(I2CIdRegister const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – I2C register value to set

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

static halco::hicann_dls::vx::OmnibusAddress get_base_address(coordinate_type const&)¶

static uint8_t get_register_address(coordinate_type const&)¶

Public Static Attributes

static constexpr size_t decode_ut_message_count¶

static constexpr size_t encode_read_ut_message_count¶

static constexpr size_t encode_write_ut_message_count¶

static constexpr size_t register_size_bytes¶

Protected Attributes

Value m_data¶

Private Functions

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

Friends

friend class cereal::access

struct fisch::vx::word_access_type::I2CIdRegister : public halco::common::detail::RantWrapper<I2CIdRegister, uint_fast32_t, std::numeric_limits<uint32_t>::max(), std::numeric_limits<uint32_t>::min()>¶

#include <i2c.h>

Public Functions

inline explicit constexpr I2CIdRegister(uintmax_t const val = 0)¶

class fisch::vx::I2CINA219RoRegister : public fisch::vx::I2CRoRegister<I2CINA219RoRegister, I2CINA219RoRegisterValue, halco::hicann_dls::vx::I2CINA219RoRegisterOnBoard>¶

#include <i2c.h>

Container for reading a read-only register of a INA219 voltage/current/power measurement device.

Public Types

typedef halco::hicann_dls::vx::I2CINA219RoRegisterOnBoard coordinate_type¶

typedef I2CINA219RoRegisterValue Value¶

Public Functions

inline explicit I2CINA219RoRegister()¶: Construct an instance with a default value.

inline explicit I2CINA219RoRegister(Value value)¶

Construct an instance with a word value.

Parameters: value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get value.

Returns: I2C register value

bool operator!=(I2CINA219RoRegister const &other) const¶

bool operator==(I2CINA219RoRegister const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – I2C register value to set

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

static halco::hicann_dls::vx::OmnibusAddress get_base_address(coordinate_type const&)¶

static uint8_t get_register_address(coordinate_type const&)¶

Public Static Attributes

static constexpr size_t decode_ut_message_count¶

static constexpr size_t encode_read_ut_message_count¶

static constexpr size_t encode_write_ut_message_count¶

static constexpr size_t register_size_bytes¶

Protected Attributes

Value m_data¶

Private Functions

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

Friends

friend class cereal::access

struct fisch::vx::word_access_type::I2CINA219RoRegister : public halco::common::detail::RantWrapper<I2CINA219RoRegister, uint_fast16_t, std::numeric_limits<uint16_t>::max(), std::numeric_limits<uint16_t>::min()>¶

#include <i2c.h>

Public Functions

inline explicit constexpr I2CINA219RoRegister(uintmax_t const val = 0)¶

class fisch::vx::I2CINA219RwRegister : public fisch::vx::I2CRwRegister<I2CINA219RwRegister, I2CINA219RwRegisterValue, halco::hicann_dls::vx::I2CINA219RwRegisterOnBoard>¶

#include <i2c.h>

Container for accessing a read-write register of a INA219 voltage/current/power measurement device.

Public Types

typedef CoordinateType coordinate_type¶

typedef I2CINA219RwRegisterValue Value¶

Public Functions

inline explicit I2CINA219RwRegister()¶: Construct an instance with a default value.

inline explicit I2CINA219RwRegister(Value value)¶

Construct an instance with a word value.

Parameters: value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(halco::hicann_dls::vx::I2CINA219RwRegisterOnBoard const &coord) const¶

Value get() const¶

Get value.

Returns: I2C register value

bool operator!=(Derived const &other) const¶

bool operator==(Derived const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – I2C register value to set

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

static halco::hicann_dls::vx::OmnibusAddress get_base_address(coordinate_type const&)¶

static uint8_t get_register_address(coordinate_type const&)¶

Public Static Attributes

static constexpr size_t decode_ut_message_count = register_size_bytes ¶

static constexpr size_t encode_read_ut_message_count = 2 + register_size_bytes ¶

static constexpr size_t encode_write_ut_message_count¶

static constexpr size_t register_size_bytes = hate::math::round_up_integer_division(hate::math::num_bits(Value::max), 8)¶

Protected Attributes

Value m_data¶

Private Functions

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

Friends

friend class cereal::access

struct fisch::vx::word_access_type::I2CINA219RwRegister : public halco::common::detail::RantWrapper<I2CINA219RwRegister, uint_fast16_t, std::numeric_limits<uint16_t>::max(), std::numeric_limits<uint16_t>::min()>¶

#include <i2c.h>

Public Functions

inline explicit constexpr I2CINA219RwRegister(uintmax_t const val = 0)¶

template<typename Derived, typename ValueType, typename CoordinateType> class fisch::vx::I2CRoRegister¶

#include <i2c.h>

General implementation of an I2C read-only register.

Its length is determined by the ValueType

Subclassed by fisch::vx::I2CRwRegister< I2CINA219RwRegister, I2CINA219RwRegisterValue, halco::hicann_dls::vx::I2CINA219RwRegisterOnBoard >, fisch::vx::I2CRwRegister< I2CAD5252RwRegister, I2CAD5252RwRegisterValue, halco::hicann_dls::vx::I2CAD5252RwRegisterOnBoard >, fisch::vx::I2CRwRegister< I2CDAC6573RwRegister, I2CDAC6573RwRegisterValue, halco::hicann_dls::vx::I2CDAC6573RwRegisterOnBoard >, fisch::vx::I2CRwRegister< I2CTCA9554RwRegister, I2CTCA9554RwRegisterValue, halco::hicann_dls::vx::I2CTCA9554RwRegisterOnBoard >, fisch::vx::I2CRwRegister< Derived, ValueType, CoordinateType >

Public Types

typedef CoordinateType coordinate_type¶

typedef ValueType Value¶

Public Functions

inline explicit I2CRoRegister()¶

inline explicit I2CRoRegister(I2CRoRegister<Derived, ValueType, CoordinateType>::Value value)¶

void decode(UTMessageFromFPGARangeOmnibus const &messages)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get value.

Returns: I2C register value

bool operator!=(Derived const &other) const¶

bool operator==(Derived const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – I2C register value to set

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

Public Static Attributes

static constexpr size_t decode_ut_message_count = register_size_bytes ¶

static constexpr size_t encode_read_ut_message_count = 2 + register_size_bytes ¶

static constexpr size_t encode_write_ut_message_count = 0¶

static constexpr size_t register_size_bytes = hate::math::round_up_integer_division(hate::math::num_bits(Value::max), 8)¶

Protected Attributes

Value m_data¶

Private Functions

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

Friends

friend class cereal::access

inline friend std::ostream &operator<<(std::ostream &os, Derived const &word)¶

template<typename Derived, typename ValueType, typename CoordinateType> class fisch::vx::I2CRwRegister : public fisch::vx::I2CRoRegister<Derived, ValueType, CoordinateType>¶

#include <i2c.h>

General implementation of an I2C read-write register.

Its length is determined by the ValueType.

Public Types

typedef CoordinateType coordinate_type¶

typedef ValueType Value¶

Public Functions

inline explicit I2CRwRegister()¶

inline explicit I2CRwRegister(Value value)¶

void decode(UTMessageFromFPGARangeOmnibus const &messages)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(CoordinateType const &coord) const¶

Value get() const¶

Get value.

Returns: I2C register value

bool operator!=(Derived const &other) const¶

bool operator==(Derived const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – I2C register value to set

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

Public Static Attributes

static constexpr size_t decode_ut_message_count = register_size_bytes ¶

static constexpr size_t encode_read_ut_message_count = 2 + register_size_bytes ¶

static constexpr size_t encode_write_ut_message_count = 2 + 2 * I2CRoRegister<Derived, ValueType, CoordinateType>::register_size_bytes¶

static constexpr size_t register_size_bytes = hate::math::round_up_integer_division(hate::math::num_bits(Value::max), 8)¶

Protected Attributes

Value m_data¶

class fisch::vx::I2CTCA9554RoRegister : public fisch::vx::I2CRoRegister<I2CTCA9554RoRegister, I2CTCA9554RoRegisterValue, halco::hicann_dls::vx::I2CTCA9554RoRegisterOnBoard>¶

#include <i2c.h>

Container for accessing a read-only I2C register on the TCA9554 IO Expander device.

Public Types

typedef halco::hicann_dls::vx::I2CTCA9554RoRegisterOnBoard coordinate_type¶

typedef I2CTCA9554RoRegisterValue Value¶

Public Functions

inline explicit I2CTCA9554RoRegister()¶: Construct an instance with a default value.

inline explicit I2CTCA9554RoRegister(Value value)¶

Construct an instance with a word value.

Parameters: value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get value.

Returns: I2C register value

bool operator!=(I2CTCA9554RoRegister const &other) const¶

bool operator==(I2CTCA9554RoRegister const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – I2C register value to set

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

static halco::hicann_dls::vx::OmnibusAddress get_base_address(coordinate_type const&)¶

static uint8_t get_register_address(coordinate_type const&)¶

Public Static Attributes

static constexpr size_t decode_ut_message_count¶

static constexpr size_t encode_read_ut_message_count¶

static constexpr size_t encode_write_ut_message_count¶

static constexpr size_t register_size_bytes¶

Protected Attributes

Value m_data¶

Private Functions

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

Friends

friend class cereal::access

struct fisch::vx::word_access_type::I2CTCA9554RoRegister : public halco::common::detail::RantWrapper<I2CTCA9554RoRegister, uint_fast16_t, std::numeric_limits<uint8_t>::max(), std::numeric_limits<uint8_t>::min()>¶

#include <i2c.h>

Public Functions

inline explicit constexpr I2CTCA9554RoRegister(uintmax_t const val = 0)¶

class fisch::vx::I2CTCA9554RwRegister : public fisch::vx::I2CRwRegister<I2CTCA9554RwRegister, I2CTCA9554RwRegisterValue, halco::hicann_dls::vx::I2CTCA9554RwRegisterOnBoard>¶

#include <i2c.h>

Container for accessing a read-write I2C register on the TCA9554 IO Expander device.

Public Types

typedef CoordinateType coordinate_type¶

typedef I2CTCA9554RwRegisterValue Value¶

Public Functions

inline explicit I2CTCA9554RwRegister()¶: Construct an instance with a default value.

inline explicit I2CTCA9554RwRegister(Value value)¶

Construct an instance with a word value.

Parameters: value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(halco::hicann_dls::vx::I2CTCA9554RwRegisterOnBoard const &coord) const¶

Value get() const¶

Get value.

Returns: I2C register value

bool operator!=(Derived const &other) const¶

bool operator==(Derived const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – I2C register value to set

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

static halco::hicann_dls::vx::OmnibusAddress get_base_address(coordinate_type const&)¶

static uint8_t get_register_address(coordinate_type const&)¶

Public Static Attributes

static constexpr size_t decode_ut_message_count = register_size_bytes ¶

static constexpr size_t encode_read_ut_message_count = 2 + register_size_bytes ¶

static constexpr size_t encode_write_ut_message_count¶

static constexpr size_t register_size_bytes = hate::math::round_up_integer_division(hate::math::num_bits(Value::max), 8)¶

Protected Attributes

Value m_data¶

Private Functions

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

Friends

friend class cereal::access

struct fisch::vx::word_access_type::I2CTCA9554RwRegister : public halco::common::detail::RantWrapper<I2CTCA9554RwRegister, uint_fast16_t, std::numeric_limits<uint8_t>::max(), std::numeric_limits<uint8_t>::min()>¶

#include <i2c.h>

Public Functions

inline explicit constexpr I2CTCA9554RwRegister(uintmax_t const val = 0)¶

template<typename T, typename = void> struct IsRangedType : public std::false_type¶: #include <fill.h>

template<typename T> struct IsRangedType<T, typename boost::enable_if_has_type<decltype(T::min)>::type> : public std::true_type¶: #include <fill.h>

template<typename ContainerT> struct fisch::vx::IsReadable¶

#include <traits.h>

Check whether given container is readable.

tparam ContainerT: Type of container

Public Static Attributes

static constexpr static bool value = detail::HasPositiveDecodeUTMessageCount<ContainerT>::value && detail::HasPositiveEncodeReadUTMessageCount<ContainerT>::value

template<typename ContainerT> struct fisch::vx::IsWritable¶

#include <traits.h>

Check whether given container is writable.

tparam ContainerT: Type of container

Public Static Attributes

static constexpr static bool value = detail::HasPositiveEncodeWriteUTMessageCount<ContainerT>::value

class fisch::vx::JTAGClockScaler¶

#include <jtag.h>

Container writing JTAG clock-scaler value.

Public Types

typedef halco::hicann_dls::vx::JTAGClockScalerOnDLS coordinate_type¶

typedef word_access_type::JTAGClockScaler Value¶

Clock-scaler value type.

The JTAG clock scales with 1 / (value + 2).

Public Functions

explicit JTAGClockScaler(Value value = Value())¶

Construct scaler with value.

Parameters: value – Value to construct scaler with

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get clock-scaler value.

Returns: Clock-scaler value

bool operator!=(JTAGClockScaler const &other) const¶

bool operator==(JTAGClockScaler const &other) const¶

void set(Value value)¶

Set clock-scaler value.

Parameters: value – Clock-scaler value to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_value¶

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, JTAGClockScaler const &scaler)¶

struct fisch::vx::word_access_type::JTAGClockScaler : public halco::common::detail::RantWrapper<JTAGClockScaler, uint_fast16_t, jtag_clock_scaler_max, jtag_clock_scaler_min>¶

#include <jtag.h>

Public Functions

inline explicit constexpr JTAGClockScaler(uintmax_t const value = 0)¶

class fisch::vx::JTAGIdCode¶

#include <jtag.h>

Container for reading the JTAG IDCODE.

Public Types

typedef halco::hicann_dls::vx::JTAGIdCodeOnDLS coordinate_type¶

typedef word_access_type::JTAGIdCode Value¶: JTAG IDCODE value type.

Public Functions

explicit JTAGIdCode(Value value = Value())¶

Construct IDCODE with value.

Parameters: value – Value to use

void decode(UTMessageFromFPGARangeJTAG const &messages)¶

Value get() const¶

Get JTAG IDCODE.

Returns: Value

bool operator!=(JTAGIdCode const &other) const¶

bool operator==(JTAGIdCode const &other) const¶

void set(Value value)¶

Set JTAG IDCODE.

Parameters: value – Value

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

Public Static Attributes

static constexpr static size_t decode_ut_message_count = 1

static constexpr static size_t encode_read_ut_message_count = 2

Private Functions

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

Private Members

Value m_value¶

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, JTAGIdCode const &id)¶

struct fisch::vx::word_access_type::JTAGIdCode : public halco::common::detail::BaseType<JTAGIdCode, uint32_t>¶

#include <jtag.h>

Public Functions

inline explicit constexpr JTAGIdCode(value_type const value = 0)¶

class fisch::vx::JTAGPhyRegister¶

#include <jtag.h>

Container writing Phy configuration on the Chip.

Public Types

typedef halco::hicann_dls::vx::JTAGPhyRegisterOnDLS coordinate_type¶

typedef word_access_type::JTAGPhyRegister Value¶: Register value type.

Public Functions

explicit JTAGPhyRegister(Value value = Value())¶

Construct register with value.

Parameters: value – Value to construct register with

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get register value.

Returns: Register value

bool operator!=(JTAGPhyRegister const &other) const¶

bool operator==(JTAGPhyRegister const &other) const¶

void set(Value value)¶

Set register value.

Parameters: value – Register value to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 2

Private Functions

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

Private Members

Value m_value¶

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, JTAGPhyRegister const &reg)¶

struct fisch::vx::word_access_type::JTAGPhyRegister : public halco::common::detail::RantWrapper<JTAGPhyRegister, uint_fast16_t, 4194303, 0>¶

#include <jtag.h>

Public Functions

inline explicit constexpr JTAGPhyRegister(uintmax_t const value = 0)¶

class fisch::vx::JTAGPLLRegister¶

#include <jtag.h>

Container for writing a PLL register.

Writing this container does not lead to an update in the registerfile of omnibus access to the same PLL configuration. Data written with this container can therefore never be read out again.

Public Types

typedef halco::hicann_dls::vx::JTAGPLLRegisterOnDLS coordinate_type¶

typedef word_access_type::JTAGPLLRegister Value¶: PLL register value type.

Public Functions

explicit JTAGPLLRegister(Value value = Value())¶

Construct register by its value.

Parameters: value – Value to set on cosntruction

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get register value.

Returns: Value to get

bool operator!=(JTAGPLLRegister const &other) const¶

bool operator==(JTAGPLLRegister const &other) const¶

void set(Value value)¶

Set register value.

Parameters: value – Value to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 4

Private Functions

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

Private Members

Value m_value¶

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, JTAGPLLRegister const &reg)¶

struct fisch::vx::word_access_type::JTAGPLLRegister : public halco::common::detail::BaseType<JTAGPLLRegister, uint32_t>¶

#include <jtag.h>

Public Functions

inline explicit constexpr JTAGPLLRegister(value_type const value = 0)¶

class fisch::vx::MADCSampleFromChip¶

#include <event.h>

MADC sample from chip event comprised of MADCSampleFromChip data and FPGATime time annotation.

Serves as value type for MADC samples accessible on a PlaybackProgram.

Public Functions

inline explicit MADCSampleFromChip(Value const &value = Value(), Channel const &channel = Channel(), ChipTime const &chip_time = ChipTime(), FPGATime const &fpga_time = FPGATime())¶

Construct MADC sample from chip event from a MADC sample from chip and a FPGA time.

Parameters

value – Sample value
chip_time – ChipTime time annotation
fpga_time – FPGATime time annotation

bool operator!=(MADCSampleFromChip const &other) const¶

bool operator==(MADCSampleFromChip const &other) const¶

Public Members

Channel channel¶: Channel from which this sample was acquired.

ChipTime chip_time¶: Chip time value.

FPGATime fpga_time¶: FPGA time annotation.

Value value¶: Sample value.

Private Functions

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

Friends

friend class cereal::access

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

class fisch::vx::NullPayloadReadable¶

#include <null_payload_readable.h>

Container for reading a payload-free tick.

Public Types

typedef halco::hicann_dls::vx::NullPayloadReadableOnFPGA coordinate_type¶

Public Functions

NullPayloadReadable()¶: Default constructor.

void decode(UTMessageFromFPGARangeLoopback const &messages)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

bool operator!=(NullPayloadReadable const &other) const¶

bool operator==(NullPayloadReadable const &other) const¶

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

Public Static Attributes

static constexpr static size_t decode_ut_message_count = 1

static constexpr static size_t encode_read_ut_message_count = 1

static constexpr static size_t encode_write_ut_message_count = 0

Private Functions

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

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, NullPayloadReadable const &id)¶

struct fisch::vx::word_access_type::NullPayloadReadable¶

#include <null_payload_readable.h>

Public Functions

bool operator!=(NullPayloadReadable const &other) const¶

bool operator==(NullPayloadReadable const &other) const¶

class fisch::vx::Omnibus¶

#include <omnibus.h>

Container for reading and writing an omnibus word.

Public Types

typedef halco::hicann_dls::vx::OmnibusAddress coordinate_type¶

typedef word_access_type::Omnibus Value¶

Public Functions

explicit Omnibus()¶: Default constructor.

explicit Omnibus(Value const &value)¶

Construct an instance with a value.

Parameters: value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value const &get() const¶

Get value.

Returns: Word value

bool operator!=(Omnibus const &other) const¶

bool operator==(Omnibus const &other) const¶

void set(Value const &value)¶

Set value.

Parameters: value – Word value to set

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

Public Static Attributes

static constexpr static size_t decode_ut_message_count = 1

static constexpr static size_t encode_read_ut_message_count = 1

static constexpr static size_t encode_write_ut_message_count = 2

Private Functions

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

Private Members

Value m_data¶

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, Omnibus const &word)¶

struct fisch::vx::word_access_type::Omnibus¶

#include <omnibus.h>

Public Types

typedef std::array<bool, sizeof(Word::value_type)> ByteEnables¶

typedef Word::value_type value_type¶

Public Functions

inline explicit constexpr Omnibus()¶: Default constructor.

inline explicit constexpr Omnibus(Word::value_type const value)¶

Construct an instance with a word value.

Parameters: value – Word value to construct instance with

inline explicit constexpr Omnibus(Word::value_type const value, ByteEnables const &byte_enables)¶

Construct an instance with a word value and byte enables.

Parameters

value – Word value to construct instance with
byte_enables – Byte enables to construct instance with

inline constexpr operator Word::value_type() const¶

bool operator!=(Omnibus const &other) const¶

bool operator==(Omnibus const &other) const¶

Public Members

ByteEnables byte_enables¶

Word word¶

Private Functions

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

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, Omnibus const &value)¶

class fisch::vx::OmnibusChipOverJTAG¶

#include <jtag.h>

Container for reading and writing an omnibus word over JTAG.

Public Types

typedef halco::hicann_dls::vx::OmnibusChipOverJTAGAddress coordinate_type¶

typedef word_access_type::OmnibusChipOverJTAG Value¶

Public Functions

explicit OmnibusChipOverJTAG(Value value = Value())¶

Construct an instance with a word value.

Parameters: value – Omnibus word value to construct instance with

void decode(UTMessageFromFPGARangeJTAG const &messages)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get value.

Returns: Omnibus word value

bool operator!=(OmnibusChipOverJTAG const &other) const¶

bool operator==(OmnibusChipOverJTAG const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – Omnibus word value to set

Public Static Functions

static std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count> encode_read(coordinate_type const &coord)¶

Public Static Attributes

static constexpr static size_t decode_ut_message_count = 1

static constexpr static size_t encode_read_ut_message_count = 6

static constexpr static size_t encode_write_ut_message_count = 6

Private Functions

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

Private Members

Value m_data¶

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, OmnibusChipOverJTAG const &word)¶

struct fisch::vx::word_access_type::OmnibusChipOverJTAG : public halco::common::detail::BaseType<OmnibusChipOverJTAG, uint32_t>¶

#include <jtag.h>

Public Functions

inline explicit constexpr OmnibusChipOverJTAG(value_type const value = 0)¶

class fisch::vx::PlaybackDecoder¶

#include <playback_decoder.h>

Playback decoder decoding a linear stream of UT messages into data response queues.

Public Types

typedef std::vector<HighspeedLinkNotification> highspeed_link_notification_queue_type¶

typedef halco::common::typed_array<size_t, halco::hicann_dls::vx::MADCSamplePackFromFPGAOnDLS> madc_sample_pack_counts_type¶

typedef std::vector<MADCSampleFromChip> madc_sample_queue_type¶

typedef ToResponseQueueTuple<detail::decode_message_types>::type response_queue_type¶

typedef halco::common::typed_array<size_t, halco::hicann_dls::vx::SpikePackFromFPGAOnDLS> spike_pack_counts_type¶

typedef std::vector<SpikeFromChip> spike_queue_type¶

typedef std::vector<TimeoutNotification> timeout_notification_queue_type¶

typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::jtag_from_hicann::Data> ut_message_from_fpga_jtag_type¶

typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::from_fpga_system::Loopback> ut_message_from_fpga_loopback_type¶

typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::omnibus_from_fpga::Data> ut_message_from_fpga_omnibus_type¶

typedef hxcomm::vx::UTMessageFromFPGAVariant ut_message_from_fpga_variant_type¶

Public Functions

PlaybackDecoder(response_queue_type &response_queue, spike_queue_type &spike_queue, madc_sample_queue_type &madc_sample_queue, highspeed_link_notification_queue_type &highspeed_link_notification_queue, spike_pack_counts_type &spike_pack_counts, madc_sample_pack_counts_type &madc_sample_pack_counts, timeout_notification_queue_type &timeout_notification_queue)¶

Construct decoder from JTAG and Omnibus queue references to put messages in.

Parameters

response_queue – Reference to response message queue
spike_queue – Reference to a spike event message queue
madc_sample_queue – Reference to a MADC sample event message queue
highspeed_link_notification_queue – Reference to a highspeed link notification queue
spike_pack_counts – Reference to a spike pack count array
madc_sample_pack_counts – Reference to a MADC sample pack count array

void clear()¶: Clear state leading to FPGA time annotation reset and clearing of all queues and event pack counters.

void operator()(ut_message_from_fpga_variant_type const &message)¶

Process a message.

Parameters: message – UT message variant to process

Private Types

typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::from_fpga_system::HighspeedLinkNotification> ut_message_from_fpga_highspeed_link_notification_type¶

typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::timing_from_fpga::Sysdelta> ut_message_from_fpga_sysdelta_type¶

typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::timing_from_fpga::Systime> ut_message_from_fpga_systime_type¶

typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::from_fpga_system::TimeoutNotification> ut_message_from_fpga_timeout_notification_type¶

Private Functions

ChipTime calculate_chip_time(uint8_t timestamp) const¶

template<size_t N> void process(hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::event_from_fpga::MADCSamplePack<N>> const &message)¶

template<size_t N> void process(hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::event_from_fpga::SpikePack<N>> const &message)¶

void process(ut_message_from_fpga_highspeed_link_notification_type const &message)¶

void process(ut_message_from_fpga_jtag_type const &message)¶

void process(ut_message_from_fpga_loopback_type const &message)¶

void process(ut_message_from_fpga_omnibus_type const &message)¶

void process(ut_message_from_fpga_sysdelta_type const &message)¶

void process(ut_message_from_fpga_systime_type const &message)¶

void process(ut_message_from_fpga_timeout_notification_type const &message)¶

Private Members

highspeed_link_notification_queue_type &m_highspeed_link_notification_queue¶

madc_sample_pack_counts_type &m_madc_sample_pack_counts¶

madc_sample_queue_type &m_madc_sample_queue¶

response_queue_type &m_response_queue¶

spike_pack_counts_type &m_spike_pack_counts¶

spike_queue_type &m_spike_queue¶

FPGATime m_time_current¶

timeout_notification_queue_type &m_timeout_notification_queue¶

class fisch::vx::PlaybackProgram : public std::enable_shared_from_this<PlaybackProgram>¶

#include <playback_program.h>

Playback program.

Public Types

typedef hxcomm::vx::UTMessageFromFPGAVariant from_fpga_message_type¶

typedef std::vector<HighspeedLinkNotification> highspeed_link_notifications_type¶

typedef std::vector<MADCSampleFromChip> madc_sample_from_chip_events_type¶

typedef halco::common::typed_array<size_t, halco::hicann_dls::vx::MADCSamplePackFromFPGAOnDLS> madc_sample_pack_counts_type¶

typedef std::vector<SpikeFromChip> spike_from_chip_events_type¶

typedef halco::common::typed_array<size_t, halco::hicann_dls::vx::SpikePackFromFPGAOnDLS> spike_pack_counts_type¶

typedef hxcomm::vx::UTMessageToFPGAVariant to_fpga_message_type¶

Public Functions

PlaybackProgram()¶: Default constructor.

~PlaybackProgram()¶

void clear_from_fpga_messages()¶: Clear the content of response data queues in order to refill them through a successive execution.

bool empty() const¶

Get whether program is empty, i.e.

no instructions are embodied.

Returns: Boolean value

highspeed_link_notifications_type const &get_highspeed_link_notifications() const¶

Get vector of time-annotated highspeed-link notifications.

Returns: Vector of notifications

madc_sample_from_chip_events_type const &get_madc_samples() const¶

Get vector of time-annotated MADC sample events.

Returns: Vector of sample events

madc_sample_pack_counts_type const &get_madc_samples_pack_counts() const¶

Get number of occurences of MADC sample packing from chip.

Returns: Array of packing occurences

spike_from_chip_events_type const &get_spikes() const¶

Get vector of time-annotated spike events.

Returns: Vector of spike events

spike_pack_counts_type const &get_spikes_pack_counts() const¶

Get number of occurences of spike packing from chip.

Returns: Array of packing occurences

std::vector<to_fpga_message_type> const &get_to_fpga_messages() const¶

Get to FPGA instruction sequence.

Returns: Vector of UT messages

bool operator!=(PlaybackProgram const &other) const¶

bool operator==(PlaybackProgram const &other) const¶

void push_from_fpga_message(from_fpga_message_type const &message)¶

Push a UT message from FPGA into the response decoder.

The message is processed and maybe put into a data response queue.

Parameters: message – UT message to push into the decoder

bool run_ok() const¶

Check if we did not receive fatal error notifications from the FPGA.

Returns: Boolean value (true if ok)

bool tickets_valid() const¶

Check that result data to all tickets is available.

Returns: Boolean value

Private Functions

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

Private Members

std::unique_ptr<detail::PlaybackProgramImpl> m_impl¶

Friends

friend class cereal::access

friend class ContainerTicket

friend std::ostream &operator<<(std::ostream &os, PlaybackProgram const &program)¶

Print instruction UT messages to ostream.

Returns: Altered ostream

friend class PlaybackProgramBuilder

friend class ReinitStackEntry

class fisch::vx::PlaybackProgramBuilder¶

#include <playback_program_builder.h>

Sequential playback program builder.

It allows building a (timed) sequence of logical instructions to be executed on the FPGA. Instructions can be of type write or read and are added to the current end of the instruction sequence. A write is defined as an instruction without deterministic response, whereas a read is defined as instruction with deterministic response expectation which is encapsulated in a ticket accessor to the to-be-acquired response data.

Public Functions

PlaybackProgramBuilder()¶: Default constructor.

void copy_back(PlaybackProgramBuilder const &other)¶

Copy other PlaybackProgramBuilder to the end of this builder instance.

The copied-from builder is untouched during the process.

Throws: std::runtime_error – On other builder not being write only
Parameters: other – Builder to copy to this instance at the back

std::shared_ptr<PlaybackProgram> done()¶

Finish playback program creation and return built program.

Resets the state of the builder.

Returns: Built playback program

bool empty() const¶

Get whether builder is empty, i.e.

no instructions are embodied.

Returns: Boolean value

bool is_write_only() const¶

Get whether program only contains write data.

Returns: Boolean Value

void merge_back(PlaybackProgramBuilder &other)¶

Merge other PlaybackProgramBuilder to the end of this builder instance.

The moved-from builder is emptied during the process.

Parameters: other – Builder to move to this instance at the back

void merge_front(PlaybackProgramBuilder &other)¶

Merge other PlaybackProgramBuilder to the beginning of this builder instance.

The moved-from builder is emptied during the process.

Parameters: other – Builder to move to this instance at the front

template<class CoordinateT> ContainerTicket<typename detail::coordinate_type_to_container_type<CoordinateT>::type> read(CoordinateT const &coord)¶

Add read instruction for container.

Template Parameters: CoordinateT – Coordinate type
Parameters: coord – Container coordinate
Returns: Ticket accessor to response data

template<class CoordinateT> ContainerTicket<typename detail::coordinate_type_to_container_type<CoordinateT>::type> read(std::vector<CoordinateT> const &coords)¶

Add read instruction for multiple containers.

Template Parameters: ContainerT – Container type
Parameters: coords – Container coordinates
Returns: Ticket accessor to response data

size_t size_from_fpga() const¶

Get number of UT messages from FPGA.

Returns: Size

size_t size_to_fpga() const¶

Get number of UT messages to FPGA.

Returns: Size

template<class ContainerT> void write(std::vector<typename ContainerT::coordinate_type> const &coords, std::vector<ContainerT> const &configs)¶

Add write instruction for multiple containers.

Template Parameters

ContainerT – Container type

Parameters

coords – Container coordinates
configs – Container data

template<class ContainerT> void write(typename ContainerT::coordinate_type const &coord, ContainerT const &config)¶

Add write instruction for container.

Template Parameters

ContainerT – Container type

Parameters

coord – Container coordinate
config – Container data

Private Members

std::shared_ptr<PlaybackProgram> m_program¶

Friends

friend std::ostream &operator<<(std::ostream &os, PlaybackProgramBuilder const &builder)¶

Print instruction UT messages added so far to ostream.

Returns: Altered ostream

struct fisch::vx::detail::PlaybackProgramImpl¶

#include <playback_program_impl.h>

Public Functions

PlaybackProgramImpl()¶

bool operator!=(PlaybackProgramImpl const &other) const¶

bool operator==(PlaybackProgramImpl const &other) const¶

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

Public Members

PlaybackDecoder m_decoder¶

PlaybackDecoder::highspeed_link_notification_queue_type m_highspeed_link_notification_response_queue¶

std::vector<hxcomm::vx::UTMessageToFPGAVariant> m_instructions¶

PlaybackDecoder::madc_sample_pack_counts_type m_madc_sample_pack_counts¶

PlaybackDecoder::madc_sample_queue_type m_madc_sample_response_queue¶

std::array<size_t, std::tuple_size<decltype(m_receive_queue)>::value> m_queue_expected_size¶

PlaybackDecoder::response_queue_type m_receive_queue¶

PlaybackDecoder::spike_pack_counts_type m_spike_pack_counts¶

PlaybackDecoder::spike_queue_type m_spike_response_queue¶

mutable std::forward_list< std::variant<# 31 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/fisch/include/fisch/vx/detail/playback_program_impl.h" 2 > > m_tickets

mutable std::mutex m_tickets_mutex¶

PlaybackDecoder::timeout_notification_queue_type m_timeout_notification_response_queue¶

class fisch::vx::PollingOmnibusBlock¶

#include <omnibus.h>

Container for polling block operation on a Omnibus address.

Compare given value from address in FPGA register file masked with expected target result.

Public Types

typedef halco::hicann_dls::vx::PollingOmnibusBlockOnFPGA coordinate_type¶

typedef word_access_type::PollingOmnibusBlock Value¶

Public Functions

PollingOmnibusBlock(Value value = Value(true))¶: Resolve block if value is true (*address & mask == target) or if value is false (*address & mask != target).

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get value.

Returns: Value

bool operator!=(PollingOmnibusBlock const &other) const¶

bool operator==(PollingOmnibusBlock const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – Value to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_value¶

Friends

friend class cereal::access

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

struct fisch::vx::word_access_type::PollingOmnibusBlock : public halco::common::detail::BaseType<PollingOmnibusBlock, bool>¶

#include <omnibus.h>

Public Functions

inline explicit constexpr PollingOmnibusBlock(bool value = false)¶

class fisch::vx::ReinitStackEntry¶

#include <reinit_stack_entry.h>

Public Functions

ReinitStackEntry() = delete¶

template<typename Connection> ReinitStackEntry(Connection &connection)¶

ReinitStackEntry(ReinitStackEntry&&) = default¶

ReinitStackEntry(ReinitStackEntry const&) = delete¶

~ReinitStackEntry()¶

void enforce()¶

void pop()¶

void set(std::shared_ptr<PlaybackProgram> const &pbmem_request, std::optional<std::shared_ptr<PlaybackProgram>> const &pbmem_snapshot = std::nullopt, bool enforce = true)¶

Set and maybe enforce reinit stack entry value.

Parameters

pbmem_request – Playback program to be executed once a reinit is required.
pbmem_snapshot – Playback program to be executed once the exclusive access to the hardware is relinquished. All read commands within this program are translated to writes and replace the pbmem_request for future reinit operations. This is to be used to snapshot (parts of) the current state of the hardware prior to releasing the exclusive access to other users and be able to reapply this state at the next reinit operation without need for client-side synchronisation and transform of the read-out data. Currently only Omnibus read -> write operations are supported.
enforce – Whether to directly apply the pbmem_request or only apply it during the next reinit.

Private Members

std::unique_ptr<Impl> m_impl¶

class fisch::vx::ResetChip¶

#include <reset.h>

Container for writing the chip reset.

Public Types

typedef halco::hicann_dls::vx::ResetChipOnDLS coordinate_type¶

typedef word_access_type::ResetChip Value¶

Public Functions

explicit ResetChip(Value value = Value(false))¶

Construct reset with boolean value.

Parameters: value – Boolean value to set

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get reset value.

Returns: Boolean reset value

bool operator!=(ResetChip const &other) const¶

bool operator==(ResetChip const &other) const¶

void set(Value value)¶

Set reset value.

Parameters: value – Boolean value to set reset to

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_value¶

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, ResetChip const &reset)¶

struct fisch::vx::word_access_type::ResetChip : public halco::common::detail::BaseType<ResetChip, bool>¶

#include <reset.h>

Public Functions

inline explicit constexpr ResetChip(bool value = false)¶

class fisch::vx::ResetJTAGTap¶

#include <jtag.h>

Container for resetting JTAG state-machine.

Public Types

typedef halco::hicann_dls::vx::ResetJTAGTapOnDLS coordinate_type¶

Public Functions

ResetJTAGTap()¶: Default constructor.

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

bool operator!=(ResetJTAGTap const &other) const¶

bool operator==(ResetJTAGTap const &other) const¶

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 1

Private Functions

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

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, ResetJTAGTap const &reset)¶

struct fisch::vx::word_access_type::ResetJTAGTap¶

#include <jtag.h>

Public Functions

bool operator!=(ResetJTAGTap const &other) const¶

bool operator==(ResetJTAGTap const &other) const¶

struct fisch::vx::RunTimeInfo¶

#include <run_time_info.h>

Time information of a run() invokation.

Public Members

hxcomm::ConnectionTimeInfo connection¶: Time information of the connection usage during the run() invokation.

std::chrono::nanoseconds playback_decode_time¶: Time spent decoding response messages into the playback program response queues.

Friends

friend std::ostream &operator<<(std::ostream &os, RunTimeInfo const &data)¶

struct fisch::vx::PlaybackDecoder::TimedResponseQueue::SizeConstraintChecker¶

Public Functions

inline SizeConstraintChecker(TimedResponseQueue const &queue)¶

inline ~SizeConstraintChecker()¶

Public Members

TimedResponseQueue const &queue¶

class fisch::vx::SPIDACControlRegister¶

#include <spi.h>

Container for reading and writing a DACControl control register over SPI.

Public Types

typedef halco::hicann_dls::vx::SPIDACControlRegisterOnBoard coordinate_type¶

typedef word_access_type::SPIDACControlRegister Value¶: DAC control value.

Public Functions

explicit SPIDACControlRegister(Value value = Value())¶

Construct an instance with a word value.

Parameters: value – Value to construct instance with

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get value.

Returns: SPIDACControlRegister value

bool operator!=(SPIDACControlRegister const &other) const¶

bool operator==(SPIDACControlRegister const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – SPIDACControlRegister word value to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 4

Private Functions

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

Private Members

Value m_data¶

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, SPIDACControlRegister const &word)¶

struct fisch::vx::word_access_type::SPIDACControlRegister : public halco::common::detail::RantWrapper<SPIDACControlRegister, uint_fast32_t, 0x1fff, 0>¶

#include <spi.h>

Public Functions

inline explicit constexpr SPIDACControlRegister(uintmax_t const value = 0)¶

class fisch::vx::SPIDACDataRegister¶

#include <spi.h>

Container for reading and writing a DACData data register over SPI.

Public Types

typedef halco::hicann_dls::vx::SPIDACDataRegisterOnBoard coordinate_type¶

typedef word_access_type::SPIDACDataRegister Value¶: DAC data value.

Public Functions

explicit SPIDACDataRegister(Value value = Value())¶

Construct an instance with a word value.

Parameters: value – Value to construct instance with

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get value.

Returns: SPIDACDataRegister value

bool operator!=(SPIDACDataRegister const &other) const¶

bool operator==(SPIDACDataRegister const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – SPIDACDataRegister word value to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 8

Private Functions

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

Private Members

Value m_data¶

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, SPIDACDataRegister const &word)¶

struct fisch::vx::word_access_type::SPIDACDataRegister : public halco::common::detail::RantWrapper<SPIDACDataRegister, uint_fast32_t, dac_value_max, dac_value_min>¶

#include <spi.h>

Public Functions

inline explicit constexpr SPIDACDataRegister(uintmax_t const value = 0)¶

class fisch::vx::SpikeFromChip¶

#include <event.h>

Spike from chip event comprised of a SpikeFromChip and FPGATime time annotation.

Serves as value type for spikes accessible on a PlaybackProgram.

Public Functions

inline explicit SpikeFromChip(SpikeLabel const &label = SpikeLabel(), ChipTime const &chip_time = ChipTime(), FPGATime const &fpga_time = FPGATime())¶

Construct spike from chip event from a label, a Chip time and a FPGA time.

Parameters

label – SpikeLabel data
chip_time – ChipTime time annotation
fpga_time – FPGATime time annotation

bool operator!=(SpikeFromChip const &other) const¶

bool operator==(SpikeFromChip const &other) const¶

Public Members

ChipTime chip_time¶: Chip time value.

FPGATime fpga_time¶: FPGA time annotation.

SpikeLabel label¶: Spike label value.

Private Functions

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

Friends

friend class cereal::access

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

struct fisch::vx::word_access_type::SpikeLabel : public halco::common::detail::BaseType<SpikeLabel, uint16_t>¶

#include <event.h>

Spike payload information.

Public Functions

inline explicit constexpr SpikeLabel(value_type const val = 0)¶

class fisch::vx::SpikePack1ToChip : public fisch::vx::SpikePackToChip<1>¶

#include <event.h>

Spike pack to chip holding one spike label.

Public Types

typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_coordinates>::type coordinate_type¶

typedef hate::type_list<halco::hicann_dls::vx::SpikePack1ToChipOnDLS, halco::hicann_dls::vx::SpikePack2ToChipOnDLS, halco::hicann_dls::vx::SpikePack3ToChipOnDLS> spike_pack_to_chip_coordinates¶

typedef hate::type_list<word_access_type::SpikePack1ToChip, word_access_type::SpikePack2ToChip, word_access_type::SpikePack3ToChip> spike_pack_to_chip_labels¶

typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_labels>::type Value¶

Public Functions

inline explicit SpikePack1ToChip()¶

inline explicit SpikePack1ToChip(Value const &labels)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value const &get() const¶

Get spike labels.

Returns: Array of SpikeLabel

bool operator!=(SpikePackToChip const &other) const¶

bool operator==(SpikePackToChip const &other) const¶

void set(Value const &value)¶

Set spike labels.

Parameters: value – Array of SpikeLabel to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count

Protected Functions

void serialize(Archive &ar, std::uint32_t const version)¶

Protected Attributes

Value m_value¶

class fisch::vx::SpikePack2ToChip : public fisch::vx::SpikePackToChip<2>¶

#include <event.h>

Spike pack to chip holding two spike labels.

Public Types

typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_coordinates>::type coordinate_type¶

typedef hate::type_list<halco::hicann_dls::vx::SpikePack1ToChipOnDLS, halco::hicann_dls::vx::SpikePack2ToChipOnDLS, halco::hicann_dls::vx::SpikePack3ToChipOnDLS> spike_pack_to_chip_coordinates¶

typedef hate::type_list<word_access_type::SpikePack1ToChip, word_access_type::SpikePack2ToChip, word_access_type::SpikePack3ToChip> spike_pack_to_chip_labels¶

typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_labels>::type Value¶

Public Functions

inline explicit SpikePack2ToChip()¶

inline explicit SpikePack2ToChip(Value const &labels)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value const &get() const¶

Get spike labels.

Returns: Array of SpikeLabel

bool operator!=(SpikePackToChip const &other) const¶

bool operator==(SpikePackToChip const &other) const¶

void set(Value const &value)¶

Set spike labels.

Parameters: value – Array of SpikeLabel to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count

Protected Functions

void serialize(Archive &ar, std::uint32_t const version)¶

Protected Attributes

Value m_value¶

class fisch::vx::SpikePack3ToChip : public fisch::vx::SpikePackToChip<3>¶

#include <event.h>

Spike pack to chip holding three spike labels.

Public Types

typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_coordinates>::type coordinate_type¶

typedef hate::type_list<halco::hicann_dls::vx::SpikePack1ToChipOnDLS, halco::hicann_dls::vx::SpikePack2ToChipOnDLS, halco::hicann_dls::vx::SpikePack3ToChipOnDLS> spike_pack_to_chip_coordinates¶

typedef hate::type_list<word_access_type::SpikePack1ToChip, word_access_type::SpikePack2ToChip, word_access_type::SpikePack3ToChip> spike_pack_to_chip_labels¶

typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_labels>::type Value¶

Public Functions

inline explicit SpikePack3ToChip()¶

inline explicit SpikePack3ToChip(Value const &labels)¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value const &get() const¶

Get spike labels.

Returns: Array of SpikeLabel

bool operator!=(SpikePackToChip const &other) const¶

bool operator==(SpikePackToChip const &other) const¶

void set(Value const &value)¶

Set spike labels.

Parameters: value – Array of SpikeLabel to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count

Protected Functions

void serialize(Archive &ar, std::uint32_t const version)¶

Protected Attributes

Value m_value¶

template<size_t NumPack> class fisch::vx::SpikePackToChip¶

#include <event.h>

Base of fixed-size spike pack to chip.

tparam NumPack: Number of spike labels to hold

Public Types

typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_coordinates>::type coordinate_type¶

typedef hate::type_list<halco::hicann_dls::vx::SpikePack1ToChipOnDLS, halco::hicann_dls::vx::SpikePack2ToChipOnDLS, halco::hicann_dls::vx::SpikePack3ToChipOnDLS> spike_pack_to_chip_coordinates¶

typedef hate::type_list<word_access_type::SpikePack1ToChip, word_access_type::SpikePack2ToChip, word_access_type::SpikePack3ToChip> spike_pack_to_chip_labels¶

typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_labels>::type Value¶

Public Functions

explicit SpikePackToChip()¶: Default constructor.

explicit SpikePackToChip(Value const &labels)¶

Construct spike pack with labels.

Parameters: labels – Array of SpikeLabel values to use

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value const &get() const¶

Get spike labels.

Returns: Array of SpikeLabel

bool operator!=(SpikePackToChip const &other) const¶

bool operator==(SpikePackToChip const &other) const¶

void set(Value const &value)¶

Set spike labels.

Parameters: value – Array of SpikeLabel to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 1

Protected Functions

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

Protected Attributes

Value m_value¶

Friends

friend class cereal::access

inline friend std::ostream &operator<<(std::ostream &os, SpikePackToChip const &spike_pack)¶

class fisch::vx::SPIShiftRegister¶

#include <spi.h>

Container for reading and writing the shift register over SPI.

Public Types

typedef halco::hicann_dls::vx::SPIShiftRegisterOnBoard coordinate_type¶

typedef word_access_type::SPIShiftRegister Value¶: Shift register value.

Public Functions

explicit SPIShiftRegister(Value value = Value())¶

Construct an instance with a word value.

Parameters: value – Value to construct instance with

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get value.

Returns: SPIShiftRegister value

bool operator!=(SPIShiftRegister const &other) const¶

bool operator==(SPIShiftRegister const &other) const¶

void set(Value value)¶

Set value.

Parameters: value – SPIShiftRegister word value to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 6

Private Functions

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

Private Members

Value m_data¶

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, SPIShiftRegister const &word)¶

struct fisch::vx::word_access_type::SPIShiftRegister : public halco::common::detail::RantWrapper<SPIShiftRegister, uint_fast32_t, 0xffffff, 0>¶

#include <spi.h>

Public Functions

inline explicit constexpr SPIShiftRegister(uintmax_t const value = 0)¶

template<typename T> struct fisch::vx::detail::SubRangeValueType¶

#include <decode.h>

Public Types

typedef void type¶

template<typename T> struct fisch::vx::detail::SubRangeValueType<boost::sub_range<T>>¶

#include <decode.h>

Public Types

typedef T type¶

class fisch::vx::SystimeSync¶

#include <systime.h>

Container for syncronization of chip and FPGA systime.

After syncronization the FPGA will annotate responses with systime information by sending additional timing messages.

Public Types

typedef halco::hicann_dls::vx::SystimeSyncOnFPGA coordinate_type¶

typedef word_access_type::SystimeSync Value¶

Public Functions

explicit SystimeSync(Value do_sync = Value(false))¶

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get systime sync enable value.

On true, systime sync is triggered, on false only a systime update response is emitted.

Returns: Boolean value

bool operator!=(SystimeSync const &other) const¶

bool operator==(SystimeSync const &other) const¶

void set(Value 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 Attributes

static constexpr static size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_do_sync¶

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, SystimeSync const &systime_sync)¶

struct fisch::vx::word_access_type::SystimeSync : public halco::common::detail::BaseType<SystimeSync, bool>¶

#include <systime.h>

Public Functions

inline explicit constexpr SystimeSync(bool value = false)¶

template<typename MessageT> struct fisch::vx::PlaybackDecoder::TimedResponseQueue¶

#include <playback_decoder.h>

Pair of UT message and FPGATime time annotation.

tparam MesageT: UT message type

Public Types

typedef MessageT message_type¶

Public Functions

inline TimedResponseQueue()¶

inline TimedResponseQueue(std::vector<message_type> const &messages, std::vector<FPGATime> const &times)¶

inline void clear()¶

inline std::vector<MessageT> const &get_messages() const¶

inline std::vector<FPGATime> const &get_times() const¶

inline bool operator!=(TimedResponseQueue const &other) const¶

inline bool operator==(TimedResponseQueue const &other) const¶

inline void push_back(MessageT const &message, FPGATime const &time)¶

inline size_t size() const¶

Private Members

std::vector<MessageT> m_messages¶

std::vector<FPGATime> m_times¶

class fisch::vx::TimeoutNotification¶

#include <event.h>

Notification from the FPGA indicating a playback instruction timeout.

Public Functions

inline explicit TimeoutNotification(Value const &value = Value(), FPGATime const &fpga_time = FPGATime())¶

Construct Playback instruction timeout notification from a value and an FPGA time.

Parameters

value – Value to store
fpga_time – FPGATime time annotation

FPGATime get_fpga_time() const¶

Get FPGA time annotation.

Returns: FPGATime time annotation

Value get_value() const¶

Get value data.

Returns: Value data

bool operator!=(TimeoutNotification const &other) const¶

bool operator==(TimeoutNotification const &other) const¶

void set_fpga_time(FPGATime const &value)¶

Set FPGA time annotation.

Parameters: value – FPGATime time annotation

void set_value(Value const &value)¶

Get value data.

Parameters: value – Value data

Private Functions

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

Private Members

FPGATime m_fpga_time¶

Value m_value¶

Friends

friend class cereal::access

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

class fisch::vx::Timer¶

#include <timer.h>

Container for writing a timer value.

Public Types

typedef halco::hicann_dls::vx::TimerOnDLS coordinate_type¶

Public Functions

Timer() = default¶: Default constructor.

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

bool operator!=(Timer const &other) const¶

bool operator==(Timer const &other) const¶

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 1

Private Functions

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

Friends

friend class cereal::access

friend std::ostream &operator<<(std::ostream &os, Timer const &timer)¶

struct fisch::vx::word_access_type::Timer¶

#include <timer.h>

Public Functions

bool operator!=(Timer const &other) const¶

bool operator==(Timer const &other) const¶

template<typename TL> struct ToResponseQueueTuple¶

template<typename ...Ts> struct fisch::vx::PlaybackDecoder::ToResponseQueueTuple<hate::type_list<Ts...>>¶

#include <playback_decoder.h>

Public Types

typedef std::tuple<TimedResponseQueue<Ts>...> type¶

struct fisch::vx::HighspeedLinkNotification::Value : public halco::common::detail::BaseType<Value, uint8_t>¶

#include <event.h>

Public Functions

inline explicit constexpr Value(value_type const val = 0)¶

struct fisch::vx::MADCSampleFromChip::Value : public halco::common::detail::RantWrapper<Value, uint16_t, 0x3ff, 0>¶

#include <event.h>

Sample value.

Restricted to the MADC’s 10 bit resolution.

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)¶

struct fisch::vx::TimeoutNotification::Value : public halco::common::detail::BaseType<Value, uint32_t>¶

#include <event.h>

Public Functions

inline explicit constexpr Value(value_type const val = 0)¶

class fisch::vx::WaitUntil¶

#include <timer.h>

Container for blocking further execution until timer value reaches specified value.

Public Types

typedef halco::hicann_dls::vx::WaitUntilOnFPGA coordinate_type¶

typedef word_access_type::WaitUntil Value¶

Public Functions

explicit WaitUntil(Value value = Value())¶

Construct timer with value.

Parameters: value – Value to construct timer with

std::array<hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count> encode_write(coordinate_type const &coord) const¶

Value get() const¶

Get timer value.

Returns: Value

bool operator!=(WaitUntil const &other) const¶

bool operator==(WaitUntil const &other) const¶

void set(Value value)¶

Set timer value.

Parameters: value – Value to set

Public Static Attributes

static constexpr static size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_value¶

Friends

friend class cereal::access

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

struct fisch::vx::word_access_type::WaitUntil : public halco::common::detail::BaseType<WaitUntil, uint32_t>¶

#include <timer.h>

Public Functions

inline explicit constexpr WaitUntil(uintmax_t value = 0)¶

struct fisch::vx::word_access_type::Omnibus::Word : public halco::common::detail::BaseType<Word, uint32_t>¶

#include <omnibus.h>

Public Functions

inline explicit constexpr Word(value_type const value = 0)¶

namespace cereal¶

namespace fisch¶

namespace fisch::vx¶

Typedefs

typedef word_access_type::I2CAD5252RwRegister I2CAD5252RwRegisterValue¶

typedef word_access_type::I2CDAC6573RwRegister I2CDAC6573RwRegisterValue¶

typedef word_access_type::I2CIdRegister I2CIdRegisterValue¶

typedef word_access_type::I2CINA219RoRegister I2CINA219RoRegisterValue¶

typedef word_access_type::I2CINA219RwRegister I2CINA219RwRegisterValue¶

typedef word_access_type::I2CTCA9554RoRegister I2CTCA9554RoRegisterValue¶

typedef word_access_type::I2CTCA9554RwRegister I2CTCA9554RwRegisterValue¶

typedef word_access_type::SpikeLabel SpikeLabel¶: Spike payload information.

template<typename Instruction> using UTMessageFromFPGARange = boost::sub_range<std::vector<hxcomm::vx::UTMessageFromFPGA<Instruction>> const>¶

typedef UTMessageFromFPGARange<hxcomm::vx::instruction::jtag_from_hicann::Data> UTMessageFromFPGARangeJTAG¶

typedef UTMessageFromFPGARange<hxcomm::vx::instruction::from_fpga_system::Loopback> UTMessageFromFPGARangeLoopback¶

typedef UTMessageFromFPGARange<hxcomm::vx::instruction::omnibus_from_fpga::Data> UTMessageFromFPGARangeOmnibus¶

Functions

template<typename T> inline T fill_ones()¶

Fill a type T variable with all bits set to one.

Template Parameters: T – Type
Returns: Value filled with ones

template<> inline SpikePack1ToChip fill_ones()¶

template<typename T> inline T fill_random(std::mt19937 &gen)¶

Draw a type T variable out of all values.

Template Parameters: T – type
Parameters: gen – RNG
Returns: random value

template<> inline SpikePack1ToChip fill_random(std::mt19937 &gen)¶

template<typename Connection> RunTimeInfo run(Connection &connection, std::shared_ptr<PlaybackProgram> const &program)¶

Transfer and execute the given playback program and fetch results.

Template Parameters

Connection – Connection type to be used for running the program

Parameters

connection – Connection instance to be used for running the program
program – PlaybackProgram to run

Returns

Run time information

Variables

constexpr size_t dac6573_value_max = 0x3ff¶: Maximal ultra96 DAC channel value (10bit).

constexpr size_t dac_value_max = 0xfff¶: Maximal xboard DAC channel value.

constexpr size_t dac_value_min = 0¶: Minimal xboard DAC channel value.

constexpr halco::hicann_dls::vx::OmnibusAddress executor_omnibus_mask {0x0800'0000 |external_ppu_memory_base_address}

constexpr halco::hicann_dls::vx::OmnibusAddress external_ppu_memory_base_address {0x0000'0000 |fpga_omnibus_mask}

constexpr size_t fpga_clock_cycles_per_ms = fpga_clock_cycles_per_us * 1000¶

constexpr size_t fpga_clock_cycles_per_s = fpga_clock_cycles_per_ms * 1000¶

constexpr size_t fpga_clock_cycles_per_us = 125¶: Number of FPGA clock cycles per {micro,milli,}second.

constexpr halco::hicann_dls::vx::OmnibusAddress fpga_omnibus_mask = {0x8000'0000}

constexpr halco::hicann_dls::vx::OmnibusAddress i2c_ad5252_base_address = {i2c_over_omnibus_mask + 0x2c}¶

constexpr halco::hicann_dls::vx::OmnibusAddress i2c_dac6573_base_address = {i2c_over_omnibus_mask + 0x4c}¶

constexpr halco::hicann_dls::vx::OmnibusAddress i2c_eeprom_base_address = {i2c_over_omnibus_mask + 0x50}¶

constexpr halco::hicann_dls::vx::OmnibusAddress i2c_ina219_base_address = {i2c_over_omnibus_mask + 0x40}¶

constexpr halco::hicann_dls::vx::OmnibusAddress i2c_over_omnibus_mask {0x0000'0800 |spi_over_omnibus_mask}

constexpr Omnibus::Value::Word i2c_over_omnibus_repeat_start = {0x100}¶

General Information about the I2C Omnibus interface.

When the I2C controller receives repeated messages with the same mode and address, it will not re-send the address. This is quite useful for multi-byte read/write operations as it conforms to the spec. of most slave devices.

Should two messages with different mode or address follow each other, a repeat-start is automatically inserted. To force a repeat-start, use the flags below. See https://gerrit.bioai.eu/gitweb?p=verilog-i2c.git;a=blob;f=rtl/i2c_master.v;hb=HEAD;js=1#l376 Add this to the I2C address to force a repeat start condition before the address byte of the next message.

constexpr Omnibus::Value::Word i2c_over_omnibus_stop = {0x80}¶: Add this to the I2C address to force a stop after the data byte of the next message.

constexpr halco::hicann_dls::vx::OmnibusAddress i2c_prescaler_base_address = {i2c_over_omnibus_mask + 0x200}¶

constexpr halco::hicann_dls::vx::OmnibusAddress i2c_tca9554_base_address = {i2c_over_omnibus_mask + 0x38}¶

constexpr size_t jtag_clock_scaler_max = 0xff¶: Maximal JTAG clock-sclaer value.

constexpr size_t jtag_clock_scaler_min = 0¶: Minimal JTAG clock-sclaer value.

constexpr halco::hicann_dls::vx::OmnibusAddress phy_omnibus_mask = {0x0000'2000 | ut_omnibus_mask}

constexpr size_t playback_memory_size_to_fpga = 4194304¶

Memory size on FPGA in instructions for playback execution.

32MB -> 32*1024*1024/8 = 4194304

constexpr halco::hicann_dls::vx::OmnibusAddress spi_over_omnibus_mask {0x0000'1000 |phy_omnibus_mask}

constexpr Omnibus::Value::Word spi_over_omnibus_stop_bit = {0x8000'0000}

constexpr halco::hicann_dls::vx::OmnibusAddress ut_omnibus_mask {0x0000'4000 |executor_omnibus_mask}

namespace fisch::vx::detail¶

Typedefs

hate::type_list<# 22 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/fisch/include/fisch/vx/playback_program_builder.h" 2 > container_list: List of container types used to resolve a container type from a coordinate type.

hate::type_list<# 32 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/fisch/include/fisch/vx/playback_program_builder.h" 2 > coordinate_list: List of coordinate types sorted the same way as the container list.

hate::type_list_unique_t< hate::multi_concat_t<#define LAST_PLAYBACK_CONTAINER(Name, Type) #define PLAYBACK_CONTAINER(Name, Type) # 13 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/fisch/include/fisch/vx/decode_message_types.h" 2 > > decode_message_types

Functions

template<typename Container, typename Value> void maybe_get_value(Container const &container, Value &value)¶

template<typename Container, typename Value> void maybe_set_value(Container &container, Value const &value)¶

Variables

template<typename C> static constexpr static size_t decode_message_types_index = hate::index_type_list_by_type<typenameDecodeMessageType<decltype(&C::decode)>::type, decode_message_types>::value

static constexpr static int jtag_pll_register_coord_size = 3

namespace fisch::vx::word_access_type¶

Typedefs

typedef std::array<SpikeLabel, 1> SpikePack1ToChip¶

typedef std::array<SpikeLabel, 2> SpikePack2ToChip¶

typedef std::array<SpikeLabel, 3> SpikePack3ToChip¶

namespace halco¶

namespace common¶

namespace detail¶

namespace hicann_dls¶

namespace vx¶

namespace std¶: STL namespace.

file cerealization.h

#include <cereal/cereal.hpp>#include <cereal/archives/json.hpp>#include <cereal/archives/portable_binary.hpp>#include “hate/visibility.h”

Defines

EXPLICIT_INSTANTIATE_CEREAL_SERIALIZE(CLASS_NAME)¶

file logger.h

#include <log4cxx/logger.h>#include <syslog.h>

Defines

FISCH_LOG_DEBUG(logger, message)¶

FISCH_LOG_ERROR(logger, message)¶

FISCH_LOG_FATAL(logger, message)¶

FISCH_LOG_INFO(logger, message)¶

FISCH_LOG_SYSLOG(level, message)¶

FISCH_LOG_TRACE(logger, message)¶

FISCH_LOG_WARN(logger, message)¶

file barrier.h: #include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/barrier.h”#include “hxcomm/vx/utmessage_fwd.h”

file barrier.h: #include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”

file chip_time.h: #include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”

file constants.h: #include “fisch/vx/genpybind.h”#include <stddef.h>

file container.h: #include “fisch/vx/barrier.h”#include “fisch/vx/event.h”#include “fisch/vx/i2c.h”#include “fisch/vx/jtag.h”#include “fisch/vx/null_payload_readable.h”#include “fisch/vx/omnibus.h”#include “fisch/vx/reset.h”#include “fisch/vx/spi.h”#include “fisch/vx/systime.h”#include “fisch/vx/timer.h”

file container_cast.h

#include “fisch/vx/container.h”#include “fisch/vx/traits.h”#include “fisch/vx/word_access_type.h”#include “hate/type_list.h”#include “fisch/vx/container.def”

Defines

PLAYBACK_CONTAINER(Name, Type)¶

file container_fwd.h

#include “fisch/vx/container.def”

Defines

PLAYBACK_CONTAINER(Name, Type)

file container_ticket.h: #include “fisch/vx/genpybind.h”#include <memory>#include <vector>

file coordinates.h: #include “halco/hicann-dls/vx/barrier.h”#include “halco/hicann-dls/vx/fpga.h”#include “halco/hicann-dls/vx/i2c.h”#include “halco/hicann-dls/vx/jtag.h”#include “halco/hicann-dls/vx/omnibus.h”#include “halco/hicann-dls/vx/reset.h”#include “halco/hicann-dls/vx/spi.h”#include “halco/hicann-dls/vx/timing.h”

file decode.h: #include “hxcomm/vx/utmessage_fwd.h”#include <type_traits>#include <vector>#include <boost/range/sub_range.hpp>

file decode_message_types.h

#include “fisch/vx/container.h”#include “fisch/vx/decode.h”#include “hate/type_list.h”#include “fisch/vx/container.def”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)¶

PLAYBACK_CONTAINER(Name, Type)

file jtag_pll_register_coord_size.h

file playback_program_impl.h

#include “fisch/vx/playback_decoder.h”#include “hxcomm/vx/utmessage_fwd.h”#include <array>#include <cstdint>#include <forward_list>#include <mutex>#include <variant>#include <vector>#include “fisch/vx/container.def”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

file event.h: #include “fisch/vx/chip_time.h”#include “fisch/vx/fpga_time.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/event.h”#include “hate/join.h”#include “hxcomm/vx/utmessage_fwd.h”

file event.h: #include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”

file fill.h

#include “fisch/vx/event.h”#include “fisch/vx/traits.h”#include <random>#include <type_traits>#include <boost/utility/enable_if.hpp>

Defines

SPIKE_PACK_TO_CHIP(Num)¶

file fisch.h: #include “fisch/vx/constants.h”#include “fisch/vx/container.h”#include “fisch/vx/container_ticket.h”#include “fisch/vx/playback_program.h”#include “fisch/vx/playback_program_builder.h”#include “fisch/vx/reinit_stack_entry.h”#include “fisch/vx/run.h”#include “fisch/vx/run_time_info.h”

file fpga_time.h: #include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”

file genpybind.h

#include <genpybind.h>

Defines

GENPYBIND_MODULE¶

GENPYBIND_TAG_FISCH_VX¶

file i2c.h: #include “fisch/vx/constants.h”#include “fisch/vx/decode.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/i2c.h”#include “halco/hicann-dls/vx/omnibus.h”#include “hate/type_index.h”#include “hxcomm/vx/utmessage_fwd.h”

file i2c.h: #include “fisch/vx/constants.h”#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”

file jtag.h: #include “fisch/vx/constants.h”#include “fisch/vx/decode.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/jtag.h”#include “hxcomm/vx/utmessage_fwd.h”

file jtag.h: #include “fisch/vx/constants.h”#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”

file null_payload_readable.h: #include “fisch/vx/decode.h”#include “fisch/vx/genpybind.h”#include “hxcomm/vx/utmessage_fwd.h”

file null_payload_readable.h: #include “fisch/vx/genpybind.h”

file omnibus.h: #include “fisch/vx/decode.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/omnibus.h”#include “hxcomm/vx/utmessage_fwd.h”

file omnibus.h: #include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”

file omnibus_constants.h: #include “fisch/vx/omnibus.h”#include “halco/hicann-dls/vx/omnibus.h”

file playback_decoder.h: #include “fisch/vx/chip_time.h”#include “fisch/vx/decode_message_types.h”#include “fisch/vx/event.h”#include “fisch/vx/fpga_time.h”#include “fisch/vx/genpybind.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/event.h”#include “hate/type_list.h”#include “hxcomm/vx/utmessage.h”#include <tuple>

file playback_program.h

#include “fisch/vx/event.h”#include “fisch/vx/genpybind.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/event.h”#include “hxcomm/vx/utmessage_fwd.h”#include <memory>#include <unordered_set>#include <variant>#include “fisch/vx/container.def”

Defines

PLAYBACK_CONTAINER(Name, Type)

file playback_program_builder.h

#include “fisch/vx/container.h”#include “fisch/vx/genpybind.h”#include <memory>#include <vector>#include “fisch/vx/container.def”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)

LAST_PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, _Type)

PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

file python_bindings.h: #include “fisch/vx/fisch.h”#include “halco/hicann-dls/vx/coordinates.h”

file reinit_stack_entry.h: #include “fisch/vx/genpybind.h”#include “fisch/vx/playback_program.h”#include <memory>#include “fisch/vx/reinit_stack_entry.tcc”

file reset.h: #include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/reset.h”#include “hxcomm/vx/utmessage_fwd.h”

file reset.h: #include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”

file run.h: #include <memory>#include “fisch/vx/run.tcc”

file run_time_info.h: #include “fisch/vx/genpybind.h”#include “hxcomm/common/connection_time_info.h”#include <chrono>#include <ostream>

file spi.h: #include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/spi.h”#include “hxcomm/vx/utmessage_fwd.h”

file spi.h: #include “fisch/vx/constants.h”#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”

file systime.h: #include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/systime.h”#include “hxcomm/vx/utmessage_fwd.h”

file systime.h: #include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”

file timer.h: #include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/timer.h”#include “hxcomm/vx/utmessage_fwd.h”

file timer.h: #include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”

file traits.h: #include “hate/type_list.h”#include <type_traits>#include <boost/utility/enable_if.hpp>

file word_access_type.h: #include “fisch/vx/word_access/type/barrier.h”#include “fisch/vx/word_access/type/event.h”#include “fisch/vx/word_access/type/i2c.h”#include “fisch/vx/word_access/type/jtag.h”#include “fisch/vx/word_access/type/null_payload_readable.h”#include “fisch/vx/word_access/type/omnibus.h”#include “fisch/vx/word_access/type/reset.h”#include “fisch/vx/word_access/type/spi.h”#include “fisch/vx/word_access/type/systime.h”#include “fisch/vx/word_access/type/timer.h”

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/fisch/include/fisch/common

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/fisch/include/fisch/vx/detail

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/fisch

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/fisch/include/fisch

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/fisch/include

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/fisch/include/fisch/vx/word_access/type

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/fisch/include/fisch/vx

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzNzk.x/fisch/include/fisch/vx/word_access