API Reference: fisch

class fisch::vx::Barrier
#include <barrier.h>

Container for sync operation.

Public Types

typedef halco::hicann_dls::vx::BarrierOnFPGA coordinate_type
typedef word_access_type::Barrier Value

Public Functions

inline explicit Barrier(Value const value = Value())
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get value.

Returns

Barrier value

bool operator!= (Barrier const &other) const SYMBOL_VISIBLE
bool operator== (Barrier const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – Barrier value to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, Barrier const &config) SYMBOL_VISIBLE
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 SYMBOL_VISIBLE Barrier jtag
static const SYMBOL_VISIBLE Barrier multi_fpga
static const SYMBOL_VISIBLE Barrier omnibus
static const SYMBOL_VISIBLE Barrier systime
static const SYMBOL_VISIBLE Barrier systime_correction
struct fisch::vx::MADCSampleFromChip::Channel : public halco::common::detail::RantWrapper<Channel, uint8_t, 0x1, 0>
#include <event.h>

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

Given as a ReadoutSourceSelection coordinate.

Public Functions

inline explicit constexpr Channel(uintmax_t const val = 0)
struct fisch::vx::ChipTime : public halco::common::detail::RantWrapper<ChipTime, uint64_t, 0x7ffffffffff, 0>
#include <chip_time.h>

Systime type for chip annotated times.

Public Functions

inline explicit constexpr ChipTime(uintmax_t const value = 0)
template<class ContainerT>
class fisch::vx::ContainerTicket
#include <container_ticket.h>

Read-ticket for multiple containers.

tparam ContainerT

Container type of corresponding data

Public Types

typedef ContainerT container_type

Public Functions

ContainerTicket(ContainerTicket &&other) = default
ContainerTicket(ContainerTicket const &other) = default
FPGATime fpga_time () const SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

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.

tparam CoordinateT

Coordinate type to resolve container type for

Public Types

typedef hate::index_type_list_by_integer<hate::index_type_list_by_type<CoordinateT, coordinate_list>::value, container_list>::type type
template<typename CoordinateT>
struct fisch::vx::detail::coordinate_type_to_container_type<std::vector<CoordinateT>>
#include <playback_program_builder.h>

Specialization for vector<coordinate>.

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

Public Types

typedef void type
template<typename F>
struct DecodeMessageType
template<typename C, typename M>
struct fisch::vx::detail::DecodeMessageType<void (C::*)(M const&)>
#include <decode.h>

Public Types

typedef SubRangeValueType<M>::type::value_type type
template<typename C, typename = void>
struct fisch::vx::detail::DecodeMessageTypeList
#include <decode.h>

Public Types

typedef hate::type_list type
template<typename C>
struct fisch::vx::detail::DecodeMessageTypeList<C, std::void_t<decltype(&C::decode)>>
#include <decode.h>

Public Types

typedef hate::type_list<typename DecodeMessageType<decltype(&C::decode)>::type> type
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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value const & get () const SYMBOL_VISIBLE

Get value.

Returns

Word value

bool operator!= (Extoll const &other) const SYMBOL_VISIBLE
bool operator== (Extoll const &other) const SYMBOL_VISIBLE
void set (Value const &value) SYMBOL_VISIBLE

Set value.

Parameters

value – Word value to set

Public Static Functions

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

Public Static Attributes

static constexpr size_t decode_ut_message_count = 2
static constexpr size_t encode_read_ut_message_count = 2
static constexpr size_t encode_write_ut_message_count = 4

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, Extoll const &word) SYMBOL_VISIBLE
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)
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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value const & get () const SYMBOL_VISIBLE

Get value.

Returns

Word value

bool operator!= (ExtollOnNwNode const &other) const SYMBOL_VISIBLE
bool operator== (ExtollOnNwNode const &other) const SYMBOL_VISIBLE
void set (Value const &value) SYMBOL_VISIBLE

Set value.

Parameters

value – Word value to set

Public Static Functions

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

Public Static Attributes

static constexpr size_t decode_ut_message_count = 2
static constexpr size_t encode_read_ut_message_count = 6
static constexpr size_t encode_write_ut_message_count = 8

Private Functions

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

Private Members

Value m_value

Friends

friend class cereal::access
friend std::ostream & operator<< (std::ostream &os, ExtollOnNwNode const &word) SYMBOL_VISIBLE
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::FPGATime : public halco::common::detail::RantWrapper<FPGATime, uint64_t, 0x7ffffffffff, 0>
#include <fpga_time.h>

Systime type for FPGA executor times.

Public Functions

inline explicit constexpr FPGATime(uintmax_t const value = 0)
template<typename T, typename = void>
struct HasPositiveDecodeUTMessageCount : public std::false_type
#include <traits.h>
template<typename T>
struct fisch::vx::detail::HasPositiveDecodeUTMessageCount<T, typename boost::enable_if_has_type<decltype(T::decode_ut_message_count)>::type>
#include <traits.h>

Public Static Attributes

static constexpr bool value = (T::decode_ut_message_count > 0)
template<typename T, typename = void>
struct HasPositiveEncodeReadUTMessageCount : public std::false_type
#include <traits.h>
template<typename T>
struct fisch::vx::detail::HasPositiveEncodeReadUTMessageCount<T, typename boost::enable_if_has_type<decltype(T::encode_read_ut_message_count)>::type>
#include <traits.h>

Public Static Attributes

static constexpr bool value = (T::encode_read_ut_message_count > 0)
template<typename T, typename = void>
struct HasPositiveEncodeWriteUTMessageCount : public std::false_type
#include <traits.h>
template<typename T>
struct fisch::vx::detail::HasPositiveEncodeWriteUTMessageCount<T, typename boost::enable_if_has_type<decltype(T::encode_write_ut_message_count)>::type>
#include <traits.h>

Public Static Attributes

static constexpr bool value = (T::encode_write_ut_message_count > 0)
template<typename T, typename = void>
struct HasValue : public std::false_type
#include <traits.h>
template<typename T>
struct HasValue<T, typename boost::enable_if_has_type<typename T::Value>::type> : public std::true_type
#include <traits.h>
class fisch::vx::HighspeedLinkNotification
#include <event.h>

Notification from the FPGA-chip link.

Public Functions

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

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

Parameters

  • value – Value to store

  • fpga_time – FPGATime time annotation

FPGATime get_fpga_time () const SYMBOL_VISIBLE

Get FPGA time annotation.

Returns

FPGATime time annotation

Value get_value () const SYMBOL_VISIBLE

Get value data.

Returns

Value data

bool operator!= (HighspeedLinkNotification const &other) const SYMBOL_VISIBLE
bool operator== (HighspeedLinkNotification const &other) const SYMBOL_VISIBLE
void set_fpga_time (FPGATime const &value) SYMBOL_VISIBLE

Set FPGA time annotation.

Parameters

value – FPGATime time annotation

