API Reference: fisch

template<typename Container>
struct fisch::vx::BackEmplacer

#include <back_emplacer.h>

Public Functions

inline BackEmplacer(Container &container)

template<typename ...Args>
inline void operator()(Args&&... args)

Private Members

Container &m_container

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

inline explicit Barrier(Value const value = Value())

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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.

Template Parameters

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>
struct 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.

Template Parameters

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

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 bool value = (T::decode_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>

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>

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<>> m_tickets

Note

Collection of message types omitted in documentation.

mutable std::mutex m_tickets_mutex

PlaybackDecoder::timeout_notification_queue_type m_timeout_notification_response_queue

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

#include <extoll.h>

Container for reading and writing an Extoll (quad-)word, i.e., 64-bit to the odfi-rf on the own FPGA node.

Public Types

typedef halco::hicann_dls::vx::ExtollAddress coordinate_type

typedef word_access_type::Extoll Value

Public Functions

inline explicit Extoll(Value const &value = Value())

Construct an instance with a value.

Parameters

value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) const

Value const &get() const

Get value.

Returns

Word value

bool operator!=(Extoll const &other) const

bool operator==(Extoll const &other) const

void set(Value const &value)

Set value.

Parameters

value – Word value to set

Public Static Functions

static void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

Public Static Attributes

static constexpr size_t decode_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 struct cereal::access

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

class fisch::vx::ExtollOnNwNode

#include <extoll.h>

Container for reading and writing an Extoll (quad-)word, i.e.

64-bit to an odfi-rf on an arbitrary network node.

Public Types

typedef halco::hicann_dls::vx::ExtollAddressOnExtollNetwork coordinate_type

typedef word_access_type::ExtollOnNwNode Value

Public Functions

inline explicit ExtollOnNwNode(Value const &value = Value())

Construct an instance with a value.

Parameters

value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) const

Value const &get() const

Get value.

Returns

Word value

bool operator!=(ExtollOnNwNode const &other) const

bool operator==(ExtollOnNwNode const &other) const

void set(Value const &value)

Set value.

Parameters

value – Word value to set

Public Static Functions

static void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

Public Static Attributes

static constexpr size_t decode_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, ExtollOnNwNode const &word)

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)

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

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

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)

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)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) const

void encode_write(halco::hicann_dls::vx::I2CAD5252RwRegisterOnBoard const &coord, UTMessageToFPGABackEmplacer &target) 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 void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

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_value

Private Functions

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

Friends

friend struct cereal::access

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)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) const

void encode_write(halco::hicann_dls::vx::I2CDAC6573RwRegisterOnBoard const &coord, UTMessageToFPGABackEmplacer &target) 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 void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

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_value

Private Functions

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

Friends

friend struct cereal::access

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)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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 void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

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 register_size_bytes

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct cereal::access

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)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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 void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

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 register_size_bytes

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct cereal::access

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)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) const

void encode_write(halco::hicann_dls::vx::I2CINA219RwRegisterOnBoard const &coord, UTMessageToFPGABackEmplacer &target) 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 void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

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_value

Private Functions

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

Friends

friend struct cereal::access

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< I2CAD5252RwRegister, I2CAD5252RwRegisterValue, halco::hicann_dls::vx::I2CAD5252RwRegisterOnBoard >, fisch::vx::I2CRwRegister< I2CDAC6573RwRegister, I2CDAC6573RwRegisterValue, halco::hicann_dls::vx::I2CDAC6573RwRegisterOnBoard >, fisch::vx::I2CRwRegister< I2CINA219RwRegister, I2CINA219RwRegisterValue, halco::hicann_dls::vx::I2CINA219RwRegisterOnBoard >, 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)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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 void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

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 register_size_bytes = hate::math::round_up_integer_division(hate::math::num_bits(Value::max), 8)

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct 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)

void encode_write(CoordinateType const &coord, UTMessageToFPGABackEmplacer &target) 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 void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

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_value

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)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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 void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

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 register_size_bytes

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct cereal::access

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)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) const

void encode_write(halco::hicann_dls::vx::I2CTCA9554RwRegisterOnBoard const &coord, UTMessageToFPGABackEmplacer &target) 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 void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

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_value

Private Functions

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

Friends

friend struct cereal::access

class fisch::vx::I2CTempRegister : public fisch::vx::I2CRoRegister<I2CTempRegister, I2CTempRegisterValue, halco::hicann_dls::vx::I2CTempRegisterOnBoard>

#include <i2c.h>

Container for reading the TMP112 temperature sensor on the chip carrier board.

Public Types

typedef halco::hicann_dls::vx::I2CTempRegisterOnBoard coordinate_type

typedef I2CTempRegisterValue Value

Public Functions

inline explicit I2CTempRegister()

Construct an instance with a default value.

inline explicit I2CTempRegister(Value value)

Construct an instance with a word value.

Parameters

value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) const

Value get() const

Get value.

Returns

I2C register value

bool operator!=(I2CTempRegister const &other) const

bool operator==(I2CTempRegister const &other) const

void set(Value value)

Set value.

Parameters

value – I2C register value to set

Public Static Functions

static void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

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 register_size_bytes

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct cereal::access

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

#include <traits.h>

Check whether given container is readable.

Template Parameters

ContainerT – Type of container

Public Static Attributes

static constexpr bool value = detail::HasPositiveDecodeUTMessageCount<ContainerT>::value && hate::is_detected_v<detail::HasEncodeRead, ContainerT>

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

#include <traits.h>

Check whether given container is writable.

Template Parameters

ContainerT – Type of container

Public Static Attributes

static constexpr bool value = hate::is_detected_v<detail::HasEncodeWrite, ContainerT>

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

inline explicit JTAGClockScaler(Value value = Value())

Construct scaler with value.

Parameters

value – Value to construct scaler with

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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

inline 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 void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

Public Static Attributes

static constexpr size_t decode_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 struct cereal::access

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

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

inline explicit JTAGPhyRegister(Value value = Value())

Construct register with value.

Parameters

value – Value to construct register with

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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

inline explicit JTAGPLLRegister(Value value = Value())

Construct register by its value.

Parameters

value – Value to set on cosntruction

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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

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

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

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

inline NullPayloadReadable()

Default constructor.

void decode(UTMessageFromFPGARangeLoopback const &messages)

bool operator!=(NullPayloadReadable const &other) const

bool operator==(NullPayloadReadable const &other) const

Public Static Functions

static void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

Public Static Attributes

static constexpr size_t decode_ut_message_count = 1

Private Functions

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

Friends

friend struct cereal::access

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

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

inline explicit Omnibus(Value const &value = Value())

Construct an instance with a value.

Parameters

value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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 void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

Public Static Attributes

static constexpr size_t decode_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 struct cereal::access

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

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

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

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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 void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

Public Static Attributes

static constexpr size_t decode_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 struct cereal::access

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

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

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

#include <playback_decoder.h>

Pair of UT message and FPGATime time annotation.

Template Parameters

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

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

Public Functions

inline SizeConstraintChecker(TimedResponseQueue const &queue)

inline ~SizeConstraintChecker()

Public Members

TimedResponseQueue const &queue

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

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 struct 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.

~PlaybackProgramBuilder()

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::vector<hxcomm::vx::UTMessageToFPGAVariant> m_instructions

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

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

inline PollingOmnibusBlock(Value value = Value(true))

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

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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

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

Construct reset with boolean value.

Parameters

value – Boolean value to set

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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

inline ResetJTAGTap()

Default constructor.

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) const

bool operator!=(ResetJTAGTap const &other) const

bool operator==(ResetJTAGTap const &other) const

Private Functions

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

Friends

friend struct cereal::access

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

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)

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

inline explicit SPIDACControlRegister(Value value = Value())

Construct an instance with a word value.

Parameters

value – Value to construct instance with

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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

inline explicit SPIDACDataRegister(Value value = Value())

Construct an instance with a word value.

Parameters

value – Value to construct instance with

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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

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

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)

void encode_write(coordinate_type const &coord, BackEmplacer<std::vector<hxcomm::vx::UTMessageToFPGAVariant>> &target) 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

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)

void encode_write(coordinate_type const &coord, BackEmplacer<std::vector<hxcomm::vx::UTMessageToFPGAVariant>> &target) 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

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)

void encode_write(coordinate_type const &coord, BackEmplacer<std::vector<hxcomm::vx::UTMessageToFPGAVariant>> &target) 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

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.

Template Parameters

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

inline explicit SpikePackToChip()

Default constructor.

inline explicit SpikePackToChip(Value const &labels)

Construct spike pack with labels.

Parameters

labels – Array of SpikeLabel values to use