void set_value (Value const &value) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE
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 halco::hicann_dls::vx::I2CAD5252RwRegisterOnBoard 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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (halco::hicann_dls::vx::I2CAD5252RwRegisterOnBoard const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get value.

Returns

I2C register value

bool operator!= (I2CAD5252RwRegister const &other) const SYMBOL_VISIBLE
bool operator== (I2CAD5252RwRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – I2C register value to set

Public Static Functions

static std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count > encode_read (coordinate_type const &coord) SYMBOL_VISIBLE
static halco::hicann_dls::vx::OmnibusAddress get_base_address (coordinate_type const &) SYMBOL_VISIBLE
static uint8_t get_register_address (coordinate_type const &) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t decode_ut_message_count
static constexpr size_t encode_read_ut_message_count
static constexpr size_t encode_write_ut_message_count
static constexpr size_t register_size_bytes

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct cereal::access
struct fisch::vx::word_access_type::I2CAD5252RwRegister : public halco::common::detail::RantWrapper<I2CAD5252RwRegister, uint_fast16_t, std::numeric_limits<uint8_t>::max(), std::numeric_limits<uint8_t>::min()>
#include <i2c.h>

Public Functions

inline explicit constexpr I2CAD5252RwRegister(uintmax_t const val = 0)
class fisch::vx::I2CDAC6573RwRegister : public fisch::vx::I2CRwRegister<I2CDAC6573RwRegister, I2CDAC6573RwRegisterValue, halco::hicann_dls::vx::I2CDAC6573RwRegisterOnBoard>
#include <i2c.h>

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

Public Types

typedef halco::hicann_dls::vx::I2CDAC6573RwRegisterOnBoard 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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get value.

Returns

I2C register value

bool operator!= (I2CDAC6573RwRegister const &other) const SYMBOL_VISIBLE
bool operator== (I2CDAC6573RwRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – I2C register value to set

Public Static Functions

static std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count > encode_read (coordinate_type const &coord) SYMBOL_VISIBLE
static halco::hicann_dls::vx::OmnibusAddress get_base_address (coordinate_type const &) SYMBOL_VISIBLE
static uint8_t get_register_address (coordinate_type const &) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t decode_ut_message_count
static constexpr size_t encode_read_ut_message_count
static constexpr size_t encode_write_ut_message_count
static constexpr size_t register_size_bytes

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct cereal::access
struct fisch::vx::word_access_type::I2CDAC6573RwRegister : public halco::common::detail::RantWrapper<I2CDAC6573RwRegister, uint_fast16_t, fisch::vx::dac6573_value_max, fisch::vx::dac_value_min>
#include <i2c.h>

Public Functions

inline explicit constexpr I2CDAC6573RwRegister(uintmax_t const val = 0)
class fisch::vx::I2CIdRegister : public fisch::vx::I2CRoRegister<I2CIdRegister, I2CIdRegisterValue, halco::hicann_dls::vx::I2CIdRegisterOnBoard>
#include <i2c.h>

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

Public Types

typedef halco::hicann_dls::vx::I2CIdRegisterOnBoard coordinate_type
typedef I2CIdRegisterValue Value

Public Functions

inline explicit I2CIdRegister()

Construct an instance with a default value.

inline explicit I2CIdRegister(Value value)

Construct an instance with a word value.

Parameters

value – Value to construct instance with

void decode (UTMessageFromFPGARangeOmnibus const &messages) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get value.

Returns

I2C register value

bool operator!= (I2CIdRegister const &other) const SYMBOL_VISIBLE
bool operator== (I2CIdRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – I2C register value to set

Public Static Functions

static std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count > encode_read (coordinate_type const &coord) SYMBOL_VISIBLE
static halco::hicann_dls::vx::OmnibusAddress get_base_address (coordinate_type const &) SYMBOL_VISIBLE
static uint8_t get_register_address (coordinate_type const &) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t decode_ut_message_count
static constexpr size_t encode_read_ut_message_count
static constexpr size_t encode_write_ut_message_count
static constexpr size_t register_size_bytes

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct cereal::access
struct fisch::vx::word_access_type::I2CIdRegister : public halco::common::detail::RantWrapper<I2CIdRegister, uint_fast32_t, std::numeric_limits<uint32_t>::max(), std::numeric_limits<uint32_t>::min()>
#include <i2c.h>

Public Functions

inline explicit constexpr I2CIdRegister(uintmax_t const val = 0)
class fisch::vx::I2CINA219RoRegister : public fisch::vx::I2CRoRegister<I2CINA219RoRegister, I2CINA219RoRegisterValue, halco::hicann_dls::vx::I2CINA219RoRegisterOnBoard>
#include <i2c.h>

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

Public Types

typedef halco::hicann_dls::vx::I2CINA219RoRegisterOnBoard coordinate_type
typedef I2CINA219RoRegisterValue Value

Public Functions

inline explicit I2CINA219RoRegister()

Construct an instance with a default value.

inline explicit I2CINA219RoRegister(Value value)

Construct an instance with a word value.

Parameters

value – Value to construct instance with

void decode (UTMessageFromFPGARangeOmnibus const &messages) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get value.

Returns

I2C register value

bool operator!= (I2CINA219RoRegister const &other) const SYMBOL_VISIBLE
bool operator== (I2CINA219RoRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – I2C register value to set

Public Static Functions

static std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count > encode_read (coordinate_type const &coord) SYMBOL_VISIBLE
static halco::hicann_dls::vx::OmnibusAddress get_base_address (coordinate_type const &) SYMBOL_VISIBLE
static uint8_t get_register_address (coordinate_type const &) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t decode_ut_message_count
static constexpr size_t encode_read_ut_message_count
static constexpr size_t encode_write_ut_message_count
static constexpr size_t register_size_bytes

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct cereal::access
struct fisch::vx::word_access_type::I2CINA219RoRegister : public halco::common::detail::RantWrapper<I2CINA219RoRegister, uint_fast16_t, std::numeric_limits<uint16_t>::max(), std::numeric_limits<uint16_t>::min()>
#include <i2c.h>

Public Functions

inline explicit constexpr I2CINA219RoRegister(uintmax_t const val = 0)
class fisch::vx::I2CINA219RwRegister : public fisch::vx::I2CRwRegister<I2CINA219RwRegister, I2CINA219RwRegisterValue, halco::hicann_dls::vx::I2CINA219RwRegisterOnBoard>
#include <i2c.h>

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

Public Types

typedef halco::hicann_dls::vx::I2CINA219RwRegisterOnBoard 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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (halco::hicann_dls::vx::I2CINA219RwRegisterOnBoard const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get value.

Returns

I2C register value

bool operator!= (I2CINA219RwRegister const &other) const SYMBOL_VISIBLE
bool operator== (I2CINA219RwRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – I2C register value to set

Public Static Functions

static std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count > encode_read (coordinate_type const &coord) SYMBOL_VISIBLE
static halco::hicann_dls::vx::OmnibusAddress get_base_address (coordinate_type const &) SYMBOL_VISIBLE
static uint8_t get_register_address (coordinate_type const &) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t decode_ut_message_count
static constexpr size_t encode_read_ut_message_count
static constexpr size_t encode_write_ut_message_count
static constexpr size_t register_size_bytes

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct cereal::access
struct fisch::vx::word_access_type::I2CINA219RwRegister : public halco::common::detail::RantWrapper<I2CINA219RwRegister, uint_fast16_t, std::numeric_limits<uint16_t>::max(), std::numeric_limits<uint16_t>::min()>
#include <i2c.h>

Public Functions

inline explicit constexpr I2CINA219RwRegister(uintmax_t const val = 0)
template<typename Derived, typename ValueType, typename CoordinateType>
class fisch::vx::I2CRoRegister
#include <i2c.h>

General implementation of an I2C read-only register.

Its length is determined by the ValueType

Subclassed by fisch::vx::I2CRwRegister< 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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get value.

Returns

I2C register value

bool operator!= (Derived const &other) const SYMBOL_VISIBLE
bool operator== (Derived const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – I2C register value to set

Public Static Functions

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

Public Static Attributes

static constexpr size_t decode_ut_message_count = register_size_bytes
static constexpr size_t encode_read_ut_message_count = 2 + register_size_bytes
static constexpr size_t encode_write_ut_message_count = 0
static constexpr size_t register_size_bytes = hate::math::round_up_integer_division(hate::math::num_bits(Value::max), 8)

Protected Attributes

Value m_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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (CoordinateType const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get value.

Returns

I2C register value

bool operator!= (Derived const &other) const SYMBOL_VISIBLE
bool operator== (Derived const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – I2C register value to set

Public Static Functions

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

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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get value.

Returns

I2C register value

bool operator!= (I2CTCA9554RoRegister const &other) const SYMBOL_VISIBLE
bool operator== (I2CTCA9554RoRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – I2C register value to set

Public Static Functions

static std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count > encode_read (coordinate_type const &coord) SYMBOL_VISIBLE
static halco::hicann_dls::vx::OmnibusAddress get_base_address (coordinate_type const &) SYMBOL_VISIBLE
static uint8_t get_register_address (coordinate_type const &) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t decode_ut_message_count
static constexpr size_t encode_read_ut_message_count
static constexpr size_t encode_write_ut_message_count
static constexpr size_t register_size_bytes

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct cereal::access
struct fisch::vx::word_access_type::I2CTCA9554RoRegister : public halco::common::detail::RantWrapper<I2CTCA9554RoRegister, uint_fast16_t, std::numeric_limits<uint8_t>::max(), std::numeric_limits<uint8_t>::min()>
#include <i2c.h>

Public Functions

inline explicit constexpr I2CTCA9554RoRegister(uintmax_t const val = 0)
class fisch::vx::I2CTCA9554RwRegister : public fisch::vx::I2CRwRegister<I2CTCA9554RwRegister, I2CTCA9554RwRegisterValue, halco::hicann_dls::vx::I2CTCA9554RwRegisterOnBoard>
#include <i2c.h>

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

Public Types

typedef halco::hicann_dls::vx::I2CTCA9554RwRegisterOnBoard 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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (halco::hicann_dls::vx::I2CTCA9554RwRegisterOnBoard const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get value.

Returns

I2C register value

bool operator!= (I2CTCA9554RwRegister const &other) const SYMBOL_VISIBLE
bool operator== (I2CTCA9554RwRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – I2C register value to set

Public Static Functions

static std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count > encode_read (coordinate_type const &coord) SYMBOL_VISIBLE
static halco::hicann_dls::vx::OmnibusAddress get_base_address (coordinate_type const &) SYMBOL_VISIBLE
static uint8_t get_register_address (coordinate_type const &) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t decode_ut_message_count
static constexpr size_t encode_read_ut_message_count
static constexpr size_t encode_write_ut_message_count
static constexpr size_t register_size_bytes

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct cereal::access
struct fisch::vx::word_access_type::I2CTCA9554RwRegister : public halco::common::detail::RantWrapper<I2CTCA9554RwRegister, uint_fast16_t, std::numeric_limits<uint8_t>::max(), std::numeric_limits<uint8_t>::min()>
#include <i2c.h>

Public Functions

inline explicit constexpr I2CTCA9554RwRegister(uintmax_t const val = 0)
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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get value.

Returns

I2C register value

bool operator!= (I2CTempRegister const &other) const SYMBOL_VISIBLE
bool operator== (I2CTempRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – I2C register value to set

Public Static Functions

static std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_read_ut_message_count > encode_read (coordinate_type const &coord) SYMBOL_VISIBLE
static halco::hicann_dls::vx::OmnibusAddress get_base_address (coordinate_type const &) SYMBOL_VISIBLE
static uint8_t get_register_address (coordinate_type const &) SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t decode_ut_message_count
static constexpr size_t encode_read_ut_message_count
static constexpr size_t encode_write_ut_message_count
static constexpr size_t register_size_bytes

Protected Attributes

Value m_value

Private Functions

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

Friends

friend struct cereal::access
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)
template<typename T, typename = void>
struct IsRangedType : public std::false_type
#include <fill.h>
template<typename T>
struct IsRangedType<T, typename boost::enable_if_has_type<decltype(T::min)>::type> : public std::true_type
#include <fill.h>
template<typename ContainerT>
struct fisch::vx::IsReadable
#include <traits.h>

Check whether given container is readable.

tparam ContainerT

Type of container

Public Static Attributes

static constexpr bool value = detail::HasPositiveDecodeUTMessageCount<ContainerT>::value && detail::HasPositiveEncodeReadUTMessageCount<ContainerT>::value
template<typename ContainerT>
struct fisch::vx::IsWritable
#include <traits.h>

Check whether given container is writable.

tparam ContainerT

Type of container

Public Static Attributes

static constexpr bool value = detail::HasPositiveEncodeWriteUTMessageCount<ContainerT>::value
class fisch::vx::JTAGClockScaler
#include <jtag.h>

Container writing JTAG clock-scaler value.

Public Types

typedef halco::hicann_dls::vx::JTAGClockScalerOnDLS coordinate_type
typedef word_access_type::JTAGClockScaler Value

Clock-scaler value type.

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

Public Functions

inline explicit JTAGClockScaler(Value value = Value())

Construct scaler with value.

Parameters

value – Value to construct scaler with

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

Get clock-scaler value.

Returns

Clock-scaler value

bool operator!= (JTAGClockScaler const &other) const SYMBOL_VISIBLE
bool operator== (JTAGClockScaler const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set clock-scaler value.

Parameters

value – Clock-scaler value to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, JTAGClockScaler const &scaler) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::JTAGClockScaler : public halco::common::detail::RantWrapper<JTAGClockScaler, uint_fast16_t, jtag_clock_scaler_max, jtag_clock_scaler_min>
#include <jtag.h>

Public Functions

inline explicit constexpr JTAGClockScaler(uintmax_t const value = 0)
class fisch::vx::JTAGIdCode
#include <jtag.h>

Container for reading the JTAG IDCODE.

Public Types

typedef halco::hicann_dls::vx::JTAGIdCodeOnDLS coordinate_type
typedef word_access_type::JTAGIdCode Value

JTAG IDCODE value type.

Public Functions

inline explicit JTAGIdCode(Value value = Value())

Construct IDCODE with value.

Parameters

value – Value to use

void decode (UTMessageFromFPGARangeJTAG const &messages) SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get JTAG IDCODE.

Returns

Value

bool operator!= (JTAGIdCode const &other) const SYMBOL_VISIBLE
bool operator== (JTAGIdCode const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set JTAG IDCODE.

Parameters

value – Value

Public Static Functions

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

Public Static Attributes

static constexpr size_t decode_ut_message_count = 1
static constexpr size_t encode_read_ut_message_count = 2

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, JTAGIdCode const &id) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::JTAGIdCode : public halco::common::detail::BaseType<JTAGIdCode, uint32_t>
#include <jtag.h>

Public Functions

inline explicit constexpr JTAGIdCode(value_type const value = 0)
class fisch::vx::JTAGPhyRegister
#include <jtag.h>

Container writing Phy configuration on the Chip.

Public Types

typedef halco::hicann_dls::vx::JTAGPhyRegisterOnDLS coordinate_type
typedef word_access_type::JTAGPhyRegister Value

Register value type.

Public Functions

inline explicit JTAGPhyRegister(Value value = Value())

Construct register with value.

Parameters

value – Value to construct register with

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

Get register value.

Returns

Register value

bool operator!= (JTAGPhyRegister const &other) const SYMBOL_VISIBLE
bool operator== (JTAGPhyRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set register value.

Parameters

value – Register value to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 2

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, JTAGPhyRegister const &reg) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::JTAGPhyRegister : public halco::common::detail::RantWrapper<JTAGPhyRegister, uint_fast16_t, 4194303, 0>
#include <jtag.h>

Public Functions

inline explicit constexpr JTAGPhyRegister(uintmax_t const value = 0)
class fisch::vx::JTAGPLLRegister
#include <jtag.h>

Container for writing a PLL register.

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

Public Types

typedef halco::hicann_dls::vx::JTAGPLLRegisterOnDLS coordinate_type
typedef word_access_type::JTAGPLLRegister Value

PLL register value type.

Public Functions

inline explicit JTAGPLLRegister(Value value = Value())

Construct register by its value.

Parameters

value – Value to set on cosntruction

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

Get register value.

Returns

Value to get

bool operator!= (JTAGPLLRegister const &other) const SYMBOL_VISIBLE
bool operator== (JTAGPLLRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set register value.

Parameters

value – Value to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 4

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, JTAGPLLRegister const &reg) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::JTAGPLLRegister : public halco::common::detail::BaseType<JTAGPLLRegister, uint32_t>
#include <jtag.h>

Public Functions

inline explicit constexpr JTAGPLLRegister(value_type const value = 0)
class fisch::vx::MADCSampleFromChip
#include <event.h>

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

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

Public Functions

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

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

Parameters

  • value – Sample value

  • chip_time – ChipTime time annotation

  • fpga_time – FPGATime time annotation

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

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) SYMBOL_VISIBLE
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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
bool operator!= (NullPayloadReadable const &other) const SYMBOL_VISIBLE
bool operator== (NullPayloadReadable const &other) const SYMBOL_VISIBLE

Public Static Functions

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

Public Static Attributes

static constexpr size_t decode_ut_message_count = 1
static constexpr size_t encode_read_ut_message_count = 1
static constexpr size_t encode_write_ut_message_count = 0

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) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::NullPayloadReadable
#include <null_payload_readable.h>

Public Functions

bool operator!= (NullPayloadReadable const &other) const SYMBOL_VISIBLE
bool operator== (NullPayloadReadable const &other) const SYMBOL_VISIBLE
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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value const & get () const SYMBOL_VISIBLE

Get value.

Returns

Word value

bool operator!= (Omnibus const &other) const SYMBOL_VISIBLE
bool operator== (Omnibus const &other) const SYMBOL_VISIBLE
void set (Value const &value) SYMBOL_VISIBLE

Set value.

Parameters

value – Word value to set

Public Static Functions

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

Public Static Attributes

static constexpr size_t decode_ut_message_count = 1
static constexpr size_t encode_read_ut_message_count = 1
static constexpr size_t encode_write_ut_message_count = 2

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, Omnibus const &word) SYMBOL_VISIBLE
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 SYMBOL_VISIBLE
bool operator== (Omnibus const &other) const SYMBOL_VISIBLE

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) SYMBOL_VISIBLE
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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get value.

Returns

Omnibus word value

bool operator!= (OmnibusChipOverJTAG const &other) const SYMBOL_VISIBLE
bool operator== (OmnibusChipOverJTAG const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – Omnibus word value to set

Public Static Functions

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

Public Static Attributes

static constexpr size_t decode_ut_message_count = 1
static constexpr size_t encode_read_ut_message_count = 6
static constexpr size_t encode_write_ut_message_count = 6

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, OmnibusChipOverJTAG const &word) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::OmnibusChipOverJTAG : public halco::common::detail::BaseType<OmnibusChipOverJTAG, uint32_t>
#include <jtag.h>

Public Functions

inline explicit constexpr OmnibusChipOverJTAG(value_type const value = 0)
class fisch::vx::PlaybackDecoder
#include <playback_decoder.h>

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

Public Types

typedef std::vector<HighspeedLinkNotification> highspeed_link_notification_queue_type
typedef halco::common::typed_array<size_t, halco::hicann_dls::vx::MADCSamplePackFromFPGAOnDLS> madc_sample_pack_counts_type
typedef std::vector<MADCSampleFromChip> madc_sample_queue_type
typedef ToResponseQueueTuple<detail::decode_message_types>::type response_queue_type
typedef halco::common::typed_array<size_t, halco::hicann_dls::vx::SpikePackFromFPGAOnDLS> spike_pack_counts_type
typedef std::vector<SpikeFromChip> spike_queue_type
typedef std::vector<TimeoutNotification> timeout_notification_queue_type
typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::jtag_from_hicann::Data> ut_message_from_fpga_jtag_type
typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::from_fpga_system::Loopback> ut_message_from_fpga_loopback_type
typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::omnibus_from_fpga::Data> ut_message_from_fpga_omnibus_type
typedef hxcomm::vx::UTMessageFromFPGAVariant ut_message_from_fpga_variant_type

Public Functions

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

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

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

Process a message.

Parameters

message – UT message variant to process

Private Types

typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::from_fpga_system::HighspeedLinkNotification> ut_message_from_fpga_highspeed_link_notification_type
typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::timing_from_fpga::Sysdelta> ut_message_from_fpga_sysdelta_type
typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::timing_from_fpga::Systime> ut_message_from_fpga_systime_type
typedef hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::from_fpga_system::TimeoutNotification> ut_message_from_fpga_timeout_notification_type

Private Functions

ChipTime calculate_chip_time(uint8_t timestamp) const
template<size_t N>
void process(hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::event_from_fpga::MADCSamplePack<N>> const &message)
template<size_t N>
void process(hxcomm::vx::UTMessageFromFPGA<hxcomm::vx::instruction::event_from_fpga::SpikePack<N>> const &message)
void process(ut_message_from_fpga_highspeed_link_notification_type const &message)
void process(ut_message_from_fpga_jtag_type const &message)
void process(ut_message_from_fpga_loopback_type const &message)
void process(ut_message_from_fpga_omnibus_type const &message)
void process(ut_message_from_fpga_sysdelta_type const &message)
void process(ut_message_from_fpga_systime_type const &message)
void process(ut_message_from_fpga_timeout_notification_type const &message)

Private Members

highspeed_link_notification_queue_type &m_highspeed_link_notification_queue
madc_sample_pack_counts_type &m_madc_sample_pack_counts
madc_sample_queue_type &m_madc_sample_queue
response_queue_type &m_response_queue
spike_pack_counts_type &m_spike_pack_counts
spike_queue_type &m_spike_queue
FPGATime m_time_current
timeout_notification_queue_type &m_timeout_notification_queue
class fisch::vx::PlaybackProgram : public std::enable_shared_from_this<PlaybackProgram>
#include <playback_program.h>

Playback program.

Public Types

typedef hxcomm::vx::UTMessageFromFPGAVariant from_fpga_message_type
typedef std::vector<HighspeedLinkNotification> highspeed_link_notifications_type
typedef std::vector<MADCSampleFromChip> madc_sample_from_chip_events_type
typedef halco::common::typed_array<size_t, halco::hicann_dls::vx::MADCSamplePackFromFPGAOnDLS> madc_sample_pack_counts_type
typedef std::vector<SpikeFromChip> spike_from_chip_events_type
typedef halco::common::typed_array<size_t, halco::hicann_dls::vx::SpikePackFromFPGAOnDLS> spike_pack_counts_type
typedef hxcomm::vx::UTMessageToFPGAVariant to_fpga_message_type

Public Functions

PlaybackProgram () SYMBOL_VISIBLE

Default constructor.

~PlaybackProgram () SYMBOL_VISIBLE
void clear_from_fpga_messages () SYMBOL_VISIBLE

Clear the content of response data queues in order to refill them through a successive execution.

bool empty () const SYMBOL_VISIBLE

Get whether program is empty, i.e.

no instructions are embodied.

Returns

Boolean value

highspeed_link_notifications_type const & get_highspeed_link_notifications () const SYMBOL_VISIBLE

Get vector of time-annotated highspeed-link notifications.

Returns

Vector of notifications

madc_sample_from_chip_events_type const & get_madc_samples () const SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

Get number of occurences of MADC sample packing from chip.

Returns

Array of packing occurences

spike_from_chip_events_type const & get_spikes () const SYMBOL_VISIBLE

Get vector of time-annotated spike events.

Returns

Vector of spike events

spike_pack_counts_type const & get_spikes_pack_counts () const SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

Get to FPGA instruction sequence.

Returns

Vector of UT messages

bool operator!= (PlaybackProgram const &other) const SYMBOL_VISIBLE
bool operator== (PlaybackProgram const &other) const SYMBOL_VISIBLE
void push_from_fpga_message (from_fpga_message_type const &message) SYMBOL_VISIBLE

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 SYMBOL_VISIBLE

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

Returns

Boolean value (true if ok)

bool tickets_valid () const SYMBOL_VISIBLE

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

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

Default constructor.

void copy_back (PlaybackProgramBuilder const &other) SYMBOL_VISIBLE

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

Finish playback program creation and return built program.

Resets the state of the builder.

Returns

Built playback program

bool empty () const SYMBOL_VISIBLE

Get whether builder is empty, i.e.

no instructions are embodied.

Returns

Boolean value

bool is_write_only () const SYMBOL_VISIBLE

Get whether program only contains write data.

Returns

Boolean Value

void merge_back (PlaybackProgramBuilder &other) SYMBOL_VISIBLE

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

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 SYMBOL_VISIBLE

Get number of UT messages from FPGA.

Returns

Size

size_t size_to_fpga () const SYMBOL_VISIBLE

Get number of UT messages to FPGA.

Returns

Size

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

Add write instruction for multiple containers.

Template Parameters

ContainerT – Container type

Parameters

  • coords – Container coordinates

  • configs – Container data

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

Add write instruction for container.

Template Parameters

ContainerT – Container type

Parameters

  • coord – Container coordinate

  • config – Container data

Private Members

std::shared_ptr<PlaybackProgram> m_program

Friends

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

Print instruction UT messages added so far to ostream.

Returns

Altered ostream

struct fisch::vx::detail::PlaybackProgramImpl
#include <playback_program_impl.h>

Public Functions

PlaybackProgramImpl () SYMBOL_VISIBLE
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<# 32 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/fisch/include/fisch/vx/detail/playback_program_impl.h" 2 > > m_tickets
mutable std::mutex m_tickets_mutex
PlaybackDecoder::timeout_notification_queue_type m_timeout_notification_response_queue
class fisch::vx::PollingOmnibusBlock
#include <omnibus.h>

Container for polling block operation on a Omnibus address.

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

Public Types

typedef halco::hicann_dls::vx::PollingOmnibusBlockOnFPGA coordinate_type
typedef word_access_type::PollingOmnibusBlock Value

Public Functions

inline PollingOmnibusBlock(Value value = Value(true))

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

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

Get value.

Returns

Value

bool operator!= (PollingOmnibusBlock const &other) const SYMBOL_VISIBLE
bool operator== (PollingOmnibusBlock const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – Value to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, PollingOmnibusBlock const &config) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::PollingOmnibusBlock : public halco::common::detail::BaseType<PollingOmnibusBlock, bool>
#include <omnibus.h>

Public Functions

inline explicit constexpr PollingOmnibusBlock(bool value = false)
class fisch::vx::ReinitStackEntry
#include <reinit_stack_entry.h>

Public Functions

ReinitStackEntry() = delete
template<typename Connection>
ReinitStackEntry(Connection &connection)
ReinitStackEntry(ReinitStackEntry&&) = default
ReinitStackEntry(ReinitStackEntry const&) = delete
~ReinitStackEntry () SYMBOL_VISIBLE
void enforce () SYMBOL_VISIBLE
void pop () SYMBOL_VISIBLE
void set (std::shared_ptr< PlaybackProgram > const &pbmem_request, std::optional< std::shared_ptr< PlaybackProgram > > const &pbmem_snapshot=std::nullopt, bool enforce=true) SYMBOL_VISIBLE

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

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

Get reset value.

Returns

Boolean reset value

bool operator!= (ResetChip const &other) const SYMBOL_VISIBLE
bool operator== (ResetChip const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set reset value.

Parameters

value – Boolean value to set reset to

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, ResetChip const &reset) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::ResetChip : public halco::common::detail::BaseType<ResetChip, bool>
#include <reset.h>

Public Functions

inline explicit constexpr ResetChip(bool value = false)
class fisch::vx::ResetJTAGTap
#include <jtag.h>

Container for resetting JTAG state-machine.

Public Types

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

Public Functions

inline ResetJTAGTap()

Default constructor.

std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
bool operator!= (ResetJTAGTap const &other) const SYMBOL_VISIBLE
bool operator== (ResetJTAGTap const &other) const SYMBOL_VISIBLE

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 1

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) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::ResetJTAGTap
#include <jtag.h>

Public Functions

bool operator!= (ResetJTAGTap const &other) const SYMBOL_VISIBLE
bool operator== (ResetJTAGTap const &other) const SYMBOL_VISIBLE
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) SYMBOL_VISIBLE
struct fisch::vx::PlaybackDecoder::TimedResponseQueue::SizeConstraintChecker

Public Functions

inline SizeConstraintChecker(TimedResponseQueue const &queue)
inline ~SizeConstraintChecker()

Public Members

TimedResponseQueue const &queue
class fisch::vx::SPIDACControlRegister
#include <spi.h>

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

Public Types

typedef halco::hicann_dls::vx::SPIDACControlRegisterOnBoard coordinate_type
typedef word_access_type::SPIDACControlRegister Value

DAC control value.

Public Functions

inline explicit SPIDACControlRegister(Value value = Value())

Construct an instance with a word value.

Parameters

value – Value to construct instance with

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

Get value.

Returns

SPIDACControlRegister value

bool operator!= (SPIDACControlRegister const &other) const SYMBOL_VISIBLE
bool operator== (SPIDACControlRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – SPIDACControlRegister word value to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 4

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, SPIDACControlRegister const &word) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::SPIDACControlRegister : public halco::common::detail::RantWrapper<SPIDACControlRegister, uint_fast32_t, 0x1fff, 0>
#include <spi.h>

Public Functions

inline explicit constexpr SPIDACControlRegister(uintmax_t const value = 0)
class fisch::vx::SPIDACDataRegister
#include <spi.h>

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

Public Types

typedef halco::hicann_dls::vx::SPIDACDataRegisterOnBoard coordinate_type
typedef word_access_type::SPIDACDataRegister Value

DAC data value.

Public Functions

inline explicit SPIDACDataRegister(Value value = Value())

Construct an instance with a word value.

Parameters

value – Value to construct instance with

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

Get value.

Returns

SPIDACDataRegister value

bool operator!= (SPIDACDataRegister const &other) const SYMBOL_VISIBLE
bool operator== (SPIDACDataRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – SPIDACDataRegister word value to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 8

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, SPIDACDataRegister const &word) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::SPIDACDataRegister : public halco::common::detail::RantWrapper<SPIDACDataRegister, uint_fast32_t, dac_value_max, dac_value_min>
#include <spi.h>

Public Functions

inline explicit constexpr SPIDACDataRegister(uintmax_t const value = 0)
class fisch::vx::SpikeFromChip
#include <event.h>

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

Serves as value type for spikes accessible on a PlaybackProgram.

Public Functions

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

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

Parameters

  • label – SpikeLabel data

  • chip_time – ChipTime time annotation

  • fpga_time – FPGATime time annotation

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

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) SYMBOL_VISIBLE
class fisch::vx::SpikePack1ToChip : public fisch::vx::SpikePackToChip<1>
#include <event.h>

Spike pack to chip holding one spike label.

Public Types

typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_coordinates>::type coordinate_type
typedef hate::type_list<halco::hicann_dls::vx::SpikePack1ToChipOnDLS, halco::hicann_dls::vx::SpikePack2ToChipOnDLS, halco::hicann_dls::vx::SpikePack3ToChipOnDLS> spike_pack_to_chip_coordinates
typedef hate::type_list<word_access_type::SpikePack1ToChip, word_access_type::SpikePack2ToChip, word_access_type::SpikePack3ToChip> spike_pack_to_chip_labels
typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_labels>::type Value

Public Functions

inline explicit SpikePack1ToChip()
inline explicit SpikePack1ToChip(Value const &labels)
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value const & get () const SYMBOL_VISIBLE

Get spike labels.

Returns

Array of SpikeLabel

bool operator!= (SpikePackToChip const &other) const SYMBOL_VISIBLE
bool operator== (SpikePackToChip const &other) const SYMBOL_VISIBLE
void set (Value const &value) SYMBOL_VISIBLE

Set spike labels.

Parameters

value – Array of SpikeLabel to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count

Protected Functions

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

Protected Attributes

Value m_value
class fisch::vx::SpikePack2ToChip : public fisch::vx::SpikePackToChip<2>
#include <event.h>

Spike pack to chip holding two spike labels.

Public Types

typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_coordinates>::type coordinate_type
typedef hate::type_list<halco::hicann_dls::vx::SpikePack1ToChipOnDLS, halco::hicann_dls::vx::SpikePack2ToChipOnDLS, halco::hicann_dls::vx::SpikePack3ToChipOnDLS> spike_pack_to_chip_coordinates
typedef hate::type_list<word_access_type::SpikePack1ToChip, word_access_type::SpikePack2ToChip, word_access_type::SpikePack3ToChip> spike_pack_to_chip_labels
typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_labels>::type Value

Public Functions

inline explicit SpikePack2ToChip()
inline explicit SpikePack2ToChip(Value const &labels)
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value const & get () const SYMBOL_VISIBLE

Get spike labels.

Returns

Array of SpikeLabel

bool operator!= (SpikePackToChip const &other) const SYMBOL_VISIBLE
bool operator== (SpikePackToChip const &other) const SYMBOL_VISIBLE
void set (Value const &value) SYMBOL_VISIBLE

Set spike labels.

Parameters

value – Array of SpikeLabel to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count

Protected Functions

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

Protected Attributes

Value m_value
class fisch::vx::SpikePack3ToChip : public fisch::vx::SpikePackToChip<3>
#include <event.h>

Spike pack to chip holding three spike labels.

Public Types

typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_coordinates>::type coordinate_type
typedef hate::type_list<halco::hicann_dls::vx::SpikePack1ToChipOnDLS, halco::hicann_dls::vx::SpikePack2ToChipOnDLS, halco::hicann_dls::vx::SpikePack3ToChipOnDLS> spike_pack_to_chip_coordinates
typedef hate::type_list<word_access_type::SpikePack1ToChip, word_access_type::SpikePack2ToChip, word_access_type::SpikePack3ToChip> spike_pack_to_chip_labels
typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_labels>::type Value

Public Functions

inline explicit SpikePack3ToChip()
inline explicit SpikePack3ToChip(Value const &labels)
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value const & get () const SYMBOL_VISIBLE

Get spike labels.

Returns

Array of SpikeLabel

bool operator!= (SpikePackToChip const &other) const SYMBOL_VISIBLE
bool operator== (SpikePackToChip const &other) const SYMBOL_VISIBLE
void set (Value const &value) SYMBOL_VISIBLE

Set spike labels.

Parameters

value – Array of SpikeLabel to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count

Protected Functions

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

Protected Attributes

Value m_value
template<size_t NumPack>
class fisch::vx::SpikePackToChip
#include <event.h>

Base of fixed-size spike pack to chip.

tparam NumPack

Number of spike labels to hold

Public Types

typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_coordinates>::type coordinate_type
typedef hate::type_list<halco::hicann_dls::vx::SpikePack1ToChipOnDLS, halco::hicann_dls::vx::SpikePack2ToChipOnDLS, halco::hicann_dls::vx::SpikePack3ToChipOnDLS> spike_pack_to_chip_coordinates
typedef hate::type_list<word_access_type::SpikePack1ToChip, word_access_type::SpikePack2ToChip, word_access_type::SpikePack3ToChip> spike_pack_to_chip_labels
typedef hate::index_type_list_by_integer<NumPack - 1, spike_pack_to_chip_labels>::type Value

Public Functions

inline explicit SpikePackToChip()

Default constructor.

inline explicit SpikePackToChip(Value const &labels)

Construct spike pack with labels.

Parameters

labels – Array of SpikeLabel values to use

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

Get spike labels.

Returns

Array of SpikeLabel

bool operator!= (SpikePackToChip const &other) const SYMBOL_VISIBLE
bool operator== (SpikePackToChip const &other) const SYMBOL_VISIBLE
void set (Value const &value) SYMBOL_VISIBLE

Set spike labels.

Parameters

value – Array of SpikeLabel to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 1

Protected Functions

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

Protected Attributes

Value m_value

Friends

friend 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

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

Get value.

Returns

SPIShiftRegister value

bool operator!= (SPIShiftRegister const &other) const SYMBOL_VISIBLE
bool operator== (SPIShiftRegister const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set value.

Parameters

value – SPIShiftRegister word value to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 6

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, SPIShiftRegister const &word) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::SPIShiftRegister : public halco::common::detail::RantWrapper<SPIShiftRegister, uint_fast32_t, 0xffffff, 0>
#include <spi.h>

Public Functions

inline explicit constexpr SPIShiftRegister(uintmax_t const value = 0)
template<typename T>
struct fisch::vx::detail::SubRangeValueType
#include <decode.h>

Public Types

typedef void type
template<typename T>
struct fisch::vx::detail::SubRangeValueType<boost::sub_range<T>>
#include <decode.h>

Public Types

typedef T type
class fisch::vx::SystimeSync
#include <systime.h>

Container for syncronization of chip and FPGA systime.

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

Public Types

typedef halco::hicann_dls::vx::SystimeSyncOnFPGA coordinate_type
typedef word_access_type::SystimeSync Value

Public Functions

inline explicit SystimeSync(Value value = Value(false))
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get systime sync enable value.

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

Returns

Boolean value

bool operator!= (SystimeSync const &other) const SYMBOL_VISIBLE
bool operator== (SystimeSync const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set systime sync enable value.

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

Parameters

value – Boolean value

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, SystimeSync const &systime_sync) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::SystimeSync : public halco::common::detail::BaseType<SystimeSync, bool>
#include <systime.h>

Public Functions

inline explicit constexpr SystimeSync(bool value = false)
template<typename MessageT>
struct fisch::vx::PlaybackDecoder::TimedResponseQueue
#include <playback_decoder.h>

Pair of UT message and FPGATime time annotation.

tparam MesageT

UT message type

Public Types

typedef MessageT message_type

Public Functions

inline TimedResponseQueue()
inline TimedResponseQueue(std::vector<message_type> const &messages, std::vector<FPGATime> const &times)
inline void clear()
inline std::vector<MessageT> const &get_messages() const
inline std::vector<FPGATime> const &get_times() const
inline bool operator!=(TimedResponseQueue const &other) const
inline bool operator==(TimedResponseQueue const &other) const
inline void push_back(MessageT const &message, FPGATime const &time)
inline size_t size() const

Private Members

std::vector<MessageT> m_messages
std::vector<FPGATime> m_times
class fisch::vx::TimeoutNotification
#include <event.h>

Notification from the FPGA indicating a playback instruction timeout.

Public Functions

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

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

Parameters

  • value – Value to store

  • fpga_time – FPGATime time annotation

FPGATime get_fpga_time () const SYMBOL_VISIBLE

Get FPGA time annotation.

Returns

FPGATime time annotation

Value get_value () const SYMBOL_VISIBLE

Get value data.

Returns

Value data

bool operator!= (TimeoutNotification const &other) const SYMBOL_VISIBLE
bool operator== (TimeoutNotification const &other) const SYMBOL_VISIBLE
void set_fpga_time (FPGATime const &value) SYMBOL_VISIBLE

Set FPGA time annotation.

Parameters

value – FPGATime time annotation

void set_value (Value const &value) SYMBOL_VISIBLE

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) SYMBOL_VISIBLE
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) SYMBOL_VISIBLE
std::array< hxcomm::vx::UTMessageToFPGAVariant, encode_write_ut_message_count > encode_write (coordinate_type const &coord) const SYMBOL_VISIBLE
Value get () const SYMBOL_VISIBLE

Get timer value.

Returns

Value value

bool operator!= (Timer const &other) const SYMBOL_VISIBLE
bool operator== (Timer const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set timer value.

Parameters

value – Value to set

Public Static Functions

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

Public Static Attributes

static constexpr size_t decode_ut_message_count = 1
static constexpr size_t encode_read_ut_message_count = 1
static constexpr size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, Timer const &timer) SYMBOL_VISIBLE
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)
template<typename TL>
struct ToResponseQueueTuple
template<typename ...Ts>
struct fisch::vx::PlaybackDecoder::ToResponseQueueTuple<hate::type_list<Ts...>>
#include <playback_decoder.h>

Public Types

typedef std::tuple<TimedResponseQueue<Ts>...> type
struct fisch::vx::HighspeedLinkNotification::Value : public halco::common::detail::BaseType<Value, uint8_t>
#include <event.h>

Public Functions

inline explicit constexpr Value(value_type const val = 0)
struct fisch::vx::MADCSampleFromChip::Value : public halco::common::detail::RantWrapper<Value, uint16_t, 0x3ff, 0>
#include <event.h>

Sample value.

Restricted to the MADC’s 10 bit resolution.

Public Functions

inline explicit constexpr Value(uintmax_t const val = 0)
struct fisch::vx::TimeoutNotification::Value : public halco::common::detail::BaseType<Value, uint32_t>
#include <event.h>

Public Functions

inline explicit constexpr Value(value_type const val = 0)
class fisch::vx::WaitUntil
#include <timer.h>

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

Public Types

typedef halco::hicann_dls::vx::WaitUntilOnFPGA coordinate_type
typedef word_access_type::WaitUntil Value

Public Functions

inline explicit WaitUntil(Value value = Value())

Construct timer with value.

Parameters

value – Value to construct timer with

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

Get timer value.

Returns

Value

bool operator!= (WaitUntil const &other) const SYMBOL_VISIBLE
bool operator== (WaitUntil const &other) const SYMBOL_VISIBLE
void set (Value value) SYMBOL_VISIBLE

Set timer value.

Parameters

value – Value to set

Public Static Attributes

static constexpr size_t encode_write_ut_message_count = 1

Private Functions

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

Private Members

Value m_value

Friends

friend struct cereal::access
friend std::ostream & operator<< (std::ostream &os, WaitUntil const &config) SYMBOL_VISIBLE
struct fisch::vx::word_access_type::WaitUntil : public halco::common::detail::BaseType<WaitUntil, uint32_t>
#include <timer.h>

Public Functions

inline explicit constexpr WaitUntil(uintmax_t value = 0)
struct fisch::vx::word_access_type::Omnibus::Word : public halco::common::detail::BaseType<Word, uint32_t>
#include <omnibus.h>

Public Functions

inline explicit constexpr Word(value_type const value = 0)
namespace cereal
namespace fisch
namespace fisch::vx

Typedefs

typedef word_access_type::I2CAD5252RwRegister I2CAD5252RwRegisterValue
typedef word_access_type::I2CDAC6573RwRegister I2CDAC6573RwRegisterValue
typedef word_access_type::I2CIdRegister I2CIdRegisterValue
typedef word_access_type::I2CINA219RoRegister I2CINA219RoRegisterValue
typedef word_access_type::I2CINA219RwRegister I2CINA219RwRegisterValue
typedef word_access_type::I2CTCA9554RoRegister I2CTCA9554RoRegisterValue
typedef word_access_type::I2CTCA9554RwRegister I2CTCA9554RwRegisterValue
typedef word_access_type::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

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<# 23 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.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<# 33 "/jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/fisch/include/fisch/vx/playback_program_builder.h" 2 > coordinate_list

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

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

Functions

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

Variables

template<typename C>
static constexpr 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 “hate/visibility.h”#include <cstdint>

Defines

FISCH_EXTERN_INSTANTIATE_CEREAL_SERIALIZE(CLASS_NAME)
file logger.h
#include <log4cxx/logger.h>#include <syslog.h>

Defines

FISCH_LOG_DEBUG(logger, message)
FISCH_LOG_ERROR(logger, message)
FISCH_LOG_FATAL(logger, message)
FISCH_LOG_INFO(logger, message)
FISCH_LOG_SYSLOG(level, message)
FISCH_LOG_TRACE(logger, message)
FISCH_LOG_WARN(logger, message)
file barrier.h
#include “fisch/cerealization.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/barrier.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”
file barrier.h
#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”#include “hate/visibility.h”
file chip_time.h
#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”
file constants.h
#include “fisch/vx/genpybind.h”#include <stddef.h>
file container.h
#include “fisch/vx/barrier.h”#include “fisch/vx/event.h”#include “fisch/vx/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 “hate/type_list.h”#include “fisch/vx/container.def”

Defines

PLAYBACK_CONTAINER(Name, Type)
file container_fwd.h
#include “fisch/vx/container.def”

Defines

PLAYBACK_CONTAINER(Name, Type)
file container_ticket.h
#include “fisch/vx/container_fwd.h”#include “fisch/vx/genpybind.h”#include “hate/visibility.h”#include <memory>#include <vector>#include “fisch/vx/container.def”

Defines

PLAYBACK_CONTAINER(Name, Type)
file coordinates.h
#include “halco/hicann-dls/vx/barrier.h”#include “halco/hicann-dls/vx/extoll.h”#include “halco/hicann-dls/vx/fpga.h”#include “halco/hicann-dls/vx/i2c.h”#include “halco/hicann-dls/vx/jtag.h”#include “halco/hicann-dls/vx/omnibus.h”#include “halco/hicann-dls/vx/reset.h”#include “halco/hicann-dls/vx/spi.h”#include “halco/hicann-dls/vx/timing.h”
file decode.h
#include “hxcomm/vx/utmessage_fwd.h”#include <type_traits>#include <vector>#include <boost/range/sub_range.hpp>
file decode_message_types.h
#include “fisch/vx/container.h”#include “fisch/vx/decode.h”#include “hate/type_list.h”#include “fisch/vx/container.def”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)
PLAYBACK_CONTAINER(Name, Type)
file jtag_pll_register_coord_size.h
file playback_program_impl.h
#include “fisch/vx/playback_decoder.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”#include <array>#include <cstdint>#include <forward_list>#include <mutex>#include <variant>#include <vector>#include “fisch/vx/container.def”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)
PLAYBACK_CONTAINER(Name, Type)
PLAYBACK_CONTAINER(Name, Type)
file event.h
#include “fisch/cerealization.h”#include “fisch/vx/chip_time.h”#include “fisch/vx/fpga_time.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/event.h”#include “hate/join.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”
file event.h
#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”#include “halco/hicann-dls/vx/event.h”
file extoll.h
#include “fisch/cerealization.h”#include “fisch/vx/decode.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/extoll.h”#include “halco/common/geometry.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”
file extoll.h
#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”
file fill.h
#include “fisch/vx/event.h”#include “fisch/vx/traits.h”#include <random>#include <type_traits>#include <boost/utility/enable_if.hpp>

Defines

SPIKE_PACK_TO_CHIP(Num)
file fisch.h
#include “fisch/vx/constants.h”#include “fisch/vx/container.h”#include “fisch/vx/container_ticket.h”#include “fisch/vx/playback_program.h”#include “fisch/vx/playback_program_builder.h”#include “fisch/vx/reinit_stack_entry.h”#include “fisch/vx/run.h”#include “fisch/vx/run_time_info.h”
file fpga_time.h
#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”
file genpybind.h
#include <genpybind.h>

Defines

GENPYBIND_MODULE
GENPYBIND_TAG_FISCH_VX
file null_payload_readable.h
#include “fisch/cerealization.h”#include “fisch/vx/decode.h”#include “fisch/vx/genpybind.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”
file null_payload_readable.h
#include “fisch/vx/genpybind.h”#include “hate/visibility.h”
file omnibus.h
#include “fisch/cerealization.h”#include “fisch/vx/decode.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/omnibus.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”
file omnibus.h
#include “fisch/cerealization.h”#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”#include “hate/visibility.h”
file omnibus_constants.h
#include “fisch/vx/omnibus.h”#include “halco/hicann-dls/vx/omnibus.h”
file playback_decoder.h
#include “fisch/vx/chip_time.h”#include “fisch/vx/decode_message_types.h”#include “fisch/vx/event.h”#include “fisch/vx/fpga_time.h”#include “fisch/vx/genpybind.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/event.h”#include “hate/type_list.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage.h”#include <tuple>
file playback_program.h
#include “fisch/cerealization.h”#include “fisch/vx/event.h”#include “fisch/vx/genpybind.h”#include “halco/common/typed_array.h”#include “halco/hicann-dls/vx/event.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”#include <memory>#include <unordered_set>#include <variant>#include “fisch/vx/container.def”

Defines

PLAYBACK_CONTAINER(Name, Type)
file playback_program_builder.h
#include “fisch/vx/container.h”#include “fisch/vx/genpybind.h”#include “hate/visibility.h”#include <memory>#include <vector>#include “fisch/vx/container.def”

Defines

LAST_PLAYBACK_CONTAINER(Name, Type)
LAST_PLAYBACK_CONTAINER(Name, Type)
PLAYBACK_CONTAINER(Name, _Type)
PLAYBACK_CONTAINER(Name, Type)
PLAYBACK_CONTAINER(Name, Type)
file python_bindings.h
#include “fisch/vx/genpybind.h”#include “fisch/vx/fisch.h”#include “halco/hicann-dls/vx/coordinates.h”
file reinit_stack_entry.h
#include “fisch/vx/genpybind.h”#include “fisch/vx/playback_program.h”#include “hate/visibility.h”#include <memory>#include “fisch/vx/reinit_stack_entry.tcc”
file reset.h
#include “fisch/cerealization.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/reset.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”
file reset.h
#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”
file run.h
#include <memory>#include “fisch/vx/run.tcc”
file run_time_info.h
#include “fisch/vx/genpybind.h”#include “hate/visibility.h”#include “hxcomm/common/connection_time_info.h”#include <chrono>#include <ostream>
file systime.h
#include “fisch/cerealization.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/systime.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”
file systime.h
#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”
file timer.h
#include “fisch/cerealization.h”#include “fisch/vx/decode.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/timer.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”
file timer.h
#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”
file traits.h
#include “hate/type_list.h”#include <type_traits>#include <boost/utility/enable_if.hpp>
file i2c.h
#include “fisch/cerealization.h”#include “fisch/vx/constants.h”#include “fisch/vx/decode.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/i2c.h”#include “hate/type_index.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”
file i2c.h
#include “fisch/vx/constants.h”#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”
file jtag.h
#include “fisch/cerealization.h”#include “fisch/vx/constants.h”#include “fisch/vx/decode.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/jtag.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”
file jtag.h
#include “fisch/vx/constants.h”#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”#include “hate/visibility.h”
file spi.h
#include “fisch/cerealization.h”#include “fisch/vx/genpybind.h”#include “fisch/vx/word_access/type/spi.h”#include “hate/visibility.h”#include “hxcomm/vx/utmessage_fwd.h”
file spi.h
#include “fisch/vx/constants.h”#include “fisch/vx/genpybind.h”#include “halco/common/geometry.h”
file 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.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/fisch/include/fisch/common
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/fisch/include/fisch/vx/detail
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/fisch
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/fisch/include/fisch
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/fisch/include
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/fisch/include/fisch/vx/word_access/type
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/fisch/include/fisch/vx
dir /jenkins/jenlib_workspaces_f9/doc_gerrit_documentation-brainscales2.ZG9jX2dlcnJpdF9kb2N1bWVudGF0aW9uLWJyYWluc2NhbGVzMiMzODM.x/fisch/include/fisch/vx/word_access