void encode_write(coordinate_type const &coord, BackEmplacer<std::vector<hxcomm::vx::UTMessageToFPGAVariant>> &target) 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

Protected Functions

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

Protected Attributes

Value m_value

Friends

friend struct 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

inline explicit SPIShiftRegister(Value value = Value())

Construct an instance with a word value.

Parameters

value – Value to construct instance with

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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

inline explicit SystimeSync(Value value = Value(false))

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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

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

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

#include <timer.h>

Container for writing and reading a timer value.

Public Types

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

typedef word_access_type::Timer Value

Public Functions

inline explicit Timer(Value const &value = Value())

Construct an instance with a value.

Parameters

value – Value to construct instance with

void decode(UTMessageFromFPGARangeOmnibus const &messages)

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) const

Value get() const

Get timer value.

Returns

Value value

bool operator!=(Timer const &other) const

bool operator==(Timer const &other) const

void set(Value value)

Set timer value.

Parameters

value – Value to set

Public Static Functions

static void encode_read(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target)

Public Static Attributes

static constexpr size_t decode_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 struct cereal::access

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

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

inline explicit WaitUntil(Value value = Value())

Construct timer with value.

Parameters

value – Value to construct timer with

void encode_write(coordinate_type const &coord, UTMessageToFPGABackEmplacer &target) 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

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access

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

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

#include <barrier.h>

Public Functions

inline explicit constexpr Barrier(uintmax_t const value = 0x0)

Public Static Attributes

static const Barrier jtag

static const Barrier multi_fpga

static const Barrier omnibus

static const Barrier systime

static const Barrier systime_correction

struct fisch::vx::word_access_type::Extoll : public halco::common::detail::BaseType<Extoll, uint64_t>

#include <extoll.h>

Public Functions

inline explicit constexpr Extoll(value_type const value = 0)

struct fisch::vx::word_access_type::ExtollOnNwNode : public halco::common::detail::BaseType<ExtollOnNwNode, uint64_t>

#include <extoll.h>

Public Functions

inline explicit constexpr ExtollOnNwNode(value_type const value = 0)

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)

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)

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)

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)

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)

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)

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)

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

#include <i2c.h>

Public Functions

inline explicit constexpr I2CTempRegister(uintmax_t const val = 0)

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)

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)

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

#include <jtag.h>

Public Functions

inline explicit constexpr JTAGPhyRegister(uintmax_t const value = 0)

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)

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

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

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

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)

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)

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)

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)

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

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)

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)

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)

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

#include <timer.h>

Public Functions

inline explicit constexpr Timer(uintmax_t const value = 0)

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)

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::I2CTempRegister I2CTempRegisterValue

typedef halco::hicann_dls::vx::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

typedef BackEmplacer<std::vector<hxcomm::vx::UTMessageToFPGAVariant>> UTMessageToFPGABackEmplacer

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<>
inline SpikePack2ToChip fill_ones()

template<>
inline SpikePack3ToChip 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<>
inline SpikePack2ToChip fill_random(std::mt19937 &gen)

template<>
inline SpikePack3ToChip 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 event_switch_mask  {0x0000'0400 |i2c_over_omnibus_mask}

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

constexpr halco::hicann_dls::vx::OmnibusAddress external_omnibus_base_address = {external_omnibus_bit_switch | executor_omnibus_mask}

constexpr halco::hicann_dls::vx::OmnibusAddress external_omnibus_bit_switch   = {0x0400'0000}

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 halco::hicann_dls::vx::OmnibusAddress i2c_tmp112_base_address = {i2c_over_omnibus_mask + 0x48}

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 odfi_external_access_config_base_address = {pulse_comm_config_omnibus_base_address}

constexpr halco::hicann_dls::vx::OmnibusAddress odfi_external_access_config_reg = {odfi_external_access_config_base_address + 0x0}

constexpr halco::hicann_dls::vx::OmnibusAddress odfi_rf_omnibus_base_address  {0x0000'0000 |external_omnibus_base_address}

constexpr halco::hicann_dls::vx::OmnibusAddress odfi_rf_omnibus_bit_switch_n   = {0x0100'0000}

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 pulse_comm_config_omnibus_base_address = {odfi_rf_omnibus_bit_switch_n | external_omnibus_base_address}

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 timer_readout = {0xc | executor_omnibus_mask}

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

namespace fisch::vx::detail

Typedefs

hate::type_list<# 24 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.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<# 34 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/fisch/include/fisch/vx/playback_program_builder.h" 2 > coordinate_list

List of coordinate types sorted the same way as the container list.

typedef hate::type_list_unique_t<hate::multi_concat_t<>> decode_message_types

Note

Collection of message types omitted in documentation.

template<typename T>
using HasEncodeRead = decltype(T::encode_read(std::declval<typename T::coordinate_type const&>(), std::declval<UTMessageToFPGABackEmplacer&>()))

template<typename T>
using HasEncodeWrite = decltype(std::declval<T const>().encode_write(std::declval<typename T::coordinate_type const&>(), std::declval<UTMessageToFPGABackEmplacer&>()))

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 size_t decode_message_types_index = hate::index_type_list_by_type<typenameDecodeMessageType<decltype(&C::decode)>::type, decode_message_types>::value

static constexpr int jtag_pll_register_coord_size = 3

namespace fisch::vx::word_access_type

Typedefs

typedef std::array<halco::hicann_dls::vx::SpikeLabel, 1> SpikePack1ToChip

typedef std::array<halco::hicann_dls::vx::SpikeLabel, 2> SpikePack2ToChip

typedef std::array<halco::hicann_dls::vx::SpikeLabel, 3> SpikePack3ToChip

namespace halco

namespace common

namespace detail

namespace hicann_dls

namespace vx

namespace std

STL namespace.

file cerealization.h

#include “”

#include <>

Defines

FISCH_EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CLASS_NAME)

file logger.h

#include <>

#include <>

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 back_emplacer.h

#include <>

file back_emplacer_fwd.h

file barrier.h

#include “fisch/cerealization.h”

#include “fisch/vx/encode_fwd.h”

#include “fisch/vx/genpybind.h”

#include “fisch/vx/word_access/type/barrier.h”

#include “”

file barrier.h

#include “fisch/vx/genpybind.h”

#include “”

#include “”

file chip_time.h

#include “fisch/vx/genpybind.h”

#include “”

file constants.h

#include “fisch/vx/genpybind.h”

#include <>

file container.h

#include “fisch/vx/barrier.h”

#include “fisch/vx/event.h”

#include “fisch/vx/extoll.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 “”

#include “”

Defines

PLAYBACK_CONTAINER(Name, Type)

file container_fwd.h

#include “”

Defines

PLAYBACK_CONTAINER(Name, Type)

file container_ticket.h

#include “fisch/vx/container_fwd.h”

#include “fisch/vx/genpybind.h”

#include “”

#include <>

#include <>

#include “”

Defines

PLAYBACK_CONTAINER(Name, Type)

file coordinates.h

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

#include “”

file decode.h

#include “”

#include <>

#include <>

#include <>

file decode_message_types.h

#include “fisch/vx/container.h”

#include “fisch/vx/decode.h”

#include “”

file jtag_pll_register_coord_size.h

file playback_program_impl.h

#include “fisch/vx/playback_decoder.h”

#include “”

#include “”

#include <>

#include <>

#include <>

#include <>

#include <>

#include <>

#include “”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

PLAYBACK_CONTAINER(Name, Type)

file encode.h

#include “fisch/vx/encode_fwd.h”

#include “fisch/vx/back_emplacer.h”

file encode_fwd.h

#include “fisch/vx/back_emplacer_fwd.h”

#include “”

#include <>

file event.h

#include “fisch/cerealization.h”

#include “fisch/vx/back_emplacer_fwd.h”

#include “fisch/vx/chip_time.h”

#include “fisch/vx/encode_fwd.h”

#include “fisch/vx/fpga_time.h”

#include “fisch/vx/genpybind.h”

#include “fisch/vx/word_access/type/event.h”

#include “”

#include “”

#include “”

#include <>

file event.h

#include “fisch/vx/genpybind.h”

#include “”

#include “”

file extoll.h

#include “fisch/cerealization.h”

#include “fisch/vx/decode.h”

#include “fisch/vx/encode_fwd.h”

#include “fisch/vx/genpybind.h”

#include “fisch/vx/word_access/type/extoll.h”

#include “”

#include “”

file extoll.h

#include “fisch/vx/genpybind.h”

#include “”

file fill.h

#include “fisch/vx/event.h”

#include “fisch/vx/traits.h”

#include <>

#include <>

#include <>

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 “”

file genpybind.h

#include <genpybind.h>

Defines

GENPYBIND_MODULE

GENPYBIND_TAG_FISCH_VX

file null_payload_readable.h

#include “fisch/cerealization.h”

#include “fisch/vx/decode.h”

#include “fisch/vx/encode_fwd.h”

#include “fisch/vx/genpybind.h”

#include “”

#include “”

file null_payload_readable.h

#include “fisch/vx/genpybind.h”

#include “”

file omnibus.h

#include “fisch/cerealization.h”

#include “fisch/vx/decode.h”

#include “fisch/vx/encode_fwd.h”

#include “fisch/vx/genpybind.h”

#include “fisch/vx/word_access/type/omnibus.h”

#include “”

#include “”

file omnibus.h

#include “fisch/cerealization.h”

#include “fisch/vx/genpybind.h”

#include “”

#include “”

file omnibus_constants.h

#include “fisch/vx/omnibus.h”

#include “”

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 “”

#include “”

#include “”

#include “”

#include “”

#include <>

file playback_program.h

#include “fisch/cerealization.h”

#include “fisch/vx/event.h”

#include “fisch/vx/genpybind.h”

#include “”

#include “”

#include “”

#include “”

#include <>

#include <>

#include <>

#include “”

Defines

PLAYBACK_CONTAINER(Name, Type)

file playback_program_builder.h

#include “fisch/vx/container.h”

#include “fisch/vx/genpybind.h”

#include “”

#include “”

#include <>

#include <>

#include “”

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/genpybind.h”

#include “fisch/vx/fisch.h”

#include “”

file reinit_stack_entry.h

#include “fisch/vx/genpybind.h”

#include “fisch/vx/playback_program.h”

#include “”

#include <>

#include “”

file reset.h

#include “fisch/cerealization.h”

#include “fisch/vx/encode_fwd.h”

#include “fisch/vx/genpybind.h”

#include “fisch/vx/word_access/type/reset.h”

#include “”

file reset.h

#include “fisch/vx/genpybind.h”

#include “”

file run.h

#include <>

#include “”

file run_time_info.h

#include “fisch/vx/genpybind.h”

#include “”

#include “”

#include <>

#include <>

file systime.h

#include “fisch/cerealization.h”

#include “fisch/vx/encode_fwd.h”

#include “fisch/vx/genpybind.h”

#include “fisch/vx/word_access/type/systime.h”

#include “”

#include “”

file systime.h

#include “fisch/vx/genpybind.h”

#include “”

file timer.h

#include “fisch/cerealization.h”

#include “fisch/vx/back_emplacer_fwd.h”

#include “fisch/vx/decode.h”

#include “fisch/vx/encode_fwd.h”

#include “fisch/vx/genpybind.h”

#include “fisch/vx/word_access/type/timer.h”

#include “”

#include “”

file timer.h

#include “fisch/vx/genpybind.h”

#include “”

file traits.h

#include “fisch/vx/encode_fwd.h”

#include “”

#include <>

#include <>

#include <>

file i2c.h

#include “fisch/cerealization.h”

#include “fisch/vx/constants.h”

#include “fisch/vx/decode.h”

#include “fisch/vx/encode_fwd.h”

#include “fisch/vx/genpybind.h”

#include “fisch/vx/word_access/type/i2c.h”

#include “”

#include “”

file i2c.h

#include “fisch/vx/constants.h”

#include “fisch/vx/genpybind.h”

#include “”

file jtag.h

#include “fisch/cerealization.h”

#include “fisch/vx/constants.h”

#include “fisch/vx/decode.h”

#include “fisch/vx/encode_fwd.h”

#include “fisch/vx/genpybind.h”

#include “fisch/vx/word_access/type/jtag.h”

#include “”

#include “”

file jtag.h

#include “fisch/vx/constants.h”

#include “fisch/vx/genpybind.h”

#include “”

#include “”

file spi.h

#include “fisch/cerealization.h”

#include “fisch/vx/encode_fwd.h”

#include “fisch/vx/genpybind.h”

#include “fisch/vx/word_access/type/spi.h”

#include “”

#include “”

file spi.h

#include “fisch/vx/constants.h”

#include “fisch/vx/genpybind.h”

#include “”

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/extoll.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-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/fisch/include/fisch/common

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

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/fisch

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/fisch/include/fisch

dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2-dependencies.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMi1kZXBlbmRlbmNpZXMjMTE3OTA.x/fisch/include

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

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

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